net.hasor.dataql.compiler.parser.DataQLParser Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hasor-dataql Show documentation
the hasor DataQL project.
There is a newer version: 4.2.5
// Generated from net/hasor/dataql/compiler/parser/DataQLParser.g4 by ANTLR 4.7.2
package net.hasor.dataql.compiler.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 DataQLParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		WS=1, COMMENT1=2, COMMENT2=3, EOL=4, AT=5, OPEN_TAG=6, IF=7, ELSE=8, RETURN=9, 
		THROW=10, EXIT=11, VAR=12, RUN=13, HINT=14, IMPORT=15, TRUE=16, FALSE=17, 
		NULL=18, AS=19, PLUS=20, MINUS=21, MUL=22, DIV=23, DIV2=24, MOD=25, LBT=26, 
		RBT=27, AND=28, OR=29, NOT=30, XOR=31, LSHIFT=32, RSHIFT=33, RSHIFT2=34, 
		GT=35, GE=36, LT=37, LE=38, EQ=39, NE=40, SC_OR=41, SC_AND=42, COMMA=43, 
		COLON=44, ASS=45, DOT=46, LSBT=47, RSBT=48, OCBR=49, CCBR=50, ROU=51, 
		QUE=52, SEM=53, CONVER=54, LAMBDA=55, STRING=56, HEX_NUM=57, OCT_NUM=58, 
		BIT_NUM=59, INTEGER_NUM=60, DECIMAL_NUM=61, IDENTIFIER=62, CLOS_TAG=63, 
		CHAR=64;
	public static final int
		RULE_rootInstSet = 0, RULE_hintInst = 1, RULE_importInst = 2, RULE_blockSet = 3, 
		RULE_ifInst = 4, RULE_breakInst = 5, RULE_lambdaDef = 6, RULE_varInst = 7, 
		RULE_runInst = 8, RULE_anyObject = 9, RULE_routeMapping = 10, RULE_routeConver = 11, 
		RULE_routeNameSet = 12, RULE_routeName = 13, RULE_routeSubscript = 14, 
		RULE_funcCall = 15, RULE_funcCallResult = 16, RULE_objectValue = 17, RULE_objectKeyValue = 18, 
		RULE_listValue = 19, RULE_primitiveValue = 20, RULE_expr = 21, RULE_dyadicExpr = 22, 
		RULE_ternaryExpr = 23, RULE_atomExpr = 24, RULE_extBlock = 25, RULE_extParams = 26;
	private static String[] makeRuleNames() {
		return new String[] {
			"rootInstSet", "hintInst", "importInst", "blockSet", "ifInst", "breakInst", 
			"lambdaDef", "varInst", "runInst", "anyObject", "routeMapping", "routeConver", 
			"routeNameSet", "routeName", "routeSubscript", "funcCall", "funcCallResult", 
			"objectValue", "objectKeyValue", "listValue", "primitiveValue", "expr", 
			"dyadicExpr", "ternaryExpr", "atomExpr", "extBlock", "extParams"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, null, null, null, "'@@'", "'<%'", "'if'", "'else'", "'return'", 
			"'throw'", "'exit'", "'var'", "'run'", "'hint'", "'import'", "'true'", 
			"'false'", "'null'", "'as'", "'+'", "'-'", "'*'", "'/'", "'\\'", "'%'", 
			"'('", "')'", "'&'", "'|'", "'!'", "'^'", "'<<'", "'>>'", "'>>>'", "'>'", 
			"'>='", "'<'", "'<='", "'=='", "'!='", "'||'", "'&&'", "','", "':'", 
			"'='", "'.'", "'['", "']'", "'{'", "'}'", null, "'?'", "';'", "'=>'", 
			"'->'", null, null, null, null, null, null, null, "'%>'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "WS", "COMMENT1", "COMMENT2", "EOL", "AT", "OPEN_TAG", "IF", "ELSE", 
			"RETURN", "THROW", "EXIT", "VAR", "RUN", "HINT", "IMPORT", "TRUE", "FALSE", 
			"NULL", "AS", "PLUS", "MINUS", "MUL", "DIV", "DIV2", "MOD", "LBT", "RBT", 
			"AND", "OR", "NOT", "XOR", "LSHIFT", "RSHIFT", "RSHIFT2", "GT", "GE", 
			"LT", "LE", "EQ", "NE", "SC_OR", "SC_AND", "COMMA", "COLON", "ASS", "DOT", 
			"LSBT", "RSBT", "OCBR", "CCBR", "ROU", "QUE", "SEM", "CONVER", "LAMBDA", 
			"STRING", "HEX_NUM", "OCT_NUM", "BIT_NUM", "INTEGER_NUM", "DECIMAL_NUM", 
			"IDENTIFIER", "CLOS_TAG", "CHAR"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	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 "DataQLParser.g4"; }

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

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

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

	public DataQLParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class RootInstSetContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(DataQLParser.EOF, 0); }
		public List hintInst() {
			return getRuleContexts(HintInstContext.class);
		}
		public HintInstContext hintInst(int i) {
			return getRuleContext(HintInstContext.class,i);
		}
		public List importInst() {
			return getRuleContexts(ImportInstContext.class);
		}
		public ImportInstContext importInst(int i) {
			return getRuleContext(ImportInstContext.class,i);
		}
		public List blockSet() {
			return getRuleContexts(BlockSetContext.class);
		}
		public BlockSetContext blockSet(int i) {
			return getRuleContext(BlockSetContext.class,i);
		}
		public RootInstSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rootInstSet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRootInstSet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRootInstSet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRootInstSet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RootInstSetContext rootInstSet() throws RecognitionException {
		RootInstSetContext _localctx = new RootInstSetContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_rootInstSet);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(57);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==HINT) {
				{
				{
				setState(54);
				hintInst();
				}
				}
				setState(59);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(63);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==IMPORT) {
				{
				{
				setState(60);
				importInst();
				}
				}
				setState(65);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(67); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(66);
				blockSet();
				}
				}
				setState(69); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << RETURN) | (1L << THROW) | (1L << EXIT) | (1L << VAR) | (1L << RUN) | (1L << OCBR))) != 0) );
			setState(71);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HintInstContext extends ParserRuleContext {
		public TerminalNode HINT() { return getToken(DataQLParser.HINT, 0); }
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public TerminalNode ASS() { return getToken(DataQLParser.ASS, 0); }
		public PrimitiveValueContext primitiveValue() {
			return getRuleContext(PrimitiveValueContext.class,0);
		}
		public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
		public HintInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_hintInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterHintInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitHintInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitHintInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final HintInstContext hintInst() throws RecognitionException {
		HintInstContext _localctx = new HintInstContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_hintInst);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(73);
			match(HINT);
			setState(74);
			match(IDENTIFIER);
			setState(75);
			match(ASS);
			setState(76);
			primitiveValue();
			setState(78);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEM) {
				{
				setState(77);
				match(SEM);
				}
			}

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

	public static class ImportInstContext extends ParserRuleContext {
		public TerminalNode IMPORT() { return getToken(DataQLParser.IMPORT, 0); }
		public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
		public TerminalNode AS() { return getToken(DataQLParser.AS, 0); }
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
		public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
		public ImportInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterImportInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitImportInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitImportInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportInstContext importInst() throws RecognitionException {
		ImportInstContext _localctx = new ImportInstContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_importInst);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(80);
			match(IMPORT);
			setState(82);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ROU) {
				{
				setState(81);
				match(ROU);
				}
			}

			setState(84);
			match(STRING);
			setState(85);
			match(AS);
			setState(86);
			match(IDENTIFIER);
			setState(88);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SEM) {
				{
				setState(87);
				match(SEM);
				}
			}

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

	public static class BlockSetContext extends ParserRuleContext {
		public BlockSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockSet; }
	 
		public BlockSetContext() { }
		public void copyFrom(BlockSetContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SingleInstContext extends BlockSetContext {
		public RunInstContext runInst() {
			return getRuleContext(RunInstContext.class,0);
		}
		public VarInstContext varInst() {
			return getRuleContext(VarInstContext.class,0);
		}
		public IfInstContext ifInst() {
			return getRuleContext(IfInstContext.class,0);
		}
		public BreakInstContext breakInst() {
			return getRuleContext(BreakInstContext.class,0);
		}
		public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
		public SingleInstContext(BlockSetContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterSingleInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitSingleInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitSingleInst(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MultipleInstContext extends BlockSetContext {
		public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
		public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
		public List runInst() {
			return getRuleContexts(RunInstContext.class);
		}
		public RunInstContext runInst(int i) {
			return getRuleContext(RunInstContext.class,i);
		}
		public List varInst() {
			return getRuleContexts(VarInstContext.class);
		}
		public VarInstContext varInst(int i) {
			return getRuleContext(VarInstContext.class,i);
		}
		public List ifInst() {
			return getRuleContexts(IfInstContext.class);
		}
		public IfInstContext ifInst(int i) {
			return getRuleContext(IfInstContext.class,i);
		}
		public List breakInst() {
			return getRuleContexts(BreakInstContext.class);
		}
		public BreakInstContext breakInst(int i) {
			return getRuleContext(BreakInstContext.class,i);
		}
		public List SEM() { return getTokens(DataQLParser.SEM); }
		public TerminalNode SEM(int i) {
			return getToken(DataQLParser.SEM, i);
		}
		public MultipleInstContext(BlockSetContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterMultipleInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitMultipleInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitMultipleInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockSetContext blockSet() throws RecognitionException {
		BlockSetContext _localctx = new BlockSetContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_blockSet);
		int _la;
		try {
			setState(115);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OCBR:
				_localctx = new MultipleInstContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(90);
				match(OCBR);
				setState(102);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << RETURN) | (1L << THROW) | (1L << EXIT) | (1L << VAR) | (1L << RUN))) != 0)) {
					{
					{
					setState(95);
					_errHandler.sync(this);
					switch (_input.LA(1)) {
					case RUN:
						{
						setState(91);
						runInst();
						}
						break;
					case VAR:
						{
						setState(92);
						varInst();
						}
						break;
					case IF:
						{
						setState(93);
						ifInst();
						}
						break;
					case RETURN:
					case THROW:
					case EXIT:
						{
						setState(94);
						breakInst();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(98);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==SEM) {
						{
						setState(97);
						match(SEM);
						}
					}

					}
					}
					setState(104);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(105);
				match(CCBR);
				}
				break;
			case IF:
			case RETURN:
			case THROW:
			case EXIT:
			case VAR:
			case RUN:
				_localctx = new SingleInstContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(110);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case RUN:
					{
					setState(106);
					runInst();
					}
					break;
				case VAR:
					{
					setState(107);
					varInst();
					}
					break;
				case IF:
					{
					setState(108);
					ifInst();
					}
					break;
				case RETURN:
				case THROW:
				case EXIT:
					{
					setState(109);
					breakInst();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(113);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
				case 1:
					{
					setState(112);
					match(SEM);
					}
					break;
				}
				}
				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 IfInstContext extends ParserRuleContext {
		public List IF() { return getTokens(DataQLParser.IF); }
		public TerminalNode IF(int i) {
			return getToken(DataQLParser.IF, i);
		}
		public List LBT() { return getTokens(DataQLParser.LBT); }
		public TerminalNode LBT(int i) {
			return getToken(DataQLParser.LBT, i);
		}
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public List RBT() { return getTokens(DataQLParser.RBT); }
		public TerminalNode RBT(int i) {
			return getToken(DataQLParser.RBT, i);
		}
		public List blockSet() {
			return getRuleContexts(BlockSetContext.class);
		}
		public BlockSetContext blockSet(int i) {
			return getRuleContext(BlockSetContext.class,i);
		}
		public List ELSE() { return getTokens(DataQLParser.ELSE); }
		public TerminalNode ELSE(int i) {
			return getToken(DataQLParser.ELSE, i);
		}
		public IfInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterIfInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitIfInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitIfInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfInstContext ifInst() throws RecognitionException {
		IfInstContext _localctx = new IfInstContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_ifInst);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(117);
			match(IF);
			setState(118);
			match(LBT);
			setState(119);
			expr();
			setState(120);
			match(RBT);
			setState(121);
			blockSet();
			setState(131);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(122);
					match(ELSE);
					setState(123);
					match(IF);
					setState(124);
					match(LBT);
					setState(125);
					expr();
					setState(126);
					match(RBT);
					setState(127);
					blockSet();
					}
					} 
				}
				setState(133);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
			}
			setState(136);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				{
				setState(134);
				match(ELSE);
				setState(135);
				blockSet();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BreakInstContext extends ParserRuleContext {
		public AnyObjectContext anyObject() {
			return getRuleContext(AnyObjectContext.class,0);
		}
		public TerminalNode RETURN() { return getToken(DataQLParser.RETURN, 0); }
		public TerminalNode THROW() { return getToken(DataQLParser.THROW, 0); }
		public TerminalNode EXIT() { return getToken(DataQLParser.EXIT, 0); }
		public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
		public TerminalNode COMMA() { return getToken(DataQLParser.COMMA, 0); }
		public BreakInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_breakInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterBreakInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitBreakInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitBreakInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BreakInstContext breakInst() throws RecognitionException {
		BreakInstContext _localctx = new BreakInstContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_breakInst);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(138);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RETURN) | (1L << THROW) | (1L << EXIT))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(141);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(139);
				match(INTEGER_NUM);
				setState(140);
				match(COMMA);
				}
				break;
			}
			setState(143);
			anyObject();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LambdaDefContext extends ParserRuleContext {
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public TerminalNode LAMBDA() { return getToken(DataQLParser.LAMBDA, 0); }
		public BlockSetContext blockSet() {
			return getRuleContext(BlockSetContext.class,0);
		}
		public List IDENTIFIER() { return getTokens(DataQLParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(DataQLParser.IDENTIFIER, i);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public LambdaDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdaDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterLambdaDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitLambdaDef(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitLambdaDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LambdaDefContext lambdaDef() throws RecognitionException {
		LambdaDefContext _localctx = new LambdaDefContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_lambdaDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(145);
			match(LBT);
			setState(154);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==IDENTIFIER) {
				{
				setState(146);
				match(IDENTIFIER);
				setState(151);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(147);
					match(COMMA);
					setState(148);
					match(IDENTIFIER);
					}
					}
					setState(153);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(156);
			match(RBT);
			setState(157);
			match(LAMBDA);
			setState(158);
			blockSet();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VarInstContext extends ParserRuleContext {
		public TerminalNode VAR() { return getToken(DataQLParser.VAR, 0); }
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public TerminalNode ASS() { return getToken(DataQLParser.ASS, 0); }
		public AnyObjectContext anyObject() {
			return getRuleContext(AnyObjectContext.class,0);
		}
		public VarInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_varInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterVarInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitVarInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitVarInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VarInstContext varInst() throws RecognitionException {
		VarInstContext _localctx = new VarInstContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_varInst);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(160);
			match(VAR);
			setState(161);
			match(IDENTIFIER);
			setState(162);
			match(ASS);
			setState(163);
			anyObject();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RunInstContext extends ParserRuleContext {
		public TerminalNode RUN() { return getToken(DataQLParser.RUN, 0); }
		public AnyObjectContext anyObject() {
			return getRuleContext(AnyObjectContext.class,0);
		}
		public RunInstContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_runInst; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRunInst(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRunInst(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRunInst(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RunInstContext runInst() throws RecognitionException {
		RunInstContext _localctx = new RunInstContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_runInst);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(165);
			match(RUN);
			setState(166);
			anyObject();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AnyObjectContext extends ParserRuleContext {
		public ExtBlockContext extBlock() {
			return getRuleContext(ExtBlockContext.class,0);
		}
		public LambdaDefContext lambdaDef() {
			return getRuleContext(LambdaDefContext.class,0);
		}
		public PrimitiveValueContext primitiveValue() {
			return getRuleContext(PrimitiveValueContext.class,0);
		}
		public ObjectValueContext objectValue() {
			return getRuleContext(ObjectValueContext.class,0);
		}
		public ListValueContext listValue() {
			return getRuleContext(ListValueContext.class,0);
		}
		public FuncCallContext funcCall() {
			return getRuleContext(FuncCallContext.class,0);
		}
		public RouteMappingContext routeMapping() {
			return getRuleContext(RouteMappingContext.class,0);
		}
		public RouteConverContext routeConver() {
			return getRuleContext(RouteConverContext.class,0);
		}
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public AnyObjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anyObject; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterAnyObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitAnyObject(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitAnyObject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AnyObjectContext anyObject() throws RecognitionException {
		AnyObjectContext _localctx = new AnyObjectContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_anyObject);
		try {
			setState(177);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(168);
				extBlock();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(169);
				lambdaDef();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(170);
				primitiveValue();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(171);
				objectValue();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(172);
				listValue();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(173);
				funcCall();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(174);
				routeMapping();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(175);
				routeConver();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(176);
				expr();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RouteMappingContext extends ParserRuleContext {
		public RouteMappingContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_routeMapping; }
	 
		public RouteMappingContext() { }
		public void copyFrom(RouteMappingContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ExprRouteContext extends RouteMappingContext {
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
		public ExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExprRoute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExprRoute(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExprRoute(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ParamRouteContext extends RouteMappingContext {
		public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
		public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
		public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
		public RouteSubscriptContext routeSubscript() {
			return getRuleContext(RouteSubscriptContext.class,0);
		}
		public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public ParamRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterParamRoute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitParamRoute(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitParamRoute(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NameExprRouteContext extends RouteMappingContext {
		public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
		public NameExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNameExprRoute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNameExprRoute(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNameExprRoute(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class SubExprRouteContext extends RouteMappingContext {
		public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
		public List routeSubscript() {
			return getRuleContexts(RouteSubscriptContext.class);
		}
		public RouteSubscriptContext routeSubscript(int i) {
			return getRuleContext(RouteSubscriptContext.class,i);
		}
		public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public SubExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterSubExprRoute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitSubExprRoute(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitSubExprRoute(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RouteMappingContext routeMapping() throws RecognitionException {
		RouteMappingContext _localctx = new RouteMappingContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_routeMapping);
		int _la;
		try {
			setState(215);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				_localctx = new ParamRouteContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(179);
				match(ROU);
				setState(180);
				match(OCBR);
				setState(181);
				_la = _input.LA(1);
				if ( !(_la==STRING || _la==IDENTIFIER) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(182);
				match(CCBR);
				setState(184);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LSBT) {
					{
					setState(183);
					routeSubscript();
					}
				}

				setState(188);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==DOT) {
					{
					setState(186);
					match(DOT);
					setState(187);
					routeNameSet();
					}
				}

				}
				break;
			case 2:
				_localctx = new SubExprRouteContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(190);
				match(ROU);
				setState(192); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(191);
					routeSubscript();
					}
					}
					setState(194); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==LSBT );
				setState(198);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==DOT) {
					{
					setState(196);
					match(DOT);
					setState(197);
					routeNameSet();
					}
				}

				}
				break;
			case 3:
				_localctx = new NameExprRouteContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(200);
				match(ROU);
				setState(202);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==DOT) {
					{
					setState(201);
					match(DOT);
					}
				}

				setState(204);
				routeNameSet();
				}
				break;
			case 4:
				_localctx = new ExprRouteContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(213);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
				case 1:
					{
					{
					setState(206);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==ROU) {
						{
						setState(205);
						match(ROU);
						}
					}

					setState(208);
					routeNameSet();
					}
					}
					break;
				case 2:
					{
					{
					setState(209);
					match(ROU);
					setState(211);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==IDENTIFIER) {
						{
						setState(210);
						routeNameSet();
						}
					}

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

	public static class RouteConverContext extends ParserRuleContext {
		public RouteConverContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_routeConver; }
	 
		public RouteConverContext() { }
		public void copyFrom(RouteConverContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ExprFmtRouteContext extends RouteConverContext {
		public RouteMappingContext routeMapping() {
			return getRuleContext(RouteMappingContext.class,0);
		}
		public TerminalNode CONVER() { return getToken(DataQLParser.CONVER, 0); }
		public ObjectValueContext objectValue() {
			return getRuleContext(ObjectValueContext.class,0);
		}
		public ListValueContext listValue() {
			return getRuleContext(ListValueContext.class,0);
		}
		public ExprFmtRouteContext(RouteConverContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExprFmtRoute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExprFmtRoute(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExprFmtRoute(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RouteConverContext routeConver() throws RecognitionException {
		RouteConverContext _localctx = new RouteConverContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_routeConver);
		try {
			_localctx = new ExprFmtRouteContext(_localctx);
			enterOuterAlt(_localctx, 1);
			{
			setState(217);
			routeMapping();
			setState(218);
			match(CONVER);
			setState(221);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OCBR:
				{
				setState(219);
				objectValue();
				}
				break;
			case LSBT:
				{
				setState(220);
				listValue();
				}
				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 RouteNameSetContext extends ParserRuleContext {
		public List routeName() {
			return getRuleContexts(RouteNameContext.class);
		}
		public RouteNameContext routeName(int i) {
			return getRuleContext(RouteNameContext.class,i);
		}
		public List DOT() { return getTokens(DataQLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(DataQLParser.DOT, i);
		}
		public RouteNameSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_routeNameSet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteNameSet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteNameSet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteNameSet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RouteNameSetContext routeNameSet() throws RecognitionException {
		RouteNameSetContext _localctx = new RouteNameSetContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_routeNameSet);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(223);
			routeName();
			setState(228);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(224);
					match(DOT);
					setState(225);
					routeName();
					}
					} 
				}
				setState(230);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RouteNameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public List routeSubscript() {
			return getRuleContexts(RouteSubscriptContext.class);
		}
		public RouteSubscriptContext routeSubscript(int i) {
			return getRuleContext(RouteSubscriptContext.class,i);
		}
		public RouteNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_routeName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RouteNameContext routeName() throws RecognitionException {
		RouteNameContext _localctx = new RouteNameContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_routeName);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(231);
			match(IDENTIFIER);
			setState(235);
			_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 ) {
					{
					{
					setState(232);
					routeSubscript();
					}
					} 
				}
				setState(237);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RouteSubscriptContext extends ParserRuleContext {
		public TerminalNode LSBT() { return getToken(DataQLParser.LSBT, 0); }
		public TerminalNode RSBT() { return getToken(DataQLParser.RSBT, 0); }
		public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
		public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public RouteSubscriptContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_routeSubscript; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteSubscript(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteSubscript(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteSubscript(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RouteSubscriptContext routeSubscript() throws RecognitionException {
		RouteSubscriptContext _localctx = new RouteSubscriptContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_routeSubscript);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(238);
			match(LSBT);
			setState(242);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				{
				setState(239);
				match(STRING);
				}
				break;
			case 2:
				{
				setState(240);
				match(INTEGER_NUM);
				}
				break;
			case 3:
				{
				setState(241);
				expr();
				}
				break;
			}
			setState(244);
			match(RSBT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FuncCallContext extends ParserRuleContext {
		public RouteMappingContext routeMapping() {
			return getRuleContext(RouteMappingContext.class,0);
		}
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public List anyObject() {
			return getRuleContexts(AnyObjectContext.class);
		}
		public AnyObjectContext anyObject(int i) {
			return getRuleContext(AnyObjectContext.class,i);
		}
		public FuncCallResultContext funcCallResult() {
			return getRuleContext(FuncCallResultContext.class,0);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public FuncCallContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funcCall; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCall(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCall(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCall(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncCallContext funcCall() throws RecognitionException {
		FuncCallContext _localctx = new FuncCallContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_funcCall);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(246);
			routeMapping();
			setState(247);
			match(LBT);
			setState(256);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
				{
				setState(248);
				anyObject();
				setState(253);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(249);
					match(COMMA);
					setState(250);
					anyObject();
					}
					}
					setState(255);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(258);
			match(RBT);
			setState(260);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				{
				setState(259);
				funcCallResult();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FuncCallResultContext extends ParserRuleContext {
		public FuncCallResultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funcCallResult; }
	 
		public FuncCallResultContext() { }
		public void copyFrom(FuncCallResultContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class FuncCallResult_route2Context extends FuncCallResultContext {
		public List routeSubscript() {
			return getRuleContexts(RouteSubscriptContext.class);
		}
		public RouteSubscriptContext routeSubscript(int i) {
			return getRuleContext(RouteSubscriptContext.class,i);
		}
		public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public FuncCallResultContext funcCallResult() {
			return getRuleContext(FuncCallResultContext.class,0);
		}
		public FuncCallResult_route2Context(FuncCallResultContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_route2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_route2(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_route2(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FuncCallResult_convertContext extends FuncCallResultContext {
		public TerminalNode CONVER() { return getToken(DataQLParser.CONVER, 0); }
		public ObjectValueContext objectValue() {
			return getRuleContext(ObjectValueContext.class,0);
		}
		public ListValueContext listValue() {
			return getRuleContext(ListValueContext.class,0);
		}
		public FuncCallResult_convertContext(FuncCallResultContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_convert(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_convert(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_convert(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FuncCallResult_route1Context extends FuncCallResultContext {
		public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
		public RouteNameSetContext routeNameSet() {
			return getRuleContext(RouteNameSetContext.class,0);
		}
		public FuncCallResultContext funcCallResult() {
			return getRuleContext(FuncCallResultContext.class,0);
		}
		public List routeSubscript() {
			return getRuleContexts(RouteSubscriptContext.class);
		}
		public RouteSubscriptContext routeSubscript(int i) {
			return getRuleContext(RouteSubscriptContext.class,i);
		}
		public FuncCallResult_route1Context(FuncCallResultContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_route1(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_route1(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_route1(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FuncCallResult_callContext extends FuncCallResultContext {
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public List anyObject() {
			return getRuleContexts(AnyObjectContext.class);
		}
		public AnyObjectContext anyObject(int i) {
			return getRuleContext(AnyObjectContext.class,i);
		}
		public FuncCallResultContext funcCallResult() {
			return getRuleContext(FuncCallResultContext.class,0);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public FuncCallResult_callContext(FuncCallResultContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_call(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_call(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_call(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncCallResultContext funcCallResult() throws RecognitionException {
		FuncCallResultContext _localctx = new FuncCallResultContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_funcCallResult);
		int _la;
		try {
			int _alt;
			setState(306);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				_localctx = new FuncCallResult_route1Context(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(267);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LSBT) {
					{
					setState(263); 
					_errHandler.sync(this);
					_la = _input.LA(1);
					do {
						{
						{
						setState(262);
						routeSubscript();
						}
						}
						setState(265); 
						_errHandler.sync(this);
						_la = _input.LA(1);
					} while ( _la==LSBT );
					}
				}

				setState(269);
				match(DOT);
				setState(270);
				routeNameSet();
				setState(272);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
				case 1:
					{
					setState(271);
					funcCallResult();
					}
					break;
				}
				}
				break;
			case 2:
				_localctx = new FuncCallResult_route2Context(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(275); 
				_errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						setState(274);
						routeSubscript();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(277); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
				} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				setState(281);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
				case 1:
					{
					setState(279);
					match(DOT);
					setState(280);
					routeNameSet();
					}
					break;
				}
				setState(284);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
				case 1:
					{
					setState(283);
					funcCallResult();
					}
					break;
				}
				}
				break;
			case 3:
				_localctx = new FuncCallResult_convertContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(286);
				match(CONVER);
				setState(289);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case OCBR:
					{
					setState(287);
					objectValue();
					}
					break;
				case LSBT:
					{
					setState(288);
					listValue();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 4:
				_localctx = new FuncCallResult_callContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(291);
				match(LBT);
				setState(300);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
					{
					setState(292);
					anyObject();
					setState(297);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(293);
						match(COMMA);
						setState(294);
						anyObject();
						}
						}
						setState(299);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				setState(302);
				match(RBT);
				setState(304);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
				case 1:
					{
					setState(303);
					funcCallResult();
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectValueContext extends ParserRuleContext {
		public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
		public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
		public List objectKeyValue() {
			return getRuleContexts(ObjectKeyValueContext.class);
		}
		public ObjectKeyValueContext objectKeyValue(int i) {
			return getRuleContext(ObjectKeyValueContext.class,i);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public ObjectValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_objectValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterObjectValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitObjectValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitObjectValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ObjectValueContext objectValue() throws RecognitionException {
		ObjectValueContext _localctx = new ObjectValueContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_objectValue);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(308);
			match(OCBR);
			setState(310);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STRING) {
				{
				setState(309);
				objectKeyValue();
				}
			}

			setState(316);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(312);
				match(COMMA);
				setState(313);
				objectKeyValue();
				}
				}
				setState(318);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(319);
			match(CCBR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectKeyValueContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
		public TerminalNode COLON() { return getToken(DataQLParser.COLON, 0); }
		public AnyObjectContext anyObject() {
			return getRuleContext(AnyObjectContext.class,0);
		}
		public ObjectKeyValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_objectKeyValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterObjectKeyValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitObjectKeyValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitObjectKeyValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ObjectKeyValueContext objectKeyValue() throws RecognitionException {
		ObjectKeyValueContext _localctx = new ObjectKeyValueContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_objectKeyValue);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(321);
			match(STRING);
			setState(324);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(322);
				match(COLON);
				setState(323);
				anyObject();
				}
			}

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

	public static class ListValueContext extends ParserRuleContext {
		public TerminalNode LSBT() { return getToken(DataQLParser.LSBT, 0); }
		public TerminalNode RSBT() { return getToken(DataQLParser.RSBT, 0); }
		public List anyObject() {
			return getRuleContexts(AnyObjectContext.class);
		}
		public AnyObjectContext anyObject(int i) {
			return getRuleContext(AnyObjectContext.class,i);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public ListValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterListValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitListValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitListValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListValueContext listValue() throws RecognitionException {
		ListValueContext _localctx = new ListValueContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_listValue);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(326);
			match(LSBT);
			setState(328);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
				{
				setState(327);
				anyObject();
				}
			}

			setState(334);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(330);
				match(COMMA);
				setState(331);
				anyObject();
				}
				}
				setState(336);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(337);
			match(RSBT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrimitiveValueContext extends ParserRuleContext {
		public PrimitiveValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitiveValue; }
	 
		public PrimitiveValueContext() { }
		public void copyFrom(PrimitiveValueContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class StringValueContext extends PrimitiveValueContext {
		public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
		public StringValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterStringValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitStringValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitStringValue(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class BooleanValueContext extends PrimitiveValueContext {
		public TerminalNode TRUE() { return getToken(DataQLParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(DataQLParser.FALSE, 0); }
		public BooleanValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterBooleanValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitBooleanValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitBooleanValue(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NumberValueContext extends PrimitiveValueContext {
		public TerminalNode DECIMAL_NUM() { return getToken(DataQLParser.DECIMAL_NUM, 0); }
		public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
		public TerminalNode HEX_NUM() { return getToken(DataQLParser.HEX_NUM, 0); }
		public TerminalNode OCT_NUM() { return getToken(DataQLParser.OCT_NUM, 0); }
		public TerminalNode BIT_NUM() { return getToken(DataQLParser.BIT_NUM, 0); }
		public NumberValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNumberValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNumberValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNumberValue(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NullValueContext extends PrimitiveValueContext {
		public TerminalNode NULL() { return getToken(DataQLParser.NULL, 0); }
		public NullValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNullValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNullValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNullValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimitiveValueContext primitiveValue() throws RecognitionException {
		PrimitiveValueContext _localctx = new PrimitiveValueContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_primitiveValue);
		int _la;
		try {
			setState(343);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING:
				_localctx = new StringValueContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(339);
				match(STRING);
				}
				break;
			case NULL:
				_localctx = new NullValueContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(340);
				match(NULL);
				}
				break;
			case TRUE:
			case FALSE:
				_localctx = new BooleanValueContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(341);
				_la = _input.LA(1);
				if ( !(_la==TRUE || _la==FALSE) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case HEX_NUM:
			case OCT_NUM:
			case BIT_NUM:
			case INTEGER_NUM:
			case DECIMAL_NUM:
				_localctx = new NumberValueContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(342);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				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 ExprContext extends ParserRuleContext {
		public ExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr; }
	 
		public ExprContext() { }
		public void copyFrom(ExprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class UnaryExprContext extends ExprContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode PLUS() { return getToken(DataQLParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(DataQLParser.MINUS, 0); }
		public TerminalNode NOT() { return getToken(DataQLParser.NOT, 0); }
		public UnaryExprContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterUnaryExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitUnaryExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitUnaryExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class PrivilegeExprContext extends ExprContext {
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public DyadicExprContext dyadicExpr() {
			return getRuleContext(DyadicExprContext.class,0);
		}
		public TernaryExprContext ternaryExpr() {
			return getRuleContext(TernaryExprContext.class,0);
		}
		public PrivilegeExprContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterPrivilegeExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitPrivilegeExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitPrivilegeExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MultipleExprContext extends ExprContext {
		public AtomExprContext atomExpr() {
			return getRuleContext(AtomExprContext.class,0);
		}
		public DyadicExprContext dyadicExpr() {
			return getRuleContext(DyadicExprContext.class,0);
		}
		public TernaryExprContext ternaryExpr() {
			return getRuleContext(TernaryExprContext.class,0);
		}
		public MultipleExprContext(ExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterMultipleExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitMultipleExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitMultipleExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExprContext expr() throws RecognitionException {
		ExprContext _localctx = new ExprContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_expr);
		int _la;
		try {
			setState(359);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case PLUS:
			case MINUS:
			case NOT:
				_localctx = new UnaryExprContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(345);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << NOT))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(346);
				expr();
				}
				break;
			case LBT:
				_localctx = new PrivilegeExprContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(347);
				match(LBT);
				setState(348);
				expr();
				setState(349);
				match(RBT);
				setState(352);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
				case 1:
					{
					setState(350);
					dyadicExpr();
					}
					break;
				case 2:
					{
					setState(351);
					ternaryExpr();
					}
					break;
				}
				}
				break;
			case TRUE:
			case FALSE:
			case NULL:
			case ROU:
			case STRING:
			case HEX_NUM:
			case OCT_NUM:
			case BIT_NUM:
			case INTEGER_NUM:
			case DECIMAL_NUM:
			case IDENTIFIER:
				_localctx = new MultipleExprContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(354);
				atomExpr();
				setState(357);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
				case 1:
					{
					setState(355);
					dyadicExpr();
					}
					break;
				case 2:
					{
					setState(356);
					ternaryExpr();
					}
					break;
				}
				}
				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 DyadicExprContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode PLUS() { return getToken(DataQLParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(DataQLParser.MINUS, 0); }
		public TerminalNode MUL() { return getToken(DataQLParser.MUL, 0); }
		public TerminalNode DIV() { return getToken(DataQLParser.DIV, 0); }
		public TerminalNode DIV2() { return getToken(DataQLParser.DIV2, 0); }
		public TerminalNode MOD() { return getToken(DataQLParser.MOD, 0); }
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public TerminalNode AND() { return getToken(DataQLParser.AND, 0); }
		public TerminalNode OR() { return getToken(DataQLParser.OR, 0); }
		public TerminalNode NOT() { return getToken(DataQLParser.NOT, 0); }
		public TerminalNode XOR() { return getToken(DataQLParser.XOR, 0); }
		public TerminalNode LSHIFT() { return getToken(DataQLParser.LSHIFT, 0); }
		public TerminalNode RSHIFT() { return getToken(DataQLParser.RSHIFT, 0); }
		public TerminalNode RSHIFT2() { return getToken(DataQLParser.RSHIFT2, 0); }
		public TerminalNode GT() { return getToken(DataQLParser.GT, 0); }
		public TerminalNode GE() { return getToken(DataQLParser.GE, 0); }
		public TerminalNode LT() { return getToken(DataQLParser.LT, 0); }
		public TerminalNode LE() { return getToken(DataQLParser.LE, 0); }
		public TerminalNode EQ() { return getToken(DataQLParser.EQ, 0); }
		public TerminalNode NE() { return getToken(DataQLParser.NE, 0); }
		public TerminalNode SC_OR() { return getToken(DataQLParser.SC_OR, 0); }
		public TerminalNode SC_AND() { return getToken(DataQLParser.SC_AND, 0); }
		public DyadicExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dyadicExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DyadicExprContext dyadicExpr() throws RecognitionException {
		DyadicExprContext _localctx = new DyadicExprContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_dyadicExpr);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(361);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << MUL) | (1L << DIV) | (1L << DIV2) | (1L << MOD) | (1L << LBT) | (1L << RBT) | (1L << AND) | (1L << OR) | (1L << NOT) | (1L << XOR) | (1L << LSHIFT) | (1L << RSHIFT) | (1L << RSHIFT2) | (1L << GT) | (1L << GE) | (1L << LT) | (1L << LE) | (1L << EQ) | (1L << NE) | (1L << SC_OR) | (1L << SC_AND))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(362);
			expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TernaryExprContext extends ParserRuleContext {
		public TerminalNode QUE() { return getToken(DataQLParser.QUE, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode COLON() { return getToken(DataQLParser.COLON, 0); }
		public TernaryExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ternaryExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterTernaryExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitTernaryExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitTernaryExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TernaryExprContext ternaryExpr() throws RecognitionException {
		TernaryExprContext _localctx = new TernaryExprContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_ternaryExpr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(364);
			match(QUE);
			setState(365);
			expr();
			setState(366);
			match(COLON);
			setState(367);
			expr();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AtomExprContext extends ParserRuleContext {
		public PrimitiveValueContext primitiveValue() {
			return getRuleContext(PrimitiveValueContext.class,0);
		}
		public FuncCallContext funcCall() {
			return getRuleContext(FuncCallContext.class,0);
		}
		public RouteMappingContext routeMapping() {
			return getRuleContext(RouteMappingContext.class,0);
		}
		public AtomExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_atomExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterAtomExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitAtomExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitAtomExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AtomExprContext atomExpr() throws RecognitionException {
		AtomExprContext _localctx = new AtomExprContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_atomExpr);
		try {
			setState(372);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(369);
				primitiveValue();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(370);
				funcCall();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(371);
				routeMapping();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExtBlockContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(DataQLParser.AT, 0); }
		public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
		public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
		public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
		public TerminalNode OPEN_TAG() { return getToken(DataQLParser.OPEN_TAG, 0); }
		public TerminalNode CLOS_TAG() { return getToken(DataQLParser.CLOS_TAG, 0); }
		public ExtParamsContext extParams() {
			return getRuleContext(ExtParamsContext.class,0);
		}
		public List CHAR() { return getTokens(DataQLParser.CHAR); }
		public TerminalNode CHAR(int i) {
			return getToken(DataQLParser.CHAR, i);
		}
		public ExtBlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_extBlock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExtBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExtBlock(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExtBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExtBlockContext extBlock() throws RecognitionException {
		ExtBlockContext _localctx = new ExtBlockContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_extBlock);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(374);
			match(AT);
			setState(375);
			match(IDENTIFIER);
			setState(376);
			match(LBT);
			setState(378);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==IDENTIFIER) {
				{
				setState(377);
				extParams();
				}
			}

			setState(380);
			match(RBT);
			setState(381);
			match(OPEN_TAG);
			setState(385);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==CHAR) {
				{
				{
				setState(382);
				match(CHAR);
				}
				}
				setState(387);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(388);
			match(CLOS_TAG);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExtParamsContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(DataQLParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(DataQLParser.IDENTIFIER, i);
		}
		public List COMMA() { return getTokens(DataQLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(DataQLParser.COMMA, i);
		}
		public ExtParamsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_extParams; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExtParams(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExtParams(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExtParams(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExtParamsContext extParams() throws RecognitionException {
		ExtParamsContext _localctx = new ExtParamsContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_extParams);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(390);
			match(IDENTIFIER);
			setState(395);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(391);
				match(COMMA);
				setState(392);
				match(IDENTIFIER);
				}
				}
				setState(397);
				_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 final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3B\u0191\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\3\2\7\2:\n\2\f\2\16\2=\13\2\3\2\7\2@\n"+
		"\2\f\2\16\2C\13\2\3\2\6\2F\n\2\r\2\16\2G\3\2\3\2\3\3\3\3\3\3\3\3\3\3\5"+
		"\3Q\n\3\3\4\3\4\5\4U\n\4\3\4\3\4\3\4\3\4\5\4[\n\4\3\5\3\5\3\5\3\5\3\5"+
		"\5\5b\n\5\3\5\5\5e\n\5\7\5g\n\5\f\5\16\5j\13\5\3\5\3\5\3\5\3\5\3\5\5\5"+
		"q\n\5\3\5\5\5t\n\5\5\5v\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
		"\6\3\6\7\6\u0084\n\6\f\6\16\6\u0087\13\6\3\6\3\6\5\6\u008b\n\6\3\7\3\7"+
		"\3\7\5\7\u0090\n\7\3\7\3\7\3\b\3\b\3\b\3\b\7\b\u0098\n\b\f\b\16\b\u009b"+
		"\13\b\5\b\u009d\n\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3"+
		"\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00b4\n\13\3\f\3\f\3"+
		"\f\3\f\3\f\5\f\u00bb\n\f\3\f\3\f\5\f\u00bf\n\f\3\f\3\f\6\f\u00c3\n\f\r"+
		"\f\16\f\u00c4\3\f\3\f\5\f\u00c9\n\f\3\f\3\f\5\f\u00cd\n\f\3\f\3\f\5\f"+
		"\u00d1\n\f\3\f\3\f\3\f\5\f\u00d6\n\f\5\f\u00d8\n\f\5\f\u00da\n\f\3\r\3"+
		"\r\3\r\3\r\5\r\u00e0\n\r\3\16\3\16\3\16\7\16\u00e5\n\16\f\16\16\16\u00e8"+
		"\13\16\3\17\3\17\7\17\u00ec\n\17\f\17\16\17\u00ef\13\17\3\20\3\20\3\20"+
		"\3\20\5\20\u00f5\n\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\7\21\u00fe\n"+
		"\21\f\21\16\21\u0101\13\21\5\21\u0103\n\21\3\21\3\21\5\21\u0107\n\21\3"+
		"\22\6\22\u010a\n\22\r\22\16\22\u010b\5\22\u010e\n\22\3\22\3\22\3\22\5"+
		"\22\u0113\n\22\3\22\6\22\u0116\n\22\r\22\16\22\u0117\3\22\3\22\5\22\u011c"+
		"\n\22\3\22\5\22\u011f\n\22\3\22\3\22\3\22\5\22\u0124\n\22\3\22\3\22\3"+
		"\22\3\22\7\22\u012a\n\22\f\22\16\22\u012d\13\22\5\22\u012f\n\22\3\22\3"+
		"\22\5\22\u0133\n\22\5\22\u0135\n\22\3\23\3\23\5\23\u0139\n\23\3\23\3\23"+
		"\7\23\u013d\n\23\f\23\16\23\u0140\13\23\3\23\3\23\3\24\3\24\3\24\5\24"+
		"\u0147\n\24\3\25\3\25\5\25\u014b\n\25\3\25\3\25\7\25\u014f\n\25\f\25\16"+
		"\25\u0152\13\25\3\25\3\25\3\26\3\26\3\26\3\26\5\26\u015a\n\26\3\27\3\27"+
		"\3\27\3\27\3\27\3\27\3\27\5\27\u0163\n\27\3\27\3\27\3\27\5\27\u0168\n"+
		"\27\5\27\u016a\n\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\32\3\32"+
		"\3\32\5\32\u0177\n\32\3\33\3\33\3\33\3\33\5\33\u017d\n\33\3\33\3\33\3"+
		"\33\7\33\u0182\n\33\f\33\16\33\u0185\13\33\3\33\3\33\3\34\3\34\3\34\7"+
		"\34\u018c\n\34\f\34\16\34\u018f\13\34\3\34\2\2\35\2\4\6\b\n\f\16\20\22"+
		"\24\26\30\32\34\36 \"$&(*,.\60\62\64\66\2\b\3\2\13\r\4\2::@@\3\2\22\23"+
		"\3\2;?\4\2\26\27  \3\2\26,\2\u01c5\2;\3\2\2\2\4K\3\2\2\2\6R\3\2\2\2\b"+
		"u\3\2\2\2\nw\3\2\2\2\f\u008c\3\2\2\2\16\u0093\3\2\2\2\20\u00a2\3\2\2\2"+
		"\22\u00a7\3\2\2\2\24\u00b3\3\2\2\2\26\u00d9\3\2\2\2\30\u00db\3\2\2\2\32"+
		"\u00e1\3\2\2\2\34\u00e9\3\2\2\2\36\u00f0\3\2\2\2 \u00f8\3\2\2\2\"\u0134"+
		"\3\2\2\2$\u0136\3\2\2\2&\u0143\3\2\2\2(\u0148\3\2\2\2*\u0159\3\2\2\2,"+
		"\u0169\3\2\2\2.\u016b\3\2\2\2\60\u016e\3\2\2\2\62\u0176\3\2\2\2\64\u0178"+
		"\3\2\2\2\66\u0188\3\2\2\28:\5\4\3\298\3\2\2\2:=\3\2\2\2;9\3\2\2\2;<\3"+
		"\2\2\2@\5\6\4\2?>\3\2\2\2@C\3\2\2\2A?\3\2\2\2AB\3"+
		"\2\2\2BE\3\2\2\2CA\3\2\2\2DF\5\b\5\2ED\3\2\2\2FG\3\2\2\2GE\3\2\2\2GH\3"+
		"\2\2\2HI\3\2\2\2IJ\7\2\2\3J\3\3\2\2\2KL\7\20\2\2LM\7@\2\2MN\7/\2\2NP\5"+
		"*\26\2OQ\7\67\2\2PO\3\2\2\2PQ\3\2\2\2Q\5\3\2\2\2RT\7\21\2\2SU\7\65\2\2"+
		"TS\3\2\2\2TU\3\2\2\2UV\3\2\2\2VW\7:\2\2WX\7\25\2\2XZ\7@\2\2Y[\7\67\2\2"+
		"ZY\3\2\2\2Z[\3\2\2\2[\7\3\2\2\2\\h\7\63\2\2]b\5\22\n\2^b\5\20\t\2_b\5"+
		"\n\6\2`b\5\f\7\2a]\3\2\2\2a^\3\2\2\2a_\3\2\2\2a`\3\2\2\2bd\3\2\2\2ce\7"+
		"\67\2\2dc\3\2\2\2de\3\2\2\2eg\3\2\2\2fa\3\2\2\2gj\3\2\2\2hf\3\2\2\2hi"+
		"\3\2\2\2ik\3\2\2\2jh\3\2\2\2kv\7\64\2\2lq\5\22\n\2mq\5\20\t\2nq\5\n\6"+
		"\2oq\5\f\7\2pl\3\2\2\2pm\3\2\2\2pn\3\2\2\2po\3\2\2\2qs\3\2\2\2rt\7\67"+
		"\2\2sr\3\2\2\2st\3\2\2\2tv\3\2\2\2u\\\3\2\2\2up\3\2\2\2v\t\3\2\2\2wx\7"+
		"\t\2\2xy\7\34\2\2yz\5,\27\2z{\7\35\2\2{\u0085\5\b\5\2|}\7\n\2\2}~\7\t"+
		"\2\2~\177\7\34\2\2\177\u0080\5,\27\2\u0080\u0081\7\35\2\2\u0081\u0082"+
		"\5\b\5\2\u0082\u0084\3\2\2\2\u0083|\3\2\2\2\u0084\u0087\3\2\2\2\u0085"+
		"\u0083\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u008a\3\2\2\2\u0087\u0085\3\2"+
		"\2\2\u0088\u0089\7\n\2\2\u0089\u008b\5\b\5\2\u008a\u0088\3\2\2\2\u008a"+
		"\u008b\3\2\2\2\u008b\13\3\2\2\2\u008c\u008f\t\2\2\2\u008d\u008e\7>\2\2"+
		"\u008e\u0090\7-\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0091"+
		"\3\2\2\2\u0091\u0092\5\24\13\2\u0092\r\3\2\2\2\u0093\u009c\7\34\2\2\u0094"+
		"\u0099\7@\2\2\u0095\u0096\7-\2\2\u0096\u0098\7@\2\2\u0097\u0095\3\2\2"+
		"\2\u0098\u009b\3\2\2\2\u0099\u0097\3\2\2\2\u0099\u009a\3\2\2\2\u009a\u009d"+
		"\3\2\2\2\u009b\u0099\3\2\2\2\u009c\u0094\3\2\2\2\u009c\u009d\3\2\2\2\u009d"+
		"\u009e\3\2\2\2\u009e\u009f\7\35\2\2\u009f\u00a0\79\2\2\u00a0\u00a1\5\b"+
		"\5\2\u00a1\17\3\2\2\2\u00a2\u00a3\7\16\2\2\u00a3\u00a4\7@\2\2\u00a4\u00a5"+
		"\7/\2\2\u00a5\u00a6\5\24\13\2\u00a6\21\3\2\2\2\u00a7\u00a8\7\17\2\2\u00a8"+
		"\u00a9\5\24\13\2\u00a9\23\3\2\2\2\u00aa\u00b4\5\64\33\2\u00ab\u00b4\5"+
		"\16\b\2\u00ac\u00b4\5*\26\2\u00ad\u00b4\5$\23\2\u00ae\u00b4\5(\25\2\u00af"+
		"\u00b4\5 \21\2\u00b0\u00b4\5\26\f\2\u00b1\u00b4\5\30\r\2\u00b2\u00b4\5"+
		",\27\2\u00b3\u00aa\3\2\2\2\u00b3\u00ab\3\2\2\2\u00b3\u00ac\3\2\2\2\u00b3"+
		"\u00ad\3\2\2\2\u00b3\u00ae\3\2\2\2\u00b3\u00af\3\2\2\2\u00b3\u00b0\3\2"+
		"\2\2\u00b3\u00b1\3\2\2\2\u00b3\u00b2\3\2\2\2\u00b4\25\3\2\2\2\u00b5\u00b6"+
		"\7\65\2\2\u00b6\u00b7\7\63\2\2\u00b7\u00b8\t\3\2\2\u00b8\u00ba\7\64\2"+
		"\2\u00b9\u00bb\5\36\20\2\u00ba\u00b9\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb"+
		"\u00be\3\2\2\2\u00bc\u00bd\7\60\2\2\u00bd\u00bf\5\32\16\2\u00be\u00bc"+
		"\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00da\3\2\2\2\u00c0\u00c2\7\65\2\2"+
		"\u00c1\u00c3\5\36\20\2\u00c2\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c2"+
		"\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c8\3\2\2\2\u00c6\u00c7\7\60\2\2"+
		"\u00c7\u00c9\5\32\16\2\u00c8\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00da"+
		"\3\2\2\2\u00ca\u00cc\7\65\2\2\u00cb\u00cd\7\60\2\2\u00cc\u00cb\3\2\2\2"+
		"\u00cc\u00cd\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00da\5\32\16\2\u00cf\u00d1"+
		"\7\65\2\2\u00d0\u00cf\3\2\2\2\u00d0\u00d1\3\2\2\2\u00d1\u00d2\3\2\2\2"+
		"\u00d2\u00d8\5\32\16\2\u00d3\u00d5\7\65\2\2\u00d4\u00d6\5\32\16\2\u00d5"+
		"\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d0\3\2"+
		"\2\2\u00d7\u00d3\3\2\2\2\u00d8\u00da\3\2\2\2\u00d9\u00b5\3\2\2\2\u00d9"+
		"\u00c0\3\2\2\2\u00d9\u00ca\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\27\3\2\2"+
		"\2\u00db\u00dc\5\26\f\2\u00dc\u00df\78\2\2\u00dd\u00e0\5$\23\2\u00de\u00e0"+
		"\5(\25\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2\2\u00e0\31\3\2\2\2\u00e1"+
		"\u00e6\5\34\17\2\u00e2\u00e3\7\60\2\2\u00e3\u00e5\5\34\17\2\u00e4\u00e2"+
		"\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7"+
		"\33\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u00ed\7@\2\2\u00ea\u00ec\5\36\20"+
		"\2\u00eb\u00ea\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee"+
		"\3\2\2\2\u00ee\35\3\2\2\2\u00ef\u00ed\3\2\2\2\u00f0\u00f4\7\61\2\2\u00f1"+
		"\u00f5\7:\2\2\u00f2\u00f5\7>\2\2\u00f3\u00f5\5,\27\2\u00f4\u00f1\3\2\2"+
		"\2\u00f4\u00f2\3\2\2\2\u00f4\u00f3\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7"+
		"\7\62\2\2\u00f7\37\3\2\2\2\u00f8\u00f9\5\26\f\2\u00f9\u0102\7\34\2\2\u00fa"+
		"\u00ff\5\24\13\2\u00fb\u00fc\7-\2\2\u00fc\u00fe\5\24\13\2\u00fd\u00fb"+
		"\3\2\2\2\u00fe\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100"+
		"\u0103\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u00fa\3\2\2\2\u0102\u0103\3\2"+
		"\2\2\u0103\u0104\3\2\2\2\u0104\u0106\7\35\2\2\u0105\u0107\5\"\22\2\u0106"+
		"\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107!\3\2\2\2\u0108\u010a\5\36\20"+
		"\2\u0109\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u0109\3\2\2\2\u010b\u010c"+
		"\3\2\2\2\u010c\u010e\3\2\2\2\u010d\u0109\3\2\2\2\u010d\u010e\3\2\2\2\u010e"+
		"\u010f\3\2\2\2\u010f\u0110\7\60\2\2\u0110\u0112\5\32\16\2\u0111\u0113"+
		"\5\"\22\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0135\3\2\2\2"+
		"\u0114\u0116\5\36\20\2\u0115\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0115"+
		"\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u011a\7\60\2\2"+
		"\u011a\u011c\5\32\16\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u011e"+
		"\3\2\2\2\u011d\u011f\5\"\22\2\u011e\u011d\3\2\2\2\u011e\u011f\3\2\2\2"+
		"\u011f\u0135\3\2\2\2\u0120\u0123\78\2\2\u0121\u0124\5$\23\2\u0122\u0124"+
		"\5(\25\2\u0123\u0121\3\2\2\2\u0123\u0122\3\2\2\2\u0124\u0135\3\2\2\2\u0125"+
		"\u012e\7\34\2\2\u0126\u012b\5\24\13\2\u0127\u0128\7-\2\2\u0128\u012a\5"+
		"\24\13\2\u0129\u0127\3\2\2\2\u012a\u012d\3\2\2\2\u012b\u0129\3\2\2\2\u012b"+
		"\u012c\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012e\u0126\3\2"+
		"\2\2\u012e\u012f\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0132\7\35\2\2\u0131"+
		"\u0133\5\"\22\2\u0132\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0135\3"+
		"\2\2\2\u0134\u010d\3\2\2\2\u0134\u0115\3\2\2\2\u0134\u0120\3\2\2\2\u0134"+
		"\u0125\3\2\2\2\u0135#\3\2\2\2\u0136\u0138\7\63\2\2\u0137\u0139\5&\24\2"+
		"\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013e\3\2\2\2\u013a\u013b"+
		"\7-\2\2\u013b\u013d\5&\24\2\u013c\u013a\3\2\2\2\u013d\u0140\3\2\2\2\u013e"+
		"\u013c\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0141\3\2\2\2\u0140\u013e\3\2"+
		"\2\2\u0141\u0142\7\64\2\2\u0142%\3\2\2\2\u0143\u0146\7:\2\2\u0144\u0145"+
		"\7.\2\2\u0145\u0147\5\24\13\2\u0146\u0144\3\2\2\2\u0146\u0147\3\2\2\2"+
		"\u0147\'\3\2\2\2\u0148\u014a\7\61\2\2\u0149\u014b\5\24\13\2\u014a\u0149"+
		"\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u0150\3\2\2\2\u014c\u014d\7-\2\2\u014d"+
		"\u014f\5\24\13\2\u014e\u014c\3\2\2\2\u014f\u0152\3\2\2\2\u0150\u014e\3"+
		"\2\2\2\u0150\u0151\3\2\2\2\u0151\u0153\3\2\2\2\u0152\u0150\3\2\2\2\u0153"+
		"\u0154\7\62\2\2\u0154)\3\2\2\2\u0155\u015a\7:\2\2\u0156\u015a\7\24\2\2"+
		"\u0157\u015a\t\4\2\2\u0158\u015a\t\5\2\2\u0159\u0155\3\2\2\2\u0159\u0156"+
		"\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u0158\3\2\2\2\u015a+\3\2\2\2\u015b"+
		"\u015c\t\6\2\2\u015c\u016a\5,\27\2\u015d\u015e\7\34\2\2\u015e\u015f\5"+
		",\27\2\u015f\u0162\7\35\2\2\u0160\u0163\5.\30\2\u0161\u0163\5\60\31\2"+
		"\u0162\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u016a"+
		"\3\2\2\2\u0164\u0167\5\62\32\2\u0165\u0168\5.\30\2\u0166\u0168\5\60\31"+
		"\2\u0167\u0165\3\2\2\2\u0167\u0166\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016a"+
		"\3\2\2\2\u0169\u015b\3\2\2\2\u0169\u015d\3\2\2\2\u0169\u0164\3\2\2\2\u016a"+
		"-\3\2\2\2\u016b\u016c\t\7\2\2\u016c\u016d\5,\27\2\u016d/\3\2\2\2\u016e"+
		"\u016f\7\66\2\2\u016f\u0170\5,\27\2\u0170\u0171\7.\2\2\u0171\u0172\5,"+
		"\27\2\u0172\61\3\2\2\2\u0173\u0177\5*\26\2\u0174\u0177\5 \21\2\u0175\u0177"+
		"\5\26\f\2\u0176\u0173\3\2\2\2\u0176\u0174\3\2\2\2\u0176\u0175\3\2\2\2"+
		"\u0177\63\3\2\2\2\u0178\u0179\7\7\2\2\u0179\u017a\7@\2\2\u017a\u017c\7"+
		"\34\2\2\u017b\u017d\5\66\34\2\u017c\u017b\3\2\2\2\u017c\u017d\3\2\2\2"+
		"\u017d\u017e\3\2\2\2\u017e\u017f\7\35\2\2\u017f\u0183\7\b\2\2\u0180\u0182"+
		"\7B\2\2\u0181\u0180\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0183"+
		"\u0184\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0183\3\2\2\2\u0186\u0187\7A"+
		"\2\2\u0187\65\3\2\2\2\u0188\u018d\7@\2\2\u0189\u018a\7-\2\2\u018a\u018c"+
		"\7@\2\2\u018b\u0189\3\2\2\2\u018c\u018f\3\2\2\2\u018d\u018b\3\2\2\2\u018d"+
		"\u018e\3\2\2\2\u018e\67\3\2\2\2\u018f\u018d\3\2\2\2<;AGPTZadhpsu\u0085"+
		"\u008a\u008f\u0099\u009c\u00b3\u00ba\u00be\u00c4\u00c8\u00cc\u00d0\u00d5"+
		"\u00d7\u00d9\u00df\u00e6\u00ed\u00f4\u00ff\u0102\u0106\u010b\u010d\u0112"+
		"\u0117\u011b\u011e\u0123\u012b\u012e\u0132\u0134\u0138\u013e\u0146\u014a"+
		"\u0150\u0159\u0162\u0167\u0169\u0176\u017c\u0183\u018d";
	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);
		}
	}
}