• Home
• com.alibaba
• qlexpress4
• 4.0.0-beta.5
• source code

×

Project download

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

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

lexpress4.4.0.0-beta.5.source-code.QLParser Maven / Gradle / Ivy

// 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, THEN=30, CLASS=31, THIS=32, 
		QuoteStringLiteral=33, IntegerLiteral=34, FloatingPointLiteral=35, IntegerOrFloatingLiteral=36, 
		LPAREN=37, RPAREN=38, LBRACE=39, RBRACE=40, LBRACK=41, RBRACK=42, DOT=43, 
		ARROW=44, SEMI=45, COMMA=46, QUESTION=47, COLON=48, DCOLON=49, GT=50, 
		LT=51, EQ=52, NOEQ=53, RIGHSHIFT_ASSGIN=54, RIGHSHIFT=55, OPTIONAL_CHAINING=56, 
		SPREAD_CHAINING=57, URSHIFT_ASSGIN=58, URSHIFT=59, LSHIFT_ASSGIN=60, LEFTSHIFT=61, 
		GE=62, LE=63, DOTMUL=64, CARET=65, ADD_ASSIGN=66, SUB_ASSIGN=67, AND_ASSIGN=68, 
		OR_ASSIGN=69, MUL_ASSIGN=70, MOD_ASSIGN=71, DIV_ASSIGN=72, XOR_ASSIGN=73, 
		BANG=74, TILDE=75, ADD=76, SUB=77, MUL=78, DIV=79, BIT_AND=80, BIT_OR=81, 
		MOD=82, INC=83, DEC=84, WS=85, COMMENT=86, LINE_COMMENT=87, OPID=88, ID=89, 
		DOUBLE_QUOTE_OPEN=90, SELECTOR_START=91, CATCH_ALL=92, DyStrExprStart=93, 
		DyStrText=94, DOUBLE_QUOTE_CLOSE=95, SelectorVariable_VANME=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'", "'then'", "'class'", "'this'", 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", "THEN", "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_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 ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 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 BREAK() { return getToken(QLParser.BREAK, 0); }
		public TerminalNode CONTINUE() { return getToken(QLParser.CONTINUE, 0); }
		public TerminalNode SEMI() { return getToken(QLParser.SEMI, 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(211);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_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(142);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
				case 1:
					{
					setState(141);
					match(SEMI);
					}
					break;
				}
				}
				break;
			case 3:
				_localctx = new WhileStatementContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(144);
				match(WHILE);
				setState(145);
				match(LPAREN);
				setState(146);
				expression();
				setState(147);
				match(RPAREN);
				setState(148);
				blockStatement();
				}
				break;
			case 4:
				_localctx = new TraditionalForStatementContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(150);
				match(FOR);
				setState(151);
				match(LPAREN);
				setState(152);
				forInit();
				setState(154);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
				case 1:
					{
					setState(153);
					((TraditionalForStatementContext)_localctx).forCondition = expression();
					}
					break;
				}
				setState(156);
				match(SEMI);
				setState(158);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
				case 1:
					{
					setState(157);
					((TraditionalForStatementContext)_localctx).forUpdate = expression();
					}
					break;
				}
				setState(160);
				match(RPAREN);
				setState(161);
				blockStatement();
				}
				break;
			case 5:
				_localctx = new ForEachStatementContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(163);
				match(FOR);
				setState(164);
				match(LPAREN);
				setState(166);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
				case 1:
					{
					setState(165);
					declType();
					}
					break;
				}
				setState(168);
				varId();
				setState(169);
				match(COLON);
				setState(170);
				expression();
				setState(171);
				match(RPAREN);
				setState(172);
				blockStatement();
				}
				break;
			case 6:
				_localctx = new FunctionStatementContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(174);
				match(FUNCTION);
				setState(175);
				varId();
				setState(176);
				match(LPAREN);
				setState(178);
				_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(177);
					formalOrInferredParameterList();
					}
				}

				setState(180);
				match(RPAREN);
				setState(181);
				match(LBRACE);
				setState(183);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
				case 1:
					{
					setState(182);
					blockStatements();
					}
					break;
				}
				setState(185);
				match(RBRACE);
				}
				break;
			case 7:
				_localctx = new MacroStatementContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(187);
				match(MACRO);
				setState(188);
				varId();
				setState(189);
				match(LBRACE);
				setState(191);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
				case 1:
					{
					setState(190);
					blockStatements();
					}
					break;
				}
				setState(193);
				match(RBRACE);
				}
				break;
			case 8:
				_localctx = new BreakContinueStatementContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(195);
				_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(197);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
				case 1:
					{
					setState(196);
					match(SEMI);
					}
					break;
				}
				}
				break;
			case 9:
				_localctx = new ReturnStatementContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(199);
				match(RETURN);
				setState(201);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
				case 1:
					{
					setState(200);
					expression();
					}
					break;
				}
				setState(204);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
				case 1:
					{
					setState(203);
					match(SEMI);
					}
					break;
				}
				}
				break;
			case 10:
				_localctx = new EmptyStatementContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(206);
				match(SEMI);
				}
				break;
			case 11:
				_localctx = new ExpressionStatementContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(207);
				expression();
				setState(209);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
				case 1:
					{
					setState(208);
					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(213);
			declType();
			setState(214);
			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(223);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(216);
				localVariableDeclaration();
				setState(217);
				match(SEMI);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(219);
				expression();
				setState(220);
				match(SEMI);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(222);
				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(225);
			variableDeclarator();
			setState(230);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(226);
				match(COMMA);
				setState(227);
				variableDeclarator();
				}
				}
				setState(232);
				_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(233);
			variableDeclaratorId();
			setState(236);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EQ) {
				{
				setState(234);
				match(EQ);
				setState(235);
				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(238);
			varId();
			setState(240);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LBRACK) {
				{
				setState(239);
				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(244);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(242);
				expression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(243);
				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(246);
			match(LBRACE);
			setState(248);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
			case 1:
				{
				setState(247);
				variableInitializerList();
				}
				break;
			}
			setState(251);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(250);
				match(COMMA);
				}
			}

			setState(253);
			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(255);
			variableInitializer();
			setState(260);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(256);
					match(COMMA);
					setState(257);
					variableInitializer();
					}
					} 
				}
				setState(262);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,22,_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(271);
			_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(263);
				primitiveType();
				setState(265);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACK) {
					{
					setState(264);
					dims();
					}
				}

				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(267);
				clsType();
				setState(269);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACK) {
					{
					setState(268);
					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(275);
			_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(273);
				primitiveType();
				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(274);
				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(277);
			_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(286);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(279);
				clsType();
				setState(281);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
				case 1:
					{
					setState(280);
					dims();
					}
					break;
				}
				}
				break;
			case BYTE:
			case SHORT:
			case INT:
			case LONG:
			case FLOAT:
			case DOUBLE:
			case CHAR:
			case BOOL:
				enterOuterAlt(_localctx, 2);
				{
				setState(283);
				primitiveType();
				setState(284);
				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(288);
			match(LBRACK);
			setState(289);
			match(RBRACK);
			setState(294);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(290);
					match(LBRACK);
					setState(291);
					match(RBRACK);
					}
					} 
				}
				setState(296);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class 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(297);
			varId();
			setState(302);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(298);
				match(DOT);
				setState(299);
				varId();
				}
				}
				setState(304);
				_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(305);
			varId();
			setState(310);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(306);
				match(DOT);
				setState(307);
				varId();
				}
				}
				setState(312);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(314);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LT || _la==NOEQ) {
				{
				setState(313);
				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(324);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LT:
				enterOuterAlt(_localctx, 1);
				{
				setState(316);
				match(LT);
				setState(318);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
				case 1:
					{
					setState(317);
					typeArgumentList();
					}
					break;
				}
				setState(321);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
				case 1:
					{
					setState(320);
					_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(323);
				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(326);
			typeArgument();
			setState(331);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(327);
					match(COMMA);
					setState(328);
					typeArgument();
					}
					} 
				}
				setState(333);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,36,_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(336);
			_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(334);
				referenceType();
				}
				break;
			case QUESTION:
				enterOuterAlt(_localctx, 2);
				{
				setState(335);
				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(338);
			match(QUESTION);
			setState(340);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EXTENDS || _la==SUPER) {
				{
				setState(339);
				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(346);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case EXTENDS:
				enterOuterAlt(_localctx, 1);
				{
				setState(342);
				match(EXTENDS);
				setState(343);
				referenceType();
				}
				break;
			case SUPER:
				enterOuterAlt(_localctx, 2);
				{
				setState(344);
				match(SUPER);
				setState(345);
				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(353);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(348);
				leftHandSide();
				setState(349);
				assignOperator();
				setState(350);
				expression();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(352);
				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(355);
			varId();
			setState(359);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(356);
					pathPart();
					}
					} 
				}
				setState(361);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,41,_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(362);
			((TernaryExprContext)_localctx).condition = baseExpr(1);
			setState(368);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				{
				setState(363);
				match(QUESTION);
				setState(364);
				((TernaryExprContext)_localctx).thenExpr = baseExpr(0);
				setState(365);
				match(COLON);
				setState(366);
				((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(370);
			primary();
			setState(375);
			_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(371);
					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(372);
					leftAsso();
					}
					} 
				}
				setState(377);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,43,_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(378);
			binaryop();
			setState(379);
			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(383);
			_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(381);
				opId();
				}
				break;
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(382);
				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(386);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				{
				setState(385);
				prefixExpress();
				}
				break;
			}
			setState(388);
			primaryNoFix();
			setState(392);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(389);
					pathPart();
					}
					} 
				}
				setState(394);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
			}
			setState(396);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
			case 1:
				{
				setState(395);
				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(398);
			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(399);
			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(401);
			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(402);
			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 THEN() { return getToken(QLParser.THEN, 0); }
		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(494);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
			case 1:
				_localctx = new ConstExprContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(404);
				literal();
				}
				break;
			case 2:
				_localctx = new CastExprContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(405);
				match(LPAREN);
				setState(406);
				declType();
				setState(407);
				match(RPAREN);
				setState(408);
				primary();
				}
				break;
			case 3:
				_localctx = new GroupExprContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(410);
				match(LPAREN);
				setState(411);
				expression();
				setState(412);
				match(RPAREN);
				}
				break;
			case 4:
				_localctx = new NewObjExprContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(414);
				match(NEW);
				setState(415);
				varId();
				setState(420);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==DOT) {
					{
					{
					setState(416);
					match(DOT);
					setState(417);
					varId();
					}
					}
					setState(422);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(424);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LT || _la==NOEQ) {
					{
					setState(423);
					typeArguments();
					}
				}

				setState(426);
				match(LPAREN);
				setState(428);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
				case 1:
					{
					setState(427);
					argumentList();
					}
					break;
				}
				setState(430);
				match(RPAREN);
				}
				break;
			case 5:
				_localctx = new NewEmptyArrExprContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(432);
				match(NEW);
				setState(433);
				declTypeNoArr();
				setState(434);
				dimExprs();
				}
				break;
			case 6:
				_localctx = new NewInitArrExprContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(436);
				match(NEW);
				setState(437);
				declTypeNoArr();
				setState(438);
				dims();
				setState(439);
				arrayInitializer();
				}
				break;
			case 7:
				_localctx = new LambdaExprContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(441);
				lambdaParameters();
				setState(442);
				match(ARROW);
				setState(449);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
				case 1:
					{
					setState(443);
					match(LBRACE);
					setState(445);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
					case 1:
						{
						setState(444);
						blockStatements();
						}
						break;
					}
					setState(447);
					match(RBRACE);
					}
					break;
				case 2:
					{
					setState(448);
					expression();
					}
					break;
				}
				}
				break;
			case 8:
				_localctx = new VarIdExprContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(451);
				varId();
				}
				break;
			case 9:
				_localctx = new TypeExprContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(452);
				primitiveType();
				}
				break;
			case 10:
				_localctx = new ListExprContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(453);
				match(LBRACK);
				setState(455);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
				case 1:
					{
					setState(454);
					listItems();
					}
					break;
				}
				setState(457);
				match(RBRACK);
				}
				break;
			case 11:
				_localctx = new MapExprContext(_localctx);
				enterOuterAlt(_localctx, 11);
				{
				setState(458);
				match(LBRACE);
				setState(459);
				mapEntries();
				setState(460);
				match(RBRACE);
				}
				break;
			case 12:
				_localctx = new BlockExprContext(_localctx);
				enterOuterAlt(_localctx, 12);
				{
				setState(462);
				match(LBRACE);
				setState(464);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
				case 1:
					{
					setState(463);
					blockStatements();
					}
					break;
				}
				setState(466);
				match(RBRACE);
				}
				break;
			case 13:
				_localctx = new IfExprContext(_localctx);
				enterOuterAlt(_localctx, 13);
				{
				setState(467);
				match(IF);
				setState(468);
				match(LPAREN);
				setState(469);
				((IfExprContext)_localctx).condition = expression();
				setState(470);
				match(RPAREN);
				setState(472);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
				case 1:
					{
					setState(471);
					match(THEN);
					}
					break;
				}
				setState(474);
				((IfExprContext)_localctx).thenBody = ifBody();
				setState(477);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
				case 1:
					{
					setState(475);
					match(ELSE);
					setState(476);
					((IfExprContext)_localctx).elseBody = ifBody();
					}
					break;
				}
				}
				break;
			case 14:
				_localctx = new TryCatchExprContext(_localctx);
				enterOuterAlt(_localctx, 14);
				{
				setState(479);
				match(TRY);
				setState(480);
				match(LBRACE);
				setState(482);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
				case 1:
					{
					setState(481);
					blockStatements();
					}
					break;
				}
				setState(484);
				match(RBRACE);
				setState(486);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
				case 1:
					{
					setState(485);
					tryCatches();
					}
					break;
				}
				setState(489);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
				case 1:
					{
					setState(488);
					tryFinally();
					}
					break;
				}
				}
				break;
			case 15:
				_localctx = new ContextSelectExprContext(_localctx);
				enterOuterAlt(_localctx, 15);
				{
				setState(491);
				match(SELECTOR_START);
				setState(492);
				match(SelectorVariable_VANME);
				setState(493);
				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(502);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(496);
				match(LBRACE);
				setState(498);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
				case 1:
					{
					setState(497);
					blockStatements();
					}
					break;
				}
				setState(500);
				match(RBRACE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(501);
				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(504);
			expression();
			setState(509);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(505);
				match(COMMA);
				setState(506);
				expression();
				}
				}
				setState(511);
				_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(512);
			match(LBRACK);
			setState(513);
			expression();
			setState(514);
			match(RBRACK);
			setState(521);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(515);
					match(LBRACK);
					setState(516);
					expression();
					setState(517);
					match(RBRACK);
					}
					} 
				}
				setState(523);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,64,_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(524);
			tryCatch();
			setState(528);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(525);
					tryCatch();
					}
					} 
				}
				setState(530);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,65,_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(531);
			match(CATCH);
			setState(532);
			match(LPAREN);
			setState(533);
			catchParams();
			setState(534);
			match(RPAREN);
			setState(535);
			match(LBRACE);
			setState(537);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
			case 1:
				{
				setState(536);
				blockStatements();
				}
				break;
			}
			setState(539);
			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(549);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
			case 1:
				{
				setState(541);
				declType();
				setState(546);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==BIT_OR) {
					{
					{
					setState(542);
					match(BIT_OR);
					setState(543);
					declType();
					}
					}
					setState(548);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
			setState(551);
			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(553);
			match(FINALLY);
			setState(554);
			match(LBRACE);
			setState(556);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				{
				setState(555);
				blockStatements();
				}
				break;
			}
			setState(558);
			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(572);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case COLON:
				enterOuterAlt(_localctx, 1);
				{
				setState(560);
				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(561);
				mapEntry();
				setState(566);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(562);
						match(COMMA);
						setState(563);
						mapEntry();
						}
						} 
					}
					setState(568);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
				}
				setState(570);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA) {
					{
					setState(569);
					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(574);
			mapKey();
			setState(575);
			match(COLON);
			setState(576);
			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(581);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
			case 1:
				_localctx = new ClsValueContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(578);
				if (!(_input.LT(-2).getText().equals("'@class'"))) throw new FailedPredicateException(this, "_input.LT(-2).getText().equals(\"'@class'\")");
				setState(579);
				match(QuoteStringLiteral);
				}
				break;
			case 2:
				_localctx = new EValueContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(580);
				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(586);
			_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(583);
				idMapKey();
				}
				break;
			case DOUBLE_QUOTE_OPEN:
				_localctx = new StringKeyContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(584);
				doubleQuoteStringLiteral();
				}
				break;
			case QuoteStringLiteral:
				_localctx = new QuoteStringKeyContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(585);
				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(620);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(588);
				varId();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(589);
				match(FOR);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(590);
				match(IF);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(591);
				match(ELSE);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(592);
				match(WHILE);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(593);
				match(BREAK);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(594);
				match(CONTINUE);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(595);
				match(RETURN);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(596);
				match(FUNCTION);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(597);
				match(MACRO);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(598);
				match(IMPORT);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(599);
				match(STATIC);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(600);
				match(NEW);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(601);
				match(BYTE);
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(602);
				match(SHORT);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(603);
				match(INT);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(604);
				match(LONG);
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(605);
				match(FLOAT);
				}
				break;
			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(606);
				match(DOUBLE);
				}
				break;
			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(607);
				match(CHAR);
				}
				break;
			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(608);
				match(BOOL);
				}
				break;
			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(609);
				match(NULL);
				}
				break;
			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(610);
				match(TRUE);
				}
				break;
			case 24:
				enterOuterAlt(_localctx, 24);
				{
				setState(611);
				match(FALSE);
				}
				break;
			case 25:
				enterOuterAlt(_localctx, 25);
				{
				setState(612);
				match(EXTENDS);
				}
				break;
			case 26:
				enterOuterAlt(_localctx, 26);
				{
				setState(613);
				match(SUPER);
				}
				break;
			case 27:
				enterOuterAlt(_localctx, 27);
				{
				setState(614);
				match(TRY);
				}
				break;
			case 28:
				enterOuterAlt(_localctx, 28);
				{
				setState(615);
				match(CATCH);
				}
				break;
			case 29:
				enterOuterAlt(_localctx, 29);
				{
				setState(616);
				match(FINALLY);
				}
				break;
			case 30:
				enterOuterAlt(_localctx, 30);
				{
				setState(617);
				match(THROW);
				}
				break;
			case 31:
				enterOuterAlt(_localctx, 31);
				{
				setState(618);
				match(CLASS);
				}
				break;
			case 32:
				enterOuterAlt(_localctx, 32);
				{
				setState(619);
				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(668);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
			case 1:
				_localctx = new MethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(622);
				match(DOT);
				setState(623);
				varId();
				setState(624);
				match(LPAREN);
				setState(626);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
				case 1:
					{
					setState(625);
					argumentList();
					}
					break;
				}
				setState(628);
				match(RPAREN);
				}
				break;
			case 2:
				_localctx = new OptionalMethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(630);
				match(OPTIONAL_CHAINING);
				setState(631);
				varId();
				setState(632);
				match(LPAREN);
				setState(634);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
				case 1:
					{
					setState(633);
					argumentList();
					}
					break;
				}
				setState(636);
				match(RPAREN);
				}
				break;
			case 3:
				_localctx = new SpreadMethodInvokeContext(_localctx);
				enterOuterAlt(_localctx, 3);
				{
				setState(638);
				match(SPREAD_CHAINING);
				setState(639);
				varId();
				setState(640);
				match(LPAREN);
				setState(642);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
				case 1:
					{
					setState(641);
					argumentList();
					}
					break;
				}
				setState(644);
				match(RPAREN);
				}
				break;
			case 4:
				_localctx = new FieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 4);
				{
				setState(646);
				match(DOT);
				setState(647);
				fieldId();
				}
				break;
			case 5:
				_localctx = new OptionalFieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 5);
				{
				setState(648);
				match(OPTIONAL_CHAINING);
				setState(649);
				fieldId();
				}
				break;
			case 6:
				_localctx = new SpreadFieldAccessContext(_localctx);
				enterOuterAlt(_localctx, 6);
				{
				setState(650);
				match(SPREAD_CHAINING);
				setState(651);
				fieldId();
				}
				break;
			case 7:
				_localctx = new MethodAccessContext(_localctx);
				enterOuterAlt(_localctx, 7);
				{
				setState(652);
				match(DCOLON);
				setState(653);
				varId();
				}
				break;
			case 8:
				_localctx = new CallExprContext(_localctx);
				enterOuterAlt(_localctx, 8);
				{
				setState(654);
				match(LPAREN);
				setState(656);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
				case 1:
					{
					setState(655);
					argumentList();
					}
					break;
				}
				setState(658);
				match(RPAREN);
				}
				break;
			case 9:
				_localctx = new IndexExprContext(_localctx);
				enterOuterAlt(_localctx, 9);
				{
				setState(659);
				match(LBRACK);
				setState(661);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
				case 1:
					{
					setState(660);
					indexValueExpr();
					}
					break;
				}
				setState(663);
				match(RBRACK);
				}
				break;
			case 10:
				_localctx = new CustomPathContext(_localctx);
				enterOuterAlt(_localctx, 10);
				{
				setState(664);
				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(665);
				opId();
				setState(666);
				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(673);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(670);
				varId();
				}
				break;
			case CLASS:
				enterOuterAlt(_localctx, 2);
				{
				setState(671);
				match(CLASS);
				}
				break;
			case QuoteStringLiteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(672);
				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(683);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
			case 1:
				_localctx = new SingleIndexContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(675);
				expression();
				}
				break;
			case 2:
				_localctx = new SliceIndexContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(677);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
				case 1:
					{
					setState(676);
					((SliceIndexContext)_localctx).start = expression();
					}
					break;
				}
				setState(679);
				match(COLON);
				setState(681);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
				case 1:
					{
					setState(680);
					((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(685);
			expression();
			setState(690);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(686);
				match(COMMA);
				setState(687);
				expression();
				}
				}
				setState(692);
				_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(700);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IntegerLiteral:
				enterOuterAlt(_localctx, 1);
				{
				setState(693);
				match(IntegerLiteral);
				}
				break;
			case FloatingPointLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(694);
				match(FloatingPointLiteral);
				}
				break;
			case IntegerOrFloatingLiteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(695);
				match(IntegerOrFloatingLiteral);
				}
				break;
			case TRUE:
			case FALSE:
				enterOuterAlt(_localctx, 4);
				{
				setState(696);
				boolenLiteral();
				}
				break;
			case QuoteStringLiteral:
				enterOuterAlt(_localctx, 5);
				{
				setState(697);
				match(QuoteStringLiteral);
				}
				break;
			case DOUBLE_QUOTE_OPEN:
				enterOuterAlt(_localctx, 6);
				{
				setState(698);
				doubleQuoteStringLiteral();
				}
				break;
			case NULL:
				enterOuterAlt(_localctx, 7);
				{
				setState(699);
				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(702);
			match(DOUBLE_QUOTE_OPEN);
			setState(707);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					setState(705);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
					case 1:
						{
						setState(703);
						match(DyStrText);
						}
						break;
					case 2:
						{
						setState(704);
						stringExpression();
						}
						break;
					}
					} 
				}
				setState(709);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
			}
			setState(710);
			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 RBRACE() { return getToken(QLParser.RBRACE, 0); }
		public TerminalNode SelectorVariable_VANME() { return getToken(QLParser.SelectorVariable_VANME, 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(721);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(712);
				if (!(interpolationMode == SCRIPT)) throw new FailedPredicateException(this, "interpolationMode == SCRIPT");
				setState(713);
				match(DyStrExprStart);
				setState(714);
				expression();
				setState(715);
				match(RBRACE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(717);
				if (!(interpolationMode == VARIABLE)) throw new FailedPredicateException(this, "interpolationMode == VARIABLE");
				setState(718);
				match(DyStrExprStart);
				setState(719);
				match(SelectorVariable_VANME);
				setState(720);
				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(723);
			_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(731);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FUNCTION:
			case ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(725);
				varId();
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 2);
				{
				setState(726);
				match(LPAREN);
				setState(728);
				_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(727);
					formalOrInferredParameterList();
					}
				}

				setState(730);
				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(733);
			formalOrInferredParameter();
			setState(738);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(734);
				match(COMMA);
				setState(735);
				formalOrInferredParameter();
				}
				}
				setState(740);
				_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(742);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
			case 1:
				{
				setState(741);
				declType();
				}
				break;
			}
			setState(744);
			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(773);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
			case 1:
				_localctx = new ImportClsContext(_localctx);
				enterOuterAlt(_localctx, 1);
				{
				setState(746);
				match(IMPORT);
				setState(747);
				varId();
				setState(752);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==DOT) {
					{
					{
					setState(748);
					match(DOT);
					setState(749);
					varId();
					}
					}
					setState(754);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(755);
				match(SEMI);
				}
				break;
			case 2:
				_localctx = new ImportPackContext(_localctx);
				enterOuterAlt(_localctx, 2);
				{
				setState(757);
				match(IMPORT);
				setState(758);
				varId();
				setState(763);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(759);
						match(DOT);
						setState(760);
						varId();
						}
						} 
					}
					setState(765);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
				}
				setState(769);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case DOT:
					{
					setState(766);
					match(DOT);
					setState(767);
					match(MUL);
					}
					break;
				case DOTMUL:
					{
					setState(768);
					match(DOTMUL);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(771);
				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(775);
			_la = _input.LA(1);
			if ( !(((((_la - 52)) & ~0x3f) == 0 && ((1L << (_la - 52)) & ((1L << (EQ - 52)) | (1L << (RIGHSHIFT_ASSGIN - 52)) | (1L << (URSHIFT_ASSGIN - 52)) | (1L << (LSHIFT_ASSGIN - 52)) | (1L << (ADD_ASSIGN - 52)) | (1L << (SUB_ASSIGN - 52)) | (1L << (AND_ASSIGN - 52)) | (1L << (OR_ASSIGN - 52)) | (1L << (MUL_ASSIGN - 52)) | (1L << (MOD_ASSIGN - 52)) | (1L << (DIV_ASSIGN - 52)) | (1L << (XOR_ASSIGN - 52)))) != 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(800);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case GT:
				enterOuterAlt(_localctx, 1);
				{
				setState(777);
				match(GT);
				}
				break;
			case LT:
				enterOuterAlt(_localctx, 2);
				{
				setState(778);
				match(LT);
				}
				break;
			case GE:
				enterOuterAlt(_localctx, 3);
				{
				setState(779);
				match(GE);
				}
				break;
			case LE:
				enterOuterAlt(_localctx, 4);
				{
				setState(780);
				match(LE);
				}
				break;
			case BANG:
				enterOuterAlt(_localctx, 5);
				{
				setState(781);
				match(BANG);
				}
				break;
			case TILDE:
				enterOuterAlt(_localctx, 6);
				{
				setState(782);
				match(TILDE);
				}
				break;
			case ADD:
				enterOuterAlt(_localctx, 7);
				{
				setState(783);
				match(ADD);
				}
				break;
			case SUB:
				enterOuterAlt(_localctx, 8);
				{
				setState(784);
				match(SUB);
				}
				break;
			case MUL:
				enterOuterAlt(_localctx, 9);
				{
				setState(785);
				match(MUL);
				}
				break;
			case DIV:
				enterOuterAlt(_localctx, 10);
				{
				setState(786);
				match(DIV);
				}
				break;
			case INC:
				enterOuterAlt(_localctx, 11);
				{
				setState(787);
				match(INC);
				}
				break;
			case DEC:
				enterOuterAlt(_localctx, 12);
				{
				setState(788);
				match(DEC);
				}
				break;
			case DOTMUL:
				enterOuterAlt(_localctx, 13);
				{
				setState(789);
				match(DOTMUL);
				}
				break;
			case NOEQ:
				enterOuterAlt(_localctx, 14);
				{
				setState(790);
				match(NOEQ);
				}
				break;
			case RIGHSHIFT:
				enterOuterAlt(_localctx, 15);
				{
				setState(791);
				match(RIGHSHIFT);
				}
				break;
			case URSHIFT:
				enterOuterAlt(_localctx, 16);
				{
				setState(792);
				match(URSHIFT);
				}
				break;
			case LEFTSHIFT:
				enterOuterAlt(_localctx, 17);
				{
				setState(793);
				match(LEFTSHIFT);
				}
				break;
			case BIT_AND:
				enterOuterAlt(_localctx, 18);
				{
				setState(794);
				match(BIT_AND);
				}
				break;
			case BIT_OR:
				enterOuterAlt(_localctx, 19);
				{
				setState(795);
				match(BIT_OR);
				}
				break;
			case MOD:
				enterOuterAlt(_localctx, 20);
				{
				setState(796);
				match(MOD);
				}
				break;
			case CARET:
				enterOuterAlt(_localctx, 21);
				{
				setState(797);
				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(798);
				assignOperator();
				}
				break;
			case OPID:
				enterOuterAlt(_localctx, 23);
				{
				setState(799);
				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(802);
			_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\u0327\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\5\4\u0091\n\4\3\4\3\4\3\4"+
		"\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u009d\n\4\3\4\3\4\5\4\u00a1\n\4\3\4\3"+
		"\4\3\4\3\4\3\4\3\4\5\4\u00a9\n\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3"+
		"\4\5\4\u00b5\n\4\3\4\3\4\3\4\5\4\u00ba\n\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4"+
		"\u00c2\n\4\3\4\3\4\3\4\3\4\5\4\u00c8\n\4\3\4\3\4\5\4\u00cc\n\4\3\4\5\4"+
		"\u00cf\n\4\3\4\3\4\3\4\5\4\u00d4\n\4\5\4\u00d6\n\4\3\5\3\5\3\5\3\6\3\6"+
		"\3\6\3\6\3\6\3\6\3\6\5\6\u00e2\n\6\3\7\3\7\3\7\7\7\u00e7\n\7\f\7\16\7"+
		"\u00ea\13\7\3\b\3\b\3\b\5\b\u00ef\n\b\3\t\3\t\5\t\u00f3\n\t\3\n\3\n\5"+
		"\n\u00f7\n\n\3\13\3\13\5\13\u00fb\n\13\3\13\5\13\u00fe\n\13\3\13\3\13"+
		"\3\f\3\f\3\f\7\f\u0105\n\f\f\f\16\f\u0108\13\f\3\r\3\r\5\r\u010c\n\r\3"+
		"\r\3\r\5\r\u0110\n\r\5\r\u0112\n\r\3\16\3\16\5\16\u0116\n\16\3\17\3\17"+
		"\3\20\3\20\5\20\u011c\n\20\3\20\3\20\3\20\5\20\u0121\n\20\3\21\3\21\3"+
		"\21\3\21\7\21\u0127\n\21\f\21\16\21\u012a\13\21\3\22\3\22\3\22\7\22\u012f"+
		"\n\22\f\22\16\22\u0132\13\22\3\23\3\23\3\23\7\23\u0137\n\23\f\23\16\23"+
		"\u013a\13\23\3\23\5\23\u013d\n\23\3\24\3\24\5\24\u0141\n\24\3\24\5\24"+
		"\u0144\n\24\3\24\5\24\u0147\n\24\3\25\3\25\3\25\7\25\u014c\n\25\f\25\16"+
		"\25\u014f\13\25\3\26\3\26\5\26\u0153\n\26\3\27\3\27\5\27\u0157\n\27\3"+
		"\30\3\30\3\30\3\30\5\30\u015d\n\30\3\31\3\31\3\31\3\31\3\31\5\31\u0164"+
		"\n\31\3\32\3\32\7\32\u0168\n\32\f\32\16\32\u016b\13\32\3\33\3\33\3\33"+
		"\3\33\3\33\3\33\5\33\u0173\n\33\3\34\3\34\3\34\7\34\u0178\n\34\f\34\16"+
		"\34\u017b\13\34\3\35\3\35\3\35\3\36\3\36\5\36\u0182\n\36\3\37\5\37\u0185"+
		"\n\37\3\37\3\37\7\37\u0189\n\37\f\37\16\37\u018c\13\37\3\37\5\37\u018f"+
		"\n\37\3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
		"\"\3\"\3\"\7\"\u01a5\n\"\f\"\16\"\u01a8\13\"\3\"\5\"\u01ab\n\"\3\"\3\""+
		"\5\"\u01af\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+
		"\3\"\5\"\u01c0\n\"\3\"\3\"\5\"\u01c4\n\"\3\"\3\"\3\"\3\"\5\"\u01ca\n\""+
		"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u01d3\n\"\3\"\3\"\3\"\3\"\3\"\3\"\5\""+
		"\u01db\n\"\3\"\3\"\3\"\5\"\u01e0\n\"\3\"\3\"\3\"\5\"\u01e5\n\"\3\"\3\""+
		"\5\"\u01e9\n\"\3\"\5\"\u01ec\n\"\3\"\3\"\3\"\5\"\u01f1\n\"\3#\3#\5#\u01f5"+
		"\n#\3#\3#\5#\u01f9\n#\3$\3$\3$\7$\u01fe\n$\f$\16$\u0201\13$\3%\3%\3%\3"+
		"%\3%\3%\3%\7%\u020a\n%\f%\16%\u020d\13%\3&\3&\7&\u0211\n&\f&\16&\u0214"+
		"\13&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u021c\n\'\3\'\3\'\3(\3(\3(\7(\u0223\n"+
		"(\f(\16(\u0226\13(\5(\u0228\n(\3(\3(\3)\3)\3)\5)\u022f\n)\3)\3)\3*\3*"+
		"\3*\3*\7*\u0237\n*\f*\16*\u023a\13*\3*\5*\u023d\n*\5*\u023f\n*\3+\3+\3"+
		"+\3+\3,\3,\3,\5,\u0248\n,\3-\3-\3-\5-\u024d\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.\u026f\n.\3/\3/\3/\3/\5/\u0275\n/\3/\3/\3/\3/\3/\3/\5/\u027d\n"+
		"/\3/\3/\3/\3/\3/\3/\5/\u0285\n/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\5"+
		"/\u0293\n/\3/\3/\3/\5/\u0298\n/\3/\3/\3/\3/\3/\5/\u029f\n/\3\60\3\60\3"+
		"\60\5\60\u02a4\n\60\3\61\3\61\5\61\u02a8\n\61\3\61\3\61\5\61\u02ac\n\61"+
		"\5\61\u02ae\n\61\3\62\3\62\3\62\7\62\u02b3\n\62\f\62\16\62\u02b6\13\62"+
		"\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02bf\n\63\3\64\3\64\3\64\7\64"+
		"\u02c4\n\64\f\64\16\64\u02c7\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\u02d4\n\65\3\66\3\66\3\67\3\67\3\67\5\67\u02db"+
		"\n\67\3\67\5\67\u02de\n\67\38\38\38\78\u02e3\n8\f8\168\u02e6\138\39\5"+
		"9\u02e9\n9\39\39\3:\3:\3:\3:\7:\u02f1\n:\f:\16:\u02f4\13:\3:\3:\3:\3:"+
		"\3:\3:\7:\u02fc\n:\f:\16:\u02ff\13:\3:\3:\3:\5:\u0304\n:\3:\3:\5:\u0308"+
		"\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<\u0323\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\\^`bdfhjlnprtvx\2\b\3\2\7\b"+
		"\3\2\17\26\5\2\64\6499==\3\2\30\31\7\2\66\6688<<>>DK\4\2\n\n[[\2\u03a7"+
		"\2}\3\2\2\2\4\u0086\3\2\2\2\6\u00d5\3\2\2\2\b\u00d7\3\2\2\2\n\u00e1\3"+
		"\2\2\2\f\u00e3\3\2\2\2\16\u00eb\3\2\2\2\20\u00f0\3\2\2\2\22\u00f6\3\2"+
		"\2\2\24\u00f8\3\2\2\2\26\u0101\3\2\2\2\30\u0111\3\2\2\2\32\u0115\3\2\2"+
		"\2\34\u0117\3\2\2\2\36\u0120\3\2\2\2 \u0122\3\2\2\2\"\u012b\3\2\2\2$\u0133"+
		"\3\2\2\2&\u0146\3\2\2\2(\u0148\3\2\2\2*\u0152\3\2\2\2,\u0154\3\2\2\2."+
		"\u015c\3\2\2\2\60\u0163\3\2\2\2\62\u0165\3\2\2\2\64\u016c\3\2\2\2\66\u0174"+
		"\3\2\2\28\u017c\3\2\2\2:\u0181\3\2\2\2<\u0184\3\2\2\2>\u0190\3\2\2\2@"+
		"\u0193\3\2\2\2B\u01f0\3\2\2\2D\u01f8\3\2\2\2F\u01fa\3\2\2\2H\u0202\3\2"+
		"\2\2J\u020e\3\2\2\2L\u0215\3\2\2\2N\u0227\3\2\2\2P\u022b\3\2\2\2R\u023e"+
		"\3\2\2\2T\u0240\3\2\2\2V\u0247\3\2\2\2X\u024c\3\2\2\2Z\u026e\3\2\2\2\\"+
		"\u029e\3\2\2\2^\u02a3\3\2\2\2`\u02ad\3\2\2\2b\u02af\3\2\2\2d\u02be\3\2"+
		"\2\2f\u02c0\3\2\2\2h\u02d3\3\2\2\2j\u02d5\3\2\2\2l\u02dd\3\2\2\2n\u02df"+
		"\3\2\2\2p\u02e8\3\2\2\2r\u0307\3\2\2\2t\u0309\3\2\2\2v\u0322\3\2\2\2x"+
		"\u0324\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\u00d6\3\2\2\2\u008d\u008e\7\37\2\2\u008e\u0090\5\60\31\2"+
		"\u008f\u0091\7/\2\2\u0090\u008f\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u00d6"+
		"\3\2\2\2\u0092\u0093\7\6\2\2\u0093\u0094\7\'\2\2\u0094\u0095\5\60\31\2"+
		"\u0095\u0096\7(\2\2\u0096\u0097\5\6\4\2\u0097\u00d6\3\2\2\2\u0098\u0099"+
		"\7\3\2\2\u0099\u009a\7\'\2\2\u009a\u009c\5\n\6\2\u009b\u009d\5\60\31\2"+
		"\u009c\u009b\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a0"+
		"\7/\2\2\u009f\u00a1\5\60\31\2\u00a0\u009f\3\2\2\2\u00a0\u00a1\3\2\2\2"+
		"\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7(\2\2\u00a3\u00a4\5\6\4\2\u00a4\u00d6"+
		"\3\2\2\2\u00a5\u00a6\7\3\2\2\u00a6\u00a8\7\'\2\2\u00a7\u00a9\5\30\r\2"+
		"\u00a8\u00a7\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab"+
		"\5x=\2\u00ab\u00ac\7\62\2\2\u00ac\u00ad\5\60\31\2\u00ad\u00ae\7(\2\2\u00ae"+
		"\u00af\5\6\4\2\u00af\u00d6\3\2\2\2\u00b0\u00b1\7\n\2\2\u00b1\u00b2\5x"+
		"=\2\u00b2\u00b4\7\'\2\2\u00b3\u00b5\5n8\2\u00b4\u00b3\3\2\2\2\u00b4\u00b5"+
		"\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b7\7(\2\2\u00b7\u00b9\7)\2\2\u00b8"+
		"\u00ba\5\4\3\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\3\2"+
		"\2\2\u00bb\u00bc\7*\2\2\u00bc\u00d6\3\2\2\2\u00bd\u00be\7\13\2\2\u00be"+
		"\u00bf\5x=\2\u00bf\u00c1\7)\2\2\u00c0\u00c2\5\4\3\2\u00c1\u00c0\3\2\2"+
		"\2\u00c1\u00c2\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c4\7*\2\2\u00c4\u00d6"+
		"\3\2\2\2\u00c5\u00c7\t\2\2\2\u00c6\u00c8\7/\2\2\u00c7\u00c6\3\2\2\2\u00c7"+
		"\u00c8\3\2\2\2\u00c8\u00d6\3\2\2\2\u00c9\u00cb\7\t\2\2\u00ca\u00cc\5\60"+
		"\31\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00ce\3\2\2\2\u00cd"+
		"\u00cf\7/\2\2\u00ce\u00cd\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d6\3\2"+
		"\2\2\u00d0\u00d6\7/\2\2\u00d1\u00d3\5\60\31\2\u00d2\u00d4\7/\2\2\u00d3"+
		"\u00d2\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d6\3\2\2\2\u00d5\u008a\3\2"+
		"\2\2\u00d5\u008d\3\2\2\2\u00d5\u0092\3\2\2\2\u00d5\u0098\3\2\2\2\u00d5"+
		"\u00a5\3\2\2\2\u00d5\u00b0\3\2\2\2\u00d5\u00bd\3\2\2\2\u00d5\u00c5\3\2"+
		"\2\2\u00d5\u00c9\3\2\2\2\u00d5\u00d0\3\2\2\2\u00d5\u00d1\3\2\2\2\u00d6"+
		"\7\3\2\2\2\u00d7\u00d8\5\30\r\2\u00d8\u00d9\5\f\7\2\u00d9\t\3\2\2\2\u00da"+
		"\u00db\5\b\5\2\u00db\u00dc\7/\2\2\u00dc\u00e2\3\2\2\2\u00dd\u00de\5\60"+
		"\31\2\u00de\u00df\7/\2\2\u00df\u00e2\3\2\2\2\u00e0\u00e2\7/\2\2\u00e1"+
		"\u00da\3\2\2\2\u00e1\u00dd\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\13\3\2\2"+
		"\2\u00e3\u00e8\5\16\b\2\u00e4\u00e5\7\60\2\2\u00e5\u00e7\5\16\b\2\u00e6"+
		"\u00e4\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9\3\2"+
		"\2\2\u00e9\r\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ee\5\20\t\2\u00ec\u00ed"+
		"\7\66\2\2\u00ed\u00ef\5\22\n\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2"+
		"\u00ef\17\3\2\2\2\u00f0\u00f2\5x=\2\u00f1\u00f3\5 \21\2\u00f2\u00f1\3"+
		"\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\21\3\2\2\2\u00f4\u00f7\5\60\31\2\u00f5"+
		"\u00f7\5\24\13\2\u00f6\u00f4\3\2\2\2\u00f6\u00f5\3\2\2\2\u00f7\23\3\2"+
		"\2\2\u00f8\u00fa\7)\2\2\u00f9\u00fb\5\26\f\2\u00fa\u00f9\3\2\2\2\u00fa"+
		"\u00fb\3\2\2\2\u00fb\u00fd\3\2\2\2\u00fc\u00fe\7\60\2\2\u00fd\u00fc\3"+
		"\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0100\7*\2\2\u0100"+
		"\25\3\2\2\2\u0101\u0106\5\22\n\2\u0102\u0103\7\60\2\2\u0103\u0105\5\22"+
		"\n\2\u0104\u0102\3\2\2\2\u0105\u0108\3\2\2\2\u0106\u0104\3\2\2\2\u0106"+
		"\u0107\3\2\2\2\u0107\27\3\2\2\2\u0108\u0106\3\2\2\2\u0109\u010b\5\34\17"+
		"\2\u010a\u010c\5 \21\2\u010b\u010a\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u0112"+
		"\3\2\2\2\u010d\u010f\5$\23\2\u010e\u0110\5 \21\2\u010f\u010e\3\2\2\2\u010f"+
		"\u0110\3\2\2\2\u0110\u0112\3\2\2\2\u0111\u0109\3\2\2\2\u0111\u010d\3\2"+
		"\2\2\u0112\31\3\2\2\2\u0113\u0116\5\34\17\2\u0114\u0116\5$\23\2\u0115"+
		"\u0113\3\2\2\2\u0115\u0114\3\2\2\2\u0116\33\3\2\2\2\u0117\u0118\t\3\2"+
		"\2\u0118\35\3\2\2\2\u0119\u011b\5$\23\2\u011a\u011c\5 \21\2\u011b\u011a"+
		"\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u0121\3\2\2\2\u011d\u011e\5\34\17\2"+
		"\u011e\u011f\5 \21\2\u011f\u0121\3\2\2\2\u0120\u0119\3\2\2\2\u0120\u011d"+
		"\3\2\2\2\u0121\37\3\2\2\2\u0122\u0123\7+\2\2\u0123\u0128\7,\2\2\u0124"+
		"\u0125\7+\2\2\u0125\u0127\7,\2\2\u0126\u0124\3\2\2\2\u0127\u012a\3\2\2"+
		"\2\u0128\u0126\3\2\2\2\u0128\u0129\3\2\2\2\u0129!\3\2\2\2\u012a\u0128"+
		"\3\2\2\2\u012b\u0130\5x=\2\u012c\u012d\7-\2\2\u012d\u012f\5x=\2\u012e"+
		"\u012c\3\2\2\2\u012f\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0130\u0131\3\2"+
		"\2\2\u0131#\3\2\2\2\u0132\u0130\3\2\2\2\u0133\u0138\5x=\2\u0134\u0135"+
		"\7-\2\2\u0135\u0137\5x=\2\u0136\u0134\3\2\2\2\u0137\u013a\3\2\2\2\u0138"+
		"\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138\3\2"+
		"\2\2\u013b\u013d\5&\24\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2\u013d"+
		"%\3\2\2\2\u013e\u0140\7\65\2\2\u013f\u0141\5(\25\2\u0140\u013f\3\2\2\2"+
		"\u0140\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142\u0144\t\4\2\2\u0143\u0142"+
		"\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0147\7\67\2\2"+
		"\u0146\u013e\3\2\2\2\u0146\u0145\3\2\2\2\u0147\'\3\2\2\2\u0148\u014d\5"+
		"*\26\2\u0149\u014a\7\60\2\2\u014a\u014c\5*\26\2\u014b\u0149\3\2\2\2\u014c"+
		"\u014f\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e)\3\2\2\2"+
		"\u014f\u014d\3\2\2\2\u0150\u0153\5\36\20\2\u0151\u0153\5,\27\2\u0152\u0150"+
		"\3\2\2\2\u0152\u0151\3\2\2\2\u0153+\3\2\2\2\u0154\u0156\7\61\2\2\u0155"+
		"\u0157\5.\30\2\u0156\u0155\3\2\2\2\u0156\u0157\3\2\2\2\u0157-\3\2\2\2"+
		"\u0158\u0159\7\32\2\2\u0159\u015d\5\36\20\2\u015a\u015b\7\33\2\2\u015b"+
		"\u015d\5\36\20\2\u015c\u0158\3\2\2\2\u015c\u015a\3\2\2\2\u015d/\3\2\2"+
		"\2\u015e\u015f\5\62\32\2\u015f\u0160\5t;\2\u0160\u0161\5\60\31\2\u0161"+
		"\u0164\3\2\2\2\u0162\u0164\5\64\33\2\u0163\u015e\3\2\2\2\u0163\u0162\3"+
		"\2\2\2\u0164\61\3\2\2\2\u0165\u0169\5x=\2\u0166\u0168\5\\/\2\u0167\u0166"+
		"\3\2\2\2\u0168\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016a"+
		"\63\3\2\2\2\u016b\u0169\3\2\2\2\u016c\u0172\5\66\34\2\u016d\u016e\7\61"+
		"\2\2\u016e\u016f\5\66\34\2\u016f\u0170\7\62\2\2\u0170\u0171\5\60\31\2"+
		"\u0171\u0173\3\2\2\2\u0172\u016d\3\2\2\2\u0172\u0173\3\2\2\2\u0173\65"+
		"\3\2\2\2\u0174\u0179\5<\37\2\u0175\u0176\6\34\2\3\u0176\u0178\58\35\2"+
		"\u0177\u0175\3\2\2\2\u0178\u017b\3\2\2\2\u0179\u0177\3\2\2\2\u0179\u017a"+
		"\3\2\2\2\u017a\67\3\2\2\2\u017b\u0179\3\2\2\2\u017c\u017d\5:\36\2\u017d"+
		"\u017e\5\66\34\2\u017e9\3\2\2\2\u017f\u0182\5v<\2\u0180\u0182\5x=\2\u0181"+
		"\u017f\3\2\2\2\u0181\u0180\3\2\2\2\u0182;\3\2\2\2\u0183\u0185\5> \2\u0184"+
		"\u0183\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u018a\5B"+
		"\"\2\u0187\u0189\5\\/\2\u0188\u0187\3\2\2\2\u0189\u018c\3\2\2\2\u018a"+
		"\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2"+
		"\2\2\u018d\u018f\5@!\2\u018e\u018d\3\2\2\2\u018e\u018f\3\2\2\2\u018f="+
		"\3\2\2\2\u0190\u0191\6 \3\2\u0191\u0192\5v<\2\u0192?\3\2\2\2\u0193\u0194"+
		"\6!\4\2\u0194\u0195\5v<\2\u0195A\3\2\2\2\u0196\u01f1\5d\63\2\u0197\u0198"+
		"\7\'\2\2\u0198\u0199\5\30\r\2\u0199\u019a\7(\2\2\u019a\u019b\5<\37\2\u019b"+
		"\u01f1\3\2\2\2\u019c\u019d\7\'\2\2\u019d\u019e\5\60\31\2\u019e\u019f\7"+
		"(\2\2\u019f\u01f1\3\2\2\2\u01a0\u01a1\7\16\2\2\u01a1\u01a6\5x=\2\u01a2"+
		"\u01a3\7-\2\2\u01a3\u01a5\5x=\2\u01a4\u01a2\3\2\2\2\u01a5\u01a8\3\2\2"+
		"\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8\u01a6"+
		"\3\2\2\2\u01a9\u01ab\5&\24\2\u01aa\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab"+
		"\u01ac\3\2\2\2\u01ac\u01ae\7\'\2\2\u01ad\u01af\5b\62\2\u01ae\u01ad\3\2"+
		"\2\2\u01ae\u01af\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\7(\2\2\u01b1"+
		"\u01f1\3\2\2\2\u01b2\u01b3\7\16\2\2\u01b3\u01b4\5\32\16\2\u01b4\u01b5"+
		"\5H%\2\u01b5\u01f1\3\2\2\2\u01b6\u01b7\7\16\2\2\u01b7\u01b8\5\32\16\2"+
		"\u01b8\u01b9\5 \21\2\u01b9\u01ba\5\24\13\2\u01ba\u01f1\3\2\2\2\u01bb\u01bc"+
		"\5l\67\2\u01bc\u01c3\7.\2\2\u01bd\u01bf\7)\2\2\u01be\u01c0\5\4\3\2\u01bf"+
		"\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c4\7*"+
		"\2\2\u01c2\u01c4\5\60\31\2\u01c3\u01bd\3\2\2\2\u01c3\u01c2\3\2\2\2\u01c4"+
		"\u01f1\3\2\2\2\u01c5\u01f1\5x=\2\u01c6\u01f1\5\34\17\2\u01c7\u01c9\7+"+
		"\2\2\u01c8\u01ca\5F$\2\u01c9\u01c8\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb"+
		"\3\2\2\2\u01cb\u01f1\7,\2\2\u01cc\u01cd\7)\2\2\u01cd\u01ce\5R*\2\u01ce"+
		"\u01cf\7*\2\2\u01cf\u01f1\3\2\2\2\u01d0\u01d2\7)\2\2\u01d1\u01d3\5\4\3"+
		"\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01f1"+
		"\7*\2\2\u01d5\u01d6\7\4\2\2\u01d6\u01d7\7\'\2\2\u01d7\u01d8\5\60\31\2"+
		"\u01d8\u01da\7(\2\2\u01d9\u01db\7 \2\2\u01da\u01d9\3\2\2\2\u01da\u01db"+
		"\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01df\5D#\2\u01dd\u01de\7\5\2\2\u01de"+
		"\u01e0\5D#\2\u01df\u01dd\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01f1\3\2\2"+
		"\2\u01e1\u01e2\7\34\2\2\u01e2\u01e4\7)\2\2\u01e3\u01e5\5\4\3\2\u01e4\u01e3"+
		"\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01e8\7*\2\2\u01e7"+
		"\u01e9\5J&\2\u01e8\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01eb\3\2\2"+
		"\2\u01ea\u01ec\5P)\2\u01eb\u01ea\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01f1"+
		"\3\2\2\2\u01ed\u01ee\7]\2\2\u01ee\u01ef\7b\2\2\u01ef\u01f1\7*\2\2\u01f0"+
		"\u0196\3\2\2\2\u01f0\u0197\3\2\2\2\u01f0\u019c\3\2\2\2\u01f0\u01a0\3\2"+
		"\2\2\u01f0\u01b2\3\2\2\2\u01f0\u01b6\3\2\2\2\u01f0\u01bb\3\2\2\2\u01f0"+
		"\u01c5\3\2\2\2\u01f0\u01c6\3\2\2\2\u01f0\u01c7\3\2\2\2\u01f0\u01cc\3\2"+
		"\2\2\u01f0\u01d0\3\2\2\2\u01f0\u01d5\3\2\2\2\u01f0\u01e1\3\2\2\2\u01f0"+
		"\u01ed\3\2\2\2\u01f1C\3\2\2\2\u01f2\u01f4\7)\2\2\u01f3\u01f5\5\4\3\2\u01f4"+
		"\u01f3\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f9\7*"+
		"\2\2\u01f7\u01f9\5\6\4\2\u01f8\u01f2\3\2\2\2\u01f8\u01f7\3\2\2\2\u01f9"+
		"E\3\2\2\2\u01fa\u01ff\5\60\31\2\u01fb\u01fc\7\60\2\2\u01fc\u01fe\5\60"+
		"\31\2\u01fd\u01fb\3\2\2\2\u01fe\u0201\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff"+
		"\u0200\3\2\2\2\u0200G\3\2\2\2\u0201\u01ff\3\2\2\2\u0202\u0203\7+\2\2\u0203"+
		"\u0204\5\60\31\2\u0204\u020b\7,\2\2\u0205\u0206\7+\2\2\u0206\u0207\5\60"+
		"\31\2\u0207\u0208\7,\2\2\u0208\u020a\3\2\2\2\u0209\u0205\3\2\2\2\u020a"+
		"\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020cI\3\2\2\2"+
		"\u020d\u020b\3\2\2\2\u020e\u0212\5L\'\2\u020f\u0211\5L\'\2\u0210\u020f"+
		"\3\2\2\2\u0211\u0214\3\2\2\2\u0212\u0210\3\2\2\2\u0212\u0213\3\2\2\2\u0213"+
		"K\3\2\2\2\u0214\u0212\3\2\2\2\u0215\u0216\7\35\2\2\u0216\u0217\7\'\2\2"+
		"\u0217\u0218\5N(\2\u0218\u0219\7(\2\2\u0219\u021b\7)\2\2\u021a\u021c\5"+
		"\4\3\2\u021b\u021a\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021d\3\2\2\2\u021d"+
		"\u021e\7*\2\2\u021eM\3\2\2\2\u021f\u0224\5\30\r\2\u0220\u0221\7S\2\2\u0221"+
		"\u0223\5\30\r\2\u0222\u0220\3\2\2\2\u0223\u0226\3\2\2\2\u0224\u0222\3"+
		"\2\2\2\u0224\u0225\3\2\2\2\u0225\u0228\3\2\2\2\u0226\u0224\3\2\2\2\u0227"+
		"\u021f\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022a\5x"+
		"=\2\u022aO\3\2\2\2\u022b\u022c\7\36\2\2\u022c\u022e\7)\2\2\u022d\u022f"+
		"\5\4\3\2\u022e\u022d\3\2\2\2\u022e\u022f\3\2\2\2\u022f\u0230\3\2\2\2\u0230"+
		"\u0231\7*\2\2\u0231Q\3\2\2\2\u0232\u023f\7\62\2\2\u0233\u0238\5T+\2\u0234"+
		"\u0235\7\60\2\2\u0235\u0237\5T+\2\u0236\u0234\3\2\2\2\u0237\u023a\3\2"+
		"\2\2\u0238\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239\u023c\3\2\2\2\u023a"+
		"\u0238\3\2\2\2\u023b\u023d\7\60\2\2\u023c\u023b\3\2\2\2\u023c\u023d\3"+
		"\2\2\2\u023d\u023f\3\2\2\2\u023e\u0232\3\2\2\2\u023e\u0233\3\2\2\2\u023f"+
		"S\3\2\2\2\u0240\u0241\5X-\2\u0241\u0242\7\62\2\2\u0242\u0243\5V,\2\u0243"+
		"U\3\2\2\2\u0244\u0245\6,\5\2\u0245\u0248\7#\2\2\u0246\u0248\5\60\31\2"+
		"\u0247\u0244\3\2\2\2\u0247\u0246\3\2\2\2\u0248W\3\2\2\2\u0249\u024d\5"+
		"Z.\2\u024a\u024d\5f\64\2\u024b\u024d\7#\2\2\u024c\u0249\3\2\2\2\u024c"+
		"\u024a\3\2\2\2\u024c\u024b\3\2\2\2\u024dY\3\2\2\2\u024e\u026f\5x=\2\u024f"+
		"\u026f\7\3\2\2\u0250\u026f\7\4\2\2\u0251\u026f\7\5\2\2\u0252\u026f\7\6"+
		"\2\2\u0253\u026f\7\7\2\2\u0254\u026f\7\b\2\2\u0255\u026f\7\t\2\2\u0256"+
		"\u026f\7\n\2\2\u0257\u026f\7\13\2\2\u0258\u026f\7\f\2\2\u0259\u026f\7"+
		"\r\2\2\u025a\u026f\7\16\2\2\u025b\u026f\7\17\2\2\u025c\u026f\7\20\2\2"+
		"\u025d\u026f\7\21\2\2\u025e\u026f\7\22\2\2\u025f\u026f\7\23\2\2\u0260"+
		"\u026f\7\24\2\2\u0261\u026f\7\25\2\2\u0262\u026f\7\26\2\2\u0263\u026f"+
		"\7\27\2\2\u0264\u026f\7\30\2\2\u0265\u026f\7\31\2\2\u0266\u026f\7\32\2"+
		"\2\u0267\u026f\7\33\2\2\u0268\u026f\7\34\2\2\u0269\u026f\7\35\2\2\u026a"+
		"\u026f\7\36\2\2\u026b\u026f\7\37\2\2\u026c\u026f\7!\2\2\u026d\u026f\7"+
		"\"\2\2\u026e\u024e\3\2\2\2\u026e\u024f\3\2\2\2\u026e\u0250\3\2\2\2\u026e"+
		"\u0251\3\2\2\2\u026e\u0252\3\2\2\2\u026e\u0253\3\2\2\2\u026e\u0254\3\2"+
		"\2\2\u026e\u0255\3\2\2\2\u026e\u0256\3\2\2\2\u026e\u0257\3\2\2\2\u026e"+
		"\u0258\3\2\2\2\u026e\u0259\3\2\2\2\u026e\u025a\3\2\2\2\u026e\u025b\3\2"+
		"\2\2\u026e\u025c\3\2\2\2\u026e\u025d\3\2\2\2\u026e\u025e\3\2\2\2\u026e"+
		"\u025f\3\2\2\2\u026e\u0260\3\2\2\2\u026e\u0261\3\2\2\2\u026e\u0262\3\2"+
		"\2\2\u026e\u0263\3\2\2\2\u026e\u0264\3\2\2\2\u026e\u0265\3\2\2\2\u026e"+
		"\u0266\3\2\2\2\u026e\u0267\3\2\2\2\u026e\u0268\3\2\2\2\u026e\u0269\3\2"+
		"\2\2\u026e\u026a\3\2\2\2\u026e\u026b\3\2\2\2\u026e\u026c\3\2\2\2\u026e"+
		"\u026d\3\2\2\2\u026f[\3\2\2\2\u0270\u0271\7-\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\u029f\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\u029f\3\2\2\2\u0280\u0281\7;\2\2\u0281\u0282\5x=\2\u0282"+
		"\u0284\7\'\2\2\u0283\u0285\5b\62\2\u0284\u0283\3\2\2\2\u0284\u0285\3\2"+
		"\2\2\u0285\u0286\3\2\2\2\u0286\u0287\7(\2\2\u0287\u029f\3\2\2\2\u0288"+
		"\u0289\7-\2\2\u0289\u029f\5^\60\2\u028a\u028b\7:\2\2\u028b\u029f\5^\60"+
		"\2\u028c\u028d\7;\2\2\u028d\u029f\5^\60\2\u028e\u028f\7\63\2\2\u028f\u029f"+
		"\5x=\2\u0290\u0292\7\'\2\2\u0291\u0293\5b\62\2\u0292\u0291\3\2\2\2\u0292"+
		"\u0293\3\2\2\2\u0293\u0294\3\2\2\2\u0294\u029f\7(\2\2\u0295\u0297\7+\2"+
		"\2\u0296\u0298\5`\61\2\u0297\u0296\3\2\2\2\u0297\u0298\3\2\2\2\u0298\u0299"+
		"\3\2\2\2\u0299\u029f\7,\2\2\u029a\u029b\6/\6\2\u029b\u029c\5v<\2\u029c"+
		"\u029d\5x=\2\u029d\u029f\3\2\2\2\u029e\u0270\3\2\2\2\u029e\u0278\3\2\2"+
		"\2\u029e\u0280\3\2\2\2\u029e\u0288\3\2\2\2\u029e\u028a\3\2\2\2\u029e\u028c"+
		"\3\2\2\2\u029e\u028e\3\2\2\2\u029e\u0290\3\2\2\2\u029e\u0295\3\2\2\2\u029e"+
		"\u029a\3\2\2\2\u029f]\3\2\2\2\u02a0\u02a4\5x=\2\u02a1\u02a4\7!\2\2\u02a2"+
		"\u02a4\7#\2\2\u02a3\u02a0\3\2\2\2\u02a3\u02a1\3\2\2\2\u02a3\u02a2\3\2"+
		"\2\2\u02a4_\3\2\2\2\u02a5\u02ae\5\60\31\2\u02a6\u02a8\5\60\31\2\u02a7"+
		"\u02a6\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\u02ab\7\62"+
		"\2\2\u02aa\u02ac\5\60\31\2\u02ab\u02aa\3\2\2\2\u02ab\u02ac\3\2\2\2\u02ac"+
		"\u02ae\3\2\2\2\u02ad\u02a5\3\2\2\2\u02ad\u02a7\3\2\2\2\u02aea\3\2\2\2"+
		"\u02af\u02b4\5\60\31\2\u02b0\u02b1\7\60\2\2\u02b1\u02b3\5\60\31\2\u02b2"+
		"\u02b0\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b4\u02b5\3\2"+
		"\2\2\u02b5c\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b7\u02bf\7$\2\2\u02b8\u02bf"+
		"\7%\2\2\u02b9\u02bf\7&\2\2\u02ba\u02bf\5j\66\2\u02bb\u02bf\7#\2\2\u02bc"+
		"\u02bf\5f\64\2\u02bd\u02bf\7\27\2\2\u02be\u02b7\3\2\2\2\u02be\u02b8\3"+
		"\2\2\2\u02be\u02b9\3\2\2\2\u02be\u02ba\3\2\2\2\u02be\u02bb\3\2\2\2\u02be"+
		"\u02bc\3\2\2\2\u02be\u02bd\3\2\2\2\u02bfe\3\2\2\2\u02c0\u02c5\7\\\2\2"+
		"\u02c1\u02c4\7`\2\2\u02c2\u02c4\5h\65\2\u02c3\u02c1\3\2\2\2\u02c3\u02c2"+
		"\3\2\2\2\u02c4\u02c7\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6"+
		"\u02c8\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c8\u02c9\7a\2\2\u02c9g\3\2\2\2\u02ca"+
		"\u02cb\6\65\7\2\u02cb\u02cc\7_\2\2\u02cc\u02cd\5\60\31\2\u02cd\u02ce\7"+
		"*\2\2\u02ce\u02d4\3\2\2\2\u02cf\u02d0\6\65\b\2\u02d0\u02d1\7_\2\2\u02d1"+
		"\u02d2\7b\2\2\u02d2\u02d4\7*\2\2\u02d3\u02ca\3\2\2\2\u02d3\u02cf\3\2\2"+
		"\2\u02d4i\3\2\2\2\u02d5\u02d6\t\5\2\2\u02d6k\3\2\2\2\u02d7\u02de\5x=\2"+
		"\u02d8\u02da\7\'\2\2\u02d9\u02db\5n8\2\u02da\u02d9\3\2\2\2\u02da\u02db"+
		"\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u02de\7(\2\2\u02dd\u02d7\3\2\2\2\u02dd"+
		"\u02d8\3\2\2\2\u02dem\3\2\2\2\u02df\u02e4\5p9\2\u02e0\u02e1\7\60\2\2\u02e1"+
		"\u02e3\5p9\2\u02e2\u02e0\3\2\2\2\u02e3\u02e6\3\2\2\2\u02e4\u02e2\3\2\2"+
		"\2\u02e4\u02e5\3\2\2\2\u02e5o\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e7\u02e9"+
		"\5\30\r\2\u02e8\u02e7\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u02ea\3\2\2\2"+
		"\u02ea\u02eb\5x=\2\u02ebq\3\2\2\2\u02ec\u02ed\7\f\2\2\u02ed\u02f2\5x="+
		"\2\u02ee\u02ef\7-\2\2\u02ef\u02f1\5x=\2\u02f0\u02ee\3\2\2\2\u02f1\u02f4"+
		"\3\2\2\2\u02f2\u02f0\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f5\3\2\2\2\u02f4"+
		"\u02f2\3\2\2\2\u02f5\u02f6\7/\2\2\u02f6\u0308\3\2\2\2\u02f7\u02f8\7\f"+
		"\2\2\u02f8\u02fd\5x=\2\u02f9\u02fa\7-\2\2\u02fa\u02fc\5x=\2\u02fb\u02f9"+
		"\3\2\2\2\u02fc\u02ff\3\2\2\2\u02fd\u02fb\3\2\2\2\u02fd\u02fe\3\2\2\2\u02fe"+
		"\u0303\3\2\2\2\u02ff\u02fd\3\2\2\2\u0300\u0301\7-\2\2\u0301\u0304\7P\2"+
		"\2\u0302\u0304\7B\2\2\u0303\u0300\3\2\2\2\u0303\u0302\3\2\2\2\u0304\u0305"+
		"\3\2\2\2\u0305\u0306\7/\2\2\u0306\u0308\3\2\2\2\u0307\u02ec\3\2\2\2\u0307"+
		"\u02f7\3\2\2\2\u0308s\3\2\2\2\u0309\u030a\t\6\2\2\u030au\3\2\2\2\u030b"+
		"\u0323\7\64\2\2\u030c\u0323\7\65\2\2\u030d\u0323\7@\2\2\u030e\u0323\7"+
		"A\2\2\u030f\u0323\7L\2\2\u0310\u0323\7M\2\2\u0311\u0323\7N\2\2\u0312\u0323"+
		"\7O\2\2\u0313\u0323\7P\2\2\u0314\u0323\7Q\2\2\u0315\u0323\7U\2\2\u0316"+
		"\u0323\7V\2\2\u0317\u0323\7B\2\2\u0318\u0323\7\67\2\2\u0319\u0323\79\2"+
		"\2\u031a\u0323\7=\2\2\u031b\u0323\7?\2\2\u031c\u0323\7R\2\2\u031d\u0323"+
		"\7S\2\2\u031e\u0323\7T\2\2\u031f\u0323\7C\2\2\u0320\u0323\5t;\2\u0321"+
		"\u0323\7Z\2\2\u0322\u030b\3\2\2\2\u0322\u030c\3\2\2\2\u0322\u030d\3\2"+
		"\2\2\u0322\u030e\3\2\2\2\u0322\u030f\3\2\2\2\u0322\u0310\3\2\2\2\u0322"+
		"\u0311\3\2\2\2\u0322\u0312\3\2\2\2\u0322\u0313\3\2\2\2\u0322\u0314\3\2"+
		"\2\2\u0322\u0315\3\2\2\2\u0322\u0316\3\2\2\2\u0322\u0317\3\2\2\2\u0322"+
		"\u0318\3\2\2\2\u0322\u0319\3\2\2\2\u0322\u031a\3\2\2\2\u0322\u031b\3\2"+
		"\2\2\u0322\u031c\3\2\2\2\u0322\u031d\3\2\2\2\u0322\u031e\3\2\2\2\u0322"+
		"\u031f\3\2\2\2\u0322\u0320\3\2\2\2\u0322\u0321\3\2\2\2\u0323w\3\2\2\2"+
		"\u0324\u0325\t\7\2\2\u0325y\3\2\2\2f}\u0081\u0088\u0090\u009c\u00a0\u00a8"+
		"\u00b4\u00b9\u00c1\u00c7\u00cb\u00ce\u00d3\u00d5\u00e1\u00e8\u00ee\u00f2"+
		"\u00f6\u00fa\u00fd\u0106\u010b\u010f\u0111\u0115\u011b\u0120\u0128\u0130"+
		"\u0138\u013c\u0140\u0143\u0146\u014d\u0152\u0156\u015c\u0163\u0169\u0172"+
		"\u0179\u0181\u0184\u018a\u018e\u01a6\u01aa\u01ae\u01bf\u01c3\u01c9\u01d2"+
		"\u01da\u01df\u01e4\u01e8\u01eb\u01f0\u01f4\u01f8\u01ff\u020b\u0212\u021b"+
		"\u0224\u0227\u022e\u0238\u023c\u023e\u0247\u024c\u026e\u0274\u027c\u0284"+
		"\u0292\u0297\u029e\u02a3\u02a7\u02ab\u02ad\u02b4\u02be\u02c3\u02c5\u02d3"+
		"\u02da\u02dd\u02e4\u02e8\u02f2\u02fd\u0303\u0307\u0322";
	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);
		}
	}
}