• Home
• com.abubusoft
• kripton-sqlite-test-library
• 6.0.0-rc.5
• source code
• JqlParser.java

×

Project download

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

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

com.abubusoft.kripton.processor.sqlite.grammars.jsql.JqlParser Maven / Gradle / Ivy

// Generated from com\abubusoft\kripton\processor\sqlite\grammars\jsql\Jql.g4 by ANTLR 4.7.1
package com.abubusoft.kripton.processor.sqlite.grammars.jsql;
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 JqlParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, SCOL=5, DOT=6, OPEN_PAR=7, CLOSE_PAR=8, 
		COMMA=9, ASSIGN=10, STAR=11, PLUS=12, MINUS=13, TILDE=14, PIPE2=15, DIV=16, 
		MOD=17, LT2=18, GT2=19, AMP=20, PIPE=21, LT=22, LT_EQ=23, GT=24, GT_EQ=25, 
		EQ=26, NOT_EQ1=27, NOT_EQ2=28, K_ABORT=29, K_ACTION=30, K_ADD=31, K_AFTER=32, 
		K_ALL=33, K_ALTER=34, K_ANALYZE=35, K_AND=36, K_AS=37, K_ASC=38, K_ATTACH=39, 
		K_AUTOINCREMENT=40, K_BEFORE=41, K_BEGIN=42, K_BETWEEN=43, K_BY=44, K_CASCADE=45, 
		K_CASE=46, K_CAST=47, K_CHECK=48, K_COLLATE=49, K_COLUMN=50, K_COMMIT=51, 
		K_CONFLICT=52, K_CONSTRAINT=53, K_CREATE=54, K_CROSS=55, K_CURRENT_DATE=56, 
		K_CURRENT_TIME=57, K_CURRENT_TIMESTAMP=58, K_DATABASE=59, K_DEFAULT=60, 
		K_DEFERRABLE=61, K_DEFERRED=62, K_DELETE=63, K_DESC=64, K_DETACH=65, K_DISTINCT=66, 
		K_DROP=67, K_EACH=68, K_ELSE=69, K_END=70, K_ESCAPE=71, K_EXCEPT=72, K_EXCLUSIVE=73, 
		K_EXISTS=74, K_EXPLAIN=75, K_FAIL=76, K_FOR=77, K_FOREIGN=78, K_FROM=79, 
		K_FULL=80, K_GLOB=81, K_GROUP=82, K_HAVING=83, K_IF=84, K_IGNORE=85, K_IMMEDIATE=86, 
		K_IN=87, K_INDEX=88, K_INDEXED=89, K_INITIALLY=90, K_INNER=91, K_INSERT=92, 
		K_INSTEAD=93, K_INTERSECT=94, K_INTO=95, K_IS=96, K_ISNULL=97, K_JOIN=98, 
		K_KEY=99, K_LEFT=100, K_LIKE=101, K_LIMIT=102, K_MATCH=103, K_NATURAL=104, 
		K_NO=105, K_NOT=106, K_NOTNULL=107, K_NULL=108, K_OF=109, K_OFFSET=110, 
		K_ON=111, K_OR=112, K_ORDER=113, K_OUTER=114, K_PLAN=115, K_PRAGMA=116, 
		K_PRIMARY=117, K_QUERY=118, K_RAISE=119, K_RECURSIVE=120, K_REFERENCES=121, 
		K_REGEXP=122, K_REINDEX=123, K_RELEASE=124, K_RENAME=125, K_REPLACE=126, 
		K_RESTRICT=127, K_RIGHT=128, K_ROLLBACK=129, K_ROW=130, K_SAVEPOINT=131, 
		K_SELECT=132, K_SET=133, K_TABLE=134, K_TEMP=135, K_TEMPORARY=136, K_THEN=137, 
		K_TO=138, K_TRANSACTION=139, K_TRIGGER=140, K_UNION=141, K_UNIQUE=142, 
		K_UPDATE=143, K_USING=144, K_VACUUM=145, K_VALUES=146, K_VIEW=147, K_VIRTUAL=148, 
		K_WHEN=149, K_WHERE=150, K_WITH=151, K_WITHOUT=152, IDENTIFIER=153, NUMERIC_LITERAL=154, 
		BIND_PARAMETER=155, STRING_LITERAL=156, BLOB_LITERAL=157, SINGLE_LINE_COMMENT=158, 
		MULTILINE_COMMENT=159, SPACES=160, UNEXPECTED_CHAR=161;
	public static final int
		RULE_parse = 0, RULE_parse_variable = 1, RULE_error = 2, RULE_sql_stmt_list = 3, 
		RULE_sql_stmt = 4, RULE_alter_table_stmt = 5, RULE_analyze_stmt = 6, RULE_attach_stmt = 7, 
		RULE_begin_stmt = 8, RULE_commit_stmt = 9, RULE_compound_select_stmt = 10, 
		RULE_create_index_stmt = 11, RULE_create_table_stmt = 12, RULE_create_trigger_stmt = 13, 
		RULE_create_view_stmt = 14, RULE_create_virtual_table_stmt = 15, RULE_delete_stmt = 16, 
		RULE_delete_stmt_limited = 17, RULE_detach_stmt = 18, RULE_drop_index_stmt = 19, 
		RULE_drop_table_stmt = 20, RULE_drop_trigger_stmt = 21, RULE_drop_view_stmt = 22, 
		RULE_factored_select_stmt = 23, RULE_insert_stmt = 24, RULE_column_name_set = 25, 
		RULE_column_value_set = 26, RULE_limit_stmt = 27, RULE_pragma_stmt = 28, 
		RULE_reindex_stmt = 29, RULE_release_stmt = 30, RULE_rollback_stmt = 31, 
		RULE_savepoint_stmt = 32, RULE_simple_select_stmt = 33, RULE_select_stmt = 34, 
		RULE_select_or_values = 35, RULE_update_stmt = 36, RULE_conflict_algorithm = 37, 
		RULE_update_stmt_limited = 38, RULE_vacuum_stmt = 39, RULE_column_def = 40, 
		RULE_type_name = 41, RULE_column_constraint = 42, RULE_conflict_clause = 43, 
		RULE_expr = 44, RULE_bind_parameter = 45, RULE_bind_parameter_name = 46, 
		RULE_bind_dynamic_sql = 47, RULE_foreign_key_clause = 48, RULE_raise_function = 49, 
		RULE_indexed_column = 50, RULE_table_constraint = 51, RULE_with_clause = 52, 
		RULE_where_stmt = 53, RULE_where_stmt_clauses = 54, RULE_qualified_table_name = 55, 
		RULE_offset_stmt = 56, RULE_order_stmt = 57, RULE_ordering_term = 58, 
		RULE_pragma_value = 59, RULE_common_table_expression = 60, RULE_result_column = 61, 
		RULE_table_or_subquery = 62, RULE_join_clause = 63, RULE_join_operator = 64, 
		RULE_join_constraint = 65, RULE_select_core = 66, RULE_compound_operator = 67, 
		RULE_cte_table_name = 68, RULE_signed_number = 69, RULE_literal_value = 70, 
		RULE_unary_operator = 71, RULE_error_message = 72, RULE_module_argument = 73, 
		RULE_column_alias = 74, RULE_keyword = 75, RULE_name = 76, RULE_function_name = 77, 
		RULE_group_stmt = 78, RULE_having_stmt = 79, RULE_database_name = 80, 
		RULE_table_name = 81, RULE_table_or_index_name = 82, RULE_new_table_name = 83, 
		RULE_column_name = 84, RULE_column_name_to_update = 85, RULE_collation_name = 86, 
		RULE_foreign_table = 87, RULE_index_name = 88, RULE_trigger_name = 89, 
		RULE_view_name = 90, RULE_module_name = 91, RULE_pragma_name = 92, RULE_projected_columns = 93, 
		RULE_savepoint_name = 94, RULE_table_alias = 95, RULE_transaction_name = 96, 
		RULE_any_name = 97;
	public static final String[] ruleNames = {
		"parse", "parse_variable", "error", "sql_stmt_list", "sql_stmt", "alter_table_stmt", 
		"analyze_stmt", "attach_stmt", "begin_stmt", "commit_stmt", "compound_select_stmt", 
		"create_index_stmt", "create_table_stmt", "create_trigger_stmt", "create_view_stmt", 
		"create_virtual_table_stmt", "delete_stmt", "delete_stmt_limited", "detach_stmt", 
		"drop_index_stmt", "drop_table_stmt", "drop_trigger_stmt", "drop_view_stmt", 
		"factored_select_stmt", "insert_stmt", "column_name_set", "column_value_set", 
		"limit_stmt", "pragma_stmt", "reindex_stmt", "release_stmt", "rollback_stmt", 
		"savepoint_stmt", "simple_select_stmt", "select_stmt", "select_or_values", 
		"update_stmt", "conflict_algorithm", "update_stmt_limited", "vacuum_stmt", 
		"column_def", "type_name", "column_constraint", "conflict_clause", "expr", 
		"bind_parameter", "bind_parameter_name", "bind_dynamic_sql", "foreign_key_clause", 
		"raise_function", "indexed_column", "table_constraint", "with_clause", 
		"where_stmt", "where_stmt_clauses", "qualified_table_name", "offset_stmt", 
		"order_stmt", "ordering_term", "pragma_value", "common_table_expression", 
		"result_column", "table_or_subquery", "join_clause", "join_operator", 
		"join_constraint", "select_core", "compound_operator", "cte_table_name", 
		"signed_number", "literal_value", "unary_operator", "error_message", "module_argument", 
		"column_alias", "keyword", "name", "function_name", "group_stmt", "having_stmt", 
		"database_name", "table_name", "table_or_index_name", "new_table_name", 
		"column_name", "column_name_to_update", "collation_name", "foreign_table", 
		"index_name", "trigger_name", "view_name", "module_name", "pragma_name", 
		"projected_columns", "savepoint_name", "table_alias", "transaction_name", 
		"any_name"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'$'", "'{'", "'}'", "'#'", "';'", "'.'", "'('", "')'", "','", "'='", 
		"'*'", "'+'", "'-'", "'~'", "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", 
		"'|'", "'<'", "'<='", "'>'", "'>='", "'=='", "'!='", "'<>'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, null, null, null, null, "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", 
		"COMMA", "ASSIGN", "STAR", "PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", 
		"LT2", "GT2", "AMP", "PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", 
		"NOT_EQ2", "K_ABORT", "K_ACTION", "K_ADD", "K_AFTER", "K_ALL", "K_ALTER", 
		"K_ANALYZE", "K_AND", "K_AS", "K_ASC", "K_ATTACH", "K_AUTOINCREMENT", 
		"K_BEFORE", "K_BEGIN", "K_BETWEEN", "K_BY", "K_CASCADE", "K_CASE", "K_CAST", 
		"K_CHECK", "K_COLLATE", "K_COLUMN", "K_COMMIT", "K_CONFLICT", "K_CONSTRAINT", 
		"K_CREATE", "K_CROSS", "K_CURRENT_DATE", "K_CURRENT_TIME", "K_CURRENT_TIMESTAMP", 
		"K_DATABASE", "K_DEFAULT", "K_DEFERRABLE", "K_DEFERRED", "K_DELETE", "K_DESC", 
		"K_DETACH", "K_DISTINCT", "K_DROP", "K_EACH", "K_ELSE", "K_END", "K_ESCAPE", 
		"K_EXCEPT", "K_EXCLUSIVE", "K_EXISTS", "K_EXPLAIN", "K_FAIL", "K_FOR", 
		"K_FOREIGN", "K_FROM", "K_FULL", "K_GLOB", "K_GROUP", "K_HAVING", "K_IF", 
		"K_IGNORE", "K_IMMEDIATE", "K_IN", "K_INDEX", "K_INDEXED", "K_INITIALLY", 
		"K_INNER", "K_INSERT", "K_INSTEAD", "K_INTERSECT", "K_INTO", "K_IS", "K_ISNULL", 
		"K_JOIN", "K_KEY", "K_LEFT", "K_LIKE", "K_LIMIT", "K_MATCH", "K_NATURAL", 
		"K_NO", "K_NOT", "K_NOTNULL", "K_NULL", "K_OF", "K_OFFSET", "K_ON", "K_OR", 
		"K_ORDER", "K_OUTER", "K_PLAN", "K_PRAGMA", "K_PRIMARY", "K_QUERY", "K_RAISE", 
		"K_RECURSIVE", "K_REFERENCES", "K_REGEXP", "K_REINDEX", "K_RELEASE", "K_RENAME", 
		"K_REPLACE", "K_RESTRICT", "K_RIGHT", "K_ROLLBACK", "K_ROW", "K_SAVEPOINT", 
		"K_SELECT", "K_SET", "K_TABLE", "K_TEMP", "K_TEMPORARY", "K_THEN", "K_TO", 
		"K_TRANSACTION", "K_TRIGGER", "K_UNION", "K_UNIQUE", "K_UPDATE", "K_USING", 
		"K_VACUUM", "K_VALUES", "K_VIEW", "K_VIRTUAL", "K_WHEN", "K_WHERE", "K_WITH", 
		"K_WITHOUT", "IDENTIFIER", "NUMERIC_LITERAL", "BIND_PARAMETER", "STRING_LITERAL", 
		"BLOB_LITERAL", "SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES", 
		"UNEXPECTED_CHAR"
	};
	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 "Jql.g4"; }

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

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

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

	public JqlParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ParseContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(JqlParser.EOF, 0); }
		public List sql_stmt_list() {
			return getRuleContexts(Sql_stmt_listContext.class);
		}
		public Sql_stmt_listContext sql_stmt_list(int i) {
			return getRuleContext(Sql_stmt_listContext.class,i);
		}
		public List error() {
			return getRuleContexts(ErrorContext.class);
		}
		public ErrorContext error(int i) {
			return getRuleContext(ErrorContext.class,i);
		}
		public ParseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parse; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterParse(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitParse(this);
		}
	}

	public final ParseContext parse() throws RecognitionException {
		ParseContext _localctx = new ParseContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_parse);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(200);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SCOL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_ATTACH) | (1L << K_BEGIN) | (1L << K_COMMIT) | (1L << K_CREATE) | (1L << K_DELETE))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (K_DETACH - 65)) | (1L << (K_DROP - 65)) | (1L << (K_END - 65)) | (1L << (K_EXPLAIN - 65)) | (1L << (K_INSERT - 65)) | (1L << (K_PRAGMA - 65)) | (1L << (K_REINDEX - 65)) | (1L << (K_RELEASE - 65)) | (1L << (K_REPLACE - 65)))) != 0) || ((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (K_ROLLBACK - 129)) | (1L << (K_SAVEPOINT - 129)) | (1L << (K_SELECT - 129)) | (1L << (K_UPDATE - 129)) | (1L << (K_VACUUM - 129)) | (1L << (K_VALUES - 129)) | (1L << (K_WITH - 129)) | (1L << (UNEXPECTED_CHAR - 129)))) != 0)) {
				{
				setState(198);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case SCOL:
				case K_ALTER:
				case K_ANALYZE:
				case K_ATTACH:
				case K_BEGIN:
				case K_COMMIT:
				case K_CREATE:
				case K_DELETE:
				case K_DETACH:
				case K_DROP:
				case K_END:
				case K_EXPLAIN:
				case K_INSERT:
				case K_PRAGMA:
				case K_REINDEX:
				case K_RELEASE:
				case K_REPLACE:
				case K_ROLLBACK:
				case K_SAVEPOINT:
				case K_SELECT:
				case K_UPDATE:
				case K_VACUUM:
				case K_VALUES:
				case K_WITH:
					{
					setState(196);
					sql_stmt_list();
					}
					break;
				case UNEXPECTED_CHAR:
					{
					setState(197);
					error();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(202);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(203);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Parse_variableContext extends ParserRuleContext {
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Group_stmtContext group_stmt() {
			return getRuleContext(Group_stmtContext.class,0);
		}
		public Having_stmtContext having_stmt() {
			return getRuleContext(Having_stmtContext.class,0);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Parse_variableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parse_variable; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterParse_variable(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitParse_variable(this);
		}
	}

	public final Parse_variableContext parse_variable() throws RecognitionException {
		Parse_variableContext _localctx = new Parse_variableContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_parse_variable);
		try {
			setState(211);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_WHERE:
				enterOuterAlt(_localctx, 1);
				{
				setState(205);
				where_stmt();
				}
				break;
			case K_GROUP:
				enterOuterAlt(_localctx, 2);
				{
				setState(206);
				group_stmt();
				}
				break;
			case K_HAVING:
				enterOuterAlt(_localctx, 3);
				{
				setState(207);
				having_stmt();
				}
				break;
			case K_ORDER:
				enterOuterAlt(_localctx, 4);
				{
				setState(208);
				order_stmt();
				}
				break;
			case K_LIMIT:
				enterOuterAlt(_localctx, 5);
				{
				setState(209);
				limit_stmt();
				}
				break;
			case COMMA:
			case K_OFFSET:
				enterOuterAlt(_localctx, 6);
				{
				setState(210);
				offset_stmt();
				}
				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 ErrorContext extends ParserRuleContext {
		public Token UNEXPECTED_CHAR;
		public TerminalNode UNEXPECTED_CHAR() { return getToken(JqlParser.UNEXPECTED_CHAR, 0); }
		public ErrorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_error; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterError(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitError(this);
		}
	}

	public final ErrorContext error() throws RecognitionException {
		ErrorContext _localctx = new ErrorContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_error);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(213);
			((ErrorContext)_localctx).UNEXPECTED_CHAR = match(UNEXPECTED_CHAR);

			     throw new RuntimeException("UNEXPECTED_CHAR=" + (((ErrorContext)_localctx).UNEXPECTED_CHAR!=null?((ErrorContext)_localctx).UNEXPECTED_CHAR.getText():null));
			   
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Sql_stmt_listContext extends ParserRuleContext {
		public List sql_stmt() {
			return getRuleContexts(Sql_stmtContext.class);
		}
		public Sql_stmtContext sql_stmt(int i) {
			return getRuleContext(Sql_stmtContext.class,i);
		}
		public Sql_stmt_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sql_stmt_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSql_stmt_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSql_stmt_list(this);
		}
	}

	public final Sql_stmt_listContext sql_stmt_list() throws RecognitionException {
		Sql_stmt_listContext _localctx = new Sql_stmt_listContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_sql_stmt_list);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(219);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SCOL) {
				{
				{
				setState(216);
				match(SCOL);
				}
				}
				setState(221);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(222);
			sql_stmt();
			setState(231);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(224); 
					_errHandler.sync(this);
					_la = _input.LA(1);
					do {
						{
						{
						setState(223);
						match(SCOL);
						}
						}
						setState(226); 
						_errHandler.sync(this);
						_la = _input.LA(1);
					} while ( _la==SCOL );
					setState(228);
					sql_stmt();
					}
					} 
				}
				setState(233);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
			}
			setState(237);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(234);
					match(SCOL);
					}
					} 
				}
				setState(239);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Sql_stmtContext extends ParserRuleContext {
		public Alter_table_stmtContext alter_table_stmt() {
			return getRuleContext(Alter_table_stmtContext.class,0);
		}
		public Analyze_stmtContext analyze_stmt() {
			return getRuleContext(Analyze_stmtContext.class,0);
		}
		public Attach_stmtContext attach_stmt() {
			return getRuleContext(Attach_stmtContext.class,0);
		}
		public Begin_stmtContext begin_stmt() {
			return getRuleContext(Begin_stmtContext.class,0);
		}
		public Commit_stmtContext commit_stmt() {
			return getRuleContext(Commit_stmtContext.class,0);
		}
		public Compound_select_stmtContext compound_select_stmt() {
			return getRuleContext(Compound_select_stmtContext.class,0);
		}
		public Create_index_stmtContext create_index_stmt() {
			return getRuleContext(Create_index_stmtContext.class,0);
		}
		public Create_table_stmtContext create_table_stmt() {
			return getRuleContext(Create_table_stmtContext.class,0);
		}
		public Create_trigger_stmtContext create_trigger_stmt() {
			return getRuleContext(Create_trigger_stmtContext.class,0);
		}
		public Create_view_stmtContext create_view_stmt() {
			return getRuleContext(Create_view_stmtContext.class,0);
		}
		public Create_virtual_table_stmtContext create_virtual_table_stmt() {
			return getRuleContext(Create_virtual_table_stmtContext.class,0);
		}
		public Delete_stmtContext delete_stmt() {
			return getRuleContext(Delete_stmtContext.class,0);
		}
		public Delete_stmt_limitedContext delete_stmt_limited() {
			return getRuleContext(Delete_stmt_limitedContext.class,0);
		}
		public Detach_stmtContext detach_stmt() {
			return getRuleContext(Detach_stmtContext.class,0);
		}
		public Drop_index_stmtContext drop_index_stmt() {
			return getRuleContext(Drop_index_stmtContext.class,0);
		}
		public Drop_table_stmtContext drop_table_stmt() {
			return getRuleContext(Drop_table_stmtContext.class,0);
		}
		public Drop_trigger_stmtContext drop_trigger_stmt() {
			return getRuleContext(Drop_trigger_stmtContext.class,0);
		}
		public Drop_view_stmtContext drop_view_stmt() {
			return getRuleContext(Drop_view_stmtContext.class,0);
		}
		public Factored_select_stmtContext factored_select_stmt() {
			return getRuleContext(Factored_select_stmtContext.class,0);
		}
		public Insert_stmtContext insert_stmt() {
			return getRuleContext(Insert_stmtContext.class,0);
		}
		public Pragma_stmtContext pragma_stmt() {
			return getRuleContext(Pragma_stmtContext.class,0);
		}
		public Reindex_stmtContext reindex_stmt() {
			return getRuleContext(Reindex_stmtContext.class,0);
		}
		public Release_stmtContext release_stmt() {
			return getRuleContext(Release_stmtContext.class,0);
		}
		public Rollback_stmtContext rollback_stmt() {
			return getRuleContext(Rollback_stmtContext.class,0);
		}
		public Savepoint_stmtContext savepoint_stmt() {
			return getRuleContext(Savepoint_stmtContext.class,0);
		}
		public Simple_select_stmtContext simple_select_stmt() {
			return getRuleContext(Simple_select_stmtContext.class,0);
		}
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public Update_stmtContext update_stmt() {
			return getRuleContext(Update_stmtContext.class,0);
		}
		public Update_stmt_limitedContext update_stmt_limited() {
			return getRuleContext(Update_stmt_limitedContext.class,0);
		}
		public Vacuum_stmtContext vacuum_stmt() {
			return getRuleContext(Vacuum_stmtContext.class,0);
		}
		public TerminalNode K_EXPLAIN() { return getToken(JqlParser.K_EXPLAIN, 0); }
		public TerminalNode K_QUERY() { return getToken(JqlParser.K_QUERY, 0); }
		public TerminalNode K_PLAN() { return getToken(JqlParser.K_PLAN, 0); }
		public Sql_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sql_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSql_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSql_stmt(this);
		}
	}

	public final Sql_stmtContext sql_stmt() throws RecognitionException {
		Sql_stmtContext _localctx = new Sql_stmtContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_sql_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(245);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_EXPLAIN) {
				{
				setState(240);
				match(K_EXPLAIN);
				setState(243);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_QUERY) {
					{
					setState(241);
					match(K_QUERY);
					setState(242);
					match(K_PLAN);
					}
				}

				}
			}

			setState(277);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(247);
				alter_table_stmt();
				}
				break;
			case 2:
				{
				setState(248);
				analyze_stmt();
				}
				break;
			case 3:
				{
				setState(249);
				attach_stmt();
				}
				break;
			case 4:
				{
				setState(250);
				begin_stmt();
				}
				break;
			case 5:
				{
				setState(251);
				commit_stmt();
				}
				break;
			case 6:
				{
				setState(252);
				compound_select_stmt();
				}
				break;
			case 7:
				{
				setState(253);
				create_index_stmt();
				}
				break;
			case 8:
				{
				setState(254);
				create_table_stmt();
				}
				break;
			case 9:
				{
				setState(255);
				create_trigger_stmt();
				}
				break;
			case 10:
				{
				setState(256);
				create_view_stmt();
				}
				break;
			case 11:
				{
				setState(257);
				create_virtual_table_stmt();
				}
				break;
			case 12:
				{
				setState(258);
				delete_stmt();
				}
				break;
			case 13:
				{
				setState(259);
				delete_stmt_limited();
				}
				break;
			case 14:
				{
				setState(260);
				detach_stmt();
				}
				break;
			case 15:
				{
				setState(261);
				drop_index_stmt();
				}
				break;
			case 16:
				{
				setState(262);
				drop_table_stmt();
				}
				break;
			case 17:
				{
				setState(263);
				drop_trigger_stmt();
				}
				break;
			case 18:
				{
				setState(264);
				drop_view_stmt();
				}
				break;
			case 19:
				{
				setState(265);
				factored_select_stmt();
				}
				break;
			case 20:
				{
				setState(266);
				insert_stmt();
				}
				break;
			case 21:
				{
				setState(267);
				pragma_stmt();
				}
				break;
			case 22:
				{
				setState(268);
				reindex_stmt();
				}
				break;
			case 23:
				{
				setState(269);
				release_stmt();
				}
				break;
			case 24:
				{
				setState(270);
				rollback_stmt();
				}
				break;
			case 25:
				{
				setState(271);
				savepoint_stmt();
				}
				break;
			case 26:
				{
				setState(272);
				simple_select_stmt();
				}
				break;
			case 27:
				{
				setState(273);
				select_stmt();
				}
				break;
			case 28:
				{
				setState(274);
				update_stmt();
				}
				break;
			case 29:
				{
				setState(275);
				update_stmt_limited();
				}
				break;
			case 30:
				{
				setState(276);
				vacuum_stmt();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Alter_table_stmtContext extends ParserRuleContext {
		public TerminalNode K_ALTER() { return getToken(JqlParser.K_ALTER, 0); }
		public TerminalNode K_TABLE() { return getToken(JqlParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_RENAME() { return getToken(JqlParser.K_RENAME, 0); }
		public TerminalNode K_TO() { return getToken(JqlParser.K_TO, 0); }
		public New_table_nameContext new_table_name() {
			return getRuleContext(New_table_nameContext.class,0);
		}
		public TerminalNode K_ADD() { return getToken(JqlParser.K_ADD, 0); }
		public Column_defContext column_def() {
			return getRuleContext(Column_defContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_COLUMN() { return getToken(JqlParser.K_COLUMN, 0); }
		public Alter_table_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alter_table_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterAlter_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitAlter_table_stmt(this);
		}
	}

	public final Alter_table_stmtContext alter_table_stmt() throws RecognitionException {
		Alter_table_stmtContext _localctx = new Alter_table_stmtContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_alter_table_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(279);
			match(K_ALTER);
			setState(280);
			match(K_TABLE);
			setState(284);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				{
				setState(281);
				database_name();
				setState(282);
				match(DOT);
				}
				break;
			}
			setState(286);
			table_name();
			setState(295);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_RENAME:
				{
				setState(287);
				match(K_RENAME);
				setState(288);
				match(K_TO);
				setState(289);
				new_table_name();
				}
				break;
			case K_ADD:
				{
				setState(290);
				match(K_ADD);
				setState(292);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
				case 1:
					{
					setState(291);
					match(K_COLUMN);
					}
					break;
				}
				setState(294);
				column_def();
				}
				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 Analyze_stmtContext extends ParserRuleContext {
		public TerminalNode K_ANALYZE() { return getToken(JqlParser.K_ANALYZE, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Table_or_index_nameContext table_or_index_name() {
			return getRuleContext(Table_or_index_nameContext.class,0);
		}
		public Analyze_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_analyze_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterAnalyze_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitAnalyze_stmt(this);
		}
	}

	public final Analyze_stmtContext analyze_stmt() throws RecognitionException {
		Analyze_stmtContext _localctx = new Analyze_stmtContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_analyze_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(297);
			match(K_ANALYZE);
			setState(304);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				{
				setState(298);
				database_name();
				}
				break;
			case 2:
				{
				setState(299);
				table_or_index_name();
				}
				break;
			case 3:
				{
				setState(300);
				database_name();
				setState(301);
				match(DOT);
				setState(302);
				table_or_index_name();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Attach_stmtContext extends ParserRuleContext {
		public TerminalNode K_ATTACH() { return getToken(JqlParser.K_ATTACH, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_DATABASE() { return getToken(JqlParser.K_DATABASE, 0); }
		public Attach_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attach_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterAttach_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitAttach_stmt(this);
		}
	}

	public final Attach_stmtContext attach_stmt() throws RecognitionException {
		Attach_stmtContext _localctx = new Attach_stmtContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_attach_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(306);
			match(K_ATTACH);
			setState(308);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(307);
				match(K_DATABASE);
				}
				break;
			}
			setState(310);
			expr(0);
			setState(311);
			match(K_AS);
			setState(312);
			database_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Begin_stmtContext extends ParserRuleContext {
		public TerminalNode K_BEGIN() { return getToken(JqlParser.K_BEGIN, 0); }
		public TerminalNode K_TRANSACTION() { return getToken(JqlParser.K_TRANSACTION, 0); }
		public TerminalNode K_DEFERRED() { return getToken(JqlParser.K_DEFERRED, 0); }
		public TerminalNode K_IMMEDIATE() { return getToken(JqlParser.K_IMMEDIATE, 0); }
		public TerminalNode K_EXCLUSIVE() { return getToken(JqlParser.K_EXCLUSIVE, 0); }
		public Transaction_nameContext transaction_name() {
			return getRuleContext(Transaction_nameContext.class,0);
		}
		public Begin_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_begin_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterBegin_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitBegin_stmt(this);
		}
	}

	public final Begin_stmtContext begin_stmt() throws RecognitionException {
		Begin_stmtContext _localctx = new Begin_stmtContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_begin_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(314);
			match(K_BEGIN);
			setState(316);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (K_DEFERRED - 62)) | (1L << (K_EXCLUSIVE - 62)) | (1L << (K_IMMEDIATE - 62)))) != 0)) {
				{
				setState(315);
				_la = _input.LA(1);
				if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (K_DEFERRED - 62)) | (1L << (K_EXCLUSIVE - 62)) | (1L << (K_IMMEDIATE - 62)))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(322);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TRANSACTION) {
				{
				setState(318);
				match(K_TRANSACTION);
				setState(320);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
				case 1:
					{
					setState(319);
					transaction_name();
					}
					break;
				}
				}
			}

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

	public static class Commit_stmtContext extends ParserRuleContext {
		public TerminalNode K_COMMIT() { return getToken(JqlParser.K_COMMIT, 0); }
		public TerminalNode K_END() { return getToken(JqlParser.K_END, 0); }
		public TerminalNode K_TRANSACTION() { return getToken(JqlParser.K_TRANSACTION, 0); }
		public Transaction_nameContext transaction_name() {
			return getRuleContext(Transaction_nameContext.class,0);
		}
		public Commit_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_commit_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCommit_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCommit_stmt(this);
		}
	}

	public final Commit_stmtContext commit_stmt() throws RecognitionException {
		Commit_stmtContext _localctx = new Commit_stmtContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_commit_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(324);
			_la = _input.LA(1);
			if ( !(_la==K_COMMIT || _la==K_END) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(329);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TRANSACTION) {
				{
				setState(325);
				match(K_TRANSACTION);
				setState(327);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
				case 1:
					{
					setState(326);
					transaction_name();
					}
					break;
				}
				}
			}

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

	public static class Compound_select_stmtContext extends ParserRuleContext {
		public List select_core() {
			return getRuleContexts(Select_coreContext.class);
		}
		public Select_coreContext select_core(int i) {
			return getRuleContext(Select_coreContext.class,i);
		}
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public List common_table_expression() {
			return getRuleContexts(Common_table_expressionContext.class);
		}
		public Common_table_expressionContext common_table_expression(int i) {
			return getRuleContext(Common_table_expressionContext.class,i);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public List K_UNION() { return getTokens(JqlParser.K_UNION); }
		public TerminalNode K_UNION(int i) {
			return getToken(JqlParser.K_UNION, i);
		}
		public List K_INTERSECT() { return getTokens(JqlParser.K_INTERSECT); }
		public TerminalNode K_INTERSECT(int i) {
			return getToken(JqlParser.K_INTERSECT, i);
		}
		public List K_EXCEPT() { return getTokens(JqlParser.K_EXCEPT); }
		public TerminalNode K_EXCEPT(int i) {
			return getToken(JqlParser.K_EXCEPT, i);
		}
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public List K_ALL() { return getTokens(JqlParser.K_ALL); }
		public TerminalNode K_ALL(int i) {
			return getToken(JqlParser.K_ALL, i);
		}
		public Compound_select_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compound_select_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCompound_select_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCompound_select_stmt(this);
		}
	}

	public final Compound_select_stmtContext compound_select_stmt() throws RecognitionException {
		Compound_select_stmtContext _localctx = new Compound_select_stmtContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_compound_select_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(343);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(331);
				match(K_WITH);
				setState(333);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
				case 1:
					{
					setState(332);
					match(K_RECURSIVE);
					}
					break;
				}
				setState(335);
				common_table_expression();
				setState(340);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(336);
					match(COMMA);
					setState(337);
					common_table_expression();
					}
					}
					setState(342);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(345);
			select_core();
			setState(355); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(352);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case K_UNION:
					{
					setState(346);
					match(K_UNION);
					setState(348);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_ALL) {
						{
						setState(347);
						match(K_ALL);
						}
					}

					}
					break;
				case K_INTERSECT:
					{
					setState(350);
					match(K_INTERSECT);
					}
					break;
				case K_EXCEPT:
					{
					setState(351);
					match(K_EXCEPT);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(354);
				select_core();
				}
				}
				setState(357); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION );
			setState(360);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(359);
				order_stmt();
				}
			}

			setState(366);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(362);
				limit_stmt();
				setState(364);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(363);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Create_index_stmtContext extends ParserRuleContext {
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_INDEX() { return getToken(JqlParser.K_INDEX, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_ON() { return getToken(JqlParser.K_ON, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public List indexed_column() {
			return getRuleContexts(Indexed_columnContext.class);
		}
		public Indexed_columnContext indexed_column(int i) {
			return getRuleContext(Indexed_columnContext.class,i);
		}
		public TerminalNode K_UNIQUE() { return getToken(JqlParser.K_UNIQUE, 0); }
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Create_index_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create_index_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCreate_index_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCreate_index_stmt(this);
		}
	}

	public final Create_index_stmtContext create_index_stmt() throws RecognitionException {
		Create_index_stmtContext _localctx = new Create_index_stmtContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_create_index_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(368);
			match(K_CREATE);
			setState(370);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_UNIQUE) {
				{
				setState(369);
				match(K_UNIQUE);
				}
			}

			setState(372);
			match(K_INDEX);
			setState(376);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				{
				setState(373);
				match(K_IF);
				setState(374);
				match(K_NOT);
				setState(375);
				match(K_EXISTS);
				}
				break;
			}
			setState(381);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
			case 1:
				{
				setState(378);
				database_name();
				setState(379);
				match(DOT);
				}
				break;
			}
			setState(383);
			index_name();
			setState(384);
			match(K_ON);
			setState(385);
			table_name();
			setState(386);
			match(OPEN_PAR);
			setState(387);
			indexed_column();
			setState(392);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(388);
				match(COMMA);
				setState(389);
				indexed_column();
				}
				}
				setState(394);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(395);
			match(CLOSE_PAR);
			setState(397);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(396);
				where_stmt();
				}
			}

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

	public static class Create_table_stmtContext extends ParserRuleContext {
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_TABLE() { return getToken(JqlParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public List column_def() {
			return getRuleContexts(Column_defContext.class);
		}
		public Column_defContext column_def(int i) {
			return getRuleContext(Column_defContext.class,i);
		}
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_TEMP() { return getToken(JqlParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(JqlParser.K_TEMPORARY, 0); }
		public List table_constraint() {
			return getRuleContexts(Table_constraintContext.class);
		}
		public Table_constraintContext table_constraint(int i) {
			return getRuleContext(Table_constraintContext.class,i);
		}
		public TerminalNode K_WITHOUT() { return getToken(JqlParser.K_WITHOUT, 0); }
		public TerminalNode IDENTIFIER() { return getToken(JqlParser.IDENTIFIER, 0); }
		public Create_table_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create_table_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCreate_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCreate_table_stmt(this);
		}
	}

	public final Create_table_stmtContext create_table_stmt() throws RecognitionException {
		Create_table_stmtContext _localctx = new Create_table_stmtContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_create_table_stmt);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(399);
			match(K_CREATE);
			setState(401);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(400);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(403);
			match(K_TABLE);
			setState(407);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
			case 1:
				{
				setState(404);
				match(K_IF);
				setState(405);
				match(K_NOT);
				setState(406);
				match(K_EXISTS);
				}
				break;
			}
			setState(412);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
			case 1:
				{
				setState(409);
				database_name();
				setState(410);
				match(DOT);
				}
				break;
			}
			setState(414);
			table_name();
			setState(438);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case OPEN_PAR:
				{
				setState(415);
				match(OPEN_PAR);
				setState(416);
				column_def();
				setState(421);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(417);
						match(COMMA);
						setState(418);
						column_def();
						}
						} 
					}
					setState(423);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
				}
				setState(428);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(424);
					match(COMMA);
					setState(425);
					table_constraint();
					}
					}
					setState(430);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(431);
				match(CLOSE_PAR);
				setState(434);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_WITHOUT) {
					{
					setState(432);
					match(K_WITHOUT);
					setState(433);
					match(IDENTIFIER);
					}
				}

				}
				break;
			case K_AS:
				{
				setState(436);
				match(K_AS);
				setState(437);
				select_stmt();
				}
				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 Create_trigger_stmtContext extends ParserRuleContext {
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_TRIGGER() { return getToken(JqlParser.K_TRIGGER, 0); }
		public Trigger_nameContext trigger_name() {
			return getRuleContext(Trigger_nameContext.class,0);
		}
		public TerminalNode K_ON() { return getToken(JqlParser.K_ON, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_BEGIN() { return getToken(JqlParser.K_BEGIN, 0); }
		public TerminalNode K_END() { return getToken(JqlParser.K_END, 0); }
		public TerminalNode K_DELETE() { return getToken(JqlParser.K_DELETE, 0); }
		public TerminalNode K_INSERT() { return getToken(JqlParser.K_INSERT, 0); }
		public TerminalNode K_UPDATE() { return getToken(JqlParser.K_UPDATE, 0); }
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public List database_name() {
			return getRuleContexts(Database_nameContext.class);
		}
		public Database_nameContext database_name(int i) {
			return getRuleContext(Database_nameContext.class,i);
		}
		public TerminalNode K_BEFORE() { return getToken(JqlParser.K_BEFORE, 0); }
		public TerminalNode K_AFTER() { return getToken(JqlParser.K_AFTER, 0); }
		public TerminalNode K_INSTEAD() { return getToken(JqlParser.K_INSTEAD, 0); }
		public List K_OF() { return getTokens(JqlParser.K_OF); }
		public TerminalNode K_OF(int i) {
			return getToken(JqlParser.K_OF, i);
		}
		public TerminalNode K_FOR() { return getToken(JqlParser.K_FOR, 0); }
		public TerminalNode K_EACH() { return getToken(JqlParser.K_EACH, 0); }
		public TerminalNode K_ROW() { return getToken(JqlParser.K_ROW, 0); }
		public TerminalNode K_WHEN() { return getToken(JqlParser.K_WHEN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_TEMP() { return getToken(JqlParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(JqlParser.K_TEMPORARY, 0); }
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public List update_stmt() {
			return getRuleContexts(Update_stmtContext.class);
		}
		public Update_stmtContext update_stmt(int i) {
			return getRuleContext(Update_stmtContext.class,i);
		}
		public List insert_stmt() {
			return getRuleContexts(Insert_stmtContext.class);
		}
		public Insert_stmtContext insert_stmt(int i) {
			return getRuleContext(Insert_stmtContext.class,i);
		}
		public List delete_stmt() {
			return getRuleContexts(Delete_stmtContext.class);
		}
		public Delete_stmtContext delete_stmt(int i) {
			return getRuleContext(Delete_stmtContext.class,i);
		}
		public List select_stmt() {
			return getRuleContexts(Select_stmtContext.class);
		}
		public Select_stmtContext select_stmt(int i) {
			return getRuleContext(Select_stmtContext.class,i);
		}
		public Create_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create_trigger_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCreate_trigger_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCreate_trigger_stmt(this);
		}
	}

	public final Create_trigger_stmtContext create_trigger_stmt() throws RecognitionException {
		Create_trigger_stmtContext _localctx = new Create_trigger_stmtContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_create_trigger_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(440);
			match(K_CREATE);
			setState(442);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(441);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(444);
			match(K_TRIGGER);
			setState(448);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				{
				setState(445);
				match(K_IF);
				setState(446);
				match(K_NOT);
				setState(447);
				match(K_EXISTS);
				}
				break;
			}
			setState(453);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
			case 1:
				{
				setState(450);
				database_name();
				setState(451);
				match(DOT);
				}
				break;
			}
			setState(455);
			trigger_name();
			setState(460);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_BEFORE:
				{
				setState(456);
				match(K_BEFORE);
				}
				break;
			case K_AFTER:
				{
				setState(457);
				match(K_AFTER);
				}
				break;
			case K_INSTEAD:
				{
				setState(458);
				match(K_INSTEAD);
				setState(459);
				match(K_OF);
				}
				break;
			case K_DELETE:
			case K_INSERT:
			case K_UPDATE:
				break;
			default:
				break;
			}
			setState(476);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_DELETE:
				{
				setState(462);
				match(K_DELETE);
				}
				break;
			case K_INSERT:
				{
				setState(463);
				match(K_INSERT);
				}
				break;
			case K_UPDATE:
				{
				setState(464);
				match(K_UPDATE);
				setState(474);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_OF) {
					{
					setState(465);
					match(K_OF);
					setState(466);
					column_name();
					setState(471);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(467);
						match(COMMA);
						setState(468);
						column_name();
						}
						}
						setState(473);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(478);
			match(K_ON);
			setState(482);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
			case 1:
				{
				setState(479);
				database_name();
				setState(480);
				match(DOT);
				}
				break;
			}
			setState(484);
			table_name();
			setState(488);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_FOR) {
				{
				setState(485);
				match(K_FOR);
				setState(486);
				match(K_EACH);
				setState(487);
				match(K_ROW);
				}
			}

			setState(492);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHEN) {
				{
				setState(490);
				match(K_WHEN);
				setState(491);
				expr(0);
				}
			}

			setState(494);
			match(K_BEGIN);
			setState(503); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(499);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
				case 1:
					{
					setState(495);
					update_stmt();
					}
					break;
				case 2:
					{
					setState(496);
					insert_stmt();
					}
					break;
				case 3:
					{
					setState(497);
					delete_stmt();
					}
					break;
				case 4:
					{
					setState(498);
					select_stmt();
					}
					break;
				}
				setState(501);
				match(SCOL);
				}
				}
				setState(505); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( ((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & ((1L << (K_DELETE - 63)) | (1L << (K_INSERT - 63)) | (1L << (K_REPLACE - 63)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (K_SELECT - 132)) | (1L << (K_UPDATE - 132)) | (1L << (K_VALUES - 132)) | (1L << (K_WITH - 132)))) != 0) );
			setState(507);
			match(K_END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Create_view_stmtContext extends ParserRuleContext {
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_VIEW() { return getToken(JqlParser.K_VIEW, 0); }
		public View_nameContext view_name() {
			return getRuleContext(View_nameContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_TEMP() { return getToken(JqlParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(JqlParser.K_TEMPORARY, 0); }
		public Create_view_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create_view_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCreate_view_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCreate_view_stmt(this);
		}
	}

	public final Create_view_stmtContext create_view_stmt() throws RecognitionException {
		Create_view_stmtContext _localctx = new Create_view_stmtContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_create_view_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(509);
			match(K_CREATE);
			setState(511);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(510);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(513);
			match(K_VIEW);
			setState(517);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
			case 1:
				{
				setState(514);
				match(K_IF);
				setState(515);
				match(K_NOT);
				setState(516);
				match(K_EXISTS);
				}
				break;
			}
			setState(522);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
			case 1:
				{
				setState(519);
				database_name();
				setState(520);
				match(DOT);
				}
				break;
			}
			setState(524);
			view_name();
			setState(525);
			match(K_AS);
			setState(526);
			select_stmt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Create_virtual_table_stmtContext extends ParserRuleContext {
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_VIRTUAL() { return getToken(JqlParser.K_VIRTUAL, 0); }
		public TerminalNode K_TABLE() { return getToken(JqlParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_USING() { return getToken(JqlParser.K_USING, 0); }
		public Module_nameContext module_name() {
			return getRuleContext(Module_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public List module_argument() {
			return getRuleContexts(Module_argumentContext.class);
		}
		public Module_argumentContext module_argument(int i) {
			return getRuleContext(Module_argumentContext.class,i);
		}
		public Create_virtual_table_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_create_virtual_table_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCreate_virtual_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCreate_virtual_table_stmt(this);
		}
	}

	public final Create_virtual_table_stmtContext create_virtual_table_stmt() throws RecognitionException {
		Create_virtual_table_stmtContext _localctx = new Create_virtual_table_stmtContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_create_virtual_table_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(528);
			match(K_CREATE);
			setState(529);
			match(K_VIRTUAL);
			setState(530);
			match(K_TABLE);
			setState(534);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) {
			case 1:
				{
				setState(531);
				match(K_IF);
				setState(532);
				match(K_NOT);
				setState(533);
				match(K_EXISTS);
				}
				break;
			}
			setState(539);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
			case 1:
				{
				setState(536);
				database_name();
				setState(537);
				match(DOT);
				}
				break;
			}
			setState(541);
			table_name();
			setState(542);
			match(K_USING);
			setState(543);
			module_name();
			setState(555);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(544);
				match(OPEN_PAR);
				setState(545);
				module_argument();
				setState(550);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(546);
					match(COMMA);
					setState(547);
					module_argument();
					}
					}
					setState(552);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(553);
				match(CLOSE_PAR);
				}
			}

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

	public static class Delete_stmtContext extends ParserRuleContext {
		public TerminalNode K_DELETE() { return getToken(JqlParser.K_DELETE, 0); }
		public TerminalNode K_FROM() { return getToken(JqlParser.K_FROM, 0); }
		public Qualified_table_nameContext qualified_table_name() {
			return getRuleContext(Qualified_table_nameContext.class,0);
		}
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Delete_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delete_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDelete_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDelete_stmt(this);
		}
	}

	public final Delete_stmtContext delete_stmt() throws RecognitionException {
		Delete_stmtContext _localctx = new Delete_stmtContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_delete_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(558);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(557);
				with_clause();
				}
			}

			setState(560);
			match(K_DELETE);
			setState(561);
			match(K_FROM);
			setState(562);
			qualified_table_name();
			setState(564);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(563);
				where_stmt();
				}
			}

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

	public static class Delete_stmt_limitedContext extends ParserRuleContext {
		public TerminalNode K_DELETE() { return getToken(JqlParser.K_DELETE, 0); }
		public TerminalNode K_FROM() { return getToken(JqlParser.K_FROM, 0); }
		public Qualified_table_nameContext qualified_table_name() {
			return getRuleContext(Qualified_table_nameContext.class,0);
		}
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Delete_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delete_stmt_limited; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDelete_stmt_limited(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDelete_stmt_limited(this);
		}
	}

	public final Delete_stmt_limitedContext delete_stmt_limited() throws RecognitionException {
		Delete_stmt_limitedContext _localctx = new Delete_stmt_limitedContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_delete_stmt_limited);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(567);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(566);
				with_clause();
				}
			}

			setState(569);
			match(K_DELETE);
			setState(570);
			match(K_FROM);
			setState(571);
			qualified_table_name();
			setState(573);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(572);
				where_stmt();
				}
			}

			setState(582);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT || _la==K_ORDER) {
				{
				setState(576);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_ORDER) {
					{
					setState(575);
					order_stmt();
					}
				}

				setState(578);
				limit_stmt();
				setState(580);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(579);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Detach_stmtContext extends ParserRuleContext {
		public TerminalNode K_DETACH() { return getToken(JqlParser.K_DETACH, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_DATABASE() { return getToken(JqlParser.K_DATABASE, 0); }
		public Detach_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_detach_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDetach_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDetach_stmt(this);
		}
	}

	public final Detach_stmtContext detach_stmt() throws RecognitionException {
		Detach_stmtContext _localctx = new Detach_stmtContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_detach_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(584);
			match(K_DETACH);
			setState(586);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
			case 1:
				{
				setState(585);
				match(K_DATABASE);
				}
				break;
			}
			setState(588);
			database_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Drop_index_stmtContext extends ParserRuleContext {
		public TerminalNode K_DROP() { return getToken(JqlParser.K_DROP, 0); }
		public TerminalNode K_INDEX() { return getToken(JqlParser.K_INDEX, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Drop_index_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drop_index_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDrop_index_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDrop_index_stmt(this);
		}
	}

	public final Drop_index_stmtContext drop_index_stmt() throws RecognitionException {
		Drop_index_stmtContext _localctx = new Drop_index_stmtContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_drop_index_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(590);
			match(K_DROP);
			setState(591);
			match(K_INDEX);
			setState(594);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
			case 1:
				{
				setState(592);
				match(K_IF);
				setState(593);
				match(K_EXISTS);
				}
				break;
			}
			setState(599);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
			case 1:
				{
				setState(596);
				database_name();
				setState(597);
				match(DOT);
				}
				break;
			}
			setState(601);
			index_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Drop_table_stmtContext extends ParserRuleContext {
		public TerminalNode K_DROP() { return getToken(JqlParser.K_DROP, 0); }
		public TerminalNode K_TABLE() { return getToken(JqlParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Drop_table_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drop_table_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDrop_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDrop_table_stmt(this);
		}
	}

	public final Drop_table_stmtContext drop_table_stmt() throws RecognitionException {
		Drop_table_stmtContext _localctx = new Drop_table_stmtContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_drop_table_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(603);
			match(K_DROP);
			setState(604);
			match(K_TABLE);
			setState(607);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
			case 1:
				{
				setState(605);
				match(K_IF);
				setState(606);
				match(K_EXISTS);
				}
				break;
			}
			setState(612);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
			case 1:
				{
				setState(609);
				database_name();
				setState(610);
				match(DOT);
				}
				break;
			}
			setState(614);
			table_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Drop_trigger_stmtContext extends ParserRuleContext {
		public TerminalNode K_DROP() { return getToken(JqlParser.K_DROP, 0); }
		public TerminalNode K_TRIGGER() { return getToken(JqlParser.K_TRIGGER, 0); }
		public Trigger_nameContext trigger_name() {
			return getRuleContext(Trigger_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Drop_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drop_trigger_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDrop_trigger_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDrop_trigger_stmt(this);
		}
	}

	public final Drop_trigger_stmtContext drop_trigger_stmt() throws RecognitionException {
		Drop_trigger_stmtContext _localctx = new Drop_trigger_stmtContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_drop_trigger_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(616);
			match(K_DROP);
			setState(617);
			match(K_TRIGGER);
			setState(620);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
			case 1:
				{
				setState(618);
				match(K_IF);
				setState(619);
				match(K_EXISTS);
				}
				break;
			}
			setState(625);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
			case 1:
				{
				setState(622);
				database_name();
				setState(623);
				match(DOT);
				}
				break;
			}
			setState(627);
			trigger_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Drop_view_stmtContext extends ParserRuleContext {
		public TerminalNode K_DROP() { return getToken(JqlParser.K_DROP, 0); }
		public TerminalNode K_VIEW() { return getToken(JqlParser.K_VIEW, 0); }
		public View_nameContext view_name() {
			return getRuleContext(View_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Drop_view_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_drop_view_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDrop_view_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDrop_view_stmt(this);
		}
	}

	public final Drop_view_stmtContext drop_view_stmt() throws RecognitionException {
		Drop_view_stmtContext _localctx = new Drop_view_stmtContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_drop_view_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(629);
			match(K_DROP);
			setState(630);
			match(K_VIEW);
			setState(633);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
			case 1:
				{
				setState(631);
				match(K_IF);
				setState(632);
				match(K_EXISTS);
				}
				break;
			}
			setState(638);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
			case 1:
				{
				setState(635);
				database_name();
				setState(636);
				match(DOT);
				}
				break;
			}
			setState(640);
			view_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Factored_select_stmtContext extends ParserRuleContext {
		public List select_core() {
			return getRuleContexts(Select_coreContext.class);
		}
		public Select_coreContext select_core(int i) {
			return getRuleContext(Select_coreContext.class,i);
		}
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public List common_table_expression() {
			return getRuleContexts(Common_table_expressionContext.class);
		}
		public Common_table_expressionContext common_table_expression(int i) {
			return getRuleContext(Common_table_expressionContext.class,i);
		}
		public List compound_operator() {
			return getRuleContexts(Compound_operatorContext.class);
		}
		public Compound_operatorContext compound_operator(int i) {
			return getRuleContext(Compound_operatorContext.class,i);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Factored_select_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_factored_select_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterFactored_select_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitFactored_select_stmt(this);
		}
	}

	public final Factored_select_stmtContext factored_select_stmt() throws RecognitionException {
		Factored_select_stmtContext _localctx = new Factored_select_stmtContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_factored_select_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(654);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(642);
				match(K_WITH);
				setState(644);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
				case 1:
					{
					setState(643);
					match(K_RECURSIVE);
					}
					break;
				}
				setState(646);
				common_table_expression();
				setState(651);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(647);
					match(COMMA);
					setState(648);
					common_table_expression();
					}
					}
					setState(653);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(656);
			select_core();
			setState(662);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION) {
				{
				{
				setState(657);
				compound_operator();
				setState(658);
				select_core();
				}
				}
				setState(664);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(666);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(665);
				order_stmt();
				}
			}

			setState(672);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(668);
				limit_stmt();
				setState(670);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(669);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Insert_stmtContext extends ParserRuleContext {
		public TerminalNode K_INTO() { return getToken(JqlParser.K_INTO, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_INSERT() { return getToken(JqlParser.K_INSERT, 0); }
		public TerminalNode K_REPLACE() { return getToken(JqlParser.K_REPLACE, 0); }
		public TerminalNode K_OR() { return getToken(JqlParser.K_OR, 0); }
		public Conflict_algorithmContext conflict_algorithm() {
			return getRuleContext(Conflict_algorithmContext.class,0);
		}
		public TerminalNode K_VALUES() { return getToken(JqlParser.K_VALUES, 0); }
		public Column_value_setContext column_value_set() {
			return getRuleContext(Column_value_setContext.class,0);
		}
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_DEFAULT() { return getToken(JqlParser.K_DEFAULT, 0); }
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Column_name_setContext column_name_set() {
			return getRuleContext(Column_name_setContext.class,0);
		}
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Insert_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insert_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterInsert_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitInsert_stmt(this);
		}
	}

	public final Insert_stmtContext insert_stmt() throws RecognitionException {
		Insert_stmtContext _localctx = new Insert_stmtContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_insert_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(675);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(674);
				with_clause();
				}
			}

			setState(682);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
			case 1:
				{
				setState(677);
				match(K_INSERT);
				}
				break;
			case 2:
				{
				setState(678);
				match(K_REPLACE);
				}
				break;
			case 3:
				{
				setState(679);
				match(K_INSERT);
				setState(680);
				match(K_OR);
				setState(681);
				conflict_algorithm();
				}
				break;
			}
			setState(684);
			match(K_INTO);
			setState(688);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
			case 1:
				{
				setState(685);
				database_name();
				setState(686);
				match(DOT);
				}
				break;
			}
			setState(690);
			table_name();
			setState(695);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(691);
				match(OPEN_PAR);
				setState(692);
				column_name_set();
				setState(693);
				match(CLOSE_PAR);
				}
			}

			setState(721);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
			case 1:
				{
				setState(697);
				match(K_VALUES);
				setState(698);
				match(OPEN_PAR);
				setState(699);
				column_value_set();
				setState(700);
				match(CLOSE_PAR);
				setState(715);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(701);
					match(COMMA);
					setState(702);
					match(OPEN_PAR);
					setState(703);
					expr(0);
					setState(708);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(704);
						match(COMMA);
						setState(705);
						expr(0);
						}
						}
						setState(710);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(711);
					match(CLOSE_PAR);
					}
					}
					setState(717);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			case 2:
				{
				setState(718);
				select_stmt();
				}
				break;
			case 3:
				{
				setState(719);
				match(K_DEFAULT);
				setState(720);
				match(K_VALUES);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_name_setContext extends ParserRuleContext {
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public Column_name_setContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_name_set; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_name_set(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_name_set(this);
		}
	}

	public final Column_name_setContext column_name_set() throws RecognitionException {
		Column_name_setContext _localctx = new Column_name_setContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_column_name_set);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(723);
			column_name();
			setState(728);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(724);
				match(COMMA);
				setState(725);
				column_name();
				}
				}
				setState(730);
				_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 Column_value_setContext extends ParserRuleContext {
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Column_value_setContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_value_set; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_value_set(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_value_set(this);
		}
	}

	public final Column_value_setContext column_value_set() throws RecognitionException {
		Column_value_setContext _localctx = new Column_value_setContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_column_value_set);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(731);
			expr(0);
			setState(736);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(732);
				match(COMMA);
				setState(733);
				expr(0);
				}
				}
				setState(738);
				_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 Limit_stmtContext extends ParserRuleContext {
		public TerminalNode K_LIMIT() { return getToken(JqlParser.K_LIMIT, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Limit_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limit_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterLimit_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitLimit_stmt(this);
		}
	}

	public final Limit_stmtContext limit_stmt() throws RecognitionException {
		Limit_stmtContext _localctx = new Limit_stmtContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_limit_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(739);
			match(K_LIMIT);
			setState(740);
			expr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Pragma_stmtContext extends ParserRuleContext {
		public TerminalNode K_PRAGMA() { return getToken(JqlParser.K_PRAGMA, 0); }
		public Pragma_nameContext pragma_name() {
			return getRuleContext(Pragma_nameContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Pragma_valueContext pragma_value() {
			return getRuleContext(Pragma_valueContext.class,0);
		}
		public Pragma_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pragma_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterPragma_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitPragma_stmt(this);
		}
	}

	public final Pragma_stmtContext pragma_stmt() throws RecognitionException {
		Pragma_stmtContext _localctx = new Pragma_stmtContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_pragma_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(742);
			match(K_PRAGMA);
			setState(746);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
			case 1:
				{
				setState(743);
				database_name();
				setState(744);
				match(DOT);
				}
				break;
			}
			setState(748);
			pragma_name();
			setState(755);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ASSIGN:
				{
				setState(749);
				match(ASSIGN);
				setState(750);
				pragma_value();
				}
				break;
			case OPEN_PAR:
				{
				setState(751);
				match(OPEN_PAR);
				setState(752);
				pragma_value();
				setState(753);
				match(CLOSE_PAR);
				}
				break;
			case EOF:
			case SCOL:
			case K_ALTER:
			case K_ANALYZE:
			case K_ATTACH:
			case K_BEGIN:
			case K_COMMIT:
			case K_CREATE:
			case K_DELETE:
			case K_DETACH:
			case K_DROP:
			case K_END:
			case K_EXPLAIN:
			case K_INSERT:
			case K_PRAGMA:
			case K_REINDEX:
			case K_RELEASE:
			case K_REPLACE:
			case K_ROLLBACK:
			case K_SAVEPOINT:
			case K_SELECT:
			case K_UPDATE:
			case K_VACUUM:
			case K_VALUES:
			case K_WITH:
			case UNEXPECTED_CHAR:
				break;
			default:
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Reindex_stmtContext extends ParserRuleContext {
		public TerminalNode K_REINDEX() { return getToken(JqlParser.K_REINDEX, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Reindex_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_reindex_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterReindex_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitReindex_stmt(this);
		}
	}

	public final Reindex_stmtContext reindex_stmt() throws RecognitionException {
		Reindex_stmtContext _localctx = new Reindex_stmtContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_reindex_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(757);
			match(K_REINDEX);
			setState(768);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
			case 1:
				{
				setState(758);
				collation_name();
				}
				break;
			case 2:
				{
				setState(762);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
				case 1:
					{
					setState(759);
					database_name();
					setState(760);
					match(DOT);
					}
					break;
				}
				setState(766);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
				case 1:
					{
					setState(764);
					table_name();
					}
					break;
				case 2:
					{
					setState(765);
					index_name();
					}
					break;
				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Release_stmtContext extends ParserRuleContext {
		public TerminalNode K_RELEASE() { return getToken(JqlParser.K_RELEASE, 0); }
		public Savepoint_nameContext savepoint_name() {
			return getRuleContext(Savepoint_nameContext.class,0);
		}
		public TerminalNode K_SAVEPOINT() { return getToken(JqlParser.K_SAVEPOINT, 0); }
		public Release_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_release_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterRelease_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitRelease_stmt(this);
		}
	}

	public final Release_stmtContext release_stmt() throws RecognitionException {
		Release_stmtContext _localctx = new Release_stmtContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_release_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(770);
			match(K_RELEASE);
			setState(772);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
			case 1:
				{
				setState(771);
				match(K_SAVEPOINT);
				}
				break;
			}
			setState(774);
			savepoint_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Rollback_stmtContext extends ParserRuleContext {
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_TRANSACTION() { return getToken(JqlParser.K_TRANSACTION, 0); }
		public TerminalNode K_TO() { return getToken(JqlParser.K_TO, 0); }
		public Savepoint_nameContext savepoint_name() {
			return getRuleContext(Savepoint_nameContext.class,0);
		}
		public Transaction_nameContext transaction_name() {
			return getRuleContext(Transaction_nameContext.class,0);
		}
		public TerminalNode K_SAVEPOINT() { return getToken(JqlParser.K_SAVEPOINT, 0); }
		public Rollback_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rollback_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterRollback_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitRollback_stmt(this);
		}
	}

	public final Rollback_stmtContext rollback_stmt() throws RecognitionException {
		Rollback_stmtContext _localctx = new Rollback_stmtContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_rollback_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(776);
			match(K_ROLLBACK);
			setState(781);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TRANSACTION) {
				{
				setState(777);
				match(K_TRANSACTION);
				setState(779);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
				case 1:
					{
					setState(778);
					transaction_name();
					}
					break;
				}
				}
			}

			setState(788);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_TO) {
				{
				setState(783);
				match(K_TO);
				setState(785);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
				case 1:
					{
					setState(784);
					match(K_SAVEPOINT);
					}
					break;
				}
				setState(787);
				savepoint_name();
				}
			}

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

	public static class Savepoint_stmtContext extends ParserRuleContext {
		public TerminalNode K_SAVEPOINT() { return getToken(JqlParser.K_SAVEPOINT, 0); }
		public Savepoint_nameContext savepoint_name() {
			return getRuleContext(Savepoint_nameContext.class,0);
		}
		public Savepoint_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_savepoint_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSavepoint_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSavepoint_stmt(this);
		}
	}

	public final Savepoint_stmtContext savepoint_stmt() throws RecognitionException {
		Savepoint_stmtContext _localctx = new Savepoint_stmtContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_savepoint_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(790);
			match(K_SAVEPOINT);
			setState(791);
			savepoint_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Simple_select_stmtContext extends ParserRuleContext {
		public Select_coreContext select_core() {
			return getRuleContext(Select_coreContext.class,0);
		}
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public List common_table_expression() {
			return getRuleContexts(Common_table_expressionContext.class);
		}
		public Common_table_expressionContext common_table_expression(int i) {
			return getRuleContext(Common_table_expressionContext.class,i);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Simple_select_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simple_select_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSimple_select_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSimple_select_stmt(this);
		}
	}

	public final Simple_select_stmtContext simple_select_stmt() throws RecognitionException {
		Simple_select_stmtContext _localctx = new Simple_select_stmtContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_simple_select_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(805);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(793);
				match(K_WITH);
				setState(795);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
				case 1:
					{
					setState(794);
					match(K_RECURSIVE);
					}
					break;
				}
				setState(797);
				common_table_expression();
				setState(802);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(798);
					match(COMMA);
					setState(799);
					common_table_expression();
					}
					}
					setState(804);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(807);
			select_core();
			setState(809);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(808);
				order_stmt();
				}
			}

			setState(815);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(811);
				limit_stmt();
				setState(813);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(812);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Select_stmtContext extends ParserRuleContext {
		public List select_or_values() {
			return getRuleContexts(Select_or_valuesContext.class);
		}
		public Select_or_valuesContext select_or_values(int i) {
			return getRuleContext(Select_or_valuesContext.class,i);
		}
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public List common_table_expression() {
			return getRuleContexts(Common_table_expressionContext.class);
		}
		public Common_table_expressionContext common_table_expression(int i) {
			return getRuleContext(Common_table_expressionContext.class,i);
		}
		public List compound_operator() {
			return getRuleContexts(Compound_operatorContext.class);
		}
		public Compound_operatorContext compound_operator(int i) {
			return getRuleContext(Compound_operatorContext.class,i);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Select_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_select_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSelect_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSelect_stmt(this);
		}
	}

	public final Select_stmtContext select_stmt() throws RecognitionException {
		Select_stmtContext _localctx = new Select_stmtContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_select_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(829);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(817);
				match(K_WITH);
				setState(819);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
				case 1:
					{
					setState(818);
					match(K_RECURSIVE);
					}
					break;
				}
				setState(821);
				common_table_expression();
				setState(826);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(822);
					match(COMMA);
					setState(823);
					common_table_expression();
					}
					}
					setState(828);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(831);
			select_or_values();
			setState(837);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION) {
				{
				{
				setState(832);
				compound_operator();
				setState(833);
				select_or_values();
				}
				}
				setState(839);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(841);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(840);
				order_stmt();
				}
			}

			setState(847);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(843);
				limit_stmt();
				setState(845);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(844);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Select_or_valuesContext extends ParserRuleContext {
		public TerminalNode K_SELECT() { return getToken(JqlParser.K_SELECT, 0); }
		public Projected_columnsContext projected_columns() {
			return getRuleContext(Projected_columnsContext.class,0);
		}
		public TerminalNode K_FROM() { return getToken(JqlParser.K_FROM, 0); }
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Group_stmtContext group_stmt() {
			return getRuleContext(Group_stmtContext.class,0);
		}
		public TerminalNode K_DISTINCT() { return getToken(JqlParser.K_DISTINCT, 0); }
		public TerminalNode K_ALL() { return getToken(JqlParser.K_ALL, 0); }
		public List table_or_subquery() {
			return getRuleContexts(Table_or_subqueryContext.class);
		}
		public Table_or_subqueryContext table_or_subquery(int i) {
			return getRuleContext(Table_or_subqueryContext.class,i);
		}
		public Join_clauseContext join_clause() {
			return getRuleContext(Join_clauseContext.class,0);
		}
		public Having_stmtContext having_stmt() {
			return getRuleContext(Having_stmtContext.class,0);
		}
		public TerminalNode K_VALUES() { return getToken(JqlParser.K_VALUES, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Select_or_valuesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_select_or_values; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSelect_or_values(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSelect_or_values(this);
		}
	}

	public final Select_or_valuesContext select_or_values() throws RecognitionException {
		Select_or_valuesContext _localctx = new Select_or_valuesContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_select_or_values);
		int _la;
		try {
			setState(905);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(849);
				match(K_SELECT);
				setState(851);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
				case 1:
					{
					setState(850);
					_la = _input.LA(1);
					if ( !(_la==K_ALL || _la==K_DISTINCT) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					break;
				}
				setState(853);
				projected_columns();
				setState(866);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_FROM) {
					{
					setState(854);
					match(K_FROM);
					setState(864);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
					case 1:
						{
						setState(855);
						table_or_subquery();
						setState(860);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==COMMA) {
							{
							{
							setState(856);
							match(COMMA);
							setState(857);
							table_or_subquery();
							}
							}
							setState(862);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						}
						break;
					case 2:
						{
						setState(863);
						join_clause();
						}
						break;
					}
					}
				}

				setState(869);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_WHERE) {
					{
					setState(868);
					where_stmt();
					}
				}

				setState(875);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_GROUP) {
					{
					setState(871);
					group_stmt();
					setState(873);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_HAVING) {
						{
						setState(872);
						having_stmt();
						}
					}

					}
				}

				}
				break;
			case K_VALUES:
				enterOuterAlt(_localctx, 2);
				{
				setState(877);
				match(K_VALUES);
				setState(878);
				match(OPEN_PAR);
				setState(879);
				expr(0);
				setState(884);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(880);
					match(COMMA);
					setState(881);
					expr(0);
					}
					}
					setState(886);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(887);
				match(CLOSE_PAR);
				setState(902);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(888);
					match(COMMA);
					setState(889);
					match(OPEN_PAR);
					setState(890);
					expr(0);
					setState(895);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(891);
						match(COMMA);
						setState(892);
						expr(0);
						}
						}
						setState(897);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(898);
					match(CLOSE_PAR);
					}
					}
					setState(904);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				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 Update_stmtContext extends ParserRuleContext {
		public TerminalNode K_UPDATE() { return getToken(JqlParser.K_UPDATE, 0); }
		public Qualified_table_nameContext qualified_table_name() {
			return getRuleContext(Qualified_table_nameContext.class,0);
		}
		public TerminalNode K_SET() { return getToken(JqlParser.K_SET, 0); }
		public List column_name_to_update() {
			return getRuleContexts(Column_name_to_updateContext.class);
		}
		public Column_name_to_updateContext column_name_to_update(int i) {
			return getRuleContext(Column_name_to_updateContext.class,i);
		}
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public TerminalNode K_OR() { return getToken(JqlParser.K_OR, 0); }
		public Conflict_algorithmContext conflict_algorithm() {
			return getRuleContext(Conflict_algorithmContext.class,0);
		}
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Update_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_update_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterUpdate_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitUpdate_stmt(this);
		}
	}

	public final Update_stmtContext update_stmt() throws RecognitionException {
		Update_stmtContext _localctx = new Update_stmtContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_update_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(908);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(907);
				with_clause();
				}
			}

			setState(910);
			match(K_UPDATE);
			setState(913);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
			case 1:
				{
				setState(911);
				match(K_OR);
				setState(912);
				conflict_algorithm();
				}
				break;
			}
			setState(915);
			qualified_table_name();
			setState(916);
			match(K_SET);
			setState(917);
			column_name_to_update();
			setState(918);
			match(ASSIGN);
			setState(919);
			expr(0);
			setState(927);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(920);
				match(COMMA);
				setState(921);
				column_name_to_update();
				setState(922);
				match(ASSIGN);
				setState(923);
				expr(0);
				}
				}
				setState(929);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(931);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(930);
				where_stmt();
				}
			}

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

	public static class Conflict_algorithmContext extends ParserRuleContext {
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(JqlParser.K_ABORT, 0); }
		public TerminalNode K_REPLACE() { return getToken(JqlParser.K_REPLACE, 0); }
		public TerminalNode K_FAIL() { return getToken(JqlParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(JqlParser.K_IGNORE, 0); }
		public Conflict_algorithmContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conflict_algorithm; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterConflict_algorithm(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitConflict_algorithm(this);
		}
	}

	public final Conflict_algorithmContext conflict_algorithm() throws RecognitionException {
		Conflict_algorithmContext _localctx = new Conflict_algorithmContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_conflict_algorithm);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(933);
			_la = _input.LA(1);
			if ( !(_la==K_ABORT || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (K_FAIL - 76)) | (1L << (K_IGNORE - 76)) | (1L << (K_REPLACE - 76)) | (1L << (K_ROLLBACK - 76)))) != 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 Update_stmt_limitedContext extends ParserRuleContext {
		public TerminalNode K_UPDATE() { return getToken(JqlParser.K_UPDATE, 0); }
		public Qualified_table_nameContext qualified_table_name() {
			return getRuleContext(Qualified_table_nameContext.class,0);
		}
		public TerminalNode K_SET() { return getToken(JqlParser.K_SET, 0); }
		public List column_name_to_update() {
			return getRuleContexts(Column_name_to_updateContext.class);
		}
		public Column_name_to_updateContext column_name_to_update(int i) {
			return getRuleContext(Column_name_to_updateContext.class,i);
		}
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public TerminalNode K_OR() { return getToken(JqlParser.K_OR, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(JqlParser.K_ABORT, 0); }
		public TerminalNode K_REPLACE() { return getToken(JqlParser.K_REPLACE, 0); }
		public TerminalNode K_FAIL() { return getToken(JqlParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(JqlParser.K_IGNORE, 0); }
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Limit_stmtContext limit_stmt() {
			return getRuleContext(Limit_stmtContext.class,0);
		}
		public Order_stmtContext order_stmt() {
			return getRuleContext(Order_stmtContext.class,0);
		}
		public Offset_stmtContext offset_stmt() {
			return getRuleContext(Offset_stmtContext.class,0);
		}
		public Update_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_update_stmt_limited; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterUpdate_stmt_limited(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitUpdate_stmt_limited(this);
		}
	}

	public final Update_stmt_limitedContext update_stmt_limited() throws RecognitionException {
		Update_stmt_limitedContext _localctx = new Update_stmt_limitedContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_update_stmt_limited);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(936);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(935);
				with_clause();
				}
			}

			setState(938);
			match(K_UPDATE);
			setState(949);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
			case 1:
				{
				setState(939);
				match(K_OR);
				setState(940);
				match(K_ROLLBACK);
				}
				break;
			case 2:
				{
				setState(941);
				match(K_OR);
				setState(942);
				match(K_ABORT);
				}
				break;
			case 3:
				{
				setState(943);
				match(K_OR);
				setState(944);
				match(K_REPLACE);
				}
				break;
			case 4:
				{
				setState(945);
				match(K_OR);
				setState(946);
				match(K_FAIL);
				}
				break;
			case 5:
				{
				setState(947);
				match(K_OR);
				setState(948);
				match(K_IGNORE);
				}
				break;
			}
			setState(951);
			qualified_table_name();
			setState(952);
			match(K_SET);
			setState(953);
			column_name_to_update();
			setState(954);
			match(ASSIGN);
			setState(955);
			expr(0);
			setState(963);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(956);
				match(COMMA);
				setState(957);
				column_name_to_update();
				setState(958);
				match(ASSIGN);
				setState(959);
				expr(0);
				}
				}
				setState(965);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(967);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(966);
				where_stmt();
				}
			}

			setState(976);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT || _la==K_ORDER) {
				{
				setState(970);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_ORDER) {
					{
					setState(969);
					order_stmt();
					}
				}

				setState(972);
				limit_stmt();
				setState(974);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(973);
					offset_stmt();
					}
				}

				}
			}

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

	public static class Vacuum_stmtContext extends ParserRuleContext {
		public TerminalNode K_VACUUM() { return getToken(JqlParser.K_VACUUM, 0); }
		public Vacuum_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vacuum_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterVacuum_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitVacuum_stmt(this);
		}
	}

	public final Vacuum_stmtContext vacuum_stmt() throws RecognitionException {
		Vacuum_stmtContext _localctx = new Vacuum_stmtContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_vacuum_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(978);
			match(K_VACUUM);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_defContext extends ParserRuleContext {
		public Column_nameContext column_name() {
			return getRuleContext(Column_nameContext.class,0);
		}
		public Type_nameContext type_name() {
			return getRuleContext(Type_nameContext.class,0);
		}
		public List column_constraint() {
			return getRuleContexts(Column_constraintContext.class);
		}
		public Column_constraintContext column_constraint(int i) {
			return getRuleContext(Column_constraintContext.class,i);
		}
		public Column_defContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_def; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_def(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_def(this);
		}
	}

	public final Column_defContext column_def() throws RecognitionException {
		Column_defContext _localctx = new Column_defContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_column_def);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(980);
			column_name();
			setState(982);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
			case 1:
				{
				setState(981);
				type_name();
				}
				break;
			}
			setState(987);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_CONSTRAINT) | (1L << K_DEFAULT))) != 0) || ((((_la - 106)) & ~0x3f) == 0 && ((1L << (_la - 106)) & ((1L << (K_NOT - 106)) | (1L << (K_NULL - 106)) | (1L << (K_PRIMARY - 106)) | (1L << (K_REFERENCES - 106)) | (1L << (K_UNIQUE - 106)))) != 0)) {
				{
				{
				setState(984);
				column_constraint();
				}
				}
				setState(989);
				_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 Type_nameContext extends ParserRuleContext {
		public List name() {
			return getRuleContexts(NameContext.class);
		}
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public List signed_number() {
			return getRuleContexts(Signed_numberContext.class);
		}
		public Signed_numberContext signed_number(int i) {
			return getRuleContext(Signed_numberContext.class,i);
		}
		public Type_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterType_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitType_name(this);
		}
	}

	public final Type_nameContext type_name() throws RecognitionException {
		Type_nameContext _localctx = new Type_nameContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_type_name);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(991); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(990);
					name();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(993); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,139,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			setState(1005);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
			case 1:
				{
				setState(995);
				match(OPEN_PAR);
				setState(996);
				signed_number();
				setState(997);
				match(CLOSE_PAR);
				}
				break;
			case 2:
				{
				setState(999);
				match(OPEN_PAR);
				setState(1000);
				signed_number();
				setState(1001);
				match(COMMA);
				setState(1002);
				signed_number();
				setState(1003);
				match(CLOSE_PAR);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_constraintContext extends ParserRuleContext {
		public TerminalNode K_PRIMARY() { return getToken(JqlParser.K_PRIMARY, 0); }
		public TerminalNode K_KEY() { return getToken(JqlParser.K_KEY, 0); }
		public Conflict_clauseContext conflict_clause() {
			return getRuleContext(Conflict_clauseContext.class,0);
		}
		public TerminalNode K_NULL() { return getToken(JqlParser.K_NULL, 0); }
		public TerminalNode K_UNIQUE() { return getToken(JqlParser.K_UNIQUE, 0); }
		public TerminalNode K_CHECK() { return getToken(JqlParser.K_CHECK, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_DEFAULT() { return getToken(JqlParser.K_DEFAULT, 0); }
		public TerminalNode K_COLLATE() { return getToken(JqlParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public Foreign_key_clauseContext foreign_key_clause() {
			return getRuleContext(Foreign_key_clauseContext.class,0);
		}
		public TerminalNode K_CONSTRAINT() { return getToken(JqlParser.K_CONSTRAINT, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public Signed_numberContext signed_number() {
			return getRuleContext(Signed_numberContext.class,0);
		}
		public Literal_valueContext literal_value() {
			return getRuleContext(Literal_valueContext.class,0);
		}
		public TerminalNode K_AUTOINCREMENT() { return getToken(JqlParser.K_AUTOINCREMENT, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_ASC() { return getToken(JqlParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(JqlParser.K_DESC, 0); }
		public Column_constraintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_constraint; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_constraint(this);
		}
	}

	public final Column_constraintContext column_constraint() throws RecognitionException {
		Column_constraintContext _localctx = new Column_constraintContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_column_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1009);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_CONSTRAINT) {
				{
				setState(1007);
				match(K_CONSTRAINT);
				setState(1008);
				name();
				}
			}

			setState(1044);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_PRIMARY:
				{
				setState(1011);
				match(K_PRIMARY);
				setState(1012);
				match(K_KEY);
				setState(1014);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_ASC || _la==K_DESC) {
					{
					setState(1013);
					_la = _input.LA(1);
					if ( !(_la==K_ASC || _la==K_DESC) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
				}

				setState(1016);
				conflict_clause();
				setState(1018);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_AUTOINCREMENT) {
					{
					setState(1017);
					match(K_AUTOINCREMENT);
					}
				}

				}
				break;
			case K_NOT:
			case K_NULL:
				{
				setState(1021);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_NOT) {
					{
					setState(1020);
					match(K_NOT);
					}
				}

				setState(1023);
				match(K_NULL);
				setState(1024);
				conflict_clause();
				}
				break;
			case K_UNIQUE:
				{
				setState(1025);
				match(K_UNIQUE);
				setState(1026);
				conflict_clause();
				}
				break;
			case K_CHECK:
				{
				setState(1027);
				match(K_CHECK);
				setState(1028);
				match(OPEN_PAR);
				setState(1029);
				expr(0);
				setState(1030);
				match(CLOSE_PAR);
				}
				break;
			case K_DEFAULT:
				{
				setState(1032);
				match(K_DEFAULT);
				setState(1039);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
				case 1:
					{
					setState(1033);
					signed_number();
					}
					break;
				case 2:
					{
					setState(1034);
					literal_value();
					}
					break;
				case 3:
					{
					setState(1035);
					match(OPEN_PAR);
					setState(1036);
					expr(0);
					setState(1037);
					match(CLOSE_PAR);
					}
					break;
				}
				}
				break;
			case K_COLLATE:
				{
				setState(1041);
				match(K_COLLATE);
				setState(1042);
				collation_name();
				}
				break;
			case K_REFERENCES:
				{
				setState(1043);
				foreign_key_clause();
				}
				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 Conflict_clauseContext extends ParserRuleContext {
		public TerminalNode K_ON() { return getToken(JqlParser.K_ON, 0); }
		public TerminalNode K_CONFLICT() { return getToken(JqlParser.K_CONFLICT, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(JqlParser.K_ABORT, 0); }
		public TerminalNode K_FAIL() { return getToken(JqlParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(JqlParser.K_IGNORE, 0); }
		public TerminalNode K_REPLACE() { return getToken(JqlParser.K_REPLACE, 0); }
		public Conflict_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conflict_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterConflict_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitConflict_clause(this);
		}
	}

	public final Conflict_clauseContext conflict_clause() throws RecognitionException {
		Conflict_clauseContext _localctx = new Conflict_clauseContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_conflict_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1049);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ON) {
				{
				setState(1046);
				match(K_ON);
				setState(1047);
				match(K_CONFLICT);
				setState(1048);
				_la = _input.LA(1);
				if ( !(_la==K_ABORT || ((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (K_FAIL - 76)) | (1L << (K_IGNORE - 76)) | (1L << (K_REPLACE - 76)) | (1L << (K_ROLLBACK - 76)))) != 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 ExprContext extends ParserRuleContext {
		public Literal_valueContext literal_value() {
			return getRuleContext(Literal_valueContext.class,0);
		}
		public Bind_parameterContext bind_parameter() {
			return getRuleContext(Bind_parameterContext.class,0);
		}
		public Bind_dynamic_sqlContext bind_dynamic_sql() {
			return getRuleContext(Bind_dynamic_sqlContext.class,0);
		}
		public Column_nameContext column_name() {
			return getRuleContext(Column_nameContext.class,0);
		}
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Unary_operatorContext unary_operator() {
			return getRuleContext(Unary_operatorContext.class,0);
		}
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public TerminalNode K_DISTINCT() { return getToken(JqlParser.K_DISTINCT, 0); }
		public TerminalNode K_CAST() { return getToken(JqlParser.K_CAST, 0); }
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Type_nameContext type_name() {
			return getRuleContext(Type_nameContext.class,0);
		}
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_CASE() { return getToken(JqlParser.K_CASE, 0); }
		public TerminalNode K_END() { return getToken(JqlParser.K_END, 0); }
		public List K_WHEN() { return getTokens(JqlParser.K_WHEN); }
		public TerminalNode K_WHEN(int i) {
			return getToken(JqlParser.K_WHEN, i);
		}
		public List K_THEN() { return getTokens(JqlParser.K_THEN); }
		public TerminalNode K_THEN(int i) {
			return getToken(JqlParser.K_THEN, i);
		}
		public TerminalNode K_ELSE() { return getToken(JqlParser.K_ELSE, 0); }
		public Raise_functionContext raise_function() {
			return getRuleContext(Raise_functionContext.class,0);
		}
		public TerminalNode K_IS() { return getToken(JqlParser.K_IS, 0); }
		public TerminalNode K_IN() { return getToken(JqlParser.K_IN, 0); }
		public TerminalNode K_LIKE() { return getToken(JqlParser.K_LIKE, 0); }
		public TerminalNode K_GLOB() { return getToken(JqlParser.K_GLOB, 0); }
		public TerminalNode K_MATCH() { return getToken(JqlParser.K_MATCH, 0); }
		public TerminalNode K_REGEXP() { return getToken(JqlParser.K_REGEXP, 0); }
		public TerminalNode K_AND() { return getToken(JqlParser.K_AND, 0); }
		public TerminalNode K_OR() { return getToken(JqlParser.K_OR, 0); }
		public TerminalNode K_BETWEEN() { return getToken(JqlParser.K_BETWEEN, 0); }
		public TerminalNode K_COLLATE() { return getToken(JqlParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_ESCAPE() { return getToken(JqlParser.K_ESCAPE, 0); }
		public TerminalNode K_ISNULL() { return getToken(JqlParser.K_ISNULL, 0); }
		public TerminalNode K_NOTNULL() { return getToken(JqlParser.K_NOTNULL, 0); }
		public TerminalNode K_NULL() { return getToken(JqlParser.K_NULL, 0); }
		public ExprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitExpr(this);
		}
	}

	public final ExprContext expr() throws RecognitionException {
		return expr(0);
	}

	private ExprContext expr(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ExprContext _localctx = new ExprContext(_ctx, _parentState);
		ExprContext _prevctx = _localctx;
		int _startState = 88;
		enterRecursionRule(_localctx, 88, RULE_expr, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1128);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
			case 1:
				{
				setState(1052);
				literal_value();
				}
				break;
			case 2:
				{
				setState(1053);
				bind_parameter();
				}
				break;
			case 3:
				{
				setState(1054);
				bind_dynamic_sql();
				}
				break;
			case 4:
				{
				setState(1063);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
				case 1:
					{
					setState(1058);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
					case 1:
						{
						setState(1055);
						database_name();
						setState(1056);
						match(DOT);
						}
						break;
					}
					setState(1060);
					table_name();
					setState(1061);
					match(DOT);
					}
					break;
				}
				setState(1065);
				column_name();
				}
				break;
			case 5:
				{
				setState(1066);
				unary_operator();
				setState(1067);
				expr(21);
				}
				break;
			case 6:
				{
				setState(1069);
				function_name();
				setState(1070);
				match(OPEN_PAR);
				setState(1083);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case T__0:
				case T__3:
				case OPEN_PAR:
				case PLUS:
				case MINUS:
				case TILDE:
				case K_ABORT:
				case K_ACTION:
				case K_ADD:
				case K_AFTER:
				case K_ALL:
				case K_ALTER:
				case K_ANALYZE:
				case K_AND:
				case K_AS:
				case K_ASC:
				case K_ATTACH:
				case K_AUTOINCREMENT:
				case K_BEFORE:
				case K_BEGIN:
				case K_BETWEEN:
				case K_BY:
				case K_CASCADE:
				case K_CASE:
				case K_CAST:
				case K_CHECK:
				case K_COLLATE:
				case K_COLUMN:
				case K_COMMIT:
				case K_CONFLICT:
				case K_CONSTRAINT:
				case K_CREATE:
				case K_CROSS:
				case K_CURRENT_DATE:
				case K_CURRENT_TIME:
				case K_CURRENT_TIMESTAMP:
				case K_DATABASE:
				case K_DEFAULT:
				case K_DEFERRABLE:
				case K_DEFERRED:
				case K_DELETE:
				case K_DESC:
				case K_DETACH:
				case K_DISTINCT:
				case K_DROP:
				case K_EACH:
				case K_ELSE:
				case K_END:
				case K_ESCAPE:
				case K_EXCEPT:
				case K_EXCLUSIVE:
				case K_EXISTS:
				case K_EXPLAIN:
				case K_FAIL:
				case K_FOR:
				case K_FOREIGN:
				case K_FROM:
				case K_FULL:
				case K_GLOB:
				case K_GROUP:
				case K_HAVING:
				case K_IF:
				case K_IGNORE:
				case K_IMMEDIATE:
				case K_IN:
				case K_INDEX:
				case K_INDEXED:
				case K_INITIALLY:
				case K_INNER:
				case K_INSERT:
				case K_INSTEAD:
				case K_INTERSECT:
				case K_INTO:
				case K_IS:
				case K_ISNULL:
				case K_JOIN:
				case K_KEY:
				case K_LEFT:
				case K_LIKE:
				case K_LIMIT:
				case K_MATCH:
				case K_NATURAL:
				case K_NO:
				case K_NOT:
				case K_NOTNULL:
				case K_NULL:
				case K_OF:
				case K_OFFSET:
				case K_ON:
				case K_OR:
				case K_ORDER:
				case K_OUTER:
				case K_PLAN:
				case K_PRAGMA:
				case K_PRIMARY:
				case K_QUERY:
				case K_RAISE:
				case K_RECURSIVE:
				case K_REFERENCES:
				case K_REGEXP:
				case K_REINDEX:
				case K_RELEASE:
				case K_RENAME:
				case K_REPLACE:
				case K_RESTRICT:
				case K_RIGHT:
				case K_ROLLBACK:
				case K_ROW:
				case K_SAVEPOINT:
				case K_SELECT:
				case K_SET:
				case K_TABLE:
				case K_TEMP:
				case K_TEMPORARY:
				case K_THEN:
				case K_TO:
				case K_TRANSACTION:
				case K_TRIGGER:
				case K_UNION:
				case K_UNIQUE:
				case K_UPDATE:
				case K_USING:
				case K_VACUUM:
				case K_VALUES:
				case K_VIEW:
				case K_VIRTUAL:
				case K_WHEN:
				case K_WHERE:
				case K_WITH:
				case K_WITHOUT:
				case IDENTIFIER:
				case NUMERIC_LITERAL:
				case BIND_PARAMETER:
				case STRING_LITERAL:
				case BLOB_LITERAL:
					{
					setState(1072);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
					case 1:
						{
						setState(1071);
						match(K_DISTINCT);
						}
						break;
					}
					setState(1074);
					expr(0);
					setState(1079);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(1075);
						match(COMMA);
						setState(1076);
						expr(0);
						}
						}
						setState(1081);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
					break;
				case STAR:
					{
					setState(1082);
					match(STAR);
					}
					break;
				case CLOSE_PAR:
					break;
				default:
					break;
				}
				setState(1085);
				match(CLOSE_PAR);
				}
				break;
			case 7:
				{
				setState(1087);
				match(OPEN_PAR);
				setState(1088);
				expr(0);
				setState(1089);
				match(CLOSE_PAR);
				}
				break;
			case 8:
				{
				setState(1091);
				match(K_CAST);
				setState(1092);
				match(OPEN_PAR);
				setState(1093);
				expr(0);
				setState(1094);
				match(K_AS);
				setState(1095);
				type_name();
				setState(1096);
				match(CLOSE_PAR);
				}
				break;
			case 9:
				{
				setState(1102);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_EXISTS || _la==K_NOT) {
					{
					setState(1099);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_NOT) {
						{
						setState(1098);
						match(K_NOT);
						}
					}

					setState(1101);
					match(K_EXISTS);
					}
				}

				setState(1104);
				match(OPEN_PAR);
				setState(1105);
				select_stmt();
				setState(1106);
				match(CLOSE_PAR);
				}
				break;
			case 10:
				{
				setState(1108);
				match(K_CASE);
				setState(1110);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
				case 1:
					{
					setState(1109);
					expr(0);
					}
					break;
				}
				setState(1117); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(1112);
					match(K_WHEN);
					setState(1113);
					expr(0);
					setState(1114);
					match(K_THEN);
					setState(1115);
					expr(0);
					}
					}
					setState(1119); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==K_WHEN );
				setState(1123);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_ELSE) {
					{
					setState(1121);
					match(K_ELSE);
					setState(1122);
					expr(0);
					}
				}

				setState(1125);
				match(K_END);
				}
				break;
			case 11:
				{
				setState(1127);
				raise_function();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(1230);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,171,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(1228);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
					case 1:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1130);
						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
						setState(1131);
						match(PIPE2);
						setState(1132);
						expr(21);
						}
						break;
					case 2:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1133);
						if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
						setState(1134);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << DIV) | (1L << MOD))) != 0)) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(1135);
						expr(20);
						}
						break;
					case 3:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1136);
						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
						setState(1137);
						_la = _input.LA(1);
						if ( !(_la==PLUS || _la==MINUS) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(1138);
						expr(19);
						}
						break;
					case 4:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1139);
						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
						setState(1140);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT2) | (1L << GT2) | (1L << AMP) | (1L << PIPE))) != 0)) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(1141);
						expr(18);
						}
						break;
					case 5:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1142);
						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
						setState(1143);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT) | (1L << LT_EQ) | (1L << GT) | (1L << GT_EQ))) != 0)) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(1144);
						expr(17);
						}
						break;
					case 6:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1145);
						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
						setState(1158);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
						case 1:
							{
							setState(1146);
							match(ASSIGN);
							}
							break;
						case 2:
							{
							setState(1147);
							match(EQ);
							}
							break;
						case 3:
							{
							setState(1148);
							match(NOT_EQ1);
							}
							break;
						case 4:
							{
							setState(1149);
							match(NOT_EQ2);
							}
							break;
						case 5:
							{
							setState(1150);
							match(K_IS);
							}
							break;
						case 6:
							{
							setState(1151);
							match(K_IS);
							setState(1152);
							match(K_NOT);
							}
							break;
						case 7:
							{
							setState(1153);
							match(K_IN);
							}
							break;
						case 8:
							{
							setState(1154);
							match(K_LIKE);
							}
							break;
						case 9:
							{
							setState(1155);
							match(K_GLOB);
							}
							break;
						case 10:
							{
							setState(1156);
							match(K_MATCH);
							}
							break;
						case 11:
							{
							setState(1157);
							match(K_REGEXP);
							}
							break;
						}
						setState(1160);
						expr(16);
						}
						break;
					case 7:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1161);
						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
						setState(1162);
						match(K_AND);
						setState(1163);
						expr(15);
						}
						break;
					case 8:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1164);
						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
						setState(1165);
						match(K_OR);
						setState(1166);
						expr(14);
						}
						break;
					case 9:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1167);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(1168);
						match(K_IS);
						setState(1170);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
						case 1:
							{
							setState(1169);
							match(K_NOT);
							}
							break;
						}
						setState(1172);
						expr(7);
						}
						break;
					case 10:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1173);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(1175);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(1174);
							match(K_NOT);
							}
						}

						setState(1177);
						match(K_BETWEEN);
						setState(1178);
						expr(0);
						setState(1179);
						match(K_AND);
						setState(1180);
						expr(6);
						}
						break;
					case 11:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1182);
						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
						setState(1183);
						match(K_COLLATE);
						setState(1184);
						collation_name();
						}
						break;
					case 12:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1185);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(1187);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(1186);
							match(K_NOT);
							}
						}

						setState(1189);
						_la = _input.LA(1);
						if ( !(((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (K_GLOB - 81)) | (1L << (K_LIKE - 81)) | (1L << (K_MATCH - 81)) | (1L << (K_REGEXP - 81)))) != 0)) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						setState(1190);
						expr(0);
						setState(1193);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
						case 1:
							{
							setState(1191);
							match(K_ESCAPE);
							setState(1192);
							expr(0);
							}
							break;
						}
						}
						break;
					case 13:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1195);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(1200);
						_errHandler.sync(this);
						switch (_input.LA(1)) {
						case K_ISNULL:
							{
							setState(1196);
							match(K_ISNULL);
							}
							break;
						case K_NOTNULL:
							{
							setState(1197);
							match(K_NOTNULL);
							}
							break;
						case K_NOT:
							{
							setState(1198);
							match(K_NOT);
							setState(1199);
							match(K_NULL);
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						}
						break;
					case 14:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(1202);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(1204);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(1203);
							match(K_NOT);
							}
						}

						setState(1206);
						match(K_IN);
						setState(1226);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
						case 1:
							{
							setState(1207);
							match(OPEN_PAR);
							setState(1217);
							_errHandler.sync(this);
							switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
							case 1:
								{
								setState(1208);
								select_stmt();
								}
								break;
							case 2:
								{
								setState(1209);
								expr(0);
								setState(1214);
								_errHandler.sync(this);
								_la = _input.LA(1);
								while (_la==COMMA) {
									{
									{
									setState(1210);
									match(COMMA);
									setState(1211);
									expr(0);
									}
									}
									setState(1216);
									_errHandler.sync(this);
									_la = _input.LA(1);
								}
								}
								break;
							}
							setState(1219);
							match(CLOSE_PAR);
							}
							break;
						case 2:
							{
							setState(1223);
							_errHandler.sync(this);
							switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
							case 1:
								{
								setState(1220);
								database_name();
								setState(1221);
								match(DOT);
								}
								break;
							}
							setState(1225);
							table_name();
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(1232);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,171,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Bind_parameterContext extends ParserRuleContext {
		public TerminalNode BIND_PARAMETER() { return getToken(JqlParser.BIND_PARAMETER, 0); }
		public Bind_parameter_nameContext bind_parameter_name() {
			return getRuleContext(Bind_parameter_nameContext.class,0);
		}
		public List SPACES() { return getTokens(JqlParser.SPACES); }
		public TerminalNode SPACES(int i) {
			return getToken(JqlParser.SPACES, i);
		}
		public Bind_parameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bind_parameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterBind_parameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitBind_parameter(this);
		}
	}

	public final Bind_parameterContext bind_parameter() throws RecognitionException {
		Bind_parameterContext _localctx = new Bind_parameterContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_bind_parameter);
		int _la;
		try {
			setState(1257);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case BIND_PARAMETER:
				enterOuterAlt(_localctx, 1);
				{
				setState(1233);
				match(BIND_PARAMETER);
				}
				break;
			case T__0:
				enterOuterAlt(_localctx, 2);
				{
				setState(1234);
				match(T__0);
				setState(1238);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==SPACES) {
					{
					{
					setState(1235);
					match(SPACES);
					}
					}
					setState(1240);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1241);
				match(T__1);
				setState(1245);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==SPACES) {
					{
					{
					setState(1242);
					match(SPACES);
					}
					}
					setState(1247);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1248);
				bind_parameter_name();
				setState(1252);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==SPACES) {
					{
					{
					setState(1249);
					match(SPACES);
					}
					}
					setState(1254);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1255);
				match(T__2);
				}
				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 Bind_parameter_nameContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(JqlParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(JqlParser.IDENTIFIER, i);
		}
		public Bind_parameter_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bind_parameter_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterBind_parameter_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitBind_parameter_name(this);
		}
	}

	public final Bind_parameter_nameContext bind_parameter_name() throws RecognitionException {
		Bind_parameter_nameContext _localctx = new Bind_parameter_nameContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_bind_parameter_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1261);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
			case 1:
				{
				setState(1259);
				match(IDENTIFIER);
				setState(1260);
				match(DOT);
				}
				break;
			}
			setState(1263);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Bind_dynamic_sqlContext extends ParserRuleContext {
		public Bind_parameter_nameContext bind_parameter_name() {
			return getRuleContext(Bind_parameter_nameContext.class,0);
		}
		public List SPACES() { return getTokens(JqlParser.SPACES); }
		public TerminalNode SPACES(int i) {
			return getToken(JqlParser.SPACES, i);
		}
		public Bind_dynamic_sqlContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bind_dynamic_sql; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterBind_dynamic_sql(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitBind_dynamic_sql(this);
		}
	}

	public final Bind_dynamic_sqlContext bind_dynamic_sql() throws RecognitionException {
		Bind_dynamic_sqlContext _localctx = new Bind_dynamic_sqlContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_bind_dynamic_sql);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1265);
			match(T__3);
			setState(1269);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SPACES) {
				{
				{
				setState(1266);
				match(SPACES);
				}
				}
				setState(1271);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(1272);
			match(T__1);
			setState(1276);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SPACES) {
				{
				{
				setState(1273);
				match(SPACES);
				}
				}
				setState(1278);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(1279);
			bind_parameter_name();
			setState(1283);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SPACES) {
				{
				{
				setState(1280);
				match(SPACES);
				}
				}
				setState(1285);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(1286);
			match(T__2);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Foreign_key_clauseContext extends ParserRuleContext {
		public TerminalNode K_REFERENCES() { return getToken(JqlParser.K_REFERENCES, 0); }
		public Foreign_tableContext foreign_table() {
			return getRuleContext(Foreign_tableContext.class,0);
		}
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public TerminalNode K_DEFERRABLE() { return getToken(JqlParser.K_DEFERRABLE, 0); }
		public List K_ON() { return getTokens(JqlParser.K_ON); }
		public TerminalNode K_ON(int i) {
			return getToken(JqlParser.K_ON, i);
		}
		public List K_MATCH() { return getTokens(JqlParser.K_MATCH); }
		public TerminalNode K_MATCH(int i) {
			return getToken(JqlParser.K_MATCH, i);
		}
		public List name() {
			return getRuleContexts(NameContext.class);
		}
		public NameContext name(int i) {
			return getRuleContext(NameContext.class,i);
		}
		public List K_DELETE() { return getTokens(JqlParser.K_DELETE); }
		public TerminalNode K_DELETE(int i) {
			return getToken(JqlParser.K_DELETE, i);
		}
		public List K_UPDATE() { return getTokens(JqlParser.K_UPDATE); }
		public TerminalNode K_UPDATE(int i) {
			return getToken(JqlParser.K_UPDATE, i);
		}
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_INITIALLY() { return getToken(JqlParser.K_INITIALLY, 0); }
		public TerminalNode K_DEFERRED() { return getToken(JqlParser.K_DEFERRED, 0); }
		public TerminalNode K_IMMEDIATE() { return getToken(JqlParser.K_IMMEDIATE, 0); }
		public List K_SET() { return getTokens(JqlParser.K_SET); }
		public TerminalNode K_SET(int i) {
			return getToken(JqlParser.K_SET, i);
		}
		public List K_NULL() { return getTokens(JqlParser.K_NULL); }
		public TerminalNode K_NULL(int i) {
			return getToken(JqlParser.K_NULL, i);
		}
		public List K_DEFAULT() { return getTokens(JqlParser.K_DEFAULT); }
		public TerminalNode K_DEFAULT(int i) {
			return getToken(JqlParser.K_DEFAULT, i);
		}
		public List K_CASCADE() { return getTokens(JqlParser.K_CASCADE); }
		public TerminalNode K_CASCADE(int i) {
			return getToken(JqlParser.K_CASCADE, i);
		}
		public List K_RESTRICT() { return getTokens(JqlParser.K_RESTRICT); }
		public TerminalNode K_RESTRICT(int i) {
			return getToken(JqlParser.K_RESTRICT, i);
		}
		public List K_NO() { return getTokens(JqlParser.K_NO); }
		public TerminalNode K_NO(int i) {
			return getToken(JqlParser.K_NO, i);
		}
		public List K_ACTION() { return getTokens(JqlParser.K_ACTION); }
		public TerminalNode K_ACTION(int i) {
			return getToken(JqlParser.K_ACTION, i);
		}
		public Foreign_key_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_foreign_key_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterForeign_key_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitForeign_key_clause(this);
		}
	}

	public final Foreign_key_clauseContext foreign_key_clause() throws RecognitionException {
		Foreign_key_clauseContext _localctx = new Foreign_key_clauseContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_foreign_key_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1288);
			match(K_REFERENCES);
			setState(1289);
			foreign_table();
			setState(1301);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(1290);
				match(OPEN_PAR);
				setState(1291);
				column_name();
				setState(1296);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1292);
					match(COMMA);
					setState(1293);
					column_name();
					}
					}
					setState(1298);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1299);
				match(CLOSE_PAR);
				}
			}

			setState(1321);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_MATCH || _la==K_ON) {
				{
				{
				setState(1317);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case K_ON:
					{
					setState(1303);
					match(K_ON);
					setState(1304);
					_la = _input.LA(1);
					if ( !(_la==K_DELETE || _la==K_UPDATE) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(1313);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
					case 1:
						{
						setState(1305);
						match(K_SET);
						setState(1306);
						match(K_NULL);
						}
						break;
					case 2:
						{
						setState(1307);
						match(K_SET);
						setState(1308);
						match(K_DEFAULT);
						}
						break;
					case 3:
						{
						setState(1309);
						match(K_CASCADE);
						}
						break;
					case 4:
						{
						setState(1310);
						match(K_RESTRICT);
						}
						break;
					case 5:
						{
						setState(1311);
						match(K_NO);
						setState(1312);
						match(K_ACTION);
						}
						break;
					}
					}
					break;
				case K_MATCH:
					{
					setState(1315);
					match(K_MATCH);
					setState(1316);
					name();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				}
				setState(1323);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(1334);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) {
			case 1:
				{
				setState(1325);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_NOT) {
					{
					setState(1324);
					match(K_NOT);
					}
				}

				setState(1327);
				match(K_DEFERRABLE);
				setState(1332);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
				case 1:
					{
					setState(1328);
					match(K_INITIALLY);
					setState(1329);
					match(K_DEFERRED);
					}
					break;
				case 2:
					{
					setState(1330);
					match(K_INITIALLY);
					setState(1331);
					match(K_IMMEDIATE);
					}
					break;
				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Raise_functionContext extends ParserRuleContext {
		public TerminalNode K_RAISE() { return getToken(JqlParser.K_RAISE, 0); }
		public TerminalNode K_IGNORE() { return getToken(JqlParser.K_IGNORE, 0); }
		public Error_messageContext error_message() {
			return getRuleContext(Error_messageContext.class,0);
		}
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(JqlParser.K_ABORT, 0); }
		public TerminalNode K_FAIL() { return getToken(JqlParser.K_FAIL, 0); }
		public Raise_functionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_raise_function; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterRaise_function(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitRaise_function(this);
		}
	}

	public final Raise_functionContext raise_function() throws RecognitionException {
		Raise_functionContext _localctx = new Raise_functionContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_raise_function);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1336);
			match(K_RAISE);
			setState(1337);
			match(OPEN_PAR);
			setState(1342);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_IGNORE:
				{
				setState(1338);
				match(K_IGNORE);
				}
				break;
			case K_ABORT:
			case K_FAIL:
			case K_ROLLBACK:
				{
				setState(1339);
				_la = _input.LA(1);
				if ( !(_la==K_ABORT || _la==K_FAIL || _la==K_ROLLBACK) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(1340);
				match(COMMA);
				setState(1341);
				error_message();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(1344);
			match(CLOSE_PAR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Indexed_columnContext extends ParserRuleContext {
		public Column_nameContext column_name() {
			return getRuleContext(Column_nameContext.class,0);
		}
		public TerminalNode K_COLLATE() { return getToken(JqlParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_ASC() { return getToken(JqlParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(JqlParser.K_DESC, 0); }
		public Indexed_columnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexed_column; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterIndexed_column(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitIndexed_column(this);
		}
	}

	public final Indexed_columnContext indexed_column() throws RecognitionException {
		Indexed_columnContext _localctx = new Indexed_columnContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_indexed_column);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1346);
			column_name();
			setState(1349);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_COLLATE) {
				{
				setState(1347);
				match(K_COLLATE);
				setState(1348);
				collation_name();
				}
			}

			setState(1352);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ASC || _la==K_DESC) {
				{
				setState(1351);
				_la = _input.LA(1);
				if ( !(_la==K_ASC || _la==K_DESC) ) {
				_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 Table_constraintContext extends ParserRuleContext {
		public List indexed_column() {
			return getRuleContexts(Indexed_columnContext.class);
		}
		public Indexed_columnContext indexed_column(int i) {
			return getRuleContext(Indexed_columnContext.class,i);
		}
		public Conflict_clauseContext conflict_clause() {
			return getRuleContext(Conflict_clauseContext.class,0);
		}
		public TerminalNode K_CHECK() { return getToken(JqlParser.K_CHECK, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_FOREIGN() { return getToken(JqlParser.K_FOREIGN, 0); }
		public TerminalNode K_KEY() { return getToken(JqlParser.K_KEY, 0); }
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public Foreign_key_clauseContext foreign_key_clause() {
			return getRuleContext(Foreign_key_clauseContext.class,0);
		}
		public TerminalNode K_CONSTRAINT() { return getToken(JqlParser.K_CONSTRAINT, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TerminalNode K_PRIMARY() { return getToken(JqlParser.K_PRIMARY, 0); }
		public TerminalNode K_UNIQUE() { return getToken(JqlParser.K_UNIQUE, 0); }
		public Table_constraintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table_constraint; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTable_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTable_constraint(this);
		}
	}

	public final Table_constraintContext table_constraint() throws RecognitionException {
		Table_constraintContext _localctx = new Table_constraintContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_table_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1356);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_CONSTRAINT) {
				{
				setState(1354);
				match(K_CONSTRAINT);
				setState(1355);
				name();
				}
			}

			setState(1394);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_PRIMARY:
			case K_UNIQUE:
				{
				setState(1361);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case K_PRIMARY:
					{
					setState(1358);
					match(K_PRIMARY);
					setState(1359);
					match(K_KEY);
					}
					break;
				case K_UNIQUE:
					{
					setState(1360);
					match(K_UNIQUE);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(1363);
				match(OPEN_PAR);
				setState(1364);
				indexed_column();
				setState(1369);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1365);
					match(COMMA);
					setState(1366);
					indexed_column();
					}
					}
					setState(1371);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1372);
				match(CLOSE_PAR);
				setState(1373);
				conflict_clause();
				}
				break;
			case K_CHECK:
				{
				setState(1375);
				match(K_CHECK);
				setState(1376);
				match(OPEN_PAR);
				setState(1377);
				expr(0);
				setState(1378);
				match(CLOSE_PAR);
				}
				break;
			case K_FOREIGN:
				{
				setState(1380);
				match(K_FOREIGN);
				setState(1381);
				match(K_KEY);
				setState(1382);
				match(OPEN_PAR);
				setState(1383);
				column_name();
				setState(1388);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1384);
					match(COMMA);
					setState(1385);
					column_name();
					}
					}
					setState(1390);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1391);
				match(CLOSE_PAR);
				setState(1392);
				foreign_key_clause();
				}
				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 With_clauseContext extends ParserRuleContext {
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public List cte_table_name() {
			return getRuleContexts(Cte_table_nameContext.class);
		}
		public Cte_table_nameContext cte_table_name(int i) {
			return getRuleContext(Cte_table_nameContext.class,i);
		}
		public List K_AS() { return getTokens(JqlParser.K_AS); }
		public TerminalNode K_AS(int i) {
			return getToken(JqlParser.K_AS, i);
		}
		public List select_stmt() {
			return getRuleContexts(Select_stmtContext.class);
		}
		public Select_stmtContext select_stmt(int i) {
			return getRuleContext(Select_stmtContext.class,i);
		}
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public With_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_with_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterWith_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitWith_clause(this);
		}
	}

	public final With_clauseContext with_clause() throws RecognitionException {
		With_clauseContext _localctx = new With_clauseContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_with_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1396);
			match(K_WITH);
			setState(1398);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
			case 1:
				{
				setState(1397);
				match(K_RECURSIVE);
				}
				break;
			}
			setState(1400);
			cte_table_name();
			setState(1401);
			match(K_AS);
			setState(1402);
			match(OPEN_PAR);
			setState(1403);
			select_stmt();
			setState(1404);
			match(CLOSE_PAR);
			setState(1414);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1405);
				match(COMMA);
				setState(1406);
				cte_table_name();
				setState(1407);
				match(K_AS);
				setState(1408);
				match(OPEN_PAR);
				setState(1409);
				select_stmt();
				setState(1410);
				match(CLOSE_PAR);
				}
				}
				setState(1416);
				_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 Where_stmtContext extends ParserRuleContext {
		public TerminalNode K_WHERE() { return getToken(JqlParser.K_WHERE, 0); }
		public Where_stmt_clausesContext where_stmt_clauses() {
			return getRuleContext(Where_stmt_clausesContext.class,0);
		}
		public Where_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_where_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterWhere_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitWhere_stmt(this);
		}
	}

	public final Where_stmtContext where_stmt() throws RecognitionException {
		Where_stmtContext _localctx = new Where_stmtContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_where_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1417);
			match(K_WHERE);
			setState(1418);
			where_stmt_clauses();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Where_stmt_clausesContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Where_stmt_clausesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_where_stmt_clauses; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterWhere_stmt_clauses(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitWhere_stmt_clauses(this);
		}
	}

	public final Where_stmt_clausesContext where_stmt_clauses() throws RecognitionException {
		Where_stmt_clausesContext _localctx = new Where_stmt_clausesContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_where_stmt_clauses);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1420);
			expr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Qualified_table_nameContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public TerminalNode K_INDEXED() { return getToken(JqlParser.K_INDEXED, 0); }
		public TerminalNode K_BY() { return getToken(JqlParser.K_BY, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public Qualified_table_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_qualified_table_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterQualified_table_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitQualified_table_name(this);
		}
	}

	public final Qualified_table_nameContext qualified_table_name() throws RecognitionException {
		Qualified_table_nameContext _localctx = new Qualified_table_nameContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_qualified_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1425);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
			case 1:
				{
				setState(1422);
				database_name();
				setState(1423);
				match(DOT);
				}
				break;
			}
			setState(1427);
			table_name();
			setState(1433);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_INDEXED:
				{
				setState(1428);
				match(K_INDEXED);
				setState(1429);
				match(K_BY);
				setState(1430);
				index_name();
				}
				break;
			case K_NOT:
				{
				setState(1431);
				match(K_NOT);
				setState(1432);
				match(K_INDEXED);
				}
				break;
			case EOF:
			case SCOL:
			case K_ALTER:
			case K_ANALYZE:
			case K_ATTACH:
			case K_BEGIN:
			case K_COMMIT:
			case K_CREATE:
			case K_DELETE:
			case K_DETACH:
			case K_DROP:
			case K_END:
			case K_EXPLAIN:
			case K_INSERT:
			case K_LIMIT:
			case K_ORDER:
			case K_PRAGMA:
			case K_REINDEX:
			case K_RELEASE:
			case K_REPLACE:
			case K_ROLLBACK:
			case K_SAVEPOINT:
			case K_SELECT:
			case K_SET:
			case K_UPDATE:
			case K_VACUUM:
			case K_VALUES:
			case K_WHERE:
			case K_WITH:
			case UNEXPECTED_CHAR:
				break;
			default:
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Offset_stmtContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_OFFSET() { return getToken(JqlParser.K_OFFSET, 0); }
		public Offset_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_offset_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterOffset_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitOffset_stmt(this);
		}
	}

	public final Offset_stmtContext offset_stmt() throws RecognitionException {
		Offset_stmtContext _localctx = new Offset_stmtContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_offset_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1435);
			_la = _input.LA(1);
			if ( !(_la==COMMA || _la==K_OFFSET) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(1436);
			expr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Order_stmtContext extends ParserRuleContext {
		public TerminalNode K_ORDER() { return getToken(JqlParser.K_ORDER, 0); }
		public TerminalNode K_BY() { return getToken(JqlParser.K_BY, 0); }
		public List ordering_term() {
			return getRuleContexts(Ordering_termContext.class);
		}
		public Ordering_termContext ordering_term(int i) {
			return getRuleContext(Ordering_termContext.class,i);
		}
		public Order_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_order_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterOrder_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitOrder_stmt(this);
		}
	}

	public final Order_stmtContext order_stmt() throws RecognitionException {
		Order_stmtContext _localctx = new Order_stmtContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_order_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1438);
			match(K_ORDER);
			setState(1439);
			match(K_BY);
			setState(1440);
			ordering_term();
			setState(1445);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1441);
				match(COMMA);
				setState(1442);
				ordering_term();
				}
				}
				setState(1447);
				_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 Ordering_termContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_COLLATE() { return getToken(JqlParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_ASC() { return getToken(JqlParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(JqlParser.K_DESC, 0); }
		public Ordering_termContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ordering_term; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterOrdering_term(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitOrdering_term(this);
		}
	}

	public final Ordering_termContext ordering_term() throws RecognitionException {
		Ordering_termContext _localctx = new Ordering_termContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_ordering_term);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1448);
			expr(0);
			setState(1451);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_COLLATE) {
				{
				setState(1449);
				match(K_COLLATE);
				setState(1450);
				collation_name();
				}
			}

			setState(1454);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ASC || _la==K_DESC) {
				{
				setState(1453);
				_la = _input.LA(1);
				if ( !(_la==K_ASC || _la==K_DESC) ) {
				_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 Pragma_valueContext extends ParserRuleContext {
		public Signed_numberContext signed_number() {
			return getRuleContext(Signed_numberContext.class,0);
		}
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TerminalNode STRING_LITERAL() { return getToken(JqlParser.STRING_LITERAL, 0); }
		public Pragma_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pragma_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterPragma_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitPragma_value(this);
		}
	}

	public final Pragma_valueContext pragma_value() throws RecognitionException {
		Pragma_valueContext _localctx = new Pragma_valueContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_pragma_value);
		try {
			setState(1459);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1456);
				signed_number();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1457);
				name();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1458);
				match(STRING_LITERAL);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Common_table_expressionContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public Common_table_expressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_common_table_expression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCommon_table_expression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCommon_table_expression(this);
		}
	}

	public final Common_table_expressionContext common_table_expression() throws RecognitionException {
		Common_table_expressionContext _localctx = new Common_table_expressionContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_common_table_expression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1461);
			table_name();
			setState(1473);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(1462);
				match(OPEN_PAR);
				setState(1463);
				column_name();
				setState(1468);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1464);
					match(COMMA);
					setState(1465);
					column_name();
					}
					}
					setState(1470);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1471);
				match(CLOSE_PAR);
				}
			}

			setState(1475);
			match(K_AS);
			setState(1476);
			match(OPEN_PAR);
			setState(1477);
			select_stmt();
			setState(1478);
			match(CLOSE_PAR);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Result_columnContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Column_aliasContext column_alias() {
			return getRuleContext(Column_aliasContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public Result_columnContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_result_column; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterResult_column(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitResult_column(this);
		}
	}

	public final Result_columnContext result_column() throws RecognitionException {
		Result_columnContext _localctx = new Result_columnContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_result_column);
		int _la;
		try {
			setState(1492);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1480);
				match(STAR);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1481);
				table_name();
				setState(1482);
				match(DOT);
				setState(1483);
				match(STAR);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1485);
				expr(0);
				setState(1490);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_AS || _la==IDENTIFIER || _la==STRING_LITERAL) {
					{
					setState(1487);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_AS) {
						{
						setState(1486);
						match(K_AS);
						}
					}

					setState(1489);
					column_alias();
					}
				}

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

	public static class Table_or_subqueryContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public Database_nameContext database_name() {
			return getRuleContext(Database_nameContext.class,0);
		}
		public Table_aliasContext table_alias() {
			return getRuleContext(Table_aliasContext.class,0);
		}
		public TerminalNode K_INDEXED() { return getToken(JqlParser.K_INDEXED, 0); }
		public TerminalNode K_BY() { return getToken(JqlParser.K_BY, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public List table_or_subquery() {
			return getRuleContexts(Table_or_subqueryContext.class);
		}
		public Table_or_subqueryContext table_or_subquery(int i) {
			return getRuleContext(Table_or_subqueryContext.class,i);
		}
		public Join_clauseContext join_clause() {
			return getRuleContext(Join_clauseContext.class,0);
		}
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public Table_or_subqueryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table_or_subquery; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTable_or_subquery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTable_or_subquery(this);
		}
	}

	public final Table_or_subqueryContext table_or_subquery() throws RecognitionException {
		Table_or_subqueryContext _localctx = new Table_or_subqueryContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_table_or_subquery);
		int _la;
		try {
			setState(1541);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1497);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
				case 1:
					{
					setState(1494);
					database_name();
					setState(1495);
					match(DOT);
					}
					break;
				}
				setState(1499);
				table_name();
				setState(1504);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
				case 1:
					{
					setState(1501);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
					case 1:
						{
						setState(1500);
						match(K_AS);
						}
						break;
					}
					setState(1503);
					table_alias();
					}
					break;
				}
				setState(1511);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case K_INDEXED:
					{
					setState(1506);
					match(K_INDEXED);
					setState(1507);
					match(K_BY);
					setState(1508);
					index_name();
					}
					break;
				case K_NOT:
					{
					setState(1509);
					match(K_NOT);
					setState(1510);
					match(K_INDEXED);
					}
					break;
				case EOF:
				case SCOL:
				case CLOSE_PAR:
				case COMMA:
				case K_ALTER:
				case K_ANALYZE:
				case K_ATTACH:
				case K_BEGIN:
				case K_COMMIT:
				case K_CREATE:
				case K_CROSS:
				case K_DELETE:
				case K_DETACH:
				case K_DROP:
				case K_END:
				case K_EXCEPT:
				case K_EXPLAIN:
				case K_GROUP:
				case K_INNER:
				case K_INSERT:
				case K_INTERSECT:
				case K_JOIN:
				case K_LEFT:
				case K_LIMIT:
				case K_NATURAL:
				case K_ON:
				case K_ORDER:
				case K_PRAGMA:
				case K_REINDEX:
				case K_RELEASE:
				case K_REPLACE:
				case K_ROLLBACK:
				case K_SAVEPOINT:
				case K_SELECT:
				case K_UNION:
				case K_UPDATE:
				case K_USING:
				case K_VACUUM:
				case K_VALUES:
				case K_WHERE:
				case K_WITH:
				case UNEXPECTED_CHAR:
					break;
				default:
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1513);
				match(OPEN_PAR);
				setState(1523);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) {
				case 1:
					{
					setState(1514);
					table_or_subquery();
					setState(1519);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(1515);
						match(COMMA);
						setState(1516);
						table_or_subquery();
						}
						}
						setState(1521);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
					break;
				case 2:
					{
					setState(1522);
					join_clause();
					}
					break;
				}
				setState(1525);
				match(CLOSE_PAR);
				setState(1530);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
				case 1:
					{
					setState(1527);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) {
					case 1:
						{
						setState(1526);
						match(K_AS);
						}
						break;
					}
					setState(1529);
					table_alias();
					}
					break;
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1532);
				match(OPEN_PAR);
				setState(1533);
				select_stmt();
				setState(1534);
				match(CLOSE_PAR);
				setState(1539);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) {
				case 1:
					{
					setState(1536);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,217,_ctx) ) {
					case 1:
						{
						setState(1535);
						match(K_AS);
						}
						break;
					}
					setState(1538);
					table_alias();
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Join_clauseContext extends ParserRuleContext {
		public List table_or_subquery() {
			return getRuleContexts(Table_or_subqueryContext.class);
		}
		public Table_or_subqueryContext table_or_subquery(int i) {
			return getRuleContext(Table_or_subqueryContext.class,i);
		}
		public List join_operator() {
			return getRuleContexts(Join_operatorContext.class);
		}
		public Join_operatorContext join_operator(int i) {
			return getRuleContext(Join_operatorContext.class,i);
		}
		public List join_constraint() {
			return getRuleContexts(Join_constraintContext.class);
		}
		public Join_constraintContext join_constraint(int i) {
			return getRuleContext(Join_constraintContext.class,i);
		}
		public Join_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_join_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterJoin_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitJoin_clause(this);
		}
	}

	public final Join_clauseContext join_clause() throws RecognitionException {
		Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_join_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1543);
			table_or_subquery();
			setState(1550);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA || _la==K_CROSS || ((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (K_INNER - 91)) | (1L << (K_JOIN - 91)) | (1L << (K_LEFT - 91)) | (1L << (K_NATURAL - 91)))) != 0)) {
				{
				{
				setState(1544);
				join_operator();
				setState(1545);
				table_or_subquery();
				setState(1546);
				join_constraint();
				}
				}
				setState(1552);
				_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 Join_operatorContext extends ParserRuleContext {
		public TerminalNode K_JOIN() { return getToken(JqlParser.K_JOIN, 0); }
		public TerminalNode K_NATURAL() { return getToken(JqlParser.K_NATURAL, 0); }
		public TerminalNode K_LEFT() { return getToken(JqlParser.K_LEFT, 0); }
		public TerminalNode K_INNER() { return getToken(JqlParser.K_INNER, 0); }
		public TerminalNode K_CROSS() { return getToken(JqlParser.K_CROSS, 0); }
		public TerminalNode K_OUTER() { return getToken(JqlParser.K_OUTER, 0); }
		public Join_operatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_join_operator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterJoin_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitJoin_operator(this);
		}
	}

	public final Join_operatorContext join_operator() throws RecognitionException {
		Join_operatorContext _localctx = new Join_operatorContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_join_operator);
		int _la;
		try {
			setState(1566);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case COMMA:
				enterOuterAlt(_localctx, 1);
				{
				setState(1553);
				match(COMMA);
				}
				break;
			case K_CROSS:
			case K_INNER:
			case K_JOIN:
			case K_LEFT:
			case K_NATURAL:
				enterOuterAlt(_localctx, 2);
				{
				setState(1555);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_NATURAL) {
					{
					setState(1554);
					match(K_NATURAL);
					}
				}

				setState(1563);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case K_LEFT:
					{
					setState(1557);
					match(K_LEFT);
					setState(1559);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_OUTER) {
						{
						setState(1558);
						match(K_OUTER);
						}
					}

					}
					break;
				case K_INNER:
					{
					setState(1561);
					match(K_INNER);
					}
					break;
				case K_CROSS:
					{
					setState(1562);
					match(K_CROSS);
					}
					break;
				case K_JOIN:
					break;
				default:
					break;
				}
				setState(1565);
				match(K_JOIN);
				}
				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 Join_constraintContext extends ParserRuleContext {
		public TerminalNode K_ON() { return getToken(JqlParser.K_ON, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_USING() { return getToken(JqlParser.K_USING, 0); }
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public Join_constraintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_join_constraint; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterJoin_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitJoin_constraint(this);
		}
	}

	public final Join_constraintContext join_constraint() throws RecognitionException {
		Join_constraintContext _localctx = new Join_constraintContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_join_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1582);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_ON:
				{
				setState(1568);
				match(K_ON);
				setState(1569);
				expr(0);
				}
				break;
			case K_USING:
				{
				setState(1570);
				match(K_USING);
				setState(1571);
				match(OPEN_PAR);
				setState(1572);
				column_name();
				setState(1577);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1573);
					match(COMMA);
					setState(1574);
					column_name();
					}
					}
					setState(1579);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1580);
				match(CLOSE_PAR);
				}
				break;
			case EOF:
			case SCOL:
			case CLOSE_PAR:
			case COMMA:
			case K_ALTER:
			case K_ANALYZE:
			case K_ATTACH:
			case K_BEGIN:
			case K_COMMIT:
			case K_CREATE:
			case K_CROSS:
			case K_DELETE:
			case K_DETACH:
			case K_DROP:
			case K_END:
			case K_EXCEPT:
			case K_EXPLAIN:
			case K_GROUP:
			case K_INNER:
			case K_INSERT:
			case K_INTERSECT:
			case K_JOIN:
			case K_LEFT:
			case K_LIMIT:
			case K_NATURAL:
			case K_ORDER:
			case K_PRAGMA:
			case K_REINDEX:
			case K_RELEASE:
			case K_REPLACE:
			case K_ROLLBACK:
			case K_SAVEPOINT:
			case K_SELECT:
			case K_UNION:
			case K_UPDATE:
			case K_VACUUM:
			case K_VALUES:
			case K_WHERE:
			case K_WITH:
			case UNEXPECTED_CHAR:
				break;
			default:
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Select_coreContext extends ParserRuleContext {
		public TerminalNode K_SELECT() { return getToken(JqlParser.K_SELECT, 0); }
		public Projected_columnsContext projected_columns() {
			return getRuleContext(Projected_columnsContext.class,0);
		}
		public TerminalNode K_FROM() { return getToken(JqlParser.K_FROM, 0); }
		public Where_stmtContext where_stmt() {
			return getRuleContext(Where_stmtContext.class,0);
		}
		public Group_stmtContext group_stmt() {
			return getRuleContext(Group_stmtContext.class,0);
		}
		public TerminalNode K_DISTINCT() { return getToken(JqlParser.K_DISTINCT, 0); }
		public TerminalNode K_ALL() { return getToken(JqlParser.K_ALL, 0); }
		public List table_or_subquery() {
			return getRuleContexts(Table_or_subqueryContext.class);
		}
		public Table_or_subqueryContext table_or_subquery(int i) {
			return getRuleContext(Table_or_subqueryContext.class,i);
		}
		public Join_clauseContext join_clause() {
			return getRuleContext(Join_clauseContext.class,0);
		}
		public Having_stmtContext having_stmt() {
			return getRuleContext(Having_stmtContext.class,0);
		}
		public TerminalNode K_VALUES() { return getToken(JqlParser.K_VALUES, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Select_coreContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_select_core; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSelect_core(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSelect_core(this);
		}
	}

	public final Select_coreContext select_core() throws RecognitionException {
		Select_coreContext _localctx = new Select_coreContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_select_core);
		int _la;
		try {
			setState(1640);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(1584);
				match(K_SELECT);
				setState(1586);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) {
				case 1:
					{
					setState(1585);
					_la = _input.LA(1);
					if ( !(_la==K_ALL || _la==K_DISTINCT) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					break;
				}
				setState(1588);
				projected_columns();
				setState(1601);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_FROM) {
					{
					setState(1589);
					match(K_FROM);
					setState(1599);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
					case 1:
						{
						setState(1590);
						table_or_subquery();
						setState(1595);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==COMMA) {
							{
							{
							setState(1591);
							match(COMMA);
							setState(1592);
							table_or_subquery();
							}
							}
							setState(1597);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						}
						break;
					case 2:
						{
						setState(1598);
						join_clause();
						}
						break;
					}
					}
				}

				setState(1604);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_WHERE) {
					{
					setState(1603);
					where_stmt();
					}
				}

				setState(1610);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==K_GROUP) {
					{
					setState(1606);
					group_stmt();
					setState(1608);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==K_HAVING) {
						{
						setState(1607);
						having_stmt();
						}
					}

					}
				}

				}
				break;
			case K_VALUES:
				enterOuterAlt(_localctx, 2);
				{
				setState(1612);
				match(K_VALUES);
				setState(1613);
				match(OPEN_PAR);
				setState(1614);
				expr(0);
				setState(1619);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1615);
					match(COMMA);
					setState(1616);
					expr(0);
					}
					}
					setState(1621);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1622);
				match(CLOSE_PAR);
				setState(1637);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1623);
					match(COMMA);
					setState(1624);
					match(OPEN_PAR);
					setState(1625);
					expr(0);
					setState(1630);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(1626);
						match(COMMA);
						setState(1627);
						expr(0);
						}
						}
						setState(1632);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(1633);
					match(CLOSE_PAR);
					}
					}
					setState(1639);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				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 Compound_operatorContext extends ParserRuleContext {
		public TerminalNode K_UNION() { return getToken(JqlParser.K_UNION, 0); }
		public TerminalNode K_ALL() { return getToken(JqlParser.K_ALL, 0); }
		public TerminalNode K_INTERSECT() { return getToken(JqlParser.K_INTERSECT, 0); }
		public TerminalNode K_EXCEPT() { return getToken(JqlParser.K_EXCEPT, 0); }
		public Compound_operatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compound_operator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCompound_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCompound_operator(this);
		}
	}

	public final Compound_operatorContext compound_operator() throws RecognitionException {
		Compound_operatorContext _localctx = new Compound_operatorContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_compound_operator);
		try {
			setState(1647);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1642);
				match(K_UNION);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1643);
				match(K_UNION);
				setState(1644);
				match(K_ALL);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1645);
				match(K_INTERSECT);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1646);
				match(K_EXCEPT);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Cte_table_nameContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public List column_name() {
			return getRuleContexts(Column_nameContext.class);
		}
		public Column_nameContext column_name(int i) {
			return getRuleContext(Column_nameContext.class,i);
		}
		public Cte_table_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cte_table_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCte_table_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCte_table_name(this);
		}
	}

	public final Cte_table_nameContext cte_table_name() throws RecognitionException {
		Cte_table_nameContext _localctx = new Cte_table_nameContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_cte_table_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1649);
			table_name();
			setState(1661);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(1650);
				match(OPEN_PAR);
				setState(1651);
				column_name();
				setState(1656);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1652);
					match(COMMA);
					setState(1653);
					column_name();
					}
					}
					setState(1658);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1659);
				match(CLOSE_PAR);
				}
			}

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

	public static class Signed_numberContext extends ParserRuleContext {
		public TerminalNode NUMERIC_LITERAL() { return getToken(JqlParser.NUMERIC_LITERAL, 0); }
		public Signed_numberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_signed_number; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSigned_number(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSigned_number(this);
		}
	}

	public final Signed_numberContext signed_number() throws RecognitionException {
		Signed_numberContext _localctx = new Signed_numberContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_signed_number);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1664);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==PLUS || _la==MINUS) {
				{
				setState(1663);
				_la = _input.LA(1);
				if ( !(_la==PLUS || _la==MINUS) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

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

	public static class Literal_valueContext extends ParserRuleContext {
		public TerminalNode NUMERIC_LITERAL() { return getToken(JqlParser.NUMERIC_LITERAL, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(JqlParser.STRING_LITERAL, 0); }
		public TerminalNode BLOB_LITERAL() { return getToken(JqlParser.BLOB_LITERAL, 0); }
		public TerminalNode K_NULL() { return getToken(JqlParser.K_NULL, 0); }
		public TerminalNode K_CURRENT_TIME() { return getToken(JqlParser.K_CURRENT_TIME, 0); }
		public TerminalNode K_CURRENT_DATE() { return getToken(JqlParser.K_CURRENT_DATE, 0); }
		public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(JqlParser.K_CURRENT_TIMESTAMP, 0); }
		public Literal_valueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterLiteral_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitLiteral_value(this);
		}
	}

	public final Literal_valueContext literal_value() throws RecognitionException {
		Literal_valueContext _localctx = new Literal_valueContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_literal_value);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1668);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_CURRENT_DATE) | (1L << K_CURRENT_TIME) | (1L << K_CURRENT_TIMESTAMP))) != 0) || ((((_la - 108)) & ~0x3f) == 0 && ((1L << (_la - 108)) & ((1L << (K_NULL - 108)) | (1L << (NUMERIC_LITERAL - 108)) | (1L << (STRING_LITERAL - 108)) | (1L << (BLOB_LITERAL - 108)))) != 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 Unary_operatorContext extends ParserRuleContext {
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public Unary_operatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unary_operator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterUnary_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitUnary_operator(this);
		}
	}

	public final Unary_operatorContext unary_operator() throws RecognitionException {
		Unary_operatorContext _localctx = new Unary_operatorContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_unary_operator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1670);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << TILDE))) != 0) || _la==K_NOT) ) {
			_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 Error_messageContext extends ParserRuleContext {
		public TerminalNode STRING_LITERAL() { return getToken(JqlParser.STRING_LITERAL, 0); }
		public Error_messageContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_error_message; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterError_message(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitError_message(this);
		}
	}

	public final Error_messageContext error_message() throws RecognitionException {
		Error_messageContext _localctx = new Error_messageContext(_ctx, getState());
		enterRule(_localctx, 144, RULE_error_message);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1672);
			match(STRING_LITERAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Module_argumentContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Column_defContext column_def() {
			return getRuleContext(Column_defContext.class,0);
		}
		public Module_argumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_module_argument; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterModule_argument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitModule_argument(this);
		}
	}

	public final Module_argumentContext module_argument() throws RecognitionException {
		Module_argumentContext _localctx = new Module_argumentContext(_ctx, getState());
		enterRule(_localctx, 146, RULE_module_argument);
		try {
			setState(1676);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1674);
				expr(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1675);
				column_def();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_aliasContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(JqlParser.IDENTIFIER, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(JqlParser.STRING_LITERAL, 0); }
		public Column_aliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_alias; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_alias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_alias(this);
		}
	}

	public final Column_aliasContext column_alias() throws RecognitionException {
		Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState());
		enterRule(_localctx, 148, RULE_column_alias);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1678);
			_la = _input.LA(1);
			if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) {
			_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 KeywordContext extends ParserRuleContext {
		public TerminalNode K_ABORT() { return getToken(JqlParser.K_ABORT, 0); }
		public TerminalNode K_ACTION() { return getToken(JqlParser.K_ACTION, 0); }
		public TerminalNode K_ADD() { return getToken(JqlParser.K_ADD, 0); }
		public TerminalNode K_AFTER() { return getToken(JqlParser.K_AFTER, 0); }
		public TerminalNode K_ALL() { return getToken(JqlParser.K_ALL, 0); }
		public TerminalNode K_ALTER() { return getToken(JqlParser.K_ALTER, 0); }
		public TerminalNode K_ANALYZE() { return getToken(JqlParser.K_ANALYZE, 0); }
		public TerminalNode K_AND() { return getToken(JqlParser.K_AND, 0); }
		public TerminalNode K_AS() { return getToken(JqlParser.K_AS, 0); }
		public TerminalNode K_ASC() { return getToken(JqlParser.K_ASC, 0); }
		public TerminalNode K_ATTACH() { return getToken(JqlParser.K_ATTACH, 0); }
		public TerminalNode K_AUTOINCREMENT() { return getToken(JqlParser.K_AUTOINCREMENT, 0); }
		public TerminalNode K_BEFORE() { return getToken(JqlParser.K_BEFORE, 0); }
		public TerminalNode K_BEGIN() { return getToken(JqlParser.K_BEGIN, 0); }
		public TerminalNode K_BETWEEN() { return getToken(JqlParser.K_BETWEEN, 0); }
		public TerminalNode K_BY() { return getToken(JqlParser.K_BY, 0); }
		public TerminalNode K_CASCADE() { return getToken(JqlParser.K_CASCADE, 0); }
		public TerminalNode K_CASE() { return getToken(JqlParser.K_CASE, 0); }
		public TerminalNode K_CAST() { return getToken(JqlParser.K_CAST, 0); }
		public TerminalNode K_CHECK() { return getToken(JqlParser.K_CHECK, 0); }
		public TerminalNode K_COLLATE() { return getToken(JqlParser.K_COLLATE, 0); }
		public TerminalNode K_COLUMN() { return getToken(JqlParser.K_COLUMN, 0); }
		public TerminalNode K_COMMIT() { return getToken(JqlParser.K_COMMIT, 0); }
		public TerminalNode K_CONFLICT() { return getToken(JqlParser.K_CONFLICT, 0); }
		public TerminalNode K_CONSTRAINT() { return getToken(JqlParser.K_CONSTRAINT, 0); }
		public TerminalNode K_CREATE() { return getToken(JqlParser.K_CREATE, 0); }
		public TerminalNode K_CROSS() { return getToken(JqlParser.K_CROSS, 0); }
		public TerminalNode K_CURRENT_DATE() { return getToken(JqlParser.K_CURRENT_DATE, 0); }
		public TerminalNode K_CURRENT_TIME() { return getToken(JqlParser.K_CURRENT_TIME, 0); }
		public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(JqlParser.K_CURRENT_TIMESTAMP, 0); }
		public TerminalNode K_DATABASE() { return getToken(JqlParser.K_DATABASE, 0); }
		public TerminalNode K_DEFAULT() { return getToken(JqlParser.K_DEFAULT, 0); }
		public TerminalNode K_DEFERRABLE() { return getToken(JqlParser.K_DEFERRABLE, 0); }
		public TerminalNode K_DEFERRED() { return getToken(JqlParser.K_DEFERRED, 0); }
		public TerminalNode K_DELETE() { return getToken(JqlParser.K_DELETE, 0); }
		public TerminalNode K_DESC() { return getToken(JqlParser.K_DESC, 0); }
		public TerminalNode K_DETACH() { return getToken(JqlParser.K_DETACH, 0); }
		public TerminalNode K_DISTINCT() { return getToken(JqlParser.K_DISTINCT, 0); }
		public TerminalNode K_DROP() { return getToken(JqlParser.K_DROP, 0); }
		public TerminalNode K_EACH() { return getToken(JqlParser.K_EACH, 0); }
		public TerminalNode K_ELSE() { return getToken(JqlParser.K_ELSE, 0); }
		public TerminalNode K_END() { return getToken(JqlParser.K_END, 0); }
		public TerminalNode K_ESCAPE() { return getToken(JqlParser.K_ESCAPE, 0); }
		public TerminalNode K_EXCEPT() { return getToken(JqlParser.K_EXCEPT, 0); }
		public TerminalNode K_EXCLUSIVE() { return getToken(JqlParser.K_EXCLUSIVE, 0); }
		public TerminalNode K_EXISTS() { return getToken(JqlParser.K_EXISTS, 0); }
		public TerminalNode K_EXPLAIN() { return getToken(JqlParser.K_EXPLAIN, 0); }
		public TerminalNode K_FAIL() { return getToken(JqlParser.K_FAIL, 0); }
		public TerminalNode K_FOR() { return getToken(JqlParser.K_FOR, 0); }
		public TerminalNode K_FOREIGN() { return getToken(JqlParser.K_FOREIGN, 0); }
		public TerminalNode K_FROM() { return getToken(JqlParser.K_FROM, 0); }
		public TerminalNode K_FULL() { return getToken(JqlParser.K_FULL, 0); }
		public TerminalNode K_GLOB() { return getToken(JqlParser.K_GLOB, 0); }
		public TerminalNode K_GROUP() { return getToken(JqlParser.K_GROUP, 0); }
		public TerminalNode K_HAVING() { return getToken(JqlParser.K_HAVING, 0); }
		public TerminalNode K_IF() { return getToken(JqlParser.K_IF, 0); }
		public TerminalNode K_IGNORE() { return getToken(JqlParser.K_IGNORE, 0); }
		public TerminalNode K_IMMEDIATE() { return getToken(JqlParser.K_IMMEDIATE, 0); }
		public TerminalNode K_IN() { return getToken(JqlParser.K_IN, 0); }
		public TerminalNode K_INDEX() { return getToken(JqlParser.K_INDEX, 0); }
		public TerminalNode K_INDEXED() { return getToken(JqlParser.K_INDEXED, 0); }
		public TerminalNode K_INITIALLY() { return getToken(JqlParser.K_INITIALLY, 0); }
		public TerminalNode K_INNER() { return getToken(JqlParser.K_INNER, 0); }
		public TerminalNode K_INSERT() { return getToken(JqlParser.K_INSERT, 0); }
		public TerminalNode K_INSTEAD() { return getToken(JqlParser.K_INSTEAD, 0); }
		public TerminalNode K_INTERSECT() { return getToken(JqlParser.K_INTERSECT, 0); }
		public TerminalNode K_INTO() { return getToken(JqlParser.K_INTO, 0); }
		public TerminalNode K_IS() { return getToken(JqlParser.K_IS, 0); }
		public TerminalNode K_ISNULL() { return getToken(JqlParser.K_ISNULL, 0); }
		public TerminalNode K_JOIN() { return getToken(JqlParser.K_JOIN, 0); }
		public TerminalNode K_KEY() { return getToken(JqlParser.K_KEY, 0); }
		public TerminalNode K_LEFT() { return getToken(JqlParser.K_LEFT, 0); }
		public TerminalNode K_LIKE() { return getToken(JqlParser.K_LIKE, 0); }
		public TerminalNode K_LIMIT() { return getToken(JqlParser.K_LIMIT, 0); }
		public TerminalNode K_MATCH() { return getToken(JqlParser.K_MATCH, 0); }
		public TerminalNode K_NATURAL() { return getToken(JqlParser.K_NATURAL, 0); }
		public TerminalNode K_NO() { return getToken(JqlParser.K_NO, 0); }
		public TerminalNode K_NOT() { return getToken(JqlParser.K_NOT, 0); }
		public TerminalNode K_NOTNULL() { return getToken(JqlParser.K_NOTNULL, 0); }
		public TerminalNode K_NULL() { return getToken(JqlParser.K_NULL, 0); }
		public TerminalNode K_OF() { return getToken(JqlParser.K_OF, 0); }
		public TerminalNode K_OFFSET() { return getToken(JqlParser.K_OFFSET, 0); }
		public TerminalNode K_ON() { return getToken(JqlParser.K_ON, 0); }
		public TerminalNode K_OR() { return getToken(JqlParser.K_OR, 0); }
		public TerminalNode K_ORDER() { return getToken(JqlParser.K_ORDER, 0); }
		public TerminalNode K_OUTER() { return getToken(JqlParser.K_OUTER, 0); }
		public TerminalNode K_PLAN() { return getToken(JqlParser.K_PLAN, 0); }
		public TerminalNode K_PRAGMA() { return getToken(JqlParser.K_PRAGMA, 0); }
		public TerminalNode K_PRIMARY() { return getToken(JqlParser.K_PRIMARY, 0); }
		public TerminalNode K_QUERY() { return getToken(JqlParser.K_QUERY, 0); }
		public TerminalNode K_RAISE() { return getToken(JqlParser.K_RAISE, 0); }
		public TerminalNode K_RECURSIVE() { return getToken(JqlParser.K_RECURSIVE, 0); }
		public TerminalNode K_REFERENCES() { return getToken(JqlParser.K_REFERENCES, 0); }
		public TerminalNode K_REGEXP() { return getToken(JqlParser.K_REGEXP, 0); }
		public TerminalNode K_REINDEX() { return getToken(JqlParser.K_REINDEX, 0); }
		public TerminalNode K_RELEASE() { return getToken(JqlParser.K_RELEASE, 0); }
		public TerminalNode K_RENAME() { return getToken(JqlParser.K_RENAME, 0); }
		public TerminalNode K_REPLACE() { return getToken(JqlParser.K_REPLACE, 0); }
		public TerminalNode K_RESTRICT() { return getToken(JqlParser.K_RESTRICT, 0); }
		public TerminalNode K_RIGHT() { return getToken(JqlParser.K_RIGHT, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(JqlParser.K_ROLLBACK, 0); }
		public TerminalNode K_ROW() { return getToken(JqlParser.K_ROW, 0); }
		public TerminalNode K_SAVEPOINT() { return getToken(JqlParser.K_SAVEPOINT, 0); }
		public TerminalNode K_SELECT() { return getToken(JqlParser.K_SELECT, 0); }
		public TerminalNode K_SET() { return getToken(JqlParser.K_SET, 0); }
		public TerminalNode K_TABLE() { return getToken(JqlParser.K_TABLE, 0); }
		public TerminalNode K_TEMP() { return getToken(JqlParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(JqlParser.K_TEMPORARY, 0); }
		public TerminalNode K_THEN() { return getToken(JqlParser.K_THEN, 0); }
		public TerminalNode K_TO() { return getToken(JqlParser.K_TO, 0); }
		public TerminalNode K_TRANSACTION() { return getToken(JqlParser.K_TRANSACTION, 0); }
		public TerminalNode K_TRIGGER() { return getToken(JqlParser.K_TRIGGER, 0); }
		public TerminalNode K_UNION() { return getToken(JqlParser.K_UNION, 0); }
		public TerminalNode K_UNIQUE() { return getToken(JqlParser.K_UNIQUE, 0); }
		public TerminalNode K_UPDATE() { return getToken(JqlParser.K_UPDATE, 0); }
		public TerminalNode K_USING() { return getToken(JqlParser.K_USING, 0); }
		public TerminalNode K_VACUUM() { return getToken(JqlParser.K_VACUUM, 0); }
		public TerminalNode K_VALUES() { return getToken(JqlParser.K_VALUES, 0); }
		public TerminalNode K_VIEW() { return getToken(JqlParser.K_VIEW, 0); }
		public TerminalNode K_VIRTUAL() { return getToken(JqlParser.K_VIRTUAL, 0); }
		public TerminalNode K_WHEN() { return getToken(JqlParser.K_WHEN, 0); }
		public TerminalNode K_WHERE() { return getToken(JqlParser.K_WHERE, 0); }
		public TerminalNode K_WITH() { return getToken(JqlParser.K_WITH, 0); }
		public TerminalNode K_WITHOUT() { return getToken(JqlParser.K_WITHOUT, 0); }
		public KeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitKeyword(this);
		}
	}

	public final KeywordContext keyword() throws RecognitionException {
		KeywordContext _localctx = new KeywordContext(_ctx, getState());
		enterRule(_localctx, 150, RULE_keyword);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1680);
			_la = _input.LA(1);
			if ( !(((((_la - 29)) & ~0x3f) == 0 && ((1L << (_la - 29)) & ((1L << (K_ABORT - 29)) | (1L << (K_ACTION - 29)) | (1L << (K_ADD - 29)) | (1L << (K_AFTER - 29)) | (1L << (K_ALL - 29)) | (1L << (K_ALTER - 29)) | (1L << (K_ANALYZE - 29)) | (1L << (K_AND - 29)) | (1L << (K_AS - 29)) | (1L << (K_ASC - 29)) | (1L << (K_ATTACH - 29)) | (1L << (K_AUTOINCREMENT - 29)) | (1L << (K_BEFORE - 29)) | (1L << (K_BEGIN - 29)) | (1L << (K_BETWEEN - 29)) | (1L << (K_BY - 29)) | (1L << (K_CASCADE - 29)) | (1L << (K_CASE - 29)) | (1L << (K_CAST - 29)) | (1L << (K_CHECK - 29)) | (1L << (K_COLLATE - 29)) | (1L << (K_COLUMN - 29)) | (1L << (K_COMMIT - 29)) | (1L << (K_CONFLICT - 29)) | (1L << (K_CONSTRAINT - 29)) | (1L << (K_CREATE - 29)) | (1L << (K_CROSS - 29)) | (1L << (K_CURRENT_DATE - 29)) | (1L << (K_CURRENT_TIME - 29)) | (1L << (K_CURRENT_TIMESTAMP - 29)) | (1L << (K_DATABASE - 29)) | (1L << (K_DEFAULT - 29)) | (1L << (K_DEFERRABLE - 29)) | (1L << (K_DEFERRED - 29)) | (1L << (K_DELETE - 29)) | (1L << (K_DESC - 29)) | (1L << (K_DETACH - 29)) | (1L << (K_DISTINCT - 29)) | (1L << (K_DROP - 29)) | (1L << (K_EACH - 29)) | (1L << (K_ELSE - 29)) | (1L << (K_END - 29)) | (1L << (K_ESCAPE - 29)) | (1L << (K_EXCEPT - 29)) | (1L << (K_EXCLUSIVE - 29)) | (1L << (K_EXISTS - 29)) | (1L << (K_EXPLAIN - 29)) | (1L << (K_FAIL - 29)) | (1L << (K_FOR - 29)) | (1L << (K_FOREIGN - 29)) | (1L << (K_FROM - 29)) | (1L << (K_FULL - 29)) | (1L << (K_GLOB - 29)) | (1L << (K_GROUP - 29)) | (1L << (K_HAVING - 29)) | (1L << (K_IF - 29)) | (1L << (K_IGNORE - 29)) | (1L << (K_IMMEDIATE - 29)) | (1L << (K_IN - 29)) | (1L << (K_INDEX - 29)) | (1L << (K_INDEXED - 29)) | (1L << (K_INITIALLY - 29)) | (1L << (K_INNER - 29)) | (1L << (K_INSERT - 29)))) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (K_INSTEAD - 93)) | (1L << (K_INTERSECT - 93)) | (1L << (K_INTO - 93)) | (1L << (K_IS - 93)) | (1L << (K_ISNULL - 93)) | (1L << (K_JOIN - 93)) | (1L << (K_KEY - 93)) | (1L << (K_LEFT - 93)) | (1L << (K_LIKE - 93)) | (1L << (K_LIMIT - 93)) | (1L << (K_MATCH - 93)) | (1L << (K_NATURAL - 93)) | (1L << (K_NO - 93)) | (1L << (K_NOT - 93)) | (1L << (K_NOTNULL - 93)) | (1L << (K_NULL - 93)) | (1L << (K_OF - 93)) | (1L << (K_OFFSET - 93)) | (1L << (K_ON - 93)) | (1L << (K_OR - 93)) | (1L << (K_ORDER - 93)) | (1L << (K_OUTER - 93)) | (1L << (K_PLAN - 93)) | (1L << (K_PRAGMA - 93)) | (1L << (K_PRIMARY - 93)) | (1L << (K_QUERY - 93)) | (1L << (K_RAISE - 93)) | (1L << (K_RECURSIVE - 93)) | (1L << (K_REFERENCES - 93)) | (1L << (K_REGEXP - 93)) | (1L << (K_REINDEX - 93)) | (1L << (K_RELEASE - 93)) | (1L << (K_RENAME - 93)) | (1L << (K_REPLACE - 93)) | (1L << (K_RESTRICT - 93)) | (1L << (K_RIGHT - 93)) | (1L << (K_ROLLBACK - 93)) | (1L << (K_ROW - 93)) | (1L << (K_SAVEPOINT - 93)) | (1L << (K_SELECT - 93)) | (1L << (K_SET - 93)) | (1L << (K_TABLE - 93)) | (1L << (K_TEMP - 93)) | (1L << (K_TEMPORARY - 93)) | (1L << (K_THEN - 93)) | (1L << (K_TO - 93)) | (1L << (K_TRANSACTION - 93)) | (1L << (K_TRIGGER - 93)) | (1L << (K_UNION - 93)) | (1L << (K_UNIQUE - 93)) | (1L << (K_UPDATE - 93)) | (1L << (K_USING - 93)) | (1L << (K_VACUUM - 93)) | (1L << (K_VALUES - 93)) | (1L << (K_VIEW - 93)) | (1L << (K_VIRTUAL - 93)) | (1L << (K_WHEN - 93)) | (1L << (K_WHERE - 93)) | (1L << (K_WITH - 93)) | (1L << (K_WITHOUT - 93)))) != 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 NameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public NameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitName(this);
		}
	}

	public final NameContext name() throws RecognitionException {
		NameContext _localctx = new NameContext(_ctx, getState());
		enterRule(_localctx, 152, RULE_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1682);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Function_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Function_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterFunction_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitFunction_name(this);
		}
	}

	public final Function_nameContext function_name() throws RecognitionException {
		Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
		enterRule(_localctx, 154, RULE_function_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1684);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Group_stmtContext extends ParserRuleContext {
		public TerminalNode K_GROUP() { return getToken(JqlParser.K_GROUP, 0); }
		public TerminalNode K_BY() { return getToken(JqlParser.K_BY, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public Group_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_group_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterGroup_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitGroup_stmt(this);
		}
	}

	public final Group_stmtContext group_stmt() throws RecognitionException {
		Group_stmtContext _localctx = new Group_stmtContext(_ctx, getState());
		enterRule(_localctx, 156, RULE_group_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1686);
			match(K_GROUP);
			setState(1687);
			match(K_BY);
			setState(1688);
			expr(0);
			setState(1693);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1689);
				match(COMMA);
				setState(1690);
				expr(0);
				}
				}
				setState(1695);
				_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 Having_stmtContext extends ParserRuleContext {
		public TerminalNode K_HAVING() { return getToken(JqlParser.K_HAVING, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Having_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_having_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterHaving_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitHaving_stmt(this);
		}
	}

	public final Having_stmtContext having_stmt() throws RecognitionException {
		Having_stmtContext _localctx = new Having_stmtContext(_ctx, getState());
		enterRule(_localctx, 158, RULE_having_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1696);
			match(K_HAVING);
			setState(1697);
			expr(0);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Database_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Database_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_database_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterDatabase_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitDatabase_name(this);
		}
	}

	public final Database_nameContext database_name() throws RecognitionException {
		Database_nameContext _localctx = new Database_nameContext(_ctx, getState());
		enterRule(_localctx, 160, RULE_database_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1699);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Table_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Table_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTable_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTable_name(this);
		}
	}

	public final Table_nameContext table_name() throws RecognitionException {
		Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
		enterRule(_localctx, 162, RULE_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1701);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Table_or_index_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Table_or_index_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table_or_index_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTable_or_index_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTable_or_index_name(this);
		}
	}

	public final Table_or_index_nameContext table_or_index_name() throws RecognitionException {
		Table_or_index_nameContext _localctx = new Table_or_index_nameContext(_ctx, getState());
		enterRule(_localctx, 164, RULE_table_or_index_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1703);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class New_table_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public New_table_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_new_table_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterNew_table_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitNew_table_name(this);
		}
	}

	public final New_table_nameContext new_table_name() throws RecognitionException {
		New_table_nameContext _localctx = new New_table_nameContext(_ctx, getState());
		enterRule(_localctx, 166, RULE_new_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1705);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Column_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_name(this);
		}
	}

	public final Column_nameContext column_name() throws RecognitionException {
		Column_nameContext _localctx = new Column_nameContext(_ctx, getState());
		enterRule(_localctx, 168, RULE_column_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1707);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Column_name_to_updateContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Column_name_to_updateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_column_name_to_update; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterColumn_name_to_update(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitColumn_name_to_update(this);
		}
	}

	public final Column_name_to_updateContext column_name_to_update() throws RecognitionException {
		Column_name_to_updateContext _localctx = new Column_name_to_updateContext(_ctx, getState());
		enterRule(_localctx, 170, RULE_column_name_to_update);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1709);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Collation_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Collation_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collation_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterCollation_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitCollation_name(this);
		}
	}

	public final Collation_nameContext collation_name() throws RecognitionException {
		Collation_nameContext _localctx = new Collation_nameContext(_ctx, getState());
		enterRule(_localctx, 172, RULE_collation_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1711);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Foreign_tableContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Foreign_tableContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_foreign_table; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterForeign_table(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitForeign_table(this);
		}
	}

	public final Foreign_tableContext foreign_table() throws RecognitionException {
		Foreign_tableContext _localctx = new Foreign_tableContext(_ctx, getState());
		enterRule(_localctx, 174, RULE_foreign_table);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1713);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Index_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Index_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_index_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterIndex_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitIndex_name(this);
		}
	}

	public final Index_nameContext index_name() throws RecognitionException {
		Index_nameContext _localctx = new Index_nameContext(_ctx, getState());
		enterRule(_localctx, 176, RULE_index_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1715);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Trigger_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Trigger_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_trigger_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTrigger_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTrigger_name(this);
		}
	}

	public final Trigger_nameContext trigger_name() throws RecognitionException {
		Trigger_nameContext _localctx = new Trigger_nameContext(_ctx, getState());
		enterRule(_localctx, 178, RULE_trigger_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1717);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class View_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public View_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_view_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterView_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitView_name(this);
		}
	}

	public final View_nameContext view_name() throws RecognitionException {
		View_nameContext _localctx = new View_nameContext(_ctx, getState());
		enterRule(_localctx, 180, RULE_view_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1719);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Module_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Module_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_module_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterModule_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitModule_name(this);
		}
	}

	public final Module_nameContext module_name() throws RecognitionException {
		Module_nameContext _localctx = new Module_nameContext(_ctx, getState());
		enterRule(_localctx, 182, RULE_module_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1721);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Pragma_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Pragma_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pragma_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterPragma_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitPragma_name(this);
		}
	}

	public final Pragma_nameContext pragma_name() throws RecognitionException {
		Pragma_nameContext _localctx = new Pragma_nameContext(_ctx, getState());
		enterRule(_localctx, 184, RULE_pragma_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1723);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Projected_columnsContext extends ParserRuleContext {
		public List result_column() {
			return getRuleContexts(Result_columnContext.class);
		}
		public Result_columnContext result_column(int i) {
			return getRuleContext(Result_columnContext.class,i);
		}
		public Projected_columnsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_projected_columns; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterProjected_columns(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitProjected_columns(this);
		}
	}

	public final Projected_columnsContext projected_columns() throws RecognitionException {
		Projected_columnsContext _localctx = new Projected_columnsContext(_ctx, getState());
		enterRule(_localctx, 186, RULE_projected_columns);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1725);
			result_column();
			setState(1730);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1726);
				match(COMMA);
				setState(1727);
				result_column();
				}
				}
				setState(1732);
				_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 Savepoint_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Savepoint_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_savepoint_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterSavepoint_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitSavepoint_name(this);
		}
	}

	public final Savepoint_nameContext savepoint_name() throws RecognitionException {
		Savepoint_nameContext _localctx = new Savepoint_nameContext(_ctx, getState());
		enterRule(_localctx, 188, RULE_savepoint_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1733);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Table_aliasContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Table_aliasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_table_alias; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTable_alias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTable_alias(this);
		}
	}

	public final Table_aliasContext table_alias() throws RecognitionException {
		Table_aliasContext _localctx = new Table_aliasContext(_ctx, getState());
		enterRule(_localctx, 190, RULE_table_alias);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1735);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Transaction_nameContext extends ParserRuleContext {
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Transaction_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_transaction_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterTransaction_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitTransaction_name(this);
		}
	}

	public final Transaction_nameContext transaction_name() throws RecognitionException {
		Transaction_nameContext _localctx = new Transaction_nameContext(_ctx, getState());
		enterRule(_localctx, 192, RULE_transaction_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1737);
			any_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Any_nameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(JqlParser.IDENTIFIER, 0); }
		public KeywordContext keyword() {
			return getRuleContext(KeywordContext.class,0);
		}
		public TerminalNode STRING_LITERAL() { return getToken(JqlParser.STRING_LITERAL, 0); }
		public Any_nameContext any_name() {
			return getRuleContext(Any_nameContext.class,0);
		}
		public Any_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_any_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).enterAny_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof JqlListener ) ((JqlListener)listener).exitAny_name(this);
		}
	}

	public final Any_nameContext any_name() throws RecognitionException {
		Any_nameContext _localctx = new Any_nameContext(_ctx, getState());
		enterRule(_localctx, 194, RULE_any_name);
		try {
			setState(1746);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENTIFIER:
				enterOuterAlt(_localctx, 1);
				{
				setState(1739);
				match(IDENTIFIER);
				}
				break;
			case K_ABORT:
			case K_ACTION:
			case K_ADD:
			case K_AFTER:
			case K_ALL:
			case K_ALTER:
			case K_ANALYZE:
			case K_AND:
			case K_AS:
			case K_ASC:
			case K_ATTACH:
			case K_AUTOINCREMENT:
			case K_BEFORE:
			case K_BEGIN:
			case K_BETWEEN:
			case K_BY:
			case K_CASCADE:
			case K_CASE:
			case K_CAST:
			case K_CHECK:
			case K_COLLATE:
			case K_COLUMN:
			case K_COMMIT:
			case K_CONFLICT:
			case K_CONSTRAINT:
			case K_CREATE:
			case K_CROSS:
			case K_CURRENT_DATE:
			case K_CURRENT_TIME:
			case K_CURRENT_TIMESTAMP:
			case K_DATABASE:
			case K_DEFAULT:
			case K_DEFERRABLE:
			case K_DEFERRED:
			case K_DELETE:
			case K_DESC:
			case K_DETACH:
			case K_DISTINCT:
			case K_DROP:
			case K_EACH:
			case K_ELSE:
			case K_END:
			case K_ESCAPE:
			case K_EXCEPT:
			case K_EXCLUSIVE:
			case K_EXISTS:
			case K_EXPLAIN:
			case K_FAIL:
			case K_FOR:
			case K_FOREIGN:
			case K_FROM:
			case K_FULL:
			case K_GLOB:
			case K_GROUP:
			case K_HAVING:
			case K_IF:
			case K_IGNORE:
			case K_IMMEDIATE:
			case K_IN:
			case K_INDEX:
			case K_INDEXED:
			case K_INITIALLY:
			case K_INNER:
			case K_INSERT:
			case K_INSTEAD:
			case K_INTERSECT:
			case K_INTO:
			case K_IS:
			case K_ISNULL:
			case K_JOIN:
			case K_KEY:
			case K_LEFT:
			case K_LIKE:
			case K_LIMIT:
			case K_MATCH:
			case K_NATURAL:
			case K_NO:
			case K_NOT:
			case K_NOTNULL:
			case K_NULL:
			case K_OF:
			case K_OFFSET:
			case K_ON:
			case K_OR:
			case K_ORDER:
			case K_OUTER:
			case K_PLAN:
			case K_PRAGMA:
			case K_PRIMARY:
			case K_QUERY:
			case K_RAISE:
			case K_RECURSIVE:
			case K_REFERENCES:
			case K_REGEXP:
			case K_REINDEX:
			case K_RELEASE:
			case K_RENAME:
			case K_REPLACE:
			case K_RESTRICT:
			case K_RIGHT:
			case K_ROLLBACK:
			case K_ROW:
			case K_SAVEPOINT:
			case K_SELECT:
			case K_SET:
			case K_TABLE:
			case K_TEMP:
			case K_TEMPORARY:
			case K_THEN:
			case K_TO:
			case K_TRANSACTION:
			case K_TRIGGER:
			case K_UNION:
			case K_UNIQUE:
			case K_UPDATE:
			case K_USING:
			case K_VACUUM:
			case K_VALUES:
			case K_VIEW:
			case K_VIRTUAL:
			case K_WHEN:
			case K_WHERE:
			case K_WITH:
			case K_WITHOUT:
				enterOuterAlt(_localctx, 2);
				{
				setState(1740);
				keyword();
				}
				break;
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 3);
				{
				setState(1741);
				match(STRING_LITERAL);
				}
				break;
			case OPEN_PAR:
				enterOuterAlt(_localctx, 4);
				{
				setState(1742);
				match(OPEN_PAR);
				setState(1743);
				any_name();
				setState(1744);
				match(CLOSE_PAR);
				}
				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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 44:
			return expr_sempred((ExprContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean expr_sempred(ExprContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 20);
		case 1:
			return precpred(_ctx, 19);
		case 2:
			return precpred(_ctx, 18);
		case 3:
			return precpred(_ctx, 17);
		case 4:
			return precpred(_ctx, 16);
		case 5:
			return precpred(_ctx, 15);
		case 6:
			return precpred(_ctx, 14);
		case 7:
			return precpred(_ctx, 13);
		case 8:
			return precpred(_ctx, 6);
		case 9:
			return precpred(_ctx, 5);
		case 10:
			return precpred(_ctx, 9);
		case 11:
			return precpred(_ctx, 8);
		case 12:
			return precpred(_ctx, 7);
		case 13:
			return precpred(_ctx, 4);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00a3\u06d7\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="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
		"`\t`\4a\ta\4b\tb\4c\tc\3\2\3\2\7\2\u00c9\n\2\f\2\16\2\u00cc\13\2\3\2\3"+
		"\2\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00d6\n\3\3\4\3\4\3\4\3\5\7\5\u00dc\n\5"+
		"\f\5\16\5\u00df\13\5\3\5\3\5\6\5\u00e3\n\5\r\5\16\5\u00e4\3\5\7\5\u00e8"+
		"\n\5\f\5\16\5\u00eb\13\5\3\5\7\5\u00ee\n\5\f\5\16\5\u00f1\13\5\3\6\3\6"+
		"\3\6\5\6\u00f6\n\6\5\6\u00f8\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6"+
		"\3\6\3\6\3\6\5\6\u0118\n\6\3\7\3\7\3\7\3\7\3\7\5\7\u011f\n\7\3\7\3\7\3"+
		"\7\3\7\3\7\3\7\5\7\u0127\n\7\3\7\5\7\u012a\n\7\3\b\3\b\3\b\3\b\3\b\3\b"+
		"\3\b\5\b\u0133\n\b\3\t\3\t\5\t\u0137\n\t\3\t\3\t\3\t\3\t\3\n\3\n\5\n\u013f"+
		"\n\n\3\n\3\n\5\n\u0143\n\n\5\n\u0145\n\n\3\13\3\13\3\13\5\13\u014a\n\13"+
		"\5\13\u014c\n\13\3\f\3\f\5\f\u0150\n\f\3\f\3\f\3\f\7\f\u0155\n\f\f\f\16"+
		"\f\u0158\13\f\5\f\u015a\n\f\3\f\3\f\3\f\5\f\u015f\n\f\3\f\3\f\5\f\u0163"+
		"\n\f\3\f\6\f\u0166\n\f\r\f\16\f\u0167\3\f\5\f\u016b\n\f\3\f\3\f\5\f\u016f"+
		"\n\f\5\f\u0171\n\f\3\r\3\r\5\r\u0175\n\r\3\r\3\r\3\r\3\r\5\r\u017b\n\r"+
		"\3\r\3\r\3\r\5\r\u0180\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0189\n\r\f"+
		"\r\16\r\u018c\13\r\3\r\3\r\5\r\u0190\n\r\3\16\3\16\5\16\u0194\n\16\3\16"+
		"\3\16\3\16\3\16\5\16\u019a\n\16\3\16\3\16\3\16\5\16\u019f\n\16\3\16\3"+
		"\16\3\16\3\16\3\16\7\16\u01a6\n\16\f\16\16\16\u01a9\13\16\3\16\3\16\7"+
		"\16\u01ad\n\16\f\16\16\16\u01b0\13\16\3\16\3\16\3\16\5\16\u01b5\n\16\3"+
		"\16\3\16\5\16\u01b9\n\16\3\17\3\17\5\17\u01bd\n\17\3\17\3\17\3\17\3\17"+
		"\5\17\u01c3\n\17\3\17\3\17\3\17\5\17\u01c8\n\17\3\17\3\17\3\17\3\17\3"+
		"\17\5\17\u01cf\n\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u01d8\n\17"+
		"\f\17\16\17\u01db\13\17\5\17\u01dd\n\17\5\17\u01df\n\17\3\17\3\17\3\17"+
		"\3\17\5\17\u01e5\n\17\3\17\3\17\3\17\3\17\5\17\u01eb\n\17\3\17\3\17\5"+
		"\17\u01ef\n\17\3\17\3\17\3\17\3\17\3\17\5\17\u01f6\n\17\3\17\3\17\6\17"+
		"\u01fa\n\17\r\17\16\17\u01fb\3\17\3\17\3\20\3\20\5\20\u0202\n\20\3\20"+
		"\3\20\3\20\3\20\5\20\u0208\n\20\3\20\3\20\3\20\5\20\u020d\n\20\3\20\3"+
		"\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0219\n\21\3\21\3\21"+
		"\3\21\5\21\u021e\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\7\21\u0227\n"+
		"\21\f\21\16\21\u022a\13\21\3\21\3\21\5\21\u022e\n\21\3\22\5\22\u0231\n"+
		"\22\3\22\3\22\3\22\3\22\5\22\u0237\n\22\3\23\5\23\u023a\n\23\3\23\3\23"+
		"\3\23\3\23\5\23\u0240\n\23\3\23\5\23\u0243\n\23\3\23\3\23\5\23\u0247\n"+
		"\23\5\23\u0249\n\23\3\24\3\24\5\24\u024d\n\24\3\24\3\24\3\25\3\25\3\25"+
		"\3\25\5\25\u0255\n\25\3\25\3\25\3\25\5\25\u025a\n\25\3\25\3\25\3\26\3"+
		"\26\3\26\3\26\5\26\u0262\n\26\3\26\3\26\3\26\5\26\u0267\n\26\3\26\3\26"+
		"\3\27\3\27\3\27\3\27\5\27\u026f\n\27\3\27\3\27\3\27\5\27\u0274\n\27\3"+
		"\27\3\27\3\30\3\30\3\30\3\30\5\30\u027c\n\30\3\30\3\30\3\30\5\30\u0281"+
		"\n\30\3\30\3\30\3\31\3\31\5\31\u0287\n\31\3\31\3\31\3\31\7\31\u028c\n"+
		"\31\f\31\16\31\u028f\13\31\5\31\u0291\n\31\3\31\3\31\3\31\3\31\7\31\u0297"+
		"\n\31\f\31\16\31\u029a\13\31\3\31\5\31\u029d\n\31\3\31\3\31\5\31\u02a1"+
		"\n\31\5\31\u02a3\n\31\3\32\5\32\u02a6\n\32\3\32\3\32\3\32\3\32\3\32\5"+
		"\32\u02ad\n\32\3\32\3\32\3\32\3\32\5\32\u02b3\n\32\3\32\3\32\3\32\3\32"+
		"\3\32\5\32\u02ba\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32"+
		"\u02c5\n\32\f\32\16\32\u02c8\13\32\3\32\3\32\7\32\u02cc\n\32\f\32\16\32"+
		"\u02cf\13\32\3\32\3\32\3\32\5\32\u02d4\n\32\3\33\3\33\3\33\7\33\u02d9"+
		"\n\33\f\33\16\33\u02dc\13\33\3\34\3\34\3\34\7\34\u02e1\n\34\f\34\16\34"+
		"\u02e4\13\34\3\35\3\35\3\35\3\36\3\36\3\36\3\36\5\36\u02ed\n\36\3\36\3"+
		"\36\3\36\3\36\3\36\3\36\3\36\5\36\u02f6\n\36\3\37\3\37\3\37\3\37\3\37"+
		"\5\37\u02fd\n\37\3\37\3\37\5\37\u0301\n\37\5\37\u0303\n\37\3 \3 \5 \u0307"+
		"\n \3 \3 \3!\3!\3!\5!\u030e\n!\5!\u0310\n!\3!\3!\5!\u0314\n!\3!\5!\u0317"+
		"\n!\3\"\3\"\3\"\3#\3#\5#\u031e\n#\3#\3#\3#\7#\u0323\n#\f#\16#\u0326\13"+
		"#\5#\u0328\n#\3#\3#\5#\u032c\n#\3#\3#\5#\u0330\n#\5#\u0332\n#\3$\3$\5"+
		"$\u0336\n$\3$\3$\3$\7$\u033b\n$\f$\16$\u033e\13$\5$\u0340\n$\3$\3$\3$"+
		"\3$\7$\u0346\n$\f$\16$\u0349\13$\3$\5$\u034c\n$\3$\3$\5$\u0350\n$\5$\u0352"+
		"\n$\3%\3%\5%\u0356\n%\3%\3%\3%\3%\3%\7%\u035d\n%\f%\16%\u0360\13%\3%\5"+
		"%\u0363\n%\5%\u0365\n%\3%\5%\u0368\n%\3%\3%\5%\u036c\n%\5%\u036e\n%\3"+
		"%\3%\3%\3%\3%\7%\u0375\n%\f%\16%\u0378\13%\3%\3%\3%\3%\3%\3%\7%\u0380"+
		"\n%\f%\16%\u0383\13%\3%\3%\7%\u0387\n%\f%\16%\u038a\13%\5%\u038c\n%\3"+
		"&\5&\u038f\n&\3&\3&\3&\5&\u0394\n&\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\7&\u03a0"+
		"\n&\f&\16&\u03a3\13&\3&\5&\u03a6\n&\3\'\3\'\3(\5(\u03ab\n(\3(\3(\3(\3"+
		"(\3(\3(\3(\3(\3(\3(\3(\5(\u03b8\n(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\7(\u03c4"+
		"\n(\f(\16(\u03c7\13(\3(\5(\u03ca\n(\3(\5(\u03cd\n(\3(\3(\5(\u03d1\n(\5"+
		"(\u03d3\n(\3)\3)\3*\3*\5*\u03d9\n*\3*\7*\u03dc\n*\f*\16*\u03df\13*\3+"+
		"\6+\u03e2\n+\r+\16+\u03e3\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u03f0\n+\3"+
		",\3,\5,\u03f4\n,\3,\3,\3,\5,\u03f9\n,\3,\3,\5,\u03fd\n,\3,\5,\u0400\n"+
		",\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\3,\5,\u0412\n,\3,\3,\3"+
		",\5,\u0417\n,\3-\3-\3-\5-\u041c\n-\3.\3.\3.\3.\3.\3.\3.\5.\u0425\n.\3"+
		".\3.\3.\5.\u042a\n.\3.\3.\3.\3.\3.\3.\3.\5.\u0433\n.\3.\3.\3.\7.\u0438"+
		"\n.\f.\16.\u043b\13.\3.\5.\u043e\n.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3"+
		".\3.\3.\5.\u044e\n.\3.\5.\u0451\n.\3.\3.\3.\3.\3.\3.\5.\u0459\n.\3.\3"+
		".\3.\3.\3.\6.\u0460\n.\r.\16.\u0461\3.\3.\5.\u0466\n.\3.\3.\3.\5.\u046b"+
		"\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.\5.\u0489\n.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u0495"+
		"\n.\3.\3.\3.\5.\u049a\n.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\5.\u04a6\n.\3."+
		"\3.\3.\3.\5.\u04ac\n.\3.\3.\3.\3.\3.\5.\u04b3\n.\3.\3.\5.\u04b7\n.\3."+
		"\3.\3.\3.\3.\3.\7.\u04bf\n.\f.\16.\u04c2\13.\5.\u04c4\n.\3.\3.\3.\3.\5"+
		".\u04ca\n.\3.\5.\u04cd\n.\7.\u04cf\n.\f.\16.\u04d2\13.\3/\3/\3/\7/\u04d7"+
		"\n/\f/\16/\u04da\13/\3/\3/\7/\u04de\n/\f/\16/\u04e1\13/\3/\3/\7/\u04e5"+
		"\n/\f/\16/\u04e8\13/\3/\3/\5/\u04ec\n/\3\60\3\60\5\60\u04f0\n\60\3\60"+
		"\3\60\3\61\3\61\7\61\u04f6\n\61\f\61\16\61\u04f9\13\61\3\61\3\61\7\61"+
		"\u04fd\n\61\f\61\16\61\u0500\13\61\3\61\3\61\7\61\u0504\n\61\f\61\16\61"+
		"\u0507\13\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\7\62\u0511\n\62\f"+
		"\62\16\62\u0514\13\62\3\62\3\62\5\62\u0518\n\62\3\62\3\62\3\62\3\62\3"+
		"\62\3\62\3\62\3\62\3\62\3\62\5\62\u0524\n\62\3\62\3\62\5\62\u0528\n\62"+
		"\7\62\u052a\n\62\f\62\16\62\u052d\13\62\3\62\5\62\u0530\n\62\3\62\3\62"+
		"\3\62\3\62\3\62\5\62\u0537\n\62\5\62\u0539\n\62\3\63\3\63\3\63\3\63\3"+
		"\63\3\63\5\63\u0541\n\63\3\63\3\63\3\64\3\64\3\64\5\64\u0548\n\64\3\64"+
		"\5\64\u054b\n\64\3\65\3\65\5\65\u054f\n\65\3\65\3\65\3\65\5\65\u0554\n"+
		"\65\3\65\3\65\3\65\3\65\7\65\u055a\n\65\f\65\16\65\u055d\13\65\3\65\3"+
		"\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\7\65\u056d"+
		"\n\65\f\65\16\65\u0570\13\65\3\65\3\65\3\65\5\65\u0575\n\65\3\66\3\66"+
		"\5\66\u0579\n\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66"+
		"\3\66\7\66\u0587\n\66\f\66\16\66\u058a\13\66\3\67\3\67\3\67\38\38\39\3"+
		"9\39\59\u0594\n9\39\39\39\39\39\39\59\u059c\n9\3:\3:\3:\3;\3;\3;\3;\3"+
		";\7;\u05a6\n;\f;\16;\u05a9\13;\3<\3<\3<\5<\u05ae\n<\3<\5<\u05b1\n<\3="+
		"\3=\3=\5=\u05b6\n=\3>\3>\3>\3>\3>\7>\u05bd\n>\f>\16>\u05c0\13>\3>\3>\5"+
		">\u05c4\n>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3?\5?\u05d2\n?\3?\5?\u05d5"+
		"\n?\5?\u05d7\n?\3@\3@\3@\5@\u05dc\n@\3@\3@\5@\u05e0\n@\3@\5@\u05e3\n@"+
		"\3@\3@\3@\3@\3@\5@\u05ea\n@\3@\3@\3@\3@\7@\u05f0\n@\f@\16@\u05f3\13@\3"+
		"@\5@\u05f6\n@\3@\3@\5@\u05fa\n@\3@\5@\u05fd\n@\3@\3@\3@\3@\5@\u0603\n"+
		"@\3@\5@\u0606\n@\5@\u0608\n@\3A\3A\3A\3A\3A\7A\u060f\nA\fA\16A\u0612\13"+
		"A\3B\3B\5B\u0616\nB\3B\3B\5B\u061a\nB\3B\3B\5B\u061e\nB\3B\5B\u0621\n"+
		"B\3C\3C\3C\3C\3C\3C\3C\7C\u062a\nC\fC\16C\u062d\13C\3C\3C\5C\u0631\nC"+
		"\3D\3D\5D\u0635\nD\3D\3D\3D\3D\3D\7D\u063c\nD\fD\16D\u063f\13D\3D\5D\u0642"+
		"\nD\5D\u0644\nD\3D\5D\u0647\nD\3D\3D\5D\u064b\nD\5D\u064d\nD\3D\3D\3D"+
		"\3D\3D\7D\u0654\nD\fD\16D\u0657\13D\3D\3D\3D\3D\3D\3D\7D\u065f\nD\fD\16"+
		"D\u0662\13D\3D\3D\7D\u0666\nD\fD\16D\u0669\13D\5D\u066b\nD\3E\3E\3E\3"+
		"E\3E\5E\u0672\nE\3F\3F\3F\3F\3F\7F\u0679\nF\fF\16F\u067c\13F\3F\3F\5F"+
		"\u0680\nF\3G\5G\u0683\nG\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\5K\u068f\nK\3L"+
		"\3L\3M\3M\3N\3N\3O\3O\3P\3P\3P\3P\3P\7P\u069e\nP\fP\16P\u06a1\13P\3Q\3"+
		"Q\3Q\3R\3R\3S\3S\3T\3T\3U\3U\3V\3V\3W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3\\\3"+
		"\\\3]\3]\3^\3^\3_\3_\3_\7_\u06c3\n_\f_\16_\u06c6\13_\3`\3`\3a\3a\3b\3"+
		"b\3c\3c\3c\3c\3c\3c\3c\5c\u06d5\nc\3c\2\3Zd\2\4\6\b\n\f\16\20\22\24\26"+
		"\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|"+
		"~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096"+
		"\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae"+
		"\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\2\24"+
		"\5\2@@KKXX\4\2\65\65HH\3\2\u0089\u008a\4\2##DD\7\2\37\37NNWW\u0080\u0080"+
		"\u0083\u0083\4\2((BB\4\2\r\r\22\23\3\2\16\17\3\2\24\27\3\2\30\33\6\2S"+
		"Sggii||\4\2AA\u0091\u0091\5\2\37\37NN\u0083\u0083\4\2\13\13pp\6\2:\u0304\3\2\2\2@\u030a\3\2\2\2B\u0318\3\2\2\2D\u0327\3\2\2\2F\u033f"+
		"\3\2\2\2H\u038b\3\2\2\2J\u038e\3\2\2\2L\u03a7\3\2\2\2N\u03aa\3\2\2\2P"+
		"\u03d4\3\2\2\2R\u03d6\3\2\2\2T\u03e1\3\2\2\2V\u03f3\3\2\2\2X\u041b\3\2"+
		"\2\2Z\u046a\3\2\2\2\\\u04eb\3\2\2\2^\u04ef\3\2\2\2`\u04f3\3\2\2\2b\u050a"+
		"\3\2\2\2d\u053a\3\2\2\2f\u0544\3\2\2\2h\u054e\3\2\2\2j\u0576\3\2\2\2l"+
		"\u058b\3\2\2\2n\u058e\3\2\2\2p\u0593\3\2\2\2r\u059d\3\2\2\2t\u05a0\3\2"+
		"\2\2v\u05aa\3\2\2\2x\u05b5\3\2\2\2z\u05b7\3\2\2\2|\u05d6\3\2\2\2~\u0607"+
		"\3\2\2\2\u0080\u0609\3\2\2\2\u0082\u0620\3\2\2\2\u0084\u0630\3\2\2\2\u0086"+
		"\u066a\3\2\2\2\u0088\u0671\3\2\2\2\u008a\u0673\3\2\2\2\u008c\u0682\3\2"+
		"\2\2\u008e\u0686\3\2\2\2\u0090\u0688\3\2\2\2\u0092\u068a\3\2\2\2\u0094"+
		"\u068e\3\2\2\2\u0096\u0690\3\2\2\2\u0098\u0692\3\2\2\2\u009a\u0694\3\2"+
		"\2\2\u009c\u0696\3\2\2\2\u009e\u0698\3\2\2\2\u00a0\u06a2\3\2\2\2\u00a2"+
		"\u06a5\3\2\2\2\u00a4\u06a7\3\2\2\2\u00a6\u06a9\3\2\2\2\u00a8\u06ab\3\2"+
		"\2\2\u00aa\u06ad\3\2\2\2\u00ac\u06af\3\2\2\2\u00ae\u06b1\3\2\2\2\u00b0"+
		"\u06b3\3\2\2\2\u00b2\u06b5\3\2\2\2\u00b4\u06b7\3\2\2\2\u00b6\u06b9\3\2"+
		"\2\2\u00b8\u06bb\3\2\2\2\u00ba\u06bd\3\2\2\2\u00bc\u06bf\3\2\2\2\u00be"+
		"\u06c7\3\2\2\2\u00c0\u06c9\3\2\2\2\u00c2\u06cb\3\2\2\2\u00c4\u06d4\3\2"+
		"\2\2\u00c6\u00c9\5\b\5\2\u00c7\u00c9\5\6\4\2\u00c8\u00c6\3\2\2\2\u00c8"+
		"\u00c7\3\2\2\2\u00c9\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2"+
		"\2\2\u00cb\u00cd\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00ce\7\2\2\3\u00ce"+
		"\3\3\2\2\2\u00cf\u00d6\5l\67\2\u00d0\u00d6\5\u009eP\2\u00d1\u00d6\5\u00a0"+
		"Q\2\u00d2\u00d6\5t;\2\u00d3\u00d6\58\35\2\u00d4\u00d6\5r:\2\u00d5\u00cf"+
		"\3\2\2\2\u00d5\u00d0\3\2\2\2\u00d5\u00d1\3\2\2\2\u00d5\u00d2\3\2\2\2\u00d5"+
		"\u00d3\3\2\2\2\u00d5\u00d4\3\2\2\2\u00d6\5\3\2\2\2\u00d7\u00d8\7\u00a3"+
		"\2\2\u00d8\u00d9\b\4\1\2\u00d9\7\3\2\2\2\u00da\u00dc\7\7\2\2\u00db\u00da"+
		"\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de"+
		"\u00e0\3\2\2\2\u00df\u00dd\3\2\2\2\u00e0\u00e9\5\n\6\2\u00e1\u00e3\7\7"+
		"\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4"+
		"\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e8\5\n\6\2\u00e7\u00e2\3\2"+
		"\2\2\u00e8\u00eb\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea"+
		"\u00ef\3\2\2\2\u00eb\u00e9\3\2\2\2\u00ec\u00ee\7\7\2\2\u00ed\u00ec\3\2"+
		"\2\2\u00ee\u00f1\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0"+
		"\t\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2\u00f5\7M\2\2\u00f3\u00f4\7x\2\2\u00f4"+
		"\u00f6\7u\2\2\u00f5\u00f3\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f8\3\2"+
		"\2\2\u00f7\u00f2\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u0117\3\2\2\2\u00f9"+
		"\u0118\5\f\7\2\u00fa\u0118\5\16\b\2\u00fb\u0118\5\20\t\2\u00fc\u0118\5"+
		"\22\n\2\u00fd\u0118\5\24\13\2\u00fe\u0118\5\26\f\2\u00ff\u0118\5\30\r"+
		"\2\u0100\u0118\5\32\16\2\u0101\u0118\5\34\17\2\u0102\u0118\5\36\20\2\u0103"+
		"\u0118\5 \21\2\u0104\u0118\5\"\22\2\u0105\u0118\5$\23\2\u0106\u0118\5"+
		"&\24\2\u0107\u0118\5(\25\2\u0108\u0118\5*\26\2\u0109\u0118\5,\27\2\u010a"+
		"\u0118\5.\30\2\u010b\u0118\5\60\31\2\u010c\u0118\5\62\32\2\u010d\u0118"+
		"\5:\36\2\u010e\u0118\5<\37\2\u010f\u0118\5> \2\u0110\u0118\5@!\2\u0111"+
		"\u0118\5B\"\2\u0112\u0118\5D#\2\u0113\u0118\5F$\2\u0114\u0118\5J&\2\u0115"+
		"\u0118\5N(\2\u0116\u0118\5P)\2\u0117\u00f9\3\2\2\2\u0117\u00fa\3\2\2\2"+
		"\u0117\u00fb\3\2\2\2\u0117\u00fc\3\2\2\2\u0117\u00fd\3\2\2\2\u0117\u00fe"+
		"\3\2\2\2\u0117\u00ff\3\2\2\2\u0117\u0100\3\2\2\2\u0117\u0101\3\2\2\2\u0117"+
		"\u0102\3\2\2\2\u0117\u0103\3\2\2\2\u0117\u0104\3\2\2\2\u0117\u0105\3\2"+
		"\2\2\u0117\u0106\3\2\2\2\u0117\u0107\3\2\2\2\u0117\u0108\3\2\2\2\u0117"+
		"\u0109\3\2\2\2\u0117\u010a\3\2\2\2\u0117\u010b\3\2\2\2\u0117\u010c\3\2"+
		"\2\2\u0117\u010d\3\2\2\2\u0117\u010e\3\2\2\2\u0117\u010f\3\2\2\2\u0117"+
		"\u0110\3\2\2\2\u0117\u0111\3\2\2\2\u0117\u0112\3\2\2\2\u0117\u0113\3\2"+
		"\2\2\u0117\u0114\3\2\2\2\u0117\u0115\3\2\2\2\u0117\u0116\3\2\2\2\u0118"+
		"\13\3\2\2\2\u0119\u011a\7$\2\2\u011a\u011e\7\u0088\2\2\u011b\u011c\5\u00a2"+
		"R\2\u011c\u011d\7\b\2\2\u011d\u011f\3\2\2\2\u011e\u011b\3\2\2\2\u011e"+
		"\u011f\3\2\2\2\u011f\u0120\3\2\2\2\u0120\u0129\5\u00a4S\2\u0121\u0122"+
		"\7\177\2\2\u0122\u0123\7\u008c\2\2\u0123\u012a\5\u00a8U\2\u0124\u0126"+
		"\7!\2\2\u0125\u0127\7\64\2\2\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2\u0127"+
		"\u0128\3\2\2\2\u0128\u012a\5R*\2\u0129\u0121\3\2\2\2\u0129\u0124\3\2\2"+
		"\2\u012a\r\3\2\2\2\u012b\u0132\7%\2\2\u012c\u0133\5\u00a2R\2\u012d\u0133"+
		"\5\u00a6T\2\u012e\u012f\5\u00a2R\2\u012f\u0130\7\b\2\2\u0130\u0131\5\u00a6"+
		"T\2\u0131\u0133\3\2\2\2\u0132\u012c\3\2\2\2\u0132\u012d\3\2\2\2\u0132"+
		"\u012e\3\2\2\2\u0132\u0133\3\2\2\2\u0133\17\3\2\2\2\u0134\u0136\7)\2\2"+
		"\u0135\u0137\7=\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138"+
		"\3\2\2\2\u0138\u0139\5Z.\2\u0139\u013a\7\'\2\2\u013a\u013b\5\u00a2R\2"+
		"\u013b\21\3\2\2\2\u013c\u013e\7,\2\2\u013d\u013f\t\2\2\2\u013e\u013d\3"+
		"\2\2\2\u013e\u013f\3\2\2\2\u013f\u0144\3\2\2\2\u0140\u0142\7\u008d\2\2"+
		"\u0141\u0143\5\u00c2b\2\u0142\u0141\3\2\2\2\u0142\u0143\3\2\2\2\u0143"+
		"\u0145\3\2\2\2\u0144\u0140\3\2\2\2\u0144\u0145\3\2\2\2\u0145\23\3\2\2"+
		"\2\u0146\u014b\t\3\2\2\u0147\u0149\7\u008d\2\2\u0148\u014a\5\u00c2b\2"+
		"\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014c\3\2\2\2\u014b\u0147"+
		"\3\2\2\2\u014b\u014c\3\2\2\2\u014c\25\3\2\2\2\u014d\u014f\7\u0099\2\2"+
		"\u014e\u0150\7z\2\2\u014f\u014e\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151"+
		"\3\2\2\2\u0151\u0156\5z>\2\u0152\u0153\7\13\2\2\u0153\u0155\5z>\2\u0154"+
		"\u0152\3\2\2\2\u0155\u0158\3\2\2\2\u0156\u0154\3\2\2\2\u0156\u0157\3\2"+
		"\2\2\u0157\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0159\u014d\3\2\2\2\u0159"+
		"\u015a\3\2\2\2\u015a\u015b\3\2\2\2\u015b\u0165\5\u0086D\2\u015c\u015e"+
		"\7\u008f\2\2\u015d\u015f\7#\2\2\u015e\u015d\3\2\2\2\u015e\u015f\3\2\2"+
		"\2\u015f\u0163\3\2\2\2\u0160\u0163\7`\2\2\u0161\u0163\7J\2\2\u0162\u015c"+
		"\3\2\2\2\u0162\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0163\u0164\3\2\2\2\u0164"+
		"\u0166\5\u0086D\2\u0165\u0162\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0165"+
		"\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u016b\5t;\2\u016a"+
		"\u0169\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u0170\3\2\2\2\u016c\u016e\58"+
		"\35\2\u016d\u016f\5r:\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2\2\2\u016f"+
		"\u0171\3\2\2\2\u0170\u016c\3\2\2\2\u0170\u0171\3\2\2\2\u0171\27\3\2\2"+
		"\2\u0172\u0174\78\2\2\u0173\u0175\7\u0090\2\2\u0174\u0173\3\2\2\2\u0174"+
		"\u0175\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u017a\7Z\2\2\u0177\u0178\7V\2"+
		"\2\u0178\u0179\7l\2\2\u0179\u017b\7L\2\2\u017a\u0177\3\2\2\2\u017a\u017b"+
		"\3\2\2\2\u017b\u017f\3\2\2\2\u017c\u017d\5\u00a2R\2\u017d\u017e\7\b\2"+
		"\2\u017e\u0180\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181"+
		"\3\2\2\2\u0181\u0182\5\u00b2Z\2\u0182\u0183\7q\2\2\u0183\u0184\5\u00a4"+
		"S\2\u0184\u0185\7\t\2\2\u0185\u018a\5f\64\2\u0186\u0187\7\13\2\2\u0187"+
		"\u0189\5f\64\2\u0188\u0186\3\2\2\2\u0189\u018c\3\2\2\2\u018a\u0188\3\2"+
		"\2\2\u018a\u018b\3\2\2\2\u018b\u018d\3\2\2\2\u018c\u018a\3\2\2\2\u018d"+
		"\u018f\7\n\2\2\u018e\u0190\5l\67\2\u018f\u018e\3\2\2\2\u018f\u0190\3\2"+
		"\2\2\u0190\31\3\2\2\2\u0191\u0193\78\2\2\u0192\u0194\t\4\2\2\u0193\u0192"+
		"\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0195\3\2\2\2\u0195\u0199\7\u0088\2"+
		"\2\u0196\u0197\7V\2\2\u0197\u0198\7l\2\2\u0198\u019a\7L\2\2\u0199\u0196"+
		"\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019e\3\2\2\2\u019b\u019c\5\u00a2R"+
		"\2\u019c\u019d\7\b\2\2\u019d\u019f\3\2\2\2\u019e\u019b\3\2\2\2\u019e\u019f"+
		"\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01b8\5\u00a4S\2\u01a1\u01a2\7\t\2"+
		"\2\u01a2\u01a7\5R*\2\u01a3\u01a4\7\13\2\2\u01a4\u01a6\5R*\2\u01a5\u01a3"+
		"\3\2\2\2\u01a6\u01a9\3\2\2\2\u01a7\u01a5\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8"+
		"\u01ae\3\2\2\2\u01a9\u01a7\3\2\2\2\u01aa\u01ab\7\13\2\2\u01ab\u01ad\5"+
		"h\65\2\u01ac\u01aa\3\2\2\2\u01ad\u01b0\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae"+
		"\u01af\3\2\2\2\u01af\u01b1\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b1\u01b4\7\n"+
		"\2\2\u01b2\u01b3\7\u009a\2\2\u01b3\u01b5\7\u009b\2\2\u01b4\u01b2\3\2\2"+
		"\2\u01b4\u01b5\3\2\2\2\u01b5\u01b9\3\2\2\2\u01b6\u01b7\7\'\2\2\u01b7\u01b9"+
		"\5F$\2\u01b8\u01a1\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b9\33\3\2\2\2\u01ba"+
		"\u01bc\78\2\2\u01bb\u01bd\t\4\2\2\u01bc\u01bb\3\2\2\2\u01bc\u01bd\3\2"+
		"\2\2\u01bd\u01be\3\2\2\2\u01be\u01c2\7\u008e\2\2\u01bf\u01c0\7V\2\2\u01c0"+
		"\u01c1\7l\2\2\u01c1\u01c3\7L\2\2\u01c2\u01bf\3\2\2\2\u01c2\u01c3\3\2\2"+
		"\2\u01c3\u01c7\3\2\2\2\u01c4\u01c5\5\u00a2R\2\u01c5\u01c6\7\b\2\2\u01c6"+
		"\u01c8\3\2\2\2\u01c7\u01c4\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\3\2"+
		"\2\2\u01c9\u01ce\5\u00b4[\2\u01ca\u01cf\7+\2\2\u01cb\u01cf\7\"\2\2\u01cc"+
		"\u01cd\7_\2\2\u01cd\u01cf\7o\2\2\u01ce\u01ca\3\2\2\2\u01ce\u01cb\3\2\2"+
		"\2\u01ce\u01cc\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01de\3\2\2\2\u01d0\u01df"+
		"\7A\2\2\u01d1\u01df\7^\2\2\u01d2\u01dc\7\u0091\2\2\u01d3\u01d4\7o\2\2"+
		"\u01d4\u01d9\5\u00aaV\2\u01d5\u01d6\7\13\2\2\u01d6\u01d8\5\u00aaV\2\u01d7"+
		"\u01d5\3\2\2\2\u01d8\u01db\3\2\2\2\u01d9\u01d7\3\2\2\2\u01d9\u01da\3\2"+
		"\2\2\u01da\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01dc\u01d3\3\2\2\2\u01dc"+
		"\u01dd\3\2\2\2\u01dd\u01df\3\2\2\2\u01de\u01d0\3\2\2\2\u01de\u01d1\3\2"+
		"\2\2\u01de\u01d2\3\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e4\7q\2\2\u01e1"+
		"\u01e2\5\u00a2R\2\u01e2\u01e3\7\b\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e1"+
		"\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01ea\5\u00a4S"+
		"\2\u01e7\u01e8\7O\2\2\u01e8\u01e9\7F\2\2\u01e9\u01eb\7\u0084\2\2\u01ea"+
		"\u01e7\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ed\7\u0097"+
		"\2\2\u01ed\u01ef\5Z.\2\u01ee\u01ec\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef\u01f0"+
		"\3\2\2\2\u01f0\u01f9\7,\2\2\u01f1\u01f6\5J&\2\u01f2\u01f6\5\62\32\2\u01f3"+
		"\u01f6\5\"\22\2\u01f4\u01f6\5F$\2\u01f5\u01f1\3\2\2\2\u01f5\u01f2\3\2"+
		"\2\2\u01f5\u01f3\3\2\2\2\u01f5\u01f4\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7"+
		"\u01f8\7\7\2\2\u01f8\u01fa\3\2\2\2\u01f9\u01f5\3\2\2\2\u01fa\u01fb\3\2"+
		"\2\2\u01fb\u01f9\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fd\3\2\2\2\u01fd"+
		"\u01fe\7H\2\2\u01fe\35\3\2\2\2\u01ff\u0201\78\2\2\u0200\u0202\t\4\2\2"+
		"\u0201\u0200\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0207"+
		"\7\u0095\2\2\u0204\u0205\7V\2\2\u0205\u0206\7l\2\2\u0206\u0208\7L\2\2"+
		"\u0207\u0204\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u020c\3\2\2\2\u0209\u020a"+
		"\5\u00a2R\2\u020a\u020b\7\b\2\2\u020b\u020d\3\2\2\2\u020c\u0209\3\2\2"+
		"\2\u020c\u020d\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u020f\5\u00b6\\\2\u020f"+
		"\u0210\7\'\2\2\u0210\u0211\5F$\2\u0211\37\3\2\2\2\u0212\u0213\78\2\2\u0213"+
		"\u0214\7\u0096\2\2\u0214\u0218\7\u0088\2\2\u0215\u0216\7V\2\2\u0216\u0217"+
		"\7l\2\2\u0217\u0219\7L\2\2\u0218\u0215\3\2\2\2\u0218\u0219\3\2\2\2\u0219"+
		"\u021d\3\2\2\2\u021a\u021b\5\u00a2R\2\u021b\u021c\7\b\2\2\u021c\u021e"+
		"\3\2\2\2\u021d\u021a\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u021f\3\2\2\2\u021f"+
		"\u0220\5\u00a4S\2\u0220\u0221\7\u0092\2\2\u0221\u022d\5\u00b8]\2\u0222"+
		"\u0223\7\t\2\2\u0223\u0228\5\u0094K\2\u0224\u0225\7\13\2\2\u0225\u0227"+
		"\5\u0094K\2\u0226\u0224\3\2\2\2\u0227\u022a\3\2\2\2\u0228\u0226\3\2\2"+
		"\2\u0228\u0229\3\2\2\2\u0229\u022b\3\2\2\2\u022a\u0228\3\2\2\2\u022b\u022c"+
		"\7\n\2\2\u022c\u022e\3\2\2\2\u022d\u0222\3\2\2\2\u022d\u022e\3\2\2\2\u022e"+
		"!\3\2\2\2\u022f\u0231\5j\66\2\u0230\u022f\3\2\2\2\u0230\u0231\3\2\2\2"+
		"\u0231\u0232\3\2\2\2\u0232\u0233\7A\2\2\u0233\u0234\7Q\2\2\u0234\u0236"+
		"\5p9\2\u0235\u0237\5l\67\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237"+
		"#\3\2\2\2\u0238\u023a\5j\66\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2"+
		"\u023a\u023b\3\2\2\2\u023b\u023c\7A\2\2\u023c\u023d\7Q\2\2\u023d\u023f"+
		"\5p9\2\u023e\u0240\5l\67\2\u023f\u023e\3\2\2\2\u023f\u0240\3\2\2\2\u0240"+
		"\u0248\3\2\2\2\u0241\u0243\5t;\2\u0242\u0241\3\2\2\2\u0242\u0243\3\2\2"+
		"\2\u0243\u0244\3\2\2\2\u0244\u0246\58\35\2\u0245\u0247\5r:\2\u0246\u0245"+
		"\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0249\3\2\2\2\u0248\u0242\3\2\2\2\u0248"+
		"\u0249\3\2\2\2\u0249%\3\2\2\2\u024a\u024c\7C\2\2\u024b\u024d\7=\2\2\u024c"+
		"\u024b\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024e\3\2\2\2\u024e\u024f\5\u00a2"+
		"R\2\u024f\'\3\2\2\2\u0250\u0251\7E\2\2\u0251\u0254\7Z\2\2\u0252\u0253"+
		"\7V\2\2\u0253\u0255\7L\2\2\u0254\u0252\3\2\2\2\u0254\u0255\3\2\2\2\u0255"+
		"\u0259\3\2\2\2\u0256\u0257\5\u00a2R\2\u0257\u0258\7\b\2\2\u0258\u025a"+
		"\3\2\2\2\u0259\u0256\3\2\2\2\u0259\u025a\3\2\2\2\u025a\u025b\3\2\2\2\u025b"+
		"\u025c\5\u00b2Z\2\u025c)\3\2\2\2\u025d\u025e\7E\2\2\u025e\u0261\7\u0088"+
		"\2\2\u025f\u0260\7V\2\2\u0260\u0262\7L\2\2\u0261\u025f\3\2\2\2\u0261\u0262"+
		"\3\2\2\2\u0262\u0266\3\2\2\2\u0263\u0264\5\u00a2R\2\u0264\u0265\7\b\2"+
		"\2\u0265\u0267\3\2\2\2\u0266\u0263\3\2\2\2\u0266\u0267\3\2\2\2\u0267\u0268"+
		"\3\2\2\2\u0268\u0269\5\u00a4S\2\u0269+\3\2\2\2\u026a\u026b\7E\2\2\u026b"+
		"\u026e\7\u008e\2\2\u026c\u026d\7V\2\2\u026d\u026f\7L\2\2\u026e\u026c\3"+
		"\2\2\2\u026e\u026f\3\2\2\2\u026f\u0273\3\2\2\2\u0270\u0271\5\u00a2R\2"+
		"\u0271\u0272\7\b\2\2\u0272\u0274\3\2\2\2\u0273\u0270\3\2\2\2\u0273\u0274"+
		"\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\5\u00b4[\2\u0276-\3\2\2\2\u0277"+
		"\u0278\7E\2\2\u0278\u027b\7\u0095\2\2\u0279\u027a\7V\2\2\u027a\u027c\7"+
		"L\2\2\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u0280\3\2\2\2\u027d"+
		"\u027e\5\u00a2R\2\u027e\u027f\7\b\2\2\u027f\u0281\3\2\2\2\u0280\u027d"+
		"\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0283\5\u00b6\\"+
		"\2\u0283/\3\2\2\2\u0284\u0286\7\u0099\2\2\u0285\u0287\7z\2\2\u0286\u0285"+
		"\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u028d\5z>\2\u0289"+
		"\u028a\7\13\2\2\u028a\u028c\5z>\2\u028b\u0289\3\2\2\2\u028c\u028f\3\2"+
		"\2\2\u028d\u028b\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u0291\3\2\2\2\u028f"+
		"\u028d\3\2\2\2\u0290\u0284\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0292\3\2"+
		"\2\2\u0292\u0298\5\u0086D\2\u0293\u0294\5\u0088E\2\u0294\u0295\5\u0086"+
		"D\2\u0295\u0297\3\2\2\2\u0296\u0293\3\2\2\2\u0297\u029a\3\2\2\2\u0298"+
		"\u0296\3\2\2\2\u0298\u0299\3\2\2\2\u0299\u029c\3\2\2\2\u029a\u0298\3\2"+
		"\2\2\u029b\u029d\5t;\2\u029c\u029b\3\2\2\2\u029c\u029d\3\2\2\2\u029d\u02a2"+
		"\3\2\2\2\u029e\u02a0\58\35\2\u029f\u02a1\5r:\2\u02a0\u029f\3\2\2\2\u02a0"+
		"\u02a1\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u029e\3\2\2\2\u02a2\u02a3\3\2"+
		"\2\2\u02a3\61\3\2\2\2\u02a4\u02a6\5j\66\2\u02a5\u02a4\3\2\2\2\u02a5\u02a6"+
		"\3\2\2\2\u02a6\u02ac\3\2\2\2\u02a7\u02ad\7^\2\2\u02a8\u02ad\7\u0080\2"+
		"\2\u02a9\u02aa\7^\2\2\u02aa\u02ab\7r\2\2\u02ab\u02ad\5L\'\2\u02ac\u02a7"+
		"\3\2\2\2\u02ac\u02a8\3\2\2\2\u02ac\u02a9\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae"+
		"\u02b2\7a\2\2\u02af\u02b0\5\u00a2R\2\u02b0\u02b1\7\b\2\2\u02b1\u02b3\3"+
		"\2\2\2\u02b2\u02af\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b4\3\2\2\2\u02b4"+
		"\u02b9\5\u00a4S\2\u02b5\u02b6\7\t\2\2\u02b6\u02b7\5\64\33\2\u02b7\u02b8"+
		"\7\n\2\2\u02b8\u02ba\3\2\2\2\u02b9\u02b5\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba"+
		"\u02d3\3\2\2\2\u02bb\u02bc\7\u0094\2\2\u02bc\u02bd\7\t\2\2\u02bd\u02be"+
		"\5\66\34\2\u02be\u02cd\7\n\2\2\u02bf\u02c0\7\13\2\2\u02c0\u02c1\7\t\2"+
		"\2\u02c1\u02c6\5Z.\2\u02c2\u02c3\7\13\2\2\u02c3\u02c5\5Z.\2\u02c4\u02c2"+
		"\3\2\2\2\u02c5\u02c8\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7"+
		"\u02c9\3\2\2\2\u02c8\u02c6\3\2\2\2\u02c9\u02ca\7\n\2\2\u02ca\u02cc\3\2"+
		"\2\2\u02cb\u02bf\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd"+
		"\u02ce\3\2\2\2\u02ce\u02d4\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d4\5F"+
		"$\2\u02d1\u02d2\7>\2\2\u02d2\u02d4\7\u0094\2\2\u02d3\u02bb\3\2\2\2\u02d3"+
		"\u02d0\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d4\63\3\2\2\2\u02d5\u02da\5\u00aa"+
		"V\2\u02d6\u02d7\7\13\2\2\u02d7\u02d9\5\u00aaV\2\u02d8\u02d6\3\2\2\2\u02d9"+
		"\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\65\3\2\2"+
		"\2\u02dc\u02da\3\2\2\2\u02dd\u02e2\5Z.\2\u02de\u02df\7\13\2\2\u02df\u02e1"+
		"\5Z.\2\u02e0\u02de\3\2\2\2\u02e1\u02e4\3\2\2\2\u02e2\u02e0\3\2\2\2\u02e2"+
		"\u02e3\3\2\2\2\u02e3\67\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e5\u02e6\7h\2\2"+
		"\u02e6\u02e7\5Z.\2\u02e79\3\2\2\2\u02e8\u02ec\7v\2\2\u02e9\u02ea\5\u00a2"+
		"R\2\u02ea\u02eb\7\b\2\2\u02eb\u02ed\3\2\2\2\u02ec\u02e9\3\2\2\2\u02ec"+
		"\u02ed\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f5\5\u00ba^\2\u02ef\u02f0"+
		"\7\f\2\2\u02f0\u02f6\5x=\2\u02f1\u02f2\7\t\2\2\u02f2\u02f3\5x=\2\u02f3"+
		"\u02f4\7\n\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02ef\3\2\2\2\u02f5\u02f1\3\2"+
		"\2\2\u02f5\u02f6\3\2\2\2\u02f6;\3\2\2\2\u02f7\u0302\7}\2\2\u02f8\u0303"+
		"\5\u00aeX\2\u02f9\u02fa\5\u00a2R\2\u02fa\u02fb\7\b\2\2\u02fb\u02fd\3\2"+
		"\2\2\u02fc\u02f9\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u0300\3\2\2\2\u02fe"+
		"\u0301\5\u00a4S\2\u02ff\u0301\5\u00b2Z\2\u0300\u02fe\3\2\2\2\u0300\u02ff"+
		"\3\2\2\2\u0301\u0303\3\2\2\2\u0302\u02f8\3\2\2\2\u0302\u02fc\3\2\2\2\u0302"+
		"\u0303\3\2\2\2\u0303=\3\2\2\2\u0304\u0306\7~\2\2\u0305\u0307\7\u0085\2"+
		"\2\u0306\u0305\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u0309"+
		"\5\u00be`\2\u0309?\3\2\2\2\u030a\u030f\7\u0083\2\2\u030b\u030d\7\u008d"+
		"\2\2\u030c\u030e\5\u00c2b\2\u030d\u030c\3\2\2\2\u030d\u030e\3\2\2\2\u030e"+
		"\u0310\3\2\2\2\u030f\u030b\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0316\3\2"+
		"\2\2\u0311\u0313\7\u008c\2\2\u0312\u0314\7\u0085\2\2\u0313\u0312\3\2\2"+
		"\2\u0313\u0314\3\2\2\2\u0314\u0315\3\2\2\2\u0315\u0317\5\u00be`\2\u0316"+
		"\u0311\3\2\2\2\u0316\u0317\3\2\2\2\u0317A\3\2\2\2\u0318\u0319\7\u0085"+
		"\2\2\u0319\u031a\5\u00be`\2\u031aC\3\2\2\2\u031b\u031d\7\u0099\2\2\u031c"+
		"\u031e\7z\2\2\u031d\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u031f\3\2"+
		"\2\2\u031f\u0324\5z>\2\u0320\u0321\7\13\2\2\u0321\u0323\5z>\2\u0322\u0320"+
		"\3\2\2\2\u0323\u0326\3\2\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2\u0325"+
		"\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0327\u031b\3\2\2\2\u0327\u0328\3\2"+
		"\2\2\u0328\u0329\3\2\2\2\u0329\u032b\5\u0086D\2\u032a\u032c\5t;\2\u032b"+
		"\u032a\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u0331\3\2\2\2\u032d\u032f\58"+
		"\35\2\u032e\u0330\5r:\2\u032f\u032e\3\2\2\2\u032f\u0330\3\2\2\2\u0330"+
		"\u0332\3\2\2\2\u0331\u032d\3\2\2\2\u0331\u0332\3\2\2\2\u0332E\3\2\2\2"+
		"\u0333\u0335\7\u0099\2\2\u0334\u0336\7z\2\2\u0335\u0334\3\2\2\2\u0335"+
		"\u0336\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u033c\5z>\2\u0338\u0339\7\13"+
		"\2\2\u0339\u033b\5z>\2\u033a\u0338\3\2\2\2\u033b\u033e\3\2\2\2\u033c\u033a"+
		"\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u0340\3\2\2\2\u033e\u033c\3\2\2\2\u033f"+
		"\u0333\3\2\2\2\u033f\u0340\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0347\5H"+
		"%\2\u0342\u0343\5\u0088E\2\u0343\u0344\5H%\2\u0344\u0346\3\2\2\2\u0345"+
		"\u0342\3\2\2\2\u0346\u0349\3\2\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2"+
		"\2\2\u0348\u034b\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034c\5t;\2\u034b\u034a"+
		"\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u0351\3\2\2\2\u034d\u034f\58\35\2\u034e"+
		"\u0350\5r:\2\u034f\u034e\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0352\3\2\2"+
		"\2\u0351\u034d\3\2\2\2\u0351\u0352\3\2\2\2\u0352G\3\2\2\2\u0353\u0355"+
		"\7\u0086\2\2\u0354\u0356\t\5\2\2\u0355\u0354\3\2\2\2\u0355\u0356\3\2\2"+
		"\2\u0356\u0357\3\2\2\2\u0357\u0364\5\u00bc_\2\u0358\u0362\7Q\2\2\u0359"+
		"\u035e\5~@\2\u035a\u035b\7\13\2\2\u035b\u035d\5~@\2\u035c\u035a\3\2\2"+
		"\2\u035d\u0360\3\2\2\2\u035e\u035c\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0363"+
		"\3\2\2\2\u0360\u035e\3\2\2\2\u0361\u0363\5\u0080A\2\u0362\u0359\3\2\2"+
		"\2\u0362\u0361\3\2\2\2\u0363\u0365\3\2\2\2\u0364\u0358\3\2\2\2\u0364\u0365"+
		"\3\2\2\2\u0365\u0367\3\2\2\2\u0366\u0368\5l\67\2\u0367\u0366\3\2\2\2\u0367"+
		"\u0368\3\2\2\2\u0368\u036d\3\2\2\2\u0369\u036b\5\u009eP\2\u036a\u036c"+
		"\5\u00a0Q\2\u036b\u036a\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036e\3\2\2"+
		"\2\u036d\u0369\3\2\2\2\u036d\u036e\3\2\2\2\u036e\u038c\3\2\2\2\u036f\u0370"+
		"\7\u0094\2\2\u0370\u0371\7\t\2\2\u0371\u0376\5Z.\2\u0372\u0373\7\13\2"+
		"\2\u0373\u0375\5Z.\2\u0374\u0372\3\2\2\2\u0375\u0378\3\2\2\2\u0376\u0374"+
		"\3\2\2\2\u0376\u0377\3\2\2\2\u0377\u0379\3\2\2\2\u0378\u0376\3\2\2\2\u0379"+
		"\u0388\7\n\2\2\u037a\u037b\7\13\2\2\u037b\u037c\7\t\2\2\u037c\u0381\5"+
		"Z.\2\u037d\u037e\7\13\2\2\u037e\u0380\5Z.\2\u037f\u037d\3\2\2\2\u0380"+
		"\u0383\3\2\2\2\u0381\u037f\3\2\2\2\u0381\u0382\3\2\2\2\u0382\u0384\3\2"+
		"\2\2\u0383\u0381\3\2\2\2\u0384\u0385\7\n\2\2\u0385\u0387\3\2\2\2\u0386"+
		"\u037a\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u0386\3\2\2\2\u0388\u0389\3\2"+
		"\2\2\u0389\u038c\3\2\2\2\u038a\u0388\3\2\2\2\u038b\u0353\3\2\2\2\u038b"+
		"\u036f\3\2\2\2\u038cI\3\2\2\2\u038d\u038f\5j\66\2\u038e\u038d\3\2\2\2"+
		"\u038e\u038f\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0393\7\u0091\2\2\u0391"+
		"\u0392\7r\2\2\u0392\u0394\5L\'\2\u0393\u0391\3\2\2\2\u0393\u0394\3\2\2"+
		"\2\u0394\u0395\3\2\2\2\u0395\u0396\5p9\2\u0396\u0397\7\u0087\2\2\u0397"+
		"\u0398\5\u00acW\2\u0398\u0399\7\f\2\2\u0399\u03a1\5Z.\2\u039a\u039b\7"+
		"\13\2\2\u039b\u039c\5\u00acW\2\u039c\u039d\7\f\2\2\u039d\u039e\5Z.\2\u039e"+
		"\u03a0\3\2\2\2\u039f\u039a\3\2\2\2\u03a0\u03a3\3\2\2\2\u03a1\u039f\3\2"+
		"\2\2\u03a1\u03a2\3\2\2\2\u03a2\u03a5\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a4"+
		"\u03a6\5l\67\2\u03a5\u03a4\3\2\2\2\u03a5\u03a6\3\2\2\2\u03a6K\3\2\2\2"+
		"\u03a7\u03a8\t\6\2\2\u03a8M\3\2\2\2\u03a9\u03ab\5j\66\2\u03aa\u03a9\3"+
		"\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac\u03b7\7\u0091\2\2"+
		"\u03ad\u03ae\7r\2\2\u03ae\u03b8\7\u0083\2\2\u03af\u03b0\7r\2\2\u03b0\u03b8"+
		"\7\37\2\2\u03b1\u03b2\7r\2\2\u03b2\u03b8\7\u0080\2\2\u03b3\u03b4\7r\2"+
		"\2\u03b4\u03b8\7N\2\2\u03b5\u03b6\7r\2\2\u03b6\u03b8\7W\2\2\u03b7\u03ad"+
		"\3\2\2\2\u03b7\u03af\3\2\2\2\u03b7\u03b1\3\2\2\2\u03b7\u03b3\3\2\2\2\u03b7"+
		"\u03b5\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03ba\5p"+
		"9\2\u03ba\u03bb\7\u0087\2\2\u03bb\u03bc\5\u00acW\2\u03bc\u03bd\7\f\2\2"+
		"\u03bd\u03c5\5Z.\2\u03be\u03bf\7\13\2\2\u03bf\u03c0\5\u00acW\2\u03c0\u03c1"+
		"\7\f\2\2\u03c1\u03c2\5Z.\2\u03c2\u03c4\3\2\2\2\u03c3\u03be\3\2\2\2\u03c4"+
		"\u03c7\3\2\2\2\u03c5\u03c3\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u03c9\3\2"+
		"\2\2\u03c7\u03c5\3\2\2\2\u03c8\u03ca\5l\67\2\u03c9\u03c8\3\2\2\2\u03c9"+
		"\u03ca\3\2\2\2\u03ca\u03d2\3\2\2\2\u03cb\u03cd\5t;\2\u03cc\u03cb\3\2\2"+
		"\2\u03cc\u03cd\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\58\35\2\u03cf\u03d1"+
		"\5r:\2\u03d0\u03cf\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03d3\3\2\2\2\u03d2"+
		"\u03cc\3\2\2\2\u03d2\u03d3\3\2\2\2\u03d3O\3\2\2\2\u03d4\u03d5\7\u0093"+
		"\2\2\u03d5Q\3\2\2\2\u03d6\u03d8\5\u00aaV\2\u03d7\u03d9\5T+\2\u03d8\u03d7"+
		"\3\2\2\2\u03d8\u03d9\3\2\2\2\u03d9\u03dd\3\2\2\2\u03da\u03dc\5V,\2\u03db"+
		"\u03da\3\2\2\2\u03dc\u03df\3\2\2\2\u03dd\u03db\3\2\2\2\u03dd\u03de\3\2"+
		"\2\2\u03deS\3\2\2\2\u03df\u03dd\3\2\2\2\u03e0\u03e2\5\u009aN\2\u03e1\u03e0"+
		"\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4"+
		"\u03ef\3\2\2\2\u03e5\u03e6\7\t\2\2\u03e6\u03e7\5\u008cG\2\u03e7\u03e8"+
		"\7\n\2\2\u03e8\u03f0\3\2\2\2\u03e9\u03ea\7\t\2\2\u03ea\u03eb\5\u008cG"+
		"\2\u03eb\u03ec\7\13\2\2\u03ec\u03ed\5\u008cG\2\u03ed\u03ee\7\n\2\2\u03ee"+
		"\u03f0\3\2\2\2\u03ef\u03e5\3\2\2\2\u03ef\u03e9\3\2\2\2\u03ef\u03f0\3\2"+
		"\2\2\u03f0U\3\2\2\2\u03f1\u03f2\7\67\2\2\u03f2\u03f4\5\u009aN\2\u03f3"+
		"\u03f1\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u0416\3\2\2\2\u03f5\u03f6\7w"+
		"\2\2\u03f6\u03f8\7e\2\2\u03f7\u03f9\t\7\2\2\u03f8\u03f7\3\2\2\2\u03f8"+
		"\u03f9\3\2\2\2\u03f9\u03fa\3\2\2\2\u03fa\u03fc\5X-\2\u03fb\u03fd\7*\2"+
		"\2\u03fc\u03fb\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u0417\3\2\2\2\u03fe\u0400"+
		"\7l\2\2\u03ff\u03fe\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0401\3\2\2\2\u0401"+
		"\u0402\7n\2\2\u0402\u0417\5X-\2\u0403\u0404\7\u0090\2\2\u0404\u0417\5"+
		"X-\2\u0405\u0406\7\62\2\2\u0406\u0407\7\t\2\2\u0407\u0408\5Z.\2\u0408"+
		"\u0409\7\n\2\2\u0409\u0417\3\2\2\2\u040a\u0411\7>\2\2\u040b\u0412\5\u008c"+
		"G\2\u040c\u0412\5\u008eH\2\u040d\u040e\7\t\2\2\u040e\u040f\5Z.\2\u040f"+
		"\u0410\7\n\2\2\u0410\u0412\3\2\2\2\u0411\u040b\3\2\2\2\u0411\u040c\3\2"+
		"\2\2\u0411\u040d\3\2\2\2\u0412\u0417\3\2\2\2\u0413\u0414\7\63\2\2\u0414"+
		"\u0417\5\u00aeX\2\u0415\u0417\5b\62\2\u0416\u03f5\3\2\2\2\u0416\u03ff"+
		"\3\2\2\2\u0416\u0403\3\2\2\2\u0416\u0405\3\2\2\2\u0416\u040a\3\2\2\2\u0416"+
		"\u0413\3\2\2\2\u0416\u0415\3\2\2\2\u0417W\3\2\2\2\u0418\u0419\7q\2\2\u0419"+
		"\u041a\7\66\2\2\u041a\u041c\t\6\2\2\u041b\u0418\3\2\2\2\u041b\u041c\3"+
		"\2\2\2\u041cY\3\2\2\2\u041d\u041e\b.\1\2\u041e\u046b\5\u008eH\2\u041f"+
		"\u046b\5\\/\2\u0420\u046b\5`\61\2\u0421\u0422\5\u00a2R\2\u0422\u0423\7"+
		"\b\2\2\u0423\u0425\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0425\3\2\2\2\u0425"+
		"\u0426\3\2\2\2\u0426\u0427\5\u00a4S\2\u0427\u0428\7\b\2\2\u0428\u042a"+
		"\3\2\2\2\u0429\u0424\3\2\2\2\u0429\u042a\3\2\2\2\u042a\u042b\3\2\2\2\u042b"+
		"\u046b\5\u00aaV\2\u042c\u042d\5\u0090I\2\u042d\u042e\5Z.\27\u042e\u046b"+
		"\3\2\2\2\u042f\u0430\5\u009cO\2\u0430\u043d\7\t\2\2\u0431\u0433\7D\2\2"+
		"\u0432\u0431\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0439"+
		"\5Z.\2\u0435\u0436\7\13\2\2\u0436\u0438\5Z.\2\u0437\u0435\3\2\2\2\u0438"+
		"\u043b\3\2\2\2\u0439\u0437\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u043e\3\2"+
		"\2\2\u043b\u0439\3\2\2\2\u043c\u043e\7\r\2\2\u043d\u0432\3\2\2\2\u043d"+
		"\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e\u043f\3\2\2\2\u043f\u0440\7\n"+
		"\2\2\u0440\u046b\3\2\2\2\u0441\u0442\7\t\2\2\u0442\u0443\5Z.\2\u0443\u0444"+
		"\7\n\2\2\u0444\u046b\3\2\2\2\u0445\u0446\7\61\2\2\u0446\u0447\7\t\2\2"+
		"\u0447\u0448\5Z.\2\u0448\u0449\7\'\2\2\u0449\u044a\5T+\2\u044a\u044b\7"+
		"\n\2\2\u044b\u046b\3\2\2\2\u044c\u044e\7l\2\2\u044d\u044c\3\2\2\2\u044d"+
		"\u044e\3\2\2\2\u044e\u044f\3\2\2\2\u044f\u0451\7L\2\2\u0450\u044d\3\2"+
		"\2\2\u0450\u0451\3\2\2\2\u0451\u0452\3\2\2\2\u0452\u0453\7\t\2\2\u0453"+
		"\u0454\5F$\2\u0454\u0455\7\n\2\2\u0455\u046b\3\2\2\2\u0456\u0458\7\60"+
		"\2\2\u0457\u0459\5Z.\2\u0458\u0457\3\2\2\2\u0458\u0459\3\2\2\2\u0459\u045f"+
		"\3\2\2\2\u045a\u045b\7\u0097\2\2\u045b\u045c\5Z.\2\u045c\u045d\7\u008b"+
		"\2\2\u045d\u045e\5Z.\2\u045e\u0460\3\2\2\2\u045f\u045a\3\2\2\2\u0460\u0461"+
		"\3\2\2\2\u0461\u045f\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0465\3\2\2\2\u0463"+
		"\u0464\7G\2\2\u0464\u0466\5Z.\2\u0465\u0463\3\2\2\2\u0465\u0466\3\2\2"+
		"\2\u0466\u0467\3\2\2\2\u0467\u0468\7H\2\2\u0468\u046b\3\2\2\2\u0469\u046b"+
		"\5d\63\2\u046a\u041d\3\2\2\2\u046a\u041f\3\2\2\2\u046a\u0420\3\2\2\2\u046a"+
		"\u0429\3\2\2\2\u046a\u042c\3\2\2\2\u046a\u042f\3\2\2\2\u046a\u0441\3\2"+
		"\2\2\u046a\u0445\3\2\2\2\u046a\u0450\3\2\2\2\u046a\u0456\3\2\2\2\u046a"+
		"\u0469\3\2\2\2\u046b\u04d0\3\2\2\2\u046c\u046d\f\26\2\2\u046d\u046e\7"+
		"\21\2\2\u046e\u04cf\5Z.\27\u046f\u0470\f\25\2\2\u0470\u0471\t\b\2\2\u0471"+
		"\u04cf\5Z.\26\u0472\u0473\f\24\2\2\u0473\u0474\t\t\2\2\u0474\u04cf\5Z"+
		".\25\u0475\u0476\f\23\2\2\u0476\u0477\t\n\2\2\u0477\u04cf\5Z.\24\u0478"+
		"\u0479\f\22\2\2\u0479\u047a\t\13\2\2\u047a\u04cf\5Z.\23\u047b\u0488\f"+
		"\21\2\2\u047c\u0489\7\f\2\2\u047d\u0489\7\34\2\2\u047e\u0489\7\35\2\2"+
		"\u047f\u0489\7\36\2\2\u0480\u0489\7b\2\2\u0481\u0482\7b\2\2\u0482\u0489"+
		"\7l\2\2\u0483\u0489\7Y\2\2\u0484\u0489\7g\2\2\u0485\u0489\7S\2\2\u0486"+
		"\u0489\7i\2\2\u0487\u0489\7|\2\2\u0488\u047c\3\2\2\2\u0488\u047d\3\2\2"+
		"\2\u0488\u047e\3\2\2\2\u0488\u047f\3\2\2\2\u0488\u0480\3\2\2\2\u0488\u0481"+
		"\3\2\2\2\u0488\u0483\3\2\2\2\u0488\u0484\3\2\2\2\u0488\u0485\3\2\2\2\u0488"+
		"\u0486\3\2\2\2\u0488\u0487\3\2\2\2\u0489\u048a\3\2\2\2\u048a\u04cf\5Z"+
		".\22\u048b\u048c\f\20\2\2\u048c\u048d\7&\2\2\u048d\u04cf\5Z.\21\u048e"+
		"\u048f\f\17\2\2\u048f\u0490\7r\2\2\u0490\u04cf\5Z.\20\u0491\u0492\f\b"+
		"\2\2\u0492\u0494\7b\2\2\u0493\u0495\7l\2\2\u0494\u0493\3\2\2\2\u0494\u0495"+
		"\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u04cf\5Z.\t\u0497\u0499\f\7\2\2\u0498"+
		"\u049a\7l\2\2\u0499\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b\3\2"+
		"\2\2\u049b\u049c\7-\2\2\u049c\u049d\5Z.\2\u049d\u049e\7&\2\2\u049e\u049f"+
		"\5Z.\b\u049f\u04cf\3\2\2\2\u04a0\u04a1\f\13\2\2\u04a1\u04a2\7\63\2\2\u04a2"+
		"\u04cf\5\u00aeX\2\u04a3\u04a5\f\n\2\2\u04a4\u04a6\7l\2\2\u04a5\u04a4\3"+
		"\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a8\t\f\2\2\u04a8"+
		"\u04ab\5Z.\2\u04a9\u04aa\7I\2\2\u04aa\u04ac\5Z.\2\u04ab\u04a9\3\2\2\2"+
		"\u04ab\u04ac\3\2\2\2\u04ac\u04cf\3\2\2\2\u04ad\u04b2\f\t\2\2\u04ae\u04b3"+
		"\7c\2\2\u04af\u04b3\7m\2\2\u04b0\u04b1\7l\2\2\u04b1\u04b3\7n\2\2\u04b2"+
		"\u04ae\3\2\2\2\u04b2\u04af\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04cf\3\2"+
		"\2\2\u04b4\u04b6\f\6\2\2\u04b5\u04b7\7l\2\2\u04b6\u04b5\3\2\2\2\u04b6"+
		"\u04b7\3\2\2\2\u04b7\u04b8\3\2\2\2\u04b8\u04cc\7Y\2\2\u04b9\u04c3\7\t"+
		"\2\2\u04ba\u04c4\5F$\2\u04bb\u04c0\5Z.\2\u04bc\u04bd\7\13\2\2\u04bd\u04bf"+
		"\5Z.\2\u04be\u04bc\3\2\2\2\u04bf\u04c2\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0"+
		"\u04c1\3\2\2\2\u04c1\u04c4\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04ba\3\2"+
		"\2\2\u04c3\u04bb\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5"+
		"\u04cd\7\n\2\2\u04c6\u04c7\5\u00a2R\2\u04c7\u04c8\7\b\2\2\u04c8\u04ca"+
		"\3\2\2\2\u04c9\u04c6\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u04cb\3\2\2\2\u04cb"+
		"\u04cd\5\u00a4S\2\u04cc\u04b9\3\2\2\2\u04cc\u04c9\3\2\2\2\u04cd\u04cf"+
		"\3\2\2\2\u04ce\u046c\3\2\2\2\u04ce\u046f\3\2\2\2\u04ce\u0472\3\2\2\2\u04ce"+
		"\u0475\3\2\2\2\u04ce\u0478\3\2\2\2\u04ce\u047b\3\2\2\2\u04ce\u048b\3\2"+
		"\2\2\u04ce\u048e\3\2\2\2\u04ce\u0491\3\2\2\2\u04ce\u0497\3\2\2\2\u04ce"+
		"\u04a0\3\2\2\2\u04ce\u04a3\3\2\2\2\u04ce\u04ad\3\2\2\2\u04ce\u04b4\3\2"+
		"\2\2\u04cf\u04d2\3\2\2\2\u04d0\u04ce\3\2\2\2\u04d0\u04d1\3\2\2\2\u04d1"+
		"[\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d3\u04ec\7\u009d\2\2\u04d4\u04d8\7\3"+
		"\2\2\u04d5\u04d7\7\u00a2\2\2\u04d6\u04d5\3\2\2\2\u04d7\u04da\3\2\2\2\u04d8"+
		"\u04d6\3\2\2\2\u04d8\u04d9\3\2\2\2\u04d9\u04db\3\2\2\2\u04da\u04d8\3\2"+
		"\2\2\u04db\u04df\7\4\2\2\u04dc\u04de\7\u00a2\2\2\u04dd\u04dc\3\2\2\2\u04de"+
		"\u04e1\3\2\2\2\u04df\u04dd\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u04e2\3\2"+
		"\2\2\u04e1\u04df\3\2\2\2\u04e2\u04e6\5^\60\2\u04e3\u04e5\7\u00a2\2\2\u04e4"+
		"\u04e3\3\2\2\2\u04e5\u04e8\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2"+
		"\2\2\u04e7\u04e9\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e9\u04ea\7\5\2\2\u04ea"+
		"\u04ec\3\2\2\2\u04eb\u04d3\3\2\2\2\u04eb\u04d4\3\2\2\2\u04ec]\3\2\2\2"+
		"\u04ed\u04ee\7\u009b\2\2\u04ee\u04f0\7\b\2\2\u04ef\u04ed\3\2\2\2\u04ef"+
		"\u04f0\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u04f2\7\u009b\2\2\u04f2_\3\2"+
		"\2\2\u04f3\u04f7\7\6\2\2\u04f4\u04f6\7\u00a2\2\2\u04f5\u04f4\3\2\2\2\u04f6"+
		"\u04f9\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u04fa\3\2"+
		"\2\2\u04f9\u04f7\3\2\2\2\u04fa\u04fe\7\4\2\2\u04fb\u04fd\7\u00a2\2\2\u04fc"+
		"\u04fb\3\2\2\2\u04fd\u0500\3\2\2\2\u04fe\u04fc\3\2\2\2\u04fe\u04ff\3\2"+
		"\2\2\u04ff\u0501\3\2\2\2\u0500\u04fe\3\2\2\2\u0501\u0505\5^\60\2\u0502"+
		"\u0504\7\u00a2\2\2\u0503\u0502\3\2\2\2\u0504\u0507\3\2\2\2\u0505\u0503"+
		"\3\2\2\2\u0505\u0506\3\2\2\2\u0506\u0508\3\2\2\2\u0507\u0505\3\2\2\2\u0508"+
		"\u0509\7\5\2\2\u0509a\3\2\2\2\u050a\u050b\7{\2\2\u050b\u0517\5\u00b0Y"+
		"\2\u050c\u050d\7\t\2\2\u050d\u0512\5\u00aaV\2\u050e\u050f\7\13\2\2\u050f"+
		"\u0511\5\u00aaV\2\u0510\u050e\3\2\2\2\u0511\u0514\3\2\2\2\u0512\u0510"+
		"\3\2\2\2\u0512\u0513\3\2\2\2\u0513\u0515\3\2\2\2\u0514\u0512\3\2\2\2\u0515"+
		"\u0516\7\n\2\2\u0516\u0518\3\2\2\2\u0517\u050c\3\2\2\2\u0517\u0518\3\2"+
		"\2\2\u0518\u052b\3\2\2\2\u0519\u051a\7q\2\2\u051a\u0523\t\r\2\2\u051b"+
		"\u051c\7\u0087\2\2\u051c\u0524\7n\2\2\u051d\u051e\7\u0087\2\2\u051e\u0524"+
		"\7>\2\2\u051f\u0524\7/\2\2\u0520\u0524\7\u0081\2\2\u0521\u0522\7k\2\2"+
		"\u0522\u0524\7 \2\2\u0523\u051b\3\2\2\2\u0523\u051d\3\2\2\2\u0523\u051f"+
		"\3\2\2\2\u0523\u0520\3\2\2\2\u0523\u0521\3\2\2\2\u0524\u0528\3\2\2\2\u0525"+
		"\u0526\7i\2\2\u0526\u0528\5\u009aN\2\u0527\u0519\3\2\2\2\u0527\u0525\3"+
		"\2\2\2\u0528\u052a\3\2\2\2\u0529\u0527\3\2\2\2\u052a\u052d\3\2\2\2\u052b"+
		"\u0529\3\2\2\2\u052b\u052c\3\2\2\2\u052c\u0538\3\2\2\2\u052d\u052b\3\2"+
		"\2\2\u052e\u0530\7l\2\2\u052f\u052e\3\2\2\2\u052f\u0530\3\2\2\2\u0530"+
		"\u0531\3\2\2\2\u0531\u0536\7?\2\2\u0532\u0533\7\\\2\2\u0533\u0537\7@\2"+
		"\2\u0534\u0535\7\\\2\2\u0535\u0537\7X\2\2\u0536\u0532\3\2\2\2\u0536\u0534"+
		"\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2\2\2\u0538\u052f\3\2\2\2\u0538"+
		"\u0539\3\2\2\2\u0539c\3\2\2\2\u053a\u053b\7y\2\2\u053b\u0540\7\t\2\2\u053c"+
		"\u0541\7W\2\2\u053d\u053e\t\16\2\2\u053e\u053f\7\13\2\2\u053f\u0541\5"+
		"\u0092J\2\u0540\u053c\3\2\2\2\u0540\u053d\3\2\2\2\u0541\u0542\3\2\2\2"+
		"\u0542\u0543\7\n\2\2\u0543e\3\2\2\2\u0544\u0547\5\u00aaV\2\u0545\u0546"+
		"\7\63\2\2\u0546\u0548\5\u00aeX\2\u0547\u0545\3\2\2\2\u0547\u0548\3\2\2"+
		"\2\u0548\u054a\3\2\2\2\u0549\u054b\t\7\2\2\u054a\u0549\3\2\2\2\u054a\u054b"+
		"\3\2\2\2\u054bg\3\2\2\2\u054c\u054d\7\67\2\2\u054d\u054f\5\u009aN\2\u054e"+
		"\u054c\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0574\3\2\2\2\u0550\u0551\7w"+
		"\2\2\u0551\u0554\7e\2\2\u0552\u0554\7\u0090\2\2\u0553\u0550\3\2\2\2\u0553"+
		"\u0552\3\2\2\2\u0554\u0555\3\2\2\2\u0555\u0556\7\t\2\2\u0556\u055b\5f"+
		"\64\2\u0557\u0558\7\13\2\2\u0558\u055a\5f\64\2\u0559\u0557\3\2\2\2\u055a"+
		"\u055d\3\2\2\2\u055b\u0559\3\2\2\2\u055b\u055c\3\2\2\2\u055c\u055e\3\2"+
		"\2\2\u055d\u055b\3\2\2\2\u055e\u055f\7\n\2\2\u055f\u0560\5X-\2\u0560\u0575"+
		"\3\2\2\2\u0561\u0562\7\62\2\2\u0562\u0563\7\t\2\2\u0563\u0564\5Z.\2\u0564"+
		"\u0565\7\n\2\2\u0565\u0575\3\2\2\2\u0566\u0567\7P\2\2\u0567\u0568\7e\2"+
		"\2\u0568\u0569\7\t\2\2\u0569\u056e\5\u00aaV\2\u056a\u056b\7\13\2\2\u056b"+
		"\u056d\5\u00aaV\2\u056c\u056a\3\2\2\2\u056d\u0570\3\2\2\2\u056e\u056c"+
		"\3\2\2\2\u056e\u056f\3\2\2\2\u056f\u0571\3\2\2\2\u0570\u056e\3\2\2\2\u0571"+
		"\u0572\7\n\2\2\u0572\u0573\5b\62\2\u0573\u0575\3\2\2\2\u0574\u0553\3\2"+
		"\2\2\u0574\u0561\3\2\2\2\u0574\u0566\3\2\2\2\u0575i\3\2\2\2\u0576\u0578"+
		"\7\u0099\2\2\u0577\u0579\7z\2\2\u0578\u0577\3\2\2\2\u0578\u0579\3\2\2"+
		"\2\u0579\u057a\3\2\2\2\u057a\u057b\5\u008aF\2\u057b\u057c\7\'\2\2\u057c"+
		"\u057d\7\t\2\2\u057d\u057e\5F$\2\u057e\u0588\7\n\2\2\u057f\u0580\7\13"+
		"\2\2\u0580\u0581\5\u008aF\2\u0581\u0582\7\'\2\2\u0582\u0583\7\t\2\2\u0583"+
		"\u0584\5F$\2\u0584\u0585\7\n\2\2\u0585\u0587\3\2\2\2\u0586\u057f\3\2\2"+
		"\2\u0587\u058a\3\2\2\2\u0588\u0586\3\2\2\2\u0588\u0589\3\2\2\2\u0589k"+
		"\3\2\2\2\u058a\u0588\3\2\2\2\u058b\u058c\7\u0098\2\2\u058c\u058d\5n8\2"+
		"\u058dm\3\2\2\2\u058e\u058f\5Z.\2\u058fo\3\2\2\2\u0590\u0591\5\u00a2R"+
		"\2\u0591\u0592\7\b\2\2\u0592\u0594\3\2\2\2\u0593\u0590\3\2\2\2\u0593\u0594"+
		"\3\2\2\2\u0594\u0595\3\2\2\2\u0595\u059b\5\u00a4S\2\u0596\u0597\7[\2\2"+
		"\u0597\u0598\7.\2\2\u0598\u059c\5\u00b2Z\2\u0599\u059a\7l\2\2\u059a\u059c"+
		"\7[\2\2\u059b\u0596\3\2\2\2\u059b\u0599\3\2\2\2\u059b\u059c\3\2\2\2\u059c"+
		"q\3\2\2\2\u059d\u059e\t\17\2\2\u059e\u059f\5Z.\2\u059fs\3\2\2\2\u05a0"+
		"\u05a1\7s\2\2\u05a1\u05a2\7.\2\2\u05a2\u05a7\5v<\2\u05a3\u05a4\7\13\2"+
		"\2\u05a4\u05a6\5v<\2\u05a5\u05a3\3\2\2\2\u05a6\u05a9\3\2\2\2\u05a7\u05a5"+
		"\3\2\2\2\u05a7\u05a8\3\2\2\2\u05a8u\3\2\2\2\u05a9\u05a7\3\2\2\2\u05aa"+
		"\u05ad\5Z.\2\u05ab\u05ac\7\63\2\2\u05ac\u05ae\5\u00aeX\2\u05ad\u05ab\3"+
		"\2\2\2\u05ad\u05ae\3\2\2\2\u05ae\u05b0\3\2\2\2\u05af\u05b1\t\7\2\2\u05b0"+
		"\u05af\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1w\3\2\2\2\u05b2\u05b6\5\u008c"+
		"G\2\u05b3\u05b6\5\u009aN\2\u05b4\u05b6\7\u009e\2\2\u05b5\u05b2\3\2\2\2"+
		"\u05b5\u05b3\3\2\2\2\u05b5\u05b4\3\2\2\2\u05b6y\3\2\2\2\u05b7\u05c3\5"+
		"\u00a4S\2\u05b8\u05b9\7\t\2\2\u05b9\u05be\5\u00aaV\2\u05ba\u05bb\7\13"+
		"\2\2\u05bb\u05bd\5\u00aaV\2\u05bc\u05ba\3\2\2\2\u05bd\u05c0\3\2\2\2\u05be"+
		"\u05bc\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u05c1\3\2\2\2\u05c0\u05be\3\2"+
		"\2\2\u05c1\u05c2\7\n\2\2\u05c2\u05c4\3\2\2\2\u05c3\u05b8\3\2\2\2\u05c3"+
		"\u05c4\3\2\2\2\u05c4\u05c5\3\2\2\2\u05c5\u05c6\7\'\2\2\u05c6\u05c7\7\t"+
		"\2\2\u05c7\u05c8\5F$\2\u05c8\u05c9\7\n\2\2\u05c9{\3\2\2\2\u05ca\u05d7"+
		"\7\r\2\2\u05cb\u05cc\5\u00a4S\2\u05cc\u05cd\7\b\2\2\u05cd\u05ce\7\r\2"+
		"\2\u05ce\u05d7\3\2\2\2\u05cf\u05d4\5Z.\2\u05d0\u05d2\7\'\2\2\u05d1\u05d0"+
		"\3\2\2\2\u05d1\u05d2\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3\u05d5\5\u0096L"+
		"\2\u05d4\u05d1\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d7\3\2\2\2\u05d6\u05ca"+
		"\3\2\2\2\u05d6\u05cb\3\2\2\2\u05d6\u05cf\3\2\2\2\u05d7}\3\2\2\2\u05d8"+
		"\u05d9\5\u00a2R\2\u05d9\u05da\7\b\2\2\u05da\u05dc\3\2\2\2\u05db\u05d8"+
		"\3\2\2\2\u05db\u05dc\3\2\2\2\u05dc\u05dd\3\2\2\2\u05dd\u05e2\5\u00a4S"+
		"\2\u05de\u05e0\7\'\2\2\u05df\u05de\3\2\2\2\u05df\u05e0\3\2\2\2\u05e0\u05e1"+
		"\3\2\2\2\u05e1\u05e3\5\u00c0a\2\u05e2\u05df\3\2\2\2\u05e2\u05e3\3\2\2"+
		"\2\u05e3\u05e9\3\2\2\2\u05e4\u05e5\7[\2\2\u05e5\u05e6\7.\2\2\u05e6\u05ea"+
		"\5\u00b2Z\2\u05e7\u05e8\7l\2\2\u05e8\u05ea\7[\2\2\u05e9\u05e4\3\2\2\2"+
		"\u05e9\u05e7\3\2\2\2\u05e9\u05ea\3\2\2\2\u05ea\u0608\3\2\2\2\u05eb\u05f5"+
		"\7\t\2\2\u05ec\u05f1\5~@\2\u05ed\u05ee\7\13\2\2\u05ee\u05f0\5~@\2\u05ef"+
		"\u05ed\3\2\2\2\u05f0\u05f3\3\2\2\2\u05f1\u05ef\3\2\2\2\u05f1\u05f2\3\2"+
		"\2\2\u05f2\u05f6\3\2\2\2\u05f3\u05f1\3\2\2\2\u05f4\u05f6\5\u0080A\2\u05f5"+
		"\u05ec\3\2\2\2\u05f5\u05f4\3\2\2\2\u05f6\u05f7\3\2\2\2\u05f7\u05fc\7\n"+
		"\2\2\u05f8\u05fa\7\'\2\2\u05f9\u05f8\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa"+
		"\u05fb\3\2\2\2\u05fb\u05fd\5\u00c0a\2\u05fc\u05f9\3\2\2\2\u05fc\u05fd"+
		"\3\2\2\2\u05fd\u0608\3\2\2\2\u05fe\u05ff\7\t\2\2\u05ff\u0600\5F$\2\u0600"+
		"\u0605\7\n\2\2\u0601\u0603\7\'\2\2\u0602\u0601\3\2\2\2\u0602\u0603\3\2"+
		"\2\2\u0603\u0604\3\2\2\2\u0604\u0606\5\u00c0a\2\u0605\u0602\3\2\2\2\u0605"+
		"\u0606\3\2\2\2\u0606\u0608\3\2\2\2\u0607\u05db\3\2\2\2\u0607\u05eb\3\2"+
		"\2\2\u0607\u05fe\3\2\2\2\u0608\177\3\2\2\2\u0609\u0610\5~@\2\u060a\u060b"+
		"\5\u0082B\2\u060b\u060c\5~@\2\u060c\u060d\5\u0084C\2\u060d\u060f\3\2\2"+
		"\2\u060e\u060a\3\2\2\2\u060f\u0612\3\2\2\2\u0610\u060e\3\2\2\2\u0610\u0611"+
		"\3\2\2\2\u0611\u0081\3\2\2\2\u0612\u0610\3\2\2\2\u0613\u0621\7\13\2\2"+
		"\u0614\u0616\7j\2\2\u0615\u0614\3\2\2\2\u0615\u0616\3\2\2\2\u0616\u061d"+
		"\3\2\2\2\u0617\u0619\7f\2\2\u0618\u061a\7t\2\2\u0619\u0618\3\2\2\2\u0619"+
		"\u061a\3\2\2\2\u061a\u061e\3\2\2\2\u061b\u061e\7]\2\2\u061c\u061e\79\2"+
		"\2\u061d\u0617\3\2\2\2\u061d\u061b\3\2\2\2\u061d\u061c\3\2\2\2\u061d\u061e"+
		"\3\2\2\2\u061e\u061f\3\2\2\2\u061f\u0621\7d\2\2\u0620\u0613\3\2\2\2\u0620"+
		"\u0615\3\2\2\2\u0621\u0083\3\2\2\2\u0622\u0623\7q\2\2\u0623\u0631\5Z."+
		"\2\u0624\u0625\7\u0092\2\2\u0625\u0626\7\t\2\2\u0626\u062b\5\u00aaV\2"+
		"\u0627\u0628\7\13\2\2\u0628\u062a\5\u00aaV\2\u0629\u0627\3\2\2\2\u062a"+
		"\u062d\3\2\2\2\u062b\u0629\3\2\2\2\u062b\u062c\3\2\2\2\u062c\u062e\3\2"+
		"\2\2\u062d\u062b\3\2\2\2\u062e\u062f\7\n\2\2\u062f\u0631\3\2\2\2\u0630"+
		"\u0622\3\2\2\2\u0630\u0624\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0085\3\2"+
		"\2\2\u0632\u0634\7\u0086\2\2\u0633\u0635\t\5\2\2\u0634\u0633\3\2\2\2\u0634"+
		"\u0635\3\2\2\2\u0635\u0636\3\2\2\2\u0636\u0643\5\u00bc_\2\u0637\u0641"+
		"\7Q\2\2\u0638\u063d\5~@\2\u0639\u063a\7\13\2\2\u063a\u063c\5~@\2\u063b"+
		"\u0639\3\2\2\2\u063c\u063f\3\2\2\2\u063d\u063b\3\2\2\2\u063d\u063e\3\2"+
		"\2\2\u063e\u0642\3\2\2\2\u063f\u063d\3\2\2\2\u0640\u0642\5\u0080A\2\u0641"+
		"\u0638\3\2\2\2\u0641\u0640\3\2\2\2\u0642\u0644\3\2\2\2\u0643\u0637\3\2"+
		"\2\2\u0643\u0644\3\2\2\2\u0644\u0646\3\2\2\2\u0645\u0647\5l\67\2\u0646"+
		"\u0645\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u064c\3\2\2\2\u0648\u064a\5\u009e"+
		"P\2\u0649\u064b\5\u00a0Q\2\u064a\u0649\3\2\2\2\u064a\u064b\3\2\2\2\u064b"+
		"\u064d\3\2\2\2\u064c\u0648\3\2\2\2\u064c\u064d\3\2\2\2\u064d\u066b\3\2"+
		"\2\2\u064e\u064f\7\u0094\2\2\u064f\u0650\7\t\2\2\u0650\u0655\5Z.\2\u0651"+
		"\u0652\7\13\2\2\u0652\u0654\5Z.\2\u0653\u0651\3\2\2\2\u0654\u0657\3\2"+
		"\2\2\u0655\u0653\3\2\2\2\u0655\u0656\3\2\2\2\u0656\u0658\3\2\2\2\u0657"+
		"\u0655\3\2\2\2\u0658\u0667\7\n\2\2\u0659\u065a\7\13\2\2\u065a\u065b\7"+
		"\t\2\2\u065b\u0660\5Z.\2\u065c\u065d\7\13\2\2\u065d\u065f\5Z.\2\u065e"+
		"\u065c\3\2\2\2\u065f\u0662\3\2\2\2\u0660\u065e\3\2\2\2\u0660\u0661\3\2"+
		"\2\2\u0661\u0663\3\2\2\2\u0662\u0660\3\2\2\2\u0663\u0664\7\n\2\2\u0664"+
		"\u0666\3\2\2\2\u0665\u0659\3\2\2\2\u0666\u0669\3\2\2\2\u0667\u0665\3\2"+
		"\2\2\u0667\u0668\3\2\2\2\u0668\u066b\3\2\2\2\u0669\u0667\3\2\2\2\u066a"+
		"\u0632\3\2\2\2\u066a\u064e\3\2\2\2\u066b\u0087\3\2\2\2\u066c\u0672\7\u008f"+
		"\2\2\u066d\u066e\7\u008f\2\2\u066e\u0672\7#\2\2\u066f\u0672\7`\2\2\u0670"+
		"\u0672\7J\2\2\u0671\u066c\3\2\2\2\u0671\u066d\3\2\2\2\u0671\u066f\3\2"+
		"\2\2\u0671\u0670\3\2\2\2\u0672\u0089\3\2\2\2\u0673\u067f\5\u00a4S\2\u0674"+
		"\u0675\7\t\2\2\u0675\u067a\5\u00aaV\2\u0676\u0677\7\13\2\2\u0677\u0679"+
		"\5\u00aaV\2\u0678\u0676\3\2\2\2\u0679\u067c\3\2\2\2\u067a\u0678\3\2\2"+
		"\2\u067a\u067b\3\2\2\2\u067b\u067d\3\2\2\2\u067c\u067a\3\2\2\2\u067d\u067e"+
		"\7\n\2\2\u067e\u0680\3\2\2\2\u067f\u0674\3\2\2\2\u067f\u0680\3\2\2\2\u0680"+
		"\u008b\3\2\2\2\u0681\u0683\t\t\2\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2"+
		"\2\2\u0683\u0684\3\2\2\2\u0684\u0685\7\u009c\2\2\u0685\u008d\3\2\2\2\u0686"+
		"\u0687\t\20\2\2\u0687\u008f\3\2\2\2\u0688\u0689\t\21\2\2\u0689\u0091\3"+
		"\2\2\2\u068a\u068b\7\u009e\2\2\u068b\u0093\3\2\2\2\u068c\u068f\5Z.\2\u068d"+
		"\u068f\5R*\2\u068e\u068c\3\2\2\2\u068e\u068d\3\2\2\2\u068f\u0095\3\2\2"+
		"\2\u0690\u0691\t\22\2\2\u0691\u0097\3\2\2\2\u0692\u0693\t\23\2\2\u0693"+
		"\u0099\3\2\2\2\u0694\u0695\5\u00c4c\2\u0695\u009b\3\2\2\2\u0696\u0697"+
		"\5\u00c4c\2\u0697\u009d\3\2\2\2\u0698\u0699\7T\2\2\u0699\u069a\7.\2\2"+
		"\u069a\u069f\5Z.\2\u069b\u069c\7\13\2\2\u069c\u069e\5Z.\2\u069d\u069b"+
		"\3\2\2\2\u069e\u06a1\3\2\2\2\u069f\u069d\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0"+
		"\u009f\3\2\2\2\u06a1\u069f\3\2\2\2\u06a2\u06a3\7U\2\2\u06a3\u06a4\5Z."+
		"\2\u06a4\u00a1\3\2\2\2\u06a5\u06a6\5\u00c4c\2\u06a6\u00a3\3\2\2\2\u06a7"+
		"\u06a8\5\u00c4c\2\u06a8\u00a5\3\2\2\2\u06a9\u06aa\5\u00c4c\2\u06aa\u00a7"+
		"\3\2\2\2\u06ab\u06ac\5\u00c4c\2\u06ac\u00a9\3\2\2\2\u06ad\u06ae\5\u00c4"+
		"c\2\u06ae\u00ab\3\2\2\2\u06af\u06b0\5\u00c4c\2\u06b0\u00ad\3\2\2\2\u06b1"+
		"\u06b2\5\u00c4c\2\u06b2\u00af\3\2\2\2\u06b3\u06b4\5\u00c4c\2\u06b4\u00b1"+
		"\3\2\2\2\u06b5\u06b6\5\u00c4c\2\u06b6\u00b3\3\2\2\2\u06b7\u06b8\5\u00c4"+
		"c\2\u06b8\u00b5\3\2\2\2\u06b9\u06ba\5\u00c4c\2\u06ba\u00b7\3\2\2\2\u06bb"+
		"\u06bc\5\u00c4c\2\u06bc\u00b9\3\2\2\2\u06bd\u06be\5\u00c4c\2\u06be\u00bb"+
		"\3\2\2\2\u06bf\u06c4\5|?\2\u06c0\u06c1\7\13\2\2\u06c1\u06c3\5|?\2\u06c2"+
		"\u06c0\3\2\2\2\u06c3\u06c6\3\2\2\2\u06c4\u06c2\3\2\2\2\u06c4\u06c5\3\2"+
		"\2\2\u06c5\u00bd\3\2\2\2\u06c6\u06c4\3\2\2\2\u06c7\u06c8\5\u00c4c\2\u06c8"+
		"\u00bf\3\2\2\2\u06c9\u06ca\5\u00c4c\2\u06ca\u00c1\3\2\2\2\u06cb\u06cc"+
		"\5\u00c4c\2\u06cc\u00c3\3\2\2\2\u06cd\u06d5\7\u009b\2\2\u06ce\u06d5\5"+
		"\u0098M\2\u06cf\u06d5\7\u009e\2\2\u06d0\u06d1\7\t\2\2\u06d1\u06d2\5\u00c4"+
		"c\2\u06d2\u06d3\7\n\2\2\u06d3\u06d5\3\2\2\2\u06d4\u06cd\3\2\2\2\u06d4"+
		"\u06ce\3\2\2\2\u06d4\u06cf\3\2\2\2\u06d4\u06d0\3\2\2\2\u06d5\u00c5\3\2"+
		"\2\2\u00f8\u00c8\u00ca\u00d5\u00dd\u00e4\u00e9\u00ef\u00f5\u00f7\u0117"+
		"\u011e\u0126\u0129\u0132\u0136\u013e\u0142\u0144\u0149\u014b\u014f\u0156"+
		"\u0159\u015e\u0162\u0167\u016a\u016e\u0170\u0174\u017a\u017f\u018a\u018f"+
		"\u0193\u0199\u019e\u01a7\u01ae\u01b4\u01b8\u01bc\u01c2\u01c7\u01ce\u01d9"+
		"\u01dc\u01de\u01e4\u01ea\u01ee\u01f5\u01fb\u0201\u0207\u020c\u0218\u021d"+
		"\u0228\u022d\u0230\u0236\u0239\u023f\u0242\u0246\u0248\u024c\u0254\u0259"+
		"\u0261\u0266\u026e\u0273\u027b\u0280\u0286\u028d\u0290\u0298\u029c\u02a0"+
		"\u02a2\u02a5\u02ac\u02b2\u02b9\u02c6\u02cd\u02d3\u02da\u02e2\u02ec\u02f5"+
		"\u02fc\u0300\u0302\u0306\u030d\u030f\u0313\u0316\u031d\u0324\u0327\u032b"+
		"\u032f\u0331\u0335\u033c\u033f\u0347\u034b\u034f\u0351\u0355\u035e\u0362"+
		"\u0364\u0367\u036b\u036d\u0376\u0381\u0388\u038b\u038e\u0393\u03a1\u03a5"+
		"\u03aa\u03b7\u03c5\u03c9\u03cc\u03d0\u03d2\u03d8\u03dd\u03e3\u03ef\u03f3"+
		"\u03f8\u03fc\u03ff\u0411\u0416\u041b\u0424\u0429\u0432\u0439\u043d\u044d"+
		"\u0450\u0458\u0461\u0465\u046a\u0488\u0494\u0499\u04a5\u04ab\u04b2\u04b6"+
		"\u04c0\u04c3\u04c9\u04cc\u04ce\u04d0\u04d8\u04df\u04e6\u04eb\u04ef\u04f7"+
		"\u04fe\u0505\u0512\u0517\u0523\u0527\u052b\u052f\u0536\u0538\u0540\u0547"+
		"\u054a\u054e\u0553\u055b\u056e\u0574\u0578\u0588\u0593\u059b\u05a7\u05ad"+
		"\u05b0\u05b5\u05be\u05c3\u05d1\u05d4\u05d6\u05db\u05df\u05e2\u05e9\u05f1"+
		"\u05f5\u05f9\u05fc\u0602\u0605\u0607\u0610\u0615\u0619\u061d\u0620\u062b"+
		"\u0630\u0634\u063d\u0641\u0643\u0646\u064a\u064c\u0655\u0660\u0667\u066a"+
		"\u0671\u067a\u067f\u0682\u068e\u069f\u06c4\u06d4";
	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);
		}
	}
}