AgentParser.java

// Generated from org/lightjason/agentspeak/grammar/Agent.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 AgentParser 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_agent = 0, RULE_initial_beliefs = 1, RULE_initial_goal = 2, RULE_belief = 3, 
		RULE_plans = 4, RULE_logicrules = 5, RULE_plan = 6, RULE_plandefinition = 7, 
		RULE_logicrule = 8, RULE_logicalruledefinition = 9, RULE_annotations = 10, 
		RULE_annotation_atom = 11, RULE_annotation_literal = 12, RULE_annotation_value_literal = 13, 
		RULE_plan_trigger = 14, RULE_plan_goal_trigger = 15, RULE_plan_belief_trigger = 16, 
		RULE_body = 17, RULE_body_formula = 18, RULE_repair_formula = 19, RULE_belief_action = 20, 
		RULE_test_action = 21, RULE_achievement_goal_action = 22, RULE_deconstruct_expression = 23, 
		RULE_assignment_expression = 24, RULE_assignment_expression_singlevariable = 25, 
		RULE_assignment_expression_multivariable = 26, RULE_unary_expression = 27, 
		RULE_binary_expression = 28, RULE_block_formula = 29, RULE_lambda = 30, 
		RULE_lambda_initialization = 31, RULE_lambda_return = 32, RULE_executable_term = 33, 
		RULE_term = 34, RULE_unification = 35, RULE_unification_constraint = 36, 
		RULE_ternary_operation = 37, RULE_ternary_operation_true = 38, RULE_ternary_operation_false = 39, 
		RULE_expression = 40, RULE_expression_bracket = 41, RULE_expression_logical_and = 42, 
		RULE_expression_logical_xor = 43, RULE_expression_logical_element = 44, 
		RULE_expression_logical_negation = 45, RULE_expression_numeric = 46, RULE_expression_numeric_relation = 47, 
		RULE_expression_numeric_additive = 48, RULE_expression_numeric_multiplicative = 49, 
		RULE_expression_numeric_power = 50, RULE_expression_numeric_element = 51, 
		RULE_executable_action = 52, RULE_executable_rule = 53, RULE_variable_evaluate = 54, 
		RULE_literal = 55, RULE_termlist = 56, RULE_variablelist = 57, RULE_atom = 58, 
		RULE_variable = 59, RULE_variableatom = 60, RULE_number = 61, RULE_digitsequence = 62;
	public static final String[] ruleNames = {
		"agent", "initial_beliefs", "initial_goal", "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 "Agent.g4"; }

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

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

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

	public AgentParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class AgentContext extends ParserRuleContext {
		public PlansContext plans() {
			return getRuleContext(PlansContext.class,0);
		}
		public Initial_beliefsContext initial_beliefs() {
			return getRuleContext(Initial_beliefsContext.class,0);
		}
		public Initial_goalContext initial_goal() {
			return getRuleContext(Initial_goalContext.class,0);
		}
		public LogicrulesContext logicrules() {
			return getRuleContext(LogicrulesContext.class,0);
		}
		public AgentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_agent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitAgent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AgentContext agent() throws RecognitionException {
		AgentContext _localctx = new AgentContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_agent);
		int _la;
		try {
			setState(137);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case EOF:
				enterOuterAlt(_localctx, 1);
				{
				}
				break;
			case EXCLAMATIONMARK:
			case STRONGNEGATION:
			case PLUS:
			case MINUS:
			case AT:
			case LOWERCASELETTER:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(128);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
				case 1:
					{
					setState(127);
					initial_beliefs();
					}
					break;
				}
				setState(131);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==EXCLAMATIONMARK) {
					{
					setState(130);
					initial_goal();
					}
				}

				setState(134);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
				case 1:
					{
					setState(133);
					logicrules();
					}
					break;
				}
				setState(136);
				plans();
				}
				}
				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 Initial_beliefsContext extends ParserRuleContext {
		public List<BeliefContext> belief() {
			return getRuleContexts(BeliefContext.class);
		}
		public BeliefContext belief(int i) {
			return getRuleContext(BeliefContext.class,i);
		}
		public Initial_beliefsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initial_beliefs; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitInitial_beliefs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Initial_beliefsContext initial_beliefs() throws RecognitionException {
		Initial_beliefsContext _localctx = new Initial_beliefsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_initial_beliefs);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(140); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(139);
					belief();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(142); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,4,_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 Initial_goalContext extends ParserRuleContext {
		public TerminalNode EXCLAMATIONMARK() { return getToken(AgentParser.EXCLAMATIONMARK, 0); }
		public AtomContext atom() {
			return getRuleContext(AtomContext.class,0);
		}
		public TerminalNode DOT() { return getToken(AgentParser.DOT, 0); }
		public Initial_goalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_initial_goal; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitInitial_goal(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Initial_goalContext initial_goal() throws RecognitionException {
		Initial_goalContext _localctx = new Initial_goalContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_initial_goal);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(144);
			match(EXCLAMATIONMARK);
			setState(145);
			atom();
			setState(146);
			match(DOT);
			}
		}
		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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitBelief(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BeliefContext belief() throws RecognitionException {
		BeliefContext _localctx = new BeliefContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_belief);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(148);
			literal();
			setState(149);
			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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitPlans(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlansContext plans() throws RecognitionException {
		PlansContext _localctx = new PlansContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_plans);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(152); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(151);
				plan();
				}
				}
				setState(154); 
				_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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitLogicrules(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicrulesContext logicrules() throws RecognitionException {
		LogicrulesContext _localctx = new LogicrulesContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_logicrules);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(157); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(156);
					logicrule();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(159); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,6,_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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitPlan(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(164);
			plan_trigger();
			setState(165);
			literal();
			setState(169);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LEFTARROW || _la==COLON) {
				{
				{
				setState(166);
				plandefinition();
				}
				}
				setState(171);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(172);
			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(AgentParser.LEFTARROW, 0); }
		public BodyContext body() {
			return getRuleContext(BodyContext.class,0);
		}
		public TerminalNode COLON() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitPlandefinition(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(178);
			match(LEFTARROW);
			setState(179);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitLogicrule(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicruleContext logicrule() throws RecognitionException {
		LogicruleContext _localctx = new LogicruleContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_logicrule);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(182);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				{
				setState(181);
				annotations();
				}
				break;
			}
			setState(184);
			literal();
			setState(186); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(185);
				logicalruledefinition();
				}
				}
				setState(188); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==RULEOPERATOR );
			setState(190);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitLogicalruledefinition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicalruledefinitionContext logicalruledefinition() throws RecognitionException {
		LogicalruledefinitionContext _localctx = new LogicalruledefinitionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_logicalruledefinition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			match(RULEOPERATOR);
			setState(193);
			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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitAnnotations(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AnnotationsContext annotations() throws RecognitionException {
		AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_annotations);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(197); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					setState(197);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
					case 1:
						{
						setState(195);
						annotation_atom();
						}
						break;
					case 2:
						{
						setState(196);
						annotation_literal();
						}
						break;
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(199); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,13,_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(AgentParser.AT, 0); }
		public TerminalNode ATOMIC() { return getToken(AgentParser.ATOMIC, 0); }
		public TerminalNode PARALLEL() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 22, RULE_annotation_atom);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(201);
			match(AT);
			setState(202);
			_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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 24, RULE_annotation_literal);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(204);
			match(AT);
			setState(205);
			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(AgentParser.CONSTANT, 0); }
		public TerminalNode LEFTROUNDBRACKET() { return getToken(AgentParser.LEFTROUNDBRACKET, 0); }
		public VariableatomContext variableatom() {
			return getRuleContext(VariableatomContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(AgentParser.COMMA, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.RIGHTROUNDBRACKET, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode STRING() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 26, RULE_annotation_value_literal);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(207);
			match(CONSTANT);
			setState(208);
			match(LEFTROUNDBRACKET);
			setState(209);
			variableatom();
			setState(210);
			match(COMMA);
			setState(213);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CONSTANTNUMBER:
			case MINUS:
			case DIGIT:
				{
				setState(211);
				number();
				}
				break;
			case STRING:
				{
				setState(212);
				match(STRING);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(215);
			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 AgentVisitor ) return ((AgentVisitor<? 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, 28, RULE_plan_trigger);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(219);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				{
				setState(217);
				plan_belief_trigger();
				}
				break;
			case 2:
				{
				setState(218);
				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(AgentParser.EXCLAMATIONMARK, 0); }
		public TerminalNode PLUS() { return getToken(AgentParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 30, RULE_plan_goal_trigger);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(221);
			_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(222);
			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(AgentParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 32, RULE_plan_belief_trigger);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(224);
			_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(AgentParser.SEMICOLON); }
		public TerminalNode SEMICOLON(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BodyContext body() throws RecognitionException {
		BodyContext _localctx = new BodyContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_body);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(226);
			body_formula();
			setState(231);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SEMICOLON) {
				{
				{
				setState(227);
				match(SEMICOLON);
				setState(228);
				body_formula();
				}
				}
				setState(233);
				_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 AgentVisitor ) return ((AgentVisitor<? 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, 36, RULE_body_formula);
		try {
			setState(241);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(234);
				repair_formula();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(235);
				belief_action();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(236);
				deconstruct_expression();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(237);
				assignment_expression();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(238);
				unary_expression();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(239);
				binary_expression();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(240);
				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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 38, RULE_repair_formula);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246);
			_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(243);
				executable_term();
				}
				break;
			case QUESTIONMARK:
				{
				setState(244);
				test_action();
				}
				break;
			case EXCLAMATIONMARK:
			case DOUBLEEXCLAMATIONMARK:
				{
				setState(245);
				achievement_goal_action();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(250);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTSHIFT) {
				{
				setState(248);
				match(LEFTSHIFT);
				setState(249);
				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(AgentParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 40, RULE_belief_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(252);
			_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(253);
			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(AgentParser.QUESTIONMARK, 0); }
		public AtomContext atom() {
			return getRuleContext(AtomContext.class,0);
		}
		public TerminalNode DOLLAR() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 42, RULE_test_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(255);
			match(QUESTIONMARK);
			setState(257);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOLLAR) {
				{
				setState(256);
				match(DOLLAR);
				}
			}

			setState(259);
			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(AgentParser.EXCLAMATIONMARK, 0); }
		public TerminalNode DOUBLEEXCLAMATIONMARK() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 44, RULE_achievement_goal_action);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(261);
			_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(264);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(262);
				literal();
				}
				break;
			case 2:
				{
				setState(263);
				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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 46, RULE_deconstruct_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(266);
			variablelist();
			setState(267);
			match(DECONSTRUCT);
			setState(270);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
			case 1:
				{
				setState(268);
				literal();
				}
				break;
			case 2:
				{
				setState(269);
				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 AgentVisitor ) return ((AgentVisitor<? 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, 48, RULE_assignment_expression);
		try {
			setState(274);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AT:
			case UNDERSCORE:
			case UPPERCASELETTER:
				enterOuterAlt(_localctx, 1);
				{
				setState(272);
				assignment_expression_singlevariable();
				}
				break;
			case LEFTANGULARBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(273);
				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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 50, RULE_assignment_expression_singlevariable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(276);
			variable();
			setState(277);
			match(ASSIGN);
			setState(278);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 52, RULE_assignment_expression_multivariable);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(280);
			variablelist();
			setState(281);
			match(ASSIGN);
			setState(282);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 54, RULE_unary_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(284);
			variable();
			setState(285);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 56, RULE_binary_expression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			variable();
			setState(288);
			match(BINARYOPERATOR);
			setState(291);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AT:
			case UNDERSCORE:
			case UPPERCASELETTER:
				{
				setState(289);
				variable();
				}
				break;
			case CONSTANTNUMBER:
			case MINUS:
			case DIGIT:
				{
				setState(290);
				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(AgentParser.LEFTCURVEDBRACKET, 0); }
		public BodyContext body() {
			return getRuleContext(BodyContext.class,0);
		}
		public TerminalNode RIGHTCURVEDBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 58, RULE_block_formula);
		try {
			setState(298);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LEFTCURVEDBRACKET:
				enterOuterAlt(_localctx, 1);
				{
				setState(293);
				match(LEFTCURVEDBRACKET);
				setState(294);
				body();
				setState(295);
				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(297);
				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(AgentParser.RIGHTARROW, 0); }
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public TerminalNode COLON() { return getToken(AgentParser.COLON, 0); }
		public Block_formulaContext block_formula() {
			return getRuleContext(Block_formulaContext.class,0);
		}
		public TerminalNode AT() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitLambda(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(303);
			lambda_initialization();
			setState(304);
			match(RIGHTARROW);
			setState(305);
			variable();
			setState(307);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==VLINE) {
				{
				setState(306);
				lambda_return();
				}
			}

			setState(309);
			match(COLON);
			setState(310);
			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(AgentParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 62, RULE_lambda_initialization);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(312);
			match(LEFTROUNDBRACKET);
			setState(315);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
			case 1:
				{
				setState(313);
				variable();
				}
				break;
			case 2:
				{
				setState(314);
				literal();
				}
				break;
			}
			setState(317);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 64, RULE_lambda_return);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(319);
			match(VLINE);
			setState(320);
			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(AgentParser.STRING, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode LOGICALVALUE() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 66, RULE_executable_term);
		try {
			setState(329);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(322);
				match(STRING);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(323);
				number();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(324);
				match(LOGICALVALUE);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(325);
				executable_action();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(326);
				executable_rule();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(327);
				expression();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(328);
				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(AgentParser.STRING, 0); }
		public NumberContext number() {
			return getRuleContext(NumberContext.class,0);
		}
		public TerminalNode LOGICALVALUE() { return getToken(AgentParser.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(AgentParser.LEFTANGULARBRACKET, 0); }
		public TermlistContext termlist() {
			return getRuleContext(TermlistContext.class,0);
		}
		public TerminalNode RIGHTANGULARBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitTerm(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermContext term() throws RecognitionException {
		TermContext _localctx = new TermContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_term);
		try {
			setState(343);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(331);
				match(STRING);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(332);
				number();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(333);
				match(LOGICALVALUE);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(334);
				literal();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(335);
				variable();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(336);
				variablelist();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(337);
				match(LEFTANGULARBRACKET);
				setState(338);
				termlist();
				setState(339);
				match(RIGHTANGULARBRACKET);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(341);
				expression();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(342);
				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(AgentParser.RIGHTSHIFT, 0); }
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public TerminalNode LEFTROUNDBRACKET() { return getToken(AgentParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode COMMA() { return getToken(AgentParser.COMMA, 0); }
		public Unification_constraintContext unification_constraint() {
			return getRuleContext(Unification_constraintContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.RIGHTROUNDBRACKET, 0); }
		public TerminalNode AT() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitUnification(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(348);
			match(RIGHTSHIFT);
			setState(356);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRONGNEGATION:
			case AT:
			case LOWERCASELETTER:
				{
				setState(349);
				literal();
				}
				break;
			case LEFTROUNDBRACKET:
				{
				setState(350);
				match(LEFTROUNDBRACKET);
				setState(351);
				literal();
				setState(352);
				match(COMMA);
				setState(353);
				unification_constraint();
				setState(354);
				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 AgentVisitor ) return ((AgentVisitor<? 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, 72, RULE_unification_constraint);
		try {
			setState(360);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(358);
				variable();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(359);
				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 AgentVisitor ) return ((AgentVisitor<? 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, 74, RULE_ternary_operation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(362);
			expression();
			setState(363);
			ternary_operation_true();
			setState(364);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 76, RULE_ternary_operation_true);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(366);
			match(QUESTIONMARK);
			setState(367);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 78, RULE_ternary_operation_false);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			match(COLON);
			setState(370);
			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(AgentParser.OR); }
		public TerminalNode OR(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_expression);
		try {
			int _alt;
			setState(381);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(372);
				expression_bracket();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(373);
				expression_logical_and();
				setState(378);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(374);
						match(OR);
						setState(375);
						expression();
						}
						} 
					}
					setState(380);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,34,_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(AgentParser.LEFTROUNDBRACKET, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 82, RULE_expression_bracket);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(383);
			match(LEFTROUNDBRACKET);
			setState(384);
			expression();
			setState(385);
			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(AgentParser.AND); }
		public TerminalNode AND(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 84, RULE_expression_logical_and);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(387);
			expression_logical_xor();
			setState(392);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(388);
					match(AND);
					setState(389);
					expression();
					}
					} 
				}
				setState(394);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,36,_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(AgentParser.XOR); }
		public TerminalNode XOR(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 86, RULE_expression_logical_xor);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(398);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				{
				setState(395);
				expression_logical_negation();
				}
				break;
			case 2:
				{
				setState(396);
				expression_logical_element();
				}
				break;
			case 3:
				{
				setState(397);
				expression_numeric();
				}
				break;
			}
			setState(404);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(400);
					match(XOR);
					setState(401);
					expression();
					}
					} 
				}
				setState(406);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,38,_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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 88, RULE_expression_logical_element);
		try {
			setState(412);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(407);
				match(LOGICALVALUE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(408);
				variable();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(409);
				executable_action();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(410);
				executable_rule();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(411);
				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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 90, RULE_expression_logical_negation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(414);
			match(STRONGNEGATION);
			setState(415);
			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(AgentParser.EQUAL, 0); }
		public TerminalNode NOTEQUAL() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 92, RULE_expression_numeric);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(417);
			expression_numeric_relation();
			setState(420);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
			case 1:
				{
				setState(418);
				_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(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_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(AgentParser.LESS, 0); }
		public TerminalNode LESSEQUAL() { return getToken(AgentParser.LESSEQUAL, 0); }
		public TerminalNode GREATER() { return getToken(AgentParser.GREATER, 0); }
		public TerminalNode GREATEREQUAL() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 94, RULE_expression_numeric_relation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(422);
			expression_numeric_additive();
			setState(425);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				{
				setState(423);
				_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(424);
				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(AgentParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 96, RULE_expression_numeric_additive);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(427);
			expression_numeric_multiplicative();
			setState(430);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				{
				setState(428);
				_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(429);
				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(AgentParser.SLASH, 0); }
		public TerminalNode MODULO() { return getToken(AgentParser.MODULO, 0); }
		public TerminalNode MULTIPLY() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 98, RULE_expression_numeric_multiplicative);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(432);
			expression_numeric_power();
			setState(435);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				{
				setState(433);
				_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(434);
				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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 100, RULE_expression_numeric_power);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(437);
			expression_numeric_element();
			setState(440);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==POW) {
				{
				setState(438);
				match(POW);
				setState(439);
				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(AgentParser.LEFTROUNDBRACKET, 0); }
		public Expression_numericContext expression_numeric() {
			return getRuleContext(Expression_numericContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 102, RULE_expression_numeric_element);
		try {
			setState(450);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(442);
				number();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(443);
				variable();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(444);
				executable_action();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(445);
				executable_rule();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(446);
				match(LEFTROUNDBRACKET);
				setState(447);
				expression_numeric();
				setState(448);
				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 AgentVisitor ) return ((AgentVisitor<? 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, 104, RULE_executable_action);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(452);
			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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 106, RULE_executable_rule);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(454);
			match(DOLLAR);
			setState(457);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
			case 1:
				{
				setState(455);
				literal();
				}
				break;
			case 2:
				{
				setState(456);
				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(AgentParser.LEFTROUNDBRACKET, 0); }
		public TermlistContext termlist() {
			return getRuleContext(TermlistContext.class,0);
		}
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? 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, 108, RULE_variable_evaluate);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(459);
			variable();
			setState(464);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTROUNDBRACKET) {
				{
				setState(460);
				match(LEFTROUNDBRACKET);
				setState(461);
				termlist();
				setState(462);
				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(AgentParser.LEFTROUNDBRACKET, 0); }
		public TerminalNode RIGHTROUNDBRACKET() { return getToken(AgentParser.RIGHTROUNDBRACKET, 0); }
		public TerminalNode AT() { return getToken(AgentParser.AT, 0); }
		public TerminalNode STRONGNEGATION() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_literal);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(467);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STRONGNEGATION || _la==AT) {
				{
				setState(466);
				_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(469);
			atom();
			setState(475);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LEFTROUNDBRACKET) {
				{
				setState(470);
				match(LEFTROUNDBRACKET);
				setState(472);
				_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(471);
					termlist();
					}
				}

				setState(474);
				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(AgentParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitTermlist(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermlistContext termlist() throws RecognitionException {
		TermlistContext _localctx = new TermlistContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_termlist);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(477);
			term();
			setState(482);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(478);
				match(COMMA);
				setState(479);
				term();
				}
				}
				setState(484);
				_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(AgentParser.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(AgentParser.RIGHTANGULARBRACKET, 0); }
		public List<TerminalNode> VLINE() { return getTokens(AgentParser.VLINE); }
		public TerminalNode VLINE(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitVariablelist(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariablelistContext variablelist() throws RecognitionException {
		VariablelistContext _localctx = new VariablelistContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_variablelist);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(485);
			match(LEFTANGULARBRACKET);
			setState(486);
			variable();
			setState(491);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==VLINE) {
				{
				{
				setState(487);
				match(VLINE);
				setState(488);
				variable();
				}
				}
				setState(493);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(494);
			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(AgentParser.LOWERCASELETTER); }
		public TerminalNode LOWERCASELETTER(int i) {
			return getToken(AgentParser.LOWERCASELETTER, i);
		}
		public List<TerminalNode> UPPERCASELETTER() { return getTokens(AgentParser.UPPERCASELETTER); }
		public TerminalNode UPPERCASELETTER(int i) {
			return getToken(AgentParser.UPPERCASELETTER, i);
		}
		public List<TerminalNode> DIGIT() { return getTokens(AgentParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(AgentParser.DIGIT, i);
		}
		public List<TerminalNode> SLASH() { return getTokens(AgentParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(AgentParser.SLASH, i);
		}
		public List<TerminalNode> MINUS() { return getTokens(AgentParser.MINUS); }
		public TerminalNode MINUS(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitAtom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AtomContext atom() throws RecognitionException {
		AtomContext _localctx = new AtomContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_atom);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(496);
			match(LOWERCASELETTER);
			setState(500);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(497);
					_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(502);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,53,_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(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitVariable(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(506);
			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(AgentParser.UPPERCASELETTER); }
		public TerminalNode UPPERCASELETTER(int i) {
			return getToken(AgentParser.UPPERCASELETTER, i);
		}
		public TerminalNode UNDERSCORE() { return getToken(AgentParser.UNDERSCORE, 0); }
		public List<TerminalNode> LOWERCASELETTER() { return getTokens(AgentParser.LOWERCASELETTER); }
		public TerminalNode LOWERCASELETTER(int i) {
			return getToken(AgentParser.LOWERCASELETTER, i);
		}
		public List<TerminalNode> DIGIT() { return getTokens(AgentParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(AgentParser.DIGIT, i);
		}
		public List<TerminalNode> SLASH() { return getTokens(AgentParser.SLASH); }
		public TerminalNode SLASH(int i) {
			return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitVariableatom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableatomContext variableatom() throws RecognitionException {
		VariableatomContext _localctx = new VariableatomContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_variableatom);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(508);
			_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(512);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(509);
					_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(514);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,55,_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(AgentParser.CONSTANTNUMBER, 0); }
		public DigitsequenceContext digitsequence() {
			return getRuleContext(DigitsequenceContext.class,0);
		}
		public TerminalNode MINUS() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitNumber(this);
			else return visitor.visitChildren(this);
		}
	}

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

			setState(520);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CONSTANTNUMBER:
				{
				setState(518);
				match(CONSTANTNUMBER);
				}
				break;
			case DIGIT:
				{
				setState(519);
				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(AgentParser.DIGIT); }
		public TerminalNode DIGIT(int i) {
			return getToken(AgentParser.DIGIT, i);
		}
		public TerminalNode DOT() { return getToken(AgentParser.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 AgentVisitor ) return ((AgentVisitor<? extends T>)visitor).visitDigitsequence(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DigitsequenceContext digitsequence() throws RecognitionException {
		DigitsequenceContext _localctx = new DigitsequenceContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_digitsequence);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(523); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(522);
				match(DIGIT);
				}
				}
				setState(525); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==DIGIT );
			setState(533);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
			case 1:
				{
				setState(527);
				match(DOT);
				setState(529); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(528);
					match(DIGIT);
					}
					}
					setState(531); 
					_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\u021a\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>\4?\t?\4@\t@\3\2\3\2\5\2\u0083\n\2\3\2\5\2\u0086\n\2\3\2\5\2\u0089"+
		"\n\2\3\2\5\2\u008c\n\2\3\3\6\3\u008f\n\3\r\3\16\3\u0090\3\4\3\4\3\4\3"+
		"\4\3\5\3\5\3\5\3\6\6\6\u009b\n\6\r\6\16\6\u009c\3\7\6\7\u00a0\n\7\r\7"+
		"\16\7\u00a1\3\b\5\b\u00a5\n\b\3\b\3\b\3\b\7\b\u00aa\n\b\f\b\16\b\u00ad"+
		"\13\b\3\b\3\b\3\t\3\t\5\t\u00b3\n\t\3\t\3\t\3\t\3\n\5\n\u00b9\n\n\3\n"+
		"\3\n\6\n\u00bd\n\n\r\n\16\n\u00be\3\n\3\n\3\13\3\13\3\13\3\f\3\f\6\f\u00c8"+
		"\n\f\r\f\16\f\u00c9\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17"+
		"\3\17\5\17\u00d8\n\17\3\17\3\17\3\20\3\20\5\20\u00de\n\20\3\21\3\21\3"+
		"\21\3\22\3\22\3\23\3\23\3\23\7\23\u00e8\n\23\f\23\16\23\u00eb\13\23\3"+
		"\24\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u00f4\n\24\3\25\3\25\3\25\5\25"+
		"\u00f9\n\25\3\25\3\25\5\25\u00fd\n\25\3\26\3\26\3\26\3\27\3\27\5\27\u0104"+
		"\n\27\3\27\3\27\3\30\3\30\3\30\5\30\u010b\n\30\3\31\3\31\3\31\3\31\5\31"+
		"\u0111\n\31\3\32\3\32\5\32\u0115\n\32\3\33\3\33\3\33\3\33\3\34\3\34\3"+
		"\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\36\5\36\u0126\n\36\3\37\3\37"+
		"\3\37\3\37\3\37\5\37\u012d\n\37\3 \5 \u0130\n \3 \3 \3 \3 \5 \u0136\n"+
		" \3 \3 \3 \3!\3!\3!\5!\u013e\n!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3"+
		"#\5#\u014c\n#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\3$\5$\u015a\n$\3%\5%\u015d"+
		"\n%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u0167\n%\3&\3&\5&\u016b\n&\3\'\3\'\3\'"+
		"\3\'\3(\3(\3(\3)\3)\3)\3*\3*\3*\3*\7*\u017b\n*\f*\16*\u017e\13*\5*\u0180"+
		"\n*\3+\3+\3+\3+\3,\3,\3,\7,\u0189\n,\f,\16,\u018c\13,\3-\3-\3-\5-\u0191"+
		"\n-\3-\3-\7-\u0195\n-\f-\16-\u0198\13-\3.\3.\3.\3.\3.\5.\u019f\n.\3/\3"+
		"/\3/\3\60\3\60\3\60\5\60\u01a7\n\60\3\61\3\61\3\61\5\61\u01ac\n\61\3\62"+
		"\3\62\3\62\5\62\u01b1\n\62\3\63\3\63\3\63\5\63\u01b6\n\63\3\64\3\64\3"+
		"\64\5\64\u01bb\n\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u01c5"+
		"\n\65\3\66\3\66\3\67\3\67\3\67\5\67\u01cc\n\67\38\38\38\38\38\58\u01d3"+
		"\n8\39\59\u01d6\n9\39\39\39\59\u01db\n9\39\59\u01de\n9\3:\3:\3:\7:\u01e3"+
		"\n:\f:\16:\u01e6\13:\3;\3;\3;\3;\7;\u01ec\n;\f;\16;\u01ef\13;\3;\3;\3"+
		"<\3<\7<\u01f5\n<\f<\16<\u01f8\13<\3=\5=\u01fb\n=\3=\3=\3>\3>\7>\u0201"+
		"\n>\f>\16>\u0204\13>\3?\5?\u0207\n?\3?\3?\5?\u020b\n?\3@\6@\u020e\n@\r"+
		"@\16@\u020f\3@\3@\6@\u0214\n@\r@\16@\u0215\5@\u0218\n@\3@\2\2A\2\4\6\b"+
		"\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVX"+
		"Z\\^`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\u0230\2\u008b\3\2\2\2\4\u008e\3\2\2\2\6\u0092\3\2\2\2\b\u0096"+
		"\3\2\2\2\n\u009a\3\2\2\2\f\u009f\3\2\2\2\16\u00a4\3\2\2\2\20\u00b2\3\2"+
		"\2\2\22\u00b8\3\2\2\2\24\u00c2\3\2\2\2\26\u00c7\3\2\2\2\30\u00cb\3\2\2"+
		"\2\32\u00ce\3\2\2\2\34\u00d1\3\2\2\2\36\u00dd\3\2\2\2 \u00df\3\2\2\2\""+
		"\u00e2\3\2\2\2$\u00e4\3\2\2\2&\u00f3\3\2\2\2(\u00f8\3\2\2\2*\u00fe\3\2"+
		"\2\2,\u0101\3\2\2\2.\u0107\3\2\2\2\60\u010c\3\2\2\2\62\u0114\3\2\2\2\64"+
		"\u0116\3\2\2\2\66\u011a\3\2\2\28\u011e\3\2\2\2:\u0121\3\2\2\2<\u012c\3"+
		"\2\2\2>\u012f\3\2\2\2@\u013a\3\2\2\2B\u0141\3\2\2\2D\u014b\3\2\2\2F\u0159"+
		"\3\2\2\2H\u015c\3\2\2\2J\u016a\3\2\2\2L\u016c\3\2\2\2N\u0170\3\2\2\2P"+
		"\u0173\3\2\2\2R\u017f\3\2\2\2T\u0181\3\2\2\2V\u0185\3\2\2\2X\u0190\3\2"+
		"\2\2Z\u019e\3\2\2\2\\\u01a0\3\2\2\2^\u01a3\3\2\2\2`\u01a8\3\2\2\2b\u01ad"+
		"\3\2\2\2d\u01b2\3\2\2\2f\u01b7\3\2\2\2h\u01c4\3\2\2\2j\u01c6\3\2\2\2l"+
		"\u01c8\3\2\2\2n\u01cd\3\2\2\2p\u01d5\3\2\2\2r\u01df\3\2\2\2t\u01e7\3\2"+
		"\2\2v\u01f2\3\2\2\2x\u01fa\3\2\2\2z\u01fe\3\2\2\2|\u0206\3\2\2\2~\u020d"+
		"\3\2\2\2\u0080\u008c\3\2\2\2\u0081\u0083\5\4\3\2\u0082\u0081\3\2\2\2\u0082"+
		"\u0083\3\2\2\2\u0083\u0085\3\2\2\2\u0084\u0086\5\6\4\2\u0085\u0084\3\2"+
		"\2\2\u0085\u0086\3\2\2\2\u0086\u0088\3\2\2\2\u0087\u0089\5\f\7\2\u0088"+
		"\u0087\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008c\5\n"+
		"\6\2\u008b\u0080\3\2\2\2\u008b\u0082\3\2\2\2\u008c\3\3\2\2\2\u008d\u008f"+
		"\5\b\5\2\u008e\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u008e\3\2\2\2\u0090"+
		"\u0091\3\2\2\2\u0091\5\3\2\2\2\u0092\u0093\7\b\2\2\u0093\u0094\5v<\2\u0094"+
		"\u0095\7\26\2\2\u0095\7\3\2\2\2\u0096\u0097\5p9\2\u0097\u0098\7\26\2\2"+
		"\u0098\t\3\2\2\2\u0099\u009b\5\16\b\2\u009a\u0099\3\2\2\2\u009b\u009c"+
		"\3\2\2\2\u009c\u009a\3\2\2\2\u009c\u009d\3\2\2\2\u009d\13\3\2\2\2\u009e"+
		"\u00a0\5\22\n\2\u009f\u009e\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u009f\3"+
		"\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\r\3\2\2\2\u00a3\u00a5\5\26\f\2\u00a4"+
		"\u00a3\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\3\2\2\2\u00a6\u00a7\5\36"+
		"\20\2\u00a7\u00ab\5p9\2\u00a8\u00aa\5\20\t\2\u00a9\u00a8\3\2\2\2\u00aa"+
		"\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac\u00ae\3\2"+
		"\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00af\7\26\2\2\u00af\17\3\2\2\2\u00b0\u00b1"+
		"\7\24\2\2\u00b1\u00b3\5R*\2\u00b2\u00b0\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3"+
		"\u00b4\3\2\2\2\u00b4\u00b5\7\20\2\2\u00b5\u00b6\5$\23\2\u00b6\21\3\2\2"+
		"\2\u00b7\u00b9\5\26\f\2\u00b8\u00b7\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9"+
		"\u00ba\3\2\2\2\u00ba\u00bc\5p9\2\u00bb\u00bd\5\24\13\2\u00bc\u00bb\3\2"+
		"\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf"+
		"\u00c0\3\2\2\2\u00c0\u00c1\7\26\2\2\u00c1\23\3\2\2\2\u00c2\u00c3\7\22"+
		"\2\2\u00c3\u00c4\5$\23\2\u00c4\25\3\2\2\2\u00c5\u00c8\5\30\r\2\u00c6\u00c8"+
		"\5\32\16\2\u00c7\u00c5\3\2\2\2\u00c7\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2"+
		"\u00c9\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\27\3\2\2\2\u00cb\u00cc"+
		"\7\23\2\2\u00cc\u00cd\t\2\2\2\u00cd\31\3\2\2\2\u00ce\u00cf\7\23\2\2\u00cf"+
		"\u00d0\5\34\17\2\u00d0\33\3\2\2\2\u00d1\u00d2\7#\2\2\u00d2\u00d3\7\31"+
		"\2\2\u00d3\u00d4\5z>\2\u00d4\u00d7\7\n\2\2\u00d5\u00d8\5|?\2\u00d6\u00d8"+
		"\7\5\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d6\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9"+
		"\u00da\7\32\2\2\u00da\35\3\2\2\2\u00db\u00de\5\"\22\2\u00dc\u00de\5 \21"+
		"\2\u00dd\u00db\3\2\2\2\u00dd\u00dc\3\2\2\2\u00de\37\3\2\2\2\u00df\u00e0"+
		"\t\3\2\2\u00e0\u00e1\7\b\2\2\u00e1!\3\2\2\2\u00e2\u00e3\t\3\2\2\u00e3"+
		"#\3\2\2\2\u00e4\u00e9\5&\24\2\u00e5\u00e6\7\25\2\2\u00e6\u00e8\5&\24\2"+
		"\u00e7\u00e5\3\2\2\2\u00e8\u00eb\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea"+
		"\3\2\2\2\u00ea%\3\2\2\2\u00eb\u00e9\3\2\2\2\u00ec\u00f4\5(\25\2\u00ed"+
		"\u00f4\5*\26\2\u00ee\u00f4\5\60\31\2\u00ef\u00f4\5\62\32\2\u00f0\u00f4"+
		"\58\35\2\u00f1\u00f4\5:\36\2\u00f2\u00f4\5> \2\u00f3\u00ec\3\2\2\2\u00f3"+
		"\u00ed\3\2\2\2\u00f3\u00ee\3\2\2\2\u00f3\u00ef\3\2\2\2\u00f3\u00f0\3\2"+
		"\2\2\u00f3\u00f1\3\2\2\2\u00f3\u00f2\3\2\2\2\u00f4\'\3\2\2\2\u00f5\u00f9"+
		"\5D#\2\u00f6\u00f9\5,\27\2\u00f7\u00f9\5.\30\2\u00f8\u00f5\3\2\2\2\u00f8"+
		"\u00f6\3\2\2\2\u00f8\u00f7\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00fb\7\37"+
		"\2\2\u00fb\u00fd\5(\25\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd"+
		")\3\2\2\2\u00fe\u00ff\t\3\2\2\u00ff\u0100\5p9\2\u0100+\3\2\2\2\u0101\u0103"+
		"\7\16\2\2\u0102\u0104\7\17\2\2\u0103\u0102\3\2\2\2\u0103\u0104\3\2\2\2"+
		"\u0104\u0105\3\2\2\2\u0105\u0106\5v<\2\u0106-\3\2\2\2\u0107\u010a\t\4"+
		"\2\2\u0108\u010b\5p9\2\u0109\u010b\5n8\2\u010a\u0108\3\2\2\2\u010a\u0109"+
		"\3\2\2\2\u010b/\3\2\2\2\u010c\u010d\5t;\2\u010d\u0110\7)\2\2\u010e\u0111"+
		"\5p9\2\u010f\u0111\5x=\2\u0110\u010e\3\2\2\2\u0110\u010f\3\2\2\2\u0111"+
		"\61\3\2\2\2\u0112\u0115\5\64\33\2\u0113\u0115\5\66\34\2\u0114\u0112\3"+
		"\2\2\2\u0114\u0113\3\2\2\2\u0115\63\3\2\2\2\u0116\u0117\5x=\2\u0117\u0118"+
		"\7(\2\2\u0118\u0119\5D#\2\u0119\65\3\2\2\2\u011a\u011b\5t;\2\u011b\u011c"+
		"\7(\2\2\u011c\u011d\5D#\2\u011d\67\3\2\2\2\u011e\u011f\5x=\2\u011f\u0120"+
		"\7\4\2\2\u01209\3\2\2\2\u0121\u0122\5x=\2\u0122\u0125\7\3\2\2\u0123\u0126"+
		"\5x=\2\u0124\u0126\5|?\2\u0125\u0123\3\2\2\2\u0125\u0124\3\2\2\2\u0126"+
		";\3\2\2\2\u0127\u0128\7\35\2\2\u0128\u0129\5$\23\2\u0129\u012a\7\36\2"+
		"\2\u012a\u012d\3\2\2\2\u012b\u012d\5&\24\2\u012c\u0127\3\2\2\2\u012c\u012b"+
		"\3\2\2\2\u012d=\3\2\2\2\u012e\u0130\7\23\2\2\u012f\u012e\3\2\2\2\u012f"+
		"\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\5@!\2\u0132\u0133\7\21"+
		"\2\2\u0133\u0135\5x=\2\u0134\u0136\5B\"\2\u0135\u0134\3\2\2\2\u0135\u0136"+
		"\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138\7\24\2\2\u0138\u0139\5<\37\2"+
		"\u0139?\3\2\2\2\u013a\u013d\7\31\2\2\u013b\u013e\5x=\2\u013c\u013e\5p"+
		"9\2\u013d\u013b\3\2\2\2\u013d\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f"+
		"\u0140\7\32\2\2\u0140A\3\2\2\2\u0141\u0142\7$\2\2\u0142\u0143\5x=\2\u0143"+
		"C\3\2\2\2\u0144\u014c\7\5\2\2\u0145\u014c\5|?\2\u0146\u014c\7\6\2\2\u0147"+
		"\u014c\5j\66\2\u0148\u014c\5l\67\2\u0149\u014c\5R*\2\u014a\u014c\5L\'"+
		"\2\u014b\u0144\3\2\2\2\u014b\u0145\3\2\2\2\u014b\u0146\3\2\2\2\u014b\u0147"+
		"\3\2\2\2\u014b\u0148\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014a\3\2\2\2\u014c"+
		"E\3\2\2\2\u014d\u015a\7\5\2\2\u014e\u015a\5|?\2\u014f\u015a\7\6\2\2\u0150"+
		"\u015a\5p9\2\u0151\u015a\5x=\2\u0152\u015a\5t;\2\u0153\u0154\7\33\2\2"+
		"\u0154\u0155\5r:\2\u0155\u0156\7\34\2\2\u0156\u015a\3\2\2\2\u0157\u015a"+
		"\5R*\2\u0158\u015a\5L\'\2\u0159\u014d\3\2\2\2\u0159\u014e\3\2\2\2\u0159"+
		"\u014f\3\2\2\2\u0159\u0150\3\2\2\2\u0159\u0151\3\2\2\2\u0159\u0152\3\2"+
		"\2\2\u0159\u0153\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u0158\3\2\2\2\u015a"+
		"G\3\2\2\2\u015b\u015d\7\23\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2"+
		"\u015d\u015e\3\2\2\2\u015e\u0166\7 \2\2\u015f\u0167\5p9\2\u0160\u0161"+
		"\7\31\2\2\u0161\u0162\5p9\2\u0162\u0163\7\n\2\2\u0163\u0164\5J&\2\u0164"+
		"\u0165\7\32\2\2\u0165\u0167\3\2\2\2\u0166\u015f\3\2\2\2\u0166\u0160\3"+
		"\2\2\2\u0167I\3\2\2\2\u0168\u016b\5x=\2\u0169\u016b\5R*\2\u016a\u0168"+
		"\3\2\2\2\u016a\u0169\3\2\2\2\u016bK\3\2\2\2\u016c\u016d\5R*\2\u016d\u016e"+
		"\5N(\2\u016e\u016f\5P)\2\u016fM\3\2\2\2\u0170\u0171\7\16\2\2\u0171\u0172"+
		"\5D#\2\u0172O\3\2\2\2\u0173\u0174\7\24\2\2\u0174\u0175\5D#\2\u0175Q\3"+
		"\2\2\2\u0176\u0180\5T+\2\u0177\u017c\5V,\2\u0178\u0179\7&\2\2\u0179\u017b"+
		"\5R*\2\u017a\u0178\3\2\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2\u017c"+
		"\u017d\3\2\2\2\u017d\u0180\3\2\2\2\u017e\u017c\3\2\2\2\u017f\u0176\3\2"+
		"\2\2\u017f\u0177\3\2\2\2\u0180S\3\2\2\2\u0181\u0182\7\31\2\2\u0182\u0183"+
		"\5R*\2\u0183\u0184\7\32\2\2\u0184U\3\2\2\2\u0185\u018a\5X-\2\u0186\u0187"+
		"\7%\2\2\u0187\u0189\5R*\2\u0188\u0186\3\2\2\2\u0189\u018c\3\2\2\2\u018a"+
		"\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018bW\3\2\2\2\u018c\u018a\3\2\2\2"+
		"\u018d\u0191\5\\/\2\u018e\u0191\5Z.\2\u018f\u0191\5^\60\2\u0190\u018d"+
		"\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3\2\2\2\u0191\u0196\3\2\2\2\u0192"+
		"\u0193\7\'\2\2\u0193\u0195\5R*\2\u0194\u0192\3\2\2\2\u0195\u0198\3\2\2"+
		"\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197Y\3\2\2\2\u0198\u0196"+
		"\3\2\2\2\u0199\u019f\7\6\2\2\u019a\u019f\5x=\2\u019b\u019f\5j\66\2\u019c"+
		"\u019f\5l\67\2\u019d\u019f\5H%\2\u019e\u0199\3\2\2\2\u019e\u019a\3\2\2"+
		"\2\u019e\u019b\3\2\2\2\u019e\u019c\3\2\2\2\u019e\u019d\3\2\2\2\u019f["+
		"\3\2\2\2\u01a0\u01a1\7\t\2\2\u01a1\u01a2\5R*\2\u01a2]\3\2\2\2\u01a3\u01a6"+
		"\5`\61\2\u01a4\u01a5\t\5\2\2\u01a5\u01a7\5^\60\2\u01a6\u01a4\3\2\2\2\u01a6"+
		"\u01a7\3\2\2\2\u01a7_\3\2\2\2\u01a8\u01ab\5b\62\2\u01a9\u01aa\t\6\2\2"+
		"\u01aa\u01ac\5^\60\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2\2\2\u01aca\3"+
		"\2\2\2\u01ad\u01b0\5d\63\2\u01ae\u01af\t\3\2\2\u01af\u01b1\5^\60\2\u01b0"+
		"\u01ae\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1c\3\2\2\2\u01b2\u01b5\5f\64\2"+
		"\u01b3\u01b4\t\7\2\2\u01b4\u01b6\5^\60\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6"+
		"\3\2\2\2\u01b6e\3\2\2\2\u01b7\u01ba\5h\65\2\u01b8\u01b9\7\60\2\2\u01b9"+
		"\u01bb\5^\60\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bbg\3\2\2\2"+
		"\u01bc\u01c5\5|?\2\u01bd\u01c5\5x=\2\u01be\u01c5\5j\66\2\u01bf\u01c5\5"+
		"l\67\2\u01c0\u01c1\7\31\2\2\u01c1\u01c2\5^\60\2\u01c2\u01c3\7\32\2\2\u01c3"+
		"\u01c5\3\2\2\2\u01c4\u01bc\3\2\2\2\u01c4\u01bd\3\2\2\2\u01c4\u01be\3\2"+
		"\2\2\u01c4\u01bf\3\2\2\2\u01c4\u01c0\3\2\2\2\u01c5i\3\2\2\2\u01c6\u01c7"+
		"\5p9\2\u01c7k\3\2\2\2\u01c8\u01cb\7\17\2\2\u01c9\u01cc\5p9\2\u01ca\u01cc"+
		"\5n8\2\u01cb\u01c9\3\2\2\2\u01cb\u01ca\3\2\2\2\u01ccm\3\2\2\2\u01cd\u01d2"+
		"\5x=\2\u01ce\u01cf\7\31\2\2\u01cf\u01d0\5r:\2\u01d0\u01d1\7\32\2\2\u01d1"+
		"\u01d3\3\2\2\2\u01d2\u01ce\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3o\3\2\2\2"+
		"\u01d4\u01d6\t\b\2\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d7"+
		"\3\2\2\2\u01d7\u01dd\5v<\2\u01d8\u01da\7\31\2\2\u01d9\u01db\5r:\2\u01da"+
		"\u01d9\3\2\2\2\u01da\u01db\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\7\32"+
		"\2\2\u01dd\u01d8\3\2\2\2\u01dd\u01de\3\2\2\2\u01deq\3\2\2\2\u01df\u01e4"+
		"\5F$\2\u01e0\u01e1\7\n\2\2\u01e1\u01e3\5F$\2\u01e2\u01e0\3\2\2\2\u01e3"+
		"\u01e6\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5s\3\2\2\2"+
		"\u01e6\u01e4\3\2\2\2\u01e7\u01e8\7\33\2\2\u01e8\u01ed\5x=\2\u01e9\u01ea"+
		"\7$\2\2\u01ea\u01ec\5x=\2\u01eb\u01e9\3\2\2\2\u01ec\u01ef\3\2\2\2\u01ed"+
		"\u01eb\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01f0\3\2\2\2\u01ef\u01ed\3\2"+
		"\2\2\u01f0\u01f1\7\34\2\2\u01f1u\3\2\2\2\u01f2\u01f6\7\63\2\2\u01f3\u01f5"+
		"\t\t\2\2\u01f4\u01f3\3\2\2\2\u01f5\u01f8\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f6"+
		"\u01f7\3\2\2\2\u01f7w\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f9\u01fb\7\23\2\2"+
		"\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fd"+
		"\5z>\2\u01fdy\3\2\2\2\u01fe\u0202\t\n\2\2\u01ff\u0201\t\13\2\2\u0200\u01ff"+
		"\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203"+
		"{\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0207\7\f\2\2\u0206\u0205\3\2\2\2"+
		"\u0206\u0207\3\2\2\2\u0207\u020a\3\2\2\2\u0208\u020b\7\7\2\2\u0209\u020b"+
		"\5~@\2\u020a\u0208\3\2\2\2\u020a\u0209\3\2\2\2\u020b}\3\2\2\2\u020c\u020e"+
		"\7\65\2\2\u020d\u020c\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u020d\3\2\2\2"+
		"\u020f\u0210\3\2\2\2\u0210\u0217\3\2\2\2\u0211\u0213\7\26\2\2\u0212\u0214"+
		"\7\65\2\2\u0213\u0212\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0213\3\2\2\2"+
		"\u0215\u0216\3\2\2\2\u0216\u0218\3\2\2\2\u0217\u0211\3\2\2\2\u0217\u0218"+
		"\3\2\2\2\u0218\177\3\2\2\2?\u0082\u0085\u0088\u008b\u0090\u009c\u00a1"+
		"\u00a4\u00ab\u00b2\u00b8\u00be\u00c7\u00c9\u00d7\u00dd\u00e9\u00f3\u00f8"+
		"\u00fc\u0103\u010a\u0110\u0114\u0125\u012c\u012f\u0135\u013d\u014b\u0159"+
		"\u015c\u0166\u016a\u017c\u017f\u018a\u0190\u0196\u019e\u01a6\u01ab\u01b0"+
		"\u01b5\u01ba\u01c4\u01cb\u01d2\u01d5\u01da\u01dd\u01e4\u01ed\u01f6\u01fa"+
		"\u0202\u0206\u020a\u020f\u0215\u0217";
	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);
		}
	}
}