// Generated from OQL.g4 by ANTLR 4.4
package com.amarsoft.app.base.antlr;
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 OQLParser 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
		WS=1, PARAMETER=2, ADD=3, SUB=4, MUL=5, DIV=6, IN=7, NOTIN=8, GREATE_THAN=9, 
		GREATE_EQUAL_THAN=10, LESS_THAN=11, LESS_EQUAL_THAN=12, EQUAL=13, TRUE=14, 
		FALSE=15, NULL=16, NOT_EQUAL=17, LOGICAL_AND=18, LOGICAL_OR=19, LEFT_PAREN=20, 
		RIGHT_PAREN=21, COMMA=22, LIKE=23, LENGTH=24, MONTH=25, ATTRIBUTE=26, 
		NUMBER=27, STRING=28;
	public static final String[] tokenNames = {
		"<INVALID>", "WS", "PARAMETER", "'+'", "'-'", "'*'", "'/'", "'in'", "'not in'", 
		"'>'", "'>='", "'<'", "'<='", "'='", "'true'", "'false'", "NULL", "'<>'", 
		"'and'", "'or'", "'('", "')'", "','", "'like'", "'length'", "'month'", 
		"ATTRIBUTE", "NUMBER", "STRING"
	};
	public static final int
		RULE_expression = 0, RULE_equality_expression = 1;
	public static final String[] ruleNames = {
		"expression", "equality_expression"
	};

	@Override
	public String getGrammarFileName() { return "OQL.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 OQLParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ExpressionContext extends ParserRuleContext {
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
	 
		public ExpressionContext() { }
		public void copyFrom(ExpressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SubExprContext extends ExpressionContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode SUB() { return getToken(OQLParser.SUB, 0); }
		public SubExprContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterSubExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitSubExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitSubExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalMonthContext extends ExpressionContext {
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MONTH() { return getToken(OQLParser.MONTH, 0); }
		public TerminalNode COMMA() { return getToken(OQLParser.COMMA, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public LogicalMonthContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalMonth(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalMonth(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalMonth(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class StringContext extends ExpressionContext {
		public TerminalNode STRING() { return getToken(OQLParser.STRING, 0); }
		public StringContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterString(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitString(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitString(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NumberContext extends ExpressionContext {
		public TerminalNode NUMBER() { return getToken(OQLParser.NUMBER, 0); }
		public NumberContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNumber(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNumber(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitNumber(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class AddSubContext extends ExpressionContext {
		public Token op;
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode SUB() { return getToken(OQLParser.SUB, 0); }
		public TerminalNode ADD() { return getToken(OQLParser.ADD, 0); }
		public AddSubContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAddSub(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAddSub(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitAddSub(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalLengthContext extends ExpressionContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LENGTH() { return getToken(OQLParser.LENGTH, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public LogicalLengthContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalLength(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalLength(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalLength(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ArrayExprContext extends ExpressionContext {
		public TerminalNode STRING(int i) {
			return getToken(OQLParser.STRING, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(OQLParser.COMMA); }
		public List<TerminalNode> ATTRIBUTE() { return getTokens(OQLParser.ATTRIBUTE); }
		public List<TerminalNode> STRING() { return getTokens(OQLParser.STRING); }
		public TerminalNode COMMA(int i) {
			return getToken(OQLParser.COMMA, i);
		}
		public TerminalNode ATTRIBUTE(int i) {
			return getToken(OQLParser.ATTRIBUTE, i);
		}
		public ArrayExprContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterArrayExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitArrayExpr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitArrayExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class AttributeContext extends ExpressionContext {
		public TerminalNode ATTRIBUTE() { return getToken(OQLParser.ATTRIBUTE, 0); }
		public AttributeContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAttribute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAttribute(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitAttribute(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ParameterContext extends ExpressionContext {
		public TerminalNode PARAMETER() { return getToken(OQLParser.PARAMETER, 0); }
		public ParameterContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParameter(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParameter(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ParenContext extends ExpressionContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public ParenContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParen(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParen(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParen(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NullContext extends ExpressionContext {
		public TerminalNode NULL() { return getToken(OQLParser.NULL, 0); }
		public NullContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNull(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNull(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitNull(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MulDivContext extends ExpressionContext {
		public Token op;
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode MUL() { return getToken(OQLParser.MUL, 0); }
		public TerminalNode DIV() { return getToken(OQLParser.DIV, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public MulDivContext(ExpressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterMulDiv(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitMulDiv(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitMulDiv(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		return expression(0);
	}

	private ExpressionContext expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
		ExpressionContext _prevctx = _localctx;
		int _startState = 0;
		enterRecursionRule(_localctx, 0, RULE_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(36);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				{
				_localctx = new SubExprContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(5); match(SUB);
				setState(6); expression(7);
				}
				break;
			case 2:
				{
				_localctx = new NumberContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(7); match(NUMBER);
				}
				break;
			case 3:
				{
				_localctx = new NullContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(8); match(NULL);
				}
				break;
			case 4:
				{
				_localctx = new StringContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(9); match(STRING);
				}
				break;
			case 5:
				{
				_localctx = new ParameterContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(10); match(PARAMETER);
				}
				break;
			case 6:
				{
				_localctx = new AttributeContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(11); match(ATTRIBUTE);
				}
				break;
			case 7:
				{
				_localctx = new LogicalLengthContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(12); match(LENGTH);
				setState(13); match(LEFT_PAREN);
				setState(14); expression(0);
				setState(15); match(RIGHT_PAREN);
				}
				break;
			case 8:
				{
				_localctx = new LogicalMonthContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(17); match(MONTH);
				setState(18); match(LEFT_PAREN);
				setState(19); expression(0);
				setState(20); match(COMMA);
				setState(21); expression(0);
				setState(22); match(RIGHT_PAREN);
				}
				break;
			case 9:
				{
				_localctx = new ArrayExprContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(24);
				_la = _input.LA(1);
				if ( !(_la==ATTRIBUTE || _la==STRING) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				setState(29);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(25); match(COMMA);
						setState(26);
						_la = _input.LA(1);
						if ( !(_la==ATTRIBUTE || _la==STRING) ) {
						_errHandler.recoverInline(this);
						}
						consume();
						}
						} 
					}
					setState(31);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
				}
				}
				break;
			case 10:
				{
				_localctx = new ParenContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(32); match(LEFT_PAREN);
				setState(33); expression(0);
				setState(34); match(RIGHT_PAREN);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(46);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(44);
					switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
					case 1:
						{
						_localctx = new MulDivContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(38);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(39);
						((MulDivContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==MUL || _la==DIV) ) {
							((MulDivContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(40); expression(7);
						}
						break;
					case 2:
						{
						_localctx = new AddSubContext(new ExpressionContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_expression);
						setState(41);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(42);
						((AddSubContext)_localctx).op = _input.LT(1);
						_la = _input.LA(1);
						if ( !(_la==ADD || _la==SUB) ) {
							((AddSubContext)_localctx).op = (Token)_errHandler.recoverInline(this);
						}
						consume();
						setState(43); expression(6);
						}
						break;
					}
					} 
				}
				setState(48);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Equality_expressionContext extends ParserRuleContext {
		public Equality_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_equality_expression; }
	 
		public Equality_expressionContext() { }
		public void copyFrom(Equality_expressionContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class LogicalTrueContext extends Equality_expressionContext {
		public TerminalNode TRUE() { return getToken(OQLParser.TRUE, 0); }
		public LogicalTrueContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalTrue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalTrue(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalTrue(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalAndOrContext extends Equality_expressionContext {
		public Token op;
		public TerminalNode LOGICAL_AND() { return getToken(OQLParser.LOGICAL_AND, 0); }
		public Equality_expressionContext equality_expression(int i) {
			return getRuleContext(Equality_expressionContext.class,i);
		}
		public List<Equality_expressionContext> equality_expression() {
			return getRuleContexts(Equality_expressionContext.class);
		}
		public TerminalNode LOGICAL_OR() { return getToken(OQLParser.LOGICAL_OR, 0); }
		public LogicalAndOrContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalAndOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalAndOr(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalAndOr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalNotInContext extends Equality_expressionContext {
		public Token op;
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode NOTIN() { return getToken(OQLParser.NOTIN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public LogicalNotInContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalNotIn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalNotIn(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalNotIn(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalFalseContext extends Equality_expressionContext {
		public TerminalNode FALSE() { return getToken(OQLParser.FALSE, 0); }
		public LogicalFalseContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalFalse(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalFalse(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalFalse(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class Paren2Context extends Equality_expressionContext {
		public Equality_expressionContext equality_expression() {
			return getRuleContext(Equality_expressionContext.class,0);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public Paren2Context(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParen2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParen2(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParen2(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalInContext extends Equality_expressionContext {
		public Token op;
		public TerminalNode IN() { return getToken(OQLParser.IN, 0); }
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
		public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
		public LogicalInContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalIn(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalIn(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalIn(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LogicalCompareContext extends Equality_expressionContext {
		public Token op;
		public TerminalNode LESS_THAN() { return getToken(OQLParser.LESS_THAN, 0); }
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TerminalNode LESS_EQUAL_THAN() { return getToken(OQLParser.LESS_EQUAL_THAN, 0); }
		public TerminalNode GREATE_EQUAL_THAN() { return getToken(OQLParser.GREATE_EQUAL_THAN, 0); }
		public List<ExpressionContext> expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public TerminalNode EQUAL() { return getToken(OQLParser.EQUAL, 0); }
		public TerminalNode LIKE() { return getToken(OQLParser.LIKE, 0); }
		public TerminalNode NOT_EQUAL() { return getToken(OQLParser.NOT_EQUAL, 0); }
		public TerminalNode GREATE_THAN() { return getToken(OQLParser.GREATE_THAN, 0); }
		public LogicalCompareContext(Equality_expressionContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalCompare(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalCompare(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalCompare(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Equality_expressionContext equality_expression() throws RecognitionException {
		return equality_expression(0);
	}

	private Equality_expressionContext equality_expression(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, _parentState);
		Equality_expressionContext _prevctx = _localctx;
		int _startState = 2;
		enterRecursionRule(_localctx, 2, RULE_equality_expression, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(72);
			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
			case 1:
				{
				_localctx = new LogicalTrueContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(50); match(TRUE);
				}
				break;
			case 2:
				{
				_localctx = new LogicalFalseContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(51); match(FALSE);
				}
				break;
			case 3:
				{
				_localctx = new LogicalCompareContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(52); expression(0);
				setState(53);
				((LogicalCompareContext)_localctx).op = _input.LT(1);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GREATE_THAN) | (1L << GREATE_EQUAL_THAN) | (1L << LESS_THAN) | (1L << LESS_EQUAL_THAN) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << LIKE))) != 0)) ) {
					((LogicalCompareContext)_localctx).op = (Token)_errHandler.recoverInline(this);
				}
				consume();
				setState(54); expression(0);
				}
				break;
			case 4:
				{
				_localctx = new LogicalInContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(56); expression(0);
				setState(57); ((LogicalInContext)_localctx).op = match(IN);
				setState(58); match(LEFT_PAREN);
				setState(59); expression(0);
				setState(60); match(RIGHT_PAREN);
				}
				break;
			case 5:
				{
				_localctx = new LogicalNotInContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(62); expression(0);
				setState(63); ((LogicalNotInContext)_localctx).op = match(NOTIN);
				setState(64); match(LEFT_PAREN);
				setState(65); expression(0);
				setState(66); match(RIGHT_PAREN);
				}
				break;
			case 6:
				{
				_localctx = new Paren2Context(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(68); match(LEFT_PAREN);
				setState(69); equality_expression(0);
				setState(70); match(RIGHT_PAREN);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(79);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					{
					_localctx = new LogicalAndOrContext(new Equality_expressionContext(_parentctx, _parentState));
					pushNewRecursionContext(_localctx, _startState, RULE_equality_expression);
					setState(74);
					if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
					setState(75);
					((LogicalAndOrContext)_localctx).op = _input.LT(1);
					_la = _input.LA(1);
					if ( !(_la==LOGICAL_AND || _la==LOGICAL_OR) ) {
						((LogicalAndOrContext)_localctx).op = (Token)_errHandler.recoverInline(this);
					}
					consume();
					setState(76); equality_expression(3);
					}
					} 
				}
				setState(81);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 0: return expression_sempred((ExpressionContext)_localctx, predIndex);
		case 1: return equality_expression_sempred((Equality_expressionContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return precpred(_ctx, 6);
		case 1: return precpred(_ctx, 5);
		}
		return true;
	}
	private boolean equality_expression_sempred(Equality_expressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2: return precpred(_ctx, 2);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\36U\4\2\t\2\4\3\t"+
		"\3\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"+
		"\3\2\3\2\3\2\3\2\3\2\3\2\7\2\36\n\2\f\2\16\2!\13\2\3\2\3\2\3\2\3\2\5\2"+
		"\'\n\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2/\n\2\f\2\16\2\62\13\2\3\3\3\3\3\3\3"+
		"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
		"\3\3\3\3\5\3K\n\3\3\3\3\3\3\3\7\3P\n\3\f\3\16\3S\13\3\3\3\2\4\2\4\4\2"+
		"\4\2\7\4\2\34\34\36\36\3\2\7\b\3\2\5\6\5\2\13\17\23\23\31\31\3\2\24\25"+
		"d\2&\3\2\2\2\4J\3\2\2\2\6\7\b\2\1\2\7\b\7\6\2\2\b\'\5\2\2\t\t\'\7\35\2"+
		"\2\n\'\7\22\2\2\13\'\7\36\2\2\f\'\7\4\2\2\r\'\7\34\2\2\16\17\7\32\2\2"+
		"\17\20\7\26\2\2\20\21\5\2\2\2\21\22\7\27\2\2\22\'\3\2\2\2\23\24\7\33\2"+
		"\2\24\25\7\26\2\2\25\26\5\2\2\2\26\27\7\30\2\2\27\30\5\2\2\2\30\31\7\27"+
		"\2\2\31\'\3\2\2\2\32\37\t\2\2\2\33\34\7\30\2\2\34\36\t\2\2\2\35\33\3\2"+
		"\2\2\36!\3\2\2\2\37\35\3\2\2\2\37 \3\2\2\2 \'\3\2\2\2!\37\3\2\2\2\"#\7"+
		"\26\2\2#$\5\2\2\2$%\7\27\2\2%\'\3\2\2\2&\6\3\2\2\2&\t\3\2\2\2&\n\3\2\2"+
		"\2&\13\3\2\2\2&\f\3\2\2\2&\r\3\2\2\2&\16\3\2\2\2&\23\3\2\2\2&\32\3\2\2"+
		"\2&\"\3\2\2\2\'\60\3\2\2\2()\f\b\2\2)*\t\3\2\2*/\5\2\2\t+,\f\7\2\2,-\t"+
		"\4\2\2-/\5\2\2\b.(\3\2\2\2.+\3\2\2\2/\62\3\2\2\2\60.\3\2\2\2\60\61\3\2"+
		"\2\2\61\3\3\2\2\2\62\60\3\2\2\2\63\64\b\3\1\2\64K\7\20\2\2\65K\7\21\2"+
		"\2\66\67\5\2\2\2\678\t\5\2\289\5\2\2\29K\3\2\2\2:;\5\2\2\2;<\7\t\2\2<"+
		"=\7\26\2\2=>\5\2\2\2>?\7\27\2\2?K\3\2\2\2@A\5\2\2\2AB\7\n\2\2BC\7\26\2"+
		"\2CD\5\2\2\2DE\7\27\2\2EK\3\2\2\2FG\7\26\2\2GH\5\4\3\2HI\7\27\2\2IK\3"+
		"\2\2\2J\63\3\2\2\2J\65\3\2\2\2J\66\3\2\2\2J:\3\2\2\2J@\3\2\2\2JF\3\2\2"+
		"\2KQ\3\2\2\2LM\f\4\2\2MN\t\6\2\2NP\5\4\3\5OL\3\2\2\2PS\3\2\2\2QO\3\2\2"+
		"\2QR\3\2\2\2R\5\3\2\2\2SQ\3\2\2\2\b\37&.\60JQ";
	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);
		}
	}
}