PlanBundleParser.java

// Generated from org/lightjason/agentspeak/grammar/PlanBundle.g4 by ANTLR 4.7.1
package org.lightjason.agentspeak.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class PlanBundleParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		BINARYOPERATOR=1, UNARYOPERATOR=2, STRING=3, LOGICALVALUE=4, CONSTANTNUMBER=5, 
		EXCLAMATIONMARK=6, STRONGNEGATION=7, COMMA=8, PLUS=9, MINUS=10, DOUBLEEXCLAMATIONMARK=11, 
		QUESTIONMARK=12, DOLLAR=13, LEFTARROW=14, RIGHTARROW=15, RULEOPERATOR=16, 
		AT=17, COLON=18, SEMICOLON=19, DOT=20, UNDERSCORE=21, SLASH=22, LEFTROUNDBRACKET=23, 
		RIGHTROUNDBRACKET=24, LEFTANGULARBRACKET=25, RIGHTANGULARBRACKET=26, LEFTCURVEDBRACKET=27, 
		RIGHTCURVEDBRACKET=28, LEFTSHIFT=29, RIGHTSHIFT=30, PARALLEL=31, ATOMIC=32, 
		CONSTANT=33, VLINE=34, AND=35, OR=36, XOR=37, ASSIGN=38, DECONSTRUCT=39, 
		LESS=40, LESSEQUAL=41, GREATER=42, GREATEREQUAL=43, EQUAL=44, NOTEQUAL=45, 
		POW=46, MULTIPLY=47, MODULO=48, LOWERCASELETTER=49, UPPERCASELETTER=50, 
		DIGIT=51, WHITESPACE=52, LINECOMMENT=53, BLOCKCOMMENT=54;
	public static final int
		RULE_planbundle = 0, RULE_belief = 1, RULE_plans = 2, RULE_logicrules = 3, 
		RULE_plan = 4, RULE_plandefinition = 5, RULE_logicrule = 6, RULE_logicalruledefinition = 7, 
		RULE_annotations = 8, RULE_annotation_atom = 9, RULE_annotation_literal = 10, 
		RULE_annotation_value_literal = 11, RULE_plan_trigger = 12, RULE_plan_goal_trigger = 13, 
		RULE_plan_belief_trigger = 14, RULE_body = 15, RULE_body_formula = 16, 
		RULE_repair_formula = 17, RULE_belief_action = 18, RULE_test_action = 19, 
		RULE_achievement_goal_action = 20, RULE_deconstruct_expression = 21, RULE_assignment_expression = 22, 
		RULE_assignment_expression_singlevariable = 23, RULE_assignment_expression_multivariable = 24, 
		RULE_unary_expression = 25, RULE_binary_expression = 26, RULE_block_formula = 27, 
		RULE_lambda = 28, RULE_lambda_initialization = 29, RULE_lambda_return = 30, 
		RULE_executable_term = 31, RULE_term = 32, RULE_unification = 33, RULE_unification_constraint = 34, 
		RULE_ternary_operation = 35, RULE_ternary_operation_true = 36, RULE_ternary_operation_false = 37, 
		RULE_expression = 38, RULE_expression_bracket = 39, RULE_expression_logical_and = 40, 
		RULE_expression_logical_xor = 41, RULE_expression_logical_element = 42, 
		RULE_expression_logical_negation = 43, RULE_expression_numeric = 44, RULE_expression_numeric_relation = 45, 
		RULE_expression_numeric_additive = 46, RULE_expression_numeric_multiplicative = 47, 
		RULE_expression_numeric_power = 48, RULE_expression_numeric_element = 49, 
		RULE_executable_action = 50, RULE_executable_rule = 51, RULE_variable_evaluate = 52, 
		RULE_literal = 53, RULE_termlist = 54, RULE_variablelist = 55, RULE_atom = 56, 
		RULE_variable = 57, RULE_variableatom = 58, RULE_number = 59, RULE_digitsequence = 60;
	public static final String[] ruleNames = {
		"planbundle", "belief", "plans", "logicrules", "plan", "plandefinition", 
		"logicrule", "logicalruledefinition", "annotations", "annotation_atom", 
		"annotation_literal", "annotation_value_literal", "plan_trigger", "plan_goal_trigger", 
		"plan_belief_trigger", "body", "body_formula", "repair_formula", "belief_action", 
		"test_action", "achievement_goal_action", "deconstruct_expression", "assignment_expression", 
		"assignment_expression_singlevariable", "assignment_expression_multivariable", 
		"unary_expression", "binary_expression", "block_formula", "lambda", "lambda_initialization", 
		"lambda_return", "executable_term", "term", "unification", "unification_constraint", 
		"ternary_operation", "ternary_operation_true", "ternary_operation_false", 
		"expression", "expression_bracket", "expression_logical_and", "expression_logical_xor", 
		"expression_logical_element", "expression_logical_negation", "expression_numeric", 
		"expression_numeric_relation", "expression_numeric_additive", "expression_numeric_multiplicative", 
		"expression_numeric_power", "expression_numeric_element", "executable_action", 
		"executable_rule", "variable_evaluate", "literal", "termlist", "variablelist", 
		"atom", "variable", "variableatom", "number", "digitsequence"
	};

	private static final String[] _LITERAL_NAMES = {
		null, null, null, null, null, null, "'!'", "'~'", "','", "'+'", "'-'", 
		"'!!'", "'?'", "'$'", "'<-'", "'->'", "':-'", "'@'", "':'", "';'", "'.'", 
		"'_'", "'/'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'<<'", "'>>'", 
		"'parallel'", "'atomic'", "'constant'", "'|'", "'&&'", "'||'", "'^'", 
		"'='", "'=..'", "'<'", "'<='", "'>'", "'>='", "'=='", null, "'**'", "'*'", 
		"'%'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, "BINARYOPERATOR", "UNARYOPERATOR", "STRING", "LOGICALVALUE", "CONSTANTNUMBER", 
		"EXCLAMATIONMARK", "STRONGNEGATION", "COMMA", "PLUS", "MINUS", "DOUBLEEXCLAMATIONMARK", 
		"QUESTIONMARK", "DOLLAR", "LEFTARROW", "RIGHTARROW", "RULEOPERATOR", "AT", 
		"COLON", "SEMICOLON", "DOT", "UNDERSCORE", "SLASH", "LEFTROUNDBRACKET", 
		"RIGHTROUNDBRACKET", "LEFTANGULARBRACKET", "RIGHTANGULARBRACKET", "LEFTCURVEDBRACKET", 
		"RIGHTCURVEDBRACKET", "LEFTSHIFT", "RIGHTSHIFT", "PARALLEL", "ATOMIC", 
		"CONSTANT", "VLINE", "AND", "OR", "XOR", "ASSIGN", "DECONSTRUCT", "LESS", 
		"LESSEQUAL", "GREATER", "GREATEREQUAL", "EQUAL", "NOTEQUAL", "POW", "MULTIPLY", 
		"MODULO", "LOWERCASELETTER", "UPPERCASELETTER", "DIGIT", "WHITESPACE", 
		"LINECOMMENT", "BLOCKCOMMENT"
	};
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "PlanBundle.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public PlanBundleParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class PlanbundleContext extends ParserRuleContext {
		public PlansContext plans() {
			return getRuleContext(PlansContext.class,0);
		}
		public List<BeliefContext> belief() {
			return getRuleContexts(BeliefContext.class);
		}
		public BeliefContext belief(int i) {
			return getRuleContext(BeliefContext.class,i);
		}
		public LogicrulesContext logicrules() {
			return getRuleContext(LogicrulesContext.class,0);
		}
		public PlanbundleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_planbundle; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlanbundle(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlanbundleContext planbundle() throws RecognitionException {
		PlanbundleContext _localctx = new PlanbundleContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_planbundle);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(125);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(122);
					belief();
					}
					} 
				}
				setState(127);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			}
			setState(129);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				{
				setState(128);
				logicrules();
				}
				break;
			}
			setState(131);
			plans();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BeliefContext extends ParserRuleContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
		public BeliefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_belief; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BeliefContext belief() throws RecognitionException {
		BeliefContext _localctx = new BeliefContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_belief);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(133);
			literal();
			setState(134);
			match(DOT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PlansContext extends ParserRuleContext {
		public List<PlanContext> plan() {
			return getRuleContexts(PlanContext.class);
		}
		public PlanContext plan(int i) {
			return getRuleContext(PlanContext.class,i);
		}
		public PlansContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plans; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlans(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlansContext plans() throws RecognitionException {
		PlansContext _localctx = new PlansContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_plans);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(137); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(136);
				plan();
				}
				}
				setState(139); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << AT))) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicrulesContext extends ParserRuleContext {
		public List<LogicruleContext> logicrule() {
			return getRuleContexts(LogicruleContext.class);
		}
		public LogicruleContext logicrule(int i) {
			return getRuleContext(LogicruleContext.class,i);
		}
		public LogicrulesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicrules; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrules(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicrulesContext logicrules() throws RecognitionException {
		LogicrulesContext _localctx = new LogicrulesContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_logicrules);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(142); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(141);
					logicrule();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(144); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PlanContext extends ParserRuleContext {
		public Plan_triggerContext plan_trigger() {
			return getRuleContext(Plan_triggerContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
		public AnnotationsContext annotations() {
			return getRuleContext(AnnotationsContext.class,0);
		}
		public List<PlandefinitionContext> plandefinition() {
			return getRuleContexts(PlandefinitionContext.class);
		}
		public PlandefinitionContext plandefinition(int i) {
			return getRuleContext(PlandefinitionContext.class,i);
		}
		public PlanContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plan; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlanContext plan() throws RecognitionException {
		PlanContext _localctx = new PlanContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_plan);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(147);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AT) {
				{
				setState(146);
				annotations();
				}
			}

			setState(149);
			plan_trigger();
			setState(150);
			literal();
			setState(154);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LEFTARROW || _la==COLON) {
				{
				{
				setState(151);
				plandefinition();
				}
				}
				setState(156);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(157);
			match(DOT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PlandefinitionContext extends ParserRuleContext {
		public TerminalNode LEFTARROW() { return getToken(PlanBundleParser.LEFTARROW, 0); }
		public BodyContext body() {
			return getRuleContext(BodyContext.class,0);
		}
		public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public PlandefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plandefinition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlandefinition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlandefinitionContext plandefinition() throws RecognitionException {
		PlandefinitionContext _localctx = new PlandefinitionContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_plandefinition);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(161);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(159);
				match(COLON);
				setState(160);
				expression();
				}
			}

			setState(163);
			match(LEFTARROW);
			setState(164);
			body();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicruleContext extends ParserRuleContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
		public AnnotationsContext annotations() {
			return getRuleContext(AnnotationsContext.class,0);
		}
		public List<LogicalruledefinitionContext> logicalruledefinition() {
			return getRuleContexts(LogicalruledefinitionContext.class);
		}
		public LogicalruledefinitionContext logicalruledefinition(int i) {
			return getRuleContext(LogicalruledefinitionContext.class,i);
		}
		public LogicruleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicrule; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicrule(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicruleContext logicrule() throws RecognitionException {
		LogicruleContext _localctx = new LogicruleContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_logicrule);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(167);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				{
				setState(166);
				annotations();
				}
				break;
			}
			setState(169);
			literal();
			setState(171); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(170);
				logicalruledefinition();
				}
				}
				setState(173); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==RULEOPERATOR );
			setState(175);
			match(DOT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LogicalruledefinitionContext extends ParserRuleContext {
		public TerminalNode RULEOPERATOR() { return getToken(PlanBundleParser.RULEOPERATOR, 0); }
		public BodyContext body() {
			return getRuleContext(BodyContext.class,0);
		}
		public LogicalruledefinitionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalruledefinition; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLogicalruledefinition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicalruledefinitionContext logicalruledefinition() throws RecognitionException {
		LogicalruledefinitionContext _localctx = new LogicalruledefinitionContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_logicalruledefinition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(177);
			match(RULEOPERATOR);
			setState(178);
			body();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AnnotationsContext extends ParserRuleContext {
		public List<Annotation_atomContext> annotation_atom() {
			return getRuleContexts(Annotation_atomContext.class);
		}
		public Annotation_atomContext annotation_atom(int i) {
			return getRuleContext(Annotation_atomContext.class,i);
		}
		public List<Annotation_literalContext> annotation_literal() {
			return getRuleContexts(Annotation_literalContext.class);
		}
		public Annotation_literalContext annotation_literal(int i) {
			return getRuleContext(Annotation_literalContext.class,i);
		}
		public AnnotationsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_annotations; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotations(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AnnotationsContext annotations() throws RecognitionException {
		AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_annotations);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(182); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					setState(182);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
					case 1:
						{
						setState(180);
						annotation_atom();
						}
						break;
					case 2:
						{
						setState(181);
						annotation_literal();
						}
						break;
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(184); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Annotation_atomContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public TerminalNode ATOMIC() { return getToken(PlanBundleParser.ATOMIC, 0); }
		public TerminalNode PARALLEL() { return getToken(PlanBundleParser.PARALLEL, 0); }
		public Annotation_atomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_annotation_atom; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_atom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Annotation_atomContext annotation_atom() throws RecognitionException {
		Annotation_atomContext _localctx = new Annotation_atomContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_annotation_atom);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(186);
			match(AT);
			setState(187);
			_la = _input.LA(1);
			if ( !(_la==PARALLEL || _la==ATOMIC) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Annotation_literalContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public Annotation_value_literalContext annotation_value_literal() {
			return getRuleContext(Annotation_value_literalContext.class,0);
		}
		public Annotation_literalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_annotation_literal; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_literal(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Annotation_literalContext annotation_literal() throws RecognitionException {
		Annotation_literalContext _localctx = new Annotation_literalContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_annotation_literal);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(189);
			match(AT);
			setState(190);
			annotation_value_literal();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Annotation_value_literalContext extends ParserRuleContext {
		public TerminalNode CONSTANT() { return getToken(PlanBundleParser.CONSTANT, 0); }
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public VariableatomContext variableatom() {
			return getRuleContext(VariableatomContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
		public Annotation_value_literalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_annotation_value_literal; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAnnotation_value_literal(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Annotation_value_literalContext annotation_value_literal() throws RecognitionException {
		Annotation_value_literalContext _localctx = new Annotation_value_literalContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_annotation_value_literal);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			match(CONSTANT);
			setState(193);
			match(LEFTROUNDBRACKET);
			setState(194);
			variableatom();
			setState(195);
			match(COMMA);
			setState(198);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CONSTANTNUMBER:
			case MINUS:
			case DIGIT:
				{
				setState(196);
				number();
				}
				break;
			case STRING:
				{
				setState(197);
				match(STRING);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(200);
			match(RIGHTROUNDBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Plan_triggerContext extends ParserRuleContext {
		public Plan_belief_triggerContext plan_belief_trigger() {
			return getRuleContext(Plan_belief_triggerContext.class,0);
		}
		public Plan_goal_triggerContext plan_goal_trigger() {
			return getRuleContext(Plan_goal_triggerContext.class,0);
		}
		public Plan_triggerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plan_trigger; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_trigger(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Plan_triggerContext plan_trigger() throws RecognitionException {
		Plan_triggerContext _localctx = new Plan_triggerContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_plan_trigger);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(204);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				{
				setState(202);
				plan_belief_trigger();
				}
				break;
			case 2:
				{
				setState(203);
				plan_goal_trigger();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Plan_goal_triggerContext extends ParserRuleContext {
		public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
		public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
		public Plan_goal_triggerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plan_goal_trigger; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_goal_trigger(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Plan_goal_triggerContext plan_goal_trigger() throws RecognitionException {
		Plan_goal_triggerContext _localctx = new Plan_goal_triggerContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_plan_goal_trigger);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(206);
			_la = _input.LA(1);
			if ( !(_la==PLUS || _la==MINUS) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(207);
			match(EXCLAMATIONMARK);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Plan_belief_triggerContext extends ParserRuleContext {
		public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
		public Plan_belief_triggerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_plan_belief_trigger; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitPlan_belief_trigger(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Plan_belief_triggerContext plan_belief_trigger() throws RecognitionException {
		Plan_belief_triggerContext _localctx = new Plan_belief_triggerContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_plan_belief_trigger);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(209);
			_la = _input.LA(1);
			if ( !(_la==PLUS || _la==MINUS) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BodyContext extends ParserRuleContext {
		public List<Body_formulaContext> body_formula() {
			return getRuleContexts(Body_formulaContext.class);
		}
		public Body_formulaContext body_formula(int i) {
			return getRuleContext(Body_formulaContext.class,i);
		}
		public List<TerminalNode> SEMICOLON() { return getTokens(PlanBundleParser.SEMICOLON); }
		public TerminalNode SEMICOLON(int i) {
			return getToken(PlanBundleParser.SEMICOLON, i);
		}
		public BodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_body; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BodyContext body() throws RecognitionException {
		BodyContext _localctx = new BodyContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_body);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(211);
			body_formula();
			setState(216);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SEMICOLON) {
				{
				{
				setState(212);
				match(SEMICOLON);
				setState(213);
				body_formula();
				}
				}
				setState(218);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Body_formulaContext extends ParserRuleContext {
		public Repair_formulaContext repair_formula() {
			return getRuleContext(Repair_formulaContext.class,0);
		}
		public Belief_actionContext belief_action() {
			return getRuleContext(Belief_actionContext.class,0);
		}
		public Deconstruct_expressionContext deconstruct_expression() {
			return getRuleContext(Deconstruct_expressionContext.class,0);
		}
		public Assignment_expressionContext assignment_expression() {
			return getRuleContext(Assignment_expressionContext.class,0);
		}
		public Unary_expressionContext unary_expression() {
			return getRuleContext(Unary_expressionContext.class,0);
		}
		public Binary_expressionContext binary_expression() {
			return getRuleContext(Binary_expressionContext.class,0);
		}
		public LambdaContext lambda() {
			return getRuleContext(LambdaContext.class,0);
		}
		public Body_formulaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_body_formula; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBody_formula(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Body_formulaContext body_formula() throws RecognitionException {
		Body_formulaContext _localctx = new Body_formulaContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_body_formula);
		try {
			setState(226);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(219);
				repair_formula();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(220);
				belief_action();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(221);
				deconstruct_expression();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(222);
				assignment_expression();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(223);
				unary_expression();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(224);
				binary_expression();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(225);
				lambda();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Repair_formulaContext extends ParserRuleContext {
		public Executable_termContext executable_term() {
			return getRuleContext(Executable_termContext.class,0);
		}
		public Test_actionContext test_action() {
			return getRuleContext(Test_actionContext.class,0);
		}
		public Achievement_goal_actionContext achievement_goal_action() {
			return getRuleContext(Achievement_goal_actionContext.class,0);
		}
		public TerminalNode LEFTSHIFT() { return getToken(PlanBundleParser.LEFTSHIFT, 0); }
		public Repair_formulaContext repair_formula() {
			return getRuleContext(Repair_formulaContext.class,0);
		}
		public Repair_formulaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_repair_formula; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitRepair_formula(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Repair_formulaContext repair_formula() throws RecognitionException {
		Repair_formulaContext _localctx = new Repair_formulaContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_repair_formula);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(231);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING:
			case LOGICALVALUE:
			case CONSTANTNUMBER:
			case STRONGNEGATION:
			case MINUS:
			case DOLLAR:
			case AT:
			case UNDERSCORE:
			case LEFTROUNDBRACKET:
			case RIGHTSHIFT:
			case LOWERCASELETTER:
			case UPPERCASELETTER:
			case DIGIT:
				{
				setState(228);
				executable_term();
				}
				break;
			case QUESTIONMARK:
				{
				setState(229);
				test_action();
				}
				break;
			case EXCLAMATIONMARK:
			case DOUBLEEXCLAMATIONMARK:
				{
				setState(230);
				achievement_goal_action();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(235);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTSHIFT) {
				{
				setState(233);
				match(LEFTSHIFT);
				setState(234);
				repair_formula();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Belief_actionContext extends ParserRuleContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
		public Belief_actionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_belief_action; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBelief_action(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Belief_actionContext belief_action() throws RecognitionException {
		Belief_actionContext _localctx = new Belief_actionContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_belief_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(237);
			_la = _input.LA(1);
			if ( !(_la==PLUS || _la==MINUS) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(238);
			literal();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Test_actionContext extends ParserRuleContext {
		public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
		public AtomContext atom() {
			return getRuleContext(AtomContext.class,0);
		}
		public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
		public Test_actionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_test_action; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTest_action(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Test_actionContext test_action() throws RecognitionException {
		Test_actionContext _localctx = new Test_actionContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_test_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(240);
			match(QUESTIONMARK);
			setState(242);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOLLAR) {
				{
				setState(241);
				match(DOLLAR);
				}
			}

			setState(244);
			atom();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Achievement_goal_actionContext extends ParserRuleContext {
		public TerminalNode EXCLAMATIONMARK() { return getToken(PlanBundleParser.EXCLAMATIONMARK, 0); }
		public TerminalNode DOUBLEEXCLAMATIONMARK() { return getToken(PlanBundleParser.DOUBLEEXCLAMATIONMARK, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public Variable_evaluateContext variable_evaluate() {
			return getRuleContext(Variable_evaluateContext.class,0);
		}
		public Achievement_goal_actionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_achievement_goal_action; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAchievement_goal_action(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Achievement_goal_actionContext achievement_goal_action() throws RecognitionException {
		Achievement_goal_actionContext _localctx = new Achievement_goal_actionContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_achievement_goal_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246);
			_la = _input.LA(1);
			if ( !(_la==EXCLAMATIONMARK || _la==DOUBLEEXCLAMATIONMARK) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(249);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				{
				setState(247);
				literal();
				}
				break;
			case 2:
				{
				setState(248);
				variable_evaluate();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Deconstruct_expressionContext extends ParserRuleContext {
		public VariablelistContext variablelist() {
			return getRuleContext(VariablelistContext.class,0);
		}
		public TerminalNode DECONSTRUCT() { return getToken(PlanBundleParser.DECONSTRUCT, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public Deconstruct_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deconstruct_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDeconstruct_expression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Deconstruct_expressionContext deconstruct_expression() throws RecognitionException {
		Deconstruct_expressionContext _localctx = new Deconstruct_expressionContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_deconstruct_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(251);
			variablelist();
			setState(252);
			match(DECONSTRUCT);
			setState(255);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				{
				setState(253);
				literal();
				}
				break;
			case 2:
				{
				setState(254);
				variable();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Assignment_expressionContext extends ParserRuleContext {
		public Assignment_expression_singlevariableContext assignment_expression_singlevariable() {
			return getRuleContext(Assignment_expression_singlevariableContext.class,0);
		}
		public Assignment_expression_multivariableContext assignment_expression_multivariable() {
			return getRuleContext(Assignment_expression_multivariableContext.class,0);
		}
		public Assignment_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignment_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Assignment_expressionContext assignment_expression() throws RecognitionException {
		Assignment_expressionContext _localctx = new Assignment_expressionContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_assignment_expression);
		try {
			setState(259);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AT:
			case UNDERSCORE:
			case UPPERCASELETTER:
				enterOuterAlt(_localctx, 1);
				{
				setState(257);
				assignment_expression_singlevariable();
				}
				break;
			case LEFTANGULARBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(258);
				assignment_expression_multivariable();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Assignment_expression_singlevariableContext extends ParserRuleContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
		public Executable_termContext executable_term() {
			return getRuleContext(Executable_termContext.class,0);
		}
		public Assignment_expression_singlevariableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignment_expression_singlevariable; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_singlevariable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Assignment_expression_singlevariableContext assignment_expression_singlevariable() throws RecognitionException {
		Assignment_expression_singlevariableContext _localctx = new Assignment_expression_singlevariableContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_assignment_expression_singlevariable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(261);
			variable();
			setState(262);
			match(ASSIGN);
			setState(263);
			executable_term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Assignment_expression_multivariableContext extends ParserRuleContext {
		public VariablelistContext variablelist() {
			return getRuleContext(VariablelistContext.class,0);
		}
		public TerminalNode ASSIGN() { return getToken(PlanBundleParser.ASSIGN, 0); }
		public Executable_termContext executable_term() {
			return getRuleContext(Executable_termContext.class,0);
		}
		public Assignment_expression_multivariableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignment_expression_multivariable; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAssignment_expression_multivariable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Assignment_expression_multivariableContext assignment_expression_multivariable() throws RecognitionException {
		Assignment_expression_multivariableContext _localctx = new Assignment_expression_multivariableContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_assignment_expression_multivariable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(265);
			variablelist();
			setState(266);
			match(ASSIGN);
			setState(267);
			executable_term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Unary_expressionContext extends ParserRuleContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public TerminalNode UNARYOPERATOR() { return getToken(PlanBundleParser.UNARYOPERATOR, 0); }
		public Unary_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unary_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnary_expression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Unary_expressionContext unary_expression() throws RecognitionException {
		Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_unary_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(269);
			variable();
			setState(270);
			match(UNARYOPERATOR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Binary_expressionContext extends ParserRuleContext {
		public List<VariableContext> variable() {
			return getRuleContexts(VariableContext.class);
		}
		public VariableContext variable(int i) {
			return getRuleContext(VariableContext.class,i);
		}
		public TerminalNode BINARYOPERATOR() { return getToken(PlanBundleParser.BINARYOPERATOR, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public Binary_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_binary_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBinary_expression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Binary_expressionContext binary_expression() throws RecognitionException {
		Binary_expressionContext _localctx = new Binary_expressionContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_binary_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(272);
			variable();
			setState(273);
			match(BINARYOPERATOR);
			setState(276);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AT:
			case UNDERSCORE:
			case UPPERCASELETTER:
				{
				setState(274);
				variable();
				}
				break;
			case CONSTANTNUMBER:
			case MINUS:
			case DIGIT:
				{
				setState(275);
				number();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Block_formulaContext extends ParserRuleContext {
		public TerminalNode LEFTCURVEDBRACKET() { return getToken(PlanBundleParser.LEFTCURVEDBRACKET, 0); }
		public BodyContext body() {
			return getRuleContext(BodyContext.class,0);
		}
		public TerminalNode RIGHTCURVEDBRACKET() { return getToken(PlanBundleParser.RIGHTCURVEDBRACKET, 0); }
		public Body_formulaContext body_formula() {
			return getRuleContext(Body_formulaContext.class,0);
		}
		public Block_formulaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block_formula; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitBlock_formula(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Block_formulaContext block_formula() throws RecognitionException {
		Block_formulaContext _localctx = new Block_formulaContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_block_formula);
		try {
			setState(283);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LEFTCURVEDBRACKET:
				enterOuterAlt(_localctx, 1);
				{
				setState(278);
				match(LEFTCURVEDBRACKET);
				setState(279);
				body();
				setState(280);
				match(RIGHTCURVEDBRACKET);
				}
				break;
			case STRING:
			case LOGICALVALUE:
			case CONSTANTNUMBER:
			case EXCLAMATIONMARK:
			case STRONGNEGATION:
			case PLUS:
			case MINUS:
			case DOUBLEEXCLAMATIONMARK:
			case QUESTIONMARK:
			case DOLLAR:
			case AT:
			case UNDERSCORE:
			case LEFTROUNDBRACKET:
			case LEFTANGULARBRACKET:
			case RIGHTSHIFT:
			case LOWERCASELETTER:
			case UPPERCASELETTER:
			case DIGIT:
				enterOuterAlt(_localctx, 2);
				{
				setState(282);
				body_formula();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LambdaContext extends ParserRuleContext {
		public Lambda_initializationContext lambda_initialization() {
			return getRuleContext(Lambda_initializationContext.class,0);
		}
		public TerminalNode RIGHTARROW() { return getToken(PlanBundleParser.RIGHTARROW, 0); }
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
		public Block_formulaContext block_formula() {
			return getRuleContext(Block_formulaContext.class,0);
		}
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public Lambda_returnContext lambda_return() {
			return getRuleContext(Lambda_returnContext.class,0);
		}
		public LambdaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambda; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LambdaContext lambda() throws RecognitionException {
		LambdaContext _localctx = new LambdaContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_lambda);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(286);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AT) {
				{
				setState(285);
				match(AT);
				}
			}

			setState(288);
			lambda_initialization();
			setState(289);
			match(RIGHTARROW);
			setState(290);
			variable();
			setState(292);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==VLINE) {
				{
				setState(291);
				lambda_return();
				}
			}

			setState(294);
			match(COLON);
			setState(295);
			block_formula();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Lambda_initializationContext extends ParserRuleContext {
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public Lambda_initializationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambda_initialization; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_initialization(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Lambda_initializationContext lambda_initialization() throws RecognitionException {
		Lambda_initializationContext _localctx = new Lambda_initializationContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_lambda_initialization);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(297);
			match(LEFTROUNDBRACKET);
			setState(300);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(298);
				variable();
				}
				break;
			case 2:
				{
				setState(299);
				literal();
				}
				break;
			}
			setState(302);
			match(RIGHTROUNDBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Lambda_returnContext extends ParserRuleContext {
		public TerminalNode VLINE() { return getToken(PlanBundleParser.VLINE, 0); }
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public Lambda_returnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambda_return; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLambda_return(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Lambda_returnContext lambda_return() throws RecognitionException {
		Lambda_returnContext _localctx = new Lambda_returnContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_lambda_return);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(304);
			match(VLINE);
			setState(305);
			variable();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Executable_termContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
		public Executable_actionContext executable_action() {
			return getRuleContext(Executable_actionContext.class,0);
		}
		public Executable_ruleContext executable_rule() {
			return getRuleContext(Executable_ruleContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Ternary_operationContext ternary_operation() {
			return getRuleContext(Ternary_operationContext.class,0);
		}
		public Executable_termContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_executable_term; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_term(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Executable_termContext executable_term() throws RecognitionException {
		Executable_termContext _localctx = new Executable_termContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_executable_term);
		try {
			setState(314);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(307);
				match(STRING);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(308);
				number();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(309);
				match(LOGICALVALUE);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(310);
				executable_action();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(311);
				executable_rule();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(312);
				expression();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(313);
				ternary_operation();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TermContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(PlanBundleParser.STRING, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public VariablelistContext variablelist() {
			return getRuleContext(VariablelistContext.class,0);
		}
		public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
		public TermlistContext termlist() {
			return getRuleContext(TermlistContext.class,0);
		}
		public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Ternary_operationContext ternary_operation() {
			return getRuleContext(Ternary_operationContext.class,0);
		}
		public TermContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_term; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTerm(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermContext term() throws RecognitionException {
		TermContext _localctx = new TermContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_term);
		try {
			setState(328);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(316);
				match(STRING);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(317);
				number();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(318);
				match(LOGICALVALUE);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(319);
				literal();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(320);
				variable();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(321);
				variablelist();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(322);
				match(LEFTANGULARBRACKET);
				setState(323);
				termlist();
				setState(324);
				match(RIGHTANGULARBRACKET);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(326);
				expression();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(327);
				ternary_operation();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnificationContext extends ParserRuleContext {
		public TerminalNode RIGHTSHIFT() { return getToken(PlanBundleParser.RIGHTSHIFT, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode COMMA() { return getToken(PlanBundleParser.COMMA, 0); }
		public Unification_constraintContext unification_constraint() {
			return getRuleContext(Unification_constraintContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public UnificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unification; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnificationContext unification() throws RecognitionException {
		UnificationContext _localctx = new UnificationContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_unification);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(331);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AT) {
				{
				setState(330);
				match(AT);
				}
			}

			setState(333);
			match(RIGHTSHIFT);
			setState(341);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRONGNEGATION:
			case AT:
			case LOWERCASELETTER:
				{
				setState(334);
				literal();
				}
				break;
			case LEFTROUNDBRACKET:
				{
				setState(335);
				match(LEFTROUNDBRACKET);
				setState(336);
				literal();
				setState(337);
				match(COMMA);
				setState(338);
				unification_constraint();
				setState(339);
				match(RIGHTROUNDBRACKET);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Unification_constraintContext extends ParserRuleContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Unification_constraintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unification_constraint; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitUnification_constraint(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Unification_constraintContext unification_constraint() throws RecognitionException {
		Unification_constraintContext _localctx = new Unification_constraintContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_unification_constraint);
		try {
			setState(345);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(343);
				variable();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(344);
				expression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Ternary_operationContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Ternary_operation_trueContext ternary_operation_true() {
			return getRuleContext(Ternary_operation_trueContext.class,0);
		}
		public Ternary_operation_falseContext ternary_operation_false() {
			return getRuleContext(Ternary_operation_falseContext.class,0);
		}
		public Ternary_operationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ternary_operation; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ternary_operationContext ternary_operation() throws RecognitionException {
		Ternary_operationContext _localctx = new Ternary_operationContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_ternary_operation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(347);
			expression();
			setState(348);
			ternary_operation_true();
			setState(349);
			ternary_operation_false();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Ternary_operation_trueContext extends ParserRuleContext {
		public TerminalNode QUESTIONMARK() { return getToken(PlanBundleParser.QUESTIONMARK, 0); }
		public Executable_termContext executable_term() {
			return getRuleContext(Executable_termContext.class,0);
		}
		public Ternary_operation_trueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ternary_operation_true; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_true(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ternary_operation_trueContext ternary_operation_true() throws RecognitionException {
		Ternary_operation_trueContext _localctx = new Ternary_operation_trueContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_ternary_operation_true);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(351);
			match(QUESTIONMARK);
			setState(352);
			executable_term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Ternary_operation_falseContext extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(PlanBundleParser.COLON, 0); }
		public Executable_termContext executable_term() {
			return getRuleContext(Executable_termContext.class,0);
		}
		public Ternary_operation_falseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ternary_operation_false; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTernary_operation_false(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Ternary_operation_falseContext ternary_operation_false() throws RecognitionException {
		Ternary_operation_falseContext _localctx = new Ternary_operation_falseContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_ternary_operation_false);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(354);
			match(COLON);
			setState(355);
			executable_term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionContext extends ParserRuleContext {
		public Expression_bracketContext expression_bracket() {
			return getRuleContext(Expression_bracketContext.class,0);
		}
		public Expression_logical_andContext expression_logical_and() {
			return getRuleContext(Expression_logical_andContext.class,0);
		}
		public List<TerminalNode> OR() { return getTokens(PlanBundleParser.OR); }
		public TerminalNode OR(int i) {
			return getToken(PlanBundleParser.OR, i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_expression);
		try {
			int _alt;
			setState(366);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(357);
				expression_bracket();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(358);
				expression_logical_and();
				setState(363);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(359);
						match(OR);
						setState(360);
						expression();
						}
						} 
					}
					setState(365);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_bracketContext extends ParserRuleContext {
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public Expression_bracketContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_bracket; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_bracket(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_bracketContext expression_bracket() throws RecognitionException {
		Expression_bracketContext _localctx = new Expression_bracketContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_expression_bracket);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(368);
			match(LEFTROUNDBRACKET);
			setState(369);
			expression();
			setState(370);
			match(RIGHTROUNDBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_logical_andContext extends ParserRuleContext {
		public Expression_logical_xorContext expression_logical_xor() {
			return getRuleContext(Expression_logical_xorContext.class,0);
		}
		public List<TerminalNode> AND() { return getTokens(PlanBundleParser.AND); }
		public TerminalNode AND(int i) {
			return getToken(PlanBundleParser.AND, i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public Expression_logical_andContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_logical_and; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_and(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_logical_andContext expression_logical_and() throws RecognitionException {
		Expression_logical_andContext _localctx = new Expression_logical_andContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_expression_logical_and);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(372);
			expression_logical_xor();
			setState(377);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(373);
					match(AND);
					setState(374);
					expression();
					}
					} 
				}
				setState(379);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_logical_xorContext extends ParserRuleContext {
		public Expression_logical_negationContext expression_logical_negation() {
			return getRuleContext(Expression_logical_negationContext.class,0);
		}
		public Expression_logical_elementContext expression_logical_element() {
			return getRuleContext(Expression_logical_elementContext.class,0);
		}
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public List<TerminalNode> XOR() { return getTokens(PlanBundleParser.XOR); }
		public TerminalNode XOR(int i) {
			return getToken(PlanBundleParser.XOR, i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public Expression_logical_xorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_logical_xor; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_xor(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_logical_xorContext expression_logical_xor() throws RecognitionException {
		Expression_logical_xorContext _localctx = new Expression_logical_xorContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_expression_logical_xor);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(383);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
			case 1:
				{
				setState(380);
				expression_logical_negation();
				}
				break;
			case 2:
				{
				setState(381);
				expression_logical_element();
				}
				break;
			case 3:
				{
				setState(382);
				expression_numeric();
				}
				break;
			}
			setState(389);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(385);
					match(XOR);
					setState(386);
					expression();
					}
					} 
				}
				setState(391);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_logical_elementContext extends ParserRuleContext {
		public TerminalNode LOGICALVALUE() { return getToken(PlanBundleParser.LOGICALVALUE, 0); }
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public Executable_actionContext executable_action() {
			return getRuleContext(Executable_actionContext.class,0);
		}
		public Executable_ruleContext executable_rule() {
			return getRuleContext(Executable_ruleContext.class,0);
		}
		public UnificationContext unification() {
			return getRuleContext(UnificationContext.class,0);
		}
		public Expression_logical_elementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_logical_element; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_element(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_logical_elementContext expression_logical_element() throws RecognitionException {
		Expression_logical_elementContext _localctx = new Expression_logical_elementContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_expression_logical_element);
		try {
			setState(397);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(392);
				match(LOGICALVALUE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(393);
				variable();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(394);
				executable_action();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(395);
				executable_rule();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(396);
				unification();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_logical_negationContext extends ParserRuleContext {
		public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public Expression_logical_negationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_logical_negation; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_logical_negation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_logical_negationContext expression_logical_negation() throws RecognitionException {
		Expression_logical_negationContext _localctx = new Expression_logical_negationContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_expression_logical_negation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(399);
			match(STRONGNEGATION);
			setState(400);
			expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numericContext extends ParserRuleContext {
		public Expression_numeric_relationContext expression_numeric_relation() {
			return getRuleContext(Expression_numeric_relationContext.class,0);
		}
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode EQUAL() { return getToken(PlanBundleParser.EQUAL, 0); }
		public TerminalNode NOTEQUAL() { return getToken(PlanBundleParser.NOTEQUAL, 0); }
		public Expression_numericContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numericContext expression_numeric() throws RecognitionException {
		Expression_numericContext _localctx = new Expression_numericContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_expression_numeric);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(402);
			expression_numeric_relation();
			setState(405);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				{
				setState(403);
				_la = _input.LA(1);
				if ( !(_la==EQUAL || _la==NOTEQUAL) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(404);
				expression_numeric();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numeric_relationContext extends ParserRuleContext {
		public Expression_numeric_additiveContext expression_numeric_additive() {
			return getRuleContext(Expression_numeric_additiveContext.class,0);
		}
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode LESS() { return getToken(PlanBundleParser.LESS, 0); }
		public TerminalNode LESSEQUAL() { return getToken(PlanBundleParser.LESSEQUAL, 0); }
		public TerminalNode GREATER() { return getToken(PlanBundleParser.GREATER, 0); }
		public TerminalNode GREATEREQUAL() { return getToken(PlanBundleParser.GREATEREQUAL, 0); }
		public Expression_numeric_relationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric_relation; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_relation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numeric_relationContext expression_numeric_relation() throws RecognitionException {
		Expression_numeric_relationContext _localctx = new Expression_numeric_relationContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_expression_numeric_relation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(407);
			expression_numeric_additive();
			setState(410);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
			case 1:
				{
				setState(408);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS) | (1L << LESSEQUAL) | (1L << GREATER) | (1L << GREATEREQUAL))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(409);
				expression_numeric();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numeric_additiveContext extends ParserRuleContext {
		public Expression_numeric_multiplicativeContext expression_numeric_multiplicative() {
			return getRuleContext(Expression_numeric_multiplicativeContext.class,0);
		}
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode PLUS() { return getToken(PlanBundleParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
		public Expression_numeric_additiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric_additive; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_additive(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numeric_additiveContext expression_numeric_additive() throws RecognitionException {
		Expression_numeric_additiveContext _localctx = new Expression_numeric_additiveContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_expression_numeric_additive);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(412);
			expression_numeric_multiplicative();
			setState(415);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
			case 1:
				{
				setState(413);
				_la = _input.LA(1);
				if ( !(_la==PLUS || _la==MINUS) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(414);
				expression_numeric();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numeric_multiplicativeContext extends ParserRuleContext {
		public Expression_numeric_powerContext expression_numeric_power() {
			return getRuleContext(Expression_numeric_powerContext.class,0);
		}
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode SLASH() { return getToken(PlanBundleParser.SLASH, 0); }
		public TerminalNode MODULO() { return getToken(PlanBundleParser.MODULO, 0); }
		public TerminalNode MULTIPLY() { return getToken(PlanBundleParser.MULTIPLY, 0); }
		public Expression_numeric_multiplicativeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric_multiplicative; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_multiplicative(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numeric_multiplicativeContext expression_numeric_multiplicative() throws RecognitionException {
		Expression_numeric_multiplicativeContext _localctx = new Expression_numeric_multiplicativeContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_expression_numeric_multiplicative);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(417);
			expression_numeric_power();
			setState(420);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
			case 1:
				{
				setState(418);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << MULTIPLY) | (1L << MODULO))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(419);
				expression_numeric();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numeric_powerContext extends ParserRuleContext {
		public Expression_numeric_elementContext expression_numeric_element() {
			return getRuleContext(Expression_numeric_elementContext.class,0);
		}
		public TerminalNode POW() { return getToken(PlanBundleParser.POW, 0); }
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public Expression_numeric_powerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric_power; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_power(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numeric_powerContext expression_numeric_power() throws RecognitionException {
		Expression_numeric_powerContext _localctx = new Expression_numeric_powerContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_expression_numeric_power);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(422);
			expression_numeric_element();
			setState(425);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==POW) {
				{
				setState(423);
				match(POW);
				setState(424);
				expression_numeric();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Expression_numeric_elementContext extends ParserRuleContext {
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public Executable_actionContext executable_action() {
			return getRuleContext(Executable_actionContext.class,0);
		}
		public Executable_ruleContext executable_rule() {
			return getRuleContext(Executable_ruleContext.class,0);
		}
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public Expression_numeric_elementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression_numeric_element; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExpression_numeric_element(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Expression_numeric_elementContext expression_numeric_element() throws RecognitionException {
		Expression_numeric_elementContext _localctx = new Expression_numeric_elementContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_expression_numeric_element);
		try {
			setState(435);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(427);
				number();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(428);
				variable();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(429);
				executable_action();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(430);
				executable_rule();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(431);
				match(LEFTROUNDBRACKET);
				setState(432);
				expression_numeric();
				setState(433);
				match(RIGHTROUNDBRACKET);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Executable_actionContext extends ParserRuleContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public Executable_actionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_executable_action; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_action(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Executable_actionContext executable_action() throws RecognitionException {
		Executable_actionContext _localctx = new Executable_actionContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_executable_action);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(437);
			literal();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Executable_ruleContext extends ParserRuleContext {
		public TerminalNode DOLLAR() { return getToken(PlanBundleParser.DOLLAR, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public Variable_evaluateContext variable_evaluate() {
			return getRuleContext(Variable_evaluateContext.class,0);
		}
		public Executable_ruleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_executable_rule; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitExecutable_rule(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Executable_ruleContext executable_rule() throws RecognitionException {
		Executable_ruleContext _localctx = new Executable_ruleContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_executable_rule);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(439);
			match(DOLLAR);
			setState(442);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				{
				setState(440);
				literal();
				}
				break;
			case 2:
				{
				setState(441);
				variable_evaluate();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Variable_evaluateContext extends ParserRuleContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public TermlistContext termlist() {
			return getRuleContext(TermlistContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public Variable_evaluateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variable_evaluate; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable_evaluate(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Variable_evaluateContext variable_evaluate() throws RecognitionException {
		Variable_evaluateContext _localctx = new Variable_evaluateContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_variable_evaluate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(444);
			variable();
			setState(449);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTROUNDBRACKET) {
				{
				setState(445);
				match(LEFTROUNDBRACKET);
				setState(446);
				termlist();
				setState(447);
				match(RIGHTROUNDBRACKET);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LiteralContext extends ParserRuleContext {
		public AtomContext atom() {
			return getRuleContext(AtomContext.class,0);
		}
		public TerminalNode LEFTROUNDBRACKET() { return getToken(PlanBundleParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(PlanBundleParser.RIGHTROUNDBRACKET, 0); }
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public TerminalNode STRONGNEGATION() { return getToken(PlanBundleParser.STRONGNEGATION, 0); }
		public TermlistContext termlist() {
			return getRuleContext(TermlistContext.class,0);
		}
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_literal);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(452);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STRONGNEGATION || _la==AT) {
				{
				setState(451);
				_la = _input.LA(1);
				if ( !(_la==STRONGNEGATION || _la==AT) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(454);
			atom();
			setState(460);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTROUNDBRACKET) {
				{
				setState(455);
				match(LEFTROUNDBRACKET);
				setState(457);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << LOGICALVALUE) | (1L << CONSTANTNUMBER) | (1L << STRONGNEGATION) | (1L << MINUS) | (1L << DOLLAR) | (1L << AT) | (1L << UNDERSCORE) | (1L << LEFTROUNDBRACKET) | (1L << LEFTANGULARBRACKET) | (1L << RIGHTSHIFT) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) {
					{
					setState(456);
					termlist();
					}
				}

				setState(459);
				match(RIGHTROUNDBRACKET);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TermlistContext extends ParserRuleContext {
		public List<TermContext> term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(PlanBundleParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(PlanBundleParser.COMMA, i);
		}
		public TermlistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_termlist; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitTermlist(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermlistContext termlist() throws RecognitionException {
		TermlistContext _localctx = new TermlistContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_termlist);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(462);
			term();
			setState(467);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(463);
				match(COMMA);
				setState(464);
				term();
				}
				}
				setState(469);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariablelistContext extends ParserRuleContext {
		public TerminalNode LEFTANGULARBRACKET() { return getToken(PlanBundleParser.LEFTANGULARBRACKET, 0); }
		public List<VariableContext> variable() {
			return getRuleContexts(VariableContext.class);
		}
		public VariableContext variable(int i) {
			return getRuleContext(VariableContext.class,i);
		}
		public TerminalNode RIGHTANGULARBRACKET() { return getToken(PlanBundleParser.RIGHTANGULARBRACKET, 0); }
		public List<TerminalNode> VLINE() { return getTokens(PlanBundleParser.VLINE); }
		public TerminalNode VLINE(int i) {
			return getToken(PlanBundleParser.VLINE, i);
		}
		public VariablelistContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variablelist; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariablelist(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariablelistContext variablelist() throws RecognitionException {
		VariablelistContext _localctx = new VariablelistContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_variablelist);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(470);
			match(LEFTANGULARBRACKET);
			setState(471);
			variable();
			setState(476);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==VLINE) {
				{
				{
				setState(472);
				match(VLINE);
				setState(473);
				variable();
				}
				}
				setState(478);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(479);
			match(RIGHTANGULARBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AtomContext extends ParserRuleContext {
		public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
		public TerminalNode LOWERCASELETTER(int i) {
			return getToken(PlanBundleParser.LOWERCASELETTER, i);
		}
		public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
		public TerminalNode UPPERCASELETTER(int i) {
			return getToken(PlanBundleParser.UPPERCASELETTER, i);
		}
		public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(PlanBundleParser.DIGIT, i);
		}
		public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(PlanBundleParser.SLASH, i);
		}
		public List<TerminalNode> MINUS() { return getTokens(PlanBundleParser.MINUS); }
		public TerminalNode MINUS(int i) {
			return getToken(PlanBundleParser.MINUS, i);
		}
		public AtomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_atom; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitAtom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AtomContext atom() throws RecognitionException {
		AtomContext _localctx = new AtomContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_atom);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(481);
			match(LOWERCASELETTER);
			setState(485);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(482);
					_la = _input.LA(1);
					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MINUS) | (1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					} 
				}
				setState(487);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariableContext extends ParserRuleContext {
		public VariableatomContext variableatom() {
			return getRuleContext(VariableatomContext.class,0);
		}
		public TerminalNode AT() { return getToken(PlanBundleParser.AT, 0); }
		public VariableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variable; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableContext variable() throws RecognitionException {
		VariableContext _localctx = new VariableContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_variable);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(489);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AT) {
				{
				setState(488);
				match(AT);
				}
			}

			setState(491);
			variableatom();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariableatomContext extends ParserRuleContext {
		public List<TerminalNode> UPPERCASELETTER() { return getTokens(PlanBundleParser.UPPERCASELETTER); }
		public TerminalNode UPPERCASELETTER(int i) {
			return getToken(PlanBundleParser.UPPERCASELETTER, i);
		}
		public TerminalNode UNDERSCORE() { return getToken(PlanBundleParser.UNDERSCORE, 0); }
		public List<TerminalNode> LOWERCASELETTER() { return getTokens(PlanBundleParser.LOWERCASELETTER); }
		public TerminalNode LOWERCASELETTER(int i) {
			return getToken(PlanBundleParser.LOWERCASELETTER, i);
		}
		public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(PlanBundleParser.DIGIT, i);
		}
		public List<TerminalNode> SLASH() { return getTokens(PlanBundleParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(PlanBundleParser.SLASH, i);
		}
		public VariableatomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableatom; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitVariableatom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableatomContext variableatom() throws RecognitionException {
		VariableatomContext _localctx = new VariableatomContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_variableatom);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(493);
			_la = _input.LA(1);
			if ( !(_la==UNDERSCORE || _la==UPPERCASELETTER) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(497);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(494);
					_la = _input.LA(1);
					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SLASH) | (1L << LOWERCASELETTER) | (1L << UPPERCASELETTER) | (1L << DIGIT))) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					} 
				}
				setState(499);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NumberContext extends ParserRuleContext {
		public TerminalNode CONSTANTNUMBER() { return getToken(PlanBundleParser.CONSTANTNUMBER, 0); }
		public DigitsequenceContext digitsequence() {
			return getRuleContext(DigitsequenceContext.class,0);
		}
		public TerminalNode MINUS() { return getToken(PlanBundleParser.MINUS, 0); }
		public NumberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_number; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitNumber(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NumberContext number() throws RecognitionException {
		NumberContext _localctx = new NumberContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_number);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(501);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==MINUS) {
				{
				setState(500);
				match(MINUS);
				}
			}

			setState(505);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CONSTANTNUMBER:
				{
				setState(503);
				match(CONSTANTNUMBER);
				}
				break;
			case DIGIT:
				{
				setState(504);
				digitsequence();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DigitsequenceContext extends ParserRuleContext {
		public List<TerminalNode> DIGIT() { return getTokens(PlanBundleParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(PlanBundleParser.DIGIT, i);
		}
		public TerminalNode DOT() { return getToken(PlanBundleParser.DOT, 0); }
		public DigitsequenceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_digitsequence; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof PlanBundleVisitor ) return ((PlanBundleVisitor<? extends T>)visitor).visitDigitsequence(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DigitsequenceContext digitsequence() throws RecognitionException {
		DigitsequenceContext _localctx = new DigitsequenceContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_digitsequence);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(508); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(507);
				match(DIGIT);
				}
				}
				setState(510); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==DIGIT );
			setState(518);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
			case 1:
				{
				setState(512);
				match(DOT);
				setState(514); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(513);
					match(DIGIT);
					}
					}
					setState(516); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==DIGIT );
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\38\u020b\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\3\2\7\2~\n\2\f\2\16\2\u0081\13\2\3\2\5\2\u0084\n\2\3\2\3\2\3\3"+
		"\3\3\3\3\3\4\6\4\u008c\n\4\r\4\16\4\u008d\3\5\6\5\u0091\n\5\r\5\16\5\u0092"+
		"\3\6\5\6\u0096\n\6\3\6\3\6\3\6\7\6\u009b\n\6\f\6\16\6\u009e\13\6\3\6\3"+
		"\6\3\7\3\7\5\7\u00a4\n\7\3\7\3\7\3\7\3\b\5\b\u00aa\n\b\3\b\3\b\6\b\u00ae"+
		"\n\b\r\b\16\b\u00af\3\b\3\b\3\t\3\t\3\t\3\n\3\n\6\n\u00b9\n\n\r\n\16\n"+
		"\u00ba\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00c9\n"+
		"\r\3\r\3\r\3\16\3\16\5\16\u00cf\n\16\3\17\3\17\3\17\3\20\3\20\3\21\3\21"+
		"\3\21\7\21\u00d9\n\21\f\21\16\21\u00dc\13\21\3\22\3\22\3\22\3\22\3\22"+
		"\3\22\3\22\5\22\u00e5\n\22\3\23\3\23\3\23\5\23\u00ea\n\23\3\23\3\23\5"+
		"\23\u00ee\n\23\3\24\3\24\3\24\3\25\3\25\5\25\u00f5\n\25\3\25\3\25\3\26"+
		"\3\26\3\26\5\26\u00fc\n\26\3\27\3\27\3\27\3\27\5\27\u0102\n\27\3\30\3"+
		"\30\5\30\u0106\n\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\33\3\33"+
		"\3\33\3\34\3\34\3\34\3\34\5\34\u0117\n\34\3\35\3\35\3\35\3\35\3\35\5\35"+
		"\u011e\n\35\3\36\5\36\u0121\n\36\3\36\3\36\3\36\3\36\5\36\u0127\n\36\3"+
		"\36\3\36\3\36\3\37\3\37\3\37\5\37\u012f\n\37\3\37\3\37\3 \3 \3 \3!\3!"+
		"\3!\3!\3!\3!\3!\5!\u013d\n!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
		"\"\3\"\5\"\u014b\n\"\3#\5#\u014e\n#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0158\n"+
		"#\3$\3$\5$\u015c\n$\3%\3%\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\7(\u016c"+
		"\n(\f(\16(\u016f\13(\5(\u0171\n(\3)\3)\3)\3)\3*\3*\3*\7*\u017a\n*\f*\16"+
		"*\u017d\13*\3+\3+\3+\5+\u0182\n+\3+\3+\7+\u0186\n+\f+\16+\u0189\13+\3"+
		",\3,\3,\3,\3,\5,\u0190\n,\3-\3-\3-\3.\3.\3.\5.\u0198\n.\3/\3/\3/\5/\u019d"+
		"\n/\3\60\3\60\3\60\5\60\u01a2\n\60\3\61\3\61\3\61\5\61\u01a7\n\61\3\62"+
		"\3\62\3\62\5\62\u01ac\n\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63"+
		"\u01b6\n\63\3\64\3\64\3\65\3\65\3\65\5\65\u01bd\n\65\3\66\3\66\3\66\3"+
		"\66\3\66\5\66\u01c4\n\66\3\67\5\67\u01c7\n\67\3\67\3\67\3\67\5\67\u01cc"+
		"\n\67\3\67\5\67\u01cf\n\67\38\38\38\78\u01d4\n8\f8\168\u01d7\138\39\3"+
		"9\39\39\79\u01dd\n9\f9\169\u01e0\139\39\39\3:\3:\7:\u01e6\n:\f:\16:\u01e9"+
		"\13:\3;\5;\u01ec\n;\3;\3;\3<\3<\7<\u01f2\n<\f<\16<\u01f5\13<\3=\5=\u01f8"+
		"\n=\3=\3=\5=\u01fc\n=\3>\6>\u01ff\n>\r>\16>\u0200\3>\3>\6>\u0205\n>\r"+
		">\16>\u0206\5>\u0209\n>\3>\2\2?\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
		" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz\2\f\3\2!\"\3"+
		"\2\13\f\4\2\b\b\r\r\3\2./\3\2*-\4\2\30\30\61\62\4\2\t\t\23\23\5\2\f\f"+
		"\30\30\63\65\4\2\27\27\64\64\4\2\30\30\63\65\2\u0220\2\177\3\2\2\2\4\u0087"+
		"\3\2\2\2\6\u008b\3\2\2\2\b\u0090\3\2\2\2\n\u0095\3\2\2\2\f\u00a3\3\2\2"+
		"\2\16\u00a9\3\2\2\2\20\u00b3\3\2\2\2\22\u00b8\3\2\2\2\24\u00bc\3\2\2\2"+
		"\26\u00bf\3\2\2\2\30\u00c2\3\2\2\2\32\u00ce\3\2\2\2\34\u00d0\3\2\2\2\36"+
		"\u00d3\3\2\2\2 \u00d5\3\2\2\2\"\u00e4\3\2\2\2$\u00e9\3\2\2\2&\u00ef\3"+
		"\2\2\2(\u00f2\3\2\2\2*\u00f8\3\2\2\2,\u00fd\3\2\2\2.\u0105\3\2\2\2\60"+
		"\u0107\3\2\2\2\62\u010b\3\2\2\2\64\u010f\3\2\2\2\66\u0112\3\2\2\28\u011d"+
		"\3\2\2\2:\u0120\3\2\2\2<\u012b\3\2\2\2>\u0132\3\2\2\2@\u013c\3\2\2\2B"+
		"\u014a\3\2\2\2D\u014d\3\2\2\2F\u015b\3\2\2\2H\u015d\3\2\2\2J\u0161\3\2"+
		"\2\2L\u0164\3\2\2\2N\u0170\3\2\2\2P\u0172\3\2\2\2R\u0176\3\2\2\2T\u0181"+
		"\3\2\2\2V\u018f\3\2\2\2X\u0191\3\2\2\2Z\u0194\3\2\2\2\\\u0199\3\2\2\2"+
		"^\u019e\3\2\2\2`\u01a3\3\2\2\2b\u01a8\3\2\2\2d\u01b5\3\2\2\2f\u01b7\3"+
		"\2\2\2h\u01b9\3\2\2\2j\u01be\3\2\2\2l\u01c6\3\2\2\2n\u01d0\3\2\2\2p\u01d8"+
		"\3\2\2\2r\u01e3\3\2\2\2t\u01eb\3\2\2\2v\u01ef\3\2\2\2x\u01f7\3\2\2\2z"+
		"\u01fe\3\2\2\2|~\5\4\3\2}|\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\177\u0080"+
		"\3\2\2\2\u0080\u0083\3\2\2\2\u0081\177\3\2\2\2\u0082\u0084\5\b\5\2\u0083"+
		"\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0086\5\6"+
		"\4\2\u0086\3\3\2\2\2\u0087\u0088\5l\67\2\u0088\u0089\7\26\2\2\u0089\5"+
		"\3\2\2\2\u008a\u008c\5\n\6\2\u008b\u008a\3\2\2\2\u008c\u008d\3\2\2\2\u008d"+
		"\u008b\3\2\2\2\u008d\u008e\3\2\2\2\u008e\7\3\2\2\2\u008f\u0091\5\16\b"+
		"\2\u0090\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0093"+
		"\3\2\2\2\u0093\t\3\2\2\2\u0094\u0096\5\22\n\2\u0095\u0094\3\2\2\2\u0095"+
		"\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0098\5\32\16\2\u0098\u009c\5"+
		"l\67\2\u0099\u009b\5\f\7\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c"+
		"\u009a\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2"+
		"\2\2\u009f\u00a0\7\26\2\2\u00a0\13\3\2\2\2\u00a1\u00a2\7\24\2\2\u00a2"+
		"\u00a4\5N(\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a5\3\2\2"+
		"\2\u00a5\u00a6\7\20\2\2\u00a6\u00a7\5 \21\2\u00a7\r\3\2\2\2\u00a8\u00aa"+
		"\5\22\n\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2"+
		"\u00ab\u00ad\5l\67\2\u00ac\u00ae\5\20\t\2\u00ad\u00ac\3\2\2\2\u00ae\u00af"+
		"\3\2\2\2\u00af\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1"+
		"\u00b2\7\26\2\2\u00b2\17\3\2\2\2\u00b3\u00b4\7\22\2\2\u00b4\u00b5\5 \21"+
		"\2\u00b5\21\3\2\2\2\u00b6\u00b9\5\24\13\2\u00b7\u00b9\5\26\f\2\u00b8\u00b6"+
		"\3\2\2\2\u00b8\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba"+
		"\u00bb\3\2\2\2\u00bb\23\3\2\2\2\u00bc\u00bd\7\23\2\2\u00bd\u00be\t\2\2"+
		"\2\u00be\25\3\2\2\2\u00bf\u00c0\7\23\2\2\u00c0\u00c1\5\30\r\2\u00c1\27"+
		"\3\2\2\2\u00c2\u00c3\7#\2\2\u00c3\u00c4\7\31\2\2\u00c4\u00c5\5v<\2\u00c5"+
		"\u00c8\7\n\2\2\u00c6\u00c9\5x=\2\u00c7\u00c9\7\5\2\2\u00c8\u00c6\3\2\2"+
		"\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\7\32\2\2\u00cb"+
		"\31\3\2\2\2\u00cc\u00cf\5\36\20\2\u00cd\u00cf\5\34\17\2\u00ce\u00cc\3"+
		"\2\2\2\u00ce\u00cd\3\2\2\2\u00cf\33\3\2\2\2\u00d0\u00d1\t\3\2\2\u00d1"+
		"\u00d2\7\b\2\2\u00d2\35\3\2\2\2\u00d3\u00d4\t\3\2\2\u00d4\37\3\2\2\2\u00d5"+
		"\u00da\5\"\22\2\u00d6\u00d7\7\25\2\2\u00d7\u00d9\5\"\22\2\u00d8\u00d6"+
		"\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db"+
		"!\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00e5\5$\23\2\u00de\u00e5\5&\24\2"+
		"\u00df\u00e5\5,\27\2\u00e0\u00e5\5.\30\2\u00e1\u00e5\5\64\33\2\u00e2\u00e5"+
		"\5\66\34\2\u00e3\u00e5\5:\36\2\u00e4\u00dd\3\2\2\2\u00e4\u00de\3\2\2\2"+
		"\u00e4\u00df\3\2\2\2\u00e4\u00e0\3\2\2\2\u00e4\u00e1\3\2\2\2\u00e4\u00e2"+
		"\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5#\3\2\2\2\u00e6\u00ea\5@!\2\u00e7\u00ea"+
		"\5(\25\2\u00e8\u00ea\5*\26\2\u00e9\u00e6\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9"+
		"\u00e8\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00ec\7\37\2\2\u00ec\u00ee\5"+
		"$\23\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee%\3\2\2\2\u00ef\u00f0"+
		"\t\3\2\2\u00f0\u00f1\5l\67\2\u00f1\'\3\2\2\2\u00f2\u00f4\7\16\2\2\u00f3"+
		"\u00f5\7\17\2\2\u00f4\u00f3\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3"+
		"\2\2\2\u00f6\u00f7\5r:\2\u00f7)\3\2\2\2\u00f8\u00fb\t\4\2\2\u00f9\u00fc"+
		"\5l\67\2\u00fa\u00fc\5j\66\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc"+
		"+\3\2\2\2\u00fd\u00fe\5p9\2\u00fe\u0101\7)\2\2\u00ff\u0102\5l\67\2\u0100"+
		"\u0102\5t;\2\u0101\u00ff\3\2\2\2\u0101\u0100\3\2\2\2\u0102-\3\2\2\2\u0103"+
		"\u0106\5\60\31\2\u0104\u0106\5\62\32\2\u0105\u0103\3\2\2\2\u0105\u0104"+
		"\3\2\2\2\u0106/\3\2\2\2\u0107\u0108\5t;\2\u0108\u0109\7(\2\2\u0109\u010a"+
		"\5@!\2\u010a\61\3\2\2\2\u010b\u010c\5p9\2\u010c\u010d\7(\2\2\u010d\u010e"+
		"\5@!\2\u010e\63\3\2\2\2\u010f\u0110\5t;\2\u0110\u0111\7\4\2\2\u0111\65"+
		"\3\2\2\2\u0112\u0113\5t;\2\u0113\u0116\7\3\2\2\u0114\u0117\5t;\2\u0115"+
		"\u0117\5x=\2\u0116\u0114\3\2\2\2\u0116\u0115\3\2\2\2\u0117\67\3\2\2\2"+
		"\u0118\u0119\7\35\2\2\u0119\u011a\5 \21\2\u011a\u011b\7\36\2\2\u011b\u011e"+
		"\3\2\2\2\u011c\u011e\5\"\22\2\u011d\u0118\3\2\2\2\u011d\u011c\3\2\2\2"+
		"\u011e9\3\2\2\2\u011f\u0121\7\23\2\2\u0120\u011f\3\2\2\2\u0120\u0121\3"+
		"\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123\5<\37\2\u0123\u0124\7\21\2\2\u0124"+
		"\u0126\5t;\2\u0125\u0127\5> \2\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2"+
		"\u0127\u0128\3\2\2\2\u0128\u0129\7\24\2\2\u0129\u012a\58\35\2\u012a;\3"+
		"\2\2\2\u012b\u012e\7\31\2\2\u012c\u012f\5t;\2\u012d\u012f\5l\67\2\u012e"+
		"\u012c\3\2\2\2\u012e\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\7\32"+
		"\2\2\u0131=\3\2\2\2\u0132\u0133\7$\2\2\u0133\u0134\5t;\2\u0134?\3\2\2"+
		"\2\u0135\u013d\7\5\2\2\u0136\u013d\5x=\2\u0137\u013d\7\6\2\2\u0138\u013d"+
		"\5f\64\2\u0139\u013d\5h\65\2\u013a\u013d\5N(\2\u013b\u013d\5H%\2\u013c"+
		"\u0135\3\2\2\2\u013c\u0136\3\2\2\2\u013c\u0137\3\2\2\2\u013c\u0138\3\2"+
		"\2\2\u013c\u0139\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013b\3\2\2\2\u013d"+
		"A\3\2\2\2\u013e\u014b\7\5\2\2\u013f\u014b\5x=\2\u0140\u014b\7\6\2\2\u0141"+
		"\u014b\5l\67\2\u0142\u014b\5t;\2\u0143\u014b\5p9\2\u0144\u0145\7\33\2"+
		"\2\u0145\u0146\5n8\2\u0146\u0147\7\34\2\2\u0147\u014b\3\2\2\2\u0148\u014b"+
		"\5N(\2\u0149\u014b\5H%\2\u014a\u013e\3\2\2\2\u014a\u013f\3\2\2\2\u014a"+
		"\u0140\3\2\2\2\u014a\u0141\3\2\2\2\u014a\u0142\3\2\2\2\u014a\u0143\3\2"+
		"\2\2\u014a\u0144\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u0149\3\2\2\2\u014b"+
		"C\3\2\2\2\u014c\u014e\7\23\2\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2"+
		"\u014e\u014f\3\2\2\2\u014f\u0157\7 \2\2\u0150\u0158\5l\67\2\u0151\u0152"+
		"\7\31\2\2\u0152\u0153\5l\67\2\u0153\u0154\7\n\2\2\u0154\u0155\5F$\2\u0155"+
		"\u0156\7\32\2\2\u0156\u0158\3\2\2\2\u0157\u0150\3\2\2\2\u0157\u0151\3"+
		"\2\2\2\u0158E\3\2\2\2\u0159\u015c\5t;\2\u015a\u015c\5N(\2\u015b\u0159"+
		"\3\2\2\2\u015b\u015a\3\2\2\2\u015cG\3\2\2\2\u015d\u015e\5N(\2\u015e\u015f"+
		"\5J&\2\u015f\u0160\5L\'\2\u0160I\3\2\2\2\u0161\u0162\7\16\2\2\u0162\u0163"+
		"\5@!\2\u0163K\3\2\2\2\u0164\u0165\7\24\2\2\u0165\u0166\5@!\2\u0166M\3"+
		"\2\2\2\u0167\u0171\5P)\2\u0168\u016d\5R*\2\u0169\u016a\7&\2\2\u016a\u016c"+
		"\5N(\2\u016b\u0169\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d"+
		"\u016e\3\2\2\2\u016e\u0171\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0167\3\2"+
		"\2\2\u0170\u0168\3\2\2\2\u0171O\3\2\2\2\u0172\u0173\7\31\2\2\u0173\u0174"+
		"\5N(\2\u0174\u0175\7\32\2\2\u0175Q\3\2\2\2\u0176\u017b\5T+\2\u0177\u0178"+
		"\7%\2\2\u0178\u017a\5N(\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2\u017b"+
		"\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017cS\3\2\2\2\u017d\u017b\3\2\2\2"+
		"\u017e\u0182\5X-\2\u017f\u0182\5V,\2\u0180\u0182\5Z.\2\u0181\u017e\3\2"+
		"\2\2\u0181\u017f\3\2\2\2\u0181\u0180\3\2\2\2\u0182\u0187\3\2\2\2\u0183"+
		"\u0184\7\'\2\2\u0184\u0186\5N(\2\u0185\u0183\3\2\2\2\u0186\u0189\3\2\2"+
		"\2\u0187\u0185\3\2\2\2\u0187\u0188\3\2\2\2\u0188U\3\2\2\2\u0189\u0187"+
		"\3\2\2\2\u018a\u0190\7\6\2\2\u018b\u0190\5t;\2\u018c\u0190\5f\64\2\u018d"+
		"\u0190\5h\65\2\u018e\u0190\5D#\2\u018f\u018a\3\2\2\2\u018f\u018b\3\2\2"+
		"\2\u018f\u018c\3\2\2\2\u018f\u018d\3\2\2\2\u018f\u018e\3\2\2\2\u0190W"+
		"\3\2\2\2\u0191\u0192\7\t\2\2\u0192\u0193\5N(\2\u0193Y\3\2\2\2\u0194\u0197"+
		"\5\\/\2\u0195\u0196\t\5\2\2\u0196\u0198\5Z.\2\u0197\u0195\3\2\2\2\u0197"+
		"\u0198\3\2\2\2\u0198[\3\2\2\2\u0199\u019c\5^\60\2\u019a\u019b\t\6\2\2"+
		"\u019b\u019d\5Z.\2\u019c\u019a\3\2\2\2\u019c\u019d\3\2\2\2\u019d]\3\2"+
		"\2\2\u019e\u01a1\5`\61\2\u019f\u01a0\t\3\2\2\u01a0\u01a2\5Z.\2\u01a1\u019f"+
		"\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2_\3\2\2\2\u01a3\u01a6\5b\62\2\u01a4"+
		"\u01a5\t\7\2\2\u01a5\u01a7\5Z.\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2"+
		"\2\u01a7a\3\2\2\2\u01a8\u01ab\5d\63\2\u01a9\u01aa\7\60\2\2\u01aa\u01ac"+
		"\5Z.\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01acc\3\2\2\2\u01ad\u01b6"+
		"\5x=\2\u01ae\u01b6\5t;\2\u01af\u01b6\5f\64\2\u01b0\u01b6\5h\65\2\u01b1"+
		"\u01b2\7\31\2\2\u01b2\u01b3\5Z.\2\u01b3\u01b4\7\32\2\2\u01b4\u01b6\3\2"+
		"\2\2\u01b5\u01ad\3\2\2\2\u01b5\u01ae\3\2\2\2\u01b5\u01af\3\2\2\2\u01b5"+
		"\u01b0\3\2\2\2\u01b5\u01b1\3\2\2\2\u01b6e\3\2\2\2\u01b7\u01b8\5l\67\2"+
		"\u01b8g\3\2\2\2\u01b9\u01bc\7\17\2\2\u01ba\u01bd\5l\67\2\u01bb\u01bd\5"+
		"j\66\2\u01bc\u01ba\3\2\2\2\u01bc\u01bb\3\2\2\2\u01bdi\3\2\2\2\u01be\u01c3"+
		"\5t;\2\u01bf\u01c0\7\31\2\2\u01c0\u01c1\5n8\2\u01c1\u01c2\7\32\2\2\u01c2"+
		"\u01c4\3\2\2\2\u01c3\u01bf\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4k\3\2\2\2"+
		"\u01c5\u01c7\t\b\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8"+
		"\3\2\2\2\u01c8\u01ce\5r:\2\u01c9\u01cb\7\31\2\2\u01ca\u01cc\5n8\2\u01cb"+
		"\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01cf\7\32"+
		"\2\2\u01ce\u01c9\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cfm\3\2\2\2\u01d0\u01d5"+
		"\5B\"\2\u01d1\u01d2\7\n\2\2\u01d2\u01d4\5B\"\2\u01d3\u01d1\3\2\2\2\u01d4"+
		"\u01d7\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6o\3\2\2\2"+
		"\u01d7\u01d5\3\2\2\2\u01d8\u01d9\7\33\2\2\u01d9\u01de\5t;\2\u01da\u01db"+
		"\7$\2\2\u01db\u01dd\5t;\2\u01dc\u01da\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de"+
		"\u01dc\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01de\3\2"+
		"\2\2\u01e1\u01e2\7\34\2\2\u01e2q\3\2\2\2\u01e3\u01e7\7\63\2\2\u01e4\u01e6"+
		"\t\t\2\2\u01e5\u01e4\3\2\2\2\u01e6\u01e9\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7"+
		"\u01e8\3\2\2\2\u01e8s\3\2\2\2\u01e9\u01e7\3\2\2\2\u01ea\u01ec\7\23\2\2"+
		"\u01eb\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee"+
		"\5v<\2\u01eeu\3\2\2\2\u01ef\u01f3\t\n\2\2\u01f0\u01f2\t\13\2\2\u01f1\u01f0"+
		"\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4"+
		"w\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f8\7\f\2\2\u01f7\u01f6\3\2\2\2"+
		"\u01f7\u01f8\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9\u01fc\7\7\2\2\u01fa\u01fc"+
		"\5z>\2\u01fb\u01f9\3\2\2\2\u01fb\u01fa\3\2\2\2\u01fcy\3\2\2\2\u01fd\u01ff"+
		"\7\65\2\2\u01fe\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u01fe\3\2\2\2"+
		"\u0200\u0201\3\2\2\2\u0201\u0208\3\2\2\2\u0202\u0204\7\26\2\2\u0203\u0205"+
		"\7\65\2\2\u0204\u0203\3\2\2\2\u0205\u0206\3\2\2\2\u0206\u0204\3\2\2\2"+
		"\u0206\u0207\3\2\2\2\u0207\u0209\3\2\2\2\u0208\u0202\3\2\2\2\u0208\u0209"+
		"\3\2\2\2\u0209{\3\2\2\2<\177\u0083\u008d\u0092\u0095\u009c\u00a3\u00a9"+
		"\u00af\u00b8\u00ba\u00c8\u00ce\u00da\u00e4\u00e9\u00ed\u00f4\u00fb\u0101"+
		"\u0105\u0116\u011d\u0120\u0126\u012e\u013c\u014a\u014d\u0157\u015b\u016d"+
		"\u0170\u017b\u0181\u0187\u018f\u0197\u019c\u01a1\u01a6\u01ab\u01b5\u01bc"+
		"\u01c3\u01c6\u01cb\u01ce\u01d5\u01de\u01e7\u01eb\u01f3\u01f7\u01fb\u0200"+
		"\u0206\u0208";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}