• Home
• io.mindmaps
• mindmaps-graql
• 0.2.0
• source code
• GraqlParser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.mindmaps.graql.internal.parser.GraqlParser Maven / Gradle / Ivy

// Generated from io/mindmaps/graql/internal/parser/Graql.g4 by ANTLR 4.5
package io.mindmaps.graql.internal.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 GraqlParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, DATATYPE=45, 
		ORDER=46, BOOLEAN=47, VARIABLE=48, ID=49, STRING=50, REGEX=51, INTEGER=52, 
		REAL=53, COMMENT=54, WS=55, DOLLAR=56;
	public static final int
		RULE_queryEOF = 0, RULE_query = 1, RULE_matchEOF = 2, RULE_askEOF = 3, 
		RULE_insertEOF = 4, RULE_deleteEOF = 5, RULE_aggregateEOF = 6, RULE_computeEOF = 7, 
		RULE_matchQuery = 8, RULE_askQuery = 9, RULE_insertQuery = 10, RULE_deleteQuery = 11, 
		RULE_aggregateQuery = 12, RULE_computeQuery = 13, RULE_subgraph = 14, 
		RULE_aggregate = 15, RULE_argument = 16, RULE_namedAgg = 17, RULE_patterns = 18, 
		RULE_pattern = 19, RULE_varPatterns = 20, RULE_varPattern = 21, RULE_property = 22, 
		RULE_casting = 23, RULE_variable = 24, RULE_predicate = 25, RULE_value = 26, 
		RULE_patternSep = 27, RULE_id = 28;
	public static final String[] ruleNames = {
		"queryEOF", "query", "matchEOF", "askEOF", "insertEOF", "deleteEOF", "aggregateEOF", 
		"computeEOF", "matchQuery", "askQuery", "insertQuery", "deleteQuery", 
		"aggregateQuery", "computeQuery", "subgraph", "aggregate", "argument", 
		"namedAgg", "patterns", "pattern", "varPatterns", "varPattern", "property", 
		"casting", "variable", "predicate", "value", "patternSep", "id"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'match'", "'select'", "','", "';'", "'limit'", "'offset'", "'distinct'", 
		"'order'", "'by'", "'ask'", "'insert'", "'delete'", "'aggregate'", "'compute'", 
		"'in'", "'('", "')'", "'as'", "'or'", "'{'", "'}'", "'isa'", "'ako'", 
		"'has-role'", "'plays-role'", "'has-scope'", "'id'", "'value'", "'lhs'", 
		"'rhs'", "'has'", "'has-resource'", "'is-abstract'", "'datatype'", "'regex'", 
		"':'", "'='", "'!='", "'>'", "'>='", "'<'", "'<='", "'contains'", "'and'", 
		null, null, null, null, null, null, null, null, null, null, null, "'$'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, "DATATYPE", "ORDER", 
		"BOOLEAN", "VARIABLE", "ID", "STRING", "REGEX", "INTEGER", "REAL", "COMMENT", 
		"WS", "DOLLAR"
	};
	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] = "";
			}
		}
	}

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

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

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

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

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

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

	public GraqlParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class QueryEOFContext extends ParserRuleContext {
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public QueryEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_queryEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterQueryEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitQueryEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitQueryEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QueryEOFContext queryEOF() throws RecognitionException {
		QueryEOFContext _localctx = new QueryEOFContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_queryEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(58);
			query();
			setState(59);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class QueryContext extends ParserRuleContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public AskQueryContext askQuery() {
			return getRuleContext(AskQueryContext.class,0);
		}
		public InsertQueryContext insertQuery() {
			return getRuleContext(InsertQueryContext.class,0);
		}
		public DeleteQueryContext deleteQuery() {
			return getRuleContext(DeleteQueryContext.class,0);
		}
		public AggregateQueryContext aggregateQuery() {
			return getRuleContext(AggregateQueryContext.class,0);
		}
		public ComputeQueryContext computeQuery() {
			return getRuleContext(ComputeQueryContext.class,0);
		}
		public QueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_query; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QueryContext query() throws RecognitionException {
		QueryContext _localctx = new QueryContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_query);
		try {
			setState(67);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(61);
				matchQuery(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(62);
				askQuery();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(63);
				insertQuery();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(64);
				deleteQuery();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(65);
				aggregateQuery();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(66);
				computeQuery();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MatchEOFContext extends ParserRuleContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public MatchEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_matchEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MatchEOFContext matchEOF() throws RecognitionException {
		MatchEOFContext _localctx = new MatchEOFContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_matchEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(69);
			matchQuery(0);
			setState(70);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AskEOFContext extends ParserRuleContext {
		public AskQueryContext askQuery() {
			return getRuleContext(AskQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public AskEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_askEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAskEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAskEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAskEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AskEOFContext askEOF() throws RecognitionException {
		AskEOFContext _localctx = new AskEOFContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_askEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(72);
			askQuery();
			setState(73);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertEOFContext extends ParserRuleContext {
		public InsertQueryContext insertQuery() {
			return getRuleContext(InsertQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public InsertEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterInsertEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitInsertEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitInsertEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InsertEOFContext insertEOF() throws RecognitionException {
		InsertEOFContext _localctx = new InsertEOFContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_insertEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(75);
			insertQuery();
			setState(76);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeleteEOFContext extends ParserRuleContext {
		public DeleteQueryContext deleteQuery() {
			return getRuleContext(DeleteQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public DeleteEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterDeleteEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitDeleteEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitDeleteEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteEOFContext deleteEOF() throws RecognitionException {
		DeleteEOFContext _localctx = new DeleteEOFContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_deleteEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(78);
			deleteQuery();
			setState(79);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AggregateEOFContext extends ParserRuleContext {
		public AggregateQueryContext aggregateQuery() {
			return getRuleContext(AggregateQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public AggregateEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aggregateEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAggregateEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAggregateEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAggregateEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AggregateEOFContext aggregateEOF() throws RecognitionException {
		AggregateEOFContext _localctx = new AggregateEOFContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_aggregateEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(81);
			aggregateQuery();
			setState(82);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ComputeEOFContext extends ParserRuleContext {
		public ComputeQueryContext computeQuery() {
			return getRuleContext(ComputeQueryContext.class,0);
		}
		public TerminalNode EOF() { return getToken(GraqlParser.EOF, 0); }
		public ComputeEOFContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_computeEOF; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterComputeEOF(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitComputeEOF(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitComputeEOF(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ComputeEOFContext computeEOF() throws RecognitionException {
		ComputeEOFContext _localctx = new ComputeEOFContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_computeEOF);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(84);
			computeQuery();
			setState(85);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MatchQueryContext extends ParserRuleContext {
		public MatchQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_matchQuery; }
	 
		public MatchQueryContext() { }
		public void copyFrom(MatchQueryContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class MatchBaseContext extends MatchQueryContext {
		public PatternsContext patterns() {
			return getRuleContext(PatternsContext.class,0);
		}
		public MatchBaseContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchBase(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchBase(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchBase(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MatchSelectContext extends MatchQueryContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public List VARIABLE() { return getTokens(GraqlParser.VARIABLE); }
		public TerminalNode VARIABLE(int i) {
			return getToken(GraqlParser.VARIABLE, i);
		}
		public MatchSelectContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchSelect(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchSelect(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchSelect(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MatchOffsetContext extends MatchQueryContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public TerminalNode INTEGER() { return getToken(GraqlParser.INTEGER, 0); }
		public MatchOffsetContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchOffset(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchOffset(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchOffset(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MatchOrderByContext extends MatchQueryContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public TerminalNode VARIABLE() { return getToken(GraqlParser.VARIABLE, 0); }
		public TerminalNode ORDER() { return getToken(GraqlParser.ORDER, 0); }
		public MatchOrderByContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchOrderBy(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchOrderBy(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchOrderBy(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MatchLimitContext extends MatchQueryContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public TerminalNode INTEGER() { return getToken(GraqlParser.INTEGER, 0); }
		public MatchLimitContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchLimit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchLimit(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchLimit(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MatchDistinctContext extends MatchQueryContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public MatchDistinctContext(MatchQueryContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterMatchDistinct(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitMatchDistinct(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitMatchDistinct(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MatchQueryContext matchQuery() throws RecognitionException {
		return matchQuery(0);
	}

	private MatchQueryContext matchQuery(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		MatchQueryContext _localctx = new MatchQueryContext(_ctx, _parentState);
		MatchQueryContext _prevctx = _localctx;
		int _startState = 16;
		enterRecursionRule(_localctx, 16, RULE_matchQuery, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			{
			_localctx = new MatchBaseContext(_localctx);
			_ctx = _localctx;
			_prevctx = _localctx;

			setState(88);
			match(T__0);
			setState(89);
			patterns();
			}
			_ctx.stop = _input.LT(-1);
			setState(123);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(121);
					switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
					case 1:
						{
						_localctx = new MatchSelectContext(new MatchQueryContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_matchQuery);
						setState(91);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(92);
						match(T__1);
						setState(93);
						match(VARIABLE);
						setState(98);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==T__2) {
							{
							{
							setState(94);
							match(T__2);
							setState(95);
							match(VARIABLE);
							}
							}
							setState(100);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						setState(101);
						match(T__3);
						}
						break;
					case 2:
						{
						_localctx = new MatchLimitContext(new MatchQueryContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_matchQuery);
						setState(102);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(103);
						match(T__4);
						setState(104);
						match(INTEGER);
						setState(105);
						match(T__3);
						}
						break;
					case 3:
						{
						_localctx = new MatchOffsetContext(new MatchQueryContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_matchQuery);
						setState(106);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(107);
						match(T__5);
						setState(108);
						match(INTEGER);
						setState(109);
						match(T__3);
						}
						break;
					case 4:
						{
						_localctx = new MatchDistinctContext(new MatchQueryContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_matchQuery);
						setState(110);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(111);
						match(T__6);
						setState(112);
						match(T__3);
						}
						break;
					case 5:
						{
						_localctx = new MatchOrderByContext(new MatchQueryContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_matchQuery);
						setState(113);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(114);
						match(T__7);
						setState(115);
						match(T__8);
						setState(116);
						match(VARIABLE);
						setState(118);
						_la = _input.LA(1);
						if (_la==ORDER) {
							{
							setState(117);
							match(ORDER);
							}
						}

						setState(120);
						match(T__3);
						}
						break;
					}
					} 
				}
				setState(125);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class AskQueryContext extends ParserRuleContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public AskQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_askQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAskQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAskQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAskQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AskQueryContext askQuery() throws RecognitionException {
		AskQueryContext _localctx = new AskQueryContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_askQuery);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(126);
			matchQuery(0);
			setState(127);
			match(T__9);
			setState(128);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertQueryContext extends ParserRuleContext {
		public VarPatternsContext varPatterns() {
			return getRuleContext(VarPatternsContext.class,0);
		}
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public InsertQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterInsertQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitInsertQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitInsertQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InsertQueryContext insertQuery() throws RecognitionException {
		InsertQueryContext _localctx = new InsertQueryContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_insertQuery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(131);
			_la = _input.LA(1);
			if (_la==T__0) {
				{
				setState(130);
				matchQuery(0);
				}
			}

			setState(133);
			match(T__10);
			setState(134);
			varPatterns();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeleteQueryContext extends ParserRuleContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public VarPatternsContext varPatterns() {
			return getRuleContext(VarPatternsContext.class,0);
		}
		public DeleteQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterDeleteQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitDeleteQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitDeleteQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteQueryContext deleteQuery() throws RecognitionException {
		DeleteQueryContext _localctx = new DeleteQueryContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_deleteQuery);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(136);
			matchQuery(0);
			setState(137);
			match(T__11);
			setState(138);
			varPatterns();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AggregateQueryContext extends ParserRuleContext {
		public MatchQueryContext matchQuery() {
			return getRuleContext(MatchQueryContext.class,0);
		}
		public AggregateContext aggregate() {
			return getRuleContext(AggregateContext.class,0);
		}
		public AggregateQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aggregateQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAggregateQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAggregateQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAggregateQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AggregateQueryContext aggregateQuery() throws RecognitionException {
		AggregateQueryContext _localctx = new AggregateQueryContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_aggregateQuery);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(140);
			matchQuery(0);
			setState(141);
			match(T__12);
			setState(142);
			aggregate();
			setState(143);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ComputeQueryContext extends ParserRuleContext {
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public SubgraphContext subgraph() {
			return getRuleContext(SubgraphContext.class,0);
		}
		public ComputeQueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_computeQuery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterComputeQuery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitComputeQuery(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitComputeQuery(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ComputeQueryContext computeQuery() throws RecognitionException {
		ComputeQueryContext _localctx = new ComputeQueryContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_computeQuery);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(145);
			match(T__13);
			setState(146);
			id();
			setState(149);
			_la = _input.LA(1);
			if (_la==T__14) {
				{
				setState(147);
				match(T__14);
				setState(148);
				subgraph();
				}
			}

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

	public static class SubgraphContext extends ParserRuleContext {
		public List id() {
			return getRuleContexts(IdContext.class);
		}
		public IdContext id(int i) {
			return getRuleContext(IdContext.class,i);
		}
		public SubgraphContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subgraph; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterSubgraph(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitSubgraph(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitSubgraph(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubgraphContext subgraph() throws RecognitionException {
		SubgraphContext _localctx = new SubgraphContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_subgraph);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(153);
			id();
			setState(158);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__2) {
				{
				{
				setState(154);
				match(T__2);
				setState(155);
				id();
				}
				}
				setState(160);
				_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 AggregateContext extends ParserRuleContext {
		public AggregateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aggregate; }
	 
		public AggregateContext() { }
		public void copyFrom(AggregateContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SelectAggContext extends AggregateContext {
		public List namedAgg() {
			return getRuleContexts(NamedAggContext.class);
		}
		public NamedAggContext namedAgg(int i) {
			return getRuleContext(NamedAggContext.class,i);
		}
		public SelectAggContext(AggregateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterSelectAgg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitSelectAgg(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitSelectAgg(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class CustomAggContext extends AggregateContext {
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public List argument() {
			return getRuleContexts(ArgumentContext.class);
		}
		public ArgumentContext argument(int i) {
			return getRuleContext(ArgumentContext.class,i);
		}
		public CustomAggContext(AggregateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterCustomAgg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitCustomAgg(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitCustomAgg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AggregateContext aggregate() throws RecognitionException {
		AggregateContext _localctx = new AggregateContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_aggregate);
		int _la;
		try {
			int _alt;
			setState(179);
			switch (_input.LA(1)) {
			case ID:
			case STRING:
				_localctx = new CustomAggContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(161);
				id();
				setState(165);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(162);
						argument();
						}
						} 
					}
					setState(167);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
				}
				}
				break;
			case T__15:
				_localctx = new SelectAggContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(168);
				match(T__15);
				setState(169);
				namedAgg();
				setState(174);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__2) {
					{
					{
					setState(170);
					match(T__2);
					setState(171);
					namedAgg();
					}
					}
					setState(176);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(177);
				match(T__16);
				}
				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 ArgumentContext extends ParserRuleContext {
		public ArgumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argument; }
	 
		public ArgumentContext() { }
		public void copyFrom(ArgumentContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class AggregateArgumentContext extends ArgumentContext {
		public AggregateContext aggregate() {
			return getRuleContext(AggregateContext.class,0);
		}
		public AggregateArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAggregateArgument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAggregateArgument(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAggregateArgument(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class VariableArgumentContext extends ArgumentContext {
		public TerminalNode VARIABLE() { return getToken(GraqlParser.VARIABLE, 0); }
		public VariableArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterVariableArgument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitVariableArgument(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitVariableArgument(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArgumentContext argument() throws RecognitionException {
		ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_argument);
		try {
			setState(183);
			switch (_input.LA(1)) {
			case VARIABLE:
				_localctx = new VariableArgumentContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(181);
				match(VARIABLE);
				}
				break;
			case T__15:
			case ID:
			case STRING:
				_localctx = new AggregateArgumentContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(182);
				aggregate();
				}
				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 NamedAggContext extends ParserRuleContext {
		public AggregateContext aggregate() {
			return getRuleContext(AggregateContext.class,0);
		}
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public NamedAggContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namedAgg; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterNamedAgg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitNamedAgg(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitNamedAgg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NamedAggContext namedAgg() throws RecognitionException {
		NamedAggContext _localctx = new NamedAggContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_namedAgg);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(185);
			aggregate();
			setState(186);
			match(T__17);
			setState(187);
			id();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PatternsContext extends ParserRuleContext {
		public List pattern() {
			return getRuleContexts(PatternContext.class);
		}
		public PatternContext pattern(int i) {
			return getRuleContext(PatternContext.class,i);
		}
		public PatternsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_patterns; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPatterns(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPatterns(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPatterns(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PatternsContext patterns() throws RecognitionException {
		PatternsContext _localctx = new PatternsContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_patterns);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(192); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(189);
					pattern(0);
					setState(190);
					match(T__3);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(194); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,12,_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 PatternContext extends ParserRuleContext {
		public PatternContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pattern; }
	 
		public PatternContext() { }
		public void copyFrom(PatternContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class VarPatternCaseContext extends PatternContext {
		public VarPatternContext varPattern() {
			return getRuleContext(VarPatternContext.class,0);
		}
		public VarPatternCaseContext(PatternContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterVarPatternCase(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitVarPatternCase(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitVarPatternCase(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class AndPatternContext extends PatternContext {
		public PatternsContext patterns() {
			return getRuleContext(PatternsContext.class,0);
		}
		public AndPatternContext(PatternContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAndPattern(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAndPattern(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAndPattern(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class OrPatternContext extends PatternContext {
		public List pattern() {
			return getRuleContexts(PatternContext.class);
		}
		public PatternContext pattern(int i) {
			return getRuleContext(PatternContext.class,i);
		}
		public OrPatternContext(PatternContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterOrPattern(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitOrPattern(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitOrPattern(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PatternContext pattern() throws RecognitionException {
		return pattern(0);
	}

	private PatternContext pattern(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		PatternContext _localctx = new PatternContext(_ctx, _parentState);
		PatternContext _prevctx = _localctx;
		int _startState = 38;
		enterRecursionRule(_localctx, 38, RULE_pattern, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(202);
			switch (_input.LA(1)) {
			case T__15:
			case T__21:
			case T__22:
			case T__23:
			case T__24:
			case T__25:
			case T__26:
			case T__27:
			case T__28:
			case T__29:
			case T__30:
			case T__31:
			case T__32:
			case T__33:
			case T__34:
			case VARIABLE:
			case ID:
			case STRING:
				{
				_localctx = new VarPatternCaseContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(197);
				varPattern();
				}
				break;
			case T__19:
				{
				_localctx = new AndPatternContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(198);
				match(T__19);
				setState(199);
				patterns();
				setState(200);
				match(T__20);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(209);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,14,_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 OrPatternContext(new PatternContext(_parentctx, _parentState));
					pushNewRecursionContext(_localctx, _startState, RULE_pattern);
					setState(204);
					if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
					setState(205);
					match(T__18);
					setState(206);
					pattern(3);
					}
					} 
				}
				setState(211);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class VarPatternsContext extends ParserRuleContext {
		public List varPattern() {
			return getRuleContexts(VarPatternContext.class);
		}
		public VarPatternContext varPattern(int i) {
			return getRuleContext(VarPatternContext.class,i);
		}
		public VarPatternsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_varPatterns; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterVarPatterns(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitVarPatterns(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitVarPatterns(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VarPatternsContext varPatterns() throws RecognitionException {
		VarPatternsContext _localctx = new VarPatternsContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_varPatterns);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(215); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(212);
				varPattern();
				setState(213);
				match(T__3);
				}
				}
				setState(217); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__15) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << VARIABLE) | (1L << ID) | (1L << STRING))) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VarPatternContext extends ParserRuleContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public List property() {
			return getRuleContexts(PropertyContext.class);
		}
		public PropertyContext property(int i) {
			return getRuleContext(PropertyContext.class,i);
		}
		public VarPatternContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_varPattern; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterVarPattern(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitVarPattern(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitVarPattern(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VarPatternContext varPattern() throws RecognitionException {
		VarPatternContext _localctx = new VarPatternContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_varPattern);
		int _la;
		try {
			int _alt;
			setState(233);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(219);
				variable();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(221);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VARIABLE) | (1L << ID) | (1L << STRING))) != 0)) {
					{
					setState(220);
					variable();
					}
				}

				setState(223);
				property();
				setState(230);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(225);
						_la = _input.LA(1);
						if (_la==T__2) {
							{
							setState(224);
							match(T__2);
							}
						}

						setState(227);
						property();
						}
						} 
					}
					setState(232);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PropertyContext extends ParserRuleContext {
		public PropertyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_property; }
	 
		public PropertyContext() { }
		public void copyFrom(PropertyContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class PropDatatypeContext extends PropertyContext {
		public TerminalNode DATATYPE() { return getToken(GraqlParser.DATATYPE, 0); }
		public PropDatatypeContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropDatatype(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropDatatype(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropDatatype(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class AkoContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public AkoContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterAko(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitAko(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitAko(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropRelContext extends PropertyContext {
		public List casting() {
			return getRuleContexts(CastingContext.class);
		}
		public CastingContext casting(int i) {
			return getRuleContext(CastingContext.class,i);
		}
		public PropRelContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropRel(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropRel(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropRel(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropHasContext extends PropertyContext {
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public PredicateContext predicate() {
			return getRuleContext(PredicateContext.class,0);
		}
		public TerminalNode VARIABLE() { return getToken(GraqlParser.VARIABLE, 0); }
		public PropHasContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropHas(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropHas(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropHas(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropLhsContext extends PropertyContext {
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public PropLhsContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropLhs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropLhs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropLhs(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropIdContext extends PropertyContext {
		public TerminalNode STRING() { return getToken(GraqlParser.STRING, 0); }
		public PropIdContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropId(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropRhsContext extends PropertyContext {
		public QueryContext query() {
			return getRuleContext(QueryContext.class,0);
		}
		public PropRhsContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropRhs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropRhs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropRhs(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class IsAbstractContext extends PropertyContext {
		public IsAbstractContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterIsAbstract(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitIsAbstract(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitIsAbstract(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class HasScopeContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public HasScopeContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterHasScope(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitHasScope(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitHasScope(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropResourceContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public PropResourceContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropResource(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropResource(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropResource(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PlaysRoleContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public PlaysRoleContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPlaysRole(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPlaysRole(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPlaysRole(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class IsaContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public IsaContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterIsa(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitIsa(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitIsa(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropRegexContext extends PropertyContext {
		public TerminalNode REGEX() { return getToken(GraqlParser.REGEX, 0); }
		public PropRegexContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropRegex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropRegex(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropRegex(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class HasRoleContext extends PropertyContext {
		public VariableContext variable() {
			return getRuleContext(VariableContext.class,0);
		}
		public HasRoleContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterHasRole(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitHasRole(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitHasRole(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PropValueContext extends PropertyContext {
		public PredicateContext predicate() {
			return getRuleContext(PredicateContext.class,0);
		}
		public PropValueContext(PropertyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPropValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPropValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPropValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PropertyContext property() throws RecognitionException {
		PropertyContext _localctx = new PropertyContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_property);
		int _la;
		try {
			setState(285);
			switch (_input.LA(1)) {
			case T__21:
				_localctx = new IsaContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(235);
				match(T__21);
				setState(236);
				variable();
				}
				break;
			case T__22:
				_localctx = new AkoContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(237);
				match(T__22);
				setState(238);
				variable();
				}
				break;
			case T__23:
				_localctx = new HasRoleContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(239);
				match(T__23);
				setState(240);
				variable();
				}
				break;
			case T__24:
				_localctx = new PlaysRoleContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(241);
				match(T__24);
				setState(242);
				variable();
				}
				break;
			case T__25:
				_localctx = new HasScopeContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(243);
				match(T__25);
				setState(244);
				variable();
				}
				break;
			case T__26:
				_localctx = new PropIdContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(245);
				match(T__26);
				setState(246);
				match(STRING);
				}
				break;
			case T__27:
				_localctx = new PropValueContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(247);
				match(T__27);
				setState(249);
				switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
				case 1:
					{
					setState(248);
					predicate(0);
					}
					break;
				}
				}
				break;
			case T__28:
				_localctx = new PropLhsContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(251);
				match(T__28);
				setState(252);
				match(T__19);
				setState(253);
				query();
				setState(254);
				match(T__20);
				}
				break;
			case T__29:
				_localctx = new PropRhsContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(256);
				match(T__29);
				setState(257);
				match(T__19);
				setState(258);
				query();
				setState(259);
				match(T__20);
				}
				break;
			case T__30:
				_localctx = new PropHasContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(261);
				match(T__30);
				setState(262);
				id();
				setState(265);
				switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
				case 1:
					{
					setState(263);
					predicate(0);
					}
					break;
				case 2:
					{
					setState(264);
					match(VARIABLE);
					}
					break;
				}
				}
				break;
			case T__31:
				_localctx = new PropResourceContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(267);
				match(T__31);
				setState(268);
				variable();
				}
				break;
			case T__15:
				_localctx = new PropRelContext(_localctx);
				enterOuterAlt(_localctx, 12);
				{
				setState(269);
				match(T__15);
				setState(270);
				casting();
				setState(275);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__2) {
					{
					{
					setState(271);
					match(T__2);
					setState(272);
					casting();
					}
					}
					setState(277);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(278);
				match(T__16);
				}
				break;
			case T__32:
				_localctx = new IsAbstractContext(_localctx);
				enterOuterAlt(_localctx, 13);
				{
				setState(280);
				match(T__32);
				}
				break;
			case T__33:
				_localctx = new PropDatatypeContext(_localctx);
				enterOuterAlt(_localctx, 14);
				{
				setState(281);
				match(T__33);
				setState(282);
				match(DATATYPE);
				}
				break;
			case T__34:
				_localctx = new PropRegexContext(_localctx);
				enterOuterAlt(_localctx, 15);
				{
				setState(283);
				match(T__34);
				setState(284);
				match(REGEX);
				}
				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 CastingContext extends ParserRuleContext {
		public List variable() {
			return getRuleContexts(VariableContext.class);
		}
		public VariableContext variable(int i) {
			return getRuleContext(VariableContext.class,i);
		}
		public CastingContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_casting; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterCasting(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitCasting(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitCasting(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CastingContext casting() throws RecognitionException {
		CastingContext _localctx = new CastingContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_casting);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(290);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				{
				setState(287);
				variable();
				setState(288);
				match(T__35);
				}
				break;
			}
			setState(292);
			variable();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariableContext extends ParserRuleContext {
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode VARIABLE() { return getToken(GraqlParser.VARIABLE, 0); }
		public VariableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterVariable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitVariable(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitVariable(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableContext variable() throws RecognitionException {
		VariableContext _localctx = new VariableContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_variable);
		try {
			setState(296);
			switch (_input.LA(1)) {
			case ID:
			case STRING:
				enterOuterAlt(_localctx, 1);
				{
				setState(294);
				id();
				}
				break;
			case VARIABLE:
				enterOuterAlt(_localctx, 2);
				{
				setState(295);
				match(VARIABLE);
				}
				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 PredicateContext extends ParserRuleContext {
		public PredicateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_predicate; }
	 
		public PredicateContext() { }
		public void copyFrom(PredicateContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class PredicateEqContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateEqContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateEq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateEq(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateEq(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateAndContext extends PredicateContext {
		public List predicate() {
			return getRuleContexts(PredicateContext.class);
		}
		public PredicateContext predicate(int i) {
			return getRuleContext(PredicateContext.class,i);
		}
		public PredicateAndContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateAnd(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateAnd(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateAnd(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateGteContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateGteContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateGte(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateGte(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateGte(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateNeqContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateNeqContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateNeq(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateNeq(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateNeq(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateRegexContext extends PredicateContext {
		public TerminalNode REGEX() { return getToken(GraqlParser.REGEX, 0); }
		public PredicateRegexContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateRegex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateRegex(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateRegex(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateContainsContext extends PredicateContext {
		public TerminalNode STRING() { return getToken(GraqlParser.STRING, 0); }
		public PredicateContainsContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateContains(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateContains(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateContains(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateGtContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateGtContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateGt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateGt(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateGt(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateLteContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateLteContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateLte(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateLte(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateLte(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateParensContext extends PredicateContext {
		public PredicateContext predicate() {
			return getRuleContext(PredicateContext.class,0);
		}
		public PredicateParensContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateParens(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateParens(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateParens(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateOrContext extends PredicateContext {
		public List predicate() {
			return getRuleContexts(PredicateContext.class);
		}
		public PredicateContext predicate(int i) {
			return getRuleContext(PredicateContext.class,i);
		}
		public PredicateOrContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateOr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateOr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateOr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PredicateLtContext extends PredicateContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public PredicateLtContext(PredicateContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPredicateLt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPredicateLt(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPredicateLt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PredicateContext predicate() throws RecognitionException {
		return predicate(0);
	}

	private PredicateContext predicate(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		PredicateContext _localctx = new PredicateContext(_ctx, _parentState);
		PredicateContext _prevctx = _localctx;
		int _startState = 50;
		enterRecursionRule(_localctx, 50, RULE_predicate, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(320);
			switch (_input.LA(1)) {
			case T__36:
			case BOOLEAN:
			case STRING:
			case INTEGER:
			case REAL:
				{
				_localctx = new PredicateEqContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;

				setState(300);
				_la = _input.LA(1);
				if (_la==T__36) {
					{
					setState(299);
					match(T__36);
					}
				}

				setState(302);
				value();
				}
				break;
			case T__37:
				{
				_localctx = new PredicateNeqContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(303);
				match(T__37);
				setState(304);
				value();
				}
				break;
			case T__38:
				{
				_localctx = new PredicateGtContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(305);
				match(T__38);
				setState(306);
				value();
				}
				break;
			case T__39:
				{
				_localctx = new PredicateGteContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(307);
				match(T__39);
				setState(308);
				value();
				}
				break;
			case T__40:
				{
				_localctx = new PredicateLtContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(309);
				match(T__40);
				setState(310);
				value();
				}
				break;
			case T__41:
				{
				_localctx = new PredicateLteContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(311);
				match(T__41);
				setState(312);
				value();
				}
				break;
			case T__42:
				{
				_localctx = new PredicateContainsContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(313);
				match(T__42);
				setState(314);
				match(STRING);
				}
				break;
			case REGEX:
				{
				_localctx = new PredicateRegexContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(315);
				match(REGEX);
				}
				break;
			case T__15:
				{
				_localctx = new PredicateParensContext(_localctx);
				_ctx = _localctx;
				_prevctx = _localctx;
				setState(316);
				match(T__15);
				setState(317);
				predicate(0);
				setState(318);
				match(T__16);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(330);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(328);
					switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
					case 1:
						{
						_localctx = new PredicateAndContext(new PredicateContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_predicate);
						setState(322);
						if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
						setState(323);
						match(T__43);
						setState(324);
						predicate(4);
						}
						break;
					case 2:
						{
						_localctx = new PredicateOrContext(new PredicateContext(_parentctx, _parentState));
						pushNewRecursionContext(_localctx, _startState, RULE_predicate);
						setState(325);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(326);
						match(T__18);
						setState(327);
						predicate(3);
						}
						break;
					}
					} 
				}
				setState(332);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class ValueContext extends ParserRuleContext {
		public ValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_value; }
	 
		public ValueContext() { }
		public void copyFrom(ValueContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ValueBooleanContext extends ValueContext {
		public TerminalNode BOOLEAN() { return getToken(GraqlParser.BOOLEAN, 0); }
		public ValueBooleanContext(ValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterValueBoolean(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitValueBoolean(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitValueBoolean(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ValueStringContext extends ValueContext {
		public TerminalNode STRING() { return getToken(GraqlParser.STRING, 0); }
		public ValueStringContext(ValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterValueString(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitValueString(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitValueString(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ValueRealContext extends ValueContext {
		public TerminalNode REAL() { return getToken(GraqlParser.REAL, 0); }
		public ValueRealContext(ValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterValueReal(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitValueReal(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitValueReal(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ValueIntegerContext extends ValueContext {
		public TerminalNode INTEGER() { return getToken(GraqlParser.INTEGER, 0); }
		public ValueIntegerContext(ValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterValueInteger(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitValueInteger(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitValueInteger(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueContext value() throws RecognitionException {
		ValueContext _localctx = new ValueContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_value);
		try {
			setState(337);
			switch (_input.LA(1)) {
			case STRING:
				_localctx = new ValueStringContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(333);
				match(STRING);
				}
				break;
			case INTEGER:
				_localctx = new ValueIntegerContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(334);
				match(INTEGER);
				}
				break;
			case REAL:
				_localctx = new ValueRealContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(335);
				match(REAL);
				}
				break;
			case BOOLEAN:
				_localctx = new ValueBooleanContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(336);
				match(BOOLEAN);
				}
				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 PatternSepContext extends ParserRuleContext {
		public PatternContext pattern() {
			return getRuleContext(PatternContext.class,0);
		}
		public PatternSepContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_patternSep; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterPatternSep(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitPatternSep(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitPatternSep(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PatternSepContext patternSep() throws RecognitionException {
		PatternSepContext _localctx = new PatternSepContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_patternSep);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(339);
			pattern(0);
			setState(340);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IdContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(GraqlParser.ID, 0); }
		public TerminalNode STRING() { return getToken(GraqlParser.STRING, 0); }
		public IdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_id; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).enterId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof GraqlListener ) ((GraqlListener)listener).exitId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof GraqlVisitor ) return ((GraqlVisitor)visitor).visitId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdContext id() throws RecognitionException {
		IdContext _localctx = new IdContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_id);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(342);
			_la = _input.LA(1);
			if ( !(_la==ID || _la==STRING) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 8:
			return matchQuery_sempred((MatchQueryContext)_localctx, predIndex);
		case 19:
			return pattern_sempred((PatternContext)_localctx, predIndex);
		case 25:
			return predicate_sempred((PredicateContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean matchQuery_sempred(MatchQueryContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 5);
		case 1:
			return precpred(_ctx, 4);
		case 2:
			return precpred(_ctx, 3);
		case 3:
			return precpred(_ctx, 2);
		case 4:
			return precpred(_ctx, 1);
		}
		return true;
	}
	private boolean pattern_sempred(PatternContext _localctx, int predIndex) {
		switch (predIndex) {
		case 5:
			return precpred(_ctx, 2);
		}
		return true;
	}
	private boolean predicate_sempred(PredicateContext _localctx, int predIndex) {
		switch (predIndex) {
		case 6:
			return precpred(_ctx, 3);
		case 7:
			return precpred(_ctx, 2);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3:\u015b\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\3\2\3\2\3\2\3\3\3\3"+
		"\3\3\3\3\3\3\3\3\5\3F\n\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7"+
		"\3\7\3\b\3\b\3\b\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\nc"+
		"\n\n\f\n\16\nf\13\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+
		"\n\3\n\3\n\3\n\3\n\5\ny\n\n\3\n\7\n|\n\n\f\n\16\n\177\13\n\3\13\3\13\3"+
		"\13\3\13\3\f\5\f\u0086\n\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16"+
		"\3\16\3\16\3\17\3\17\3\17\3\17\5\17\u0098\n\17\3\17\3\17\3\20\3\20\3\20"+
		"\7\20\u009f\n\20\f\20\16\20\u00a2\13\20\3\21\3\21\7\21\u00a6\n\21\f\21"+
		"\16\21\u00a9\13\21\3\21\3\21\3\21\3\21\7\21\u00af\n\21\f\21\16\21\u00b2"+
		"\13\21\3\21\3\21\5\21\u00b6\n\21\3\22\3\22\5\22\u00ba\n\22\3\23\3\23\3"+
		"\23\3\23\3\24\3\24\3\24\6\24\u00c3\n\24\r\24\16\24\u00c4\3\25\3\25\3\25"+
		"\3\25\3\25\3\25\5\25\u00cd\n\25\3\25\3\25\3\25\7\25\u00d2\n\25\f\25\16"+
		"\25\u00d5\13\25\3\26\3\26\3\26\6\26\u00da\n\26\r\26\16\26\u00db\3\27\3"+
		"\27\5\27\u00e0\n\27\3\27\3\27\5\27\u00e4\n\27\3\27\7\27\u00e7\n\27\f\27"+
		"\16\27\u00ea\13\27\5\27\u00ec\n\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30"+
		"\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u00fc\n\30\3\30\3\30\3\30\3\30"+
		"\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u010c\n\30\3\30"+
		"\3\30\3\30\3\30\3\30\3\30\7\30\u0114\n\30\f\30\16\30\u0117\13\30\3\30"+
		"\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0120\n\30\3\31\3\31\3\31\5\31\u0125"+
		"\n\31\3\31\3\31\3\32\3\32\5\32\u012b\n\32\3\33\3\33\5\33\u012f\n\33\3"+
		"\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3"+
		"\33\3\33\3\33\3\33\5\33\u0143\n\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33"+
		"\u014b\n\33\f\33\16\33\u014e\13\33\3\34\3\34\3\34\3\34\5\34\u0154\n\34"+
		"\3\35\3\35\3\35\3\36\3\36\3\36\2\5\22(\64\37\2\4\6\b\n\f\16\20\22\24\26"+
		"\30\32\34\36 \"$&(*,.\60\62\64\668:\2\3\3\2\63\64\u017a\2<\3\2\2\2\4E"+
		"\3\2\2\2\6G\3\2\2\2\bJ\3\2\2\2\nM\3\2\2\2\fP\3\2\2\2\16S\3\2\2\2\20V\3"+
		"\2\2\2\22Y\3\2\2\2\24\u0080\3\2\2\2\26\u0085\3\2\2\2\30\u008a\3\2\2\2"+
		"\32\u008e\3\2\2\2\34\u0093\3\2\2\2\36\u009b\3\2\2\2 \u00b5\3\2\2\2\"\u00b9"+
		"\3\2\2\2$\u00bb\3\2\2\2&\u00c2\3\2\2\2(\u00cc\3\2\2\2*\u00d9\3\2\2\2,"+
		"\u00eb\3\2\2\2.\u011f\3\2\2\2\60\u0124\3\2\2\2\62\u012a\3\2\2\2\64\u0142"+
		"\3\2\2\2\66\u0153\3\2\2\28\u0155\3\2\2\2:\u0158\3\2\2\2<=\5\4\3\2=>\7"+
		"\2\2\3>\3\3\2\2\2?F\5\22\n\2@F\5\24\13\2AF\5\26\f\2BF\5\30\r\2CF\5\32"+
		"\16\2DF\5\34\17\2E?\3\2\2\2E@\3\2\2\2EA\3\2\2\2EB\3\2\2\2EC\3\2\2\2ED"+
		"\3\2\2\2F\5\3\2\2\2GH\5\22\n\2HI\7\2\2\3I\7\3\2\2\2JK\5\24\13\2KL\7\2"+
		"\2\3L\t\3\2\2\2MN\5\26\f\2NO\7\2\2\3O\13\3\2\2\2PQ\5\30\r\2QR\7\2\2\3"+
		"R\r\3\2\2\2ST\5\32\16\2TU\7\2\2\3U\17\3\2\2\2VW\5\34\17\2WX\7\2\2\3X\21"+
		"\3\2\2\2YZ\b\n\1\2Z[\7\3\2\2[\\\5&\24\2\\}\3\2\2\2]^\f\7\2\2^_\7\4\2\2"+
		"_d\7\62\2\2`a\7\5\2\2ac\7\62\2\2b`\3\2\2\2cf\3\2\2\2db\3\2\2\2de\3\2\2"+
		"\2eg\3\2\2\2fd\3\2\2\2g|\7\6\2\2hi\f\6\2\2ij\7\7\2\2jk\7\66\2\2k|\7\6"+
		"\2\2lm\f\5\2\2mn\7\b\2\2no\7\66\2\2o|\7\6\2\2pq\f\4\2\2qr\7\t\2\2r|\7"+
		"\6\2\2st\f\3\2\2tu\7\n\2\2uv\7\13\2\2vx\7\62\2\2wy\7\60\2\2xw\3\2\2\2"+
		"xy\3\2\2\2yz\3\2\2\2z|\7\6\2\2{]\3\2\2\2{h\3\2\2\2{l\3\2\2\2{p\3\2\2\2"+
		"{s\3\2\2\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\23\3\2\2\2\177}\3\2\2\2\u0080"+
		"\u0081\5\22\n\2\u0081\u0082\7\f\2\2\u0082\u0083\7\6\2\2\u0083\25\3\2\2"+
		"\2\u0084\u0086\5\22\n\2\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2\2\u0086"+
		"\u0087\3\2\2\2\u0087\u0088\7\r\2\2\u0088\u0089\5*\26\2\u0089\27\3\2\2"+
		"\2\u008a\u008b\5\22\n\2\u008b\u008c\7\16\2\2\u008c\u008d\5*\26\2\u008d"+
		"\31\3\2\2\2\u008e\u008f\5\22\n\2\u008f\u0090\7\17\2\2\u0090\u0091\5 \21"+
		"\2\u0091\u0092\7\6\2\2\u0092\33\3\2\2\2\u0093\u0094\7\20\2\2\u0094\u0097"+
		"\5:\36\2\u0095\u0096\7\21\2\2\u0096\u0098\5\36\20\2\u0097\u0095\3\2\2"+
		"\2\u0097\u0098\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009a\7\6\2\2\u009a\35"+
		"\3\2\2\2\u009b\u00a0\5:\36\2\u009c\u009d\7\5\2\2\u009d\u009f\5:\36\2\u009e"+
		"\u009c\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u00a1\3\2"+
		"\2\2\u00a1\37\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a7\5:\36\2\u00a4\u00a6"+
		"\5\"\22\2\u00a5\u00a4\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a5\3\2\2\2"+
		"\u00a7\u00a8\3\2\2\2\u00a8\u00b6\3\2\2\2\u00a9\u00a7\3\2\2\2\u00aa\u00ab"+
		"\7\22\2\2\u00ab\u00b0\5$\23\2\u00ac\u00ad\7\5\2\2\u00ad\u00af\5$\23\2"+
		"\u00ae\u00ac\3\2\2\2\u00af\u00b2\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00b1"+
		"\3\2\2\2\u00b1\u00b3\3\2\2\2\u00b2\u00b0\3\2\2\2\u00b3\u00b4\7\23\2\2"+
		"\u00b4\u00b6\3\2\2\2\u00b5\u00a3\3\2\2\2\u00b5\u00aa\3\2\2\2\u00b6!\3"+
		"\2\2\2\u00b7\u00ba\7\62\2\2\u00b8\u00ba\5 \21\2\u00b9\u00b7\3\2\2\2\u00b9"+
		"\u00b8\3\2\2\2\u00ba#\3\2\2\2\u00bb\u00bc\5 \21\2\u00bc\u00bd\7\24\2\2"+
		"\u00bd\u00be\5:\36\2\u00be%\3\2\2\2\u00bf\u00c0\5(\25\2\u00c0\u00c1\7"+
		"\6\2\2\u00c1\u00c3\3\2\2\2\u00c2\u00bf\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4"+
		"\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\'\3\2\2\2\u00c6\u00c7\b\25\1"+
		"\2\u00c7\u00cd\5,\27\2\u00c8\u00c9\7\26\2\2\u00c9\u00ca\5&\24\2\u00ca"+
		"\u00cb\7\27\2\2\u00cb\u00cd\3\2\2\2\u00cc\u00c6\3\2\2\2\u00cc\u00c8\3"+
		"\2\2\2\u00cd\u00d3\3\2\2\2\u00ce\u00cf\f\4\2\2\u00cf\u00d0\7\25\2\2\u00d0"+
		"\u00d2\5(\25\5\u00d1\u00ce\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d1\3\2"+
		"\2\2\u00d3\u00d4\3\2\2\2\u00d4)\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d6\u00d7"+
		"\5,\27\2\u00d7\u00d8\7\6\2\2\u00d8\u00da\3\2\2\2\u00d9\u00d6\3\2\2\2\u00da"+
		"\u00db\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc+\3\2\2\2"+
		"\u00dd\u00ec\5\62\32\2\u00de\u00e0\5\62\32\2\u00df\u00de\3\2\2\2\u00df"+
		"\u00e0\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e8\5.\30\2\u00e2\u00e4\7\5"+
		"\2\2\u00e3\u00e2\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5"+
		"\u00e7\5.\30\2\u00e6\u00e3\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2"+
		"\2\2\u00e8\u00e9\3\2\2\2\u00e9\u00ec\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb"+
		"\u00dd\3\2\2\2\u00eb\u00df\3\2\2\2\u00ec-\3\2\2\2\u00ed\u00ee\7\30\2\2"+
		"\u00ee\u0120\5\62\32\2\u00ef\u00f0\7\31\2\2\u00f0\u0120\5\62\32\2\u00f1"+
		"\u00f2\7\32\2\2\u00f2\u0120\5\62\32\2\u00f3\u00f4\7\33\2\2\u00f4\u0120"+
		"\5\62\32\2\u00f5\u00f6\7\34\2\2\u00f6\u0120\5\62\32\2\u00f7\u00f8\7\35"+
		"\2\2\u00f8\u0120\7\64\2\2\u00f9\u00fb\7\36\2\2\u00fa\u00fc\5\64\33\2\u00fb"+
		"\u00fa\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u0120\3\2\2\2\u00fd\u00fe\7\37"+
		"\2\2\u00fe\u00ff\7\26\2\2\u00ff\u0100\5\4\3\2\u0100\u0101\7\27\2\2\u0101"+
		"\u0120\3\2\2\2\u0102\u0103\7 \2\2\u0103\u0104\7\26\2\2\u0104\u0105\5\4"+
		"\3\2\u0105\u0106\7\27\2\2\u0106\u0120\3\2\2\2\u0107\u0108\7!\2\2\u0108"+
		"\u010b\5:\36\2\u0109\u010c\5\64\33\2\u010a\u010c\7\62\2\2\u010b\u0109"+
		"\3\2\2\2\u010b\u010a\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u0120\3\2\2\2\u010d"+
		"\u010e\7\"\2\2\u010e\u0120\5\62\32\2\u010f\u0110\7\22\2\2\u0110\u0115"+
		"\5\60\31\2\u0111\u0112\7\5\2\2\u0112\u0114\5\60\31\2\u0113\u0111\3\2\2"+
		"\2\u0114\u0117\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0116\3\2\2\2\u0116\u0118"+
		"\3\2\2\2\u0117\u0115\3\2\2\2\u0118\u0119\7\23\2\2\u0119\u0120\3\2\2\2"+
		"\u011a\u0120\7#\2\2\u011b\u011c\7$\2\2\u011c\u0120\7/\2\2\u011d\u011e"+
		"\7%\2\2\u011e\u0120\7\65\2\2\u011f\u00ed\3\2\2\2\u011f\u00ef\3\2\2\2\u011f"+
		"\u00f1\3\2\2\2\u011f\u00f3\3\2\2\2\u011f\u00f5\3\2\2\2\u011f\u00f7\3\2"+
		"\2\2\u011f\u00f9\3\2\2\2\u011f\u00fd\3\2\2\2\u011f\u0102\3\2\2\2\u011f"+
		"\u0107\3\2\2\2\u011f\u010d\3\2\2\2\u011f\u010f\3\2\2\2\u011f\u011a\3\2"+
		"\2\2\u011f\u011b\3\2\2\2\u011f\u011d\3\2\2\2\u0120/\3\2\2\2\u0121\u0122"+
		"\5\62\32\2\u0122\u0123\7&\2\2\u0123\u0125\3\2\2\2\u0124\u0121\3\2\2\2"+
		"\u0124\u0125\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0127\5\62\32\2\u0127\61"+
		"\3\2\2\2\u0128\u012b\5:\36\2\u0129\u012b\7\62\2\2\u012a\u0128\3\2\2\2"+
		"\u012a\u0129\3\2\2\2\u012b\63\3\2\2\2\u012c\u012e\b\33\1\2\u012d\u012f"+
		"\7\'\2\2\u012e\u012d\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0130\3\2\2\2\u0130"+
		"\u0143\5\66\34\2\u0131\u0132\7(\2\2\u0132\u0143\5\66\34\2\u0133\u0134"+
		"\7)\2\2\u0134\u0143\5\66\34\2\u0135\u0136\7*\2\2\u0136\u0143\5\66\34\2"+
		"\u0137\u0138\7+\2\2\u0138\u0143\5\66\34\2\u0139\u013a\7,\2\2\u013a\u0143"+
		"\5\66\34\2\u013b\u013c\7-\2\2\u013c\u0143\7\64\2\2\u013d\u0143\7\65\2"+
		"\2\u013e\u013f\7\22\2\2\u013f\u0140\5\64\33\2\u0140\u0141\7\23\2\2\u0141"+
		"\u0143\3\2\2\2\u0142\u012c\3\2\2\2\u0142\u0131\3\2\2\2\u0142\u0133\3\2"+
		"\2\2\u0142\u0135\3\2\2\2\u0142\u0137\3\2\2\2\u0142\u0139\3\2\2\2\u0142"+
		"\u013b\3\2\2\2\u0142\u013d\3\2\2\2\u0142\u013e\3\2\2\2\u0143\u014c\3\2"+
		"\2\2\u0144\u0145\f\5\2\2\u0145\u0146\7.\2\2\u0146\u014b\5\64\33\6\u0147"+
		"\u0148\f\4\2\2\u0148\u0149\7\25\2\2\u0149\u014b\5\64\33\5\u014a\u0144"+
		"\3\2\2\2\u014a\u0147\3\2\2\2\u014b\u014e\3\2\2\2\u014c\u014a\3\2\2\2\u014c"+
		"\u014d\3\2\2\2\u014d\65\3\2\2\2\u014e\u014c\3\2\2\2\u014f\u0154\7\64\2"+
		"\2\u0150\u0154\7\66\2\2\u0151\u0154\7\67\2\2\u0152\u0154\7\61\2\2\u0153"+
		"\u014f\3\2\2\2\u0153\u0150\3\2\2\2\u0153\u0151\3\2\2\2\u0153\u0152\3\2"+
		"\2\2\u0154\67\3\2\2\2\u0155\u0156\5(\25\2\u0156\u0157\7\6\2\2\u01579\3"+
		"\2\2\2\u0158\u0159\t\2\2\2\u0159;\3\2\2\2!Edx{}\u0085\u0097\u00a0\u00a7"+
		"\u00b0\u00b5\u00b9\u00c4\u00cc\u00d3\u00db\u00df\u00e3\u00e8\u00eb\u00fb"+
		"\u010b\u0115\u011f\u0124\u012a\u012e\u0142\u014a\u014c\u0153";
	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);
		}
	}
}