LExpress4.4.0.0-beta.1.source-code.QLParser Maven / Gradle / Ivy

Go to download
// Generated from QLParser.g4 by ANTLR 4.9.3

    package com.alibaba.qlexpress4.aparser;
    import static com.alibaba.qlexpress4.aparser.ParserOperatorManager.OpType.*;
    import static com.alibaba.qlexpress4.QLPrecedences.*;
    import static com.alibaba.qlexpress4.aparser.InterpolationMode.*;

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 QLParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		FOR=1, IF=2, ELSE=3, WHILE=4, BREAK=5, CONTINUE=6, RETURN=7, FUNCTION=8, 
		MACRO=9, IMPORT=10, STATIC=11, NEW=12, BYTE=13, SHORT=14, INT=15, LONG=16, 
		FLOAT=17, DOUBLE=18, CHAR=19, BOOL=20, NULL=21, TRUE=22, FALSE=23, EXTENDS=24, 
		SUPER=25, TRY=26, CATCH=27, FINALLY=28, THROW=29, CLASS=30, THIS=31, QuoteStringLiteral=32, 
		IntegerLiteral=33, FloatingPointLiteral=34, IntegerOrFloatingLiteral=35, 
		LPAREN=36, RPAREN=37, LBRACE=38, RBRACE=39, LBRACK=40, RBRACK=41, DOT=42, 
		ARROW=43, SEMI=44, COMMA=45, QUESTION=46, COLON=47, DCOLON=48, GT=49, 
		LT=50, EQ=51, NOEQ=52, RIGHSHIFT_ASSGIN=53, RIGHSHIFT=54, OPTIONAL_CHAINING=55, 
		SPREAD_CHAINING=56, URSHIFT_ASSGIN=57, URSHIFT=58, LSHIFT_ASSGIN=59, LEFTSHIFT=60, 
		GE=61, LE=62, DOTMUL=63, CARET=64, ADD_ASSIGN=65, SUB_ASSIGN=66, AND_ASSIGN=67, 
		OR_ASSIGN=68, MUL_ASSIGN=69, MOD_ASSIGN=70, DIV_ASSIGN=71, XOR_ASSIGN=72, 
		BANG=73, TILDE=74, ADD=75, SUB=76, MUL=77, DIV=78, BIT_AND=79, BIT_OR=80, 
		MOD=81, INC=82, DEC=83, WS=84, COMMENT=85, LINE_COMMENT=86, OPID=87, ID=88, 
		DOUBLE_QUOTE_OPEN=89, SELECTOR_START=90, CATCH_ALL=91, DyStrExprStart=92, 
		DyStrText=93, DOUBLE_QUOTE_CLOSE=94, SelectorVariable_VANME=95, StrExpr_END=96, 
		StrExpr_WS=97;
	public static final int
		RULE_program = 0, RULE_blockStatements = 1, RULE_blockStatement = 2, RULE_localVariableDeclaration = 3, 
		RULE_forInit = 4, RULE_variableDeclaratorList = 5, RULE_variableDeclarator = 6, 
		RULE_variableDeclaratorId = 7, RULE_variableInitializer = 8, RULE_arrayInitializer = 9, 
		RULE_variableInitializerList = 10, RULE_declType = 11, RULE_declTypeNoArr = 12, 
		RULE_primitiveType = 13, RULE_referenceType = 14, RULE_dims = 15, RULE_clsTypeNoTypeArguments = 16, 
		RULE_clsType = 17, RULE_typeArguments = 18, RULE_typeArgumentList = 19, 
		RULE_typeArgument = 20, RULE_wildcard = 21, RULE_wildcardBounds = 22, 
		RULE_expression = 23, RULE_leftHandSide = 24, RULE_ternaryExpr = 25, RULE_baseExpr = 26, 
		RULE_leftAsso = 27, RULE_binaryop = 28, RULE_primary = 29, RULE_prefixExpress = 30, 
		RULE_suffixExpress = 31, RULE_primaryNoFix = 32, RULE_ifBody = 33, RULE_listItems = 34, 
		RULE_dimExprs = 35, RULE_tryCatches = 36, RULE_tryCatch = 37, RULE_catchParams = 38, 
		RULE_tryFinally = 39, RULE_mapEntries = 40, RULE_mapEntry = 41, RULE_mapValue = 42, 
		RULE_mapKey = 43, RULE_idMapKey = 44, RULE_pathPart = 45, RULE_fieldId = 46, 
		RULE_indexValueExpr = 47, RULE_argumentList = 48, RULE_literal = 49, RULE_doubleQuoteStringLiteral = 50, 
		RULE_stringExpression = 51, RULE_boolenLiteral = 52, RULE_lambdaParameters = 53, 
		RULE_formalOrInferredParameterList = 54, RULE_formalOrInferredParameter = 55, 
		RULE_importDeclaration = 56, RULE_assignOperator = 57, RULE_opId = 58, 
		RULE_varId = 59;
	private static String[] makeRuleNames() {
		return new String[] {
			"program", "blockStatements", "blockStatement", "localVariableDeclaration", 
			"forInit", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", 
			"variableInitializer", "arrayInitializer", "variableInitializerList", 
			"declType", "declTypeNoArr", "primitiveType", "referenceType", "dims", 
			"clsTypeNoTypeArguments", "clsType", "typeArguments", "typeArgumentList", 
			"typeArgument", "wildcard", "wildcardBounds", "expression", "leftHandSide", 
			"ternaryExpr", "baseExpr", "leftAsso", "binaryop", "primary", "prefixExpress", 
			"suffixExpress", "primaryNoFix", "ifBody", "listItems", "dimExprs", "tryCatches", 
			"tryCatch", "catchParams", "tryFinally", "mapEntries", "mapEntry", "mapValue", 
			"mapKey", "idMapKey", "pathPart", "fieldId", "indexValueExpr", "argumentList", 
			"literal", "doubleQuoteStringLiteral", "stringExpression", "boolenLiteral", 
			"lambdaParameters", "formalOrInferredParameterList", "formalOrInferredParameter", 
			"importDeclaration", "assignOperator", "opId", "varId"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'for'", "'if'", "'else'", "'while'", "'break'", "'continue'", 
			"'return'", "'function'", "'macro'", "'import'", "'static'", "'new'", 
			"'byte'", "'short'", "'int'", "'long'", "'float'", "'double'", "'char'", 
			"'boolean'", "'null'", "'true'", "'false'", "'extends'", "'super'", "'try'", 
			"'catch'", "'finally'", "'throw'", "'class'", "'this'", null, null, null, 
			null, "'('", "')'", "'{'", "'}'", "'['", "']'", "'.'", "'->'", "';'", 
			"','", "'?'", "':'", "'::'", "'>'", "'<'", "'='", "'<>'", "'>>='", "'>>'", 
			"'?.'", "'*.'", "'>>>='", "'>>>'", "'<<='", "'<<'", "'>='", "'<='", "'.*'", 
			"'^'", "'+='", "'-='", "'&='", "'|='", "'*='", "'%='", "'/='", "'^='", 
			"'!'", "'~'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'%'", "'++'", 
			"'--'", null, null, null, null, null, null, null, null, null, null, null, 
			null, "'$}'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "FOR", "IF", "ELSE", "WHILE", "BREAK", "CONTINUE", "RETURN", "FUNCTION", 
			"MACRO", "IMPORT", "STATIC", "NEW", "BYTE", "SHORT", "INT", "LONG", "FLOAT", 
			"DOUBLE", "CHAR", "BOOL", "NULL", "TRUE", "FALSE", "EXTENDS", "SUPER", 
			"TRY", "CATCH", "FINALLY", "THROW", "CLASS", "THIS", "QuoteStringLiteral", 
			"IntegerLiteral", "FloatingPointLiteral", "IntegerOrFloatingLiteral", 
			"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "DOT", "ARROW", 
			"SEMI", "COMMA", "QUESTION", "COLON", "DCOLON", "GT", "LT", "EQ", "NOEQ", 
			"RIGHSHIFT_ASSGIN", "RIGHSHIFT", "OPTIONAL_CHAINING", "SPREAD_CHAINING", 
			"URSHIFT_ASSGIN", "URSHIFT", "LSHIFT_ASSGIN", "LEFTSHIFT", "GE", "LE", 
			"DOTMUL", "CARET", "ADD_ASSIGN", "SUB_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", 
			"MUL_ASSIGN", "MOD_ASSIGN", "DIV_ASSIGN", "XOR_ASSIGN", "BANG", "TILDE", 
			"ADD", "SUB", "MUL", "DIV", "BIT_AND", "BIT_OR", "MOD", "INC", "DEC", 
			"WS", "COMMENT", "LINE_COMMENT", "OPID", "ID", "DOUBLE_QUOTE_OPEN", "SELECTOR_START", 
			"CATCH_ALL", "DyStrExprStart", "DyStrText", "DOUBLE_QUOTE_CLOSE", "SelectorVariable_VANME", 
			"StrExpr_END", "StrExpr_WS"
		};
	}
	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 "QLParser.g4"; }

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

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

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


	    ParserOperatorManager opM;
	    InterpolationMode interpolationMode;
	    public QLParser(TokenStream input, ParserOperatorManager opM, InterpolationMode interpolationMode) {    // custom constructor
	        this(input);
	        this.opM = opM;
	        this.interpolationMode = interpolationMode;
	    }

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

	public static class ProgramContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(QLParser.EOF, 0); }
		public List importDeclaration() {
			return getRuleContexts(ImportDeclarationContext.class);
		}
		public ImportDeclarationContext importDeclaration(int i) {
			return getRuleContext(ImportDeclarationContext.class,i);
		}
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public ProgramContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_program; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterProgram(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitProgram(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitProgram(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ProgramContext program() throws RecognitionException {
		ProgramContext _localctx = new ProgramContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_program);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(123);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(120);
					importDeclaration();
					}
					} 
				}
				setState(125);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			}
			setState(127);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				{
				setState(126);
				blockStatements();
				}
				break;
			}
			setState(129);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockStatementsContext extends ParserRuleContext {
		public List blockStatement() {
			return getRuleContexts(BlockStatementContext.class);
		}
		public BlockStatementContext blockStatement(int i) {
			return getRuleContext(BlockStatementContext.class,i);
		}
		public BlockStatementsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockStatements; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBlockStatements(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBlockStatements(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBlockStatements(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockStatementsContext blockStatements() throws RecognitionException {
		BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_blockStatements);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(132); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(131);
					blockStatement();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(134); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockStatementContext extends ParserRuleContext {
		public BlockStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockStatement; }
	 
		public BlockStatementContext() { }
		public void copyFrom(BlockStatementContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class WhileStatementContext extends BlockStatementContext {
		public TerminalNode WHILE() { return getToken(QLParser.WHILE, 0); }
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public BlockStatementContext blockStatement() {
			return getRuleContext(BlockStatementContext.class,0);
		}
		public WhileStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterWhileStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitWhileStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitWhileStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class TraditionalForStatementContext extends BlockStatementContext {
		public ExpressionContext forCondition;
		public ExpressionContext forUpdate;
		public TerminalNode FOR() { return getToken(QLParser.FOR, 0); }
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public ForInitContext forInit() {
			return getRuleContext(ForInitContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public BlockStatementContext blockStatement() {
			return getRuleContext(BlockStatementContext.class,0);
		}
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public TraditionalForStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTraditionalForStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTraditionalForStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTraditionalForStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class EmptyStatementContext extends BlockStatementContext {
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public EmptyStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterEmptyStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitEmptyStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitEmptyStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LocalVariableDeclarationStatementContext extends BlockStatementContext {
		public LocalVariableDeclarationContext localVariableDeclaration() {
			return getRuleContext(LocalVariableDeclarationContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public LocalVariableDeclarationStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLocalVariableDeclarationStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLocalVariableDeclarationStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLocalVariableDeclarationStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ForEachStatementContext extends BlockStatementContext {
		public TerminalNode FOR() { return getToken(QLParser.FOR, 0); }
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode COLON() { return getToken(QLParser.COLON, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public BlockStatementContext blockStatement() {
			return getRuleContext(BlockStatementContext.class,0);
		}
		public DeclTypeContext declType() {
			return getRuleContext(DeclTypeContext.class,0);
		}
		public ForEachStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterForEachStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitForEachStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitForEachStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MacroStatementContext extends BlockStatementContext {
		public TerminalNode MACRO() { return getToken(QLParser.MACRO, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public MacroStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMacroStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMacroStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMacroStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ThrowStatementContext extends BlockStatementContext {
		public TerminalNode THROW() { return getToken(QLParser.THROW, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public ThrowStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterThrowStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitThrowStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitThrowStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FunctionStatementContext extends BlockStatementContext {
		public TerminalNode FUNCTION() { return getToken(QLParser.FUNCTION, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public FormalOrInferredParameterListContext formalOrInferredParameterList() {
			return getRuleContext(FormalOrInferredParameterListContext.class,0);
		}
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public FunctionStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterFunctionStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitFunctionStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitFunctionStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ExpressionStatementContext extends BlockStatementContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public ExpressionStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterExpressionStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitExpressionStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitExpressionStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ReturnStatementContext extends BlockStatementContext {
		public TerminalNode RETURN() { return getToken(QLParser.RETURN, 0); }
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ReturnStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterReturnStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitReturnStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitReturnStatement(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class BreakContinueStatementContext extends BlockStatementContext {
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public TerminalNode BREAK() { return getToken(QLParser.BREAK, 0); }
		public TerminalNode CONTINUE() { return getToken(QLParser.CONTINUE, 0); }
		public BreakContinueStatementContext(BlockStatementContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBreakContinueStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBreakContinueStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBreakContinueStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockStatementContext blockStatement() throws RecognitionException {
		BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_blockStatement);
		int _la;
		try {
			setState(206);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				_localctx = new LocalVariableDeclarationStatementContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(136);
				localVariableDeclaration();
				setState(137);
				match(SEMI);
				}
				break;
			case 2:
				_localctx = new ThrowStatementContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(139);
				match(THROW);
				setState(140);
				expression();
				setState(141);
				match(SEMI);
				}
				break;
			case 3:
				_localctx = new WhileStatementContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(143);
				match(WHILE);
				setState(144);
				match(LPAREN);
				setState(145);
				expression();
				setState(146);
				match(RPAREN);
				setState(147);
				blockStatement();
				}
				break;
			case 4:
				_localctx = new TraditionalForStatementContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(149);
				match(FOR);
				setState(150);
				match(LPAREN);
				setState(151);
				forInit();
				setState(153);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
				case 1:
					{
					setState(152);
					((TraditionalForStatementContext)_localctx).forCondition = expression();
					}
					break;
				}
				setState(155);
				match(SEMI);
				setState(157);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
				case 1:
					{
					setState(156);
					((TraditionalForStatementContext)_localctx).forUpdate = expression();
					}
					break;
				}
				setState(159);
				match(RPAREN);
				setState(160);
				blockStatement();
				}
				break;
			case 5:
				_localctx = new ForEachStatementContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(162);
				match(FOR);
				setState(163);
				match(LPAREN);
				setState(165);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
				case 1:
					{
					setState(164);
					declType();
					}
					break;
				}
				setState(167);
				varId();
				setState(168);
				match(COLON);
				setState(169);
				expression();
				setState(170);
				match(RPAREN);
				setState(171);
				blockStatement();
				}
				break;
			case 6:
				_localctx = new FunctionStatementContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(173);
				match(FUNCTION);
				setState(174);
				varId();
				setState(175);
				match(LPAREN);
				setState(177);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FUNCTION) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << CHAR) | (1L << BOOL))) != 0) || _la==ID) {
					{
					setState(176);
					formalOrInferredParameterList();
					}
				}

				setState(179);
				match(RPAREN);
				setState(180);
				match(LBRACE);
				setState(182);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
				case 1:
					{
					setState(181);
					blockStatements();
					}
					break;
				}
				setState(184);
				match(RBRACE);
				}
				break;
			case 7:
				_localctx = new MacroStatementContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(186);
				match(MACRO);
				setState(187);
				varId();
				setState(188);
				match(LBRACE);
				setState(190);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
				case 1:
					{
					setState(189);
					blockStatements();
					}
					break;
				}
				setState(192);
				match(RBRACE);
				}
				break;
			case 8:
				_localctx = new BreakContinueStatementContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(194);
				_la = _input.LA(1);
				if ( !(_la==BREAK || _la==CONTINUE) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(195);
				match(SEMI);
				}
				break;
			case 9:
				_localctx = new ReturnStatementContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(196);
				match(RETURN);
				setState(198);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
				case 1:
					{
					setState(197);
					expression();
					}
					break;
				}
				setState(200);
				match(SEMI);
				}
				break;
			case 10:
				_localctx = new EmptyStatementContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(201);
				match(SEMI);
				}
				break;
			case 11:
				_localctx = new ExpressionStatementContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(202);
				expression();
				setState(204);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
				case 1:
					{
					setState(203);
					match(SEMI);
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LocalVariableDeclarationContext extends ParserRuleContext {
		public DeclTypeContext declType() {
			return getRuleContext(DeclTypeContext.class,0);
		}
		public VariableDeclaratorListContext variableDeclaratorList() {
			return getRuleContext(VariableDeclaratorListContext.class,0);
		}
		public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_localVariableDeclaration; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLocalVariableDeclaration(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLocalVariableDeclaration(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLocalVariableDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
		LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_localVariableDeclaration);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(208);
			declType();
			setState(209);
			variableDeclaratorList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ForInitContext extends ParserRuleContext {
		public LocalVariableDeclarationContext localVariableDeclaration() {
			return getRuleContext(LocalVariableDeclarationContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ForInitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_forInit; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterForInit(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitForInit(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitForInit(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ForInitContext forInit() throws RecognitionException {
		ForInitContext _localctx = new ForInitContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_forInit);
		try {
			setState(218);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(211);
				localVariableDeclaration();
				setState(212);
				match(SEMI);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(214);
				expression();
				setState(215);
				match(SEMI);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(217);
				match(SEMI);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariableDeclaratorListContext extends ParserRuleContext {
		public List variableDeclarator() {
			return getRuleContexts(VariableDeclaratorContext.class);
		}
		public VariableDeclaratorContext variableDeclarator(int i) {
			return getRuleContext(VariableDeclaratorContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVariableDeclaratorList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVariableDeclaratorList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVariableDeclaratorList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
		VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_variableDeclaratorList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(220);
			variableDeclarator();
			setState(225);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(221);
				match(COMMA);
				setState(222);
				variableDeclarator();
				}
				}
				setState(227);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VariableDeclaratorContext extends ParserRuleContext {
		public VariableDeclaratorIdContext variableDeclaratorId() {
			return getRuleContext(VariableDeclaratorIdContext.class,0);
		}
		public TerminalNode EQ() { return getToken(QLParser.EQ, 0); }
		public VariableInitializerContext variableInitializer() {
			return getRuleContext(VariableInitializerContext.class,0);
		}
		public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableDeclarator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVariableDeclarator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVariableDeclarator(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVariableDeclarator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
		VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_variableDeclarator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(228);
			variableDeclaratorId();
			setState(231);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EQ) {
				{
				setState(229);
				match(EQ);
				setState(230);
				variableInitializer();
				}
			}

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

	public static class VariableDeclaratorIdContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public DimsContext dims() {
			return getRuleContext(DimsContext.class,0);
		}
		public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVariableDeclaratorId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVariableDeclaratorId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVariableDeclaratorId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
		VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_variableDeclaratorId);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(233);
			varId();
			setState(235);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LBRACK) {
				{
				setState(234);
				dims();
				}
			}

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

	public static class VariableInitializerContext extends ParserRuleContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public ArrayInitializerContext arrayInitializer() {
			return getRuleContext(ArrayInitializerContext.class,0);
		}
		public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableInitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVariableInitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVariableInitializer(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVariableInitializer(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableInitializerContext variableInitializer() throws RecognitionException {
		VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_variableInitializer);
		try {
			setState(239);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(237);
				expression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(238);
				arrayInitializer();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArrayInitializerContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public VariableInitializerListContext variableInitializerList() {
			return getRuleContext(VariableInitializerListContext.class,0);
		}
		public TerminalNode COMMA() { return getToken(QLParser.COMMA, 0); }
		public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arrayInitializer; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterArrayInitializer(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitArrayInitializer(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitArrayInitializer(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
		ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_arrayInitializer);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(241);
			match(LBRACE);
			setState(243);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				{
				setState(242);
				variableInitializerList();
				}
				break;
			}
			setState(246);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(245);
				match(COMMA);
				}
			}

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

	public static class VariableInitializerListContext extends ParserRuleContext {
		public List variableInitializer() {
			return getRuleContexts(VariableInitializerContext.class);
		}
		public VariableInitializerContext variableInitializer(int i) {
			return getRuleContext(VariableInitializerContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public VariableInitializerListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_variableInitializerList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVariableInitializerList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVariableInitializerList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVariableInitializerList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
		VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_variableInitializerList);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(250);
			variableInitializer();
			setState(255);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(251);
					match(COMMA);
					setState(252);
					variableInitializer();
					}
					} 
				}
				setState(257);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeclTypeContext extends ParserRuleContext {
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public DimsContext dims() {
			return getRuleContext(DimsContext.class,0);
		}
		public ClsTypeContext clsType() {
			return getRuleContext(ClsTypeContext.class,0);
		}
		public DeclTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterDeclType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitDeclType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitDeclType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeclTypeContext declType() throws RecognitionException {
		DeclTypeContext _localctx = new DeclTypeContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_declType);
		int _la;
		try {
			setState(266);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
				enterOuterAlt(_localctx, 1);
				{
				setState(258);
				primitiveType();
				setState(260);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACK) {
					{
					setState(259);
					dims();
					}
				}

				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(262);
				clsType();
				setState(264);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACK) {
					{
					setState(263);
					dims();
					}
				}

				}
				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 DeclTypeNoArrContext extends ParserRuleContext {
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public ClsTypeContext clsType() {
			return getRuleContext(ClsTypeContext.class,0);
		}
		public DeclTypeNoArrContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declTypeNoArr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterDeclTypeNoArr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitDeclTypeNoArr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitDeclTypeNoArr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeclTypeNoArrContext declTypeNoArr() throws RecognitionException {
		DeclTypeNoArrContext _localctx = new DeclTypeNoArrContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_declTypeNoArr);
		try {
			setState(270);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
				enterOuterAlt(_localctx, 1);
				{
				setState(268);
				primitiveType();
				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(269);
				clsType();
				}
				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 PrimitiveTypeContext extends ParserRuleContext {
		public TerminalNode BYTE() { return getToken(QLParser.BYTE, 0); }
		public TerminalNode SHORT() { return getToken(QLParser.SHORT, 0); }
		public TerminalNode INT() { return getToken(QLParser.INT, 0); }
		public TerminalNode LONG() { return getToken(QLParser.LONG, 0); }
		public TerminalNode FLOAT() { return getToken(QLParser.FLOAT, 0); }
		public TerminalNode DOUBLE() { return getToken(QLParser.DOUBLE, 0); }
		public TerminalNode BOOL() { return getToken(QLParser.BOOL, 0); }
		public TerminalNode CHAR() { return getToken(QLParser.CHAR, 0); }
		public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitiveType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterPrimitiveType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitPrimitiveType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitPrimitiveType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
		PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_primitiveType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(272);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << CHAR) | (1L << BOOL))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ReferenceTypeContext extends ParserRuleContext {
		public ClsTypeContext clsType() {
			return getRuleContext(ClsTypeContext.class,0);
		}
		public DimsContext dims() {
			return getRuleContext(DimsContext.class,0);
		}
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_referenceType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterReferenceType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitReferenceType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitReferenceType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ReferenceTypeContext referenceType() throws RecognitionException {
		ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_referenceType);
		try {
			setState(281);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(274);
				clsType();
				setState(276);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
				case 1:
					{
					setState(275);
					dims();
					}
					break;
				}
				}
				break;
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
				enterOuterAlt(_localctx, 2);
				{
				setState(278);
				primitiveType();
				setState(279);
				dims();
				}
				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 DimsContext extends ParserRuleContext {
		public List LBRACK() { return getTokens(QLParser.LBRACK); }
		public TerminalNode LBRACK(int i) {
			return getToken(QLParser.LBRACK, i);
		}
		public List RBRACK() { return getTokens(QLParser.RBRACK); }
		public TerminalNode RBRACK(int i) {
			return getToken(QLParser.RBRACK, i);
		}
		public DimsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dims; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterDims(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitDims(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitDims(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DimsContext dims() throws RecognitionException {
		DimsContext _localctx = new DimsContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_dims);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(283);
			match(LBRACK);
			setState(284);
			match(RBRACK);
			setState(289);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(285);
					match(LBRACK);
					setState(286);
					match(RBRACK);
					}
					} 
				}
				setState(291);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClsTypeNoTypeArgumentsContext extends ParserRuleContext {
		public List varId() {
			return getRuleContexts(VarIdContext.class);
		}
		public VarIdContext varId(int i) {
			return getRuleContext(VarIdContext.class,i);
		}
		public List DOT() { return getTokens(QLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(QLParser.DOT, i);
		}
		public ClsTypeNoTypeArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_clsTypeNoTypeArguments; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterClsTypeNoTypeArguments(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitClsTypeNoTypeArguments(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitClsTypeNoTypeArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClsTypeNoTypeArgumentsContext clsTypeNoTypeArguments() throws RecognitionException {
		ClsTypeNoTypeArgumentsContext _localctx = new ClsTypeNoTypeArgumentsContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_clsTypeNoTypeArguments);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(292);
			varId();
			setState(297);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(293);
				match(DOT);
				setState(294);
				varId();
				}
				}
				setState(299);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClsTypeContext extends ParserRuleContext {
		public List varId() {
			return getRuleContexts(VarIdContext.class);
		}
		public VarIdContext varId(int i) {
			return getRuleContext(VarIdContext.class,i);
		}
		public List DOT() { return getTokens(QLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(QLParser.DOT, i);
		}
		public TypeArgumentsContext typeArguments() {
			return getRuleContext(TypeArgumentsContext.class,0);
		}
		public ClsTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_clsType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterClsType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitClsType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitClsType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClsTypeContext clsType() throws RecognitionException {
		ClsTypeContext _localctx = new ClsTypeContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_clsType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(300);
			varId();
			setState(305);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(301);
				match(DOT);
				setState(302);
				varId();
				}
				}
				setState(307);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(309);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LT || _la==NOEQ) {
				{
				setState(308);
				typeArguments();
				}
			}

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

	public static class TypeArgumentsContext extends ParserRuleContext {
		public TerminalNode LT() { return getToken(QLParser.LT, 0); }
		public TypeArgumentListContext typeArgumentList() {
			return getRuleContext(TypeArgumentListContext.class,0);
		}
		public TerminalNode GT() { return getToken(QLParser.GT, 0); }
		public TerminalNode RIGHSHIFT() { return getToken(QLParser.RIGHSHIFT, 0); }
		public TerminalNode URSHIFT() { return getToken(QLParser.URSHIFT, 0); }
		public TerminalNode NOEQ() { return getToken(QLParser.NOEQ, 0); }
		public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArguments; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTypeArguments(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTypeArguments(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTypeArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgumentsContext typeArguments() throws RecognitionException {
		TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_typeArguments);
		int _la;
		try {
			setState(319);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LT:
				enterOuterAlt(_localctx, 1);
				{
				setState(311);
				match(LT);
				setState(313);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
				case 1:
					{
					setState(312);
					typeArgumentList();
					}
					break;
				}
				setState(316);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
				case 1:
					{
					setState(315);
					_la = _input.LA(1);
					if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GT) | (1L << RIGHSHIFT) | (1L << URSHIFT))) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					break;
				}
				}
				break;
			case NOEQ:
				enterOuterAlt(_localctx, 2);
				{
				setState(318);
				match(NOEQ);
				}
				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 TypeArgumentListContext extends ParserRuleContext {
		public List typeArgument() {
			return getRuleContexts(TypeArgumentContext.class);
		}
		public TypeArgumentContext typeArgument(int i) {
			return getRuleContext(TypeArgumentContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArgumentList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTypeArgumentList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTypeArgumentList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTypeArgumentList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
		TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_typeArgumentList);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(321);
			typeArgument();
			setState(326);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(322);
					match(COMMA);
					setState(323);
					typeArgument();
					}
					} 
				}
				setState(328);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TypeArgumentContext extends ParserRuleContext {
		public ReferenceTypeContext referenceType() {
			return getRuleContext(ReferenceTypeContext.class,0);
		}
		public WildcardContext wildcard() {
			return getRuleContext(WildcardContext.class,0);
		}
		public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArgument; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTypeArgument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTypeArgument(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTypeArgument(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgumentContext typeArgument() throws RecognitionException {
		TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_typeArgument);
		try {
			setState(331);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(329);
				referenceType();
				}
				break;
			case QUESTION:
				enterOuterAlt(_localctx, 2);
				{
				setState(330);
				wildcard();
				}
				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 WildcardContext extends ParserRuleContext {
		public TerminalNode QUESTION() { return getToken(QLParser.QUESTION, 0); }
		public WildcardBoundsContext wildcardBounds() {
			return getRuleContext(WildcardBoundsContext.class,0);
		}
		public WildcardContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wildcard; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterWildcard(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitWildcard(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitWildcard(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WildcardContext wildcard() throws RecognitionException {
		WildcardContext _localctx = new WildcardContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_wildcard);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(333);
			match(QUESTION);
			setState(335);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EXTENDS || _la==SUPER) {
				{
				setState(334);
				wildcardBounds();
				}
			}

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

	public static class WildcardBoundsContext extends ParserRuleContext {
		public TerminalNode EXTENDS() { return getToken(QLParser.EXTENDS, 0); }
		public ReferenceTypeContext referenceType() {
			return getRuleContext(ReferenceTypeContext.class,0);
		}
		public TerminalNode SUPER() { return getToken(QLParser.SUPER, 0); }
		public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wildcardBounds; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterWildcardBounds(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitWildcardBounds(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitWildcardBounds(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
		WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_wildcardBounds);
		try {
			setState(341);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case EXTENDS:
				enterOuterAlt(_localctx, 1);
				{
				setState(337);
				match(EXTENDS);
				setState(338);
				referenceType();
				}
				break;
			case SUPER:
				enterOuterAlt(_localctx, 2);
				{
				setState(339);
				match(SUPER);
				setState(340);
				referenceType();
				}
				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 ExpressionContext extends ParserRuleContext {
		public LeftHandSideContext leftHandSide() {
			return getRuleContext(LeftHandSideContext.class,0);
		}
		public AssignOperatorContext assignOperator() {
			return getRuleContext(AssignOperatorContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TernaryExprContext ternaryExpr() {
			return getRuleContext(TernaryExprContext.class,0);
		}
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_expression);
		try {
			setState(348);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(343);
				leftHandSide();
				setState(344);
				assignOperator();
				setState(345);
				expression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(347);
				ternaryExpr();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LeftHandSideContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public List pathPart() {
			return getRuleContexts(PathPartContext.class);
		}
		public PathPartContext pathPart(int i) {
			return getRuleContext(PathPartContext.class,i);
		}
		public LeftHandSideContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_leftHandSide; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLeftHandSide(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLeftHandSide(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLeftHandSide(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LeftHandSideContext leftHandSide() throws RecognitionException {
		LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_leftHandSide);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(350);
			varId();
			setState(354);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(351);
					pathPart();
					}
					} 
				}
				setState(356);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
			}
			}
		}
		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 BaseExprContext condition;
		public BaseExprContext thenExpr;
		public ExpressionContext elseExpr;
		public List baseExpr() {
			return getRuleContexts(BaseExprContext.class);
		}
		public BaseExprContext baseExpr(int i) {
			return getRuleContext(BaseExprContext.class,i);
		}
		public TerminalNode QUESTION() { return getToken(QLParser.QUESTION, 0); }
		public TerminalNode COLON() { return getToken(QLParser.COLON, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,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 QLParserListener ) ((QLParserListener)listener).enterTernaryExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTernaryExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTernaryExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TernaryExprContext ternaryExpr() throws RecognitionException {
		TernaryExprContext _localctx = new TernaryExprContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_ternaryExpr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(357);
			((TernaryExprContext)_localctx).condition = baseExpr(1);
			setState(363);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
			case 1:
				{
				setState(358);
				match(QUESTION);
				setState(359);
				((TernaryExprContext)_localctx).thenExpr = baseExpr(0);
				setState(360);
				match(COLON);
				setState(361);
				((TernaryExprContext)_localctx).elseExpr = expression();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BaseExprContext extends ParserRuleContext {
		public int p;
		public PrimaryContext primary() {
			return getRuleContext(PrimaryContext.class,0);
		}
		public List leftAsso() {
			return getRuleContexts(LeftAssoContext.class);
		}
		public LeftAssoContext leftAsso(int i) {
			return getRuleContext(LeftAssoContext.class,i);
		}
		public BaseExprContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
		public BaseExprContext(ParserRuleContext parent, int invokingState, int p) {
			super(parent, invokingState);
			this.p = p;
		}
		@Override public int getRuleIndex() { return RULE_baseExpr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBaseExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBaseExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBaseExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BaseExprContext baseExpr(int p) throws RecognitionException {
		BaseExprContext _localctx = new BaseExprContext(_ctx, getState(), p);
		enterRule(_localctx, 52, RULE_baseExpr);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(365);
			primary();
			setState(370);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(366);
					if (!(_input.LT(1).getType() != Token.EOF &&
					        opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) >= _localctx.p)) throw new FailedPredicateException(this, "_input.LT(1).getType() != Token.EOF &&\n        opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) >= $p");
					setState(367);
					leftAsso();
					}
					} 
				}
				setState(372);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LeftAssoContext extends ParserRuleContext {
		public BinaryopContext binaryop() {
			return getRuleContext(BinaryopContext.class,0);
		}
		public BaseExprContext baseExpr() {
			return getRuleContext(BaseExprContext.class,0);
		}
		public LeftAssoContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_leftAsso; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLeftAsso(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLeftAsso(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLeftAsso(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LeftAssoContext leftAsso() throws RecognitionException {
		LeftAssoContext _localctx = new LeftAssoContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_leftAsso);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(373);
			binaryop();
			setState(374);
			baseExpr(opM.precedence(_input.LT(-1).getText()) + 1);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BinaryopContext extends ParserRuleContext {
		public OpIdContext opId() {
			return getRuleContext(OpIdContext.class,0);
		}
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public BinaryopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_binaryop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBinaryop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBinaryop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBinaryop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BinaryopContext binaryop() throws RecognitionException {
		BinaryopContext _localctx = new BinaryopContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_binaryop);
		try {
			setState(378);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case GT:
			case LT:
			case EQ:
			case NOEQ:
			case RIGHSHIFT_ASSGIN:
			case RIGHSHIFT:
			case URSHIFT_ASSGIN:
			case URSHIFT:
			case LSHIFT_ASSGIN:
			case LEFTSHIFT:
			case GE:
			case LE:
			case DOTMUL:
			case CARET:
			case ADD_ASSIGN:
			case SUB_ASSIGN:
			case AND_ASSIGN:
			case OR_ASSIGN:
			case MUL_ASSIGN:
			case MOD_ASSIGN:
			case DIV_ASSIGN:
			case XOR_ASSIGN:
			case BANG:
			case TILDE:
			case ADD:
			case SUB:
			case MUL:
			case DIV:
			case BIT_AND:
			case BIT_OR:
			case MOD:
			case INC:
			case DEC:
			case OPID:
				enterOuterAlt(_localctx, 1);
				{
				setState(376);
				opId();
				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(377);
				varId();
				}
				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 PrimaryContext extends ParserRuleContext {
		public PrimaryNoFixContext primaryNoFix() {
			return getRuleContext(PrimaryNoFixContext.class,0);
		}
		public PrefixExpressContext prefixExpress() {
			return getRuleContext(PrefixExpressContext.class,0);
		}
		public List pathPart() {
			return getRuleContexts(PathPartContext.class);
		}
		public PathPartContext pathPart(int i) {
			return getRuleContext(PathPartContext.class,i);
		}
		public SuffixExpressContext suffixExpress() {
			return getRuleContext(SuffixExpressContext.class,0);
		}
		public PrimaryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primary; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterPrimary(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitPrimary(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitPrimary(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimaryContext primary() throws RecognitionException {
		PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_primary);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(381);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				{
				setState(380);
				prefixExpress();
				}
				break;
			}
			setState(383);
			primaryNoFix();
			setState(387);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(384);
					pathPart();
					}
					} 
				}
				setState(389);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
			}
			setState(391);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				{
				setState(390);
				suffixExpress();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrefixExpressContext extends ParserRuleContext {
		public OpIdContext opId() {
			return getRuleContext(OpIdContext.class,0);
		}
		public PrefixExpressContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_prefixExpress; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterPrefixExpress(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitPrefixExpress(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitPrefixExpress(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrefixExpressContext prefixExpress() throws RecognitionException {
		PrefixExpressContext _localctx = new PrefixExpressContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_prefixExpress);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(393);
			if (!(_input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), PREFIX))) throw new FailedPredicateException(this, "_input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), PREFIX)");
			setState(394);
			opId();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SuffixExpressContext extends ParserRuleContext {
		public OpIdContext opId() {
			return getRuleContext(OpIdContext.class,0);
		}
		public SuffixExpressContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_suffixExpress; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterSuffixExpress(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitSuffixExpress(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitSuffixExpress(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SuffixExpressContext suffixExpress() throws RecognitionException {
		SuffixExpressContext _localctx = new SuffixExpressContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_suffixExpress);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396);
			if (!(_input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), SUFFIX))) throw new FailedPredicateException(this, "_input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), SUFFIX)");
			setState(397);
			opId();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrimaryNoFixContext extends ParserRuleContext {
		public PrimaryNoFixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primaryNoFix; }
	 
		public PrimaryNoFixContext() { }
		public void copyFrom(PrimaryNoFixContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class GroupExprContext extends PrimaryNoFixContext {
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public GroupExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterGroupExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitGroupExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitGroupExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NewEmptyArrExprContext extends PrimaryNoFixContext {
		public TerminalNode NEW() { return getToken(QLParser.NEW, 0); }
		public DeclTypeNoArrContext declTypeNoArr() {
			return getRuleContext(DeclTypeNoArrContext.class,0);
		}
		public DimExprsContext dimExprs() {
			return getRuleContext(DimExprsContext.class,0);
		}
		public NewEmptyArrExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterNewEmptyArrExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitNewEmptyArrExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitNewEmptyArrExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class VarIdExprContext extends PrimaryNoFixContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public VarIdExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVarIdExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVarIdExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVarIdExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class CastExprContext extends PrimaryNoFixContext {
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public DeclTypeContext declType() {
			return getRuleContext(DeclTypeContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public PrimaryContext primary() {
			return getRuleContext(PrimaryContext.class,0);
		}
		public CastExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterCastExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitCastExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitCastExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class TypeExprContext extends PrimaryNoFixContext {
		public PrimitiveTypeContext primitiveType() {
			return getRuleContext(PrimitiveTypeContext.class,0);
		}
		public TypeExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTypeExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTypeExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTypeExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ContextSelectExprContext extends PrimaryNoFixContext {
		public TerminalNode SELECTOR_START() { return getToken(QLParser.SELECTOR_START, 0); }
		public TerminalNode SelectorVariable_VANME() { return getToken(QLParser.SelectorVariable_VANME, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public ContextSelectExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterContextSelectExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitContextSelectExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitContextSelectExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MapExprContext extends PrimaryNoFixContext {
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public MapEntriesContext mapEntries() {
			return getRuleContext(MapEntriesContext.class,0);
		}
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public MapExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMapExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMapExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMapExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NewInitArrExprContext extends PrimaryNoFixContext {
		public TerminalNode NEW() { return getToken(QLParser.NEW, 0); }
		public DeclTypeNoArrContext declTypeNoArr() {
			return getRuleContext(DeclTypeNoArrContext.class,0);
		}
		public DimsContext dims() {
			return getRuleContext(DimsContext.class,0);
		}
		public ArrayInitializerContext arrayInitializer() {
			return getRuleContext(ArrayInitializerContext.class,0);
		}
		public NewInitArrExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterNewInitArrExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitNewInitArrExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitNewInitArrExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class TryCatchExprContext extends PrimaryNoFixContext {
		public TerminalNode TRY() { return getToken(QLParser.TRY, 0); }
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public TryCatchesContext tryCatches() {
			return getRuleContext(TryCatchesContext.class,0);
		}
		public TryFinallyContext tryFinally() {
			return getRuleContext(TryFinallyContext.class,0);
		}
		public TryCatchExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTryCatchExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTryCatchExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTryCatchExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class NewObjExprContext extends PrimaryNoFixContext {
		public TerminalNode NEW() { return getToken(QLParser.NEW, 0); }
		public List varId() {
			return getRuleContexts(VarIdContext.class);
		}
		public VarIdContext varId(int i) {
			return getRuleContext(VarIdContext.class,i);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public List DOT() { return getTokens(QLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(QLParser.DOT, i);
		}
		public TypeArgumentsContext typeArguments() {
			return getRuleContext(TypeArgumentsContext.class,0);
		}
		public ArgumentListContext argumentList() {
			return getRuleContext(ArgumentListContext.class,0);
		}
		public NewObjExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterNewObjExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitNewObjExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitNewObjExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class LambdaExprContext extends PrimaryNoFixContext {
		public LambdaParametersContext lambdaParameters() {
			return getRuleContext(LambdaParametersContext.class,0);
		}
		public TerminalNode ARROW() { return getToken(QLParser.ARROW, 0); }
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public LambdaExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLambdaExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLambdaExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLambdaExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class IfExprContext extends PrimaryNoFixContext {
		public ExpressionContext condition;
		public IfBodyContext thenBody;
		public IfBodyContext elseBody;
		public TerminalNode IF() { return getToken(QLParser.IF, 0); }
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public List ifBody() {
			return getRuleContexts(IfBodyContext.class);
		}
		public IfBodyContext ifBody(int i) {
			return getRuleContext(IfBodyContext.class,i);
		}
		public TerminalNode ELSE() { return getToken(QLParser.ELSE, 0); }
		public IfExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterIfExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitIfExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitIfExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class BlockExprContext extends PrimaryNoFixContext {
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public BlockExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBlockExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBlockExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBlockExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ListExprContext extends PrimaryNoFixContext {
		public TerminalNode LBRACK() { return getToken(QLParser.LBRACK, 0); }
		public TerminalNode RBRACK() { return getToken(QLParser.RBRACK, 0); }
		public ListItemsContext listItems() {
			return getRuleContext(ListItemsContext.class,0);
		}
		public ListExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterListExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitListExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitListExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ConstExprContext extends PrimaryNoFixContext {
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public ConstExprContext(PrimaryNoFixContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterConstExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitConstExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitConstExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimaryNoFixContext primaryNoFix() throws RecognitionException {
		PrimaryNoFixContext _localctx = new PrimaryNoFixContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_primaryNoFix);
		int _la;
		try {
			setState(486);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
			case 1:
				_localctx = new ConstExprContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(399);
				literal();
				}
				break;
			case 2:
				_localctx = new CastExprContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(400);
				match(LPAREN);
				setState(401);
				declType();
				setState(402);
				match(RPAREN);
				setState(403);
				primary();
				}
				break;
			case 3:
				_localctx = new GroupExprContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(405);
				match(LPAREN);
				setState(406);
				expression();
				setState(407);
				match(RPAREN);
				}
				break;
			case 4:
				_localctx = new NewObjExprContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(409);
				match(NEW);
				setState(410);
				varId();
				setState(415);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==DOT) {
					{
					{
					setState(411);
					match(DOT);
					setState(412);
					varId();
					}
					}
					setState(417);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(419);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LT || _la==NOEQ) {
					{
					setState(418);
					typeArguments();
					}
				}

				setState(421);
				match(LPAREN);
				setState(423);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
				case 1:
					{
					setState(422);
					argumentList();
					}
					break;
				}
				setState(425);
				match(RPAREN);
				}
				break;
			case 5:
				_localctx = new NewEmptyArrExprContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(427);
				match(NEW);
				setState(428);
				declTypeNoArr();
				setState(429);
				dimExprs();
				}
				break;
			case 6:
				_localctx = new NewInitArrExprContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(431);
				match(NEW);
				setState(432);
				declTypeNoArr();
				setState(433);
				dims();
				setState(434);
				arrayInitializer();
				}
				break;
			case 7:
				_localctx = new LambdaExprContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(436);
				lambdaParameters();
				setState(437);
				match(ARROW);
				setState(444);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
				case 1:
					{
					setState(438);
					match(LBRACE);
					setState(440);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
					case 1:
						{
						setState(439);
						blockStatements();
						}
						break;
					}
					setState(442);
					match(RBRACE);
					}
					break;
				case 2:
					{
					setState(443);
					expression();
					}
					break;
				}
				}
				break;
			case 8:
				_localctx = new VarIdExprContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(446);
				varId();
				}
				break;
			case 9:
				_localctx = new TypeExprContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(447);
				primitiveType();
				}
				break;
			case 10:
				_localctx = new ListExprContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(448);
				match(LBRACK);
				setState(450);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
				case 1:
					{
					setState(449);
					listItems();
					}
					break;
				}
				setState(452);
				match(RBRACK);
				}
				break;
			case 11:
				_localctx = new MapExprContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(453);
				match(LBRACE);
				setState(454);
				mapEntries();
				setState(455);
				match(RBRACE);
				}
				break;
			case 12:
				_localctx = new BlockExprContext(_localctx);
				enterOuterAlt(_localctx, 12);
				{
				setState(457);
				match(LBRACE);
				setState(459);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
				case 1:
					{
					setState(458);
					blockStatements();
					}
					break;
				}
				setState(461);
				match(RBRACE);
				}
				break;
			case 13:
				_localctx = new IfExprContext(_localctx);
				enterOuterAlt(_localctx, 13);
				{
				setState(462);
				match(IF);
				setState(463);
				match(LPAREN);
				setState(464);
				((IfExprContext)_localctx).condition = expression();
				setState(465);
				match(RPAREN);
				setState(466);
				((IfExprContext)_localctx).thenBody = ifBody();
				setState(469);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
				case 1:
					{
					setState(467);
					match(ELSE);
					setState(468);
					((IfExprContext)_localctx).elseBody = ifBody();
					}
					break;
				}
				}
				break;
			case 14:
				_localctx = new TryCatchExprContext(_localctx);
				enterOuterAlt(_localctx, 14);
				{
				setState(471);
				match(TRY);
				setState(472);
				match(LBRACE);
				setState(474);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
				case 1:
					{
					setState(473);
					blockStatements();
					}
					break;
				}
				setState(476);
				match(RBRACE);
				setState(478);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
				case 1:
					{
					setState(477);
					tryCatches();
					}
					break;
				}
				setState(481);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
				case 1:
					{
					setState(480);
					tryFinally();
					}
					break;
				}
				}
				break;
			case 15:
				_localctx = new ContextSelectExprContext(_localctx);
				enterOuterAlt(_localctx, 15);
				{
				setState(483);
				match(SELECTOR_START);
				setState(484);
				match(SelectorVariable_VANME);
				setState(485);
				match(RBRACE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IfBodyContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public BlockStatementContext blockStatement() {
			return getRuleContext(BlockStatementContext.class,0);
		}
		public IfBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifBody; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterIfBody(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitIfBody(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitIfBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfBodyContext ifBody() throws RecognitionException {
		IfBodyContext _localctx = new IfBodyContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_ifBody);
		try {
			setState(494);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(488);
				match(LBRACE);
				setState(490);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
				case 1:
					{
					setState(489);
					blockStatements();
					}
					break;
				}
				setState(492);
				match(RBRACE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(493);
				blockStatement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListItemsContext extends ParserRuleContext {
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public ListItemsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listItems; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterListItems(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitListItems(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitListItems(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListItemsContext listItems() throws RecognitionException {
		ListItemsContext _localctx = new ListItemsContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_listItems);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(496);
			expression();
			setState(501);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(497);
				match(COMMA);
				setState(498);
				expression();
				}
				}
				setState(503);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DimExprsContext extends ParserRuleContext {
		public List LBRACK() { return getTokens(QLParser.LBRACK); }
		public TerminalNode LBRACK(int i) {
			return getToken(QLParser.LBRACK, i);
		}
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List RBRACK() { return getTokens(QLParser.RBRACK); }
		public TerminalNode RBRACK(int i) {
			return getToken(QLParser.RBRACK, i);
		}
		public DimExprsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dimExprs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterDimExprs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitDimExprs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitDimExprs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DimExprsContext dimExprs() throws RecognitionException {
		DimExprsContext _localctx = new DimExprsContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_dimExprs);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(504);
			match(LBRACK);
			setState(505);
			expression();
			setState(506);
			match(RBRACK);
			setState(513);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(507);
					match(LBRACK);
					setState(508);
					expression();
					setState(509);
					match(RBRACK);
					}
					} 
				}
				setState(515);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TryCatchesContext extends ParserRuleContext {
		public List tryCatch() {
			return getRuleContexts(TryCatchContext.class);
		}
		public TryCatchContext tryCatch(int i) {
			return getRuleContext(TryCatchContext.class,i);
		}
		public TryCatchesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tryCatches; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTryCatches(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTryCatches(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTryCatches(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TryCatchesContext tryCatches() throws RecognitionException {
		TryCatchesContext _localctx = new TryCatchesContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_tryCatches);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(516);
			tryCatch();
			setState(520);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(517);
					tryCatch();
					}
					} 
				}
				setState(522);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,61,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TryCatchContext extends ParserRuleContext {
		public TerminalNode CATCH() { return getToken(QLParser.CATCH, 0); }
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public CatchParamsContext catchParams() {
			return getRuleContext(CatchParamsContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public TryCatchContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tryCatch; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTryCatch(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTryCatch(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTryCatch(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TryCatchContext tryCatch() throws RecognitionException {
		TryCatchContext _localctx = new TryCatchContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_tryCatch);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(523);
			match(CATCH);
			setState(524);
			match(LPAREN);
			setState(525);
			catchParams();
			setState(526);
			match(RPAREN);
			setState(527);
			match(LBRACE);
			setState(529);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				{
				setState(528);
				blockStatements();
				}
				break;
			}
			setState(531);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CatchParamsContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public List declType() {
			return getRuleContexts(DeclTypeContext.class);
		}
		public DeclTypeContext declType(int i) {
			return getRuleContext(DeclTypeContext.class,i);
		}
		public List BIT_OR() { return getTokens(QLParser.BIT_OR); }
		public TerminalNode BIT_OR(int i) {
			return getToken(QLParser.BIT_OR, i);
		}
		public CatchParamsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_catchParams; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterCatchParams(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitCatchParams(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitCatchParams(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CatchParamsContext catchParams() throws RecognitionException {
		CatchParamsContext _localctx = new CatchParamsContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_catchParams);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(541);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
			case 1:
				{
				setState(533);
				declType();
				setState(538);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==BIT_OR) {
					{
					{
					setState(534);
					match(BIT_OR);
					setState(535);
					declType();
					}
					}
					setState(540);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
			setState(543);
			varId();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TryFinallyContext extends ParserRuleContext {
		public TerminalNode FINALLY() { return getToken(QLParser.FINALLY, 0); }
		public TerminalNode LBRACE() { return getToken(QLParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public BlockStatementsContext blockStatements() {
			return getRuleContext(BlockStatementsContext.class,0);
		}
		public TryFinallyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tryFinally; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterTryFinally(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitTryFinally(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitTryFinally(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TryFinallyContext tryFinally() throws RecognitionException {
		TryFinallyContext _localctx = new TryFinallyContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_tryFinally);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(545);
			match(FINALLY);
			setState(546);
			match(LBRACE);
			setState(548);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
			case 1:
				{
				setState(547);
				blockStatements();
				}
				break;
			}
			setState(550);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapEntriesContext extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(QLParser.COLON, 0); }
		public List mapEntry() {
			return getRuleContexts(MapEntryContext.class);
		}
		public MapEntryContext mapEntry(int i) {
			return getRuleContext(MapEntryContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public MapEntriesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapEntries; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMapEntries(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMapEntries(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMapEntries(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapEntriesContext mapEntries() throws RecognitionException {
		MapEntriesContext _localctx = new MapEntriesContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_mapEntries);
		int _la;
		try {
			int _alt;
			setState(564);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case COLON:
				enterOuterAlt(_localctx, 1);
				{
				setState(552);
				match(COLON);
				}
				break;
			case FOR:
			case IF:
			case ELSE:
			case WHILE:
			case BREAK:
			case CONTINUE:
			case RETURN:
			case FUNCTION:
			case MACRO:
			case IMPORT:
			case STATIC:
			case NEW:
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
			case NULL:
			case TRUE:
			case FALSE:
			case EXTENDS:
			case SUPER:
			case TRY:
			case CATCH:
			case FINALLY:
			case THROW:
			case CLASS:
			case THIS:
			case QuoteStringLiteral:
			case ID:
			case DOUBLE_QUOTE_OPEN:
				enterOuterAlt(_localctx, 2);
				{
				setState(553);
				mapEntry();
				setState(558);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(554);
						match(COMMA);
						setState(555);
						mapEntry();
						}
						} 
					}
					setState(560);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
				}
				setState(562);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA) {
					{
					setState(561);
					match(COMMA);
					}
				}

				}
				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 MapEntryContext extends ParserRuleContext {
		public MapKeyContext mapKey() {
			return getRuleContext(MapKeyContext.class,0);
		}
		public TerminalNode COLON() { return getToken(QLParser.COLON, 0); }
		public MapValueContext mapValue() {
			return getRuleContext(MapValueContext.class,0);
		}
		public MapEntryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapEntry; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMapEntry(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMapEntry(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMapEntry(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapEntryContext mapEntry() throws RecognitionException {
		MapEntryContext _localctx = new MapEntryContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_mapEntry);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(566);
			mapKey();
			setState(567);
			match(COLON);
			setState(568);
			mapValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapValueContext extends ParserRuleContext {
		public MapValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapValue; }
	 
		public MapValueContext() { }
		public void copyFrom(MapValueContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ClsValueContext extends MapValueContext {
		public TerminalNode QuoteStringLiteral() { return getToken(QLParser.QuoteStringLiteral, 0); }
		public ClsValueContext(MapValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterClsValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitClsValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitClsValue(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class EValueContext extends MapValueContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public EValueContext(MapValueContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterEValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitEValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitEValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapValueContext mapValue() throws RecognitionException {
		MapValueContext _localctx = new MapValueContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_mapValue);
		try {
			setState(573);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				_localctx = new ClsValueContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(570);
				if (!(_input.LT(-2).getText().equals("'@class'"))) throw new FailedPredicateException(this, "_input.LT(-2).getText().equals(\"'@class'\")");
				setState(571);
				match(QuoteStringLiteral);
				}
				break;
			case 2:
				_localctx = new EValueContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(572);
				expression();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MapKeyContext extends ParserRuleContext {
		public MapKeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mapKey; }
	 
		public MapKeyContext() { }
		public void copyFrom(MapKeyContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class QuoteStringKeyContext extends MapKeyContext {
		public TerminalNode QuoteStringLiteral() { return getToken(QLParser.QuoteStringLiteral, 0); }
		public QuoteStringKeyContext(MapKeyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterQuoteStringKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitQuoteStringKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitQuoteStringKey(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class IdKeyContext extends MapKeyContext {
		public IdMapKeyContext idMapKey() {
			return getRuleContext(IdMapKeyContext.class,0);
		}
		public IdKeyContext(MapKeyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterIdKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitIdKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitIdKey(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class StringKeyContext extends MapKeyContext {
		public DoubleQuoteStringLiteralContext doubleQuoteStringLiteral() {
			return getRuleContext(DoubleQuoteStringLiteralContext.class,0);
		}
		public StringKeyContext(MapKeyContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterStringKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitStringKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitStringKey(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MapKeyContext mapKey() throws RecognitionException {
		MapKeyContext _localctx = new MapKeyContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_mapKey);
		try {
			setState(578);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FOR:
			case IF:
			case ELSE:
			case WHILE:
			case BREAK:
			case CONTINUE:
			case RETURN:
			case FUNCTION:
			case MACRO:
			case IMPORT:
			case STATIC:
			case NEW:
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
			case NULL:
			case TRUE:
			case FALSE:
			case EXTENDS:
			case SUPER:
			case TRY:
			case CATCH:
			case FINALLY:
			case THROW:
			case CLASS:
			case THIS:
			case ID:
				_localctx = new IdKeyContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(575);
				idMapKey();
				}
				break;
			case DOUBLE_QUOTE_OPEN:
				_localctx = new StringKeyContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(576);
				doubleQuoteStringLiteral();
				}
				break;
			case QuoteStringLiteral:
				_localctx = new QuoteStringKeyContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(577);
				match(QuoteStringLiteral);
				}
				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 IdMapKeyContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode FOR() { return getToken(QLParser.FOR, 0); }
		public TerminalNode IF() { return getToken(QLParser.IF, 0); }
		public TerminalNode ELSE() { return getToken(QLParser.ELSE, 0); }
		public TerminalNode WHILE() { return getToken(QLParser.WHILE, 0); }
		public TerminalNode BREAK() { return getToken(QLParser.BREAK, 0); }
		public TerminalNode CONTINUE() { return getToken(QLParser.CONTINUE, 0); }
		public TerminalNode RETURN() { return getToken(QLParser.RETURN, 0); }
		public TerminalNode FUNCTION() { return getToken(QLParser.FUNCTION, 0); }
		public TerminalNode MACRO() { return getToken(QLParser.MACRO, 0); }
		public TerminalNode IMPORT() { return getToken(QLParser.IMPORT, 0); }
		public TerminalNode STATIC() { return getToken(QLParser.STATIC, 0); }
		public TerminalNode NEW() { return getToken(QLParser.NEW, 0); }
		public TerminalNode BYTE() { return getToken(QLParser.BYTE, 0); }
		public TerminalNode SHORT() { return getToken(QLParser.SHORT, 0); }
		public TerminalNode INT() { return getToken(QLParser.INT, 0); }
		public TerminalNode LONG() { return getToken(QLParser.LONG, 0); }
		public TerminalNode FLOAT() { return getToken(QLParser.FLOAT, 0); }
		public TerminalNode DOUBLE() { return getToken(QLParser.DOUBLE, 0); }
		public TerminalNode CHAR() { return getToken(QLParser.CHAR, 0); }
		public TerminalNode BOOL() { return getToken(QLParser.BOOL, 0); }
		public TerminalNode NULL() { return getToken(QLParser.NULL, 0); }
		public TerminalNode TRUE() { return getToken(QLParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(QLParser.FALSE, 0); }
		public TerminalNode EXTENDS() { return getToken(QLParser.EXTENDS, 0); }
		public TerminalNode SUPER() { return getToken(QLParser.SUPER, 0); }
		public TerminalNode TRY() { return getToken(QLParser.TRY, 0); }
		public TerminalNode CATCH() { return getToken(QLParser.CATCH, 0); }
		public TerminalNode FINALLY() { return getToken(QLParser.FINALLY, 0); }
		public TerminalNode THROW() { return getToken(QLParser.THROW, 0); }
		public TerminalNode CLASS() { return getToken(QLParser.CLASS, 0); }
		public TerminalNode THIS() { return getToken(QLParser.THIS, 0); }
		public IdMapKeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_idMapKey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterIdMapKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitIdMapKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitIdMapKey(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdMapKeyContext idMapKey() throws RecognitionException {
		IdMapKeyContext _localctx = new IdMapKeyContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_idMapKey);
		try {
			setState(612);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(580);
				varId();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(581);
				match(FOR);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(582);
				match(IF);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(583);
				match(ELSE);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(584);
				match(WHILE);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(585);
				match(BREAK);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(586);
				match(CONTINUE);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(587);
				match(RETURN);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(588);
				match(FUNCTION);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(589);
				match(MACRO);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(590);
				match(IMPORT);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(591);
				match(STATIC);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(592);
				match(NEW);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(593);
				match(BYTE);
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(594);
				match(SHORT);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(595);
				match(INT);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(596);
				match(LONG);
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(597);
				match(FLOAT);
				}
				break;
			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(598);
				match(DOUBLE);
				}
				break;
			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(599);
				match(CHAR);
				}
				break;
			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(600);
				match(BOOL);
				}
				break;
			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(601);
				match(NULL);
				}
				break;
			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(602);
				match(TRUE);
				}
				break;
			case 24:
				enterOuterAlt(_localctx, 24);
				{
				setState(603);
				match(FALSE);
				}
				break;
			case 25:
				enterOuterAlt(_localctx, 25);
				{
				setState(604);
				match(EXTENDS);
				}
				break;
			case 26:
				enterOuterAlt(_localctx, 26);
				{
				setState(605);
				match(SUPER);
				}
				break;
			case 27:
				enterOuterAlt(_localctx, 27);
				{
				setState(606);
				match(TRY);
				}
				break;
			case 28:
				enterOuterAlt(_localctx, 28);
				{
				setState(607);
				match(CATCH);
				}
				break;
			case 29:
				enterOuterAlt(_localctx, 29);
				{
				setState(608);
				match(FINALLY);
				}
				break;
			case 30:
				enterOuterAlt(_localctx, 30);
				{
				setState(609);
				match(THROW);
				}
				break;
			case 31:
				enterOuterAlt(_localctx, 31);
				{
				setState(610);
				match(CLASS);
				}
				break;
			case 32:
				enterOuterAlt(_localctx, 32);
				{
				setState(611);
				match(THIS);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PathPartContext extends ParserRuleContext {
		public PathPartContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pathPart; }
	 
		public PathPartContext() { }
		public void copyFrom(PathPartContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class IndexExprContext extends PathPartContext {
		public TerminalNode LBRACK() { return getToken(QLParser.LBRACK, 0); }
		public TerminalNode RBRACK() { return getToken(QLParser.RBRACK, 0); }
		public IndexValueExprContext indexValueExpr() {
			return getRuleContext(IndexValueExprContext.class,0);
		}
		public IndexExprContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterIndexExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitIndexExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitIndexExpr(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class SpreadMethodInvokeContext extends PathPartContext {
		public TerminalNode SPREAD_CHAINING() { return getToken(QLParser.SPREAD_CHAINING, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public ArgumentListContext argumentList() {
			return getRuleContext(ArgumentListContext.class,0);
		}
		public SpreadMethodInvokeContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterSpreadMethodInvoke(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitSpreadMethodInvoke(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitSpreadMethodInvoke(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class CustomPathContext extends PathPartContext {
		public OpIdContext opId() {
			return getRuleContext(OpIdContext.class,0);
		}
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public CustomPathContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterCustomPath(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitCustomPath(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitCustomPath(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MethodInvokeContext extends PathPartContext {
		public TerminalNode DOT() { return getToken(QLParser.DOT, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public ArgumentListContext argumentList() {
			return getRuleContext(ArgumentListContext.class,0);
		}
		public MethodInvokeContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMethodInvoke(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMethodInvoke(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMethodInvoke(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class OptionalMethodInvokeContext extends PathPartContext {
		public TerminalNode OPTIONAL_CHAINING() { return getToken(QLParser.OPTIONAL_CHAINING, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public ArgumentListContext argumentList() {
			return getRuleContext(ArgumentListContext.class,0);
		}
		public OptionalMethodInvokeContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterOptionalMethodInvoke(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitOptionalMethodInvoke(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitOptionalMethodInvoke(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class MethodAccessContext extends PathPartContext {
		public TerminalNode DCOLON() { return getToken(QLParser.DCOLON, 0); }
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public MethodAccessContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterMethodAccess(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitMethodAccess(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitMethodAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class FieldAccessContext extends PathPartContext {
		public TerminalNode DOT() { return getToken(QLParser.DOT, 0); }
		public FieldIdContext fieldId() {
			return getRuleContext(FieldIdContext.class,0);
		}
		public FieldAccessContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterFieldAccess(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitFieldAccess(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitFieldAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class OptionalFieldAccessContext extends PathPartContext {
		public TerminalNode OPTIONAL_CHAINING() { return getToken(QLParser.OPTIONAL_CHAINING, 0); }
		public FieldIdContext fieldId() {
			return getRuleContext(FieldIdContext.class,0);
		}
		public OptionalFieldAccessContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterOptionalFieldAccess(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitOptionalFieldAccess(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitOptionalFieldAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class SpreadFieldAccessContext extends PathPartContext {
		public TerminalNode SPREAD_CHAINING() { return getToken(QLParser.SPREAD_CHAINING, 0); }
		public FieldIdContext fieldId() {
			return getRuleContext(FieldIdContext.class,0);
		}
		public SpreadFieldAccessContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterSpreadFieldAccess(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitSpreadFieldAccess(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitSpreadFieldAccess(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class CallExprContext extends PathPartContext {
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public ArgumentListContext argumentList() {
			return getRuleContext(ArgumentListContext.class,0);
		}
		public CallExprContext(PathPartContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterCallExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitCallExpr(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitCallExpr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PathPartContext pathPart() throws RecognitionException {
		PathPartContext _localctx = new PathPartContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_pathPart);
		try {
			setState(660);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
			case 1:
				_localctx = new MethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(614);
				match(DOT);
				setState(615);
				varId();
				setState(616);
				match(LPAREN);
				setState(618);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
				case 1:
					{
					setState(617);
					argumentList();
					}
					break;
				}
				setState(620);
				match(RPAREN);
				}
				break;
			case 2:
				_localctx = new OptionalMethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(622);
				match(OPTIONAL_CHAINING);
				setState(623);
				varId();
				setState(624);
				match(LPAREN);
				setState(626);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
				case 1:
					{
					setState(625);
					argumentList();
					}
					break;
				}
				setState(628);
				match(RPAREN);
				}
				break;
			case 3:
				_localctx = new SpreadMethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(630);
				match(SPREAD_CHAINING);
				setState(631);
				varId();
				setState(632);
				match(LPAREN);
				setState(634);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
				case 1:
					{
					setState(633);
					argumentList();
					}
					break;
				}
				setState(636);
				match(RPAREN);
				}
				break;
			case 4:
				_localctx = new FieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(638);
				match(DOT);
				setState(639);
				fieldId();
				}
				break;
			case 5:
				_localctx = new OptionalFieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(640);
				match(OPTIONAL_CHAINING);
				setState(641);
				fieldId();
				}
				break;
			case 6:
				_localctx = new SpreadFieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(642);
				match(SPREAD_CHAINING);
				setState(643);
				fieldId();
				}
				break;
			case 7:
				_localctx = new MethodAccessContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(644);
				match(DCOLON);
				setState(645);
				varId();
				}
				break;
			case 8:
				_localctx = new CallExprContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(646);
				match(LPAREN);
				setState(648);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
				case 1:
					{
					setState(647);
					argumentList();
					}
					break;
				}
				setState(650);
				match(RPAREN);
				}
				break;
			case 9:
				_localctx = new IndexExprContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(651);
				match(LBRACK);
				setState(653);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
				case 1:
					{
					setState(652);
					indexValueExpr();
					}
					break;
				}
				setState(655);
				match(RBRACK);
				}
				break;
			case 10:
				_localctx = new CustomPathContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(656);
				if (!(opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) == GROUP)) throw new FailedPredicateException(this, "opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) == GROUP");
				setState(657);
				opId();
				setState(658);
				varId();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FieldIdContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode CLASS() { return getToken(QLParser.CLASS, 0); }
		public TerminalNode QuoteStringLiteral() { return getToken(QLParser.QuoteStringLiteral, 0); }
		public FieldIdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fieldId; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterFieldId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitFieldId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitFieldId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FieldIdContext fieldId() throws RecognitionException {
		FieldIdContext _localctx = new FieldIdContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_fieldId);
		try {
			setState(665);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(662);
				varId();
				}
				break;
			case CLASS:
				enterOuterAlt(_localctx, 2);
				{
				setState(663);
				match(CLASS);
				}
				break;
			case QuoteStringLiteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(664);
				match(QuoteStringLiteral);
				}
				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 IndexValueExprContext extends ParserRuleContext {
		public IndexValueExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexValueExpr; }
	 
		public IndexValueExprContext() { }
		public void copyFrom(IndexValueExprContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class SliceIndexContext extends IndexValueExprContext {
		public ExpressionContext start;
		public ExpressionContext end;
		public TerminalNode COLON() { return getToken(QLParser.COLON, 0); }
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public SliceIndexContext(IndexValueExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterSliceIndex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitSliceIndex(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitSliceIndex(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class SingleIndexContext extends IndexValueExprContext {
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public SingleIndexContext(IndexValueExprContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterSingleIndex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitSingleIndex(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitSingleIndex(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexValueExprContext indexValueExpr() throws RecognitionException {
		IndexValueExprContext _localctx = new IndexValueExprContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_indexValueExpr);
		try {
			setState(675);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
			case 1:
				_localctx = new SingleIndexContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(667);
				expression();
				}
				break;
			case 2:
				_localctx = new SliceIndexContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(669);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
				case 1:
					{
					setState(668);
					((SliceIndexContext)_localctx).start = expression();
					}
					break;
				}
				setState(671);
				match(COLON);
				setState(673);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
				case 1:
					{
					setState(672);
					((SliceIndexContext)_localctx).end = expression();
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArgumentListContext extends ParserRuleContext {
		public List expression() {
			return getRuleContexts(ExpressionContext.class);
		}
		public ExpressionContext expression(int i) {
			return getRuleContext(ExpressionContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public ArgumentListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argumentList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterArgumentList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitArgumentList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitArgumentList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArgumentListContext argumentList() throws RecognitionException {
		ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_argumentList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(677);
			expression();
			setState(682);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(678);
				match(COMMA);
				setState(679);
				expression();
				}
				}
				setState(684);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LiteralContext extends ParserRuleContext {
		public TerminalNode IntegerLiteral() { return getToken(QLParser.IntegerLiteral, 0); }
		public TerminalNode FloatingPointLiteral() { return getToken(QLParser.FloatingPointLiteral, 0); }
		public TerminalNode IntegerOrFloatingLiteral() { return getToken(QLParser.IntegerOrFloatingLiteral, 0); }
		public BoolenLiteralContext boolenLiteral() {
			return getRuleContext(BoolenLiteralContext.class,0);
		}
		public TerminalNode QuoteStringLiteral() { return getToken(QLParser.QuoteStringLiteral, 0); }
		public DoubleQuoteStringLiteralContext doubleQuoteStringLiteral() {
			return getRuleContext(DoubleQuoteStringLiteralContext.class,0);
		}
		public TerminalNode NULL() { return getToken(QLParser.NULL, 0); }
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_literal);
		try {
			setState(692);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntegerLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(685);
				match(IntegerLiteral);
				}
				break;
			case FloatingPointLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(686);
				match(FloatingPointLiteral);
				}
				break;
			case IntegerOrFloatingLiteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(687);
				match(IntegerOrFloatingLiteral);
				}
				break;
			case TRUE:
			case FALSE:
				enterOuterAlt(_localctx, 4);
				{
				setState(688);
				boolenLiteral();
				}
				break;
			case QuoteStringLiteral:
				enterOuterAlt(_localctx, 5);
				{
				setState(689);
				match(QuoteStringLiteral);
				}
				break;
			case DOUBLE_QUOTE_OPEN:
				enterOuterAlt(_localctx, 6);
				{
				setState(690);
				doubleQuoteStringLiteral();
				}
				break;
			case NULL:
				enterOuterAlt(_localctx, 7);
				{
				setState(691);
				match(NULL);
				}
				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 DoubleQuoteStringLiteralContext extends ParserRuleContext {
		public TerminalNode DOUBLE_QUOTE_OPEN() { return getToken(QLParser.DOUBLE_QUOTE_OPEN, 0); }
		public TerminalNode DOUBLE_QUOTE_CLOSE() { return getToken(QLParser.DOUBLE_QUOTE_CLOSE, 0); }
		public List DyStrText() { return getTokens(QLParser.DyStrText); }
		public TerminalNode DyStrText(int i) {
			return getToken(QLParser.DyStrText, i);
		}
		public List stringExpression() {
			return getRuleContexts(StringExpressionContext.class);
		}
		public StringExpressionContext stringExpression(int i) {
			return getRuleContext(StringExpressionContext.class,i);
		}
		public DoubleQuoteStringLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_doubleQuoteStringLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterDoubleQuoteStringLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitDoubleQuoteStringLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitDoubleQuoteStringLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DoubleQuoteStringLiteralContext doubleQuoteStringLiteral() throws RecognitionException {
		DoubleQuoteStringLiteralContext _localctx = new DoubleQuoteStringLiteralContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_doubleQuoteStringLiteral);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(694);
			match(DOUBLE_QUOTE_OPEN);
			setState(699);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					setState(697);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
					case 1:
						{
						setState(695);
						match(DyStrText);
						}
						break;
					case 2:
						{
						setState(696);
						stringExpression();
						}
						break;
					}
					} 
				}
				setState(701);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
			}
			setState(702);
			match(DOUBLE_QUOTE_CLOSE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StringExpressionContext extends ParserRuleContext {
		public TerminalNode DyStrExprStart() { return getToken(QLParser.DyStrExprStart, 0); }
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode StrExpr_END() { return getToken(QLParser.StrExpr_END, 0); }
		public TerminalNode SelectorVariable_VANME() { return getToken(QLParser.SelectorVariable_VANME, 0); }
		public TerminalNode RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public StringExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stringExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterStringExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitStringExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitStringExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StringExpressionContext stringExpression() throws RecognitionException {
		StringExpressionContext _localctx = new StringExpressionContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_stringExpression);
		try {
			setState(713);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(704);
				if (!(interpolationMode == SCRIPT)) throw new FailedPredicateException(this, "interpolationMode == SCRIPT");
				setState(705);
				match(DyStrExprStart);
				setState(706);
				expression();
				setState(707);
				match(StrExpr_END);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(709);
				if (!(interpolationMode == VARIABLE)) throw new FailedPredicateException(this, "interpolationMode == VARIABLE");
				setState(710);
				match(DyStrExprStart);
				setState(711);
				match(SelectorVariable_VANME);
				setState(712);
				match(RBRACE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BoolenLiteralContext extends ParserRuleContext {
		public TerminalNode TRUE() { return getToken(QLParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(QLParser.FALSE, 0); }
		public BoolenLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_boolenLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterBoolenLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitBoolenLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitBoolenLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BoolenLiteralContext boolenLiteral() throws RecognitionException {
		BoolenLiteralContext _localctx = new BoolenLiteralContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_boolenLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(715);
			_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();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LambdaParametersContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(QLParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(QLParser.RPAREN, 0); }
		public FormalOrInferredParameterListContext formalOrInferredParameterList() {
			return getRuleContext(FormalOrInferredParameterListContext.class,0);
		}
		public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_lambdaParameters; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterLambdaParameters(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitLambdaParameters(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitLambdaParameters(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LambdaParametersContext lambdaParameters() throws RecognitionException {
		LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_lambdaParameters);
		int _la;
		try {
			setState(723);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(717);
				varId();
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 2);
				{
				setState(718);
				match(LPAREN);
				setState(720);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FUNCTION) | (1L << BYTE) | (1L << SHORT) | (1L << INT) | (1L << LONG) | (1L << FLOAT) | (1L << DOUBLE) | (1L << CHAR) | (1L << BOOL))) != 0) || _la==ID) {
					{
					setState(719);
					formalOrInferredParameterList();
					}
				}

				setState(722);
				match(RPAREN);
				}
				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 FormalOrInferredParameterListContext extends ParserRuleContext {
		public List formalOrInferredParameter() {
			return getRuleContexts(FormalOrInferredParameterContext.class);
		}
		public FormalOrInferredParameterContext formalOrInferredParameter(int i) {
			return getRuleContext(FormalOrInferredParameterContext.class,i);
		}
		public List COMMA() { return getTokens(QLParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(QLParser.COMMA, i);
		}
		public FormalOrInferredParameterListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_formalOrInferredParameterList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterFormalOrInferredParameterList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitFormalOrInferredParameterList(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitFormalOrInferredParameterList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FormalOrInferredParameterListContext formalOrInferredParameterList() throws RecognitionException {
		FormalOrInferredParameterListContext _localctx = new FormalOrInferredParameterListContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_formalOrInferredParameterList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(725);
			formalOrInferredParameter();
			setState(730);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(726);
				match(COMMA);
				setState(727);
				formalOrInferredParameter();
				}
				}
				setState(732);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FormalOrInferredParameterContext extends ParserRuleContext {
		public VarIdContext varId() {
			return getRuleContext(VarIdContext.class,0);
		}
		public DeclTypeContext declType() {
			return getRuleContext(DeclTypeContext.class,0);
		}
		public FormalOrInferredParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_formalOrInferredParameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterFormalOrInferredParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitFormalOrInferredParameter(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitFormalOrInferredParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FormalOrInferredParameterContext formalOrInferredParameter() throws RecognitionException {
		FormalOrInferredParameterContext _localctx = new FormalOrInferredParameterContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_formalOrInferredParameter);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(734);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
			case 1:
				{
				setState(733);
				declType();
				}
				break;
			}
			setState(736);
			varId();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImportDeclarationContext extends ParserRuleContext {
		public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importDeclaration; }
	 
		public ImportDeclarationContext() { }
		public void copyFrom(ImportDeclarationContext ctx) {
			super.copyFrom(ctx);
		}
	}
	public static class ImportClsContext extends ImportDeclarationContext {
		public TerminalNode IMPORT() { return getToken(QLParser.IMPORT, 0); }
		public List varId() {
			return getRuleContexts(VarIdContext.class);
		}
		public VarIdContext varId(int i) {
			return getRuleContext(VarIdContext.class,i);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public List DOT() { return getTokens(QLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(QLParser.DOT, i);
		}
		public ImportClsContext(ImportDeclarationContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterImportCls(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitImportCls(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitImportCls(this);
			else return visitor.visitChildren(this);
		}
	}
	public static class ImportPackContext extends ImportDeclarationContext {
		public TerminalNode IMPORT() { return getToken(QLParser.IMPORT, 0); }
		public List varId() {
			return getRuleContexts(VarIdContext.class);
		}
		public VarIdContext varId(int i) {
			return getRuleContext(VarIdContext.class,i);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 0); }
		public List DOT() { return getTokens(QLParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(QLParser.DOT, i);
		}
		public TerminalNode MUL() { return getToken(QLParser.MUL, 0); }
		public TerminalNode DOTMUL() { return getToken(QLParser.DOTMUL, 0); }
		public ImportPackContext(ImportDeclarationContext ctx) { copyFrom(ctx); }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterImportPack(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitImportPack(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitImportPack(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportDeclarationContext importDeclaration() throws RecognitionException {
		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_importDeclaration);
		int _la;
		try {
			int _alt;
			setState(765);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
			case 1:
				_localctx = new ImportClsContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(738);
				match(IMPORT);
				setState(739);
				varId();
				setState(744);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==DOT) {
					{
					{
					setState(740);
					match(DOT);
					setState(741);
					varId();
					}
					}
					setState(746);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(747);
				match(SEMI);
				}
				break;
			case 2:
				_localctx = new ImportPackContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(749);
				match(IMPORT);
				setState(750);
				varId();
				setState(755);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(751);
						match(DOT);
						setState(752);
						varId();
						}
						} 
					}
					setState(757);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
				}
				setState(761);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case DOT:
					{
					setState(758);
					match(DOT);
					setState(759);
					match(MUL);
					}
					break;
				case DOTMUL:
					{
					setState(760);
					match(DOTMUL);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(763);
				match(SEMI);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AssignOperatorContext extends ParserRuleContext {
		public TerminalNode EQ() { return getToken(QLParser.EQ, 0); }
		public TerminalNode RIGHSHIFT_ASSGIN() { return getToken(QLParser.RIGHSHIFT_ASSGIN, 0); }
		public TerminalNode URSHIFT_ASSGIN() { return getToken(QLParser.URSHIFT_ASSGIN, 0); }
		public TerminalNode LSHIFT_ASSGIN() { return getToken(QLParser.LSHIFT_ASSGIN, 0); }
		public TerminalNode ADD_ASSIGN() { return getToken(QLParser.ADD_ASSIGN, 0); }
		public TerminalNode SUB_ASSIGN() { return getToken(QLParser.SUB_ASSIGN, 0); }
		public TerminalNode AND_ASSIGN() { return getToken(QLParser.AND_ASSIGN, 0); }
		public TerminalNode OR_ASSIGN() { return getToken(QLParser.OR_ASSIGN, 0); }
		public TerminalNode MUL_ASSIGN() { return getToken(QLParser.MUL_ASSIGN, 0); }
		public TerminalNode MOD_ASSIGN() { return getToken(QLParser.MOD_ASSIGN, 0); }
		public TerminalNode DIV_ASSIGN() { return getToken(QLParser.DIV_ASSIGN, 0); }
		public TerminalNode XOR_ASSIGN() { return getToken(QLParser.XOR_ASSIGN, 0); }
		public AssignOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_assignOperator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterAssignOperator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitAssignOperator(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitAssignOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AssignOperatorContext assignOperator() throws RecognitionException {
		AssignOperatorContext _localctx = new AssignOperatorContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_assignOperator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(767);
			_la = _input.LA(1);
			if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (EQ - 51)) | (1L << (RIGHSHIFT_ASSGIN - 51)) | (1L << (URSHIFT_ASSGIN - 51)) | (1L << (LSHIFT_ASSGIN - 51)) | (1L << (ADD_ASSIGN - 51)) | (1L << (SUB_ASSIGN - 51)) | (1L << (AND_ASSIGN - 51)) | (1L << (OR_ASSIGN - 51)) | (1L << (MUL_ASSIGN - 51)) | (1L << (MOD_ASSIGN - 51)) | (1L << (DIV_ASSIGN - 51)) | (1L << (XOR_ASSIGN - 51)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OpIdContext extends ParserRuleContext {
		public TerminalNode GT() { return getToken(QLParser.GT, 0); }
		public TerminalNode LT() { return getToken(QLParser.LT, 0); }
		public TerminalNode GE() { return getToken(QLParser.GE, 0); }
		public TerminalNode LE() { return getToken(QLParser.LE, 0); }
		public TerminalNode BANG() { return getToken(QLParser.BANG, 0); }
		public TerminalNode TILDE() { return getToken(QLParser.TILDE, 0); }
		public TerminalNode ADD() { return getToken(QLParser.ADD, 0); }
		public TerminalNode SUB() { return getToken(QLParser.SUB, 0); }
		public TerminalNode MUL() { return getToken(QLParser.MUL, 0); }
		public TerminalNode DIV() { return getToken(QLParser.DIV, 0); }
		public TerminalNode INC() { return getToken(QLParser.INC, 0); }
		public TerminalNode DEC() { return getToken(QLParser.DEC, 0); }
		public TerminalNode DOTMUL() { return getToken(QLParser.DOTMUL, 0); }
		public TerminalNode NOEQ() { return getToken(QLParser.NOEQ, 0); }
		public TerminalNode RIGHSHIFT() { return getToken(QLParser.RIGHSHIFT, 0); }
		public TerminalNode URSHIFT() { return getToken(QLParser.URSHIFT, 0); }
		public TerminalNode LEFTSHIFT() { return getToken(QLParser.LEFTSHIFT, 0); }
		public TerminalNode BIT_AND() { return getToken(QLParser.BIT_AND, 0); }
		public TerminalNode BIT_OR() { return getToken(QLParser.BIT_OR, 0); }
		public TerminalNode MOD() { return getToken(QLParser.MOD, 0); }
		public TerminalNode CARET() { return getToken(QLParser.CARET, 0); }
		public AssignOperatorContext assignOperator() {
			return getRuleContext(AssignOperatorContext.class,0);
		}
		public TerminalNode OPID() { return getToken(QLParser.OPID, 0); }
		public OpIdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opId; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterOpId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitOpId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitOpId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpIdContext opId() throws RecognitionException {
		OpIdContext _localctx = new OpIdContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_opId);
		try {
			setState(792);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case GT:
				enterOuterAlt(_localctx, 1);
				{
				setState(769);
				match(GT);
				}
				break;
			case LT:
				enterOuterAlt(_localctx, 2);
				{
				setState(770);
				match(LT);
				}
				break;
			case GE:
				enterOuterAlt(_localctx, 3);
				{
				setState(771);
				match(GE);
				}
				break;
			case LE:
				enterOuterAlt(_localctx, 4);
				{
				setState(772);
				match(LE);
				}
				break;
			case BANG:
				enterOuterAlt(_localctx, 5);
				{
				setState(773);
				match(BANG);
				}
				break;
			case TILDE:
				enterOuterAlt(_localctx, 6);
				{
				setState(774);
				match(TILDE);
				}
				break;
			case ADD:
				enterOuterAlt(_localctx, 7);
				{
				setState(775);
				match(ADD);
				}
				break;
			case SUB:
				enterOuterAlt(_localctx, 8);
				{
				setState(776);
				match(SUB);
				}
				break;
			case MUL:
				enterOuterAlt(_localctx, 9);
				{
				setState(777);
				match(MUL);
				}
				break;
			case DIV:
				enterOuterAlt(_localctx, 10);
				{
				setState(778);
				match(DIV);
				}
				break;
			case INC:
				enterOuterAlt(_localctx, 11);
				{
				setState(779);
				match(INC);
				}
				break;
			case DEC:
				enterOuterAlt(_localctx, 12);
				{
				setState(780);
				match(DEC);
				}
				break;
			case DOTMUL:
				enterOuterAlt(_localctx, 13);
				{
				setState(781);
				match(DOTMUL);
				}
				break;
			case NOEQ:
				enterOuterAlt(_localctx, 14);
				{
				setState(782);
				match(NOEQ);
				}
				break;
			case RIGHSHIFT:
				enterOuterAlt(_localctx, 15);
				{
				setState(783);
				match(RIGHSHIFT);
				}
				break;
			case URSHIFT:
				enterOuterAlt(_localctx, 16);
				{
				setState(784);
				match(URSHIFT);
				}
				break;
			case LEFTSHIFT:
				enterOuterAlt(_localctx, 17);
				{
				setState(785);
				match(LEFTSHIFT);
				}
				break;
			case BIT_AND:
				enterOuterAlt(_localctx, 18);
				{
				setState(786);
				match(BIT_AND);
				}
				break;
			case BIT_OR:
				enterOuterAlt(_localctx, 19);
				{
				setState(787);
				match(BIT_OR);
				}
				break;
			case MOD:
				enterOuterAlt(_localctx, 20);
				{
				setState(788);
				match(MOD);
				}
				break;
			case CARET:
				enterOuterAlt(_localctx, 21);
				{
				setState(789);
				match(CARET);
				}
				break;
			case EQ:
			case RIGHSHIFT_ASSGIN:
			case URSHIFT_ASSGIN:
			case LSHIFT_ASSGIN:
			case ADD_ASSIGN:
			case SUB_ASSIGN:
			case AND_ASSIGN:
			case OR_ASSIGN:
			case MUL_ASSIGN:
			case MOD_ASSIGN:
			case DIV_ASSIGN:
			case XOR_ASSIGN:
				enterOuterAlt(_localctx, 22);
				{
				setState(790);
				assignOperator();
				}
				break;
			case OPID:
				enterOuterAlt(_localctx, 23);
				{
				setState(791);
				match(OPID);
				}
				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 VarIdContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(QLParser.ID, 0); }
		public TerminalNode FUNCTION() { return getToken(QLParser.FUNCTION, 0); }
		public VarIdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_varId; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).enterVarId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof QLParserListener ) ((QLParserListener)listener).exitVarId(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof QLParserVisitor ) return ((QLParserVisitor)visitor).visitVarId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VarIdContext varId() throws RecognitionException {
		VarIdContext _localctx = new VarIdContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_varId);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(794);
			_la = _input.LA(1);
			if ( !(_la==FUNCTION || _la==ID) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 26:
			return baseExpr_sempred((BaseExprContext)_localctx, predIndex);
		case 30:
			return prefixExpress_sempred((PrefixExpressContext)_localctx, predIndex);
		case 31:
			return suffixExpress_sempred((SuffixExpressContext)_localctx, predIndex);
		case 42:
			return mapValue_sempred((MapValueContext)_localctx, predIndex);
		case 45:
			return pathPart_sempred((PathPartContext)_localctx, predIndex);
		case 51:
			return stringExpression_sempred((StringExpressionContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean baseExpr_sempred(BaseExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return _input.LT(1).getType() != Token.EOF &&
		        opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) >= _localctx.p;
		}
		return true;
	}
	private boolean prefixExpress_sempred(PrefixExpressContext _localctx, int predIndex) {
		switch (predIndex) {
		case 1:
			return _input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), PREFIX);
		}
		return true;
	}
	private boolean suffixExpress_sempred(SuffixExpressContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return _input.LT(1).getType() != Token.EOF && opM.isOpType(_input.LT(1).getText(), SUFFIX);
		}
		return true;
	}
	private boolean mapValue_sempred(MapValueContext _localctx, int predIndex) {
		switch (predIndex) {
		case 3:
			return _input.LT(-2).getText().equals("'@class'");
		}
		return true;
	}
	private boolean pathPart_sempred(PathPartContext _localctx, int predIndex) {
		switch (predIndex) {
		case 4:
			return opM.isOpType(_input.LT(1).getText(), MIDDLE) && opM.precedence(_input.LT(1).getText()) == GROUP;
		}
		return true;
	}
	private boolean stringExpression_sempred(StringExpressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 5:
			return interpolationMode == SCRIPT;
		case 6:
			return interpolationMode == VARIABLE;
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3c\u031f\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\3\2\7\2|\n\2\f\2\16\2\177\13\2\3\2\5\2\u0082\n\2\3\2\3\2\3\3\6\3\u0087"+
		"\n\3\r\3\16\3\u0088\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
		"\4\3\4\3\4\3\4\3\4\5\4\u009c\n\4\3\4\3\4\5\4\u00a0\n\4\3\4\3\4\3\4\3\4"+
		"\3\4\3\4\5\4\u00a8\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00b4"+
		"\n\4\3\4\3\4\3\4\5\4\u00b9\n\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00c1\n\4\3"+
		"\4\3\4\3\4\3\4\3\4\3\4\5\4\u00c9\n\4\3\4\3\4\3\4\3\4\5\4\u00cf\n\4\5\4"+
		"\u00d1\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00dd\n\6\3\7\3"+
		"\7\3\7\7\7\u00e2\n\7\f\7\16\7\u00e5\13\7\3\b\3\b\3\b\5\b\u00ea\n\b\3\t"+
		"\3\t\5\t\u00ee\n\t\3\n\3\n\5\n\u00f2\n\n\3\13\3\13\5\13\u00f6\n\13\3\13"+
		"\5\13\u00f9\n\13\3\13\3\13\3\f\3\f\3\f\7\f\u0100\n\f\f\f\16\f\u0103\13"+
		"\f\3\r\3\r\5\r\u0107\n\r\3\r\3\r\5\r\u010b\n\r\5\r\u010d\n\r\3\16\3\16"+
		"\5\16\u0111\n\16\3\17\3\17\3\20\3\20\5\20\u0117\n\20\3\20\3\20\3\20\5"+
		"\20\u011c\n\20\3\21\3\21\3\21\3\21\7\21\u0122\n\21\f\21\16\21\u0125\13"+
		"\21\3\22\3\22\3\22\7\22\u012a\n\22\f\22\16\22\u012d\13\22\3\23\3\23\3"+
		"\23\7\23\u0132\n\23\f\23\16\23\u0135\13\23\3\23\5\23\u0138\n\23\3\24\3"+
		"\24\5\24\u013c\n\24\3\24\5\24\u013f\n\24\3\24\5\24\u0142\n\24\3\25\3\25"+
		"\3\25\7\25\u0147\n\25\f\25\16\25\u014a\13\25\3\26\3\26\5\26\u014e\n\26"+
		"\3\27\3\27\5\27\u0152\n\27\3\30\3\30\3\30\3\30\5\30\u0158\n\30\3\31\3"+
		"\31\3\31\3\31\3\31\5\31\u015f\n\31\3\32\3\32\7\32\u0163\n\32\f\32\16\32"+
		"\u0166\13\32\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u016e\n\33\3\34\3\34\3"+
		"\34\7\34\u0173\n\34\f\34\16\34\u0176\13\34\3\35\3\35\3\35\3\36\3\36\5"+
		"\36\u017d\n\36\3\37\5\37\u0180\n\37\3\37\3\37\7\37\u0184\n\37\f\37\16"+
		"\37\u0187\13\37\3\37\5\37\u018a\n\37\3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3\""+
		"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u01a0\n\"\f\"\16\"\u01a3"+
		"\13\"\3\"\5\"\u01a6\n\"\3\"\3\"\5\"\u01aa\n\"\3\"\3\"\3\"\3\"\3\"\3\""+
		"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u01bb\n\"\3\"\3\"\5\"\u01bf\n"+
		"\"\3\"\3\"\3\"\3\"\5\"\u01c5\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u01ce"+
		"\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u01d8\n\"\3\"\3\"\3\"\5\"\u01dd"+
		"\n\"\3\"\3\"\5\"\u01e1\n\"\3\"\5\"\u01e4\n\"\3\"\3\"\3\"\5\"\u01e9\n\""+
		"\3#\3#\5#\u01ed\n#\3#\3#\5#\u01f1\n#\3$\3$\3$\7$\u01f6\n$\f$\16$\u01f9"+
		"\13$\3%\3%\3%\3%\3%\3%\3%\7%\u0202\n%\f%\16%\u0205\13%\3&\3&\7&\u0209"+
		"\n&\f&\16&\u020c\13&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0214\n\'\3\'\3\'\3("+
		"\3(\3(\7(\u021b\n(\f(\16(\u021e\13(\5(\u0220\n(\3(\3(\3)\3)\3)\5)\u0227"+
		"\n)\3)\3)\3*\3*\3*\3*\7*\u022f\n*\f*\16*\u0232\13*\3*\5*\u0235\n*\5*\u0237"+
		"\n*\3+\3+\3+\3+\3,\3,\3,\5,\u0240\n,\3-\3-\3-\5-\u0245\n-\3.\3.\3.\3."+
		"\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+
		"\3.\3.\3.\3.\3.\5.\u0267\n.\3/\3/\3/\3/\5/\u026d\n/\3/\3/\3/\3/\3/\3/"+
		"\5/\u0275\n/\3/\3/\3/\3/\3/\3/\5/\u027d\n/\3/\3/\3/\3/\3/\3/\3/\3/\3/"+
		"\3/\3/\3/\5/\u028b\n/\3/\3/\3/\5/\u0290\n/\3/\3/\3/\3/\3/\5/\u0297\n/"+
		"\3\60\3\60\3\60\5\60\u029c\n\60\3\61\3\61\5\61\u02a0\n\61\3\61\3\61\5"+
		"\61\u02a4\n\61\5\61\u02a6\n\61\3\62\3\62\3\62\7\62\u02ab\n\62\f\62\16"+
		"\62\u02ae\13\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02b7\n\63\3\64"+
		"\3\64\3\64\7\64\u02bc\n\64\f\64\16\64\u02bf\13\64\3\64\3\64\3\65\3\65"+
		"\3\65\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u02cc\n\65\3\66\3\66\3\67\3\67"+
		"\3\67\5\67\u02d3\n\67\3\67\5\67\u02d6\n\67\38\38\38\78\u02db\n8\f8\16"+
		"8\u02de\138\39\59\u02e1\n9\39\39\3:\3:\3:\3:\7:\u02e9\n:\f:\16:\u02ec"+
		"\13:\3:\3:\3:\3:\3:\3:\7:\u02f4\n:\f:\16:\u02f7\13:\3:\3:\3:\5:\u02fc"+
		"\n:\3:\3:\5:\u0300\n:\3;\3;\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<\3<"+
		"\3<\3<\3<\3<\3<\3<\3<\3<\3<\5<\u031b\n<\3=\3=\3=\2\2>\2\4\6\b\n\f\16\20"+
		"\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhj"+
		"lnprtvx\2\b\3\2\7\b\3\2\17\26\5\2\63\6388<<\3\2\30\31\7\2\65\65\67\67"+
		";;==CJ\4\2\n\nZZ\2\u039b\2}\3\2\2\2\4\u0086\3\2\2\2\6\u00d0\3\2\2\2\b"+
		"\u00d2\3\2\2\2\n\u00dc\3\2\2\2\f\u00de\3\2\2\2\16\u00e6\3\2\2\2\20\u00eb"+
		"\3\2\2\2\22\u00f1\3\2\2\2\24\u00f3\3\2\2\2\26\u00fc\3\2\2\2\30\u010c\3"+
		"\2\2\2\32\u0110\3\2\2\2\34\u0112\3\2\2\2\36\u011b\3\2\2\2 \u011d\3\2\2"+
		"\2\"\u0126\3\2\2\2$\u012e\3\2\2\2&\u0141\3\2\2\2(\u0143\3\2\2\2*\u014d"+
		"\3\2\2\2,\u014f\3\2\2\2.\u0157\3\2\2\2\60\u015e\3\2\2\2\62\u0160\3\2\2"+
		"\2\64\u0167\3\2\2\2\66\u016f\3\2\2\28\u0177\3\2\2\2:\u017c\3\2\2\2<\u017f"+
		"\3\2\2\2>\u018b\3\2\2\2@\u018e\3\2\2\2B\u01e8\3\2\2\2D\u01f0\3\2\2\2F"+
		"\u01f2\3\2\2\2H\u01fa\3\2\2\2J\u0206\3\2\2\2L\u020d\3\2\2\2N\u021f\3\2"+
		"\2\2P\u0223\3\2\2\2R\u0236\3\2\2\2T\u0238\3\2\2\2V\u023f\3\2\2\2X\u0244"+
		"\3\2\2\2Z\u0266\3\2\2\2\\\u0296\3\2\2\2^\u029b\3\2\2\2`\u02a5\3\2\2\2"+
		"b\u02a7\3\2\2\2d\u02b6\3\2\2\2f\u02b8\3\2\2\2h\u02cb\3\2\2\2j\u02cd\3"+
		"\2\2\2l\u02d5\3\2\2\2n\u02d7\3\2\2\2p\u02e0\3\2\2\2r\u02ff\3\2\2\2t\u0301"+
		"\3\2\2\2v\u031a\3\2\2\2x\u031c\3\2\2\2z|\5r:\2{z\3\2\2\2|\177\3\2\2\2"+
		"}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080\u0082\5\4\3\2\u0081"+
		"\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0084\7\2"+
		"\2\3\u0084\3\3\2\2\2\u0085\u0087\5\6\4\2\u0086\u0085\3\2\2\2\u0087\u0088"+
		"\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\5\3\2\2\2\u008a"+
		"\u008b\5\b\5\2\u008b\u008c\7.\2\2\u008c\u00d1\3\2\2\2\u008d\u008e\7\37"+
		"\2\2\u008e\u008f\5\60\31\2\u008f\u0090\7.\2\2\u0090\u00d1\3\2\2\2\u0091"+
		"\u0092\7\6\2\2\u0092\u0093\7&\2\2\u0093\u0094\5\60\31\2\u0094\u0095\7"+
		"\'\2\2\u0095\u0096\5\6\4\2\u0096\u00d1\3\2\2\2\u0097\u0098\7\3\2\2\u0098"+
		"\u0099\7&\2\2\u0099\u009b\5\n\6\2\u009a\u009c\5\60\31\2\u009b\u009a\3"+
		"\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009f\7.\2\2\u009e"+
		"\u00a0\5\60\31\2\u009f\u009e\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a1\3"+
		"\2\2\2\u00a1\u00a2\7\'\2\2\u00a2\u00a3\5\6\4\2\u00a3\u00d1\3\2\2\2\u00a4"+
		"\u00a5\7\3\2\2\u00a5\u00a7\7&\2\2\u00a6\u00a8\5\30\r\2\u00a7\u00a6\3\2"+
		"\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\5x=\2\u00aa\u00ab"+
		"\7\61\2\2\u00ab\u00ac\5\60\31\2\u00ac\u00ad\7\'\2\2\u00ad\u00ae\5\6\4"+
		"\2\u00ae\u00d1\3\2\2\2\u00af\u00b0\7\n\2\2\u00b0\u00b1\5x=\2\u00b1\u00b3"+
		"\7&\2\2\u00b2\u00b4\5n8\2\u00b3\u00b2\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4"+
		"\u00b5\3\2\2\2\u00b5\u00b6\7\'\2\2\u00b6\u00b8\7(\2\2\u00b7\u00b9\5\4"+
		"\3\2\u00b8\u00b7\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba"+
		"\u00bb\7)\2\2\u00bb\u00d1\3\2\2\2\u00bc\u00bd\7\13\2\2\u00bd\u00be\5x"+
		"=\2\u00be\u00c0\7(\2\2\u00bf\u00c1\5\4\3\2\u00c0\u00bf\3\2\2\2\u00c0\u00c1"+
		"\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c3\7)\2\2\u00c3\u00d1\3\2\2\2\u00c4"+
		"\u00c5\t\2\2\2\u00c5\u00d1\7.\2\2\u00c6\u00c8\7\t\2\2\u00c7\u00c9\5\60"+
		"\31\2\u00c8\u00c7\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca"+
		"\u00d1\7.\2\2\u00cb\u00d1\7.\2\2\u00cc\u00ce\5\60\31\2\u00cd\u00cf\7."+
		"\2\2\u00ce\u00cd\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d1\3\2\2\2\u00d0"+
		"\u008a\3\2\2\2\u00d0\u008d\3\2\2\2\u00d0\u0091\3\2\2\2\u00d0\u0097\3\2"+
		"\2\2\u00d0\u00a4\3\2\2\2\u00d0\u00af\3\2\2\2\u00d0\u00bc\3\2\2\2\u00d0"+
		"\u00c4\3\2\2\2\u00d0\u00c6\3\2\2\2\u00d0\u00cb\3\2\2\2\u00d0\u00cc\3\2"+
		"\2\2\u00d1\7\3\2\2\2\u00d2\u00d3\5\30\r\2\u00d3\u00d4\5\f\7\2\u00d4\t"+
		"\3\2\2\2\u00d5\u00d6\5\b\5\2\u00d6\u00d7\7.\2\2\u00d7\u00dd\3\2\2\2\u00d8"+
		"\u00d9\5\60\31\2\u00d9\u00da\7.\2\2\u00da\u00dd\3\2\2\2\u00db\u00dd\7"+
		".\2\2\u00dc\u00d5\3\2\2\2\u00dc\u00d8\3\2\2\2\u00dc\u00db\3\2\2\2\u00dd"+
		"\13\3\2\2\2\u00de\u00e3\5\16\b\2\u00df\u00e0\7/\2\2\u00e0\u00e2\5\16\b"+
		"\2\u00e1\u00df\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3\u00e4"+
		"\3\2\2\2\u00e4\r\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00e9\5\20\t\2\u00e7"+
		"\u00e8\7\65\2\2\u00e8\u00ea\5\22\n\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3"+
		"\2\2\2\u00ea\17\3\2\2\2\u00eb\u00ed\5x=\2\u00ec\u00ee\5 \21\2\u00ed\u00ec"+
		"\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\21\3\2\2\2\u00ef\u00f2\5\60\31\2\u00f0"+
		"\u00f2\5\24\13\2\u00f1\u00ef\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\23\3\2"+
		"\2\2\u00f3\u00f5\7(\2\2\u00f4\u00f6\5\26\f\2\u00f5\u00f4\3\2\2\2\u00f5"+
		"\u00f6\3\2\2\2\u00f6\u00f8\3\2\2\2\u00f7\u00f9\7/\2\2\u00f8\u00f7\3\2"+
		"\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\7)\2\2\u00fb"+
		"\25\3\2\2\2\u00fc\u0101\5\22\n\2\u00fd\u00fe\7/\2\2\u00fe\u0100\5\22\n"+
		"\2\u00ff\u00fd\3\2\2\2\u0100\u0103\3\2\2\2\u0101\u00ff\3\2\2\2\u0101\u0102"+
		"\3\2\2\2\u0102\27\3\2\2\2\u0103\u0101\3\2\2\2\u0104\u0106\5\34\17\2\u0105"+
		"\u0107\5 \21\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u010d\3\2"+
		"\2\2\u0108\u010a\5$\23\2\u0109\u010b\5 \21\2\u010a\u0109\3\2\2\2\u010a"+
		"\u010b\3\2\2\2\u010b\u010d\3\2\2\2\u010c\u0104\3\2\2\2\u010c\u0108\3\2"+
		"\2\2\u010d\31\3\2\2\2\u010e\u0111\5\34\17\2\u010f\u0111\5$\23\2\u0110"+
		"\u010e\3\2\2\2\u0110\u010f\3\2\2\2\u0111\33\3\2\2\2\u0112\u0113\t\3\2"+
		"\2\u0113\35\3\2\2\2\u0114\u0116\5$\23\2\u0115\u0117\5 \21\2\u0116\u0115"+
		"\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u011c\3\2\2\2\u0118\u0119\5\34\17\2"+
		"\u0119\u011a\5 \21\2\u011a\u011c\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0118"+
		"\3\2\2\2\u011c\37\3\2\2\2\u011d\u011e\7*\2\2\u011e\u0123\7+\2\2\u011f"+
		"\u0120\7*\2\2\u0120\u0122\7+\2\2\u0121\u011f\3\2\2\2\u0122\u0125\3\2\2"+
		"\2\u0123\u0121\3\2\2\2\u0123\u0124\3\2\2\2\u0124!\3\2\2\2\u0125\u0123"+
		"\3\2\2\2\u0126\u012b\5x=\2\u0127\u0128\7,\2\2\u0128\u012a\5x=\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#\3\2\2\2\u012d\u012b\3\2\2\2\u012e\u0133\5x=\2\u012f\u0130"+
		"\7,\2\2\u0130\u0132\5x=\2\u0131\u012f\3\2\2\2\u0132\u0135\3\2\2\2\u0133"+
		"\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0137\3\2\2\2\u0135\u0133\3\2"+
		"\2\2\u0136\u0138\5&\24\2\u0137\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138"+
		"%\3\2\2\2\u0139\u013b\7\64\2\2\u013a\u013c\5(\25\2\u013b\u013a\3\2\2\2"+
		"\u013b\u013c\3\2\2\2\u013c\u013e\3\2\2\2\u013d\u013f\t\4\2\2\u013e\u013d"+
		"\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0142\3\2\2\2\u0140\u0142\7\66\2\2"+
		"\u0141\u0139\3\2\2\2\u0141\u0140\3\2\2\2\u0142\'\3\2\2\2\u0143\u0148\5"+
		"*\26\2\u0144\u0145\7/\2\2\u0145\u0147\5*\26\2\u0146\u0144\3\2\2\2\u0147"+
		"\u014a\3\2\2\2\u0148\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149)\3\2\2\2"+
		"\u014a\u0148\3\2\2\2\u014b\u014e\5\36\20\2\u014c\u014e\5,\27\2\u014d\u014b"+
		"\3\2\2\2\u014d\u014c\3\2\2\2\u014e+\3\2\2\2\u014f\u0151\7\60\2\2\u0150"+
		"\u0152\5.\30\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2\u0152-\3\2\2\2"+
		"\u0153\u0154\7\32\2\2\u0154\u0158\5\36\20\2\u0155\u0156\7\33\2\2\u0156"+
		"\u0158\5\36\20\2\u0157\u0153\3\2\2\2\u0157\u0155\3\2\2\2\u0158/\3\2\2"+
		"\2\u0159\u015a\5\62\32\2\u015a\u015b\5t;\2\u015b\u015c\5\60\31\2\u015c"+
		"\u015f\3\2\2\2\u015d\u015f\5\64\33\2\u015e\u0159\3\2\2\2\u015e\u015d\3"+
		"\2\2\2\u015f\61\3\2\2\2\u0160\u0164\5x=\2\u0161\u0163\5\\/\2\u0162\u0161"+
		"\3\2\2\2\u0163\u0166\3\2\2\2\u0164\u0162\3\2\2\2\u0164\u0165\3\2\2\2\u0165"+
		"\63\3\2\2\2\u0166\u0164\3\2\2\2\u0167\u016d\5\66\34\2\u0168\u0169\7\60"+
		"\2\2\u0169\u016a\5\66\34\2\u016a\u016b\7\61\2\2\u016b\u016c\5\60\31\2"+
		"\u016c\u016e\3\2\2\2\u016d\u0168\3\2\2\2\u016d\u016e\3\2\2\2\u016e\65"+
		"\3\2\2\2\u016f\u0174\5<\37\2\u0170\u0171\6\34\2\3\u0171\u0173\58\35\2"+
		"\u0172\u0170\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2\2\2\u0174\u0175"+
		"\3\2\2\2\u0175\67\3\2\2\2\u0176\u0174\3\2\2\2\u0177\u0178\5:\36\2\u0178"+
		"\u0179\5\66\34\2\u01799\3\2\2\2\u017a\u017d\5v<\2\u017b\u017d\5x=\2\u017c"+
		"\u017a\3\2\2\2\u017c\u017b\3\2\2\2\u017d;\3\2\2\2\u017e\u0180\5> \2\u017f"+
		"\u017e\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\3\2\2\2\u0181\u0185\5B"+
		"\"\2\u0182\u0184\5\\/\2\u0183\u0182\3\2\2\2\u0184\u0187\3\2\2\2\u0185"+
		"\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0189\3\2\2\2\u0187\u0185\3\2"+
		"\2\2\u0188\u018a\5@!\2\u0189\u0188\3\2\2\2\u0189\u018a\3\2\2\2\u018a="+
		"\3\2\2\2\u018b\u018c\6 \3\2\u018c\u018d\5v<\2\u018d?\3\2\2\2\u018e\u018f"+
		"\6!\4\2\u018f\u0190\5v<\2\u0190A\3\2\2\2\u0191\u01e9\5d\63\2\u0192\u0193"+
		"\7&\2\2\u0193\u0194\5\30\r\2\u0194\u0195\7\'\2\2\u0195\u0196\5<\37\2\u0196"+
		"\u01e9\3\2\2\2\u0197\u0198\7&\2\2\u0198\u0199\5\60\31\2\u0199\u019a\7"+
		"\'\2\2\u019a\u01e9\3\2\2\2\u019b\u019c\7\16\2\2\u019c\u01a1\5x=\2\u019d"+
		"\u019e\7,\2\2\u019e\u01a0\5x=\2\u019f\u019d\3\2\2\2\u01a0\u01a3\3\2\2"+
		"\2\u01a1\u019f\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a5\3\2\2\2\u01a3\u01a1"+
		"\3\2\2\2\u01a4\u01a6\5&\24\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6"+
		"\u01a7\3\2\2\2\u01a7\u01a9\7&\2\2\u01a8\u01aa\5b\62\2\u01a9\u01a8\3\2"+
		"\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7\'\2\2\u01ac"+
		"\u01e9\3\2\2\2\u01ad\u01ae\7\16\2\2\u01ae\u01af\5\32\16\2\u01af\u01b0"+
		"\5H%\2\u01b0\u01e9\3\2\2\2\u01b1\u01b2\7\16\2\2\u01b2\u01b3\5\32\16\2"+
		"\u01b3\u01b4\5 \21\2\u01b4\u01b5\5\24\13\2\u01b5\u01e9\3\2\2\2\u01b6\u01b7"+
		"\5l\67\2\u01b7\u01be\7-\2\2\u01b8\u01ba\7(\2\2\u01b9\u01bb\5\4\3\2\u01ba"+
		"\u01b9\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bf\7)"+
		"\2\2\u01bd\u01bf\5\60\31\2\u01be\u01b8\3\2\2\2\u01be\u01bd\3\2\2\2\u01bf"+
		"\u01e9\3\2\2\2\u01c0\u01e9\5x=\2\u01c1\u01e9\5\34\17\2\u01c2\u01c4\7*"+
		"\2\2\u01c3\u01c5\5F$\2\u01c4\u01c3\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c6"+
		"\3\2\2\2\u01c6\u01e9\7+\2\2\u01c7\u01c8\7(\2\2\u01c8\u01c9\5R*\2\u01c9"+
		"\u01ca\7)\2\2\u01ca\u01e9\3\2\2\2\u01cb\u01cd\7(\2\2\u01cc\u01ce\5\4\3"+
		"\2\u01cd\u01cc\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01e9"+
		"\7)\2\2\u01d0\u01d1\7\4\2\2\u01d1\u01d2\7&\2\2\u01d2\u01d3\5\60\31\2\u01d3"+
		"\u01d4\7\'\2\2\u01d4\u01d7\5D#\2\u01d5\u01d6\7\5\2\2\u01d6\u01d8\5D#\2"+
		"\u01d7\u01d5\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8\u01e9\3\2\2\2\u01d9\u01da"+
		"\7\34\2\2\u01da\u01dc\7(\2\2\u01db\u01dd\5\4\3\2\u01dc\u01db\3\2\2\2\u01dc"+
		"\u01dd\3\2\2\2\u01dd\u01de\3\2\2\2\u01de\u01e0\7)\2\2\u01df\u01e1\5J&"+
		"\2\u01e0\u01df\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e3\3\2\2\2\u01e2\u01e4"+
		"\5P)\2\u01e3\u01e2\3\2\2\2\u01e3\u01e4\3\2\2\2\u01e4\u01e9\3\2\2\2\u01e5"+
		"\u01e6\7\\\2\2\u01e6\u01e7\7a\2\2\u01e7\u01e9\7)\2\2\u01e8\u0191\3\2\2"+
		"\2\u01e8\u0192\3\2\2\2\u01e8\u0197\3\2\2\2\u01e8\u019b\3\2\2\2\u01e8\u01ad"+
		"\3\2\2\2\u01e8\u01b1\3\2\2\2\u01e8\u01b6\3\2\2\2\u01e8\u01c0\3\2\2\2\u01e8"+
		"\u01c1\3\2\2\2\u01e8\u01c2\3\2\2\2\u01e8\u01c7\3\2\2\2\u01e8\u01cb\3\2"+
		"\2\2\u01e8\u01d0\3\2\2\2\u01e8\u01d9\3\2\2\2\u01e8\u01e5\3\2\2\2\u01e9"+
		"C\3\2\2\2\u01ea\u01ec\7(\2\2\u01eb\u01ed\5\4\3\2\u01ec\u01eb\3\2\2\2\u01ec"+
		"\u01ed\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01f1\7)\2\2\u01ef\u01f1\5\6"+
		"\4\2\u01f0\u01ea\3\2\2\2\u01f0\u01ef\3\2\2\2\u01f1E\3\2\2\2\u01f2\u01f7"+
		"\5\60\31\2\u01f3\u01f4\7/\2\2\u01f4\u01f6\5\60\31\2\u01f5\u01f3\3\2\2"+
		"\2\u01f6\u01f9\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8G"+
		"\3\2\2\2\u01f9\u01f7\3\2\2\2\u01fa\u01fb\7*\2\2\u01fb\u01fc\5\60\31\2"+
		"\u01fc\u0203\7+\2\2\u01fd\u01fe\7*\2\2\u01fe\u01ff\5\60\31\2\u01ff\u0200"+
		"\7+\2\2\u0200\u0202\3\2\2\2\u0201\u01fd\3\2\2\2\u0202\u0205\3\2\2\2\u0203"+
		"\u0201\3\2\2\2\u0203\u0204\3\2\2\2\u0204I\3\2\2\2\u0205\u0203\3\2\2\2"+
		"\u0206\u020a\5L\'\2\u0207\u0209\5L\'\2\u0208\u0207\3\2\2\2\u0209\u020c"+
		"\3\2\2\2\u020a\u0208\3\2\2\2\u020a\u020b\3\2\2\2\u020bK\3\2\2\2\u020c"+
		"\u020a\3\2\2\2\u020d\u020e\7\35\2\2\u020e\u020f\7&\2\2\u020f\u0210\5N"+
		"(\2\u0210\u0211\7\'\2\2\u0211\u0213\7(\2\2\u0212\u0214\5\4\3\2\u0213\u0212"+
		"\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0216\7)\2\2\u0216"+
		"M\3\2\2\2\u0217\u021c\5\30\r\2\u0218\u0219\7R\2\2\u0219\u021b\5\30\r\2"+
		"\u021a\u0218\3\2\2\2\u021b\u021e\3\2\2\2\u021c\u021a\3\2\2\2\u021c\u021d"+
		"\3\2\2\2\u021d\u0220\3\2\2\2\u021e\u021c\3\2\2\2\u021f\u0217\3\2\2\2\u021f"+
		"\u0220\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\5x=\2\u0222O\3\2\2\2\u0223"+
		"\u0224\7\36\2\2\u0224\u0226\7(\2\2\u0225\u0227\5\4\3\2\u0226\u0225\3\2"+
		"\2\2\u0226\u0227\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0229\7)\2\2\u0229"+
		"Q\3\2\2\2\u022a\u0237\7\61\2\2\u022b\u0230\5T+\2\u022c\u022d\7/\2\2\u022d"+
		"\u022f\5T+\2\u022e\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3\2\2"+
		"\2\u0230\u0231\3\2\2\2\u0231\u0234\3\2\2\2\u0232\u0230\3\2\2\2\u0233\u0235"+
		"\7/\2\2\u0234\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0237\3\2\2\2\u0236"+
		"\u022a\3\2\2\2\u0236\u022b\3\2\2\2\u0237S\3\2\2\2\u0238\u0239\5X-\2\u0239"+
		"\u023a\7\61\2\2\u023a\u023b\5V,\2\u023bU\3\2\2\2\u023c\u023d\6,\5\2\u023d"+
		"\u0240\7\"\2\2\u023e\u0240\5\60\31\2\u023f\u023c\3\2\2\2\u023f\u023e\3"+
		"\2\2\2\u0240W\3\2\2\2\u0241\u0245\5Z.\2\u0242\u0245\5f\64\2\u0243\u0245"+
		"\7\"\2\2\u0244\u0241\3\2\2\2\u0244\u0242\3\2\2\2\u0244\u0243\3\2\2\2\u0245"+
		"Y\3\2\2\2\u0246\u0267\5x=\2\u0247\u0267\7\3\2\2\u0248\u0267\7\4\2\2\u0249"+
		"\u0267\7\5\2\2\u024a\u0267\7\6\2\2\u024b\u0267\7\7\2\2\u024c\u0267\7\b"+
		"\2\2\u024d\u0267\7\t\2\2\u024e\u0267\7\n\2\2\u024f\u0267\7\13\2\2\u0250"+
		"\u0267\7\f\2\2\u0251\u0267\7\r\2\2\u0252\u0267\7\16\2\2\u0253\u0267\7"+
		"\17\2\2\u0254\u0267\7\20\2\2\u0255\u0267\7\21\2\2\u0256\u0267\7\22\2\2"+
		"\u0257\u0267\7\23\2\2\u0258\u0267\7\24\2\2\u0259\u0267\7\25\2\2\u025a"+
		"\u0267\7\26\2\2\u025b\u0267\7\27\2\2\u025c\u0267\7\30\2\2\u025d\u0267"+
		"\7\31\2\2\u025e\u0267\7\32\2\2\u025f\u0267\7\33\2\2\u0260\u0267\7\34\2"+
		"\2\u0261\u0267\7\35\2\2\u0262\u0267\7\36\2\2\u0263\u0267\7\37\2\2\u0264"+
		"\u0267\7 \2\2\u0265\u0267\7!\2\2\u0266\u0246\3\2\2\2\u0266\u0247\3\2\2"+
		"\2\u0266\u0248\3\2\2\2\u0266\u0249\3\2\2\2\u0266\u024a\3\2\2\2\u0266\u024b"+
		"\3\2\2\2\u0266\u024c\3\2\2\2\u0266\u024d\3\2\2\2\u0266\u024e\3\2\2\2\u0266"+
		"\u024f\3\2\2\2\u0266\u0250\3\2\2\2\u0266\u0251\3\2\2\2\u0266\u0252\3\2"+
		"\2\2\u0266\u0253\3\2\2\2\u0266\u0254\3\2\2\2\u0266\u0255\3\2\2\2\u0266"+
		"\u0256\3\2\2\2\u0266\u0257\3\2\2\2\u0266\u0258\3\2\2\2\u0266\u0259\3\2"+
		"\2\2\u0266\u025a\3\2\2\2\u0266\u025b\3\2\2\2\u0266\u025c\3\2\2\2\u0266"+
		"\u025d\3\2\2\2\u0266\u025e\3\2\2\2\u0266\u025f\3\2\2\2\u0266\u0260\3\2"+
		"\2\2\u0266\u0261\3\2\2\2\u0266\u0262\3\2\2\2\u0266\u0263\3\2\2\2\u0266"+
		"\u0264\3\2\2\2\u0266\u0265\3\2\2\2\u0267[\3\2\2\2\u0268\u0269\7,\2\2\u0269"+
		"\u026a\5x=\2\u026a\u026c\7&\2\2\u026b\u026d\5b\62\2\u026c\u026b\3\2\2"+
		"\2\u026c\u026d\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u026f\7\'\2\2\u026f\u0297"+
		"\3\2\2\2\u0270\u0271\79\2\2\u0271\u0272\5x=\2\u0272\u0274\7&\2\2\u0273"+
		"\u0275\5b\62\2\u0274\u0273\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\3\2"+
		"\2\2\u0276\u0277\7\'\2\2\u0277\u0297\3\2\2\2\u0278\u0279\7:\2\2\u0279"+
		"\u027a\5x=\2\u027a\u027c\7&\2\2\u027b\u027d\5b\62\2\u027c\u027b\3\2\2"+
		"\2\u027c\u027d\3\2\2\2\u027d\u027e\3\2\2\2\u027e\u027f\7\'\2\2\u027f\u0297"+
		"\3\2\2\2\u0280\u0281\7,\2\2\u0281\u0297\5^\60\2\u0282\u0283\79\2\2\u0283"+
		"\u0297\5^\60\2\u0284\u0285\7:\2\2\u0285\u0297\5^\60\2\u0286\u0287\7\62"+
		"\2\2\u0287\u0297\5x=\2\u0288\u028a\7&\2\2\u0289\u028b\5b\62\2\u028a\u0289"+
		"\3\2\2\2\u028a\u028b\3\2\2\2\u028b\u028c\3\2\2\2\u028c\u0297\7\'\2\2\u028d"+
		"\u028f\7*\2\2\u028e\u0290\5`\61\2\u028f\u028e\3\2\2\2\u028f\u0290\3\2"+
		"\2\2\u0290\u0291\3\2\2\2\u0291\u0297\7+\2\2\u0292\u0293\6/\6\2\u0293\u0294"+
		"\5v<\2\u0294\u0295\5x=\2\u0295\u0297\3\2\2\2\u0296\u0268\3\2\2\2\u0296"+
		"\u0270\3\2\2\2\u0296\u0278\3\2\2\2\u0296\u0280\3\2\2\2\u0296\u0282\3\2"+
		"\2\2\u0296\u0284\3\2\2\2\u0296\u0286\3\2\2\2\u0296\u0288\3\2\2\2\u0296"+
		"\u028d\3\2\2\2\u0296\u0292\3\2\2\2\u0297]\3\2\2\2\u0298\u029c\5x=\2\u0299"+
		"\u029c\7 \2\2\u029a\u029c\7\"\2\2\u029b\u0298\3\2\2\2\u029b\u0299\3\2"+
		"\2\2\u029b\u029a\3\2\2\2\u029c_\3\2\2\2\u029d\u02a6\5\60\31\2\u029e\u02a0"+
		"\5\60\31\2\u029f\u029e\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a1\3\2\2\2"+
		"\u02a1\u02a3\7\61\2\2\u02a2\u02a4\5\60\31\2\u02a3\u02a2\3\2\2\2\u02a3"+
		"\u02a4\3\2\2\2\u02a4\u02a6\3\2\2\2\u02a5\u029d\3\2\2\2\u02a5\u029f\3\2"+
		"\2\2\u02a6a\3\2\2\2\u02a7\u02ac\5\60\31\2\u02a8\u02a9\7/\2\2\u02a9\u02ab"+
		"\5\60\31\2\u02aa\u02a8\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac\u02aa\3\2\2\2"+
		"\u02ac\u02ad\3\2\2\2\u02adc\3\2\2\2\u02ae\u02ac\3\2\2\2\u02af\u02b7\7"+
		"#\2\2\u02b0\u02b7\7$\2\2\u02b1\u02b7\7%\2\2\u02b2\u02b7\5j\66\2\u02b3"+
		"\u02b7\7\"\2\2\u02b4\u02b7\5f\64\2\u02b5\u02b7\7\27\2\2\u02b6\u02af\3"+
		"\2\2\2\u02b6\u02b0\3\2\2\2\u02b6\u02b1\3\2\2\2\u02b6\u02b2\3\2\2\2\u02b6"+
		"\u02b3\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b5\3\2\2\2\u02b7e\3\2\2\2"+
		"\u02b8\u02bd\7[\2\2\u02b9\u02bc\7_\2\2\u02ba\u02bc\5h\65\2\u02bb\u02b9"+
		"\3\2\2\2\u02bb\u02ba\3\2\2\2\u02bc\u02bf\3\2\2\2\u02bd\u02bb\3\2\2\2\u02bd"+
		"\u02be\3\2\2\2\u02be\u02c0\3\2\2\2\u02bf\u02bd\3\2\2\2\u02c0\u02c1\7`"+
		"\2\2\u02c1g\3\2\2\2\u02c2\u02c3\6\65\7\2\u02c3\u02c4\7^\2\2\u02c4\u02c5"+
		"\5\60\31\2\u02c5\u02c6\7b\2\2\u02c6\u02cc\3\2\2\2\u02c7\u02c8\6\65\b\2"+
		"\u02c8\u02c9\7^\2\2\u02c9\u02ca\7a\2\2\u02ca\u02cc\7)\2\2\u02cb\u02c2"+
		"\3\2\2\2\u02cb\u02c7\3\2\2\2\u02cci\3\2\2\2\u02cd\u02ce\t\5\2\2\u02ce"+
		"k\3\2\2\2\u02cf\u02d6\5x=\2\u02d0\u02d2\7&\2\2\u02d1\u02d3\5n8\2\u02d2"+
		"\u02d1\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d6\7\'"+
		"\2\2\u02d5\u02cf\3\2\2\2\u02d5\u02d0\3\2\2\2\u02d6m\3\2\2\2\u02d7\u02dc"+
		"\5p9\2\u02d8\u02d9\7/\2\2\u02d9\u02db\5p9\2\u02da\u02d8\3\2\2\2\u02db"+
		"\u02de\3\2\2\2\u02dc\u02da\3\2\2\2\u02dc\u02dd\3\2\2\2\u02ddo\3\2\2\2"+
		"\u02de\u02dc\3\2\2\2\u02df\u02e1\5\30\r\2\u02e0\u02df\3\2\2\2\u02e0\u02e1"+
		"\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2\u02e3\5x=\2\u02e3q\3\2\2\2\u02e4\u02e5"+
		"\7\f\2\2\u02e5\u02ea\5x=\2\u02e6\u02e7\7,\2\2\u02e7\u02e9\5x=\2\u02e8"+
		"\u02e6\3\2\2\2\u02e9\u02ec\3\2\2\2\u02ea\u02e8\3\2\2\2\u02ea\u02eb\3\2"+
		"\2\2\u02eb\u02ed\3\2\2\2\u02ec\u02ea\3\2\2\2\u02ed\u02ee\7.\2\2\u02ee"+
		"\u0300\3\2\2\2\u02ef\u02f0\7\f\2\2\u02f0\u02f5\5x=\2\u02f1\u02f2\7,\2"+
		"\2\u02f2\u02f4\5x=\2\u02f3\u02f1\3\2\2\2\u02f4\u02f7\3\2\2\2\u02f5\u02f3"+
		"\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02fb\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f8"+
		"\u02f9\7,\2\2\u02f9\u02fc\7O\2\2\u02fa\u02fc\7A\2\2\u02fb\u02f8\3\2\2"+
		"\2\u02fb\u02fa\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02fe\7.\2\2\u02fe\u0300"+
		"\3\2\2\2\u02ff\u02e4\3\2\2\2\u02ff\u02ef\3\2\2\2\u0300s\3\2\2\2\u0301"+
		"\u0302\t\6\2\2\u0302u\3\2\2\2\u0303\u031b\7\63\2\2\u0304\u031b\7\64\2"+
		"\2\u0305\u031b\7?\2\2\u0306\u031b\7@\2\2\u0307\u031b\7K\2\2\u0308\u031b"+
		"\7L\2\2\u0309\u031b\7M\2\2\u030a\u031b\7N\2\2\u030b\u031b\7O\2\2\u030c"+
		"\u031b\7P\2\2\u030d\u031b\7T\2\2\u030e\u031b\7U\2\2\u030f\u031b\7A\2\2"+
		"\u0310\u031b\7\66\2\2\u0311\u031b\78\2\2\u0312\u031b\7<\2\2\u0313\u031b"+
		"\7>\2\2\u0314\u031b\7Q\2\2\u0315\u031b\7R\2\2\u0316\u031b\7S\2\2\u0317"+
		"\u031b\7B\2\2\u0318\u031b\5t;\2\u0319\u031b\7Y\2\2\u031a\u0303\3\2\2\2"+
		"\u031a\u0304\3\2\2\2\u031a\u0305\3\2\2\2\u031a\u0306\3\2\2\2\u031a\u0307"+
		"\3\2\2\2\u031a\u0308\3\2\2\2\u031a\u0309\3\2\2\2\u031a\u030a\3\2\2\2\u031a"+
		"\u030b\3\2\2\2\u031a\u030c\3\2\2\2\u031a\u030d\3\2\2\2\u031a\u030e\3\2"+
		"\2\2\u031a\u030f\3\2\2\2\u031a\u0310\3\2\2\2\u031a\u0311\3\2\2\2\u031a"+
		"\u0312\3\2\2\2\u031a\u0313\3\2\2\2\u031a\u0314\3\2\2\2\u031a\u0315\3\2"+
		"\2\2\u031a\u0316\3\2\2\2\u031a\u0317\3\2\2\2\u031a\u0318\3\2\2\2\u031a"+
		"\u0319\3\2\2\2\u031bw\3\2\2\2\u031c\u031d\t\7\2\2\u031dy\3\2\2\2b}\u0081"+
		"\u0088\u009b\u009f\u00a7\u00b3\u00b8\u00c0\u00c8\u00ce\u00d0\u00dc\u00e3"+
		"\u00e9\u00ed\u00f1\u00f5\u00f8\u0101\u0106\u010a\u010c\u0110\u0116\u011b"+
		"\u0123\u012b\u0133\u0137\u013b\u013e\u0141\u0148\u014d\u0151\u0157\u015e"+
		"\u0164\u016d\u0174\u017c\u017f\u0185\u0189\u01a1\u01a5\u01a9\u01ba\u01be"+
		"\u01c4\u01cd\u01d7\u01dc\u01e0\u01e3\u01e8\u01ec\u01f0\u01f7\u0203\u020a"+
		"\u0213\u021c\u021f\u0226\u0230\u0234\u0236\u023f\u0244\u0266\u026c\u0274"+
		"\u027c\u028a\u028f\u0296\u029b\u029f\u02a3\u02a5\u02ac\u02b6\u02bb\u02bd"+
		"\u02cb\u02d2\u02d5\u02dc\u02e0\u02ea\u02f5\u02fb\u02ff\u031a";
	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);
		}
	}
}