VeLaParser.java

// Generated from /home/runner/work/VStar/VStar/src/org/aavso/tools/vstar/vela/VeLa.g4 by ANTLR 4.5.3
package org.aavso.tools.vstar.vela;
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 VeLaParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		BACK_ARROW=1, IS=2, COLON=3, ARROW=4, IF=5, THEN=6, ELSE=7, WHEN=8, WHILE=9, 
		FUN=10, LAMBDA=11, INT_T=12, REAL_T=13, BOOL_T=14, STR_T=15, LIST_T=16, 
		MINUS=17, PLUS=18, MULT=19, DIV=20, POW=21, EQUAL=22, NOT_EQUAL=23, GREATER_THAN=24, 
		LESS_THAN=25, GREATER_THAN_OR_EQUAL=26, LESS_THAN_OR_EQUAL=27, APPROXIMATELY_EQUAL=28, 
		SHIFT_LEFT=29, SHIFT_RIGHT=30, IN=31, LPAREN=32, RPAREN=33, LBRACKET=34, 
		RBRACKET=35, LBRACE=36, RBRACE=37, PERIOD=38, COMMA=39, AND=40, XOR=41, 
		OR=42, NOT=43, INTEGER=44, REAL=45, BOOLEAN=46, IDENT=47, STRING=48, WS=49, 
		HELP_COMMENT=50, COMMENT=51;
	public static final int
		RULE_sequence = 0, RULE_binding = 1, RULE_namedFundef = 2, RULE_expression = 3, 
		RULE_selectionExpression = 4, RULE_whenExpression = 5, RULE_ifExpression = 6, 
		RULE_consequent = 7, RULE_whileLoop = 8, RULE_booleanExpression = 9, RULE_exclusiveOrExpression = 10, 
		RULE_conjunctiveExpression = 11, RULE_logicalNegationExpression = 12, 
		RULE_relationalExpression = 13, RULE_shiftExpression = 14, RULE_additiveExpression = 15, 
		RULE_multiplicativeExpression = 16, RULE_unaryExpression = 17, RULE_exponentiationExpression = 18, 
		RULE_funcall = 19, RULE_factor = 20, RULE_integer = 21, RULE_real = 22, 
		RULE_bool = 23, RULE_string = 24, RULE_list = 25, RULE_symbol = 26, RULE_anonFundef = 27, 
		RULE_formalParameter = 28, RULE_type = 29, RULE_block = 30;
	public static final String[] ruleNames = {
		"sequence", "binding", "namedFundef", "expression", "selectionExpression", 
		"whenExpression", "ifExpression", "consequent", "whileLoop", "booleanExpression", 
		"exclusiveOrExpression", "conjunctiveExpression", "logicalNegationExpression", 
		"relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", 
		"unaryExpression", "exponentiationExpression", "funcall", "factor", "integer", 
		"real", "bool", "string", "list", "symbol", "anonFundef", "formalParameter", 
		"type", "block"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'<-'", null, "':'", "'->'", null, null, null, null, null, null, 
		null, null, null, null, null, null, "'-'", "'+'", "'*'", "'/'", "'^'", 
		"'='", "'<>'", "'>'", "'<'", "'>='", "'<='", "'=~'", "'<<'", "'>>'", null, 
		"'('", "')'", "'['", "']'", "'{'", "'}'", "'.'", "','"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, "BACK_ARROW", "IS", "COLON", "ARROW", "IF", "THEN", "ELSE", "WHEN", 
		"WHILE", "FUN", "LAMBDA", "INT_T", "REAL_T", "BOOL_T", "STR_T", "LIST_T", 
		"MINUS", "PLUS", "MULT", "DIV", "POW", "EQUAL", "NOT_EQUAL", "GREATER_THAN", 
		"LESS_THAN", "GREATER_THAN_OR_EQUAL", "LESS_THAN_OR_EQUAL", "APPROXIMATELY_EQUAL", 
		"SHIFT_LEFT", "SHIFT_RIGHT", "IN", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", 
		"LBRACE", "RBRACE", "PERIOD", "COMMA", "AND", "XOR", "OR", "NOT", "INTEGER", 
		"REAL", "BOOLEAN", "IDENT", "STRING", "WS", "HELP_COMMENT", "COMMENT"
	};
	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 "VeLa.g4"; }

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

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

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

	public VeLaParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class SequenceContext extends ParserRuleContext {
		public List<BindingContext> binding() {
			return getRuleContexts(BindingContext.class);
		}
		public BindingContext binding(int i) {
			return getRuleContext(BindingContext.class,i);
		}
		public List<WhileLoopContext> whileLoop() {
			return getRuleContexts(WhileLoopContext.class);
		}
		public WhileLoopContext whileLoop(int i) {
			return getRuleContext(WhileLoopContext.class,i);
		}
		public List<NamedFundefContext> namedFundef() {
			return getRuleContexts(NamedFundefContext.class);
		}
		public NamedFundefContext namedFundef(int i) {
			return getRuleContext(NamedFundefContext.class,i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public SequenceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sequence; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterSequence(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitSequence(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitSequence(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SequenceContext sequence() throws RecognitionException {
		SequenceContext _localctx = new SequenceContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_sequence);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(68);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << WHEN) | (1L << WHILE) | (1L << FUN) | (1L << LAMBDA) | (1L << MINUS) | (1L << LPAREN) | (1L << LBRACKET) | (1L << NOT) | (1L << INTEGER) | (1L << REAL) | (1L << BOOLEAN) | (1L << IDENT) | (1L << STRING) | (1L << HELP_COMMENT))) != 0)) {
				{
				setState(66);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
				case 1:
					{
					setState(62);
					binding();
					}
					break;
				case 2:
					{
					setState(63);
					whileLoop();
					}
					break;
				case 3:
					{
					setState(64);
					namedFundef();
					}
					break;
				case 4:
					{
					setState(65);
					expression();
					}
					break;
				}
				}
				setState(70);
				_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 BindingContext extends ParserRuleContext {
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode BACK_ARROW() { return getToken(VeLaParser.BACK_ARROW, 0); }
		public TerminalNode IS() { return getToken(VeLaParser.IS, 0); }
		public BindingContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_binding; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterBinding(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitBinding(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitBinding(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BindingContext binding() throws RecognitionException {
		BindingContext _localctx = new BindingContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_binding);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(71);
			symbol();
			setState(72);
			_la = _input.LA(1);
			if ( !(_la==BACK_ARROW || _la==IS) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			setState(73);
			expression();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NamedFundefContext extends ParserRuleContext {
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(VeLaParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(VeLaParser.RPAREN, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode HELP_COMMENT() { return getToken(VeLaParser.HELP_COMMENT, 0); }
		public List<FormalParameterContext> formalParameter() {
			return getRuleContexts(FormalParameterContext.class);
		}
		public FormalParameterContext formalParameter(int i) {
			return getRuleContext(FormalParameterContext.class,i);
		}
		public TerminalNode COLON() { return getToken(VeLaParser.COLON, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public NamedFundefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namedFundef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterNamedFundef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitNamedFundef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitNamedFundef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NamedFundefContext namedFundef() throws RecognitionException {
		NamedFundefContext _localctx = new NamedFundefContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_namedFundef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(76);
			_la = _input.LA(1);
			if (_la==HELP_COMMENT) {
				{
				setState(75);
				match(HELP_COMMENT);
				}
			}

			setState(78);
			symbol();
			setState(79);
			match(LPAREN);
			setState(81);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				{
				setState(80);
				formalParameter();
				}
				break;
			}
			setState(86);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==IDENT) {
				{
				{
				setState(83);
				formalParameter();
				}
				}
				setState(88);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(89);
			match(RPAREN);
			setState(92);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(90);
				match(COLON);
				setState(91);
				type();
				}
			}

			setState(94);
			block();
			}
		}
		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 SelectionExpressionContext selectionExpression() {
			return getRuleContext(SelectionExpressionContext.class,0);
		}
		public BooleanExpressionContext booleanExpression() {
			return getRuleContext(BooleanExpressionContext.class,0);
		}
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_expression);
		try {
			setState(98);
			switch (_input.LA(1)) {
			case IF:
			case WHEN:
				enterOuterAlt(_localctx, 1);
				{
				setState(96);
				selectionExpression();
				}
				break;
			case FUN:
			case LAMBDA:
			case MINUS:
			case LPAREN:
			case LBRACKET:
			case NOT:
			case INTEGER:
			case REAL:
			case BOOLEAN:
			case IDENT:
			case STRING:
				enterOuterAlt(_localctx, 2);
				{
				setState(97);
				booleanExpression();
				}
				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 SelectionExpressionContext extends ParserRuleContext {
		public WhenExpressionContext whenExpression() {
			return getRuleContext(WhenExpressionContext.class,0);
		}
		public IfExpressionContext ifExpression() {
			return getRuleContext(IfExpressionContext.class,0);
		}
		public SelectionExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectionExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterSelectionExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitSelectionExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitSelectionExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectionExpressionContext selectionExpression() throws RecognitionException {
		SelectionExpressionContext _localctx = new SelectionExpressionContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_selectionExpression);
		try {
			setState(102);
			switch (_input.LA(1)) {
			case WHEN:
				enterOuterAlt(_localctx, 1);
				{
				setState(100);
				whenExpression();
				}
				break;
			case IF:
				enterOuterAlt(_localctx, 2);
				{
				setState(101);
				ifExpression();
				}
				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 WhenExpressionContext extends ParserRuleContext {
		public TerminalNode WHEN() { return getToken(VeLaParser.WHEN, 0); }
		public List<BooleanExpressionContext> booleanExpression() {
			return getRuleContexts(BooleanExpressionContext.class);
		}
		public BooleanExpressionContext booleanExpression(int i) {
			return getRuleContext(BooleanExpressionContext.class,i);
		}
		public List<TerminalNode> ARROW() { return getTokens(VeLaParser.ARROW); }
		public TerminalNode ARROW(int i) {
			return getToken(VeLaParser.ARROW, i);
		}
		public List<ConsequentContext> consequent() {
			return getRuleContexts(ConsequentContext.class);
		}
		public ConsequentContext consequent(int i) {
			return getRuleContext(ConsequentContext.class,i);
		}
		public WhenExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whenExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterWhenExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitWhenExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitWhenExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhenExpressionContext whenExpression() throws RecognitionException {
		WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_whenExpression);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(104);
			match(WHEN);
			setState(109); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(105);
					booleanExpression();
					setState(106);
					match(ARROW);
					setState(107);
					consequent();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(111); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_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 IfExpressionContext extends ParserRuleContext {
		public TerminalNode IF() { return getToken(VeLaParser.IF, 0); }
		public BooleanExpressionContext booleanExpression() {
			return getRuleContext(BooleanExpressionContext.class,0);
		}
		public TerminalNode THEN() { return getToken(VeLaParser.THEN, 0); }
		public List<ConsequentContext> consequent() {
			return getRuleContexts(ConsequentContext.class);
		}
		public ConsequentContext consequent(int i) {
			return getRuleContext(ConsequentContext.class,i);
		}
		public TerminalNode ELSE() { return getToken(VeLaParser.ELSE, 0); }
		public IfExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterIfExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitIfExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitIfExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfExpressionContext ifExpression() throws RecognitionException {
		IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_ifExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(113);
			match(IF);
			setState(114);
			booleanExpression();
			setState(115);
			match(THEN);
			setState(116);
			consequent();
			setState(119);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(117);
				match(ELSE);
				setState(118);
				consequent();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConsequentContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public ConsequentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_consequent; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterConsequent(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitConsequent(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitConsequent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConsequentContext consequent() throws RecognitionException {
		ConsequentContext _localctx = new ConsequentContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_consequent);
		try {
			setState(123);
			switch (_input.LA(1)) {
			case IF:
			case WHEN:
			case FUN:
			case LAMBDA:
			case MINUS:
			case LPAREN:
			case LBRACKET:
			case NOT:
			case INTEGER:
			case REAL:
			case BOOLEAN:
			case IDENT:
			case STRING:
				enterOuterAlt(_localctx, 1);
				{
				setState(121);
				expression();
				}
				break;
			case LBRACE:
				enterOuterAlt(_localctx, 2);
				{
				setState(122);
				block();
				}
				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 WhileLoopContext extends ParserRuleContext {
		public TerminalNode WHILE() { return getToken(VeLaParser.WHILE, 0); }
		public BooleanExpressionContext booleanExpression() {
			return getRuleContext(BooleanExpressionContext.class,0);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public WhileLoopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whileLoop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterWhileLoop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitWhileLoop(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitWhileLoop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhileLoopContext whileLoop() throws RecognitionException {
		WhileLoopContext _localctx = new WhileLoopContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_whileLoop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(125);
			match(WHILE);
			setState(126);
			booleanExpression();
			setState(127);
			block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BooleanExpressionContext extends ParserRuleContext {
		public List<ExclusiveOrExpressionContext> exclusiveOrExpression() {
			return getRuleContexts(ExclusiveOrExpressionContext.class);
		}
		public ExclusiveOrExpressionContext exclusiveOrExpression(int i) {
			return getRuleContext(ExclusiveOrExpressionContext.class,i);
		}
		public List<TerminalNode> OR() { return getTokens(VeLaParser.OR); }
		public TerminalNode OR(int i) {
			return getToken(VeLaParser.OR, i);
		}
		public BooleanExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterBooleanExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitBooleanExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitBooleanExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BooleanExpressionContext booleanExpression() throws RecognitionException {
		BooleanExpressionContext _localctx = new BooleanExpressionContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_booleanExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(129);
			exclusiveOrExpression();
			setState(134);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==OR) {
				{
				{
				setState(130);
				match(OR);
				setState(131);
				exclusiveOrExpression();
				}
				}
				setState(136);
				_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 ExclusiveOrExpressionContext extends ParserRuleContext {
		public List<ConjunctiveExpressionContext> conjunctiveExpression() {
			return getRuleContexts(ConjunctiveExpressionContext.class);
		}
		public ConjunctiveExpressionContext conjunctiveExpression(int i) {
			return getRuleContext(ConjunctiveExpressionContext.class,i);
		}
		public List<TerminalNode> XOR() { return getTokens(VeLaParser.XOR); }
		public TerminalNode XOR(int i) {
			return getToken(VeLaParser.XOR, i);
		}
		public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exclusiveOrExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterExclusiveOrExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitExclusiveOrExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitExclusiveOrExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
		ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_exclusiveOrExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(137);
			conjunctiveExpression();
			setState(142);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==XOR) {
				{
				{
				setState(138);
				match(XOR);
				setState(139);
				conjunctiveExpression();
				}
				}
				setState(144);
				_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 ConjunctiveExpressionContext extends ParserRuleContext {
		public List<LogicalNegationExpressionContext> logicalNegationExpression() {
			return getRuleContexts(LogicalNegationExpressionContext.class);
		}
		public LogicalNegationExpressionContext logicalNegationExpression(int i) {
			return getRuleContext(LogicalNegationExpressionContext.class,i);
		}
		public List<TerminalNode> AND() { return getTokens(VeLaParser.AND); }
		public TerminalNode AND(int i) {
			return getToken(VeLaParser.AND, i);
		}
		public ConjunctiveExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conjunctiveExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterConjunctiveExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitConjunctiveExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitConjunctiveExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConjunctiveExpressionContext conjunctiveExpression() throws RecognitionException {
		ConjunctiveExpressionContext _localctx = new ConjunctiveExpressionContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_conjunctiveExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(145);
			logicalNegationExpression();
			setState(150);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==AND) {
				{
				{
				setState(146);
				match(AND);
				setState(147);
				logicalNegationExpression();
				}
				}
				setState(152);
				_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 LogicalNegationExpressionContext extends ParserRuleContext {
		public RelationalExpressionContext relationalExpression() {
			return getRuleContext(RelationalExpressionContext.class,0);
		}
		public TerminalNode NOT() { return getToken(VeLaParser.NOT, 0); }
		public LogicalNegationExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_logicalNegationExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterLogicalNegationExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitLogicalNegationExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitLogicalNegationExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LogicalNegationExpressionContext logicalNegationExpression() throws RecognitionException {
		LogicalNegationExpressionContext _localctx = new LogicalNegationExpressionContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_logicalNegationExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(154);
			_la = _input.LA(1);
			if (_la==NOT) {
				{
				setState(153);
				match(NOT);
				}
			}

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

	public static class RelationalExpressionContext extends ParserRuleContext {
		public List<ShiftExpressionContext> shiftExpression() {
			return getRuleContexts(ShiftExpressionContext.class);
		}
		public ShiftExpressionContext shiftExpression(int i) {
			return getRuleContext(ShiftExpressionContext.class,i);
		}
		public TerminalNode EQUAL() { return getToken(VeLaParser.EQUAL, 0); }
		public TerminalNode NOT_EQUAL() { return getToken(VeLaParser.NOT_EQUAL, 0); }
		public TerminalNode GREATER_THAN() { return getToken(VeLaParser.GREATER_THAN, 0); }
		public TerminalNode LESS_THAN() { return getToken(VeLaParser.LESS_THAN, 0); }
		public TerminalNode GREATER_THAN_OR_EQUAL() { return getToken(VeLaParser.GREATER_THAN_OR_EQUAL, 0); }
		public TerminalNode LESS_THAN_OR_EQUAL() { return getToken(VeLaParser.LESS_THAN_OR_EQUAL, 0); }
		public TerminalNode APPROXIMATELY_EQUAL() { return getToken(VeLaParser.APPROXIMATELY_EQUAL, 0); }
		public TerminalNode IN() { return getToken(VeLaParser.IN, 0); }
		public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationalExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterRelationalExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitRelationalExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitRelationalExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationalExpressionContext relationalExpression() throws RecognitionException {
		RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_relationalExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(158);
			shiftExpression();
			setState(161);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN) | (1L << LESS_THAN) | (1L << GREATER_THAN_OR_EQUAL) | (1L << LESS_THAN_OR_EQUAL) | (1L << APPROXIMATELY_EQUAL) | (1L << IN))) != 0)) {
				{
				setState(159);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN) | (1L << LESS_THAN) | (1L << GREATER_THAN_OR_EQUAL) | (1L << LESS_THAN_OR_EQUAL) | (1L << APPROXIMATELY_EQUAL) | (1L << IN))) != 0)) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				setState(160);
				shiftExpression();
				}
			}

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

	public static class ShiftExpressionContext extends ParserRuleContext {
		public List<AdditiveExpressionContext> additiveExpression() {
			return getRuleContexts(AdditiveExpressionContext.class);
		}
		public AdditiveExpressionContext additiveExpression(int i) {
			return getRuleContext(AdditiveExpressionContext.class,i);
		}
		public List<TerminalNode> SHIFT_LEFT() { return getTokens(VeLaParser.SHIFT_LEFT); }
		public TerminalNode SHIFT_LEFT(int i) {
			return getToken(VeLaParser.SHIFT_LEFT, i);
		}
		public List<TerminalNode> SHIFT_RIGHT() { return getTokens(VeLaParser.SHIFT_RIGHT); }
		public TerminalNode SHIFT_RIGHT(int i) {
			return getToken(VeLaParser.SHIFT_RIGHT, i);
		}
		public ShiftExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shiftExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterShiftExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitShiftExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitShiftExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ShiftExpressionContext shiftExpression() throws RecognitionException {
		ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_shiftExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(163);
			additiveExpression();
			setState(168);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SHIFT_LEFT || _la==SHIFT_RIGHT) {
				{
				{
				setState(164);
				_la = _input.LA(1);
				if ( !(_la==SHIFT_LEFT || _la==SHIFT_RIGHT) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				setState(165);
				additiveExpression();
				}
				}
				setState(170);
				_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 AdditiveExpressionContext extends ParserRuleContext {
		public List<MultiplicativeExpressionContext> multiplicativeExpression() {
			return getRuleContexts(MultiplicativeExpressionContext.class);
		}
		public MultiplicativeExpressionContext multiplicativeExpression(int i) {
			return getRuleContext(MultiplicativeExpressionContext.class,i);
		}
		public List<TerminalNode> PLUS() { return getTokens(VeLaParser.PLUS); }
		public TerminalNode PLUS(int i) {
			return getToken(VeLaParser.PLUS, i);
		}
		public List<TerminalNode> MINUS() { return getTokens(VeLaParser.MINUS); }
		public TerminalNode MINUS(int i) {
			return getToken(VeLaParser.MINUS, i);
		}
		public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_additiveExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterAdditiveExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitAdditiveExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitAdditiveExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
		AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_additiveExpression);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(171);
			multiplicativeExpression();
			setState(176);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(172);
					_la = _input.LA(1);
					if ( !(_la==MINUS || _la==PLUS) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(173);
					multiplicativeExpression();
					}
					} 
				}
				setState(178);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MultiplicativeExpressionContext extends ParserRuleContext {
		public List<UnaryExpressionContext> unaryExpression() {
			return getRuleContexts(UnaryExpressionContext.class);
		}
		public UnaryExpressionContext unaryExpression(int i) {
			return getRuleContext(UnaryExpressionContext.class,i);
		}
		public List<TerminalNode> MULT() { return getTokens(VeLaParser.MULT); }
		public TerminalNode MULT(int i) {
			return getToken(VeLaParser.MULT, i);
		}
		public List<TerminalNode> DIV() { return getTokens(VeLaParser.DIV); }
		public TerminalNode DIV(int i) {
			return getToken(VeLaParser.DIV, i);
		}
		public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterMultiplicativeExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitMultiplicativeExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitMultiplicativeExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
		MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_multiplicativeExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(179);
			unaryExpression();
			setState(184);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==MULT || _la==DIV) {
				{
				{
				setState(180);
				_la = _input.LA(1);
				if ( !(_la==MULT || _la==DIV) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				setState(181);
				unaryExpression();
				}
				}
				setState(186);
				_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 UnaryExpressionContext extends ParserRuleContext {
		public ExponentiationExpressionContext exponentiationExpression() {
			return getRuleContext(ExponentiationExpressionContext.class,0);
		}
		public TerminalNode MINUS() { return getToken(VeLaParser.MINUS, 0); }
		public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaryExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterUnaryExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitUnaryExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitUnaryExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnaryExpressionContext unaryExpression() throws RecognitionException {
		UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_unaryExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(188);
			_la = _input.LA(1);
			if (_la==MINUS) {
				{
				setState(187);
				match(MINUS);
				}
			}

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

	public static class ExponentiationExpressionContext extends ParserRuleContext {
		public List<FuncallContext> funcall() {
			return getRuleContexts(FuncallContext.class);
		}
		public FuncallContext funcall(int i) {
			return getRuleContext(FuncallContext.class,i);
		}
		public List<TerminalNode> POW() { return getTokens(VeLaParser.POW); }
		public TerminalNode POW(int i) {
			return getToken(VeLaParser.POW, i);
		}
		public ExponentiationExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exponentiationExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterExponentiationExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitExponentiationExpression(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitExponentiationExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExponentiationExpressionContext exponentiationExpression() throws RecognitionException {
		ExponentiationExpressionContext _localctx = new ExponentiationExpressionContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_exponentiationExpression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			funcall();
			setState(197);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==POW) {
				{
				{
				{
				setState(193);
				match(POW);
				}
				setState(194);
				funcall();
				}
				}
				setState(199);
				_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 FuncallContext extends ParserRuleContext {
		public FactorContext factor() {
			return getRuleContext(FactorContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(VeLaParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(VeLaParser.RPAREN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public FuncallContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funcall; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterFuncall(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitFuncall(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitFuncall(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncallContext funcall() throws RecognitionException {
		FuncallContext _localctx = new FuncallContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_funcall);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(200);
			factor();
			setState(209);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
			case 1:
				{
				setState(201);
				match(LPAREN);
				setState(205);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << WHEN) | (1L << FUN) | (1L << LAMBDA) | (1L << MINUS) | (1L << LPAREN) | (1L << LBRACKET) | (1L << NOT) | (1L << INTEGER) | (1L << REAL) | (1L << BOOLEAN) | (1L << IDENT) | (1L << STRING))) != 0)) {
					{
					{
					setState(202);
					expression();
					}
					}
					setState(207);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(208);
				match(RPAREN);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FactorContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(VeLaParser.LPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(VeLaParser.RPAREN, 0); }
		public IntegerContext integer() {
			return getRuleContext(IntegerContext.class,0);
		}
		public RealContext real() {
			return getRuleContext(RealContext.class,0);
		}
		public BoolContext bool() {
			return getRuleContext(BoolContext.class,0);
		}
		public StringContext string() {
			return getRuleContext(StringContext.class,0);
		}
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public AnonFundefContext anonFundef() {
			return getRuleContext(AnonFundefContext.class,0);
		}
		public FactorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_factor; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterFactor(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitFactor(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitFactor(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FactorContext factor() throws RecognitionException {
		FactorContext _localctx = new FactorContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_factor);
		try {
			setState(222);
			switch (_input.LA(1)) {
			case LPAREN:
				enterOuterAlt(_localctx, 1);
				{
				setState(211);
				match(LPAREN);
				setState(212);
				expression();
				setState(213);
				match(RPAREN);
				}
				break;
			case INTEGER:
				enterOuterAlt(_localctx, 2);
				{
				setState(215);
				integer();
				}
				break;
			case REAL:
				enterOuterAlt(_localctx, 3);
				{
				setState(216);
				real();
				}
				break;
			case BOOLEAN:
				enterOuterAlt(_localctx, 4);
				{
				setState(217);
				bool();
				}
				break;
			case STRING:
				enterOuterAlt(_localctx, 5);
				{
				setState(218);
				string();
				}
				break;
			case LBRACKET:
				enterOuterAlt(_localctx, 6);
				{
				setState(219);
				list();
				}
				break;
			case IDENT:
				enterOuterAlt(_localctx, 7);
				{
				setState(220);
				symbol();
				}
				break;
			case FUN:
			case LAMBDA:
				enterOuterAlt(_localctx, 8);
				{
				setState(221);
				anonFundef();
				}
				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 IntegerContext extends ParserRuleContext {
		public TerminalNode INTEGER() { return getToken(VeLaParser.INTEGER, 0); }
		public IntegerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_integer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterInteger(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitInteger(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitInteger(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IntegerContext integer() throws RecognitionException {
		IntegerContext _localctx = new IntegerContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_integer);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(224);
			match(INTEGER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RealContext extends ParserRuleContext {
		public TerminalNode REAL() { return getToken(VeLaParser.REAL, 0); }
		public RealContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_real; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterReal(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitReal(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitReal(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RealContext real() throws RecognitionException {
		RealContext _localctx = new RealContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_real);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(226);
			match(REAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BoolContext extends ParserRuleContext {
		public TerminalNode BOOLEAN() { return getToken(VeLaParser.BOOLEAN, 0); }
		public BoolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bool; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterBool(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitBool(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitBool(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BoolContext bool() throws RecognitionException {
		BoolContext _localctx = new BoolContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_bool);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(228);
			match(BOOLEAN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StringContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(VeLaParser.STRING, 0); }
		public StringContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_string; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterString(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitString(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitString(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StringContext string() throws RecognitionException {
		StringContext _localctx = new StringContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_string);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(230);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(VeLaParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(VeLaParser.RBRACKET, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public ListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListContext list() throws RecognitionException {
		ListContext _localctx = new ListContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(232);
			match(LBRACKET);
			setState(234);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				{
				setState(233);
				expression();
				}
				break;
			}
			setState(239);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << WHEN) | (1L << FUN) | (1L << LAMBDA) | (1L << MINUS) | (1L << LPAREN) | (1L << LBRACKET) | (1L << NOT) | (1L << INTEGER) | (1L << REAL) | (1L << BOOLEAN) | (1L << IDENT) | (1L << STRING))) != 0)) {
				{
				{
				setState(236);
				expression();
				}
				}
				setState(241);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(242);
			match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SymbolContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(VeLaParser.IDENT, 0); }
		public SymbolContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_symbol; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterSymbol(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitSymbol(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitSymbol(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SymbolContext symbol() throws RecognitionException {
		SymbolContext _localctx = new SymbolContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_symbol);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(244);
			match(IDENT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AnonFundefContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(VeLaParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(VeLaParser.RPAREN, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode FUN() { return getToken(VeLaParser.FUN, 0); }
		public TerminalNode LAMBDA() { return getToken(VeLaParser.LAMBDA, 0); }
		public List<FormalParameterContext> formalParameter() {
			return getRuleContexts(FormalParameterContext.class);
		}
		public FormalParameterContext formalParameter(int i) {
			return getRuleContext(FormalParameterContext.class,i);
		}
		public TerminalNode COLON() { return getToken(VeLaParser.COLON, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public AnonFundefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anonFundef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterAnonFundef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitAnonFundef(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitAnonFundef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AnonFundefContext anonFundef() throws RecognitionException {
		AnonFundefContext _localctx = new AnonFundefContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_anonFundef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246);
			_la = _input.LA(1);
			if ( !(_la==FUN || _la==LAMBDA) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			setState(247);
			match(LPAREN);
			setState(249);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				{
				setState(248);
				formalParameter();
				}
				break;
			}
			setState(254);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==IDENT) {
				{
				{
				setState(251);
				formalParameter();
				}
				}
				setState(256);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(257);
			match(RPAREN);
			setState(260);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(258);
				match(COLON);
				setState(259);
				type();
				}
			}

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

	public static class FormalParameterContext extends ParserRuleContext {
		public SymbolContext symbol() {
			return getRuleContext(SymbolContext.class,0);
		}
		public TerminalNode COLON() { return getToken(VeLaParser.COLON, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public FormalParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_formalParameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterFormalParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitFormalParameter(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitFormalParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FormalParameterContext formalParameter() throws RecognitionException {
		FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_formalParameter);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(264);
			symbol();
			setState(265);
			match(COLON);
			setState(266);
			type();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TypeContext extends ParserRuleContext {
		public TerminalNode INT_T() { return getToken(VeLaParser.INT_T, 0); }
		public TerminalNode REAL_T() { return getToken(VeLaParser.REAL_T, 0); }
		public TerminalNode BOOL_T() { return getToken(VeLaParser.BOOL_T, 0); }
		public TerminalNode STR_T() { return getToken(VeLaParser.STR_T, 0); }
		public TerminalNode LIST_T() { return getToken(VeLaParser.LIST_T, 0); }
		public TerminalNode FUN() { return getToken(VeLaParser.FUN, 0); }
		public TerminalNode LAMBDA() { return getToken(VeLaParser.LAMBDA, 0); }
		public TypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeContext type() throws RecognitionException {
		TypeContext _localctx = new TypeContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_type);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(268);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FUN) | (1L << LAMBDA) | (1L << INT_T) | (1L << REAL_T) | (1L << BOOL_T) | (1L << STR_T) | (1L << LIST_T))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(VeLaParser.LBRACE, 0); }
		public SequenceContext sequence() {
			return getRuleContext(SequenceContext.class,0);
		}
		public TerminalNode RBRACE() { return getToken(VeLaParser.RBRACE, 0); }
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).enterBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof VeLaListener ) ((VeLaListener)listener).exitBlock(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof VeLaVisitor ) return ((VeLaVisitor<? extends T>)visitor).visitBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(270);
			match(LBRACE);
			setState(271);
			sequence();
			setState(272);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\65\u0115\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 \3\2"+
		"\3\2\3\2\3\2\7\2E\n\2\f\2\16\2H\13\2\3\3\3\3\3\3\3\3\3\4\5\4O\n\4\3\4"+
		"\3\4\3\4\5\4T\n\4\3\4\7\4W\n\4\f\4\16\4Z\13\4\3\4\3\4\3\4\5\4_\n\4\3\4"+
		"\3\4\3\5\3\5\5\5e\n\5\3\6\3\6\5\6i\n\6\3\7\3\7\3\7\3\7\3\7\6\7p\n\7\r"+
		"\7\16\7q\3\b\3\b\3\b\3\b\3\b\3\b\5\bz\n\b\3\t\3\t\5\t~\n\t\3\n\3\n\3\n"+
		"\3\n\3\13\3\13\3\13\7\13\u0087\n\13\f\13\16\13\u008a\13\13\3\f\3\f\3\f"+
		"\7\f\u008f\n\f\f\f\16\f\u0092\13\f\3\r\3\r\3\r\7\r\u0097\n\r\f\r\16\r"+
		"\u009a\13\r\3\16\5\16\u009d\n\16\3\16\3\16\3\17\3\17\3\17\5\17\u00a4\n"+
		"\17\3\20\3\20\3\20\7\20\u00a9\n\20\f\20\16\20\u00ac\13\20\3\21\3\21\3"+
		"\21\7\21\u00b1\n\21\f\21\16\21\u00b4\13\21\3\22\3\22\3\22\7\22\u00b9\n"+
		"\22\f\22\16\22\u00bc\13\22\3\23\5\23\u00bf\n\23\3\23\3\23\3\24\3\24\3"+
		"\24\7\24\u00c6\n\24\f\24\16\24\u00c9\13\24\3\25\3\25\3\25\7\25\u00ce\n"+
		"\25\f\25\16\25\u00d1\13\25\3\25\5\25\u00d4\n\25\3\26\3\26\3\26\3\26\3"+
		"\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26\u00e1\n\26\3\27\3\27\3\30\3\30"+
		"\3\31\3\31\3\32\3\32\3\33\3\33\5\33\u00ed\n\33\3\33\7\33\u00f0\n\33\f"+
		"\33\16\33\u00f3\13\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\5\35\u00fc\n"+
		"\35\3\35\7\35\u00ff\n\35\f\35\16\35\u0102\13\35\3\35\3\35\3\35\5\35\u0107"+
		"\n\35\3\35\3\35\3\36\3\36\3\36\3\36\3\37\3\37\3 \3 \3 \3 \3 \2\2!\2\4"+
		"\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>\2\t\3\2\3"+
		"\4\4\2\30\36!!\3\2\37 \3\2\23\24\3\2\25\26\3\2\f\r\3\2\f\22\u011a\2F\3"+
		"\2\2\2\4I\3\2\2\2\6N\3\2\2\2\bd\3\2\2\2\nh\3\2\2\2\fj\3\2\2\2\16s\3\2"+
		"\2\2\20}\3\2\2\2\22\177\3\2\2\2\24\u0083\3\2\2\2\26\u008b\3\2\2\2\30\u0093"+
		"\3\2\2\2\32\u009c\3\2\2\2\34\u00a0\3\2\2\2\36\u00a5\3\2\2\2 \u00ad\3\2"+
		"\2\2\"\u00b5\3\2\2\2$\u00be\3\2\2\2&\u00c2\3\2\2\2(\u00ca\3\2\2\2*\u00e0"+
		"\3\2\2\2,\u00e2\3\2\2\2.\u00e4\3\2\2\2\60\u00e6\3\2\2\2\62\u00e8\3\2\2"+
		"\2\64\u00ea\3\2\2\2\66\u00f6\3\2\2\28\u00f8\3\2\2\2:\u010a\3\2\2\2<\u010e"+
		"\3\2\2\2>\u0110\3\2\2\2@E\5\4\3\2AE\5\22\n\2BE\5\6\4\2CE\5\b\5\2D@\3\2"+
		"\2\2DA\3\2\2\2DB\3\2\2\2DC\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2G\3\3"+
		"\2\2\2HF\3\2\2\2IJ\5\66\34\2JK\t\2\2\2KL\5\b\5\2L\5\3\2\2\2MO\7\64\2\2"+
		"NM\3\2\2\2NO\3\2\2\2OP\3\2\2\2PQ\5\66\34\2QS\7\"\2\2RT\5:\36\2SR\3\2\2"+
		"\2ST\3\2\2\2TX\3\2\2\2UW\5:\36\2VU\3\2\2\2WZ\3\2\2\2XV\3\2\2\2XY\3\2\2"+
		"\2Y[\3\2\2\2ZX\3\2\2\2[^\7#\2\2\\]\7\5\2\2]_\5<\37\2^\\\3\2\2\2^_\3\2"+
		"\2\2_`\3\2\2\2`a\5> \2a\7\3\2\2\2be\5\n\6\2ce\5\24\13\2db\3\2\2\2dc\3"+
		"\2\2\2e\t\3\2\2\2fi\5\f\7\2gi\5\16\b\2hf\3\2\2\2hg\3\2\2\2i\13\3\2\2\2"+
		"jo\7\n\2\2kl\5\24\13\2lm\7\6\2\2mn\5\20\t\2np\3\2\2\2ok\3\2\2\2pq\3\2"+
		"\2\2qo\3\2\2\2qr\3\2\2\2r\r\3\2\2\2st\7\7\2\2tu\5\24\13\2uv\7\b\2\2vy"+
		"\5\20\t\2wx\7\t\2\2xz\5\20\t\2yw\3\2\2\2yz\3\2\2\2z\17\3\2\2\2{~\5\b\5"+
		"\2|~\5> \2}{\3\2\2\2}|\3\2\2\2~\21\3\2\2\2\177\u0080\7\13\2\2\u0080\u0081"+
		"\5\24\13\2\u0081\u0082\5> \2\u0082\23\3\2\2\2\u0083\u0088\5\26\f\2\u0084"+
		"\u0085\7,\2\2\u0085\u0087\5\26\f\2\u0086\u0084\3\2\2\2\u0087\u008a\3\2"+
		"\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\25\3\2\2\2\u008a\u0088"+
		"\3\2\2\2\u008b\u0090\5\30\r\2\u008c\u008d\7+\2\2\u008d\u008f\5\30\r\2"+
		"\u008e\u008c\3\2\2\2\u008f\u0092\3\2\2\2\u0090\u008e\3\2\2\2\u0090\u0091"+
		"\3\2\2\2\u0091\27\3\2\2\2\u0092\u0090\3\2\2\2\u0093\u0098\5\32\16\2\u0094"+
		"\u0095\7*\2\2\u0095\u0097\5\32\16\2\u0096\u0094\3\2\2\2\u0097\u009a\3"+
		"\2\2\2\u0098\u0096\3\2\2\2\u0098\u0099\3\2\2\2\u0099\31\3\2\2\2\u009a"+
		"\u0098\3\2\2\2\u009b\u009d\7-\2\2\u009c\u009b\3\2\2\2\u009c\u009d\3\2"+
		"\2\2\u009d\u009e\3\2\2\2\u009e\u009f\5\34\17\2\u009f\33\3\2\2\2\u00a0"+
		"\u00a3\5\36\20\2\u00a1\u00a2\t\3\2\2\u00a2\u00a4\5\36\20\2\u00a3\u00a1"+
		"\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\35\3\2\2\2\u00a5\u00aa\5 \21\2\u00a6"+
		"\u00a7\t\4\2\2\u00a7\u00a9\5 \21\2\u00a8\u00a6\3\2\2\2\u00a9\u00ac\3\2"+
		"\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\37\3\2\2\2\u00ac\u00aa"+
		"\3\2\2\2\u00ad\u00b2\5\"\22\2\u00ae\u00af\t\5\2\2\u00af\u00b1\5\"\22\2"+
		"\u00b0\u00ae\3\2\2\2\u00b1\u00b4\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b2\u00b3"+
		"\3\2\2\2\u00b3!\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b5\u00ba\5$\23\2\u00b6"+
		"\u00b7\t\6\2\2\u00b7\u00b9\5$\23\2\u00b8\u00b6\3\2\2\2\u00b9\u00bc\3\2"+
		"\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb#\3\2\2\2\u00bc\u00ba"+
		"\3\2\2\2\u00bd\u00bf\7\23\2\2\u00be\u00bd\3\2\2\2\u00be\u00bf\3\2\2\2"+
		"\u00bf\u00c0\3\2\2\2\u00c0\u00c1\5&\24\2\u00c1%\3\2\2\2\u00c2\u00c7\5"+
		"(\25\2\u00c3\u00c4\7\27\2\2\u00c4\u00c6\5(\25\2\u00c5\u00c3\3\2\2\2\u00c6"+
		"\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\'\3\2\2\2"+
		"\u00c9\u00c7\3\2\2\2\u00ca\u00d3\5*\26\2\u00cb\u00cf\7\"\2\2\u00cc\u00ce"+
		"\5\b\5\2\u00cd\u00cc\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf"+
		"\u00d0\3\2\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d2\u00d4\7#"+
		"\2\2\u00d3\u00cb\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4)\3\2\2\2\u00d5\u00d6"+
		"\7\"\2\2\u00d6\u00d7\5\b\5\2\u00d7\u00d8\7#\2\2\u00d8\u00e1\3\2\2\2\u00d9"+
		"\u00e1\5,\27\2\u00da\u00e1\5.\30\2\u00db\u00e1\5\60\31\2\u00dc\u00e1\5"+
		"\62\32\2\u00dd\u00e1\5\64\33\2\u00de\u00e1\5\66\34\2\u00df\u00e1\58\35"+
		"\2\u00e0\u00d5\3\2\2\2\u00e0\u00d9\3\2\2\2\u00e0\u00da\3\2\2\2\u00e0\u00db"+
		"\3\2\2\2\u00e0\u00dc\3\2\2\2\u00e0\u00dd\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0"+
		"\u00df\3\2\2\2\u00e1+\3\2\2\2\u00e2\u00e3\7.\2\2\u00e3-\3\2\2\2\u00e4"+
		"\u00e5\7/\2\2\u00e5/\3\2\2\2\u00e6\u00e7\7\60\2\2\u00e7\61\3\2\2\2\u00e8"+
		"\u00e9\7\62\2\2\u00e9\63\3\2\2\2\u00ea\u00ec\7$\2\2\u00eb\u00ed\5\b\5"+
		"\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00f1\3\2\2\2\u00ee\u00f0"+
		"\5\b\5\2\u00ef\u00ee\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1"+
		"\u00f2\3\2\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f5\7%"+
		"\2\2\u00f5\65\3\2\2\2\u00f6\u00f7\7\61\2\2\u00f7\67\3\2\2\2\u00f8\u00f9"+
		"\t\7\2\2\u00f9\u00fb\7\"\2\2\u00fa\u00fc\5:\36\2\u00fb\u00fa\3\2\2\2\u00fb"+
		"\u00fc\3\2\2\2\u00fc\u0100\3\2\2\2\u00fd\u00ff\5:\36\2\u00fe\u00fd\3\2"+
		"\2\2\u00ff\u0102\3\2\2\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101"+
		"\u0103\3\2\2\2\u0102\u0100\3\2\2\2\u0103\u0106\7#\2\2\u0104\u0105\7\5"+
		"\2\2\u0105\u0107\5<\37\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107"+
		"\u0108\3\2\2\2\u0108\u0109\5> \2\u01099\3\2\2\2\u010a\u010b\5\66\34\2"+
		"\u010b\u010c\7\5\2\2\u010c\u010d\5<\37\2\u010d;\3\2\2\2\u010e\u010f\t"+
		"\b\2\2\u010f=\3\2\2\2\u0110\u0111\7&\2\2\u0111\u0112\5\2\2\2\u0112\u0113"+
		"\7\'\2\2\u0113?\3\2\2\2\37DFNSX^dhqy}\u0088\u0090\u0098\u009c\u00a3\u00aa"+
		"\u00b2\u00ba\u00be\u00c7\u00cf\u00d3\u00e0\u00ec\u00f1\u00fb\u0100\u0106";
	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);
		}
	}
}