• Home
• com.squareup.sqldelight
• compiler
• 0.4.2
• source code
• SqliteParser.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.squareup.sqldelight.SqliteParser Maven / Gradle / Ivy

// Generated from com/squareup/sqldelight/Sqlite.g4 by ANTLR 4.5

    package com.squareup.sqldelight;

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

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

	private static final String[] _LITERAL_NAMES = {
		null, "':'", null, null, null, null, null, null, null, null, null, null, 
		null, "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", "'~'", 
		"'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", 
		"'>='", "'=='", "'!='", "'<>'", "'''"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, null, "K_JAVA_BOOLEAN", "K_JAVA_INTEGER", "K_JAVA_LONG", "K_JAVA_FLOAT", 
		"K_JAVA_DOUBLE", "K_JAVA_STRING", "K_JAVA_BYTE_ARRAY", "K_INTEGER", "K_REAL", 
		"K_TEXT", "K_BLOB", "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", 
		"QUOTE", "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_KEY", "K_FROM", "K_FULL", "K_GLOB", "K_GROUP", "K_HAVING", 
		"K_IF", "K_IGNORE", "K_IMMEDIATE", "K_IMPORT", "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_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_KEY", 
		"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_WHEN", "K_WHERE", 
		"K_WITH", "K_WITHOUT", "IDENTIFIER", "INTEGER_LITERAL", "REAL_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 "Sqlite.g4"; }

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

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

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

	public SqliteParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ParseContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(SqliteParser.EOF, 0); }
		public Sql_stmt_listContext sql_stmt_list() {
			return getRuleContext(Sql_stmt_listContext.class,0);
		}
		public ErrorContext error() {
			return getRuleContext(ErrorContext.class,0);
		}
		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 SqliteListener ) ((SqliteListener)listener).enterParse(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitParse(this);
		}
	}

	public final ParseContext parse() throws RecognitionException {
		ParseContext _localctx = new ParseContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_parse);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(156);
			switch (_input.LA(1)) {
			case EOF:
			case K_CREATE:
			case K_IMPORT:
			case IDENTIFIER:
				{
				setState(154);
				sql_stmt_list();
				}
				break;
			case UNEXPECTED_CHAR:
				{
				setState(155);
				error();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(158);
			match(EOF);
			}
		}
		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 TerminalNode UNEXPECTED_CHAR() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterError(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitError(this);
		}
	}

	public final ErrorContext error() throws RecognitionException {
		ErrorContext _localctx = new ErrorContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_error);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(160);
			match(UNEXPECTED_CHAR);
			}
		}
		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 import_stmt() {
			return getRuleContexts(Import_stmtContext.class);
		}
		public Import_stmtContext import_stmt(int i) {
			return getRuleContext(Import_stmtContext.class,i);
		}
		public Create_table_stmtContext create_table_stmt() {
			return getRuleContext(Create_table_stmtContext.class,0);
		}
		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 SqliteListener ) ((SqliteListener)listener).enterSql_stmt_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 4, RULE_sql_stmt_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(165);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_IMPORT) {
				{
				{
				setState(162);
				import_stmt();
				}
				}
				setState(167);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(171);
			_la = _input.LA(1);
			if (_la==K_CREATE) {
				{
				setState(168);
				create_table_stmt();
				setState(169);
				match(SCOL);
				}
			}

			setState(178);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==IDENTIFIER) {
				{
				{
				setState(173);
				sql_stmt();
				setState(174);
				match(SCOL);
				}
				}
				setState(180);
				_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 Import_stmtContext extends ParserRuleContext {
		public TerminalNode K_IMPORT() { return getToken(SqliteParser.K_IMPORT, 0); }
		public Java_type_nameContext java_type_name() {
			return getRuleContext(Java_type_nameContext.class,0);
		}
		public Import_stmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_import_stmt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterImport_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitImport_stmt(this);
		}
	}

	public final Import_stmtContext import_stmt() throws RecognitionException {
		Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_import_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(181);
			match(K_IMPORT);
			setState(182);
			java_type_name();
			setState(183);
			match(SCOL);
			}
		}
		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 Sql_stmt_nameContext sql_stmt_name() {
			return getRuleContext(Sql_stmt_nameContext.class,0);
		}
		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 Create_index_stmtContext create_index_stmt() {
			return getRuleContext(Create_index_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 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 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 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 Savepoint_stmtContext savepoint_stmt() {
			return getRuleContext(Savepoint_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(SqliteParser.K_EXPLAIN, 0); }
		public TerminalNode K_QUERY() { return getToken(SqliteParser.K_QUERY, 0); }
		public TerminalNode K_PLAN() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterSql_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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(185);
			sql_stmt_name();
			setState(186);
			match(T__0);
			setState(192);
			_la = _input.LA(1);
			if (_la==K_EXPLAIN) {
				{
				setState(187);
				match(K_EXPLAIN);
				setState(190);
				_la = _input.LA(1);
				if (_la==K_QUERY) {
					{
					setState(188);
					match(K_QUERY);
					setState(189);
					match(K_PLAN);
					}
				}

				}
			}

			setState(214);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				{
				setState(194);
				alter_table_stmt();
				}
				break;
			case 2:
				{
				setState(195);
				analyze_stmt();
				}
				break;
			case 3:
				{
				setState(196);
				create_index_stmt();
				}
				break;
			case 4:
				{
				setState(197);
				create_trigger_stmt();
				}
				break;
			case 5:
				{
				setState(198);
				create_view_stmt();
				}
				break;
			case 6:
				{
				setState(199);
				delete_stmt();
				}
				break;
			case 7:
				{
				setState(200);
				delete_stmt_limited();
				}
				break;
			case 8:
				{
				setState(201);
				drop_index_stmt();
				}
				break;
			case 9:
				{
				setState(202);
				drop_table_stmt();
				}
				break;
			case 10:
				{
				setState(203);
				drop_trigger_stmt();
				}
				break;
			case 11:
				{
				setState(204);
				drop_view_stmt();
				}
				break;
			case 12:
				{
				setState(205);
				insert_stmt();
				}
				break;
			case 13:
				{
				setState(206);
				pragma_stmt();
				}
				break;
			case 14:
				{
				setState(207);
				reindex_stmt();
				}
				break;
			case 15:
				{
				setState(208);
				release_stmt();
				}
				break;
			case 16:
				{
				setState(209);
				savepoint_stmt();
				}
				break;
			case 17:
				{
				setState(210);
				select_stmt();
				}
				break;
			case 18:
				{
				setState(211);
				update_stmt();
				}
				break;
			case 19:
				{
				setState(212);
				update_stmt_limited();
				}
				break;
			case 20:
				{
				setState(213);
				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(SqliteParser.K_ALTER, 0); }
		public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_RENAME() { return getToken(SqliteParser.K_RENAME, 0); }
		public TerminalNode K_TO() { return getToken(SqliteParser.K_TO, 0); }
		public New_table_nameContext new_table_name() {
			return getRuleContext(New_table_nameContext.class,0);
		}
		public TerminalNode K_ADD() { return getToken(SqliteParser.K_ADD, 0); }
		public Column_defContext column_def() {
			return getRuleContext(Column_defContext.class,0);
		}
		public TerminalNode K_COLUMN() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterAlter_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(216);
			match(K_ALTER);
			setState(217);
			match(K_TABLE);
			setState(218);
			table_name();
			setState(227);
			switch (_input.LA(1)) {
			case K_RENAME:
				{
				setState(219);
				match(K_RENAME);
				setState(220);
				match(K_TO);
				setState(221);
				new_table_name();
				}
				break;
			case K_ADD:
				{
				setState(222);
				match(K_ADD);
				setState(224);
				_la = _input.LA(1);
				if (_la==K_COLUMN) {
					{
					setState(223);
					match(K_COLUMN);
					}
				}

				setState(226);
				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(SqliteParser.K_ANALYZE, 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 SqliteListener ) ((SqliteListener)listener).enterAnalyze_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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(229);
			match(K_ANALYZE);
			setState(230);
			table_or_index_name();
			}
		}
		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(SqliteParser.K_CREATE, 0); }
		public TerminalNode K_INDEX() { return getToken(SqliteParser.K_INDEX, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_ON() { return getToken(SqliteParser.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(SqliteParser.K_UNIQUE, 0); }
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
		public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.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 SqliteListener ) ((SqliteListener)listener).enterCreate_index_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 14, RULE_create_index_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(232);
			match(K_CREATE);
			setState(234);
			_la = _input.LA(1);
			if (_la==K_UNIQUE) {
				{
				setState(233);
				match(K_UNIQUE);
				}
			}

			setState(236);
			match(K_INDEX);
			setState(240);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(237);
				match(K_IF);
				setState(238);
				match(K_NOT);
				setState(239);
				match(K_EXISTS);
				}
			}

			setState(242);
			index_name();
			setState(243);
			match(K_ON);
			setState(244);
			table_name();
			setState(245);
			match(OPEN_PAR);
			setState(246);
			indexed_column();
			setState(251);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(247);
				match(COMMA);
				setState(248);
				indexed_column();
				}
				}
				setState(253);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(254);
			match(CLOSE_PAR);
			setState(257);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(255);
				match(K_WHERE);
				setState(256);
				expr(0);
				}
			}

			}
		}
		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(SqliteParser.K_CREATE, 0); }
		public TerminalNode K_TABLE() { return getToken(SqliteParser.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(SqliteParser.K_AS, 0); }
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
		public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.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(SqliteParser.K_WITHOUT, 0); }
		public TerminalNode IDENTIFIER() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterCreate_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 16, RULE_create_table_stmt);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(259);
			match(K_CREATE);
			setState(261);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(260);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			setState(263);
			match(K_TABLE);
			setState(267);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(264);
				match(K_IF);
				setState(265);
				match(K_NOT);
				setState(266);
				match(K_EXISTS);
				}
			}

			setState(269);
			table_name();
			setState(293);
			switch (_input.LA(1)) {
			case OPEN_PAR:
				{
				setState(270);
				match(OPEN_PAR);
				setState(271);
				column_def();
				setState(276);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(272);
						match(COMMA);
						setState(273);
						column_def();
						}
						} 
					}
					setState(278);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
				}
				setState(283);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(279);
					match(COMMA);
					setState(280);
					table_constraint();
					}
					}
					setState(285);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(286);
				match(CLOSE_PAR);
				setState(289);
				_la = _input.LA(1);
				if (_la==K_WITHOUT) {
					{
					setState(287);
					match(K_WITHOUT);
					setState(288);
					match(IDENTIFIER);
					}
				}

				}
				break;
			case K_AS:
				{
				setState(291);
				match(K_AS);
				setState(292);
				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(SqliteParser.K_CREATE, 0); }
		public TerminalNode K_TRIGGER() { return getToken(SqliteParser.K_TRIGGER, 0); }
		public Trigger_nameContext trigger_name() {
			return getRuleContext(Trigger_nameContext.class,0);
		}
		public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_BEGIN() { return getToken(SqliteParser.K_BEGIN, 0); }
		public TerminalNode K_END() { return getToken(SqliteParser.K_END, 0); }
		public TerminalNode K_DELETE() { return getToken(SqliteParser.K_DELETE, 0); }
		public TerminalNode K_INSERT() { return getToken(SqliteParser.K_INSERT, 0); }
		public TerminalNode K_UPDATE() { return getToken(SqliteParser.K_UPDATE, 0); }
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
		public TerminalNode K_BEFORE() { return getToken(SqliteParser.K_BEFORE, 0); }
		public TerminalNode K_AFTER() { return getToken(SqliteParser.K_AFTER, 0); }
		public TerminalNode K_INSTEAD() { return getToken(SqliteParser.K_INSTEAD, 0); }
		public List K_OF() { return getTokens(SqliteParser.K_OF); }
		public TerminalNode K_OF(int i) {
			return getToken(SqliteParser.K_OF, i);
		}
		public TerminalNode K_FOR() { return getToken(SqliteParser.K_FOR, 0); }
		public TerminalNode K_EACH() { return getToken(SqliteParser.K_EACH, 0); }
		public TerminalNode K_ROW() { return getToken(SqliteParser.K_ROW, 0); }
		public TerminalNode K_WHEN() { return getToken(SqliteParser.K_WHEN, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterCreate_trigger_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 18, RULE_create_trigger_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(295);
			match(K_CREATE);
			setState(297);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(296);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			setState(299);
			match(K_TRIGGER);
			setState(303);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(300);
				match(K_IF);
				setState(301);
				match(K_NOT);
				setState(302);
				match(K_EXISTS);
				}
			}

			setState(305);
			trigger_name();
			setState(310);
			switch (_input.LA(1)) {
			case K_BEFORE:
				{
				setState(306);
				match(K_BEFORE);
				}
				break;
			case K_AFTER:
				{
				setState(307);
				match(K_AFTER);
				}
				break;
			case K_INSTEAD:
				{
				setState(308);
				match(K_INSTEAD);
				setState(309);
				match(K_OF);
				}
				break;
			case K_DELETE:
			case K_INSERT:
			case K_UPDATE:
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(326);
			switch (_input.LA(1)) {
			case K_DELETE:
				{
				setState(312);
				match(K_DELETE);
				}
				break;
			case K_INSERT:
				{
				setState(313);
				match(K_INSERT);
				}
				break;
			case K_UPDATE:
				{
				setState(314);
				match(K_UPDATE);
				setState(324);
				_la = _input.LA(1);
				if (_la==K_OF) {
					{
					setState(315);
					match(K_OF);
					setState(316);
					column_name();
					setState(321);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(317);
						match(COMMA);
						setState(318);
						column_name();
						}
						}
						setState(323);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(328);
			match(K_ON);
			setState(329);
			table_name();
			setState(333);
			_la = _input.LA(1);
			if (_la==K_FOR) {
				{
				setState(330);
				match(K_FOR);
				setState(331);
				match(K_EACH);
				setState(332);
				match(K_ROW);
				}
			}

			setState(337);
			_la = _input.LA(1);
			if (_la==K_WHEN) {
				{
				setState(335);
				match(K_WHEN);
				setState(336);
				expr(0);
				}
			}

			setState(339);
			match(K_BEGIN);
			setState(348); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(344);
				switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
				case 1:
					{
					setState(340);
					update_stmt();
					}
					break;
				case 2:
					{
					setState(341);
					insert_stmt();
					}
					break;
				case 3:
					{
					setState(342);
					delete_stmt();
					}
					break;
				case 4:
					{
					setState(343);
					select_stmt();
					}
					break;
				}
				setState(346);
				match(SCOL);
				}
				}
				setState(350); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (K_DELETE - 72)) | (1L << (K_INSERT - 72)) | (1L << (K_REPLACE - 72)))) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & ((1L << (K_SELECT - 141)) | (1L << (K_UPDATE - 141)) | (1L << (K_VALUES - 141)) | (1L << (K_WITH - 141)))) != 0) );
			setState(352);
			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(SqliteParser.K_CREATE, 0); }
		public TerminalNode K_VIEW() { return getToken(SqliteParser.K_VIEW, 0); }
		public View_nameContext view_name() {
			return getRuleContext(View_nameContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
		public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
		public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterCreate_view_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 20, RULE_create_view_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(354);
			match(K_CREATE);
			setState(356);
			_la = _input.LA(1);
			if (_la==K_TEMP || _la==K_TEMPORARY) {
				{
				setState(355);
				_la = _input.LA(1);
				if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			setState(358);
			match(K_VIEW);
			setState(362);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(359);
				match(K_IF);
				setState(360);
				match(K_NOT);
				setState(361);
				match(K_EXISTS);
				}
			}

			setState(364);
			view_name();
			setState(365);
			match(K_AS);
			setState(366);
			select_stmt();
			}
		}
		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(SqliteParser.K_DELETE, 0); }
		public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.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 SqliteListener ) ((SqliteListener)listener).enterDelete_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDelete_stmt(this);
		}
	}

	public final Delete_stmtContext delete_stmt() throws RecognitionException {
		Delete_stmtContext _localctx = new Delete_stmtContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_delete_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(368);
				with_clause();
				}
			}

			setState(371);
			match(K_DELETE);
			setState(372);
			match(K_FROM);
			setState(373);
			table_name();
			setState(376);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(374);
				match(K_WHERE);
				setState(375);
				expr(0);
				}
			}

			}
		}
		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(SqliteParser.K_DELETE, 0); }
		public TerminalNode K_FROM() { return getToken(SqliteParser.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 TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
		public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.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 TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 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 SqliteListener ) ((SqliteListener)listener).enterDelete_stmt_limited(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 24, RULE_delete_stmt_limited);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(379);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(378);
				with_clause();
				}
			}

			setState(381);
			match(K_DELETE);
			setState(382);
			match(K_FROM);
			setState(383);
			qualified_table_name();
			setState(386);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(384);
				match(K_WHERE);
				setState(385);
				expr(0);
				}
			}

			setState(406);
			_la = _input.LA(1);
			if (_la==K_LIMIT || _la==K_ORDER) {
				{
				setState(398);
				_la = _input.LA(1);
				if (_la==K_ORDER) {
					{
					setState(388);
					match(K_ORDER);
					setState(389);
					match(K_BY);
					setState(390);
					ordering_term();
					setState(395);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(391);
						match(COMMA);
						setState(392);
						ordering_term();
						}
						}
						setState(397);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				setState(400);
				match(K_LIMIT);
				setState(401);
				expr(0);
				setState(404);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(402);
					_la = _input.LA(1);
					if ( !(_la==COMMA || _la==K_OFFSET) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(403);
					expr(0);
					}
				}

				}
			}

			}
		}
		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(SqliteParser.K_DROP, 0); }
		public TerminalNode K_INDEX() { return getToken(SqliteParser.K_INDEX, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 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 SqliteListener ) ((SqliteListener)listener).enterDrop_index_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 26, RULE_drop_index_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(408);
			match(K_DROP);
			setState(409);
			match(K_INDEX);
			setState(412);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(410);
				match(K_IF);
				setState(411);
				match(K_EXISTS);
				}
			}

			setState(414);
			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(SqliteParser.K_DROP, 0); }
		public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 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 SqliteListener ) ((SqliteListener)listener).enterDrop_table_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 28, RULE_drop_table_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(416);
			match(K_DROP);
			setState(417);
			match(K_TABLE);
			setState(420);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(418);
				match(K_IF);
				setState(419);
				match(K_EXISTS);
				}
			}

			setState(422);
			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(SqliteParser.K_DROP, 0); }
		public TerminalNode K_TRIGGER() { return getToken(SqliteParser.K_TRIGGER, 0); }
		public Trigger_nameContext trigger_name() {
			return getRuleContext(Trigger_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 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 SqliteListener ) ((SqliteListener)listener).enterDrop_trigger_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 30, RULE_drop_trigger_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(424);
			match(K_DROP);
			setState(425);
			match(K_TRIGGER);
			setState(428);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(426);
				match(K_IF);
				setState(427);
				match(K_EXISTS);
				}
			}

			setState(430);
			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(SqliteParser.K_DROP, 0); }
		public TerminalNode K_VIEW() { return getToken(SqliteParser.K_VIEW, 0); }
		public View_nameContext view_name() {
			return getRuleContext(View_nameContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 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 SqliteListener ) ((SqliteListener)listener).enterDrop_view_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 32, RULE_drop_view_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(432);
			match(K_DROP);
			setState(433);
			match(K_VIEW);
			setState(436);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(434);
				match(K_IF);
				setState(435);
				match(K_EXISTS);
				}
			}

			setState(438);
			view_name();
			}
		}
		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(SqliteParser.K_INTO, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_INSERT() { return getToken(SqliteParser.K_INSERT, 0); }
		public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
		public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
		public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
		public TerminalNode K_VALUES() { return getToken(SqliteParser.K_VALUES, 0); }
		public ValuesContext values() {
			return getRuleContext(ValuesContext.class,0);
		}
		public Select_stmtContext select_stmt() {
			return getRuleContext(Select_stmtContext.class,0);
		}
		public TerminalNode K_DEFAULT() { return getToken(SqliteParser.K_DEFAULT, 0); }
		public With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.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 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 SqliteListener ) ((SqliteListener)listener).enterInsert_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitInsert_stmt(this);
		}
	}

	public final Insert_stmtContext insert_stmt() throws RecognitionException {
		Insert_stmtContext _localctx = new Insert_stmtContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_insert_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(441);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(440);
				with_clause();
				}
			}

			setState(460);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				{
				setState(443);
				match(K_INSERT);
				}
				break;
			case 2:
				{
				setState(444);
				match(K_REPLACE);
				}
				break;
			case 3:
				{
				setState(445);
				match(K_INSERT);
				setState(446);
				match(K_OR);
				setState(447);
				match(K_REPLACE);
				}
				break;
			case 4:
				{
				setState(448);
				match(K_INSERT);
				setState(449);
				match(K_OR);
				setState(450);
				match(K_ROLLBACK);
				}
				break;
			case 5:
				{
				setState(451);
				match(K_INSERT);
				setState(452);
				match(K_OR);
				setState(453);
				match(K_ABORT);
				}
				break;
			case 6:
				{
				setState(454);
				match(K_INSERT);
				setState(455);
				match(K_OR);
				setState(456);
				match(K_FAIL);
				}
				break;
			case 7:
				{
				setState(457);
				match(K_INSERT);
				setState(458);
				match(K_OR);
				setState(459);
				match(K_IGNORE);
				}
				break;
			}
			setState(462);
			match(K_INTO);
			setState(463);
			table_name();
			setState(475);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(464);
				match(OPEN_PAR);
				setState(465);
				column_name();
				setState(470);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(466);
					match(COMMA);
					setState(467);
					column_name();
					}
					}
					setState(472);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(473);
				match(CLOSE_PAR);
				}
			}

			setState(482);
			switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
			case 1:
				{
				setState(477);
				match(K_VALUES);
				setState(478);
				values();
				}
				break;
			case 2:
				{
				setState(479);
				select_stmt();
				}
				break;
			case 3:
				{
				setState(480);
				match(K_DEFAULT);
				setState(481);
				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 Pragma_stmtContext extends ParserRuleContext {
		public TerminalNode K_PRAGMA() { return getToken(SqliteParser.K_PRAGMA, 0); }
		public Pragma_nameContext pragma_name() {
			return getRuleContext(Pragma_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 SqliteListener ) ((SqliteListener)listener).enterPragma_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_stmt(this);
		}
	}

	public final Pragma_stmtContext pragma_stmt() throws RecognitionException {
		Pragma_stmtContext _localctx = new Pragma_stmtContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_pragma_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(484);
			match(K_PRAGMA);
			setState(485);
			pragma_name();
			setState(492);
			switch (_input.LA(1)) {
			case ASSIGN:
				{
				setState(486);
				match(ASSIGN);
				setState(487);
				pragma_value();
				}
				break;
			case OPEN_PAR:
				{
				setState(488);
				match(OPEN_PAR);
				setState(489);
				pragma_value();
				setState(490);
				match(CLOSE_PAR);
				}
				break;
			case SCOL:
				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 Reindex_stmtContext extends ParserRuleContext {
		public TerminalNode K_REINDEX() { return getToken(SqliteParser.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 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 SqliteListener ) ((SqliteListener)listener).enterReindex_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitReindex_stmt(this);
		}
	}

	public final Reindex_stmtContext reindex_stmt() throws RecognitionException {
		Reindex_stmtContext _localctx = new Reindex_stmtContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_reindex_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(494);
			match(K_REINDEX);
			setState(500);
			switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
			case 1:
				{
				setState(495);
				collation_name();
				}
				break;
			case 2:
				{
				setState(498);
				switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
				case 1:
					{
					setState(496);
					table_name();
					}
					break;
				case 2:
					{
					setState(497);
					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(SqliteParser.K_RELEASE, 0); }
		public Savepoint_nameContext savepoint_name() {
			return getRuleContext(Savepoint_nameContext.class,0);
		}
		public TerminalNode K_SAVEPOINT() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterRelease_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitRelease_stmt(this);
		}
	}

	public final Release_stmtContext release_stmt() throws RecognitionException {
		Release_stmtContext _localctx = new Release_stmtContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_release_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(502);
			match(K_RELEASE);
			setState(504);
			_la = _input.LA(1);
			if (_la==K_SAVEPOINT) {
				{
				setState(503);
				match(K_SAVEPOINT);
				}
			}

			setState(506);
			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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterSavepoint_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSavepoint_stmt(this);
		}
	}

	public final Savepoint_stmtContext savepoint_stmt() throws RecognitionException {
		Savepoint_stmtContext _localctx = new Savepoint_stmtContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_savepoint_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(508);
			match(K_SAVEPOINT);
			setState(509);
			savepoint_name();
			}
		}
		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 With_clauseContext with_clause() {
			return getRuleContext(With_clauseContext.class,0);
		}
		public List compound_operator() {
			return getRuleContexts(Compound_operatorContext.class);
		}
		public Compound_operatorContext compound_operator(int i) {
			return getRuleContext(Compound_operatorContext.class,i);
		}
		public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.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 TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 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 SqliteListener ) ((SqliteListener)listener).enterSelect_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSelect_stmt(this);
		}
	}

	public final Select_stmtContext select_stmt() throws RecognitionException {
		Select_stmtContext _localctx = new Select_stmtContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_select_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(512);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(511);
				with_clause();
				}
			}

			setState(514);
			select_or_values();
			setState(520);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION) {
				{
				{
				setState(515);
				compound_operator();
				setState(516);
				select_or_values();
				}
				}
				setState(522);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(533);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(523);
				match(K_ORDER);
				setState(524);
				match(K_BY);
				setState(525);
				ordering_term();
				setState(530);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(526);
					match(COMMA);
					setState(527);
					ordering_term();
					}
					}
					setState(532);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(541);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(535);
				match(K_LIMIT);
				setState(536);
				expr(0);
				setState(539);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(537);
					_la = _input.LA(1);
					if ( !(_la==COMMA || _la==K_OFFSET) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(538);
					expr(0);
					}
				}

				}
			}

			}
		}
		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(SqliteParser.K_SELECT, 0); }
		public List result_column() {
			return getRuleContexts(Result_columnContext.class);
		}
		public Result_columnContext result_column(int i) {
			return getRuleContext(Result_columnContext.class,i);
		}
		public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
		public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public TerminalNode K_GROUP() { return getToken(SqliteParser.K_GROUP, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
		public TerminalNode K_DISTINCT() { return getToken(SqliteParser.K_DISTINCT, 0); }
		public TerminalNode K_ALL() { return getToken(SqliteParser.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(SqliteParser.K_VALUES, 0); }
		public ValuesContext values() {
			return getRuleContext(ValuesContext.class,0);
		}
		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 SqliteListener ) ((SqliteListener)listener).enterSelect_or_values(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 46, RULE_select_or_values);
		int _la;
		try {
			setState(590);
			switch (_input.LA(1)) {
			case K_SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(543);
				match(K_SELECT);
				setState(545);
				_la = _input.LA(1);
				if (_la==K_ALL || _la==K_DISTINCT) {
					{
					setState(544);
					_la = _input.LA(1);
					if ( !(_la==K_ALL || _la==K_DISTINCT) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					}
				}

				setState(547);
				result_column();
				setState(552);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(548);
					match(COMMA);
					setState(549);
					result_column();
					}
					}
					setState(554);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(567);
				_la = _input.LA(1);
				if (_la==K_FROM) {
					{
					setState(555);
					match(K_FROM);
					setState(565);
					switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
					case 1:
						{
						setState(556);
						table_or_subquery();
						setState(561);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==COMMA) {
							{
							{
							setState(557);
							match(COMMA);
							setState(558);
							table_or_subquery();
							}
							}
							setState(563);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						}
						break;
					case 2:
						{
						setState(564);
						join_clause();
						}
						break;
					}
					}
				}

				setState(571);
				_la = _input.LA(1);
				if (_la==K_WHERE) {
					{
					setState(569);
					match(K_WHERE);
					setState(570);
					expr(0);
					}
				}

				setState(586);
				_la = _input.LA(1);
				if (_la==K_GROUP) {
					{
					setState(573);
					match(K_GROUP);
					setState(574);
					match(K_BY);
					setState(575);
					expr(0);
					setState(580);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(576);
						match(COMMA);
						setState(577);
						expr(0);
						}
						}
						setState(582);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(584);
					_la = _input.LA(1);
					if (_la==K_HAVING) {
						{
						setState(583);
						having_stmt();
						}
					}

					}
				}

				}
				break;
			case K_VALUES:
				enterOuterAlt(_localctx, 2);
				{
				setState(588);
				match(K_VALUES);
				setState(589);
				values();
				}
				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 Having_stmtContext extends ParserRuleContext {
		public TerminalNode K_HAVING() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterHaving_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitHaving_stmt(this);
		}
	}

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

	public static class ValuesContext extends ParserRuleContext {
		public List expr() {
			return getRuleContexts(ExprContext.class);
		}
		public ExprContext expr(int i) {
			return getRuleContext(ExprContext.class,i);
		}
		public ValuesContext values() {
			return getRuleContext(ValuesContext.class,0);
		}
		public ValuesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_values; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterValues(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitValues(this);
		}
	}

	public final ValuesContext values() throws RecognitionException {
		ValuesContext _localctx = new ValuesContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_values);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(595);
			match(OPEN_PAR);
			setState(596);
			expr(0);
			setState(601);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(597);
				match(COMMA);
				setState(598);
				expr(0);
				}
				}
				setState(603);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(604);
			match(CLOSE_PAR);
			setState(607);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(605);
				match(COMMA);
				setState(606);
				values();
				}
			}

			}
		}
		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(SqliteParser.K_UPDATE, 0); }
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_SET() { return getToken(SqliteParser.K_SET, 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 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(SqliteParser.K_OR, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
		public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
		public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
		public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 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 SqliteListener ) ((SqliteListener)listener).enterUpdate_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitUpdate_stmt(this);
		}
	}

	public final Update_stmtContext update_stmt() throws RecognitionException {
		Update_stmtContext _localctx = new Update_stmtContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_update_stmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(610);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(609);
				with_clause();
				}
			}

			setState(612);
			match(K_UPDATE);
			setState(623);
			switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
			case 1:
				{
				setState(613);
				match(K_OR);
				setState(614);
				match(K_ROLLBACK);
				}
				break;
			case 2:
				{
				setState(615);
				match(K_OR);
				setState(616);
				match(K_ABORT);
				}
				break;
			case 3:
				{
				setState(617);
				match(K_OR);
				setState(618);
				match(K_REPLACE);
				}
				break;
			case 4:
				{
				setState(619);
				match(K_OR);
				setState(620);
				match(K_FAIL);
				}
				break;
			case 5:
				{
				setState(621);
				match(K_OR);
				setState(622);
				match(K_IGNORE);
				}
				break;
			}
			setState(625);
			table_name();
			setState(626);
			match(K_SET);
			setState(627);
			column_name();
			setState(628);
			match(ASSIGN);
			setState(629);
			expr(0);
			setState(637);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(630);
				match(COMMA);
				setState(631);
				column_name();
				setState(632);
				match(ASSIGN);
				setState(633);
				expr(0);
				}
				}
				setState(639);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(642);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(640);
				match(K_WHERE);
				setState(641);
				expr(0);
				}
			}

			}
		}
		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(SqliteParser.K_UPDATE, 0); }
		public Qualified_table_nameContext qualified_table_name() {
			return getRuleContext(Qualified_table_nameContext.class,0);
		}
		public TerminalNode K_SET() { return getToken(SqliteParser.K_SET, 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 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(SqliteParser.K_OR, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
		public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
		public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
		public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
		public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
		public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.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 TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 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 SqliteListener ) ((SqliteListener)listener).enterUpdate_stmt_limited(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 54, RULE_update_stmt_limited);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(645);
			_la = _input.LA(1);
			if (_la==K_WITH) {
				{
				setState(644);
				with_clause();
				}
			}

			setState(647);
			match(K_UPDATE);
			setState(658);
			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
			case 1:
				{
				setState(648);
				match(K_OR);
				setState(649);
				match(K_ROLLBACK);
				}
				break;
			case 2:
				{
				setState(650);
				match(K_OR);
				setState(651);
				match(K_ABORT);
				}
				break;
			case 3:
				{
				setState(652);
				match(K_OR);
				setState(653);
				match(K_REPLACE);
				}
				break;
			case 4:
				{
				setState(654);
				match(K_OR);
				setState(655);
				match(K_FAIL);
				}
				break;
			case 5:
				{
				setState(656);
				match(K_OR);
				setState(657);
				match(K_IGNORE);
				}
				break;
			}
			setState(660);
			qualified_table_name();
			setState(661);
			match(K_SET);
			setState(662);
			column_name();
			setState(663);
			match(ASSIGN);
			setState(664);
			expr(0);
			setState(672);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(665);
				match(COMMA);
				setState(666);
				column_name();
				setState(667);
				match(ASSIGN);
				setState(668);
				expr(0);
				}
				}
				setState(674);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(677);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(675);
				match(K_WHERE);
				setState(676);
				expr(0);
				}
			}

			setState(697);
			_la = _input.LA(1);
			if (_la==K_LIMIT || _la==K_ORDER) {
				{
				setState(689);
				_la = _input.LA(1);
				if (_la==K_ORDER) {
					{
					setState(679);
					match(K_ORDER);
					setState(680);
					match(K_BY);
					setState(681);
					ordering_term();
					setState(686);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(682);
						match(COMMA);
						setState(683);
						ordering_term();
						}
						}
						setState(688);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				setState(691);
				match(K_LIMIT);
				setState(692);
				expr(0);
				setState(695);
				_la = _input.LA(1);
				if (_la==COMMA || _la==K_OFFSET) {
					{
					setState(693);
					_la = _input.LA(1);
					if ( !(_la==COMMA || _la==K_OFFSET) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(694);
					expr(0);
					}
				}

				}
			}

			}
		}
		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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterVacuum_stmt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitVacuum_stmt(this);
		}
	}

	public final Vacuum_stmtContext vacuum_stmt() throws RecognitionException {
		Vacuum_stmtContext _localctx = new Vacuum_stmtContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_vacuum_stmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(699);
			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 SqliteListener ) ((SqliteListener)listener).enterColumn_def(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_def(this);
		}
	}

	public final Column_defContext column_def() throws RecognitionException {
		Column_defContext _localctx = new Column_defContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_column_def);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(701);
			column_name();
			setState(702);
			type_name();
			setState(706);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (((((_la - 57)) & ~0x3f) == 0 && ((1L << (_la - 57)) & ((1L << (K_CHECK - 57)) | (1L << (K_COLLATE - 57)) | (1L << (K_CONSTRAINT - 57)) | (1L << (K_DEFAULT - 57)) | (1L << (K_NOT - 57)) | (1L << (K_NULL - 57)))) != 0) || ((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (K_PRIMARY_KEY - 126)) | (1L << (K_REFERENCES - 126)) | (1L << (K_UNIQUE - 126)))) != 0)) {
				{
				{
				setState(703);
				column_constraint();
				}
				}
				setState(708);
				_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 Sqlite_type_nameContext sqlite_type_name() {
			return getRuleContext(Sqlite_type_nameContext.class,0);
		}
		public List signed_number() {
			return getRuleContexts(Signed_numberContext.class);
		}
		public Signed_numberContext signed_number(int i) {
			return getRuleContext(Signed_numberContext.class,i);
		}
		public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
		public Java_type_nameContext java_type_name() {
			return getRuleContext(Java_type_nameContext.class,0);
		}
		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 SqliteListener ) ((SqliteListener)listener).enterType_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitType_name(this);
		}
	}

	public final Type_nameContext type_name() throws RecognitionException {
		Type_nameContext _localctx = new Type_nameContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_type_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(709);
			sqlite_type_name();
			setState(720);
			switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
			case 1:
				{
				setState(710);
				match(OPEN_PAR);
				setState(711);
				signed_number();
				setState(712);
				match(CLOSE_PAR);
				}
				break;
			case 2:
				{
				setState(714);
				match(OPEN_PAR);
				setState(715);
				signed_number();
				setState(716);
				match(COMMA);
				setState(717);
				signed_number();
				setState(718);
				match(CLOSE_PAR);
				}
				break;
			}
			setState(724);
			_la = _input.LA(1);
			if (_la==K_AS) {
				{
				setState(722);
				match(K_AS);
				setState(723);
				java_type_name();
				}
			}

			}
		}
		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_KEY() { return getToken(SqliteParser.K_PRIMARY_KEY, 0); }
		public Conflict_clauseContext conflict_clause() {
			return getRuleContext(Conflict_clauseContext.class,0);
		}
		public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
		public TerminalNode K_UNIQUE() { return getToken(SqliteParser.K_UNIQUE, 0); }
		public TerminalNode K_CHECK() { return getToken(SqliteParser.K_CHECK, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_DEFAULT() { return getToken(SqliteParser.K_DEFAULT, 0); }
		public TerminalNode K_COLLATE() { return getToken(SqliteParser.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(SqliteParser.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(SqliteParser.K_AUTOINCREMENT, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterColumn_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_constraint(this);
		}
	}

	public final Column_constraintContext column_constraint() throws RecognitionException {
		Column_constraintContext _localctx = new Column_constraintContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_column_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(728);
			_la = _input.LA(1);
			if (_la==K_CONSTRAINT) {
				{
				setState(726);
				match(K_CONSTRAINT);
				setState(727);
				name();
				}
			}

			setState(762);
			switch (_input.LA(1)) {
			case K_PRIMARY_KEY:
				{
				setState(730);
				match(K_PRIMARY_KEY);
				setState(732);
				_la = _input.LA(1);
				if (_la==K_ASC || _la==K_DESC) {
					{
					setState(731);
					_la = _input.LA(1);
					if ( !(_la==K_ASC || _la==K_DESC) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					}
				}

				setState(734);
				conflict_clause();
				setState(736);
				_la = _input.LA(1);
				if (_la==K_AUTOINCREMENT) {
					{
					setState(735);
					match(K_AUTOINCREMENT);
					}
				}

				}
				break;
			case K_NOT:
			case K_NULL:
				{
				setState(739);
				_la = _input.LA(1);
				if (_la==K_NOT) {
					{
					setState(738);
					match(K_NOT);
					}
				}

				setState(741);
				match(K_NULL);
				setState(742);
				conflict_clause();
				}
				break;
			case K_UNIQUE:
				{
				setState(743);
				match(K_UNIQUE);
				setState(744);
				conflict_clause();
				}
				break;
			case K_CHECK:
				{
				setState(745);
				match(K_CHECK);
				setState(746);
				match(OPEN_PAR);
				setState(747);
				expr(0);
				setState(748);
				match(CLOSE_PAR);
				}
				break;
			case K_DEFAULT:
				{
				setState(750);
				match(K_DEFAULT);
				setState(757);
				switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
				case 1:
					{
					setState(751);
					signed_number();
					}
					break;
				case 2:
					{
					setState(752);
					literal_value();
					}
					break;
				case 3:
					{
					setState(753);
					match(OPEN_PAR);
					setState(754);
					expr(0);
					setState(755);
					match(CLOSE_PAR);
					}
					break;
				}
				}
				break;
			case K_COLLATE:
				{
				setState(759);
				match(K_COLLATE);
				setState(760);
				collation_name();
				}
				break;
			case K_REFERENCES:
				{
				setState(761);
				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(SqliteParser.K_ON, 0); }
		public TerminalNode K_CONFLICT() { return getToken(SqliteParser.K_CONFLICT, 0); }
		public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
		public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
		public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
		public TerminalNode K_REPLACE() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterConflict_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitConflict_clause(this);
		}
	}

	public final Conflict_clauseContext conflict_clause() throws RecognitionException {
		Conflict_clauseContext _localctx = new Conflict_clauseContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_conflict_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(767);
			_la = _input.LA(1);
			if (_la==K_ON) {
				{
				setState(764);
				match(K_ON);
				setState(765);
				match(K_CONFLICT);
				setState(766);
				_la = _input.LA(1);
				if ( !(_la==K_ABORT || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (K_FAIL - 85)) | (1L << (K_IGNORE - 85)) | (1L << (K_REPLACE - 85)) | (1L << (K_ROLLBACK - 85)))) != 0)) ) {
				_errHandler.recoverInline(this);
				} else {
					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 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 Literal_valueContext literal_value() {
			return getRuleContext(Literal_valueContext.class,0);
		}
		public TerminalNode BIND_PARAMETER() { return getToken(SqliteParser.BIND_PARAMETER, 0); }
		public Column_nameContext column_name() {
			return getRuleContext(Column_nameContext.class,0);
		}
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public Function_nameContext function_name() {
			return getRuleContext(Function_nameContext.class,0);
		}
		public TerminalNode STAR() { return getToken(SqliteParser.STAR, 0); }
		public TerminalNode K_DISTINCT() { return getToken(SqliteParser.K_DISTINCT, 0); }
		public TerminalNode OPEN_PAR() { return getToken(SqliteParser.OPEN_PAR, 0); }
		public TerminalNode CLOSE_PAR() { return getToken(SqliteParser.CLOSE_PAR, 0); }
		public TerminalNode K_CAST() { return getToken(SqliteParser.K_CAST, 0); }
		public TerminalNode K_AS() { return getToken(SqliteParser.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(SqliteParser.K_EXISTS, 0); }
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_CASE() { return getToken(SqliteParser.K_CASE, 0); }
		public TerminalNode K_END() { return getToken(SqliteParser.K_END, 0); }
		public List K_WHEN() { return getTokens(SqliteParser.K_WHEN); }
		public TerminalNode K_WHEN(int i) {
			return getToken(SqliteParser.K_WHEN, i);
		}
		public List K_THEN() { return getTokens(SqliteParser.K_THEN); }
		public TerminalNode K_THEN(int i) {
			return getToken(SqliteParser.K_THEN, i);
		}
		public List return_expr() {
			return getRuleContexts(Return_exprContext.class);
		}
		public Return_exprContext return_expr(int i) {
			return getRuleContext(Return_exprContext.class,i);
		}
		public TerminalNode K_ELSE() { return getToken(SqliteParser.K_ELSE, 0); }
		public Raise_functionContext raise_function() {
			return getRuleContext(Raise_functionContext.class,0);
		}
		public TerminalNode K_AND() { return getToken(SqliteParser.K_AND, 0); }
		public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
		public TerminalNode K_IS() { return getToken(SqliteParser.K_IS, 0); }
		public TerminalNode K_BETWEEN() { return getToken(SqliteParser.K_BETWEEN, 0); }
		public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_LIKE() { return getToken(SqliteParser.K_LIKE, 0); }
		public TerminalNode K_GLOB() { return getToken(SqliteParser.K_GLOB, 0); }
		public TerminalNode K_REGEXP() { return getToken(SqliteParser.K_REGEXP, 0); }
		public TerminalNode K_MATCH() { return getToken(SqliteParser.K_MATCH, 0); }
		public TerminalNode K_ESCAPE() { return getToken(SqliteParser.K_ESCAPE, 0); }
		public TerminalNode K_ISNULL() { return getToken(SqliteParser.K_ISNULL, 0); }
		public TerminalNode K_NOTNULL() { return getToken(SqliteParser.K_NOTNULL, 0); }
		public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
		public TerminalNode K_IN() { return getToken(SqliteParser.K_IN, 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 SqliteListener ) ((SqliteListener)listener).enterExpr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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 = 66;
		enterRecursionRule(_localctx, 66, RULE_expr, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(840);
			switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
			case 1:
				{
				setState(770);
				unary_operator();
				setState(771);
				expr(21);
				}
				break;
			case 2:
				{
				setState(773);
				literal_value();
				}
				break;
			case 3:
				{
				setState(774);
				match(BIND_PARAMETER);
				}
				break;
			case 4:
				{
				setState(778);
				switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
				case 1:
					{
					setState(775);
					table_name();
					setState(776);
					match(DOT);
					}
					break;
				}
				setState(780);
				column_name();
				}
				break;
			case 5:
				{
				setState(781);
				function_name();
				setState(782);
				match(OPEN_PAR);
				setState(795);
				switch (_input.LA(1)) {
				case OPEN_PAR:
				case PLUS:
				case MINUS:
				case TILDE:
				case K_CASE:
				case K_CAST:
				case K_CURRENT_DATE:
				case K_CURRENT_TIME:
				case K_CURRENT_TIMESTAMP:
				case K_DISTINCT:
				case K_EXISTS:
				case K_NOT:
				case K_NULL:
				case K_RAISE:
				case IDENTIFIER:
				case INTEGER_LITERAL:
				case REAL_LITERAL:
				case BIND_PARAMETER:
				case STRING_LITERAL:
				case BLOB_LITERAL:
					{
					setState(784);
					_la = _input.LA(1);
					if (_la==K_DISTINCT) {
						{
						setState(783);
						match(K_DISTINCT);
						}
					}

					setState(786);
					expr(0);
					setState(791);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(787);
						match(COMMA);
						setState(788);
						expr(0);
						}
						}
						setState(793);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
					break;
				case STAR:
					{
					setState(794);
					match(STAR);
					}
					break;
				case CLOSE_PAR:
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(797);
				match(CLOSE_PAR);
				}
				break;
			case 6:
				{
				setState(799);
				match(OPEN_PAR);
				setState(800);
				expr(0);
				setState(801);
				match(CLOSE_PAR);
				}
				break;
			case 7:
				{
				setState(803);
				match(K_CAST);
				setState(804);
				match(OPEN_PAR);
				setState(805);
				expr(0);
				setState(806);
				match(K_AS);
				setState(807);
				type_name();
				setState(808);
				match(CLOSE_PAR);
				}
				break;
			case 8:
				{
				setState(814);
				_la = _input.LA(1);
				if (_la==K_EXISTS || _la==K_NOT) {
					{
					setState(811);
					_la = _input.LA(1);
					if (_la==K_NOT) {
						{
						setState(810);
						match(K_NOT);
						}
					}

					setState(813);
					match(K_EXISTS);
					}
				}

				setState(816);
				match(OPEN_PAR);
				setState(817);
				select_stmt();
				setState(818);
				match(CLOSE_PAR);
				}
				break;
			case 9:
				{
				setState(820);
				match(K_CASE);
				setState(822);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPEN_PAR) | (1L << PLUS) | (1L << MINUS) | (1L << TILDE) | (1L << K_CASE) | (1L << K_CAST))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (K_CURRENT_DATE - 65)) | (1L << (K_CURRENT_TIME - 65)) | (1L << (K_CURRENT_TIMESTAMP - 65)) | (1L << (K_EXISTS - 65)) | (1L << (K_NOT - 65)) | (1L << (K_NULL - 65)) | (1L << (K_RAISE - 65)))) != 0) || ((((_la - 161)) & ~0x3f) == 0 && ((1L << (_la - 161)) & ((1L << (IDENTIFIER - 161)) | (1L << (INTEGER_LITERAL - 161)) | (1L << (REAL_LITERAL - 161)) | (1L << (BIND_PARAMETER - 161)) | (1L << (STRING_LITERAL - 161)) | (1L << (BLOB_LITERAL - 161)))) != 0)) {
					{
					setState(821);
					expr(0);
					}
				}

				setState(829); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(824);
					match(K_WHEN);
					setState(825);
					expr(0);
					setState(826);
					match(K_THEN);
					setState(827);
					return_expr();
					}
					}
					setState(831); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==K_WHEN );
				setState(835);
				_la = _input.LA(1);
				if (_la==K_ELSE) {
					{
					setState(833);
					match(K_ELSE);
					setState(834);
					expr(0);
					}
				}

				setState(837);
				match(K_END);
				}
				break;
			case 10:
				{
				setState(839);
				raise_function();
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(924);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(922);
					switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
					case 1:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(842);
						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
						setState(843);
						match(PIPE2);
						setState(844);
						expr(21);
						}
						break;
					case 2:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(845);
						if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
						setState(846);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << DIV) | (1L << MOD))) != 0)) ) {
						_errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(847);
						expr(20);
						}
						break;
					case 3:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(848);
						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
						setState(849);
						_la = _input.LA(1);
						if ( !(_la==PLUS || _la==MINUS) ) {
						_errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(850);
						expr(19);
						}
						break;
					case 4:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(851);
						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
						setState(852);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT2) | (1L << GT2) | (1L << AMP) | (1L << PIPE))) != 0)) ) {
						_errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(853);
						expr(18);
						}
						break;
					case 5:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(854);
						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
						setState(855);
						_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 {
							consume();
						}
						setState(856);
						expr(17);
						}
						break;
					case 6:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(857);
						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
						setState(858);
						_la = _input.LA(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSIGN) | (1L << EQ) | (1L << NOT_EQ1) | (1L << NOT_EQ2))) != 0)) ) {
						_errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(859);
						expr(16);
						}
						break;
					case 7:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(860);
						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
						setState(861);
						match(K_AND);
						setState(862);
						expr(15);
						}
						break;
					case 8:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(863);
						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
						setState(864);
						match(K_OR);
						setState(865);
						expr(14);
						}
						break;
					case 9:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(866);
						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
						setState(867);
						match(K_IS);
						setState(869);
						switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
						case 1:
							{
							setState(868);
							match(K_NOT);
							}
							break;
						}
						setState(871);
						expr(7);
						}
						break;
					case 10:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(872);
						if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
						setState(874);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(873);
							match(K_NOT);
							}
						}

						setState(876);
						match(K_BETWEEN);
						setState(877);
						expr(0);
						setState(878);
						match(K_AND);
						setState(879);
						expr(6);
						}
						break;
					case 11:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(881);
						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
						setState(882);
						match(K_COLLATE);
						setState(883);
						collation_name();
						}
						break;
					case 12:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(884);
						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
						setState(886);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(885);
							match(K_NOT);
							}
						}

						setState(888);
						_la = _input.LA(1);
						if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & ((1L << (K_GLOB - 90)) | (1L << (K_LIKE - 90)) | (1L << (K_MATCH - 90)) | (1L << (K_REGEXP - 90)))) != 0)) ) {
						_errHandler.recoverInline(this);
						} else {
							consume();
						}
						setState(889);
						expr(0);
						setState(892);
						switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
						case 1:
							{
							setState(890);
							match(K_ESCAPE);
							setState(891);
							expr(0);
							}
							break;
						}
						}
						break;
					case 13:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(894);
						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
						setState(899);
						switch (_input.LA(1)) {
						case K_ISNULL:
							{
							setState(895);
							match(K_ISNULL);
							}
							break;
						case K_NOTNULL:
							{
							setState(896);
							match(K_NOTNULL);
							}
							break;
						case K_NOT:
							{
							setState(897);
							match(K_NOT);
							setState(898);
							match(K_NULL);
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						}
						break;
					case 14:
						{
						_localctx = new ExprContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_expr);
						setState(901);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(903);
						_la = _input.LA(1);
						if (_la==K_NOT) {
							{
							setState(902);
							match(K_NOT);
							}
						}

						setState(905);
						match(K_IN);
						setState(920);
						switch (_input.LA(1)) {
						case OPEN_PAR:
							{
							setState(906);
							match(OPEN_PAR);
							setState(916);
							switch (_input.LA(1)) {
							case K_SELECT:
							case K_VALUES:
							case K_WITH:
								{
								setState(907);
								select_stmt();
								}
								break;
							case OPEN_PAR:
							case PLUS:
							case MINUS:
							case TILDE:
							case K_CASE:
							case K_CAST:
							case K_CURRENT_DATE:
							case K_CURRENT_TIME:
							case K_CURRENT_TIMESTAMP:
							case K_EXISTS:
							case K_NOT:
							case K_NULL:
							case K_RAISE:
							case IDENTIFIER:
							case INTEGER_LITERAL:
							case REAL_LITERAL:
							case BIND_PARAMETER:
							case STRING_LITERAL:
							case BLOB_LITERAL:
								{
								setState(908);
								expr(0);
								setState(913);
								_errHandler.sync(this);
								_la = _input.LA(1);
								while (_la==COMMA) {
									{
									{
									setState(909);
									match(COMMA);
									setState(910);
									expr(0);
									}
									}
									setState(915);
									_errHandler.sync(this);
									_la = _input.LA(1);
								}
								}
								break;
							case CLOSE_PAR:
								break;
							default:
								throw new NoViableAltException(this);
							}
							setState(918);
							match(CLOSE_PAR);
							}
							break;
						case IDENTIFIER:
							{
							setState(919);
							table_name();
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						}
						break;
					}
					} 
				}
				setState(926);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class Return_exprContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public Return_exprContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_return_expr; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterReturn_expr(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitReturn_expr(this);
		}
	}

	public final Return_exprContext return_expr() throws RecognitionException {
		Return_exprContext _localctx = new Return_exprContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_return_expr);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(927);
			expr(0);
			}
		}
		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(SqliteParser.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(SqliteParser.K_DEFERRABLE, 0); }
		public List K_ON() { return getTokens(SqliteParser.K_ON); }
		public TerminalNode K_ON(int i) {
			return getToken(SqliteParser.K_ON, i);
		}
		public List K_MATCH() { return getTokens(SqliteParser.K_MATCH); }
		public TerminalNode K_MATCH(int i) {
			return getToken(SqliteParser.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(SqliteParser.K_DELETE); }
		public TerminalNode K_DELETE(int i) {
			return getToken(SqliteParser.K_DELETE, i);
		}
		public List K_UPDATE() { return getTokens(SqliteParser.K_UPDATE); }
		public TerminalNode K_UPDATE(int i) {
			return getToken(SqliteParser.K_UPDATE, i);
		}
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_INITIALLY() { return getToken(SqliteParser.K_INITIALLY, 0); }
		public TerminalNode K_DEFERRED() { return getToken(SqliteParser.K_DEFERRED, 0); }
		public TerminalNode K_IMMEDIATE() { return getToken(SqliteParser.K_IMMEDIATE, 0); }
		public List K_SET() { return getTokens(SqliteParser.K_SET); }
		public TerminalNode K_SET(int i) {
			return getToken(SqliteParser.K_SET, i);
		}
		public List K_NULL() { return getTokens(SqliteParser.K_NULL); }
		public TerminalNode K_NULL(int i) {
			return getToken(SqliteParser.K_NULL, i);
		}
		public List K_DEFAULT() { return getTokens(SqliteParser.K_DEFAULT); }
		public TerminalNode K_DEFAULT(int i) {
			return getToken(SqliteParser.K_DEFAULT, i);
		}
		public List K_CASCADE() { return getTokens(SqliteParser.K_CASCADE); }
		public TerminalNode K_CASCADE(int i) {
			return getToken(SqliteParser.K_CASCADE, i);
		}
		public List K_RESTRICT() { return getTokens(SqliteParser.K_RESTRICT); }
		public TerminalNode K_RESTRICT(int i) {
			return getToken(SqliteParser.K_RESTRICT, i);
		}
		public List K_NO() { return getTokens(SqliteParser.K_NO); }
		public TerminalNode K_NO(int i) {
			return getToken(SqliteParser.K_NO, i);
		}
		public List K_ACTION() { return getTokens(SqliteParser.K_ACTION); }
		public TerminalNode K_ACTION(int i) {
			return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterForeign_key_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 70, RULE_foreign_key_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(929);
			match(K_REFERENCES);
			setState(930);
			foreign_table();
			setState(942);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(931);
				match(OPEN_PAR);
				setState(932);
				column_name();
				setState(937);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(933);
					match(COMMA);
					setState(934);
					column_name();
					}
					}
					setState(939);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(940);
				match(CLOSE_PAR);
				}
			}

			setState(962);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_MATCH || _la==K_ON) {
				{
				{
				setState(958);
				switch (_input.LA(1)) {
				case K_ON:
					{
					setState(944);
					match(K_ON);
					setState(945);
					_la = _input.LA(1);
					if ( !(_la==K_DELETE || _la==K_UPDATE) ) {
					_errHandler.recoverInline(this);
					} else {
						consume();
					}
					setState(954);
					switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
					case 1:
						{
						setState(946);
						match(K_SET);
						setState(947);
						match(K_NULL);
						}
						break;
					case 2:
						{
						setState(948);
						match(K_SET);
						setState(949);
						match(K_DEFAULT);
						}
						break;
					case 3:
						{
						setState(950);
						match(K_CASCADE);
						}
						break;
					case 4:
						{
						setState(951);
						match(K_RESTRICT);
						}
						break;
					case 5:
						{
						setState(952);
						match(K_NO);
						setState(953);
						match(K_ACTION);
						}
						break;
					}
					}
					break;
				case K_MATCH:
					{
					setState(956);
					match(K_MATCH);
					setState(957);
					name();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				}
				setState(964);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(975);
			switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
			case 1:
				{
				setState(966);
				_la = _input.LA(1);
				if (_la==K_NOT) {
					{
					setState(965);
					match(K_NOT);
					}
				}

				setState(968);
				match(K_DEFERRABLE);
				setState(973);
				switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
				case 1:
					{
					setState(969);
					match(K_INITIALLY);
					setState(970);
					match(K_DEFERRED);
					}
					break;
				case 2:
					{
					setState(971);
					match(K_INITIALLY);
					setState(972);
					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(SqliteParser.K_RAISE, 0); }
		public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
		public Error_messageContext error_message() {
			return getRuleContext(Error_messageContext.class,0);
		}
		public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
		public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
		public TerminalNode K_FAIL() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterRaise_function(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitRaise_function(this);
		}
	}

	public final Raise_functionContext raise_function() throws RecognitionException {
		Raise_functionContext _localctx = new Raise_functionContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_raise_function);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(977);
			match(K_RAISE);
			setState(978);
			match(OPEN_PAR);
			setState(983);
			switch (_input.LA(1)) {
			case K_IGNORE:
				{
				setState(979);
				match(K_IGNORE);
				}
				break;
			case K_ABORT:
			case K_FAIL:
			case K_ROLLBACK:
				{
				setState(980);
				_la = _input.LA(1);
				if ( !(_la==K_ABORT || _la==K_FAIL || _la==K_ROLLBACK) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				setState(981);
				match(COMMA);
				setState(982);
				error_message();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(985);
			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(SqliteParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterIndexed_column(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitIndexed_column(this);
		}
	}

	public final Indexed_columnContext indexed_column() throws RecognitionException {
		Indexed_columnContext _localctx = new Indexed_columnContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_indexed_column);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(987);
			column_name();
			setState(990);
			_la = _input.LA(1);
			if (_la==K_COLLATE) {
				{
				setState(988);
				match(K_COLLATE);
				setState(989);
				collation_name();
				}
			}

			setState(993);
			_la = _input.LA(1);
			if (_la==K_ASC || _la==K_DESC) {
				{
				setState(992);
				_la = _input.LA(1);
				if ( !(_la==K_ASC || _la==K_DESC) ) {
				_errHandler.recoverInline(this);
				} else {
					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(SqliteParser.K_CHECK, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_FOREIGN_KEY() { return getToken(SqliteParser.K_FOREIGN_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(SqliteParser.K_CONSTRAINT, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TerminalNode K_PRIMARY_KEY() { return getToken(SqliteParser.K_PRIMARY_KEY, 0); }
		public TerminalNode K_UNIQUE() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterTable_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_constraint(this);
		}
	}

	public final Table_constraintContext table_constraint() throws RecognitionException {
		Table_constraintContext _localctx = new Table_constraintContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_table_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(997);
			_la = _input.LA(1);
			if (_la==K_CONSTRAINT) {
				{
				setState(995);
				match(K_CONSTRAINT);
				setState(996);
				name();
				}
			}

			setState(1030);
			switch (_input.LA(1)) {
			case K_PRIMARY_KEY:
			case K_UNIQUE:
				{
				setState(999);
				_la = _input.LA(1);
				if ( !(_la==K_PRIMARY_KEY || _la==K_UNIQUE) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				setState(1000);
				match(OPEN_PAR);
				setState(1001);
				indexed_column();
				setState(1006);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1002);
					match(COMMA);
					setState(1003);
					indexed_column();
					}
					}
					setState(1008);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1009);
				match(CLOSE_PAR);
				setState(1010);
				conflict_clause();
				}
				break;
			case K_CHECK:
				{
				setState(1012);
				match(K_CHECK);
				setState(1013);
				match(OPEN_PAR);
				setState(1014);
				expr(0);
				setState(1015);
				match(CLOSE_PAR);
				}
				break;
			case K_FOREIGN_KEY:
				{
				setState(1017);
				match(K_FOREIGN_KEY);
				setState(1018);
				match(OPEN_PAR);
				setState(1019);
				column_name();
				setState(1024);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1020);
					match(COMMA);
					setState(1021);
					column_name();
					}
					}
					setState(1026);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1027);
				match(CLOSE_PAR);
				setState(1028);
				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(SqliteParser.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 TerminalNode K_RECURSIVE() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterWith_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitWith_clause(this);
		}
	}

	public final With_clauseContext with_clause() throws RecognitionException {
		With_clauseContext _localctx = new With_clauseContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_with_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1032);
			match(K_WITH);
			setState(1034);
			_la = _input.LA(1);
			if (_la==K_RECURSIVE) {
				{
				setState(1033);
				match(K_RECURSIVE);
				}
			}

			setState(1036);
			common_table_expression();
			setState(1041);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1037);
				match(COMMA);
				setState(1038);
				common_table_expression();
				}
				}
				setState(1043);
				_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 Qualified_table_nameContext extends ParserRuleContext {
		public Table_nameContext table_name() {
			return getRuleContext(Table_nameContext.class,0);
		}
		public TerminalNode K_INDEXED() { return getToken(SqliteParser.K_INDEXED, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_NOT() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterQualified_table_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 80, RULE_qualified_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1044);
			table_name();
			setState(1050);
			switch (_input.LA(1)) {
			case K_INDEXED:
				{
				setState(1045);
				match(K_INDEXED);
				setState(1046);
				match(K_BY);
				setState(1047);
				index_name();
				}
				break;
			case K_NOT:
				{
				setState(1048);
				match(K_NOT);
				setState(1049);
				match(K_INDEXED);
				}
				break;
			case SCOL:
			case K_LIMIT:
			case K_ORDER:
			case K_SET:
			case K_WHERE:
				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 Ordering_termContext extends ParserRuleContext {
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
		public Collation_nameContext collation_name() {
			return getRuleContext(Collation_nameContext.class,0);
		}
		public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterOrdering_term(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitOrdering_term(this);
		}
	}

	public final Ordering_termContext ordering_term() throws RecognitionException {
		Ordering_termContext _localctx = new Ordering_termContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_ordering_term);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1052);
			expr(0);
			setState(1055);
			_la = _input.LA(1);
			if (_la==K_COLLATE) {
				{
				setState(1053);
				match(K_COLLATE);
				setState(1054);
				collation_name();
				}
			}

			setState(1058);
			_la = _input.LA(1);
			if (_la==K_ASC || _la==K_DESC) {
				{
				setState(1057);
				_la = _input.LA(1);
				if ( !(_la==K_ASC || _la==K_DESC) ) {
				_errHandler.recoverInline(this);
				} else {
					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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterPragma_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_value(this);
		}
	}

	public final Pragma_valueContext pragma_value() throws RecognitionException {
		Pragma_valueContext _localctx = new Pragma_valueContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_pragma_value);
		try {
			setState(1063);
			switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1060);
				signed_number();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1061);
				name();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1062);
				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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterCommon_table_expression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 86, RULE_common_table_expression);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1065);
			table_name();
			setState(1077);
			_la = _input.LA(1);
			if (_la==OPEN_PAR) {
				{
				setState(1066);
				match(OPEN_PAR);
				setState(1067);
				column_name();
				setState(1072);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1068);
					match(COMMA);
					setState(1069);
					column_name();
					}
					}
					setState(1074);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1075);
				match(CLOSE_PAR);
				}
			}

			setState(1079);
			match(K_AS);
			setState(1080);
			match(OPEN_PAR);
			setState(1081);
			select_stmt();
			setState(1082);
			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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterResult_column(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitResult_column(this);
		}
	}

	public final Result_columnContext result_column() throws RecognitionException {
		Result_columnContext _localctx = new Result_columnContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_result_column);
		int _la;
		try {
			setState(1096);
			switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1084);
				match(STAR);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1085);
				table_name();
				setState(1086);
				match(DOT);
				setState(1087);
				match(STAR);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1089);
				expr(0);
				setState(1094);
				_la = _input.LA(1);
				if (_la==K_AS || _la==IDENTIFIER) {
					{
					setState(1091);
					_la = _input.LA(1);
					if (_la==K_AS) {
						{
						setState(1090);
						match(K_AS);
						}
					}

					setState(1093);
					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 Table_aliasContext table_alias() {
			return getRuleContext(Table_aliasContext.class,0);
		}
		public TerminalNode K_INDEXED() { return getToken(SqliteParser.K_INDEXED, 0); }
		public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
		public Index_nameContext index_name() {
			return getRuleContext(Index_nameContext.class,0);
		}
		public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
		public TerminalNode K_AS() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterTable_or_subquery(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 90, RULE_table_or_subquery);
		int _la;
		try {
			setState(1135);
			switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1098);
				table_name();
				setState(1103);
				_la = _input.LA(1);
				if (_la==K_AS || _la==IDENTIFIER) {
					{
					setState(1100);
					_la = _input.LA(1);
					if (_la==K_AS) {
						{
						setState(1099);
						match(K_AS);
						}
					}

					setState(1102);
					table_alias();
					}
				}

				setState(1110);
				switch (_input.LA(1)) {
				case K_INDEXED:
					{
					setState(1105);
					match(K_INDEXED);
					setState(1106);
					match(K_BY);
					setState(1107);
					index_name();
					}
					break;
				case K_NOT:
					{
					setState(1108);
					match(K_NOT);
					setState(1109);
					match(K_INDEXED);
					}
					break;
				case SCOL:
				case CLOSE_PAR:
				case COMMA:
				case K_CROSS:
				case K_EXCEPT:
				case K_GROUP:
				case K_INNER:
				case K_INTERSECT:
				case K_JOIN:
				case K_LEFT:
				case K_LIMIT:
				case K_NATURAL:
				case K_ON:
				case K_ORDER:
				case K_UNION:
				case K_USING:
				case K_WHERE:
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1112);
				match(OPEN_PAR);
				setState(1122);
				switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
				case 1:
					{
					setState(1113);
					table_or_subquery();
					setState(1118);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==COMMA) {
						{
						{
						setState(1114);
						match(COMMA);
						setState(1115);
						table_or_subquery();
						}
						}
						setState(1120);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
					break;
				case 2:
					{
					setState(1121);
					join_clause();
					}
					break;
				}
				setState(1124);
				match(CLOSE_PAR);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1126);
				match(OPEN_PAR);
				setState(1127);
				select_stmt();
				setState(1128);
				match(CLOSE_PAR);
				setState(1133);
				_la = _input.LA(1);
				if (_la==K_AS || _la==IDENTIFIER) {
					{
					setState(1130);
					_la = _input.LA(1);
					if (_la==K_AS) {
						{
						setState(1129);
						match(K_AS);
						}
					}

					setState(1132);
					table_alias();
					}
				}

				}
				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 SqliteListener ) ((SqliteListener)listener).enterJoin_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_clause(this);
		}
	}

	public final Join_clauseContext join_clause() throws RecognitionException {
		Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_join_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1137);
			table_or_subquery();
			setState(1144);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_CROSS - 64)) | (1L << (K_INNER - 64)) | (1L << (K_JOIN - 64)) | (1L << (K_LEFT - 64)) | (1L << (K_NATURAL - 64)))) != 0)) {
				{
				{
				setState(1138);
				join_operator();
				setState(1139);
				table_or_subquery();
				setState(1140);
				join_constraint();
				}
				}
				setState(1146);
				_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(SqliteParser.K_JOIN, 0); }
		public TerminalNode K_NATURAL() { return getToken(SqliteParser.K_NATURAL, 0); }
		public TerminalNode K_LEFT() { return getToken(SqliteParser.K_LEFT, 0); }
		public TerminalNode K_INNER() { return getToken(SqliteParser.K_INNER, 0); }
		public TerminalNode K_CROSS() { return getToken(SqliteParser.K_CROSS, 0); }
		public TerminalNode K_OUTER() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterJoin_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_operator(this);
		}
	}

	public final Join_operatorContext join_operator() throws RecognitionException {
		Join_operatorContext _localctx = new Join_operatorContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_join_operator);
		int _la;
		try {
			setState(1160);
			switch (_input.LA(1)) {
			case COMMA:
				enterOuterAlt(_localctx, 1);
				{
				setState(1147);
				match(COMMA);
				}
				break;
			case K_CROSS:
			case K_INNER:
			case K_JOIN:
			case K_LEFT:
			case K_NATURAL:
				enterOuterAlt(_localctx, 2);
				{
				setState(1149);
				_la = _input.LA(1);
				if (_la==K_NATURAL) {
					{
					setState(1148);
					match(K_NATURAL);
					}
				}

				setState(1157);
				switch (_input.LA(1)) {
				case K_LEFT:
					{
					setState(1151);
					match(K_LEFT);
					setState(1153);
					_la = _input.LA(1);
					if (_la==K_OUTER) {
						{
						setState(1152);
						match(K_OUTER);
						}
					}

					}
					break;
				case K_INNER:
					{
					setState(1155);
					match(K_INNER);
					}
					break;
				case K_CROSS:
					{
					setState(1156);
					match(K_CROSS);
					}
					break;
				case K_JOIN:
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(1159);
				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(SqliteParser.K_ON, 0); }
		public ExprContext expr() {
			return getRuleContext(ExprContext.class,0);
		}
		public TerminalNode K_USING() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterJoin_constraint(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_constraint(this);
		}
	}

	public final Join_constraintContext join_constraint() throws RecognitionException {
		Join_constraintContext _localctx = new Join_constraintContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_join_constraint);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1176);
			switch (_input.LA(1)) {
			case K_ON:
				{
				setState(1162);
				match(K_ON);
				setState(1163);
				expr(0);
				}
				break;
			case K_USING:
				{
				setState(1164);
				match(K_USING);
				setState(1165);
				match(OPEN_PAR);
				setState(1166);
				column_name();
				setState(1171);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1167);
					match(COMMA);
					setState(1168);
					column_name();
					}
					}
					setState(1173);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1174);
				match(CLOSE_PAR);
				}
				break;
			case SCOL:
			case CLOSE_PAR:
			case COMMA:
			case K_CROSS:
			case K_EXCEPT:
			case K_GROUP:
			case K_INNER:
			case K_INTERSECT:
			case K_JOIN:
			case K_LEFT:
			case K_LIMIT:
			case K_NATURAL:
			case K_ORDER:
			case K_UNION:
			case K_WHERE:
				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(SqliteParser.K_UNION, 0); }
		public TerminalNode K_ALL() { return getToken(SqliteParser.K_ALL, 0); }
		public TerminalNode K_INTERSECT() { return getToken(SqliteParser.K_INTERSECT, 0); }
		public TerminalNode K_EXCEPT() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterCompound_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCompound_operator(this);
		}
	}

	public final Compound_operatorContext compound_operator() throws RecognitionException {
		Compound_operatorContext _localctx = new Compound_operatorContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_compound_operator);
		try {
			setState(1183);
			switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1178);
				match(K_UNION);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1179);
				match(K_UNION);
				setState(1180);
				match(K_ALL);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1181);
				match(K_INTERSECT);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1182);
				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 Signed_numberContext extends ParserRuleContext {
		public TerminalNode INTEGER_LITERAL() { return getToken(SqliteParser.INTEGER_LITERAL, 0); }
		public TerminalNode REAL_LITERAL() { return getToken(SqliteParser.REAL_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 SqliteListener ) ((SqliteListener)listener).enterSigned_number(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSigned_number(this);
		}
	}

	public final Signed_numberContext signed_number() throws RecognitionException {
		Signed_numberContext _localctx = new Signed_numberContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_signed_number);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1186);
			_la = _input.LA(1);
			if (_la==PLUS || _la==MINUS) {
				{
				setState(1185);
				_la = _input.LA(1);
				if ( !(_la==PLUS || _la==MINUS) ) {
				_errHandler.recoverInline(this);
				} else {
					consume();
				}
				}
			}

			setState(1188);
			_la = _input.LA(1);
			if ( !(_la==INTEGER_LITERAL || _la==REAL_LITERAL) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		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 INTEGER_LITERAL() { return getToken(SqliteParser.INTEGER_LITERAL, 0); }
		public TerminalNode REAL_LITERAL() { return getToken(SqliteParser.REAL_LITERAL, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
		public TerminalNode BLOB_LITERAL() { return getToken(SqliteParser.BLOB_LITERAL, 0); }
		public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
		public TerminalNode K_CURRENT_TIME() { return getToken(SqliteParser.K_CURRENT_TIME, 0); }
		public TerminalNode K_CURRENT_DATE() { return getToken(SqliteParser.K_CURRENT_DATE, 0); }
		public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterLiteral_value(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitLiteral_value(this);
		}
	}

	public final Literal_valueContext literal_value() throws RecognitionException {
		Literal_valueContext _localctx = new Literal_valueContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_literal_value);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1190);
			_la = _input.LA(1);
			if ( !(((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (K_CURRENT_DATE - 65)) | (1L << (K_CURRENT_TIME - 65)) | (1L << (K_CURRENT_TIMESTAMP - 65)) | (1L << (K_NULL - 65)))) != 0) || ((((_la - 162)) & ~0x3f) == 0 && ((1L << (_la - 162)) & ((1L << (INTEGER_LITERAL - 162)) | (1L << (REAL_LITERAL - 162)) | (1L << (STRING_LITERAL - 162)) | (1L << (BLOB_LITERAL - 162)))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterUnary_operator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitUnary_operator(this);
		}
	}

	public final Unary_operatorContext unary_operator() throws RecognitionException {
		Unary_operatorContext _localctx = new Unary_operatorContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_unary_operator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1192);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << TILDE))) != 0) || _la==K_NOT) ) {
			_errHandler.recoverInline(this);
			} else {
				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(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterError_message(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitError_message(this);
		}
	}

	public final Error_messageContext error_message() throws RecognitionException {
		Error_messageContext _localctx = new Error_messageContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_error_message);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1194);
			match(STRING_LITERAL);
			}
		}
		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(SqliteParser.IDENTIFIER, 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 SqliteListener ) ((SqliteListener)listener).enterColumn_alias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_alias(this);
		}
	}

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

	public final KeywordContext keyword() throws RecognitionException {
		KeywordContext _localctx = new KeywordContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_keyword);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1198);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_JAVA_BOOLEAN) | (1L << K_JAVA_INTEGER) | (1L << K_JAVA_LONG) | (1L << K_JAVA_FLOAT) | (1L << K_JAVA_DOUBLE) | (1L << K_JAVA_STRING) | (1L << K_JAVA_BYTE_ARRAY) | (1L << K_INTEGER) | (1L << K_REAL) | (1L << K_TEXT) | (1L << K_BLOB) | (1L << K_ABORT) | (1L << K_ACTION) | (1L << K_ADD) | (1L << K_AFTER) | (1L << K_ALL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_AND) | (1L << K_AS) | (1L << K_ASC) | (1L << K_ATTACH) | (1L << K_AUTOINCREMENT) | (1L << K_BEFORE) | (1L << K_BEGIN) | (1L << K_BETWEEN) | (1L << K_BY) | (1L << K_CASCADE) | (1L << K_CASE) | (1L << K_CAST) | (1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_COLUMN) | (1L << K_COMMIT) | (1L << K_CONFLICT) | (1L << K_CONSTRAINT) | (1L << K_CREATE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_CROSS - 64)) | (1L << (K_CURRENT_DATE - 64)) | (1L << (K_CURRENT_TIME - 64)) | (1L << (K_CURRENT_TIMESTAMP - 64)) | (1L << (K_DATABASE - 64)) | (1L << (K_DEFAULT - 64)) | (1L << (K_DEFERRABLE - 64)) | (1L << (K_DEFERRED - 64)) | (1L << (K_DELETE - 64)) | (1L << (K_DESC - 64)) | (1L << (K_DETACH - 64)) | (1L << (K_DISTINCT - 64)) | (1L << (K_DROP - 64)) | (1L << (K_EACH - 64)) | (1L << (K_ELSE - 64)) | (1L << (K_END - 64)) | (1L << (K_ESCAPE - 64)) | (1L << (K_EXCEPT - 64)) | (1L << (K_EXCLUSIVE - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_EXPLAIN - 64)) | (1L << (K_FAIL - 64)) | (1L << (K_FOR - 64)) | (1L << (K_FOREIGN_KEY - 64)) | (1L << (K_FROM - 64)) | (1L << (K_FULL - 64)) | (1L << (K_GLOB - 64)) | (1L << (K_GROUP - 64)) | (1L << (K_HAVING - 64)) | (1L << (K_IF - 64)) | (1L << (K_IGNORE - 64)) | (1L << (K_IMMEDIATE - 64)) | (1L << (K_IMPORT - 64)) | (1L << (K_IN - 64)) | (1L << (K_INDEX - 64)) | (1L << (K_INDEXED - 64)) | (1L << (K_INITIALLY - 64)) | (1L << (K_INNER - 64)) | (1L << (K_INSERT - 64)) | (1L << (K_INSTEAD - 64)) | (1L << (K_INTERSECT - 64)) | (1L << (K_INTO - 64)) | (1L << (K_IS - 64)) | (1L << (K_ISNULL - 64)) | (1L << (K_JOIN - 64)) | (1L << (K_LEFT - 64)) | (1L << (K_LIKE - 64)) | (1L << (K_LIMIT - 64)) | (1L << (K_MATCH - 64)) | (1L << (K_NATURAL - 64)) | (1L << (K_NO - 64)) | (1L << (K_NOT - 64)) | (1L << (K_NOTNULL - 64)) | (1L << (K_NULL - 64)) | (1L << (K_OF - 64)) | (1L << (K_OFFSET - 64)) | (1L << (K_ON - 64)) | (1L << (K_OR - 64)) | (1L << (K_ORDER - 64)) | (1L << (K_OUTER - 64)) | (1L << (K_PLAN - 64)) | (1L << (K_PRAGMA - 64)) | (1L << (K_PRIMARY_KEY - 64)) | (1L << (K_QUERY - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (K_RAISE - 128)) | (1L << (K_RECURSIVE - 128)) | (1L << (K_REFERENCES - 128)) | (1L << (K_REGEXP - 128)) | (1L << (K_REINDEX - 128)) | (1L << (K_RELEASE - 128)) | (1L << (K_RENAME - 128)) | (1L << (K_REPLACE - 128)) | (1L << (K_RESTRICT - 128)) | (1L << (K_RIGHT - 128)) | (1L << (K_ROLLBACK - 128)) | (1L << (K_ROW - 128)) | (1L << (K_SAVEPOINT - 128)) | (1L << (K_SELECT - 128)) | (1L << (K_SET - 128)) | (1L << (K_TABLE - 128)) | (1L << (K_TEMP - 128)) | (1L << (K_TEMPORARY - 128)) | (1L << (K_THEN - 128)) | (1L << (K_TO - 128)) | (1L << (K_TRANSACTION - 128)) | (1L << (K_TRIGGER - 128)) | (1L << (K_UNION - 128)) | (1L << (K_UNIQUE - 128)) | (1L << (K_UPDATE - 128)) | (1L << (K_USING - 128)) | (1L << (K_VACUUM - 128)) | (1L << (K_VALUES - 128)) | (1L << (K_VIEW - 128)) | (1L << (K_WHEN - 128)) | (1L << (K_WHERE - 128)) | (1L << (K_WITH - 128)) | (1L << (K_WITHOUT - 128)))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				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 SqliteListener ) ((SqliteListener)listener).enterName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitName(this);
		}
	}

	public final NameContext name() throws RecognitionException {
		NameContext _localctx = new NameContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1200);
			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 SqliteListener ) ((SqliteListener)listener).enterFunction_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitFunction_name(this);
		}
	}

	public final Function_nameContext function_name() throws RecognitionException {
		Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_function_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1202);
			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 TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 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 SqliteListener ) ((SqliteListener)listener).enterTable_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_name(this);
		}
	}

	public final Table_nameContext table_name() throws RecognitionException {
		Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1204);
			match(IDENTIFIER);
			}
		}
		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 SqliteListener ) ((SqliteListener)listener).enterTable_or_index_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 118, RULE_table_or_index_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1206);
			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 SqliteListener ) ((SqliteListener)listener).enterNew_table_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)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, 120, RULE_new_table_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1208);
			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 TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 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 SqliteListener ) ((SqliteListener)listener).enterColumn_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_name(this);
		}
	}

	public final Column_nameContext column_name() throws RecognitionException {
		Column_nameContext _localctx = new Column_nameContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_column_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1210);
			_la = _input.LA(1);
			if ( !(_la==IDENTIFIER || _la==STRING_LITERAL) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Sql_stmt_nameContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
		public Sql_stmt_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sql_stmt_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSql_stmt_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSql_stmt_name(this);
		}
	}

	public final Sql_stmt_nameContext sql_stmt_name() throws RecognitionException {
		Sql_stmt_nameContext _localctx = new Sql_stmt_nameContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_sql_stmt_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1212);
			match(IDENTIFIER);
			}
		}
		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 SqliteListener ) ((SqliteListener)listener).enterCollation_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCollation_name(this);
		}
	}

	public final Collation_nameContext collation_name() throws RecognitionException {
		Collation_nameContext _localctx = new Collation_nameContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_collation_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1214);
			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 SqliteListener ) ((SqliteListener)listener).enterForeign_table(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitForeign_table(this);
		}
	}

	public final Foreign_tableContext foreign_table() throws RecognitionException {
		Foreign_tableContext _localctx = new Foreign_tableContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_foreign_table);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1216);
			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 SqliteListener ) ((SqliteListener)listener).enterIndex_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitIndex_name(this);
		}
	}

	public final Index_nameContext index_name() throws RecognitionException {
		Index_nameContext _localctx = new Index_nameContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_index_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1218);
			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 SqliteListener ) ((SqliteListener)listener).enterTrigger_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTrigger_name(this);
		}
	}

	public final Trigger_nameContext trigger_name() throws RecognitionException {
		Trigger_nameContext _localctx = new Trigger_nameContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_trigger_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1220);
			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 TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 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 SqliteListener ) ((SqliteListener)listener).enterView_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitView_name(this);
		}
	}

	public final View_nameContext view_name() throws RecognitionException {
		View_nameContext _localctx = new View_nameContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_view_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1222);
			match(IDENTIFIER);
			}
		}
		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 SqliteListener ) ((SqliteListener)listener).enterPragma_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_name(this);
		}
	}

	public final Pragma_nameContext pragma_name() throws RecognitionException {
		Pragma_nameContext _localctx = new Pragma_nameContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_pragma_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1224);
			any_name();
			}
		}
		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 SqliteListener ) ((SqliteListener)listener).enterSavepoint_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSavepoint_name(this);
		}
	}

	public final Savepoint_nameContext savepoint_name() throws RecognitionException {
		Savepoint_nameContext _localctx = new Savepoint_nameContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_savepoint_name);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1226);
			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 TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 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 SqliteListener ) ((SqliteListener)listener).enterTable_alias(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_alias(this);
		}
	}

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

	public static class Sqlite_type_nameContext extends ParserRuleContext {
		public TerminalNode K_INTEGER() { return getToken(SqliteParser.K_INTEGER, 0); }
		public TerminalNode K_REAL() { return getToken(SqliteParser.K_REAL, 0); }
		public TerminalNode K_TEXT() { return getToken(SqliteParser.K_TEXT, 0); }
		public TerminalNode K_BLOB() { return getToken(SqliteParser.K_BLOB, 0); }
		public Sqlite_type_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sqlite_type_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSqlite_type_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSqlite_type_name(this);
		}
	}

	public final Sqlite_type_nameContext sqlite_type_name() throws RecognitionException {
		Sqlite_type_nameContext _localctx = new Sqlite_type_nameContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_sqlite_type_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1230);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_INTEGER) | (1L << K_REAL) | (1L << K_TEXT) | (1L << K_BLOB))) != 0)) ) {
			_errHandler.recoverInline(this);
			} else {
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Java_type_nameContext extends ParserRuleContext {
		public TerminalNode K_JAVA_BOOLEAN() { return getToken(SqliteParser.K_JAVA_BOOLEAN, 0); }
		public TerminalNode K_JAVA_INTEGER() { return getToken(SqliteParser.K_JAVA_INTEGER, 0); }
		public TerminalNode K_JAVA_LONG() { return getToken(SqliteParser.K_JAVA_LONG, 0); }
		public TerminalNode K_JAVA_FLOAT() { return getToken(SqliteParser.K_JAVA_FLOAT, 0); }
		public TerminalNode K_JAVA_DOUBLE() { return getToken(SqliteParser.K_JAVA_DOUBLE, 0); }
		public TerminalNode K_JAVA_STRING() { return getToken(SqliteParser.K_JAVA_STRING, 0); }
		public TerminalNode K_JAVA_BYTE_ARRAY() { return getToken(SqliteParser.K_JAVA_BYTE_ARRAY, 0); }
		public Custom_typeContext custom_type() {
			return getRuleContext(Custom_typeContext.class,0);
		}
		public Java_type_nameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_java_type_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJava_type_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJava_type_name(this);
		}
	}

	public final Java_type_nameContext java_type_name() throws RecognitionException {
		Java_type_nameContext _localctx = new Java_type_nameContext(_ctx, getState());
		enterRule(_localctx, 144, RULE_java_type_name);
		try {
			setState(1240);
			switch (_input.LA(1)) {
			case K_JAVA_BOOLEAN:
				enterOuterAlt(_localctx, 1);
				{
				setState(1232);
				match(K_JAVA_BOOLEAN);
				}
				break;
			case K_JAVA_INTEGER:
				enterOuterAlt(_localctx, 2);
				{
				setState(1233);
				match(K_JAVA_INTEGER);
				}
				break;
			case K_JAVA_LONG:
				enterOuterAlt(_localctx, 3);
				{
				setState(1234);
				match(K_JAVA_LONG);
				}
				break;
			case K_JAVA_FLOAT:
				enterOuterAlt(_localctx, 4);
				{
				setState(1235);
				match(K_JAVA_FLOAT);
				}
				break;
			case K_JAVA_DOUBLE:
				enterOuterAlt(_localctx, 5);
				{
				setState(1236);
				match(K_JAVA_DOUBLE);
				}
				break;
			case K_JAVA_STRING:
				enterOuterAlt(_localctx, 6);
				{
				setState(1237);
				match(K_JAVA_STRING);
				}
				break;
			case K_JAVA_BYTE_ARRAY:
				enterOuterAlt(_localctx, 7);
				{
				setState(1238);
				match(K_JAVA_BYTE_ARRAY);
				}
				break;
			case IDENTIFIER:
				enterOuterAlt(_localctx, 8);
				{
				setState(1239);
				custom_type();
				}
				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 Custom_typeContext extends ParserRuleContext {
		public List java_type() {
			return getRuleContexts(Java_typeContext.class);
		}
		public Java_typeContext java_type(int i) {
			return getRuleContext(Java_typeContext.class,i);
		}
		public List java_type_name() {
			return getRuleContexts(Java_type_nameContext.class);
		}
		public Java_type_nameContext java_type_name(int i) {
			return getRuleContext(Java_type_nameContext.class,i);
		}
		public List java_type_name2() {
			return getRuleContexts(Java_type_name2Context.class);
		}
		public Java_type_name2Context java_type_name2(int i) {
			return getRuleContext(Java_type_name2Context.class,i);
		}
		public Custom_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_custom_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCustom_type(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCustom_type(this);
		}
	}

	public final Custom_typeContext custom_type() throws RecognitionException {
		Custom_typeContext _localctx = new Custom_typeContext(_ctx, getState());
		enterRule(_localctx, 146, RULE_custom_type);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1242);
			java_type();
			setState(1275);
			switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
			case 1:
				{
				{
				setState(1243);
				match(LT);
				setState(1244);
				java_type_name();
				setState(1249);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1245);
					match(COMMA);
					setState(1246);
					java_type_name();
					}
					}
					setState(1251);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1252);
				match(GT);
				}
				}
				break;
			case 2:
				{
				{
				setState(1254);
				match(LT);
				setState(1260);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,158,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(1255);
						java_type_name();
						setState(1256);
						match(COMMA);
						}
						} 
					}
					setState(1262);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,158,_ctx);
				}
				setState(1263);
				java_type();
				setState(1264);
				match(LT);
				setState(1265);
				java_type_name2();
				setState(1270);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(1266);
					match(COMMA);
					setState(1267);
					java_type_name2();
					}
					}
					setState(1272);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1273);
				match(GT2);
				}
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Java_type_name2Context extends ParserRuleContext {
		public Java_type_nameContext java_type_name() {
			return getRuleContext(Java_type_nameContext.class,0);
		}
		public Java_type_name2Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_java_type_name2; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJava_type_name2(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJava_type_name2(this);
		}
	}

	public final Java_type_name2Context java_type_name2() throws RecognitionException {
		Java_type_name2Context _localctx = new Java_type_name2Context(_ctx, getState());
		enterRule(_localctx, 148, RULE_java_type_name2);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1277);
			java_type_name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Java_typeContext extends ParserRuleContext {
		public List IDENTIFIER() { return getTokens(SqliteParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(SqliteParser.IDENTIFIER, i);
		}
		public Java_typeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_java_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJava_type(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJava_type(this);
		}
	}

	public final Java_typeContext java_type() throws RecognitionException {
		Java_typeContext _localctx = new Java_typeContext(_ctx, getState());
		enterRule(_localctx, 150, RULE_java_type);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1283);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,161,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(1279);
					match(IDENTIFIER);
					setState(1280);
					match(DOT);
					}
					} 
				}
				setState(1285);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,161,_ctx);
			}
			setState(1286);
			match(IDENTIFIER);
			}
		}
		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(SqliteParser.IDENTIFIER, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.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 SqliteListener ) ((SqliteListener)listener).enterAny_name(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitAny_name(this);
		}
	}

	public final Any_nameContext any_name() throws RecognitionException {
		Any_nameContext _localctx = new Any_nameContext(_ctx, getState());
		enterRule(_localctx, 152, RULE_any_name);
		try {
			setState(1294);
			switch (_input.LA(1)) {
			case IDENTIFIER:
				enterOuterAlt(_localctx, 1);
				{
				setState(1288);
				match(IDENTIFIER);
				}
				break;
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 2);
				{
				setState(1289);
				match(STRING_LITERAL);
				}
				break;
			case OPEN_PAR:
				enterOuterAlt(_localctx, 3);
				{
				setState(1290);
				match(OPEN_PAR);
				setState(1291);
				any_name();
				setState(1292);
				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 33:
			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\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u00ac\u0513\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\3\2\3\2\5\2\u009f\n\2\3\2\3\2\3\3\3"+
		"\3\3\4\7\4\u00a6\n\4\f\4\16\4\u00a9\13\4\3\4\3\4\3\4\5\4\u00ae\n\4\3\4"+
		"\3\4\3\4\7\4\u00b3\n\4\f\4\16\4\u00b6\13\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6"+
		"\3\6\3\6\5\6\u00c1\n\6\5\6\u00c3\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\5\6\u00d9\n\6\3\7\3\7\3"+
		"\7\3\7\3\7\3\7\3\7\3\7\5\7\u00e3\n\7\3\7\5\7\u00e6\n\7\3\b\3\b\3\b\3\t"+
		"\3\t\5\t\u00ed\n\t\3\t\3\t\3\t\3\t\5\t\u00f3\n\t\3\t\3\t\3\t\3\t\3\t\3"+
		"\t\3\t\7\t\u00fc\n\t\f\t\16\t\u00ff\13\t\3\t\3\t\3\t\5\t\u0104\n\t\3\n"+
		"\3\n\5\n\u0108\n\n\3\n\3\n\3\n\3\n\5\n\u010e\n\n\3\n\3\n\3\n\3\n\3\n\7"+
		"\n\u0115\n\n\f\n\16\n\u0118\13\n\3\n\3\n\7\n\u011c\n\n\f\n\16\n\u011f"+
		"\13\n\3\n\3\n\3\n\5\n\u0124\n\n\3\n\3\n\5\n\u0128\n\n\3\13\3\13\5\13\u012c"+
		"\n\13\3\13\3\13\3\13\3\13\5\13\u0132\n\13\3\13\3\13\3\13\3\13\3\13\5\13"+
		"\u0139\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u0142\n\13\f\13\16"+
		"\13\u0145\13\13\5\13\u0147\n\13\5\13\u0149\n\13\3\13\3\13\3\13\3\13\3"+
		"\13\5\13\u0150\n\13\3\13\3\13\5\13\u0154\n\13\3\13\3\13\3\13\3\13\3\13"+
		"\5\13\u015b\n\13\3\13\3\13\6\13\u015f\n\13\r\13\16\13\u0160\3\13\3\13"+
		"\3\f\3\f\5\f\u0167\n\f\3\f\3\f\3\f\3\f\5\f\u016d\n\f\3\f\3\f\3\f\3\f\3"+
		"\r\5\r\u0174\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u017b\n\r\3\16\5\16\u017e\n\16"+
		"\3\16\3\16\3\16\3\16\3\16\5\16\u0185\n\16\3\16\3\16\3\16\3\16\3\16\7\16"+
		"\u018c\n\16\f\16\16\16\u018f\13\16\5\16\u0191\n\16\3\16\3\16\3\16\3\16"+
		"\5\16\u0197\n\16\5\16\u0199\n\16\3\17\3\17\3\17\3\17\5\17\u019f\n\17\3"+
		"\17\3\17\3\20\3\20\3\20\3\20\5\20\u01a7\n\20\3\20\3\20\3\21\3\21\3\21"+
		"\3\21\5\21\u01af\n\21\3\21\3\21\3\22\3\22\3\22\3\22\5\22\u01b7\n\22\3"+
		"\22\3\22\3\23\5\23\u01bc\n\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
		"\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u01cf\n\23\3\23\3\23"+
		"\3\23\3\23\3\23\3\23\7\23\u01d7\n\23\f\23\16\23\u01da\13\23\3\23\3\23"+
		"\5\23\u01de\n\23\3\23\3\23\3\23\3\23\3\23\5\23\u01e5\n\23\3\24\3\24\3"+
		"\24\3\24\3\24\3\24\3\24\3\24\5\24\u01ef\n\24\3\25\3\25\3\25\3\25\5\25"+
		"\u01f5\n\25\5\25\u01f7\n\25\3\26\3\26\5\26\u01fb\n\26\3\26\3\26\3\27\3"+
		"\27\3\27\3\30\5\30\u0203\n\30\3\30\3\30\3\30\3\30\7\30\u0209\n\30\f\30"+
		"\16\30\u020c\13\30\3\30\3\30\3\30\3\30\3\30\7\30\u0213\n\30\f\30\16\30"+
		"\u0216\13\30\5\30\u0218\n\30\3\30\3\30\3\30\3\30\5\30\u021e\n\30\5\30"+
		"\u0220\n\30\3\31\3\31\5\31\u0224\n\31\3\31\3\31\3\31\7\31\u0229\n\31\f"+
		"\31\16\31\u022c\13\31\3\31\3\31\3\31\3\31\7\31\u0232\n\31\f\31\16\31\u0235"+
		"\13\31\3\31\5\31\u0238\n\31\5\31\u023a\n\31\3\31\3\31\5\31\u023e\n\31"+
		"\3\31\3\31\3\31\3\31\3\31\7\31\u0245\n\31\f\31\16\31\u0248\13\31\3\31"+
		"\5\31\u024b\n\31\5\31\u024d\n\31\3\31\3\31\5\31\u0251\n\31\3\32\3\32\3"+
		"\32\3\33\3\33\3\33\3\33\7\33\u025a\n\33\f\33\16\33\u025d\13\33\3\33\3"+
		"\33\3\33\5\33\u0262\n\33\3\34\5\34\u0265\n\34\3\34\3\34\3\34\3\34\3\34"+
		"\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u0272\n\34\3\34\3\34\3\34\3\34\3\34"+
		"\3\34\3\34\3\34\3\34\3\34\7\34\u027e\n\34\f\34\16\34\u0281\13\34\3\34"+
		"\3\34\5\34\u0285\n\34\3\35\5\35\u0288\n\35\3\35\3\35\3\35\3\35\3\35\3"+
		"\35\3\35\3\35\3\35\3\35\3\35\5\35\u0295\n\35\3\35\3\35\3\35\3\35\3\35"+
		"\3\35\3\35\3\35\3\35\3\35\7\35\u02a1\n\35\f\35\16\35\u02a4\13\35\3\35"+
		"\3\35\5\35\u02a8\n\35\3\35\3\35\3\35\3\35\3\35\7\35\u02af\n\35\f\35\16"+
		"\35\u02b2\13\35\5\35\u02b4\n\35\3\35\3\35\3\35\3\35\5\35\u02ba\n\35\5"+
		"\35\u02bc\n\35\3\36\3\36\3\37\3\37\3\37\7\37\u02c3\n\37\f\37\16\37\u02c6"+
		"\13\37\3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5 \u02d3\n \3 \3 \5 \u02d7\n "+
		"\3!\3!\5!\u02db\n!\3!\3!\5!\u02df\n!\3!\3!\5!\u02e3\n!\3!\5!\u02e6\n!"+
		"\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u02f8\n!\3!\3!\3!"+
		"\5!\u02fd\n!\3\"\3\"\3\"\5\"\u0302\n\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u030d"+
		"\n#\3#\3#\3#\3#\5#\u0313\n#\3#\3#\3#\7#\u0318\n#\f#\16#\u031b\13#\3#\5"+
		"#\u031e\n#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u032e\n#\3#\5"+
		"#\u0331\n#\3#\3#\3#\3#\3#\3#\5#\u0339\n#\3#\3#\3#\3#\3#\6#\u0340\n#\r"+
		"#\16#\u0341\3#\3#\5#\u0346\n#\3#\3#\3#\5#\u034b\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#\5#\u0368"+
		"\n#\3#\3#\3#\5#\u036d\n#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0379\n#\3#"+
		"\3#\3#\3#\5#\u037f\n#\3#\3#\3#\3#\3#\5#\u0386\n#\3#\3#\5#\u038a\n#\3#"+
		"\3#\3#\3#\3#\3#\7#\u0392\n#\f#\16#\u0395\13#\5#\u0397\n#\3#\3#\5#\u039b"+
		"\n#\7#\u039d\n#\f#\16#\u03a0\13#\3$\3$\3%\3%\3%\3%\3%\3%\7%\u03aa\n%\f"+
		"%\16%\u03ad\13%\3%\3%\5%\u03b1\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u03bd"+
		"\n%\3%\3%\5%\u03c1\n%\7%\u03c3\n%\f%\16%\u03c6\13%\3%\5%\u03c9\n%\3%\3"+
		"%\3%\3%\3%\5%\u03d0\n%\5%\u03d2\n%\3&\3&\3&\3&\3&\3&\5&\u03da\n&\3&\3"+
		"&\3\'\3\'\3\'\5\'\u03e1\n\'\3\'\5\'\u03e4\n\'\3(\3(\5(\u03e8\n(\3(\3("+
		"\3(\3(\3(\7(\u03ef\n(\f(\16(\u03f2\13(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3"+
		"(\3(\3(\7(\u0401\n(\f(\16(\u0404\13(\3(\3(\3(\5(\u0409\n(\3)\3)\5)\u040d"+
		"\n)\3)\3)\3)\7)\u0412\n)\f)\16)\u0415\13)\3*\3*\3*\3*\3*\3*\5*\u041d\n"+
		"*\3+\3+\3+\5+\u0422\n+\3+\5+\u0425\n+\3,\3,\3,\5,\u042a\n,\3-\3-\3-\3"+
		"-\3-\7-\u0431\n-\f-\16-\u0434\13-\3-\3-\5-\u0438\n-\3-\3-\3-\3-\3-\3."+
		"\3.\3.\3.\3.\3.\3.\5.\u0446\n.\3.\5.\u0449\n.\5.\u044b\n.\3/\3/\5/\u044f"+
		"\n/\3/\5/\u0452\n/\3/\3/\3/\3/\3/\5/\u0459\n/\3/\3/\3/\3/\7/\u045f\n/"+
		"\f/\16/\u0462\13/\3/\5/\u0465\n/\3/\3/\3/\3/\3/\3/\5/\u046d\n/\3/\5/\u0470"+
		"\n/\5/\u0472\n/\3\60\3\60\3\60\3\60\3\60\7\60\u0479\n\60\f\60\16\60\u047c"+
		"\13\60\3\61\3\61\5\61\u0480\n\61\3\61\3\61\5\61\u0484\n\61\3\61\3\61\5"+
		"\61\u0488\n\61\3\61\5\61\u048b\n\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62"+
		"\7\62\u0494\n\62\f\62\16\62\u0497\13\62\3\62\3\62\5\62\u049b\n\62\3\63"+
		"\3\63\3\63\3\63\3\63\5\63\u04a2\n\63\3\64\5\64\u04a5\n\64\3\64\3\64\3"+
		"\65\3\65\3\66\3\66\3\67\3\67\38\38\39\39\3:\3:\3;\3;\3<\3<\3=\3=\3>\3"+
		">\3?\3?\3@\3@\3A\3A\3B\3B\3C\3C\3D\3D\3E\3E\3F\3F\3G\3G\3H\3H\3I\3I\3"+
		"J\3J\3J\3J\3J\3J\3J\3J\5J\u04db\nJ\3K\3K\3K\3K\3K\7K\u04e2\nK\fK\16K\u04e5"+
		"\13K\3K\3K\3K\3K\3K\3K\7K\u04ed\nK\fK\16K\u04f0\13K\3K\3K\3K\3K\3K\7K"+
		"\u04f7\nK\fK\16K\u04fa\13K\3K\3K\5K\u04fe\nK\3L\3L\3M\3M\7M\u0504\nM\f"+
		"M\16M\u0507\13M\3M\3M\3N\3N\3N\3N\3N\3N\5N\u0511\nN\3N\2\3DO\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\2\26\3\2\u0092\u0093\4\2\23\23yy\4\2,,"+
		"MM\4\2\61\61KK\7\2((WW``\u0089\u0089\u008c\u008c\4\2\25\25\32\33\3\2\26"+
		"\27\3\2\34\37\3\2 #\4\2\24\24$&\6\2\\\\pprr\u0085\u0085\4\2JJ\u009a\u009a"+
		"\5\2((WW\u008c\u008c\4\2\u0080\u0080\u0099\u0099\3\2\u00a4\u00a5\6\2C"+
		"Eww\u00a4\u00a5\u00a7\u00a8\4\2\26\30uu\4\2\4\16(\u00a2\4\2\u00a3\u00a3"+
		"\u00a7\u00a7\3\2\13\16\u05c4\2\u009e\3\2\2\2\4\u00a2\3\2\2\2\6\u00a7\3"+
		"\2\2\2\b\u00b7\3\2\2\2\n\u00bb\3\2\2\2\f\u00da\3\2\2\2\16\u00e7\3\2\2"+
		"\2\20\u00ea\3\2\2\2\22\u0105\3\2\2\2\24\u0129\3\2\2\2\26\u0164\3\2\2\2"+
		"\30\u0173\3\2\2\2\32\u017d\3\2\2\2\34\u019a\3\2\2\2\36\u01a2\3\2\2\2 "+
		"\u01aa\3\2\2\2\"\u01b2\3\2\2\2$\u01bb\3\2\2\2&\u01e6\3\2\2\2(\u01f0\3"+
		"\2\2\2*\u01f8\3\2\2\2,\u01fe\3\2\2\2.\u0202\3\2\2\2\60\u0250\3\2\2\2\62"+
		"\u0252\3\2\2\2\64\u0255\3\2\2\2\66\u0264\3\2\2\28\u0287\3\2\2\2:\u02bd"+
		"\3\2\2\2<\u02bf\3\2\2\2>\u02c7\3\2\2\2@\u02da\3\2\2\2B\u0301\3\2\2\2D"+
		"\u034a\3\2\2\2F\u03a1\3\2\2\2H\u03a3\3\2\2\2J\u03d3\3\2\2\2L\u03dd\3\2"+
		"\2\2N\u03e7\3\2\2\2P\u040a\3\2\2\2R\u0416\3\2\2\2T\u041e\3\2\2\2V\u0429"+
		"\3\2\2\2X\u042b\3\2\2\2Z\u044a\3\2\2\2\\\u0471\3\2\2\2^\u0473\3\2\2\2"+
		"`\u048a\3\2\2\2b\u049a\3\2\2\2d\u04a1\3\2\2\2f\u04a4\3\2\2\2h\u04a8\3"+
		"\2\2\2j\u04aa\3\2\2\2l\u04ac\3\2\2\2n\u04ae\3\2\2\2p\u04b0\3\2\2\2r\u04b2"+
		"\3\2\2\2t\u04b4\3\2\2\2v\u04b6\3\2\2\2x\u04b8\3\2\2\2z\u04ba\3\2\2\2|"+
		"\u04bc\3\2\2\2~\u04be\3\2\2\2\u0080\u04c0\3\2\2\2\u0082\u04c2\3\2\2\2"+
		"\u0084\u04c4\3\2\2\2\u0086\u04c6\3\2\2\2\u0088\u04c8\3\2\2\2\u008a\u04ca"+
		"\3\2\2\2\u008c\u04cc\3\2\2\2\u008e\u04ce\3\2\2\2\u0090\u04d0\3\2\2\2\u0092"+
		"\u04da\3\2\2\2\u0094\u04dc\3\2\2\2\u0096\u04ff\3\2\2\2\u0098\u0505\3\2"+
		"\2\2\u009a\u0510\3\2\2\2\u009c\u009f\5\6\4\2\u009d\u009f\5\4\3\2\u009e"+
		"\u009c\3\2\2\2\u009e\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a1\7\2"+
		"\2\3\u00a1\3\3\2\2\2\u00a2\u00a3\7\u00ac\2\2\u00a3\5\3\2\2\2\u00a4\u00a6"+
		"\5\b\5\2\u00a5\u00a4\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a7"+
		"\u00a8\3\2\2\2\u00a8\u00ad\3\2\2\2\u00a9\u00a7\3\2\2\2\u00aa\u00ab\5\22"+
		"\n\2\u00ab\u00ac\7\17\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00aa\3\2\2\2\u00ad"+
		"\u00ae\3\2\2\2\u00ae\u00b4\3\2\2\2\u00af\u00b0\5\n\6\2\u00b0\u00b1\7\17"+
		"\2\2\u00b1\u00b3\3\2\2\2\u00b2\u00af\3\2\2\2\u00b3\u00b6\3\2\2\2\u00b4"+
		"\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\7\3\2\2\2\u00b6\u00b4\3\2\2\2"+
		"\u00b7\u00b8\7b\2\2\u00b8\u00b9\5\u0092J\2\u00b9\u00ba\7\17\2\2\u00ba"+
		"\t\3\2\2\2\u00bb\u00bc\5~@\2\u00bc\u00c2\7\3\2\2\u00bd\u00c0\7V\2\2\u00be"+
		"\u00bf\7\u0081\2\2\u00bf\u00c1\7~\2\2\u00c0\u00be\3\2\2\2\u00c0\u00c1"+
		"\3\2\2\2\u00c1\u00c3\3\2\2\2\u00c2\u00bd\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3"+
		"\u00d8\3\2\2\2\u00c4\u00d9\5\f\7\2\u00c5\u00d9\5\16\b\2\u00c6\u00d9\5"+
		"\20\t\2\u00c7\u00d9\5\24\13\2\u00c8\u00d9\5\26\f\2\u00c9\u00d9\5\30\r"+
		"\2\u00ca\u00d9\5\32\16\2\u00cb\u00d9\5\34\17\2\u00cc\u00d9\5\36\20\2\u00cd"+
		"\u00d9\5 \21\2\u00ce\u00d9\5\"\22\2\u00cf\u00d9\5$\23\2\u00d0\u00d9\5"+
		"&\24\2\u00d1\u00d9\5(\25\2\u00d2\u00d9\5*\26\2\u00d3\u00d9\5,\27\2\u00d4"+
		"\u00d9\5.\30\2\u00d5\u00d9\5\66\34\2\u00d6\u00d9\58\35\2\u00d7\u00d9\5"+
		":\36\2\u00d8\u00c4\3\2\2\2\u00d8\u00c5\3\2\2\2\u00d8\u00c6\3\2\2\2\u00d8"+
		"\u00c7\3\2\2\2\u00d8\u00c8\3\2\2\2\u00d8\u00c9\3\2\2\2\u00d8\u00ca\3\2"+
		"\2\2\u00d8\u00cb\3\2\2\2\u00d8\u00cc\3\2\2\2\u00d8\u00cd\3\2\2\2\u00d8"+
		"\u00ce\3\2\2\2\u00d8\u00cf\3\2\2\2\u00d8\u00d0\3\2\2\2\u00d8\u00d1\3\2"+
		"\2\2\u00d8\u00d2\3\2\2\2\u00d8\u00d3\3\2\2\2\u00d8\u00d4\3\2\2\2\u00d8"+
		"\u00d5\3\2\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d7\3\2\2\2\u00d9\13\3\2\2"+
		"\2\u00da\u00db\7-\2\2\u00db\u00dc\7\u0091\2\2\u00dc\u00e5\5v<\2\u00dd"+
		"\u00de\7\u0088\2\2\u00de\u00df\7\u0095\2\2\u00df\u00e6\5z>\2\u00e0\u00e2"+
		"\7*\2\2\u00e1\u00e3\7=\2\2\u00e2\u00e1\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3"+
		"\u00e4\3\2\2\2\u00e4\u00e6\5<\37\2\u00e5\u00dd\3\2\2\2\u00e5\u00e0\3\2"+
		"\2\2\u00e6\r\3\2\2\2\u00e7\u00e8\7.\2\2\u00e8\u00e9\5x=\2\u00e9\17\3\2"+
		"\2\2\u00ea\u00ec\7A\2\2\u00eb\u00ed\7\u0099\2\2\u00ec\u00eb\3\2\2\2\u00ec"+
		"\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00f2\7d\2\2\u00ef\u00f0\7_\2"+
		"\2\u00f0\u00f1\7u\2\2\u00f1\u00f3\7U\2\2\u00f2\u00ef\3\2\2\2\u00f2\u00f3"+
		"\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\5\u0084C\2\u00f5\u00f6\7z\2\2"+
		"\u00f6\u00f7\5v<\2\u00f7\u00f8\7\21\2\2\u00f8\u00fd\5L\'\2\u00f9\u00fa"+
		"\7\23\2\2\u00fa\u00fc\5L\'\2\u00fb\u00f9\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd"+
		"\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0100\3\2\2\2\u00ff\u00fd\3\2"+
		"\2\2\u0100\u0103\7\22\2\2\u0101\u0102\7\u00a0\2\2\u0102\u0104\5D#\2\u0103"+
		"\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\21\3\2\2\2\u0105\u0107\7A\2\2"+
		"\u0106\u0108\t\2\2\2\u0107\u0106\3\2\2\2\u0107\u0108\3\2\2\2\u0108\u0109"+
		"\3\2\2\2\u0109\u010d\7\u0091\2\2\u010a\u010b\7_\2\2\u010b\u010c\7u\2\2"+
		"\u010c\u010e\7U\2\2\u010d\u010a\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u010f"+
		"\3\2\2\2\u010f\u0127\5v<\2\u0110\u0111\7\21\2\2\u0111\u0116\5<\37\2\u0112"+
		"\u0113\7\23\2\2\u0113\u0115\5<\37\2\u0114\u0112\3\2\2\2\u0115\u0118\3"+
		"\2\2\2\u0116\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u011d\3\2\2\2\u0118"+
		"\u0116\3\2\2\2\u0119\u011a\7\23\2\2\u011a\u011c\5N(\2\u011b\u0119\3\2"+
		"\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+
		"\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0123\7\22\2\2\u0121\u0122\7"+
		"\u00a2\2\2\u0122\u0124\7\u00a3\2\2\u0123\u0121\3\2\2\2\u0123\u0124\3\2"+
		"\2\2\u0124\u0128\3\2\2\2\u0125\u0126\7\60\2\2\u0126\u0128\5.\30\2\u0127"+
		"\u0110\3\2\2\2\u0127\u0125\3\2\2\2\u0128\23\3\2\2\2\u0129\u012b\7A\2\2"+
		"\u012a\u012c\t\2\2\2\u012b\u012a\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012d"+
		"\3\2\2\2\u012d\u0131\7\u0097\2\2\u012e\u012f\7_\2\2\u012f\u0130\7u\2\2"+
		"\u0130\u0132\7U\2\2\u0131\u012e\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133"+
		"\3\2\2\2\u0133\u0138\5\u0086D\2\u0134\u0139\7\64\2\2\u0135\u0139\7+\2"+
		"\2\u0136\u0137\7i\2\2\u0137\u0139\7x\2\2\u0138\u0134\3\2\2\2\u0138\u0135"+
		"\3\2\2\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u0148\3\2\2\2\u013a"+
		"\u0149\7J\2\2\u013b\u0149\7h\2\2\u013c\u0146\7\u009a\2\2\u013d\u013e\7"+
		"x\2\2\u013e\u0143\5|?\2\u013f\u0140\7\23\2\2\u0140\u0142\5|?\2\u0141\u013f"+
		"\3\2\2\2\u0142\u0145\3\2\2\2\u0143\u0141\3\2\2\2\u0143\u0144\3\2\2\2\u0144"+
		"\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0146\u013d\3\2\2\2\u0146\u0147\3\2"+
		"\2\2\u0147\u0149\3\2\2\2\u0148\u013a\3\2\2\2\u0148\u013b\3\2\2\2\u0148"+
		"\u013c\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014b\7z\2\2\u014b\u014f\5v<"+
		"\2\u014c\u014d\7X\2\2\u014d\u014e\7O\2\2\u014e\u0150\7\u008d\2\2\u014f"+
		"\u014c\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0153\3\2\2\2\u0151\u0152\7\u009f"+
		"\2\2\u0152\u0154\5D#\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0155"+
		"\3\2\2\2\u0155\u015e\7\65\2\2\u0156\u015b\5\66\34\2\u0157\u015b\5$\23"+
		"\2\u0158\u015b\5\30\r\2\u0159\u015b\5.\30\2\u015a\u0156\3\2\2\2\u015a"+
		"\u0157\3\2\2\2\u015a\u0158\3\2\2\2\u015a\u0159\3\2\2\2\u015b\u015c\3\2"+
		"\2\2\u015c\u015d\7\17\2\2\u015d\u015f\3\2\2\2\u015e\u015a\3\2\2\2\u015f"+
		"\u0160\3\2\2\2\u0160\u015e\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0162\3\2"+
		"\2\2\u0162\u0163\7Q\2\2\u0163\25\3\2\2\2\u0164\u0166\7A\2\2\u0165\u0167"+
		"\t\2\2\2\u0166\u0165\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\3\2\2\2\u0168"+
		"\u016c\7\u009e\2\2\u0169\u016a\7_\2\2\u016a\u016b\7u\2\2\u016b\u016d\7"+
		"U\2\2\u016c\u0169\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e"+
		"\u016f\5\u0088E\2\u016f\u0170\7\60\2\2\u0170\u0171\5.\30\2\u0171\27\3"+
		"\2\2\2\u0172\u0174\5P)\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174"+
		"\u0175\3\2\2\2\u0175\u0176\7J\2\2\u0176\u0177\7Z\2\2\u0177\u017a\5v<\2"+
		"\u0178\u0179\7\u00a0\2\2\u0179\u017b\5D#\2\u017a\u0178\3\2\2\2\u017a\u017b"+
		"\3\2\2\2\u017b\31\3\2\2\2\u017c\u017e\5P)\2\u017d\u017c\3\2\2\2\u017d"+
		"\u017e\3\2\2\2\u017e\u017f\3\2\2\2\u017f\u0180\7J\2\2\u0180\u0181\7Z\2"+
		"\2\u0181\u0184\5R*\2\u0182\u0183\7\u00a0\2\2\u0183\u0185\5D#\2\u0184\u0182"+
		"\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0198\3\2\2\2\u0186\u0187\7|\2\2\u0187"+
		"\u0188\7\67\2\2\u0188\u018d\5T+\2\u0189\u018a\7\23\2\2\u018a\u018c\5T"+
		"+\2\u018b\u0189\3\2\2\2\u018c\u018f\3\2\2\2\u018d\u018b\3\2\2\2\u018d"+
		"\u018e\3\2\2\2\u018e\u0191\3\2\2\2\u018f\u018d\3\2\2\2\u0190\u0186\3\2"+
		"\2\2\u0190\u0191\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193\7q\2\2\u0193"+
		"\u0196\5D#\2\u0194\u0195\t\3\2\2\u0195\u0197\5D#\2\u0196\u0194\3\2\2\2"+
		"\u0196\u0197\3\2\2\2\u0197\u0199\3\2\2\2\u0198\u0190\3\2\2\2\u0198\u0199"+
		"\3\2\2\2\u0199\33\3\2\2\2\u019a\u019b\7N\2\2\u019b\u019e\7d\2\2\u019c"+
		"\u019d\7_\2\2\u019d\u019f\7U\2\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2"+
		"\2\u019f\u01a0\3\2\2\2\u01a0\u01a1\5\u0084C\2\u01a1\35\3\2\2\2\u01a2\u01a3"+
		"\7N\2\2\u01a3\u01a6\7\u0091\2\2\u01a4\u01a5\7_\2\2\u01a5\u01a7\7U\2\2"+
		"\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8\u01a9"+
		"\5v<\2\u01a9\37\3\2\2\2\u01aa\u01ab\7N\2\2\u01ab\u01ae\7\u0097\2\2\u01ac"+
		"\u01ad\7_\2\2\u01ad\u01af\7U\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01af\3\2\2"+
		"\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\5\u0086D\2\u01b1!\3\2\2\2\u01b2\u01b3"+
		"\7N\2\2\u01b3\u01b6\7\u009e\2\2\u01b4\u01b5\7_\2\2\u01b5\u01b7\7U\2\2"+
		"\u01b6\u01b4\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b9"+
		"\5\u0088E\2\u01b9#\3\2\2\2\u01ba\u01bc\5P)\2\u01bb\u01ba\3\2\2\2\u01bb"+
		"\u01bc\3\2\2\2\u01bc\u01ce\3\2\2\2\u01bd\u01cf\7h\2\2\u01be\u01cf\7\u0089"+
		"\2\2\u01bf\u01c0\7h\2\2\u01c0\u01c1\7{\2\2\u01c1\u01cf\7\u0089\2\2\u01c2"+
		"\u01c3\7h\2\2\u01c3\u01c4\7{\2\2\u01c4\u01cf\7\u008c\2\2\u01c5\u01c6\7"+
		"h\2\2\u01c6\u01c7\7{\2\2\u01c7\u01cf\7(\2\2\u01c8\u01c9\7h\2\2\u01c9\u01ca"+
		"\7{\2\2\u01ca\u01cf\7W\2\2\u01cb\u01cc\7h\2\2\u01cc\u01cd\7{\2\2\u01cd"+
		"\u01cf\7`\2\2\u01ce\u01bd\3\2\2\2\u01ce\u01be\3\2\2\2\u01ce\u01bf\3\2"+
		"\2\2\u01ce\u01c2\3\2\2\2\u01ce\u01c5\3\2\2\2\u01ce\u01c8\3\2\2\2\u01ce"+
		"\u01cb\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d1\7k\2\2\u01d1\u01dd\5v<"+
		"\2\u01d2\u01d3\7\21\2\2\u01d3\u01d8\5|?\2\u01d4\u01d5\7\23\2\2\u01d5\u01d7"+
		"\5|?\2\u01d6\u01d4\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8"+
		"\u01d9\3\2\2\2\u01d9\u01db\3\2\2\2\u01da\u01d8\3\2\2\2\u01db\u01dc\7\22"+
		"\2\2\u01dc\u01de\3\2\2\2\u01dd\u01d2\3\2\2\2\u01dd\u01de\3\2\2\2\u01de"+
		"\u01e4\3\2\2\2\u01df\u01e0\7\u009d\2\2\u01e0\u01e5\5\64\33\2\u01e1\u01e5"+
		"\5.\30\2\u01e2\u01e3\7G\2\2\u01e3\u01e5\7\u009d\2\2\u01e4\u01df\3\2\2"+
		"\2\u01e4\u01e1\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5%\3\2\2\2\u01e6\u01e7"+
		"\7\177\2\2\u01e7\u01ee\5\u008aF\2\u01e8\u01e9\7\24\2\2\u01e9\u01ef\5V"+
		",\2\u01ea\u01eb\7\21\2\2\u01eb\u01ec\5V,\2\u01ec\u01ed\7\22\2\2\u01ed"+
		"\u01ef\3\2\2\2\u01ee\u01e8\3\2\2\2\u01ee\u01ea\3\2\2\2\u01ee\u01ef\3\2"+
		"\2\2\u01ef\'\3\2\2\2\u01f0\u01f6\7\u0086\2\2\u01f1\u01f7\5\u0080A\2\u01f2"+
		"\u01f5\5v<\2\u01f3\u01f5\5\u0084C\2\u01f4\u01f2\3\2\2\2\u01f4\u01f3\3"+
		"\2\2\2\u01f5\u01f7\3\2\2\2\u01f6\u01f1\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f6"+
		"\u01f7\3\2\2\2\u01f7)\3\2\2\2\u01f8\u01fa\7\u0087\2\2\u01f9\u01fb\7\u008e"+
		"\2\2\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc"+
		"\u01fd\5\u008cG\2\u01fd+\3\2\2\2\u01fe\u01ff\7\u008e\2\2\u01ff\u0200\5"+
		"\u008cG\2\u0200-\3\2\2\2\u0201\u0203\5P)\2\u0202\u0201\3\2\2\2\u0202\u0203"+
		"\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u020a\5\60\31\2\u0205\u0206\5d\63\2"+
		"\u0206\u0207\5\60\31\2\u0207\u0209\3\2\2\2\u0208\u0205\3\2\2\2\u0209\u020c"+
		"\3\2\2\2\u020a\u0208\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u0217\3\2\2\2\u020c"+
		"\u020a\3\2\2\2\u020d\u020e\7|\2\2\u020e\u020f\7\67\2\2\u020f\u0214\5T"+
		"+\2\u0210\u0211\7\23\2\2\u0211\u0213\5T+\2\u0212\u0210\3\2\2\2\u0213\u0216"+
		"\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0218\3\2\2\2\u0216"+
		"\u0214\3\2\2\2\u0217\u020d\3\2\2\2\u0217\u0218\3\2\2\2\u0218\u021f\3\2"+
		"\2\2\u0219\u021a\7q\2\2\u021a\u021d\5D#\2\u021b\u021c\t\3\2\2\u021c\u021e"+
		"\5D#\2\u021d\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u0220\3\2\2\2\u021f"+
		"\u0219\3\2\2\2\u021f\u0220\3\2\2\2\u0220/\3\2\2\2\u0221\u0223\7\u008f"+
		"\2\2\u0222\u0224\t\4\2\2\u0223\u0222\3\2\2\2\u0223\u0224\3\2\2\2\u0224"+
		"\u0225\3\2\2\2\u0225\u022a\5Z.\2\u0226\u0227\7\23\2\2\u0227\u0229\5Z."+
		"\2\u0228\u0226\3\2\2\2\u0229\u022c\3\2\2\2\u022a\u0228\3\2\2\2\u022a\u022b"+
		"\3\2\2\2\u022b\u0239\3\2\2\2\u022c\u022a\3\2\2\2\u022d\u0237\7Z\2\2\u022e"+
		"\u0233\5\\/\2\u022f\u0230\7\23\2\2\u0230\u0232\5\\/\2\u0231\u022f\3\2"+
		"\2\2\u0232\u0235\3\2\2\2\u0233\u0231\3\2\2\2\u0233\u0234\3\2\2\2\u0234"+
		"\u0238\3\2\2\2\u0235\u0233\3\2\2\2\u0236\u0238\5^\60\2\u0237\u022e\3\2"+
		"\2\2\u0237\u0236\3\2\2\2\u0238\u023a\3\2\2\2\u0239\u022d\3\2\2\2\u0239"+
		"\u023a\3\2\2\2\u023a\u023d\3\2\2\2\u023b\u023c\7\u00a0\2\2\u023c\u023e"+
		"\5D#\2\u023d\u023b\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u024c\3\2\2\2\u023f"+
		"\u0240\7]\2\2\u0240\u0241\7\67\2\2\u0241\u0246\5D#\2\u0242\u0243\7\23"+
		"\2\2\u0243\u0245\5D#\2\u0244\u0242\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244"+
		"\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u024a\3\2\2\2\u0248\u0246\3\2\2\2\u0249"+
		"\u024b\5\62\32\2\u024a\u0249\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u024d\3"+
		"\2\2\2\u024c\u023f\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u0251\3\2\2\2\u024e"+
		"\u024f\7\u009d\2\2\u024f\u0251\5\64\33\2\u0250\u0221\3\2\2\2\u0250\u024e"+
		"\3\2\2\2\u0251\61\3\2\2\2\u0252\u0253\7^\2\2\u0253\u0254\5D#\2\u0254\63"+
		"\3\2\2\2\u0255\u0256\7\21\2\2\u0256\u025b\5D#\2\u0257\u0258\7\23\2\2\u0258"+
		"\u025a\5D#\2\u0259\u0257\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2"+
		"\2\u025b\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u0261"+
		"\7\22\2\2\u025f\u0260\7\23\2\2\u0260\u0262\5\64\33\2\u0261\u025f\3\2\2"+
		"\2\u0261\u0262\3\2\2\2\u0262\65\3\2\2\2\u0263\u0265\5P)\2\u0264\u0263"+
		"\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0266\3\2\2\2\u0266\u0271\7\u009a\2"+
		"\2\u0267\u0268\7{\2\2\u0268\u0272\7\u008c\2\2\u0269\u026a\7{\2\2\u026a"+
		"\u0272\7(\2\2\u026b\u026c\7{\2\2\u026c\u0272\7\u0089\2\2\u026d\u026e\7"+
		"{\2\2\u026e\u0272\7W\2\2\u026f\u0270\7{\2\2\u0270\u0272\7`\2\2\u0271\u0267"+
		"\3\2\2\2\u0271\u0269\3\2\2\2\u0271\u026b\3\2\2\2\u0271\u026d\3\2\2\2\u0271"+
		"\u026f\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0274\5v"+
		"<\2\u0274\u0275\7\u0090\2\2\u0275\u0276\5|?\2\u0276\u0277\7\24\2\2\u0277"+
		"\u027f\5D#\2\u0278\u0279\7\23\2\2\u0279\u027a\5|?\2\u027a\u027b\7\24\2"+
		"\2\u027b\u027c\5D#\2\u027c\u027e\3\2\2\2\u027d\u0278\3\2\2\2\u027e\u0281"+
		"\3\2\2\2\u027f\u027d\3\2\2\2\u027f\u0280\3\2\2\2\u0280\u0284\3\2\2\2\u0281"+
		"\u027f\3\2\2\2\u0282\u0283\7\u00a0\2\2\u0283\u0285\5D#\2\u0284\u0282\3"+
		"\2\2\2\u0284\u0285\3\2\2\2\u0285\67\3\2\2\2\u0286\u0288\5P)\2\u0287\u0286"+
		"\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u0289\3\2\2\2\u0289\u0294\7\u009a\2"+
		"\2\u028a\u028b\7{\2\2\u028b\u0295\7\u008c\2\2\u028c\u028d\7{\2\2\u028d"+
		"\u0295\7(\2\2\u028e\u028f\7{\2\2\u028f\u0295\7\u0089\2\2\u0290\u0291\7"+
		"{\2\2\u0291\u0295\7W\2\2\u0292\u0293\7{\2\2\u0293\u0295\7`\2\2\u0294\u028a"+
		"\3\2\2\2\u0294\u028c\3\2\2\2\u0294\u028e\3\2\2\2\u0294\u0290\3\2\2\2\u0294"+
		"\u0292\3\2\2\2\u0294\u0295\3\2\2\2\u0295\u0296\3\2\2\2\u0296\u0297\5R"+
		"*\2\u0297\u0298\7\u0090\2\2\u0298\u0299\5|?\2\u0299\u029a\7\24\2\2\u029a"+
		"\u02a2\5D#\2\u029b\u029c\7\23\2\2\u029c\u029d\5|?\2\u029d\u029e\7\24\2"+
		"\2\u029e\u029f\5D#\2\u029f\u02a1\3\2\2\2\u02a0\u029b\3\2\2\2\u02a1\u02a4"+
		"\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a2\u02a3\3\2\2\2\u02a3\u02a7\3\2\2\2\u02a4"+
		"\u02a2\3\2\2\2\u02a5\u02a6\7\u00a0\2\2\u02a6\u02a8\5D#\2\u02a7\u02a5\3"+
		"\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02bb\3\2\2\2\u02a9\u02aa\7|\2\2\u02aa"+
		"\u02ab\7\67\2\2\u02ab\u02b0\5T+\2\u02ac\u02ad\7\23\2\2\u02ad\u02af\5T"+
		"+\2\u02ae\u02ac\3\2\2\2\u02af\u02b2\3\2\2\2\u02b0\u02ae\3\2\2\2\u02b0"+
		"\u02b1\3\2\2\2\u02b1\u02b4\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b3\u02a9\3\2"+
		"\2\2\u02b3\u02b4\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5\u02b6\7q\2\2\u02b6"+
		"\u02b9\5D#\2\u02b7\u02b8\t\3\2\2\u02b8\u02ba\5D#\2\u02b9\u02b7\3\2\2\2"+
		"\u02b9\u02ba\3\2\2\2\u02ba\u02bc\3\2\2\2\u02bb\u02b3\3\2\2\2\u02bb\u02bc"+
		"\3\2\2\2\u02bc9\3\2\2\2\u02bd\u02be\7\u009c\2\2\u02be;\3\2\2\2\u02bf\u02c0"+
		"\5|?\2\u02c0\u02c4\5> \2\u02c1\u02c3\5@!\2\u02c2\u02c1\3\2\2\2\u02c3\u02c6"+
		"\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5=\3\2\2\2\u02c6"+
		"\u02c4\3\2\2\2\u02c7\u02d2\5\u0090I\2\u02c8\u02c9\7\21\2\2\u02c9\u02ca"+
		"\5f\64\2\u02ca\u02cb\7\22\2\2\u02cb\u02d3\3\2\2\2\u02cc\u02cd\7\21\2\2"+
		"\u02cd\u02ce\5f\64\2\u02ce\u02cf\7\23\2\2\u02cf\u02d0\5f\64\2\u02d0\u02d1"+
		"\7\22\2\2\u02d1\u02d3\3\2\2\2\u02d2\u02c8\3\2\2\2\u02d2\u02cc\3\2\2\2"+
		"\u02d2\u02d3\3\2\2\2\u02d3\u02d6\3\2\2\2\u02d4\u02d5\7\60\2\2\u02d5\u02d7"+
		"\5\u0092J\2\u02d6\u02d4\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7?\3\2\2\2\u02d8"+
		"\u02d9\7@\2\2\u02d9\u02db\5r:\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2"+
		"\2\u02db\u02fc\3\2\2\2\u02dc\u02de\7\u0080\2\2\u02dd\u02df\t\5\2\2\u02de"+
		"\u02dd\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e2\5B"+
		"\"\2\u02e1\u02e3\7\63\2\2\u02e2\u02e1\3\2\2\2\u02e2\u02e3\3\2\2\2\u02e3"+
		"\u02fd\3\2\2\2\u02e4\u02e6\7u\2\2\u02e5\u02e4\3\2\2\2\u02e5\u02e6\3\2"+
		"\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\7w\2\2\u02e8\u02fd\5B\"\2\u02e9\u02ea"+
		"\7\u0099\2\2\u02ea\u02fd\5B\"\2\u02eb\u02ec\7;\2\2\u02ec\u02ed\7\21\2"+
		"\2\u02ed\u02ee\5D#\2\u02ee\u02ef\7\22\2\2\u02ef\u02fd\3\2\2\2\u02f0\u02f7"+
		"\7G\2\2\u02f1\u02f8\5f\64\2\u02f2\u02f8\5h\65\2\u02f3\u02f4\7\21\2\2\u02f4"+
		"\u02f5\5D#\2\u02f5\u02f6\7\22\2\2\u02f6\u02f8\3\2\2\2\u02f7\u02f1\3\2"+
		"\2\2\u02f7\u02f2\3\2\2\2\u02f7\u02f3\3\2\2\2\u02f8\u02fd\3\2\2\2\u02f9"+
		"\u02fa\7<\2\2\u02fa\u02fd\5\u0080A\2\u02fb\u02fd\5H%\2\u02fc\u02dc\3\2"+
		"\2\2\u02fc\u02e5\3\2\2\2\u02fc\u02e9\3\2\2\2\u02fc\u02eb\3\2\2\2\u02fc"+
		"\u02f0\3\2\2\2\u02fc\u02f9\3\2\2\2\u02fc\u02fb\3\2\2\2\u02fdA\3\2\2\2"+
		"\u02fe\u02ff\7z\2\2\u02ff\u0300\7?\2\2\u0300\u0302\t\6\2\2\u0301\u02fe"+
		"\3\2\2\2\u0301\u0302\3\2\2\2\u0302C\3\2\2\2\u0303\u0304\b#\1\2\u0304\u0305"+
		"\5j\66\2\u0305\u0306\5D#\27\u0306\u034b\3\2\2\2\u0307\u034b\5h\65\2\u0308"+
		"\u034b\7\u00a6\2\2\u0309\u030a\5v<\2\u030a\u030b\7\20\2\2\u030b\u030d"+
		"\3\2\2\2\u030c\u0309\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u030e\3\2\2\2\u030e"+
		"\u034b\5|?\2\u030f\u0310\5t;\2\u0310\u031d\7\21\2\2\u0311\u0313\7M\2\2"+
		"\u0312\u0311\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u0319"+
		"\5D#\2\u0315\u0316\7\23\2\2\u0316\u0318\5D#\2\u0317\u0315\3\2\2\2\u0318"+
		"\u031b\3\2\2\2\u0319\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031e\3\2"+
		"\2\2\u031b\u0319\3\2\2\2\u031c\u031e\7\25\2\2\u031d\u0312\3\2\2\2\u031d"+
		"\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0320\7\22"+
		"\2\2\u0320\u034b\3\2\2\2\u0321\u0322\7\21\2\2\u0322\u0323\5D#\2\u0323"+
		"\u0324\7\22\2\2\u0324\u034b\3\2\2\2\u0325\u0326\7:\2\2\u0326\u0327\7\21"+
		"\2\2\u0327\u0328\5D#\2\u0328\u0329\7\60\2\2\u0329\u032a\5> \2\u032a\u032b"+
		"\7\22\2\2\u032b\u034b\3\2\2\2\u032c\u032e\7u\2\2\u032d\u032c\3\2\2\2\u032d"+
		"\u032e\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0331\7U\2\2\u0330\u032d\3\2"+
		"\2\2\u0330\u0331\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0333\7\21\2\2\u0333"+
		"\u0334\5.\30\2\u0334\u0335\7\22\2\2\u0335\u034b\3\2\2\2\u0336\u0338\7"+
		"9\2\2\u0337\u0339\5D#\2\u0338\u0337\3\2\2\2\u0338\u0339\3\2\2\2\u0339"+
		"\u033f\3\2\2\2\u033a\u033b\7\u009f\2\2\u033b\u033c\5D#\2\u033c\u033d\7"+
		"\u0094\2\2\u033d\u033e\5F$\2\u033e\u0340\3\2\2\2\u033f\u033a\3\2\2\2\u0340"+
		"\u0341\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0345\3\2"+
		"\2\2\u0343\u0344\7P\2\2\u0344\u0346\5D#\2\u0345\u0343\3\2\2\2\u0345\u0346"+
		"\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348\7Q\2\2\u0348\u034b\3\2\2\2\u0349"+
		"\u034b\5J&\2\u034a\u0303\3\2\2\2\u034a\u0307\3\2\2\2\u034a\u0308\3\2\2"+
		"\2\u034a\u030c\3\2\2\2\u034a\u030f\3\2\2\2\u034a\u0321\3\2\2\2\u034a\u0325"+
		"\3\2\2\2\u034a\u0330\3\2\2\2\u034a\u0336\3\2\2\2\u034a\u0349\3\2\2\2\u034b"+
		"\u039e\3\2\2\2\u034c\u034d\f\26\2\2\u034d\u034e\7\31\2\2\u034e\u039d\5"+
		"D#\27\u034f\u0350\f\25\2\2\u0350\u0351\t\7\2\2\u0351\u039d\5D#\26\u0352"+
		"\u0353\f\24\2\2\u0353\u0354\t\b\2\2\u0354\u039d\5D#\25\u0355\u0356\f\23"+
		"\2\2\u0356\u0357\t\t\2\2\u0357\u039d\5D#\24\u0358\u0359\f\22\2\2\u0359"+
		"\u035a\t\n\2\2\u035a\u039d\5D#\23\u035b\u035c\f\21\2\2\u035c\u035d\t\13"+
		"\2\2\u035d\u039d\5D#\22\u035e\u035f\f\20\2\2\u035f\u0360\7/\2\2\u0360"+
		"\u039d\5D#\21\u0361\u0362\f\17\2\2\u0362\u0363\7{\2\2\u0363\u039d\5D#"+
		"\20\u0364\u0365\f\b\2\2\u0365\u0367\7l\2\2\u0366\u0368\7u\2\2\u0367\u0366"+
		"\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u039d\5D#\t\u036a"+
		"\u036c\f\7\2\2\u036b\u036d\7u\2\2\u036c\u036b\3\2\2\2\u036c\u036d\3\2"+
		"\2\2\u036d\u036e\3\2\2\2\u036e\u036f\7\66\2\2\u036f\u0370\5D#\2\u0370"+
		"\u0371\7/\2\2\u0371\u0372\5D#\b\u0372\u039d\3\2\2\2\u0373\u0374\f\13\2"+
		"\2\u0374\u0375\7<\2\2\u0375\u039d\5\u0080A\2\u0376\u0378\f\n\2\2\u0377"+
		"\u0379\7u\2\2\u0378\u0377\3\2\2\2\u0378\u0379\3\2\2\2\u0379\u037a\3\2"+
		"\2\2\u037a\u037b\t\f\2\2\u037b\u037e\5D#\2\u037c\u037d\7R\2\2\u037d\u037f"+
		"\5D#\2\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u039d\3\2\2\2\u0380"+
		"\u0385\f\t\2\2\u0381\u0386\7m\2\2\u0382\u0386\7v\2\2\u0383\u0384\7u\2"+
		"\2\u0384\u0386\7w\2\2\u0385\u0381\3\2\2\2\u0385\u0382\3\2\2\2\u0385\u0383"+
		"\3\2\2\2\u0386\u039d\3\2\2\2\u0387\u0389\f\6\2\2\u0388\u038a\7u\2\2\u0389"+
		"\u0388\3\2\2\2\u0389\u038a\3\2\2\2\u038a\u038b\3\2\2\2\u038b\u039a\7c"+
		"\2\2\u038c\u0396\7\21\2\2\u038d\u0397\5.\30\2\u038e\u0393\5D#\2\u038f"+
		"\u0390\7\23\2\2\u0390\u0392\5D#\2\u0391\u038f\3\2\2\2\u0392\u0395\3\2"+
		"\2\2\u0393\u0391\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0397\3\2\2\2\u0395"+
		"\u0393\3\2\2\2\u0396\u038d\3\2\2\2\u0396\u038e\3\2\2\2\u0396\u0397\3\2"+
		"\2\2\u0397\u0398\3\2\2\2\u0398\u039b\7\22\2\2\u0399\u039b\5v<\2\u039a"+
		"\u038c\3\2\2\2\u039a\u0399\3\2\2\2\u039b\u039d\3\2\2\2\u039c\u034c\3\2"+
		"\2\2\u039c\u034f\3\2\2\2\u039c\u0352\3\2\2\2\u039c\u0355\3\2\2\2\u039c"+
		"\u0358\3\2\2\2\u039c\u035b\3\2\2\2\u039c\u035e\3\2\2\2\u039c\u0361\3\2"+
		"\2\2\u039c\u0364\3\2\2\2\u039c\u036a\3\2\2\2\u039c\u0373\3\2\2\2\u039c"+
		"\u0376\3\2\2\2\u039c\u0380\3\2\2\2\u039c\u0387\3\2\2\2\u039d\u03a0\3\2"+
		"\2\2\u039e\u039c\3\2\2\2\u039e\u039f\3\2\2\2\u039fE\3\2\2\2\u03a0\u039e"+
		"\3\2\2\2\u03a1\u03a2\5D#\2\u03a2G\3\2\2\2\u03a3\u03a4\7\u0084\2\2\u03a4"+
		"\u03b0\5\u0082B\2\u03a5\u03a6\7\21\2\2\u03a6\u03ab\5|?\2\u03a7\u03a8\7"+
		"\23\2\2\u03a8\u03aa\5|?\2\u03a9\u03a7\3\2\2\2\u03aa\u03ad\3\2\2\2\u03ab"+
		"\u03a9\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac\u03ae\3\2\2\2\u03ad\u03ab\3\2"+
		"\2\2\u03ae\u03af\7\22\2\2\u03af\u03b1\3\2\2\2\u03b0\u03a5\3\2\2\2\u03b0"+
		"\u03b1\3\2\2\2\u03b1\u03c4\3\2\2\2\u03b2\u03b3\7z\2\2\u03b3\u03bc\t\r"+
		"\2\2\u03b4\u03b5\7\u0090\2\2\u03b5\u03bd\7w\2\2\u03b6\u03b7\7\u0090\2"+
		"\2\u03b7\u03bd\7G\2\2\u03b8\u03bd\78\2\2\u03b9\u03bd\7\u008a\2\2\u03ba"+
		"\u03bb\7t\2\2\u03bb\u03bd\7)\2\2\u03bc\u03b4\3\2\2\2\u03bc\u03b6\3\2\2"+
		"\2\u03bc\u03b8\3\2\2\2\u03bc\u03b9\3\2\2\2\u03bc\u03ba\3\2\2\2\u03bd\u03c1"+
		"\3\2\2\2\u03be\u03bf\7r\2\2\u03bf\u03c1\5r:\2\u03c0\u03b2\3\2\2\2\u03c0"+
		"\u03be\3\2\2\2\u03c1\u03c3\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c3\u03c6\3\2"+
		"\2\2\u03c4\u03c2\3\2\2\2\u03c4\u03c5\3\2\2\2\u03c5\u03d1\3\2\2\2\u03c6"+
		"\u03c4\3\2\2\2\u03c7\u03c9\7u\2\2\u03c8\u03c7\3\2\2\2\u03c8\u03c9\3\2"+
		"\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cf\7H\2\2\u03cb\u03cc\7f\2\2\u03cc\u03d0"+
		"\7I\2\2\u03cd\u03ce\7f\2\2\u03ce\u03d0\7a\2\2\u03cf\u03cb\3\2\2\2\u03cf"+
		"\u03cd\3\2\2\2\u03cf\u03d0\3\2\2\2\u03d0\u03d2\3\2\2\2\u03d1\u03c8\3\2"+
		"\2\2\u03d1\u03d2\3\2\2\2\u03d2I\3\2\2\2\u03d3\u03d4\7\u0082\2\2\u03d4"+
		"\u03d9\7\21\2\2\u03d5\u03da\7`\2\2\u03d6\u03d7\t\16\2\2\u03d7\u03d8\7"+
		"\23\2\2\u03d8\u03da\5l\67\2\u03d9\u03d5\3\2\2\2\u03d9\u03d6\3\2\2\2\u03da"+
		"\u03db\3\2\2\2\u03db\u03dc\7\22\2\2\u03dcK\3\2\2\2\u03dd\u03e0\5|?\2\u03de"+
		"\u03df\7<\2\2\u03df\u03e1\5\u0080A\2\u03e0\u03de\3\2\2\2\u03e0\u03e1\3"+
		"\2\2\2\u03e1\u03e3\3\2\2\2\u03e2\u03e4\t\5\2\2\u03e3\u03e2\3\2\2\2\u03e3"+
		"\u03e4\3\2\2\2\u03e4M\3\2\2\2\u03e5\u03e6\7@\2\2\u03e6\u03e8\5r:\2\u03e7"+
		"\u03e5\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u0408\3\2\2\2\u03e9\u03ea\t\17"+
		"\2\2\u03ea\u03eb\7\21\2\2\u03eb\u03f0\5L\'\2\u03ec\u03ed\7\23\2\2\u03ed"+
		"\u03ef\5L\'\2\u03ee\u03ec\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0\u03ee\3\2"+
		"\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f3\3\2\2\2\u03f2\u03f0\3\2\2\2\u03f3"+
		"\u03f4\7\22\2\2\u03f4\u03f5\5B\"\2\u03f5\u0409\3\2\2\2\u03f6\u03f7\7;"+
		"\2\2\u03f7\u03f8\7\21\2\2\u03f8\u03f9\5D#\2\u03f9\u03fa\7\22\2\2\u03fa"+
		"\u0409\3\2\2\2\u03fb\u03fc\7Y\2\2\u03fc\u03fd\7\21\2\2\u03fd\u0402\5|"+
		"?\2\u03fe\u03ff\7\23\2\2\u03ff\u0401\5|?\2\u0400\u03fe\3\2\2\2\u0401\u0404"+
		"\3\2\2\2\u0402\u0400\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0405\3\2\2\2\u0404"+
		"\u0402\3\2\2\2\u0405\u0406\7\22\2\2\u0406\u0407\5H%\2\u0407\u0409\3\2"+
		"\2\2\u0408\u03e9\3\2\2\2\u0408\u03f6\3\2\2\2\u0408\u03fb\3\2\2\2\u0409"+
		"O\3\2\2\2\u040a\u040c\7\u00a1\2\2\u040b\u040d\7\u0083\2\2\u040c\u040b"+
		"\3\2\2\2\u040c\u040d\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0413\5X-\2\u040f"+
		"\u0410\7\23\2\2\u0410\u0412\5X-\2\u0411\u040f\3\2\2\2\u0412\u0415\3\2"+
		"\2\2\u0413\u0411\3\2\2\2\u0413\u0414\3\2\2\2\u0414Q\3\2\2\2\u0415\u0413"+
		"\3\2\2\2\u0416\u041c\5v<\2\u0417\u0418\7e\2\2\u0418\u0419\7\67\2\2\u0419"+
		"\u041d\5\u0084C\2\u041a\u041b\7u\2\2\u041b\u041d\7e\2\2\u041c\u0417\3"+
		"\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041dS\3\2\2\2\u041e\u0421"+
		"\5D#\2\u041f\u0420\7<\2\2\u0420\u0422\5\u0080A\2\u0421\u041f\3\2\2\2\u0421"+
		"\u0422\3\2\2\2\u0422\u0424\3\2\2\2\u0423\u0425\t\5\2\2\u0424\u0423\3\2"+
		"\2\2\u0424\u0425\3\2\2\2\u0425U\3\2\2\2\u0426\u042a\5f\64\2\u0427\u042a"+
		"\5r:\2\u0428\u042a\7\u00a7\2\2\u0429\u0426\3\2\2\2\u0429\u0427\3\2\2\2"+
		"\u0429\u0428\3\2\2\2\u042aW\3\2\2\2\u042b\u0437\5v<\2\u042c\u042d\7\21"+
		"\2\2\u042d\u0432\5|?\2\u042e\u042f\7\23\2\2\u042f\u0431\5|?\2\u0430\u042e"+
		"\3\2\2\2\u0431\u0434\3\2\2\2\u0432\u0430\3\2\2\2\u0432\u0433\3\2\2\2\u0433"+
		"\u0435\3\2\2\2\u0434\u0432\3\2\2\2\u0435\u0436\7\22\2\2\u0436\u0438\3"+
		"\2\2\2\u0437\u042c\3\2\2\2\u0437\u0438\3\2\2\2\u0438\u0439\3\2\2\2\u0439"+
		"\u043a\7\60\2\2\u043a\u043b\7\21\2\2\u043b\u043c\5.\30\2\u043c\u043d\7"+
		"\22\2\2\u043dY\3\2\2\2\u043e\u044b\7\25\2\2\u043f\u0440\5v<\2\u0440\u0441"+
		"\7\20\2\2\u0441\u0442\7\25\2\2\u0442\u044b\3\2\2\2\u0443\u0448\5D#\2\u0444"+
		"\u0446\7\60\2\2\u0445\u0444\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0447\3"+
		"\2\2\2\u0447\u0449\5n8\2\u0448\u0445\3\2\2\2\u0448\u0449\3\2\2\2\u0449"+
		"\u044b\3\2\2\2\u044a\u043e\3\2\2\2\u044a\u043f\3\2\2\2\u044a\u0443\3\2"+
		"\2\2\u044b[\3\2\2\2\u044c\u0451\5v<\2\u044d\u044f\7\60\2\2\u044e\u044d"+
		"\3\2\2\2\u044e\u044f\3\2\2\2\u044f\u0450\3\2\2\2\u0450\u0452\5\u008eH"+
		"\2\u0451\u044e\3\2\2\2\u0451\u0452\3\2\2\2\u0452\u0458\3\2\2\2\u0453\u0454"+
		"\7e\2\2\u0454\u0455\7\67\2\2\u0455\u0459\5\u0084C\2\u0456\u0457\7u\2\2"+
		"\u0457\u0459\7e\2\2\u0458\u0453\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0459"+
		"\3\2\2\2\u0459\u0472\3\2\2\2\u045a\u0464\7\21\2\2\u045b\u0460\5\\/\2\u045c"+
		"\u045d\7\23\2\2\u045d\u045f\5\\/\2\u045e\u045c\3\2\2\2\u045f\u0462\3\2"+
		"\2\2\u0460\u045e\3\2\2\2\u0460\u0461\3\2\2\2\u0461\u0465\3\2\2\2\u0462"+
		"\u0460\3\2\2\2\u0463\u0465\5^\60\2\u0464\u045b\3\2\2\2\u0464\u0463\3\2"+
		"\2\2\u0465\u0466\3\2\2\2\u0466\u0467\7\22\2\2\u0467\u0472\3\2\2\2\u0468"+
		"\u0469\7\21\2\2\u0469\u046a\5.\30\2\u046a\u046f\7\22\2\2\u046b\u046d\7"+
		"\60\2\2\u046c\u046b\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u046e\3\2\2\2\u046e"+
		"\u0470\5\u008eH\2\u046f\u046c\3\2\2\2\u046f\u0470\3\2\2\2\u0470\u0472"+
		"\3\2\2\2\u0471\u044c\3\2\2\2\u0471\u045a\3\2\2\2\u0471\u0468\3\2\2\2\u0472"+
		"]\3\2\2\2\u0473\u047a\5\\/\2\u0474\u0475\5`\61\2\u0475\u0476\5\\/\2\u0476"+
		"\u0477\5b\62\2\u0477\u0479\3\2\2\2\u0478\u0474\3\2\2\2\u0479\u047c\3\2"+
		"\2\2\u047a\u0478\3\2\2\2\u047a\u047b\3\2\2\2\u047b_\3\2\2\2\u047c\u047a"+
		"\3\2\2\2\u047d\u048b\7\23\2\2\u047e\u0480\7s\2\2\u047f\u047e\3\2\2\2\u047f"+
		"\u0480\3\2\2\2\u0480\u0487\3\2\2\2\u0481\u0483\7o\2\2\u0482\u0484\7}\2"+
		"\2\u0483\u0482\3\2\2\2\u0483\u0484\3\2\2\2\u0484\u0488\3\2\2\2\u0485\u0488"+
		"\7g\2\2\u0486\u0488\7B\2\2\u0487\u0481\3\2\2\2\u0487\u0485\3\2\2\2\u0487"+
		"\u0486\3\2\2\2\u0487\u0488\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048b\7n"+
		"\2\2\u048a\u047d\3\2\2\2\u048a\u047f\3\2\2\2\u048ba\3\2\2\2\u048c\u048d"+
		"\7z\2\2\u048d\u049b\5D#\2\u048e\u048f\7\u009b\2\2\u048f\u0490\7\21\2\2"+
		"\u0490\u0495\5|?\2\u0491\u0492\7\23\2\2\u0492\u0494\5|?\2\u0493\u0491"+
		"\3\2\2\2\u0494\u0497\3\2\2\2\u0495\u0493\3\2\2\2\u0495\u0496\3\2\2\2\u0496"+
		"\u0498\3\2\2\2\u0497\u0495\3\2\2\2\u0498\u0499\7\22\2\2\u0499\u049b\3"+
		"\2\2\2\u049a\u048c\3\2\2\2\u049a\u048e\3\2\2\2\u049a\u049b\3\2\2\2\u049b"+
		"c\3\2\2\2\u049c\u04a2\7\u0098\2\2\u049d\u049e\7\u0098\2\2\u049e\u04a2"+
		"\7,\2\2\u049f\u04a2\7j\2\2\u04a0\u04a2\7S\2\2\u04a1\u049c\3\2\2\2\u04a1"+
		"\u049d\3\2\2\2\u04a1\u049f\3\2\2\2\u04a1\u04a0\3\2\2\2\u04a2e\3\2\2\2"+
		"\u04a3\u04a5\t\b\2\2\u04a4\u04a3\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a6"+
		"\3\2\2\2\u04a6\u04a7\t\20\2\2\u04a7g\3\2\2\2\u04a8\u04a9\t\21\2\2\u04a9"+
		"i\3\2\2\2\u04aa\u04ab\t\22\2\2\u04abk\3\2\2\2\u04ac\u04ad\7\u00a7\2\2"+
		"\u04adm\3\2\2\2\u04ae\u04af\7\u00a3\2\2\u04afo\3\2\2\2\u04b0\u04b1\t\23"+
		"\2\2\u04b1q\3\2\2\2\u04b2\u04b3\5\u009aN\2\u04b3s\3\2\2\2\u04b4\u04b5"+
		"\5\u009aN\2\u04b5u\3\2\2\2\u04b6\u04b7\7\u00a3\2\2\u04b7w\3\2\2\2\u04b8"+
		"\u04b9\5\u009aN\2\u04b9y\3\2\2\2\u04ba\u04bb\5\u009aN\2\u04bb{\3\2\2\2"+
		"\u04bc\u04bd\t\24\2\2\u04bd}\3\2\2\2\u04be\u04bf\7\u00a3\2\2\u04bf\177"+
		"\3\2\2\2\u04c0\u04c1\5\u009aN\2\u04c1\u0081\3\2\2\2\u04c2\u04c3\5\u009a"+
		"N\2\u04c3\u0083\3\2\2\2\u04c4\u04c5\5\u009aN\2\u04c5\u0085\3\2\2\2\u04c6"+
		"\u04c7\5\u009aN\2\u04c7\u0087\3\2\2\2\u04c8\u04c9\7\u00a3\2\2\u04c9\u0089"+
		"\3\2\2\2\u04ca\u04cb\5\u009aN\2\u04cb\u008b\3\2\2\2\u04cc\u04cd\5\u009a"+
		"N\2\u04cd\u008d\3\2\2\2\u04ce\u04cf\7\u00a3\2\2\u04cf\u008f\3\2\2\2\u04d0"+
		"\u04d1\t\25\2\2\u04d1\u0091\3\2\2\2\u04d2\u04db\7\4\2\2\u04d3\u04db\7"+
		"\5\2\2\u04d4\u04db\7\6\2\2\u04d5\u04db\7\7\2\2\u04d6\u04db\7\b\2\2\u04d7"+
		"\u04db\7\t\2\2\u04d8\u04db\7\n\2\2\u04d9\u04db\5\u0094K\2\u04da\u04d2"+
		"\3\2\2\2\u04da\u04d3\3\2\2\2\u04da\u04d4\3\2\2\2\u04da\u04d5\3\2\2\2\u04da"+
		"\u04d6\3\2\2\2\u04da\u04d7\3\2\2\2\u04da\u04d8\3\2\2\2\u04da\u04d9\3\2"+
		"\2\2\u04db\u0093\3\2\2\2\u04dc\u04fd\5\u0098M\2\u04dd\u04de\7 \2\2\u04de"+
		"\u04e3\5\u0092J\2\u04df\u04e0\7\23\2\2\u04e0\u04e2\5\u0092J\2\u04e1\u04df"+
		"\3\2\2\2\u04e2\u04e5\3\2\2\2\u04e3\u04e1\3\2\2\2\u04e3\u04e4\3\2\2\2\u04e4"+
		"\u04e6\3\2\2\2\u04e5\u04e3\3\2\2\2\u04e6\u04e7\7\"\2\2\u04e7\u04fe\3\2"+
		"\2\2\u04e8\u04ee\7 \2\2\u04e9\u04ea\5\u0092J\2\u04ea\u04eb\7\23\2\2\u04eb"+
		"\u04ed\3\2\2\2\u04ec\u04e9\3\2\2\2\u04ed\u04f0\3\2\2\2\u04ee\u04ec\3\2"+
		"\2\2\u04ee\u04ef\3\2\2\2\u04ef\u04f1\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f1"+
		"\u04f2\5\u0098M\2\u04f2\u04f3\7 \2\2\u04f3\u04f8\5\u0096L\2\u04f4\u04f5"+
		"\7\23\2\2\u04f5\u04f7\5\u0096L\2\u04f6\u04f4\3\2\2\2\u04f7\u04fa\3\2\2"+
		"\2\u04f8\u04f6\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fb\3\2\2\2\u04fa\u04f8"+
		"\3\2\2\2\u04fb\u04fc\7\35\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04dd\3\2\2\2"+
		"\u04fd\u04e8\3\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u0095\3\2\2\2\u04ff\u0500"+
		"\5\u0092J\2\u0500\u0097\3\2\2\2\u0501\u0502\7\u00a3\2\2\u0502\u0504\7"+
		"\20\2\2\u0503\u0501\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\u00a3"+
		"\2\2\u0509\u0099\3\2\2\2\u050a\u0511\7\u00a3\2\2\u050b\u0511\7\u00a7\2"+
		"\2\u050c\u050d\7\21\2\2\u050d\u050e\5\u009aN\2\u050e\u050f\7\22\2\2\u050f"+
		"\u0511\3\2\2\2\u0510\u050a\3\2\2\2\u0510\u050b\3\2\2\2\u0510\u050c\3\2"+
		"\2\2\u0511\u009b\3\2\2\2\u00a5\u009e\u00a7\u00ad\u00b4\u00c0\u00c2\u00d8"+
		"\u00e2\u00e5\u00ec\u00f2\u00fd\u0103\u0107\u010d\u0116\u011d\u0123\u0127"+
		"\u012b\u0131\u0138\u0143\u0146\u0148\u014f\u0153\u015a\u0160\u0166\u016c"+
		"\u0173\u017a\u017d\u0184\u018d\u0190\u0196\u0198\u019e\u01a6\u01ae\u01b6"+
		"\u01bb\u01ce\u01d8\u01dd\u01e4\u01ee\u01f4\u01f6\u01fa\u0202\u020a\u0214"+
		"\u0217\u021d\u021f\u0223\u022a\u0233\u0237\u0239\u023d\u0246\u024a\u024c"+
		"\u0250\u025b\u0261\u0264\u0271\u027f\u0284\u0287\u0294\u02a2\u02a7\u02b0"+
		"\u02b3\u02b9\u02bb\u02c4\u02d2\u02d6\u02da\u02de\u02e2\u02e5\u02f7\u02fc"+
		"\u0301\u030c\u0312\u0319\u031d\u032d\u0330\u0338\u0341\u0345\u034a\u0367"+
		"\u036c\u0378\u037e\u0385\u0389\u0393\u0396\u039a\u039c\u039e\u03ab\u03b0"+
		"\u03bc\u03c0\u03c4\u03c8\u03cf\u03d1\u03d9\u03e0\u03e3\u03e7\u03f0\u0402"+
		"\u0408\u040c\u0413\u041c\u0421\u0424\u0429\u0432\u0437\u0445\u0448\u044a"+
		"\u044e\u0451\u0458\u0460\u0464\u046c\u046f\u0471\u047a\u047f\u0483\u0487"+
		"\u048a\u0495\u049a\u04a1\u04a4\u04da\u04e3\u04ee\u04f8\u04fd\u0505\u0510";
	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);
		}
	}
}