gt: 		enterRule(_localctx, 14, RULE_assignment);
context: // Generated from While.g4 by ANTLR 4.4
  
  package parser;
  
  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 WhileParser extends Parser {
  	static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); }
  
  	protected static final DFA[] _decisionToDFA;
  	protected static final PredictionContextCache _sharedContextCache =
  		new PredictionContextCache();
  	public static final int
  		T__27=1, T__26=2, T__25=3, T__24=4, T__23=5, T__22=6, T__21=7, T__20=8, 
  		T__19=9, T__18=10, T__17=11, T__16=12, T__15=13, T__14=14, T__13=15, T__12=16, 
  		T__11=17, T__10=18, T__9=19, T__8=20, T__7=21, T__6=22, T__5=23, T__4=24, 
  		T__3=25, T__2=26, T__1=27, T__0=28, ID=29, Int=30, WS=31;
  	public static final String[] tokenNames = {
  		"<INVALID>", "'/'", "'true'", "'procedure'", "'||'", "';'", "'while'", 
  		"'{'", "'&&'", "'}'", "'if'", "'call'", "':='", "'('", "'*'", "','", "'false'", 
  		"'=='", "'<'", "'val'", "'>'", "'or'", "'!'", "'else'", "')'", "'and'", 
  		"'+'", "'not'", "'-'", "ID", "Int", "WS"
  	};
  	public static final int
  		RULE_bool = 0, RULE_program = 1, RULE_statement = 2, RULE_block = 3, RULE_procedure = 4, 
  		RULE_s_if = 5, RULE_s_while = 6, RULE_assignment = 7, RULE_procedureCall = 8, 
  		RULE_expression = 9, RULE_intExpression = 10, RULE_idExpression = 11, 
  		RULE_unaryExpression = 12, RULE_notExpression = 13, RULE_binaryExpression = 14, 
  		RULE_binaryOperator = 15, RULE_mathExpression = 16, RULE_mathOperator = 17;
  	public static final String[] ruleNames = {
  		"bool", "program", "statement", "block", "procedure", "s_if", "s_while", 
  		"assignment", "procedureCall", "expression", "intExpression", "idExpression", 
  		"unaryExpression", "notExpression", "binaryExpression", "binaryOperator", 
  		"mathExpression", "mathOperator"
  	};
  
  	@Override
  	public String getGrammarFileName() { return "While.g4"; }
  
  	@Override
  	public String[] getTokenNames() { return tokenNames; }
  
  	@Override
  	public String[] getRuleNames() { return ruleNames; }
  
  	@Override
  	public String getSerializedATN() { return _serializedATN; }
  
  	@Override
  	public ATN getATN() { return _ATN; }
  
  	public WhileParser(TokenStream input) {
  		super(input);
  		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
  	}
  	public static class BoolContext extends ParserRuleContext {
  		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 WhileListener ) ((WhileListener)listener).enterBool(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitBool(this);
  		}
  	}
  
  	public final BoolContext bool() throws RecognitionException {
  		BoolContext _localctx = new BoolContext(_ctx, getState());
  		enterRule(_localctx, 0, RULE_bool);
  		int _la;
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(36);
  			_la = _input.LA(1);
  			if ( !(_la==T__26 || _la==T__12) ) {
  			_errHandler.recoverInline(this);
  			}
  			consume();
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class ProgramContext extends ParserRuleContext {
  		public StatementContext statement(int i) {
  			return getRuleContext(StatementContext.class,i);
  		}
  		public List<StatementContext> statement() {
  			return getRuleContexts(StatementContext.class);
  		}
  		public ProgramContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_program; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterProgram(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitProgram(this);
  		}
  	}
  
  	public final ProgramContext program() throws RecognitionException {
  		ProgramContext _localctx = new ProgramContext(_ctx, getState());
  		enterRule(_localctx, 2, RULE_program);
  		int _la;
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(39); 
  			_errHandler.sync(this);
  			_la = _input.LA(1);
  			do {
  				{
  				{
  				setState(38); statement();
  				}
  				}
  				setState(41); 
  				_errHandler.sync(this);
  				_la = _input.LA(1);
  			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__18) | (1L << T__17) | (1L << ID))) != 0) );
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class StatementContext extends ParserRuleContext {
  		public ProcedureCallContext procedureCall() {
  			return getRuleContext(ProcedureCallContext.class,0);
  		}
  		public AssignmentContext assignment() {
  			return getRuleContext(AssignmentContext.class,0);
  		}
  		public S_whileContext s_while() {
  			return getRuleContext(S_whileContext.class,0);
  		}
  		public ProcedureContext procedure() {
  			return getRuleContext(ProcedureContext.class,0);
  		}
  		public S_ifContext s_if() {
  			return getRuleContext(S_ifContext.class,0);
  		}
  		public BlockContext block() {
  			return getRuleContext(BlockContext.class,0);
  		}
  		public StatementContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_statement; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterStatement(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitStatement(this);
  		}
  	}
  
  	public final StatementContext statement() throws RecognitionException {
  		StatementContext _localctx = new StatementContext(_ctx, getState());
  		enterRule(_localctx, 4, RULE_statement);
  		try {
  			setState(49);
  			switch (_input.LA(1)) {
  			case T__21:
  				enterOuterAlt(_localctx, 1);
  				{
  				setState(43); block();
  				}
  				break;
  			case T__18:
  				enterOuterAlt(_localctx, 2);
  				{
  				setState(44); s_if();
  				}
  				break;
  			case T__22:
  				enterOuterAlt(_localctx, 3);
  				{
  				setState(45); s_while();
  				}
  				break;
  			case ID:
  				enterOuterAlt(_localctx, 4);
  				{
  				setState(46); assignment();
  				}
  				break;
  			case T__25:
  				enterOuterAlt(_localctx, 5);
  				{
  				setState(47); procedure();
  				}
  				break;
  			case T__17:
  				enterOuterAlt(_localctx, 6);
  				{
  				setState(48); procedureCall();
  				}
  				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 BlockContext extends ParserRuleContext {
  		public StatementContext statement(int i) {
  			return getRuleContext(StatementContext.class,i);
  		}
  		public List<StatementContext> statement() {
  			return getRuleContexts(StatementContext.class);
  		}
  		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 WhileListener ) ((WhileListener)listener).enterBlock(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitBlock(this);
  		}
  	}
  
  	public final BlockContext block() throws RecognitionException {
  		BlockContext _localctx = new BlockContext(_ctx, getState());
  		enterRule(_localctx, 6, RULE_block);
  		int _la;
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(51); match(T__21);
  			setState(55);
  			_errHandler.sync(this);
  			_la = _input.LA(1);
  			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__25) | (1L << T__22) | (1L << T__21) | (1L << T__18) | (1L << T__17) | (1L << ID))) != 0)) {
  				{
  				{
  				setState(52); statement();
  				}
  				}
  				setState(57);
  				_errHandler.sync(this);
  				_la = _input.LA(1);
  			}
  			setState(58); match(T__19);
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class ProcedureContext extends ParserRuleContext {
  		public List<TerminalNode> ID() { return getTokens(WhileParser.ID); }
  		public TerminalNode ID(int i) {
  			return getToken(WhileParser.ID, i);
  		}
  		public BlockContext block() {
  			return getRuleContext(BlockContext.class,0);
  		}
  		public ProcedureContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_procedure; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterProcedure(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitProcedure(this);
  		}
  	}
  
  	public final ProcedureContext procedure() throws RecognitionException {
  		ProcedureContext _localctx = new ProcedureContext(_ctx, getState());
  		enterRule(_localctx, 8, RULE_procedure);
  		int _la;
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(60); match(T__25);
  			setState(61); match(ID);
  			setState(62); match(T__15);
  			setState(63); match(T__9);
  			setState(64); match(ID);
  			setState(69);
  			_errHandler.sync(this);
  			_la = _input.LA(1);
  			while (_la==T__13) {
  				{
  				{
  				setState(65); match(T__13);
  				setState(66); match(ID);
  				}
  				}
  				setState(71);
  				_errHandler.sync(this);
  				_la = _input.LA(1);
  			}
  			setState(72); match(T__4);
  			setState(73); block();
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class S_ifContext extends ParserRuleContext {
  		public StatementContext statement(int i) {
  			return getRuleContext(StatementContext.class,i);
  		}
  		public List<StatementContext> statement() {
  			return getRuleContexts(StatementContext.class);
  		}
  		public ExpressionContext expression() {
  			return getRuleContext(ExpressionContext.class,0);
  		}
  		public S_ifContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_s_if; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterS_if(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitS_if(this);
  		}
  	}
  
  	public final S_ifContext s_if() throws RecognitionException {
  		S_ifContext _localctx = new S_ifContext(_ctx, getState());
  		enterRule(_localctx, 10, RULE_s_if);
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(75); match(T__18);
  			setState(76); expression();
  			setState(77); statement();
  			setState(78); match(T__5);
  			setState(79); statement();
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class S_whileContext extends ParserRuleContext {
  		public StatementContext statement() {
  			return getRuleContext(StatementContext.class,0);
  		}
  		public ExpressionContext expression() {
  			return getRuleContext(ExpressionContext.class,0);
  		}
  		public S_whileContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_s_while; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterS_while(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitS_while(this);
  		}
  	}
  
  	public final S_whileContext s_while() throws RecognitionException {
  		S_whileContext _localctx = new S_whileContext(_ctx, getState());
  		enterRule(_localctx, 12, RULE_s_while);
  		try {
  			enterOuterAlt(_localctx, 1);
  			{
  			setState(81); match(T__22);
  			setState(82); expression();
  			setState(83); statement();
  			}
  		}
  		catch (RecognitionException re) {
  			_localctx.exception = re;
  			_errHandler.reportError(this, re);
  			_errHandler.recover(this, re);
  		}
  		finally {
  			exitRule();
  		}
  		return _localctx;
  	}
  
  	public static class AssignmentContext extends ParserRuleContext {
  		public TerminalNode ID() { return getToken(WhileParser.ID, 0); }
  		public ExpressionContext expression() {
  			return getRuleContext(ExpressionContext.class,0);
  		}
  		public AssignmentContext(ParserRuleContext parent, int invokingState) {
  			super(parent, invokingState);
  		}
  		@Override public int getRuleIndex() { return RULE_assignment; }
  		@Override
  		public void enterRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).enterAssignment(this);
  		}
  		@Override
  		public void exitRule(ParseTreeListener listener) {
  			if ( listener instanceof WhileListener ) ((WhileListener)listener).exitAssignment(this);
  		}
  	}
  
  	public final AssignmentContext assignment() throws RecognitionException {
  		AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
  