DwarfCorp/YarnSpinner/YarnSpinnerParser.cs

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

// Generated from YarnSpinnerParser.g4 by ANTLR 4.7

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

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

[System.CodeDom.Compiler.GeneratedCode("ANTLR", "4.7")]
[System.CLSCompliant(false)]
public partial class YarnSpinnerParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		BODY_ENTER=1, HEADER_TITLE=2, HEADER_TAGS=3, HEADER_NAME=4, HEADER_SEPARATOR=5, 
		STRING=6, ID=7, NEWLINE=8, UNKNOWN=9, TITLE_WS=10, TITLE_TEXT=11, TAG_TEXT=12, 
		HEADER_WS=13, HEADER_TEXT=14, WS_IN_BODY=15, COMMENT=16, BODY_CLOSE=17, 
		TEXT_STRING=18, SHORTCUT_ENTER=19, INDENT=20, DEDENT=21, COMMAND_IF=22, 
		COMMAND_ELSE=23, COMMAND_ELSE_IF=24, COMMAND_ENDIF=25, COMMAND_SET=26, 
		COMMAND_FUNC=27, COMMAND_OPEN=28, OPTION_ENTER=29, HASHTAG=30, TEXT=31, 
		SHORTCUT_TEXT=32, COMMAND_WS=33, COMMAND_CLOSE=34, COMMAND_STRING=35, 
		KEYWORD_IF=36, KEYWORD_ELSE=37, KEYWORD_ELSE_IF=38, KEYWORD_SET=39, KEYWORD_TRUE=40, 
		KEYWORD_FALSE=41, KEYWORD_NULL=42, KEYWORD_TO=43, OPERATOR_LOGICAL_LESS_THAN_EQUALS=44, 
		OPERATOR_LOGICAL_GREATER_THAN_EQUALS=45, OPERATOR_LOGICAL_EQUALS=46, OPERATOR_LOGICAL_LESS=47, 
		OPERATOR_LOGICAL_GREATER=48, OPERATOR_LOGICAL_NOT_EQUALS=49, OPERATOR_LOGICAL_AND=50, 
		OPERATOR_LOGICAL_OR=51, OPERATOR_LOGICAL_XOR=52, OPERATOR_LOGICAL_NOT=53, 
		OPERATOR_MATHS_ADDITION_EQUALS=54, OPERATOR_MATHS_SUBTRACTION_EQUALS=55, 
		OPERATOR_MATHS_MULTIPLICATION_EQUALS=56, OPERATOR_MATHS_MODULUS_EQUALS=57, 
		OPERATOR_MATHS_DIVISION_EQUALS=58, OPERATOR_MATHS_ADDITION=59, OPERATOR_MATHS_SUBTRACTION=60, 
		OPERATOR_MATHS_MULTIPLICATION=61, OPERATOR_MATHS_DIVISION=62, OPERATOR_MATHS_MODULUS=63, 
		LPAREN=64, RPAREN=65, COMMA=66, VAR_ID=67, BODY_NUMBER=68, FUNC_ID=69, 
		COMMAND_UNKNOWN=70, ACTION=71, OPTION_SEPARATOR=72, OPTION_TEXT=73, OPTION_CLOSE=74, 
		OPTION_LINK=75;
	public const int
		RULE_dialogue = 0, RULE_node = 1, RULE_header = 2, RULE_header_title = 3, 
		RULE_header_tag = 4, RULE_header_line = 5, RULE_body = 6, RULE_statement = 7, 
		RULE_shortcut_statement = 8, RULE_shortcut = 9, RULE_shortcut_conditional = 10, 
		RULE_shortcut_text = 11, RULE_if_statement = 12, RULE_if_clause = 13, 
		RULE_else_if_clause = 14, RULE_else_clause = 15, RULE_set_statement = 16, 
		RULE_option_statement = 17, RULE_function = 18, RULE_function_statement = 19, 
		RULE_action_statement = 20, RULE_text = 21, RULE_line_statement = 22, 
		RULE_hashtag_block = 23, RULE_hashtag = 24, RULE_expression = 25, RULE_value = 26, 
		RULE_variable = 27;
	public static readonly string[] ruleNames = {
		"dialogue", "node", "header", "header_title", "header_tag", "header_line", 
		"body", "statement", "shortcut_statement", "shortcut", "shortcut_conditional", 
		"shortcut_text", "if_statement", "if_clause", "else_if_clause", "else_clause", 
		"set_statement", "option_statement", "function", "function_statement", 
		"action_statement", "text", "line_statement", "hashtag_block", "hashtag", 
		"expression", "value", "variable"
	};

	private static readonly string[] _LiteralNames = {
		null, "'---'", "'title:'", "'tags:'", null, "':'", null, null, null, null, 
		null, null, null, null, null, null, null, "'==='", null, null, "'\u0007'", 
		"'\u000B'", null, null, null, null, null, null, null, "'[['", null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, "'+='", "'-='", 
		"'*='", "'%='", "'/='", "'+'", "'-'", "'*'", "'/'", "'%'", "'('", "')'", 
		"','", null, null, null, null, null, "'|'", null, "']]'"
	};
	private static readonly string[] _SymbolicNames = {
		null, "BODY_ENTER", "HEADER_TITLE", "HEADER_TAGS", "HEADER_NAME", "HEADER_SEPARATOR", 
		"STRING", "ID", "NEWLINE", "UNKNOWN", "TITLE_WS", "TITLE_TEXT", "TAG_TEXT", 
		"HEADER_WS", "HEADER_TEXT", "WS_IN_BODY", "COMMENT", "BODY_CLOSE", "TEXT_STRING", 
		"SHORTCUT_ENTER", "INDENT", "DEDENT", "COMMAND_IF", "COMMAND_ELSE", "COMMAND_ELSE_IF", 
		"COMMAND_ENDIF", "COMMAND_SET", "COMMAND_FUNC", "COMMAND_OPEN", "OPTION_ENTER", 
		"HASHTAG", "TEXT", "SHORTCUT_TEXT", "COMMAND_WS", "COMMAND_CLOSE", "COMMAND_STRING", 
		"KEYWORD_IF", "KEYWORD_ELSE", "KEYWORD_ELSE_IF", "KEYWORD_SET", "KEYWORD_TRUE", 
		"KEYWORD_FALSE", "KEYWORD_NULL", "KEYWORD_TO", "OPERATOR_LOGICAL_LESS_THAN_EQUALS", 
		"OPERATOR_LOGICAL_GREATER_THAN_EQUALS", "OPERATOR_LOGICAL_EQUALS", "OPERATOR_LOGICAL_LESS", 
		"OPERATOR_LOGICAL_GREATER", "OPERATOR_LOGICAL_NOT_EQUALS", "OPERATOR_LOGICAL_AND", 
		"OPERATOR_LOGICAL_OR", "OPERATOR_LOGICAL_XOR", "OPERATOR_LOGICAL_NOT", 
		"OPERATOR_MATHS_ADDITION_EQUALS", "OPERATOR_MATHS_SUBTRACTION_EQUALS", 
		"OPERATOR_MATHS_MULTIPLICATION_EQUALS", "OPERATOR_MATHS_MODULUS_EQUALS", 
		"OPERATOR_MATHS_DIVISION_EQUALS", "OPERATOR_MATHS_ADDITION", "OPERATOR_MATHS_SUBTRACTION", 
		"OPERATOR_MATHS_MULTIPLICATION", "OPERATOR_MATHS_DIVISION", "OPERATOR_MATHS_MODULUS", 
		"LPAREN", "RPAREN", "COMMA", "VAR_ID", "BODY_NUMBER", "FUNC_ID", "COMMAND_UNKNOWN", 
		"ACTION", "OPTION_SEPARATOR", "OPTION_TEXT", "OPTION_CLOSE", "OPTION_LINK"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

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

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

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

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

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

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

		public YarnSpinnerParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}
	public partial class DialogueContext : ParserRuleContext {
		public ITerminalNode Eof() { return GetToken(YarnSpinnerParser.Eof, 0); }
		public NodeContext[] node() {
			return GetRuleContexts<NodeContext>();
		}
		public NodeContext node(int i) {
			return GetRuleContext<NodeContext>(i);
		}
		public DialogueContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dialogue; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterDialogue(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitDialogue(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDialogue(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DialogueContext dialogue() {
		DialogueContext _localctx = new DialogueContext(Context, State);
		EnterRule(_localctx, 0, RULE_dialogue);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 57;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 56; node();
				}
				}
				State = 59;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==HEADER_TITLE );
			State = 61; Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class NodeContext : ParserRuleContext {
		public HeaderContext header() {
			return GetRuleContext<HeaderContext>(0);
		}
		public BodyContext body() {
			return GetRuleContext<BodyContext>(0);
		}
		public ITerminalNode[] NEWLINE() { return GetTokens(YarnSpinnerParser.NEWLINE); }
		public ITerminalNode NEWLINE(int i) {
			return GetToken(YarnSpinnerParser.NEWLINE, i);
		}
		public NodeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_node; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterNode(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitNode(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitNode(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public NodeContext node() {
		NodeContext _localctx = new NodeContext(Context, State);
		EnterRule(_localctx, 2, RULE_node);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 63; header();
			State = 64; body();
			State = 68;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==NEWLINE) {
				{
				{
				State = 65; Match(NEWLINE);
				}
				}
				State = 70;
				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 HeaderContext : ParserRuleContext {
		public Header_titleContext header_title() {
			return GetRuleContext<Header_titleContext>(0);
		}
		public Header_tagContext[] header_tag() {
			return GetRuleContexts<Header_tagContext>();
		}
		public Header_tagContext header_tag(int i) {
			return GetRuleContext<Header_tagContext>(i);
		}
		public Header_lineContext[] header_line() {
			return GetRuleContexts<Header_lineContext>();
		}
		public Header_lineContext header_line(int i) {
			return GetRuleContext<Header_lineContext>(i);
		}
		public HeaderContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_header; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHeader(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHeader(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHeader(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public HeaderContext header() {
		HeaderContext _localctx = new HeaderContext(Context, State);
		EnterRule(_localctx, 4, RULE_header);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 71; header_title();
			State = 76;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==HEADER_TAGS || _la==HEADER_NAME) {
				{
				State = 74;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case HEADER_TAGS:
					{
					State = 72; header_tag();
					}
					break;
				case HEADER_NAME:
					{
					State = 73; header_line();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 78;
				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 Header_titleContext : ParserRuleContext {
		public ITerminalNode HEADER_TITLE() { return GetToken(YarnSpinnerParser.HEADER_TITLE, 0); }
		public ITerminalNode TITLE_TEXT() { return GetToken(YarnSpinnerParser.TITLE_TEXT, 0); }
		public ITerminalNode NEWLINE() { return GetToken(YarnSpinnerParser.NEWLINE, 0); }
		public Header_titleContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_header_title; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHeader_title(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHeader_title(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHeader_title(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Header_titleContext header_title() {
		Header_titleContext _localctx = new Header_titleContext(Context, State);
		EnterRule(_localctx, 6, RULE_header_title);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 79; Match(HEADER_TITLE);
			State = 80; Match(TITLE_TEXT);
			State = 81; Match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Header_tagContext : ParserRuleContext {
		public ITerminalNode HEADER_TAGS() { return GetToken(YarnSpinnerParser.HEADER_TAGS, 0); }
		public ITerminalNode TAG_TEXT() { return GetToken(YarnSpinnerParser.TAG_TEXT, 0); }
		public ITerminalNode NEWLINE() { return GetToken(YarnSpinnerParser.NEWLINE, 0); }
		public Header_tagContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_header_tag; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHeader_tag(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHeader_tag(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHeader_tag(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Header_tagContext header_tag() {
		Header_tagContext _localctx = new Header_tagContext(Context, State);
		EnterRule(_localctx, 8, RULE_header_tag);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 83; Match(HEADER_TAGS);
			State = 84; Match(TAG_TEXT);
			State = 85; Match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Header_lineContext : ParserRuleContext {
		public ITerminalNode HEADER_NAME() { return GetToken(YarnSpinnerParser.HEADER_NAME, 0); }
		public ITerminalNode HEADER_TEXT() { return GetToken(YarnSpinnerParser.HEADER_TEXT, 0); }
		public ITerminalNode NEWLINE() { return GetToken(YarnSpinnerParser.NEWLINE, 0); }
		public Header_lineContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_header_line; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHeader_line(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHeader_line(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHeader_line(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Header_lineContext header_line() {
		Header_lineContext _localctx = new Header_lineContext(Context, State);
		EnterRule(_localctx, 10, RULE_header_line);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 87; Match(HEADER_NAME);
			State = 88; Match(HEADER_SEPARATOR);
			State = 89; Match(HEADER_TEXT);
			State = 90; Match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class BodyContext : ParserRuleContext {
		public ITerminalNode BODY_ENTER() { return GetToken(YarnSpinnerParser.BODY_ENTER, 0); }
		public ITerminalNode BODY_CLOSE() { return GetToken(YarnSpinnerParser.BODY_CLOSE, 0); }
		public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public BodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_body; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterBody(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitBody(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public BodyContext body() {
		BodyContext _localctx = new BodyContext(Context, State);
		EnterRule(_localctx, 12, RULE_body);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 92; Match(BODY_ENTER);
			State = 96;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (TEXT_STRING - 18)) | (1L << (SHORTCUT_ENTER - 18)) | (1L << (COMMAND_IF - 18)) | (1L << (COMMAND_SET - 18)) | (1L << (COMMAND_FUNC - 18)) | (1L << (OPTION_ENTER - 18)) | (1L << (TEXT - 18)) | (1L << (ACTION - 18)))) != 0)) {
				{
				{
				State = 93; statement();
				}
				}
				State = 98;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 99; Match(BODY_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StatementContext : ParserRuleContext {
		public Shortcut_statementContext shortcut_statement() {
			return GetRuleContext<Shortcut_statementContext>(0);
		}
		public If_statementContext if_statement() {
			return GetRuleContext<If_statementContext>(0);
		}
		public Set_statementContext set_statement() {
			return GetRuleContext<Set_statementContext>(0);
		}
		public Option_statementContext option_statement() {
			return GetRuleContext<Option_statementContext>(0);
		}
		public Function_statementContext function_statement() {
			return GetRuleContext<Function_statementContext>(0);
		}
		public Action_statementContext action_statement() {
			return GetRuleContext<Action_statementContext>(0);
		}
		public Line_statementContext line_statement() {
			return GetRuleContext<Line_statementContext>(0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterStatement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitStatement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StatementContext statement() {
		StatementContext _localctx = new StatementContext(Context, State);
		EnterRule(_localctx, 14, RULE_statement);
		try {
			State = 108;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case SHORTCUT_ENTER:
				EnterOuterAlt(_localctx, 1);
				{
				State = 101; shortcut_statement();
				}
				break;
			case COMMAND_IF:
				EnterOuterAlt(_localctx, 2);
				{
				State = 102; if_statement();
				}
				break;
			case COMMAND_SET:
				EnterOuterAlt(_localctx, 3);
				{
				State = 103; set_statement();
				}
				break;
			case OPTION_ENTER:
				EnterOuterAlt(_localctx, 4);
				{
				State = 104; option_statement();
				}
				break;
			case COMMAND_FUNC:
				EnterOuterAlt(_localctx, 5);
				{
				State = 105; function_statement();
				}
				break;
			case ACTION:
				EnterOuterAlt(_localctx, 6);
				{
				State = 106; action_statement();
				}
				break;
			case TEXT_STRING:
			case TEXT:
				EnterOuterAlt(_localctx, 7);
				{
				State = 107; line_statement();
				}
				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 Shortcut_statementContext : ParserRuleContext {
		public ShortcutContext[] shortcut() {
			return GetRuleContexts<ShortcutContext>();
		}
		public ShortcutContext shortcut(int i) {
			return GetRuleContext<ShortcutContext>(i);
		}
		public Shortcut_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_shortcut_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterShortcut_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitShortcut_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitShortcut_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Shortcut_statementContext shortcut_statement() {
		Shortcut_statementContext _localctx = new Shortcut_statementContext(Context, State);
		EnterRule(_localctx, 16, RULE_shortcut_statement);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 111;
			ErrorHandler.Sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					State = 110; shortcut();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 113;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,6,Context);
			} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ShortcutContext : ParserRuleContext {
		public ITerminalNode SHORTCUT_ENTER() { return GetToken(YarnSpinnerParser.SHORTCUT_ENTER, 0); }
		public Shortcut_textContext shortcut_text() {
			return GetRuleContext<Shortcut_textContext>(0);
		}
		public Shortcut_conditionalContext shortcut_conditional() {
			return GetRuleContext<Shortcut_conditionalContext>(0);
		}
		public Hashtag_blockContext hashtag_block() {
			return GetRuleContext<Hashtag_blockContext>(0);
		}
		public ITerminalNode INDENT() { return GetToken(YarnSpinnerParser.INDENT, 0); }
		public ITerminalNode DEDENT() { return GetToken(YarnSpinnerParser.DEDENT, 0); }
		public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public ShortcutContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_shortcut; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterShortcut(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitShortcut(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitShortcut(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ShortcutContext shortcut() {
		ShortcutContext _localctx = new ShortcutContext(Context, State);
		EnterRule(_localctx, 18, RULE_shortcut);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 115; Match(SHORTCUT_ENTER);
			State = 116; shortcut_text();
			State = 118;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,7,Context) ) {
			case 1:
				{
				State = 117; shortcut_conditional();
				}
				break;
			}
			State = 121;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==HASHTAG) {
				{
				State = 120; hashtag_block();
				}
			}

			State = 131;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==INDENT) {
				{
				State = 123; Match(INDENT);
				State = 127;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (TEXT_STRING - 18)) | (1L << (SHORTCUT_ENTER - 18)) | (1L << (COMMAND_IF - 18)) | (1L << (COMMAND_SET - 18)) | (1L << (COMMAND_FUNC - 18)) | (1L << (OPTION_ENTER - 18)) | (1L << (TEXT - 18)) | (1L << (ACTION - 18)))) != 0)) {
					{
					{
					State = 124; statement();
					}
					}
					State = 129;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 130; Match(DEDENT);
				}
			}

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

	public partial class Shortcut_conditionalContext : ParserRuleContext {
		public ITerminalNode COMMAND_IF() { return GetToken(YarnSpinnerParser.COMMAND_IF, 0); }
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ITerminalNode COMMAND_CLOSE() { return GetToken(YarnSpinnerParser.COMMAND_CLOSE, 0); }
		public Shortcut_conditionalContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_shortcut_conditional; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterShortcut_conditional(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitShortcut_conditional(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitShortcut_conditional(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Shortcut_conditionalContext shortcut_conditional() {
		Shortcut_conditionalContext _localctx = new Shortcut_conditionalContext(Context, State);
		EnterRule(_localctx, 20, RULE_shortcut_conditional);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 133; Match(COMMAND_IF);
			State = 134; expression(0);
			State = 135; Match(COMMAND_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Shortcut_textContext : ParserRuleContext {
		public ITerminalNode SHORTCUT_TEXT() { return GetToken(YarnSpinnerParser.SHORTCUT_TEXT, 0); }
		public Shortcut_textContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_shortcut_text; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterShortcut_text(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitShortcut_text(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitShortcut_text(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Shortcut_textContext shortcut_text() {
		Shortcut_textContext _localctx = new Shortcut_textContext(Context, State);
		EnterRule(_localctx, 22, RULE_shortcut_text);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 137; Match(SHORTCUT_TEXT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class If_statementContext : ParserRuleContext {
		public If_clauseContext if_clause() {
			return GetRuleContext<If_clauseContext>(0);
		}
		public ITerminalNode COMMAND_ENDIF() { return GetToken(YarnSpinnerParser.COMMAND_ENDIF, 0); }
		public Else_if_clauseContext[] else_if_clause() {
			return GetRuleContexts<Else_if_clauseContext>();
		}
		public Else_if_clauseContext else_if_clause(int i) {
			return GetRuleContext<Else_if_clauseContext>(i);
		}
		public Else_clauseContext else_clause() {
			return GetRuleContext<Else_clauseContext>(0);
		}
		public Hashtag_blockContext hashtag_block() {
			return GetRuleContext<Hashtag_blockContext>(0);
		}
		public If_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_if_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterIf_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitIf_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIf_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public If_statementContext if_statement() {
		If_statementContext _localctx = new If_statementContext(Context, State);
		EnterRule(_localctx, 24, RULE_if_statement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 139; if_clause();
			State = 143;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMAND_ELSE_IF) {
				{
				{
				State = 140; else_if_clause();
				}
				}
				State = 145;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 147;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==COMMAND_ELSE) {
				{
				State = 146; else_clause();
				}
			}

			State = 149; Match(COMMAND_ENDIF);
			State = 151;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==HASHTAG) {
				{
				State = 150; hashtag_block();
				}
			}

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

	public partial class If_clauseContext : ParserRuleContext {
		public ITerminalNode COMMAND_IF() { return GetToken(YarnSpinnerParser.COMMAND_IF, 0); }
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ITerminalNode COMMAND_CLOSE() { return GetToken(YarnSpinnerParser.COMMAND_CLOSE, 0); }
		public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public If_clauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_if_clause; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterIf_clause(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitIf_clause(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIf_clause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public If_clauseContext if_clause() {
		If_clauseContext _localctx = new If_clauseContext(Context, State);
		EnterRule(_localctx, 26, RULE_if_clause);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 153; Match(COMMAND_IF);
			State = 154; expression(0);
			State = 155; Match(COMMAND_CLOSE);
			State = 159;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (TEXT_STRING - 18)) | (1L << (SHORTCUT_ENTER - 18)) | (1L << (COMMAND_IF - 18)) | (1L << (COMMAND_SET - 18)) | (1L << (COMMAND_FUNC - 18)) | (1L << (OPTION_ENTER - 18)) | (1L << (TEXT - 18)) | (1L << (ACTION - 18)))) != 0)) {
				{
				{
				State = 156; statement();
				}
				}
				State = 161;
				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 Else_if_clauseContext : ParserRuleContext {
		public ITerminalNode COMMAND_ELSE_IF() { return GetToken(YarnSpinnerParser.COMMAND_ELSE_IF, 0); }
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ITerminalNode COMMAND_CLOSE() { return GetToken(YarnSpinnerParser.COMMAND_CLOSE, 0); }
		public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public Else_if_clauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_else_if_clause; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterElse_if_clause(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitElse_if_clause(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitElse_if_clause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Else_if_clauseContext else_if_clause() {
		Else_if_clauseContext _localctx = new Else_if_clauseContext(Context, State);
		EnterRule(_localctx, 28, RULE_else_if_clause);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 162; Match(COMMAND_ELSE_IF);
			State = 163; expression(0);
			State = 164; Match(COMMAND_CLOSE);
			State = 168;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (TEXT_STRING - 18)) | (1L << (SHORTCUT_ENTER - 18)) | (1L << (COMMAND_IF - 18)) | (1L << (COMMAND_SET - 18)) | (1L << (COMMAND_FUNC - 18)) | (1L << (OPTION_ENTER - 18)) | (1L << (TEXT - 18)) | (1L << (ACTION - 18)))) != 0)) {
				{
				{
				State = 165; statement();
				}
				}
				State = 170;
				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 Else_clauseContext : ParserRuleContext {
		public ITerminalNode COMMAND_ELSE() { return GetToken(YarnSpinnerParser.COMMAND_ELSE, 0); }
		public StatementContext[] statement() {
			return GetRuleContexts<StatementContext>();
		}
		public StatementContext statement(int i) {
			return GetRuleContext<StatementContext>(i);
		}
		public Else_clauseContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_else_clause; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterElse_clause(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitElse_clause(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitElse_clause(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Else_clauseContext else_clause() {
		Else_clauseContext _localctx = new Else_clauseContext(Context, State);
		EnterRule(_localctx, 30, RULE_else_clause);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 171; Match(COMMAND_ELSE);
			State = 175;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (TEXT_STRING - 18)) | (1L << (SHORTCUT_ENTER - 18)) | (1L << (COMMAND_IF - 18)) | (1L << (COMMAND_SET - 18)) | (1L << (COMMAND_FUNC - 18)) | (1L << (OPTION_ENTER - 18)) | (1L << (TEXT - 18)) | (1L << (ACTION - 18)))) != 0)) {
				{
				{
				State = 172; statement();
				}
				}
				State = 177;
				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 Set_statementContext : ParserRuleContext {
		public ITerminalNode COMMAND_SET() { return GetToken(YarnSpinnerParser.COMMAND_SET, 0); }
		public VariableContext variable() {
			return GetRuleContext<VariableContext>(0);
		}
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ITerminalNode COMMAND_CLOSE() { return GetToken(YarnSpinnerParser.COMMAND_CLOSE, 0); }
		public ITerminalNode[] KEYWORD_TO() { return GetTokens(YarnSpinnerParser.KEYWORD_TO); }
		public ITerminalNode KEYWORD_TO(int i) {
			return GetToken(YarnSpinnerParser.KEYWORD_TO, i);
		}
		public Set_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_set_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterSet_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitSet_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSet_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Set_statementContext set_statement() {
		Set_statementContext _localctx = new Set_statementContext(Context, State);
		EnterRule(_localctx, 32, RULE_set_statement);
		int _la;
		try {
			State = 193;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,18,Context) ) {
			case 1:
				EnterOuterAlt(_localctx, 1);
				{
				State = 178; Match(COMMAND_SET);
				State = 179; variable();
				State = 183;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==KEYWORD_TO) {
					{
					{
					State = 180; Match(KEYWORD_TO);
					}
					}
					State = 185;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 186; expression(0);
				State = 187; Match(COMMAND_CLOSE);
				}
				break;
			case 2:
				EnterOuterAlt(_localctx, 2);
				{
				State = 189; Match(COMMAND_SET);
				State = 190; expression(0);
				State = 191; Match(COMMAND_CLOSE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Option_statementContext : ParserRuleContext {
		public ITerminalNode OPTION_TEXT() { return GetToken(YarnSpinnerParser.OPTION_TEXT, 0); }
		public ITerminalNode OPTION_LINK() { return GetToken(YarnSpinnerParser.OPTION_LINK, 0); }
		public Hashtag_blockContext hashtag_block() {
			return GetRuleContext<Hashtag_blockContext>(0);
		}
		public Option_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_option_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterOption_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitOption_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitOption_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Option_statementContext option_statement() {
		Option_statementContext _localctx = new Option_statementContext(Context, State);
		EnterRule(_localctx, 34, RULE_option_statement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 203;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,19,Context) ) {
			case 1:
				{
				State = 195; Match(OPTION_ENTER);
				State = 196; Match(OPTION_TEXT);
				State = 197; Match(OPTION_SEPARATOR);
				State = 198; Match(OPTION_LINK);
				State = 199; Match(OPTION_CLOSE);
				}
				break;
			case 2:
				{
				State = 200; Match(OPTION_ENTER);
				State = 201; Match(OPTION_TEXT);
				State = 202; Match(OPTION_CLOSE);
				}
				break;
			}
			State = 206;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==HASHTAG) {
				{
				State = 205; hashtag_block();
				}
			}

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

	public partial class FunctionContext : ParserRuleContext {
		public ITerminalNode FUNC_ID() { return GetToken(YarnSpinnerParser.FUNC_ID, 0); }
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ITerminalNode[] COMMA() { return GetTokens(YarnSpinnerParser.COMMA); }
		public ITerminalNode COMMA(int i) {
			return GetToken(YarnSpinnerParser.COMMA, i);
		}
		public FunctionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_function; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterFunction(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitFunction(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunction(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public FunctionContext function() {
		FunctionContext _localctx = new FunctionContext(Context, State);
		EnterRule(_localctx, 36, RULE_function);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 208; Match(FUNC_ID);
			State = 209; Match(LPAREN);
			State = 211;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (((((_la - 35)) & ~0x3f) == 0 && ((1L << (_la - 35)) & ((1L << (COMMAND_STRING - 35)) | (1L << (KEYWORD_TRUE - 35)) | (1L << (KEYWORD_FALSE - 35)) | (1L << (KEYWORD_NULL - 35)) | (1L << (OPERATOR_LOGICAL_NOT - 35)) | (1L << (OPERATOR_MATHS_SUBTRACTION - 35)) | (1L << (LPAREN - 35)) | (1L << (VAR_ID - 35)) | (1L << (BODY_NUMBER - 35)) | (1L << (FUNC_ID - 35)))) != 0)) {
				{
				State = 210; expression(0);
				}
			}

			State = 217;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 213; Match(COMMA);
				State = 214; expression(0);
				}
				}
				State = 219;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 220; Match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Function_statementContext : ParserRuleContext {
		public ITerminalNode COMMAND_FUNC() { return GetToken(YarnSpinnerParser.COMMAND_FUNC, 0); }
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ITerminalNode COMMAND_CLOSE() { return GetToken(YarnSpinnerParser.COMMAND_CLOSE, 0); }
		public ITerminalNode[] COMMA() { return GetTokens(YarnSpinnerParser.COMMA); }
		public ITerminalNode COMMA(int i) {
			return GetToken(YarnSpinnerParser.COMMA, i);
		}
		public Function_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_function_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterFunction_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitFunction_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitFunction_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Function_statementContext function_statement() {
		Function_statementContext _localctx = new Function_statementContext(Context, State);
		EnterRule(_localctx, 38, RULE_function_statement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 222; Match(COMMAND_FUNC);
			State = 223; expression(0);
			State = 228;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 224; Match(COMMA);
				State = 225; expression(0);
				}
				}
				State = 230;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 231; Match(RPAREN);
			State = 232; Match(COMMAND_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Action_statementContext : ParserRuleContext {
		public ITerminalNode ACTION() { return GetToken(YarnSpinnerParser.ACTION, 0); }
		public Action_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_action_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterAction_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitAction_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitAction_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Action_statementContext action_statement() {
		Action_statementContext _localctx = new Action_statementContext(Context, State);
		EnterRule(_localctx, 40, RULE_action_statement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 234; Match(ACTION);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TextContext : ParserRuleContext {
		public ITerminalNode TEXT() { return GetToken(YarnSpinnerParser.TEXT, 0); }
		public ITerminalNode TEXT_STRING() { return GetToken(YarnSpinnerParser.TEXT_STRING, 0); }
		public TextContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_text; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterText(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitText(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitText(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TextContext text() {
		TextContext _localctx = new TextContext(Context, State);
		EnterRule(_localctx, 42, RULE_text);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 236;
			_la = TokenStream.LA(1);
			if ( !(_la==TEXT_STRING || _la==TEXT) ) {
			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 Line_statementContext : ParserRuleContext {
		public TextContext text() {
			return GetRuleContext<TextContext>(0);
		}
		public Hashtag_blockContext hashtag_block() {
			return GetRuleContext<Hashtag_blockContext>(0);
		}
		public Line_statementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_line_statement; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterLine_statement(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitLine_statement(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitLine_statement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Line_statementContext line_statement() {
		Line_statementContext _localctx = new Line_statementContext(Context, State);
		EnterRule(_localctx, 44, RULE_line_statement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 238; text();
			State = 240;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==HASHTAG) {
				{
				State = 239; hashtag_block();
				}
			}

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

	public partial class Hashtag_blockContext : ParserRuleContext {
		public HashtagContext[] hashtag() {
			return GetRuleContexts<HashtagContext>();
		}
		public HashtagContext hashtag(int i) {
			return GetRuleContext<HashtagContext>(i);
		}
		public Hashtag_blockContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_hashtag_block; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHashtag_block(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHashtag_block(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHashtag_block(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public Hashtag_blockContext hashtag_block() {
		Hashtag_blockContext _localctx = new Hashtag_blockContext(Context, State);
		EnterRule(_localctx, 46, RULE_hashtag_block);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 243;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 242; hashtag();
				}
				}
				State = 245;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==HASHTAG );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class HashtagContext : ParserRuleContext {
		public ITerminalNode HASHTAG() { return GetToken(YarnSpinnerParser.HASHTAG, 0); }
		public HashtagContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_hashtag; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterHashtag(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitHashtag(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitHashtag(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public HashtagContext hashtag() {
		HashtagContext _localctx = new HashtagContext(Context, State);
		EnterRule(_localctx, 48, RULE_hashtag);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 247; Match(HASHTAG);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionContext : ParserRuleContext {
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
	 
		public ExpressionContext() { }
		public virtual void CopyFrom(ExpressionContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class ExpParensContext : ExpressionContext {
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpParensContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpParens(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpParens(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpParens(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpMultDivModContext : ExpressionContext {
		public IToken op;
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ExpMultDivModContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpMultDivMod(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpMultDivMod(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpMultDivMod(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpMultDivModEqualsContext : ExpressionContext {
		public IToken op;
		public VariableContext variable() {
			return GetRuleContext<VariableContext>(0);
		}
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpMultDivModEqualsContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpMultDivModEquals(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpMultDivModEquals(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpMultDivModEquals(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpComparisonContext : ExpressionContext {
		public IToken op;
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ITerminalNode OPERATOR_LOGICAL_LESS_THAN_EQUALS() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_LESS_THAN_EQUALS, 0); }
		public ITerminalNode OPERATOR_LOGICAL_GREATER_THAN_EQUALS() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_GREATER_THAN_EQUALS, 0); }
		public ITerminalNode OPERATOR_LOGICAL_LESS() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_LESS, 0); }
		public ITerminalNode OPERATOR_LOGICAL_GREATER() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_GREATER, 0); }
		public ExpComparisonContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpComparison(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpComparison(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpComparison(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpNegativeContext : ExpressionContext {
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpNegativeContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpNegative(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpNegative(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpNegative(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpAndOrXorContext : ExpressionContext {
		public IToken op;
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ITerminalNode OPERATOR_LOGICAL_AND() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_AND, 0); }
		public ITerminalNode OPERATOR_LOGICAL_OR() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_OR, 0); }
		public ITerminalNode OPERATOR_LOGICAL_XOR() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_XOR, 0); }
		public ExpAndOrXorContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpAndOrXor(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpAndOrXor(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpAndOrXor(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpPlusMinusEqualsContext : ExpressionContext {
		public IToken op;
		public VariableContext variable() {
			return GetRuleContext<VariableContext>(0);
		}
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpPlusMinusEqualsContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpPlusMinusEquals(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpPlusMinusEquals(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpPlusMinusEquals(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpAddSubContext : ExpressionContext {
		public IToken op;
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ExpAddSubContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpAddSub(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpAddSub(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpAddSub(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpNotContext : ExpressionContext {
		public ITerminalNode OPERATOR_LOGICAL_NOT() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_NOT, 0); }
		public ExpressionContext expression() {
			return GetRuleContext<ExpressionContext>(0);
		}
		public ExpNotContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpNot(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpNot(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpNot(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpValueContext : ExpressionContext {
		public ValueContext value() {
			return GetRuleContext<ValueContext>(0);
		}
		public ExpValueContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpValue(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpValue(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpValue(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ExpEqualityContext : ExpressionContext {
		public IToken op;
		public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		public ITerminalNode OPERATOR_LOGICAL_EQUALS() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_EQUALS, 0); }
		public ITerminalNode OPERATOR_LOGICAL_NOT_EQUALS() { return GetToken(YarnSpinnerParser.OPERATOR_LOGICAL_NOT_EQUALS, 0); }
		public ExpEqualityContext(ExpressionContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterExpEquality(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitExpEquality(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpEquality(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		return expression(0);
	}

	private ExpressionContext expression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExpressionContext _localctx = new ExpressionContext(Context, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 50;
		EnterRecursionRule(_localctx, 50, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 267;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,26,Context) ) {
			case 1:
				{
				_localctx = new ExpParensContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 250; Match(LPAREN);
				State = 251; expression(0);
				State = 252; Match(RPAREN);
				}
				break;
			case 2:
				{
				_localctx = new ExpNegativeContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 254; Match(OPERATOR_MATHS_SUBTRACTION);
				State = 255; expression(10);
				}
				break;
			case 3:
				{
				_localctx = new ExpNotContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 256; Match(OPERATOR_LOGICAL_NOT);
				State = 257; expression(9);
				}
				break;
			case 4:
				{
				_localctx = new ExpMultDivModEqualsContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 258; variable();
				State = 259;
				((ExpMultDivModEqualsContext)_localctx).op = TokenStream.LT(1);
				_la = TokenStream.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPERATOR_MATHS_MULTIPLICATION_EQUALS) | (1L << OPERATOR_MATHS_MODULUS_EQUALS) | (1L << OPERATOR_MATHS_DIVISION_EQUALS))) != 0)) ) {
					((ExpMultDivModEqualsContext)_localctx).op = ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 260; expression(4);
				}
				break;
			case 5:
				{
				_localctx = new ExpPlusMinusEqualsContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 262; variable();
				State = 263;
				((ExpPlusMinusEqualsContext)_localctx).op = TokenStream.LT(1);
				_la = TokenStream.LA(1);
				if ( !(_la==OPERATOR_MATHS_ADDITION_EQUALS || _la==OPERATOR_MATHS_SUBTRACTION_EQUALS) ) {
					((ExpPlusMinusEqualsContext)_localctx).op = ErrorHandler.RecoverInline(this);
				}
				else {
					ErrorHandler.ReportMatch(this);
				    Consume();
				}
				State = 264; expression(3);
				}
				break;
			case 6:
				{
				_localctx = new ExpValueContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 266; value();
				}
				break;
			}
			Context.Stop = TokenStream.LT(-1);
			State = 286;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 284;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,27,Context) ) {
					case 1:
						{
						_localctx = new ExpMultDivModContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 269;
						if (!(Precpred(Context, 8))) throw new FailedPredicateException(this, "Precpred(Context, 8)");
						State = 270;
						((ExpMultDivModContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPERATOR_MATHS_MULTIPLICATION) | (1L << OPERATOR_MATHS_DIVISION) | (1L << OPERATOR_MATHS_MODULUS))) != 0)) ) {
							((ExpMultDivModContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 271; expression(9);
						}
						break;
					case 2:
						{
						_localctx = new ExpAddSubContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 272;
						if (!(Precpred(Context, 7))) throw new FailedPredicateException(this, "Precpred(Context, 7)");
						State = 273;
						((ExpAddSubContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==OPERATOR_MATHS_ADDITION || _la==OPERATOR_MATHS_SUBTRACTION) ) {
							((ExpAddSubContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 274; expression(8);
						}
						break;
					case 3:
						{
						_localctx = new ExpComparisonContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 275;
						if (!(Precpred(Context, 6))) throw new FailedPredicateException(this, "Precpred(Context, 6)");
						State = 276;
						((ExpComparisonContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPERATOR_LOGICAL_LESS_THAN_EQUALS) | (1L << OPERATOR_LOGICAL_GREATER_THAN_EQUALS) | (1L << OPERATOR_LOGICAL_LESS) | (1L << OPERATOR_LOGICAL_GREATER))) != 0)) ) {
							((ExpComparisonContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 277; expression(7);
						}
						break;
					case 4:
						{
						_localctx = new ExpEqualityContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 278;
						if (!(Precpred(Context, 5))) throw new FailedPredicateException(this, "Precpred(Context, 5)");
						State = 279;
						((ExpEqualityContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !(_la==OPERATOR_LOGICAL_EQUALS || _la==OPERATOR_LOGICAL_NOT_EQUALS) ) {
							((ExpEqualityContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 280; expression(6);
						}
						break;
					case 5:
						{
						_localctx = new ExpAndOrXorContext(new ExpressionContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expression);
						State = 281;
						if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)");
						State = 282;
						((ExpAndOrXorContext)_localctx).op = TokenStream.LT(1);
						_la = TokenStream.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPERATOR_LOGICAL_AND) | (1L << OPERATOR_LOGICAL_OR) | (1L << OPERATOR_LOGICAL_XOR))) != 0)) ) {
							((ExpAndOrXorContext)_localctx).op = ErrorHandler.RecoverInline(this);
						}
						else {
							ErrorHandler.ReportMatch(this);
						    Consume();
						}
						State = 283; expression(3);
						}
						break;
					}
					} 
				}
				State = 288;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,28,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public partial class ValueContext : ParserRuleContext {
		public ValueContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_value; } }
	 
		public ValueContext() { }
		public virtual void CopyFrom(ValueContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class ValueNullContext : ValueContext {
		public ITerminalNode KEYWORD_NULL() { return GetToken(YarnSpinnerParser.KEYWORD_NULL, 0); }
		public ValueNullContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueNull(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueNull(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueNull(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueNumberContext : ValueContext {
		public ITerminalNode BODY_NUMBER() { return GetToken(YarnSpinnerParser.BODY_NUMBER, 0); }
		public ValueNumberContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueNumber(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueNumber(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueNumber(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueTrueContext : ValueContext {
		public ITerminalNode KEYWORD_TRUE() { return GetToken(YarnSpinnerParser.KEYWORD_TRUE, 0); }
		public ValueTrueContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueTrue(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueTrue(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueTrue(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueFalseContext : ValueContext {
		public ITerminalNode KEYWORD_FALSE() { return GetToken(YarnSpinnerParser.KEYWORD_FALSE, 0); }
		public ValueFalseContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueFalse(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueFalse(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueFalse(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueFuncContext : ValueContext {
		public FunctionContext function() {
			return GetRuleContext<FunctionContext>(0);
		}
		public ValueFuncContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueFunc(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueFunc(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueFunc(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueVarContext : ValueContext {
		public VariableContext variable() {
			return GetRuleContext<VariableContext>(0);
		}
		public ValueVarContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueVar(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueVar(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueVar(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class ValueStringContext : ValueContext {
		public ITerminalNode COMMAND_STRING() { return GetToken(YarnSpinnerParser.COMMAND_STRING, 0); }
		public ValueStringContext(ValueContext context) { CopyFrom(context); }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterValueString(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitValueString(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitValueString(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ValueContext value() {
		ValueContext _localctx = new ValueContext(Context, State);
		EnterRule(_localctx, 52, RULE_value);
		try {
			State = 296;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case BODY_NUMBER:
				_localctx = new ValueNumberContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 289; Match(BODY_NUMBER);
				}
				break;
			case KEYWORD_TRUE:
				_localctx = new ValueTrueContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 290; Match(KEYWORD_TRUE);
				}
				break;
			case KEYWORD_FALSE:
				_localctx = new ValueFalseContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 291; Match(KEYWORD_FALSE);
				}
				break;
			case VAR_ID:
				_localctx = new ValueVarContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 292; variable();
				}
				break;
			case COMMAND_STRING:
				_localctx = new ValueStringContext(_localctx);
				EnterOuterAlt(_localctx, 5);
				{
				State = 293; Match(COMMAND_STRING);
				}
				break;
			case FUNC_ID:
				_localctx = new ValueFuncContext(_localctx);
				EnterOuterAlt(_localctx, 6);
				{
				State = 294; function();
				}
				break;
			case KEYWORD_NULL:
				_localctx = new ValueNullContext(_localctx);
				EnterOuterAlt(_localctx, 7);
				{
				State = 295; Match(KEYWORD_NULL);
				}
				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 VariableContext : ParserRuleContext {
		public ITerminalNode VAR_ID() { return GetToken(YarnSpinnerParser.VAR_ID, 0); }
		public VariableContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variable; } }
		public override void EnterRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.EnterVariable(this);
		}
		public override void ExitRule(IParseTreeListener listener) {
			IYarnSpinnerParserListener typedListener = listener as IYarnSpinnerParserListener;
			if (typedListener != null) typedListener.ExitVariable(this);
		}
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IYarnSpinnerParserVisitor<TResult> typedVisitor = visitor as IYarnSpinnerParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariable(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariableContext variable() {
		VariableContext _localctx = new VariableContext(Context, State);
		EnterRule(_localctx, 54, RULE_variable);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 298; Match(VAR_ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 25: return expression_sempred((ExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private bool expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 8);
		case 1: return Precpred(Context, 7);
		case 2: return Precpred(Context, 6);
		case 3: return Precpred(Context, 5);
		case 4: return Precpred(Context, 2);
		}
		return true;
	}

	private static char[] _serializedATN = {
		'\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786', 
		'\x5964', '\x3', 'M', '\x12F', '\x4', '\x2', '\t', '\x2', '\x4', '\x3', 
		'\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x4', '\x5', '\t', '\x5', '\x4', 
		'\x6', '\t', '\x6', '\x4', '\a', '\t', '\a', '\x4', '\b', '\t', '\b', 
		'\x4', '\t', '\t', '\t', '\x4', '\n', '\t', '\n', '\x4', '\v', '\t', '\v', 
		'\x4', '\f', '\t', '\f', '\x4', '\r', '\t', '\r', '\x4', '\xE', '\t', 
		'\xE', '\x4', '\xF', '\t', '\xF', '\x4', '\x10', '\t', '\x10', '\x4', 
		'\x11', '\t', '\x11', '\x4', '\x12', '\t', '\x12', '\x4', '\x13', '\t', 
		'\x13', '\x4', '\x14', '\t', '\x14', '\x4', '\x15', '\t', '\x15', '\x4', 
		'\x16', '\t', '\x16', '\x4', '\x17', '\t', '\x17', '\x4', '\x18', '\t', 
		'\x18', '\x4', '\x19', '\t', '\x19', '\x4', '\x1A', '\t', '\x1A', '\x4', 
		'\x1B', '\t', '\x1B', '\x4', '\x1C', '\t', '\x1C', '\x4', '\x1D', '\t', 
		'\x1D', '\x3', '\x2', '\x6', '\x2', '<', '\n', '\x2', '\r', '\x2', '\xE', 
		'\x2', '=', '\x3', '\x2', '\x3', '\x2', '\x3', '\x3', '\x3', '\x3', '\x3', 
		'\x3', '\a', '\x3', '\x45', '\n', '\x3', '\f', '\x3', '\xE', '\x3', 'H', 
		'\v', '\x3', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\a', '\x4', 'M', 
		'\n', '\x4', '\f', '\x4', '\xE', '\x4', 'P', '\v', '\x4', '\x3', '\x5', 
		'\x3', '\x5', '\x3', '\x5', '\x3', '\x5', '\x3', '\x6', '\x3', '\x6', 
		'\x3', '\x6', '\x3', '\x6', '\x3', '\a', '\x3', '\a', '\x3', '\a', '\x3', 
		'\a', '\x3', '\a', '\x3', '\b', '\x3', '\b', '\a', '\b', '\x61', '\n', 
		'\b', '\f', '\b', '\xE', '\b', '\x64', '\v', '\b', '\x3', '\b', '\x3', 
		'\b', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', '\x3', '\t', 
		'\x3', '\t', '\x3', '\t', '\x5', '\t', 'o', '\n', '\t', '\x3', '\n', '\x6', 
		'\n', 'r', '\n', '\n', '\r', '\n', '\xE', '\n', 's', '\x3', '\v', '\x3', 
		'\v', '\x3', '\v', '\x5', '\v', 'y', '\n', '\v', '\x3', '\v', '\x5', '\v', 
		'|', '\n', '\v', '\x3', '\v', '\x3', '\v', '\a', '\v', '\x80', '\n', '\v', 
		'\f', '\v', '\xE', '\v', '\x83', '\v', '\v', '\x3', '\v', '\x5', '\v', 
		'\x86', '\n', '\v', '\x3', '\f', '\x3', '\f', '\x3', '\f', '\x3', '\f', 
		'\x3', '\r', '\x3', '\r', '\x3', '\xE', '\x3', '\xE', '\a', '\xE', '\x90', 
		'\n', '\xE', '\f', '\xE', '\xE', '\xE', '\x93', '\v', '\xE', '\x3', '\xE', 
		'\x5', '\xE', '\x96', '\n', '\xE', '\x3', '\xE', '\x3', '\xE', '\x5', 
		'\xE', '\x9A', '\n', '\xE', '\x3', '\xF', '\x3', '\xF', '\x3', '\xF', 
		'\x3', '\xF', '\a', '\xF', '\xA0', '\n', '\xF', '\f', '\xF', '\xE', '\xF', 
		'\xA3', '\v', '\xF', '\x3', '\x10', '\x3', '\x10', '\x3', '\x10', '\x3', 
		'\x10', '\a', '\x10', '\xA9', '\n', '\x10', '\f', '\x10', '\xE', '\x10', 
		'\xAC', '\v', '\x10', '\x3', '\x11', '\x3', '\x11', '\a', '\x11', '\xB0', 
		'\n', '\x11', '\f', '\x11', '\xE', '\x11', '\xB3', '\v', '\x11', '\x3', 
		'\x12', '\x3', '\x12', '\x3', '\x12', '\a', '\x12', '\xB8', '\n', '\x12', 
		'\f', '\x12', '\xE', '\x12', '\xBB', '\v', '\x12', '\x3', '\x12', '\x3', 
		'\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', '\x12', '\x3', 
		'\x12', '\x5', '\x12', '\xC4', '\n', '\x12', '\x3', '\x13', '\x3', '\x13', 
		'\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', '\x3', '\x13', 
		'\x3', '\x13', '\x5', '\x13', '\xCE', '\n', '\x13', '\x3', '\x13', '\x5', 
		'\x13', '\xD1', '\n', '\x13', '\x3', '\x14', '\x3', '\x14', '\x3', '\x14', 
		'\x5', '\x14', '\xD6', '\n', '\x14', '\x3', '\x14', '\x3', '\x14', '\a', 
		'\x14', '\xDA', '\n', '\x14', '\f', '\x14', '\xE', '\x14', '\xDD', '\v', 
		'\x14', '\x3', '\x14', '\x3', '\x14', '\x3', '\x15', '\x3', '\x15', '\x3', 
		'\x15', '\x3', '\x15', '\a', '\x15', '\xE5', '\n', '\x15', '\f', '\x15', 
		'\xE', '\x15', '\xE8', '\v', '\x15', '\x3', '\x15', '\x3', '\x15', '\x3', 
		'\x15', '\x3', '\x16', '\x3', '\x16', '\x3', '\x17', '\x3', '\x17', '\x3', 
		'\x18', '\x3', '\x18', '\x5', '\x18', '\xF3', '\n', '\x18', '\x3', '\x19', 
		'\x6', '\x19', '\xF6', '\n', '\x19', '\r', '\x19', '\xE', '\x19', '\xF7', 
		'\x3', '\x1A', '\x3', '\x1A', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', 
		'\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', 
		'\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', 
		'\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', 
		'\x5', '\x1B', '\x10E', '\n', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', 
		'\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', 
		'\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', '\x1B', '\x3', 
		'\x1B', '\x3', '\x1B', '\x3', '\x1B', '\a', '\x1B', '\x11F', '\n', '\x1B', 
		'\f', '\x1B', '\xE', '\x1B', '\x122', '\v', '\x1B', '\x3', '\x1C', '\x3', 
		'\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', '\x1C', '\x3', 
		'\x1C', '\x5', '\x1C', '\x12B', '\n', '\x1C', '\x3', '\x1D', '\x3', '\x1D', 
		'\x3', '\x1D', '\x2', '\x3', '\x34', '\x1E', '\x2', '\x4', '\x6', '\b', 
		'\n', '\f', '\xE', '\x10', '\x12', '\x14', '\x16', '\x18', '\x1A', '\x1C', 
		'\x1E', ' ', '\"', '$', '&', '(', '*', ',', '.', '\x30', '\x32', '\x34', 
		'\x36', '\x38', '\x2', '\n', '\x4', '\x2', '\x14', '\x14', '!', '!', '\x3', 
		'\x2', ':', '<', '\x3', '\x2', '\x38', '\x39', '\x3', '\x2', '?', '\x41', 
		'\x3', '\x2', '=', '>', '\x4', '\x2', '.', '/', '\x31', '\x32', '\x4', 
		'\x2', '\x30', '\x30', '\x33', '\x33', '\x3', '\x2', '\x34', '\x36', '\x2', 
		'\x141', '\x2', ';', '\x3', '\x2', '\x2', '\x2', '\x4', '\x41', '\x3', 
		'\x2', '\x2', '\x2', '\x6', 'I', '\x3', '\x2', '\x2', '\x2', '\b', 'Q', 
		'\x3', '\x2', '\x2', '\x2', '\n', 'U', '\x3', '\x2', '\x2', '\x2', '\f', 
		'Y', '\x3', '\x2', '\x2', '\x2', '\xE', '^', '\x3', '\x2', '\x2', '\x2', 
		'\x10', 'n', '\x3', '\x2', '\x2', '\x2', '\x12', 'q', '\x3', '\x2', '\x2', 
		'\x2', '\x14', 'u', '\x3', '\x2', '\x2', '\x2', '\x16', '\x87', '\x3', 
		'\x2', '\x2', '\x2', '\x18', '\x8B', '\x3', '\x2', '\x2', '\x2', '\x1A', 
		'\x8D', '\x3', '\x2', '\x2', '\x2', '\x1C', '\x9B', '\x3', '\x2', '\x2', 
		'\x2', '\x1E', '\xA4', '\x3', '\x2', '\x2', '\x2', ' ', '\xAD', '\x3', 
		'\x2', '\x2', '\x2', '\"', '\xC3', '\x3', '\x2', '\x2', '\x2', '$', '\xCD', 
		'\x3', '\x2', '\x2', '\x2', '&', '\xD2', '\x3', '\x2', '\x2', '\x2', '(', 
		'\xE0', '\x3', '\x2', '\x2', '\x2', '*', '\xEC', '\x3', '\x2', '\x2', 
		'\x2', ',', '\xEE', '\x3', '\x2', '\x2', '\x2', '.', '\xF0', '\x3', '\x2', 
		'\x2', '\x2', '\x30', '\xF5', '\x3', '\x2', '\x2', '\x2', '\x32', '\xF9', 
		'\x3', '\x2', '\x2', '\x2', '\x34', '\x10D', '\x3', '\x2', '\x2', '\x2', 
		'\x36', '\x12A', '\x3', '\x2', '\x2', '\x2', '\x38', '\x12C', '\x3', '\x2', 
		'\x2', '\x2', ':', '<', '\x5', '\x4', '\x3', '\x2', ';', ':', '\x3', '\x2', 
		'\x2', '\x2', '<', '=', '\x3', '\x2', '\x2', '\x2', '=', ';', '\x3', '\x2', 
		'\x2', '\x2', '=', '>', '\x3', '\x2', '\x2', '\x2', '>', '?', '\x3', '\x2', 
		'\x2', '\x2', '?', '@', '\a', '\x2', '\x2', '\x3', '@', '\x3', '\x3', 
		'\x2', '\x2', '\x2', '\x41', '\x42', '\x5', '\x6', '\x4', '\x2', '\x42', 
		'\x46', '\x5', '\xE', '\b', '\x2', '\x43', '\x45', '\a', '\n', '\x2', 
		'\x2', '\x44', '\x43', '\x3', '\x2', '\x2', '\x2', '\x45', 'H', '\x3', 
		'\x2', '\x2', '\x2', '\x46', '\x44', '\x3', '\x2', '\x2', '\x2', '\x46', 
		'G', '\x3', '\x2', '\x2', '\x2', 'G', '\x5', '\x3', '\x2', '\x2', '\x2', 
		'H', '\x46', '\x3', '\x2', '\x2', '\x2', 'I', 'N', '\x5', '\b', '\x5', 
		'\x2', 'J', 'M', '\x5', '\n', '\x6', '\x2', 'K', 'M', '\x5', '\f', '\a', 
		'\x2', 'L', 'J', '\x3', '\x2', '\x2', '\x2', 'L', 'K', '\x3', '\x2', '\x2', 
		'\x2', 'M', 'P', '\x3', '\x2', '\x2', '\x2', 'N', 'L', '\x3', '\x2', '\x2', 
		'\x2', 'N', 'O', '\x3', '\x2', '\x2', '\x2', 'O', '\a', '\x3', '\x2', 
		'\x2', '\x2', 'P', 'N', '\x3', '\x2', '\x2', '\x2', 'Q', 'R', '\a', '\x4', 
		'\x2', '\x2', 'R', 'S', '\a', '\r', '\x2', '\x2', 'S', 'T', '\a', '\n', 
		'\x2', '\x2', 'T', '\t', '\x3', '\x2', '\x2', '\x2', 'U', 'V', '\a', '\x5', 
		'\x2', '\x2', 'V', 'W', '\a', '\xE', '\x2', '\x2', 'W', 'X', '\a', '\n', 
		'\x2', '\x2', 'X', '\v', '\x3', '\x2', '\x2', '\x2', 'Y', 'Z', '\a', '\x6', 
		'\x2', '\x2', 'Z', '[', '\a', '\a', '\x2', '\x2', '[', '\\', '\a', '\x10', 
		'\x2', '\x2', '\\', ']', '\a', '\n', '\x2', '\x2', ']', '\r', '\x3', '\x2', 
		'\x2', '\x2', '^', '\x62', '\a', '\x3', '\x2', '\x2', '_', '\x61', '\x5', 
		'\x10', '\t', '\x2', '`', '_', '\x3', '\x2', '\x2', '\x2', '\x61', '\x64', 
		'\x3', '\x2', '\x2', '\x2', '\x62', '`', '\x3', '\x2', '\x2', '\x2', '\x62', 
		'\x63', '\x3', '\x2', '\x2', '\x2', '\x63', '\x65', '\x3', '\x2', '\x2', 
		'\x2', '\x64', '\x62', '\x3', '\x2', '\x2', '\x2', '\x65', '\x66', '\a', 
		'\x13', '\x2', '\x2', '\x66', '\xF', '\x3', '\x2', '\x2', '\x2', 'g', 
		'o', '\x5', '\x12', '\n', '\x2', 'h', 'o', '\x5', '\x1A', '\xE', '\x2', 
		'i', 'o', '\x5', '\"', '\x12', '\x2', 'j', 'o', '\x5', '$', '\x13', '\x2', 
		'k', 'o', '\x5', '(', '\x15', '\x2', 'l', 'o', '\x5', '*', '\x16', '\x2', 
		'm', 'o', '\x5', '.', '\x18', '\x2', 'n', 'g', '\x3', '\x2', '\x2', '\x2', 
		'n', 'h', '\x3', '\x2', '\x2', '\x2', 'n', 'i', '\x3', '\x2', '\x2', '\x2', 
		'n', 'j', '\x3', '\x2', '\x2', '\x2', 'n', 'k', '\x3', '\x2', '\x2', '\x2', 
		'n', 'l', '\x3', '\x2', '\x2', '\x2', 'n', 'm', '\x3', '\x2', '\x2', '\x2', 
		'o', '\x11', '\x3', '\x2', '\x2', '\x2', 'p', 'r', '\x5', '\x14', '\v', 
		'\x2', 'q', 'p', '\x3', '\x2', '\x2', '\x2', 'r', 's', '\x3', '\x2', '\x2', 
		'\x2', 's', 'q', '\x3', '\x2', '\x2', '\x2', 's', 't', '\x3', '\x2', '\x2', 
		'\x2', 't', '\x13', '\x3', '\x2', '\x2', '\x2', 'u', 'v', '\a', '\x15', 
		'\x2', '\x2', 'v', 'x', '\x5', '\x18', '\r', '\x2', 'w', 'y', '\x5', '\x16', 
		'\f', '\x2', 'x', 'w', '\x3', '\x2', '\x2', '\x2', 'x', 'y', '\x3', '\x2', 
		'\x2', '\x2', 'y', '{', '\x3', '\x2', '\x2', '\x2', 'z', '|', '\x5', '\x30', 
		'\x19', '\x2', '{', 'z', '\x3', '\x2', '\x2', '\x2', '{', '|', '\x3', 
		'\x2', '\x2', '\x2', '|', '\x85', '\x3', '\x2', '\x2', '\x2', '}', '\x81', 
		'\a', '\x16', '\x2', '\x2', '~', '\x80', '\x5', '\x10', '\t', '\x2', '\x7F', 
		'~', '\x3', '\x2', '\x2', '\x2', '\x80', '\x83', '\x3', '\x2', '\x2', 
		'\x2', '\x81', '\x7F', '\x3', '\x2', '\x2', '\x2', '\x81', '\x82', '\x3', 
		'\x2', '\x2', '\x2', '\x82', '\x84', '\x3', '\x2', '\x2', '\x2', '\x83', 
		'\x81', '\x3', '\x2', '\x2', '\x2', '\x84', '\x86', '\a', '\x17', '\x2', 
		'\x2', '\x85', '}', '\x3', '\x2', '\x2', '\x2', '\x85', '\x86', '\x3', 
		'\x2', '\x2', '\x2', '\x86', '\x15', '\x3', '\x2', '\x2', '\x2', '\x87', 
		'\x88', '\a', '\x18', '\x2', '\x2', '\x88', '\x89', '\x5', '\x34', '\x1B', 
		'\x2', '\x89', '\x8A', '\a', '$', '\x2', '\x2', '\x8A', '\x17', '\x3', 
		'\x2', '\x2', '\x2', '\x8B', '\x8C', '\a', '\"', '\x2', '\x2', '\x8C', 
		'\x19', '\x3', '\x2', '\x2', '\x2', '\x8D', '\x91', '\x5', '\x1C', '\xF', 
		'\x2', '\x8E', '\x90', '\x5', '\x1E', '\x10', '\x2', '\x8F', '\x8E', '\x3', 
		'\x2', '\x2', '\x2', '\x90', '\x93', '\x3', '\x2', '\x2', '\x2', '\x91', 
		'\x8F', '\x3', '\x2', '\x2', '\x2', '\x91', '\x92', '\x3', '\x2', '\x2', 
		'\x2', '\x92', '\x95', '\x3', '\x2', '\x2', '\x2', '\x93', '\x91', '\x3', 
		'\x2', '\x2', '\x2', '\x94', '\x96', '\x5', ' ', '\x11', '\x2', '\x95', 
		'\x94', '\x3', '\x2', '\x2', '\x2', '\x95', '\x96', '\x3', '\x2', '\x2', 
		'\x2', '\x96', '\x97', '\x3', '\x2', '\x2', '\x2', '\x97', '\x99', '\a', 
		'\x1B', '\x2', '\x2', '\x98', '\x9A', '\x5', '\x30', '\x19', '\x2', '\x99', 
		'\x98', '\x3', '\x2', '\x2', '\x2', '\x99', '\x9A', '\x3', '\x2', '\x2', 
		'\x2', '\x9A', '\x1B', '\x3', '\x2', '\x2', '\x2', '\x9B', '\x9C', '\a', 
		'\x18', '\x2', '\x2', '\x9C', '\x9D', '\x5', '\x34', '\x1B', '\x2', '\x9D', 
		'\xA1', '\a', '$', '\x2', '\x2', '\x9E', '\xA0', '\x5', '\x10', '\t', 
		'\x2', '\x9F', '\x9E', '\x3', '\x2', '\x2', '\x2', '\xA0', '\xA3', '\x3', 
		'\x2', '\x2', '\x2', '\xA1', '\x9F', '\x3', '\x2', '\x2', '\x2', '\xA1', 
		'\xA2', '\x3', '\x2', '\x2', '\x2', '\xA2', '\x1D', '\x3', '\x2', '\x2', 
		'\x2', '\xA3', '\xA1', '\x3', '\x2', '\x2', '\x2', '\xA4', '\xA5', '\a', 
		'\x1A', '\x2', '\x2', '\xA5', '\xA6', '\x5', '\x34', '\x1B', '\x2', '\xA6', 
		'\xAA', '\a', '$', '\x2', '\x2', '\xA7', '\xA9', '\x5', '\x10', '\t', 
		'\x2', '\xA8', '\xA7', '\x3', '\x2', '\x2', '\x2', '\xA9', '\xAC', '\x3', 
		'\x2', '\x2', '\x2', '\xAA', '\xA8', '\x3', '\x2', '\x2', '\x2', '\xAA', 
		'\xAB', '\x3', '\x2', '\x2', '\x2', '\xAB', '\x1F', '\x3', '\x2', '\x2', 
		'\x2', '\xAC', '\xAA', '\x3', '\x2', '\x2', '\x2', '\xAD', '\xB1', '\a', 
		'\x19', '\x2', '\x2', '\xAE', '\xB0', '\x5', '\x10', '\t', '\x2', '\xAF', 
		'\xAE', '\x3', '\x2', '\x2', '\x2', '\xB0', '\xB3', '\x3', '\x2', '\x2', 
		'\x2', '\xB1', '\xAF', '\x3', '\x2', '\x2', '\x2', '\xB1', '\xB2', '\x3', 
		'\x2', '\x2', '\x2', '\xB2', '!', '\x3', '\x2', '\x2', '\x2', '\xB3', 
		'\xB1', '\x3', '\x2', '\x2', '\x2', '\xB4', '\xB5', '\a', '\x1C', '\x2', 
		'\x2', '\xB5', '\xB9', '\x5', '\x38', '\x1D', '\x2', '\xB6', '\xB8', '\a', 
		'-', '\x2', '\x2', '\xB7', '\xB6', '\x3', '\x2', '\x2', '\x2', '\xB8', 
		'\xBB', '\x3', '\x2', '\x2', '\x2', '\xB9', '\xB7', '\x3', '\x2', '\x2', 
		'\x2', '\xB9', '\xBA', '\x3', '\x2', '\x2', '\x2', '\xBA', '\xBC', '\x3', 
		'\x2', '\x2', '\x2', '\xBB', '\xB9', '\x3', '\x2', '\x2', '\x2', '\xBC', 
		'\xBD', '\x5', '\x34', '\x1B', '\x2', '\xBD', '\xBE', '\a', '$', '\x2', 
		'\x2', '\xBE', '\xC4', '\x3', '\x2', '\x2', '\x2', '\xBF', '\xC0', '\a', 
		'\x1C', '\x2', '\x2', '\xC0', '\xC1', '\x5', '\x34', '\x1B', '\x2', '\xC1', 
		'\xC2', '\a', '$', '\x2', '\x2', '\xC2', '\xC4', '\x3', '\x2', '\x2', 
		'\x2', '\xC3', '\xB4', '\x3', '\x2', '\x2', '\x2', '\xC3', '\xBF', '\x3', 
		'\x2', '\x2', '\x2', '\xC4', '#', '\x3', '\x2', '\x2', '\x2', '\xC5', 
		'\xC6', '\a', '\x1F', '\x2', '\x2', '\xC6', '\xC7', '\a', 'K', '\x2', 
		'\x2', '\xC7', '\xC8', '\a', 'J', '\x2', '\x2', '\xC8', '\xC9', '\a', 
		'M', '\x2', '\x2', '\xC9', '\xCE', '\a', 'L', '\x2', '\x2', '\xCA', '\xCB', 
		'\a', '\x1F', '\x2', '\x2', '\xCB', '\xCC', '\a', 'K', '\x2', '\x2', '\xCC', 
		'\xCE', '\a', 'L', '\x2', '\x2', '\xCD', '\xC5', '\x3', '\x2', '\x2', 
		'\x2', '\xCD', '\xCA', '\x3', '\x2', '\x2', '\x2', '\xCE', '\xD0', '\x3', 
		'\x2', '\x2', '\x2', '\xCF', '\xD1', '\x5', '\x30', '\x19', '\x2', '\xD0', 
		'\xCF', '\x3', '\x2', '\x2', '\x2', '\xD0', '\xD1', '\x3', '\x2', '\x2', 
		'\x2', '\xD1', '%', '\x3', '\x2', '\x2', '\x2', '\xD2', '\xD3', '\a', 
		'G', '\x2', '\x2', '\xD3', '\xD5', '\a', '\x42', '\x2', '\x2', '\xD4', 
		'\xD6', '\x5', '\x34', '\x1B', '\x2', '\xD5', '\xD4', '\x3', '\x2', '\x2', 
		'\x2', '\xD5', '\xD6', '\x3', '\x2', '\x2', '\x2', '\xD6', '\xDB', '\x3', 
		'\x2', '\x2', '\x2', '\xD7', '\xD8', '\a', '\x44', '\x2', '\x2', '\xD8', 
		'\xDA', '\x5', '\x34', '\x1B', '\x2', '\xD9', '\xD7', '\x3', '\x2', '\x2', 
		'\x2', '\xDA', '\xDD', '\x3', '\x2', '\x2', '\x2', '\xDB', '\xD9', '\x3', 
		'\x2', '\x2', '\x2', '\xDB', '\xDC', '\x3', '\x2', '\x2', '\x2', '\xDC', 
		'\xDE', '\x3', '\x2', '\x2', '\x2', '\xDD', '\xDB', '\x3', '\x2', '\x2', 
		'\x2', '\xDE', '\xDF', '\a', '\x43', '\x2', '\x2', '\xDF', '\'', '\x3', 
		'\x2', '\x2', '\x2', '\xE0', '\xE1', '\a', '\x1D', '\x2', '\x2', '\xE1', 
		'\xE6', '\x5', '\x34', '\x1B', '\x2', '\xE2', '\xE3', '\a', '\x44', '\x2', 
		'\x2', '\xE3', '\xE5', '\x5', '\x34', '\x1B', '\x2', '\xE4', '\xE2', '\x3', 
		'\x2', '\x2', '\x2', '\xE5', '\xE8', '\x3', '\x2', '\x2', '\x2', '\xE6', 
		'\xE4', '\x3', '\x2', '\x2', '\x2', '\xE6', '\xE7', '\x3', '\x2', '\x2', 
		'\x2', '\xE7', '\xE9', '\x3', '\x2', '\x2', '\x2', '\xE8', '\xE6', '\x3', 
		'\x2', '\x2', '\x2', '\xE9', '\xEA', '\a', '\x43', '\x2', '\x2', '\xEA', 
		'\xEB', '\a', '$', '\x2', '\x2', '\xEB', ')', '\x3', '\x2', '\x2', '\x2', 
		'\xEC', '\xED', '\a', 'I', '\x2', '\x2', '\xED', '+', '\x3', '\x2', '\x2', 
		'\x2', '\xEE', '\xEF', '\t', '\x2', '\x2', '\x2', '\xEF', '-', '\x3', 
		'\x2', '\x2', '\x2', '\xF0', '\xF2', '\x5', ',', '\x17', '\x2', '\xF1', 
		'\xF3', '\x5', '\x30', '\x19', '\x2', '\xF2', '\xF1', '\x3', '\x2', '\x2', 
		'\x2', '\xF2', '\xF3', '\x3', '\x2', '\x2', '\x2', '\xF3', '/', '\x3', 
		'\x2', '\x2', '\x2', '\xF4', '\xF6', '\x5', '\x32', '\x1A', '\x2', '\xF5', 
		'\xF4', '\x3', '\x2', '\x2', '\x2', '\xF6', '\xF7', '\x3', '\x2', '\x2', 
		'\x2', '\xF7', '\xF5', '\x3', '\x2', '\x2', '\x2', '\xF7', '\xF8', '\x3', 
		'\x2', '\x2', '\x2', '\xF8', '\x31', '\x3', '\x2', '\x2', '\x2', '\xF9', 
		'\xFA', '\a', ' ', '\x2', '\x2', '\xFA', '\x33', '\x3', '\x2', '\x2', 
		'\x2', '\xFB', '\xFC', '\b', '\x1B', '\x1', '\x2', '\xFC', '\xFD', '\a', 
		'\x42', '\x2', '\x2', '\xFD', '\xFE', '\x5', '\x34', '\x1B', '\x2', '\xFE', 
		'\xFF', '\a', '\x43', '\x2', '\x2', '\xFF', '\x10E', '\x3', '\x2', '\x2', 
		'\x2', '\x100', '\x101', '\a', '>', '\x2', '\x2', '\x101', '\x10E', '\x5', 
		'\x34', '\x1B', '\f', '\x102', '\x103', '\a', '\x37', '\x2', '\x2', '\x103', 
		'\x10E', '\x5', '\x34', '\x1B', '\v', '\x104', '\x105', '\x5', '\x38', 
		'\x1D', '\x2', '\x105', '\x106', '\t', '\x3', '\x2', '\x2', '\x106', '\x107', 
		'\x5', '\x34', '\x1B', '\x6', '\x107', '\x10E', '\x3', '\x2', '\x2', '\x2', 
		'\x108', '\x109', '\x5', '\x38', '\x1D', '\x2', '\x109', '\x10A', '\t', 
		'\x4', '\x2', '\x2', '\x10A', '\x10B', '\x5', '\x34', '\x1B', '\x5', '\x10B', 
		'\x10E', '\x3', '\x2', '\x2', '\x2', '\x10C', '\x10E', '\x5', '\x36', 
		'\x1C', '\x2', '\x10D', '\xFB', '\x3', '\x2', '\x2', '\x2', '\x10D', '\x100', 
		'\x3', '\x2', '\x2', '\x2', '\x10D', '\x102', '\x3', '\x2', '\x2', '\x2', 
		'\x10D', '\x104', '\x3', '\x2', '\x2', '\x2', '\x10D', '\x108', '\x3', 
		'\x2', '\x2', '\x2', '\x10D', '\x10C', '\x3', '\x2', '\x2', '\x2', '\x10E', 
		'\x120', '\x3', '\x2', '\x2', '\x2', '\x10F', '\x110', '\f', '\n', '\x2', 
		'\x2', '\x110', '\x111', '\t', '\x5', '\x2', '\x2', '\x111', '\x11F', 
		'\x5', '\x34', '\x1B', '\v', '\x112', '\x113', '\f', '\t', '\x2', '\x2', 
		'\x113', '\x114', '\t', '\x6', '\x2', '\x2', '\x114', '\x11F', '\x5', 
		'\x34', '\x1B', '\n', '\x115', '\x116', '\f', '\b', '\x2', '\x2', '\x116', 
		'\x117', '\t', '\a', '\x2', '\x2', '\x117', '\x11F', '\x5', '\x34', '\x1B', 
		'\t', '\x118', '\x119', '\f', '\a', '\x2', '\x2', '\x119', '\x11A', '\t', 
		'\b', '\x2', '\x2', '\x11A', '\x11F', '\x5', '\x34', '\x1B', '\b', '\x11B', 
		'\x11C', '\f', '\x4', '\x2', '\x2', '\x11C', '\x11D', '\t', '\t', '\x2', 
		'\x2', '\x11D', '\x11F', '\x5', '\x34', '\x1B', '\x5', '\x11E', '\x10F', 
		'\x3', '\x2', '\x2', '\x2', '\x11E', '\x112', '\x3', '\x2', '\x2', '\x2', 
		'\x11E', '\x115', '\x3', '\x2', '\x2', '\x2', '\x11E', '\x118', '\x3', 
		'\x2', '\x2', '\x2', '\x11E', '\x11B', '\x3', '\x2', '\x2', '\x2', '\x11F', 
		'\x122', '\x3', '\x2', '\x2', '\x2', '\x120', '\x11E', '\x3', '\x2', '\x2', 
		'\x2', '\x120', '\x121', '\x3', '\x2', '\x2', '\x2', '\x121', '\x35', 
		'\x3', '\x2', '\x2', '\x2', '\x122', '\x120', '\x3', '\x2', '\x2', '\x2', 
		'\x123', '\x12B', '\a', '\x46', '\x2', '\x2', '\x124', '\x12B', '\a', 
		'*', '\x2', '\x2', '\x125', '\x12B', '\a', '+', '\x2', '\x2', '\x126', 
		'\x12B', '\x5', '\x38', '\x1D', '\x2', '\x127', '\x12B', '\a', '%', '\x2', 
		'\x2', '\x128', '\x12B', '\x5', '&', '\x14', '\x2', '\x129', '\x12B', 
		'\a', ',', '\x2', '\x2', '\x12A', '\x123', '\x3', '\x2', '\x2', '\x2', 
		'\x12A', '\x124', '\x3', '\x2', '\x2', '\x2', '\x12A', '\x125', '\x3', 
		'\x2', '\x2', '\x2', '\x12A', '\x126', '\x3', '\x2', '\x2', '\x2', '\x12A', 
		'\x127', '\x3', '\x2', '\x2', '\x2', '\x12A', '\x128', '\x3', '\x2', '\x2', 
		'\x2', '\x12A', '\x129', '\x3', '\x2', '\x2', '\x2', '\x12B', '\x37', 
		'\x3', '\x2', '\x2', '\x2', '\x12C', '\x12D', '\a', '\x45', '\x2', '\x2', 
		'\x12D', '\x39', '\x3', '\x2', '\x2', '\x2', ' ', '=', '\x46', 'L', 'N', 
		'\x62', 'n', 's', 'x', '{', '\x81', '\x85', '\x91', '\x95', '\x99', '\xA1', 
		'\xAA', '\xB1', '\xB9', '\xC3', '\xCD', '\xD0', '\xD5', '\xDB', '\xE6', 
		'\xF2', '\xF7', '\x10D', '\x11E', '\x120', '\x12A',
	};

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


}