All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.phoenix.parse.PhoenixSQLLexer Maven / Gradle / Ivy

// $ANTLR 3.5.2 PhoenixSQL.g 2024-10-22 18:19:25

/**
 * Copyright 2010 The Apache Software Foundation
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.phoenix.parse;
///CLOVER:OFF


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

@SuppressWarnings("all")
public class PhoenixSQLLexer extends Lexer {
	public static final int EOF=-1;
	public static final int ACTIVE=4;
	public static final int ADD=5;
	public static final int ALL=6;
	public static final int ALTER=7;
	public static final int AND=8;
	public static final int ANY=9;
	public static final int ARRAY=10;
	public static final int AS=11;
	public static final int ASC=12;
	public static final int ASTERISK=13;
	public static final int ASYNC=14;
	public static final int AT=15;
	public static final int B=16;
	public static final int BETWEEN=17;
	public static final int BIND_NAME=18;
	public static final int BIN_DIGIT=19;
	public static final int BIN_LITERAL=20;
	public static final int BY=21;
	public static final int CACHE=22;
	public static final int CASCADE=23;
	public static final int CASE=24;
	public static final int CAST=25;
	public static final int CHAR=26;
	public static final int CHAR_ESC=27;
	public static final int CLOSE=28;
	public static final int COLON=29;
	public static final int COLUMN=30;
	public static final int COLUMNS=31;
	public static final int COLUMN_QUALIFIER_COUNTER=32;
	public static final int COMMA=33;
	public static final int COMMENT_AND_HINT_END=34;
	public static final int COMMENT_START=35;
	public static final int CONCAT=36;
	public static final int CONSTANT=37;
	public static final int CONSTRAINT=38;
	public static final int CREATE=39;
	public static final int CURRENT=40;
	public static final int CURSOR=41;
	public static final int CYCLE=42;
	public static final int DBL_QUOTE_CHAR=43;
	public static final int DECIMAL=44;
	public static final int DECLARE=45;
	public static final int DEFAULT=46;
	public static final int DEFAULTVALUE=47;
	public static final int DELETE=48;
	public static final int DESC=49;
	public static final int DIGIT=50;
	public static final int DISABLE=51;
	public static final int DISTINCT=52;
	public static final int DIVIDE=53;
	public static final int DOT=54;
	public static final int DOUBLE=55;
	public static final int DOUBLE_EQ=56;
	public static final int DOUBLE_QUOTE=57;
	public static final int DROP=58;
	public static final int DUPLICATE=59;
	public static final int ELSE=60;
	public static final int ENCODED_QUALIFIER=61;
	public static final int END=62;
	public static final int EOL=63;
	public static final int EQ=64;
	public static final int EXECUTE=65;
	public static final int EXISTS=66;
	public static final int EXPLAIN=67;
	public static final int Exponent=68;
	public static final int FALSE=69;
	public static final int FETCH=70;
	public static final int FIELDCHAR=71;
	public static final int FIRST=72;
	public static final int FOR=73;
	public static final int FROM=74;
	public static final int FULL=75;
	public static final int FUNCTION=76;
	public static final int GRANT=77;
	public static final int GROUP=78;
	public static final int GT=79;
	public static final int HAVING=80;
	public static final int HEX_DIGIT=81;
	public static final int HEX_LITERAL=82;
	public static final int HINT_START=83;
	public static final int IF=84;
	public static final int IGNORE=85;
	public static final int ILIKE=86;
	public static final int IMMUTABLE=87;
	public static final int IN=88;
	public static final int INCLUDE=89;
	public static final int INCREMENT=90;
	public static final int INDEX=91;
	public static final int INNER=92;
	public static final int INTO=93;
	public static final int IS=94;
	public static final int JAR=95;
	public static final int JARS=96;
	public static final int JOIN=97;
	public static final int KEY=98;
	public static final int LAST=99;
	public static final int LCURLY=100;
	public static final int LEFT=101;
	public static final int LETTER=102;
	public static final int LIKE=103;
	public static final int LIMIT=104;
	public static final int LIST=105;
	public static final int LOCAL=106;
	public static final int LPAREN=107;
	public static final int LSQUARE=108;
	public static final int LT=109;
	public static final int MAXVALUE=110;
	public static final int MINUS=111;
	public static final int MINVALUE=112;
	public static final int ML_COMMENT=113;
	public static final int ML_HINT=114;
	public static final int NAME=115;
	public static final int NEXT=116;
	public static final int NOEQ1=117;
	public static final int NOEQ2=118;
	public static final int NOT=119;
	public static final int NOVERIFY=120;
	public static final int NULL=121;
	public static final int NULLS=122;
	public static final int NUMBER=123;
	public static final int OFF=124;
	public static final int OFFSET=125;
	public static final int ON=126;
	public static final int ONLY=127;
	public static final int OPEN=128;
	public static final int OR=129;
	public static final int ORDER=130;
	public static final int OTHER=131;
	public static final int OUTER=132;
	public static final int OUTER_JOIN=133;
	public static final int PERCENT=134;
	public static final int PLUS=135;
	public static final int POSINTEGER=136;
	public static final int PRIMARY=137;
	public static final int QUESTION=138;
	public static final int RCURLY=139;
	public static final int REBUILD=140;
	public static final int REGIONS=141;
	public static final int REPLACE=142;
	public static final int RETURNS=143;
	public static final int REVOKE=144;
	public static final int RIGHT=145;
	public static final int ROW=146;
	public static final int ROWS=147;
	public static final int ROW_TIMESTAMP=148;
	public static final int RPAREN=149;
	public static final int RSQUARE=150;
	public static final int SAMPLING=151;
	public static final int SCHEMA=152;
	public static final int SCHEMAS=153;
	public static final int SELECT=154;
	public static final int SEMICOLON=155;
	public static final int SEQUENCE=156;
	public static final int SESSION=157;
	public static final int SET=158;
	public static final int SHOW=159;
	public static final int SL_COMMENT=160;
	public static final int SL_COMMENT1=161;
	public static final int SL_COMMENT2=162;
	public static final int SOME=163;
	public static final int SPLIT=164;
	public static final int START=165;
	public static final int STATISTICS=166;
	public static final int STRING_LITERAL=167;
	public static final int TABLE=168;
	public static final int TABLES=169;
	public static final int TABLESAMPLE=170;
	public static final int TEMPORARY=171;
	public static final int THEN=172;
	public static final int TILDE=173;
	public static final int TO=174;
	public static final int TRACE=175;
	public static final int TRUE=176;
	public static final int UNCOVERED=177;
	public static final int UNION=178;
	public static final int UNUSABLE=179;
	public static final int UPDATE=180;
	public static final int UPGRADE=181;
	public static final int UPSERT=182;
	public static final int USABLE=183;
	public static final int USE=184;
	public static final int USING=185;
	public static final int VALUE=186;
	public static final int VALUES=187;
	public static final int VIEW=188;
	public static final int WHEN=189;
	public static final int WHERE=190;
	public static final int WITH=191;
	public static final int WITHIN=192;
	public static final int WS=193;
	public static final int X=194;




	// delegates
	// delegators
	public Lexer[] getDelegates() {
		return new Lexer[] {};
	}

	public PhoenixSQLLexer() {} 
	public PhoenixSQLLexer(CharStream input) {
		this(input, new RecognizerSharedState());
	}
	public PhoenixSQLLexer(CharStream input, RecognizerSharedState state) {
		super(input,state);
	}
	@Override public String getGrammarFileName() { return "PhoenixSQL.g"; }

	// $ANTLR start "ACTIVE"
	public final void mACTIVE() throws RecognitionException {
		try {
			int _type = ACTIVE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:29:8: ( 'active' )
			// PhoenixSQL.g:29:10: 'active'
			{
			match("active"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ACTIVE"

	// $ANTLR start "ADD"
	public final void mADD() throws RecognitionException {
		try {
			int _type = ADD;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:30:5: ( 'add' )
			// PhoenixSQL.g:30:7: 'add'
			{
			match("add"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ADD"

	// $ANTLR start "ALL"
	public final void mALL() throws RecognitionException {
		try {
			int _type = ALL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:31:5: ( 'all' )
			// PhoenixSQL.g:31:7: 'all'
			{
			match("all"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ALL"

	// $ANTLR start "ALTER"
	public final void mALTER() throws RecognitionException {
		try {
			int _type = ALTER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:32:7: ( 'alter' )
			// PhoenixSQL.g:32:9: 'alter'
			{
			match("alter"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ALTER"

	// $ANTLR start "AND"
	public final void mAND() throws RecognitionException {
		try {
			int _type = AND;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:33:5: ( 'and' )
			// PhoenixSQL.g:33:7: 'and'
			{
			match("and"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "AND"

	// $ANTLR start "ANY"
	public final void mANY() throws RecognitionException {
		try {
			int _type = ANY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:34:5: ( 'any' )
			// PhoenixSQL.g:34:7: 'any'
			{
			match("any"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ANY"

	// $ANTLR start "ARRAY"
	public final void mARRAY() throws RecognitionException {
		try {
			int _type = ARRAY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:35:7: ( 'array' )
			// PhoenixSQL.g:35:9: 'array'
			{
			match("array"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ARRAY"

	// $ANTLR start "AS"
	public final void mAS() throws RecognitionException {
		try {
			int _type = AS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:36:4: ( 'as' )
			// PhoenixSQL.g:36:6: 'as'
			{
			match("as"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "AS"

	// $ANTLR start "ASC"
	public final void mASC() throws RecognitionException {
		try {
			int _type = ASC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:37:5: ( 'asc' )
			// PhoenixSQL.g:37:7: 'asc'
			{
			match("asc"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ASC"

	// $ANTLR start "ASYNC"
	public final void mASYNC() throws RecognitionException {
		try {
			int _type = ASYNC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:38:7: ( 'async' )
			// PhoenixSQL.g:38:9: 'async'
			{
			match("async"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ASYNC"

	// $ANTLR start "BETWEEN"
	public final void mBETWEEN() throws RecognitionException {
		try {
			int _type = BETWEEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:39:9: ( 'between' )
			// PhoenixSQL.g:39:11: 'between'
			{
			match("between"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BETWEEN"

	// $ANTLR start "BY"
	public final void mBY() throws RecognitionException {
		try {
			int _type = BY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:40:4: ( 'by' )
			// PhoenixSQL.g:40:6: 'by'
			{
			match("by"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BY"

	// $ANTLR start "CACHE"
	public final void mCACHE() throws RecognitionException {
		try {
			int _type = CACHE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:41:7: ( 'cache' )
			// PhoenixSQL.g:41:9: 'cache'
			{
			match("cache"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CACHE"

	// $ANTLR start "CASCADE"
	public final void mCASCADE() throws RecognitionException {
		try {
			int _type = CASCADE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:42:9: ( 'cascade' )
			// PhoenixSQL.g:42:11: 'cascade'
			{
			match("cascade"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CASCADE"

	// $ANTLR start "CASE"
	public final void mCASE() throws RecognitionException {
		try {
			int _type = CASE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:43:6: ( 'case' )
			// PhoenixSQL.g:43:8: 'case'
			{
			match("case"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CASE"

	// $ANTLR start "CAST"
	public final void mCAST() throws RecognitionException {
		try {
			int _type = CAST;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:44:6: ( 'cast' )
			// PhoenixSQL.g:44:8: 'cast'
			{
			match("cast"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CAST"

	// $ANTLR start "CLOSE"
	public final void mCLOSE() throws RecognitionException {
		try {
			int _type = CLOSE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:45:7: ( 'close' )
			// PhoenixSQL.g:45:9: 'close'
			{
			match("close"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CLOSE"

	// $ANTLR start "COLUMN"
	public final void mCOLUMN() throws RecognitionException {
		try {
			int _type = COLUMN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:46:8: ( 'column' )
			// PhoenixSQL.g:46:10: 'column'
			{
			match("column"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COLUMN"

	// $ANTLR start "COLUMNS"
	public final void mCOLUMNS() throws RecognitionException {
		try {
			int _type = COLUMNS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:47:9: ( 'columns' )
			// PhoenixSQL.g:47:11: 'columns'
			{
			match("columns"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COLUMNS"

	// $ANTLR start "COLUMN_QUALIFIER_COUNTER"
	public final void mCOLUMN_QUALIFIER_COUNTER() throws RecognitionException {
		try {
			int _type = COLUMN_QUALIFIER_COUNTER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:48:26: ( 'column_qualifier_counter' )
			// PhoenixSQL.g:48:28: 'column_qualifier_counter'
			{
			match("column_qualifier_counter"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COLUMN_QUALIFIER_COUNTER"

	// $ANTLR start "CONSTANT"
	public final void mCONSTANT() throws RecognitionException {
		try {
			int _type = CONSTANT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:49:10: ( 'constant' )
			// PhoenixSQL.g:49:12: 'constant'
			{
			match("constant"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CONSTANT"

	// $ANTLR start "CONSTRAINT"
	public final void mCONSTRAINT() throws RecognitionException {
		try {
			int _type = CONSTRAINT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:50:12: ( 'constraint' )
			// PhoenixSQL.g:50:14: 'constraint'
			{
			match("constraint"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CONSTRAINT"

	// $ANTLR start "CREATE"
	public final void mCREATE() throws RecognitionException {
		try {
			int _type = CREATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:51:8: ( 'create' )
			// PhoenixSQL.g:51:10: 'create'
			{
			match("create"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CREATE"

	// $ANTLR start "CURRENT"
	public final void mCURRENT() throws RecognitionException {
		try {
			int _type = CURRENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:52:9: ( 'current' )
			// PhoenixSQL.g:52:11: 'current'
			{
			match("current"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CURRENT"

	// $ANTLR start "CURSOR"
	public final void mCURSOR() throws RecognitionException {
		try {
			int _type = CURSOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:53:8: ( 'cursor' )
			// PhoenixSQL.g:53:10: 'cursor'
			{
			match("cursor"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CURSOR"

	// $ANTLR start "CYCLE"
	public final void mCYCLE() throws RecognitionException {
		try {
			int _type = CYCLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:54:7: ( 'cycle' )
			// PhoenixSQL.g:54:9: 'cycle'
			{
			match("cycle"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CYCLE"

	// $ANTLR start "DECLARE"
	public final void mDECLARE() throws RecognitionException {
		try {
			int _type = DECLARE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:55:9: ( 'declare' )
			// PhoenixSQL.g:55:11: 'declare'
			{
			match("declare"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DECLARE"

	// $ANTLR start "DEFAULT"
	public final void mDEFAULT() throws RecognitionException {
		try {
			int _type = DEFAULT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:56:9: ( 'default' )
			// PhoenixSQL.g:56:11: 'default'
			{
			match("default"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DEFAULT"

	// $ANTLR start "DEFAULTVALUE"
	public final void mDEFAULTVALUE() throws RecognitionException {
		try {
			int _type = DEFAULTVALUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:57:14: ( 'defaultvalue' )
			// PhoenixSQL.g:57:16: 'defaultvalue'
			{
			match("defaultvalue"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DEFAULTVALUE"

	// $ANTLR start "DELETE"
	public final void mDELETE() throws RecognitionException {
		try {
			int _type = DELETE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:58:8: ( 'delete' )
			// PhoenixSQL.g:58:10: 'delete'
			{
			match("delete"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DELETE"

	// $ANTLR start "DESC"
	public final void mDESC() throws RecognitionException {
		try {
			int _type = DESC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:59:6: ( 'desc' )
			// PhoenixSQL.g:59:8: 'desc'
			{
			match("desc"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DESC"

	// $ANTLR start "DISABLE"
	public final void mDISABLE() throws RecognitionException {
		try {
			int _type = DISABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:60:9: ( 'disable' )
			// PhoenixSQL.g:60:11: 'disable'
			{
			match("disable"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DISABLE"

	// $ANTLR start "DISTINCT"
	public final void mDISTINCT() throws RecognitionException {
		try {
			int _type = DISTINCT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:61:10: ( 'distinct' )
			// PhoenixSQL.g:61:12: 'distinct'
			{
			match("distinct"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DISTINCT"

	// $ANTLR start "DROP"
	public final void mDROP() throws RecognitionException {
		try {
			int _type = DROP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:62:6: ( 'drop' )
			// PhoenixSQL.g:62:8: 'drop'
			{
			match("drop"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DROP"

	// $ANTLR start "DUPLICATE"
	public final void mDUPLICATE() throws RecognitionException {
		try {
			int _type = DUPLICATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:63:11: ( 'duplicate' )
			// PhoenixSQL.g:63:13: 'duplicate'
			{
			match("duplicate"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DUPLICATE"

	// $ANTLR start "ELSE"
	public final void mELSE() throws RecognitionException {
		try {
			int _type = ELSE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:64:6: ( 'else' )
			// PhoenixSQL.g:64:8: 'else'
			{
			match("else"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ELSE"

	// $ANTLR start "ENCODED_QUALIFIER"
	public final void mENCODED_QUALIFIER() throws RecognitionException {
		try {
			int _type = ENCODED_QUALIFIER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:65:19: ( 'encoded_qualifier' )
			// PhoenixSQL.g:65:21: 'encoded_qualifier'
			{
			match("encoded_qualifier"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ENCODED_QUALIFIER"

	// $ANTLR start "END"
	public final void mEND() throws RecognitionException {
		try {
			int _type = END;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:66:5: ( 'end' )
			// PhoenixSQL.g:66:7: 'end'
			{
			match("end"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "END"

	// $ANTLR start "EXECUTE"
	public final void mEXECUTE() throws RecognitionException {
		try {
			int _type = EXECUTE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:67:9: ( 'execute' )
			// PhoenixSQL.g:67:11: 'execute'
			{
			match("execute"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EXECUTE"

	// $ANTLR start "EXISTS"
	public final void mEXISTS() throws RecognitionException {
		try {
			int _type = EXISTS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:68:8: ( 'exists' )
			// PhoenixSQL.g:68:10: 'exists'
			{
			match("exists"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EXISTS"

	// $ANTLR start "EXPLAIN"
	public final void mEXPLAIN() throws RecognitionException {
		try {
			int _type = EXPLAIN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:69:9: ( 'explain' )
			// PhoenixSQL.g:69:11: 'explain'
			{
			match("explain"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EXPLAIN"

	// $ANTLR start "FALSE"
	public final void mFALSE() throws RecognitionException {
		try {
			int _type = FALSE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:70:7: ( 'false' )
			// PhoenixSQL.g:70:9: 'false'
			{
			match("false"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FALSE"

	// $ANTLR start "FETCH"
	public final void mFETCH() throws RecognitionException {
		try {
			int _type = FETCH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:71:7: ( 'fetch' )
			// PhoenixSQL.g:71:9: 'fetch'
			{
			match("fetch"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FETCH"

	// $ANTLR start "FIRST"
	public final void mFIRST() throws RecognitionException {
		try {
			int _type = FIRST;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:72:7: ( 'first' )
			// PhoenixSQL.g:72:9: 'first'
			{
			match("first"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FIRST"

	// $ANTLR start "FOR"
	public final void mFOR() throws RecognitionException {
		try {
			int _type = FOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:73:5: ( 'for' )
			// PhoenixSQL.g:73:7: 'for'
			{
			match("for"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FOR"

	// $ANTLR start "FROM"
	public final void mFROM() throws RecognitionException {
		try {
			int _type = FROM;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:74:6: ( 'from' )
			// PhoenixSQL.g:74:8: 'from'
			{
			match("from"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FROM"

	// $ANTLR start "FULL"
	public final void mFULL() throws RecognitionException {
		try {
			int _type = FULL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:75:6: ( 'full' )
			// PhoenixSQL.g:75:8: 'full'
			{
			match("full"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FULL"

	// $ANTLR start "FUNCTION"
	public final void mFUNCTION() throws RecognitionException {
		try {
			int _type = FUNCTION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:76:10: ( 'function' )
			// PhoenixSQL.g:76:12: 'function'
			{
			match("function"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FUNCTION"

	// $ANTLR start "GRANT"
	public final void mGRANT() throws RecognitionException {
		try {
			int _type = GRANT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:77:7: ( 'grant' )
			// PhoenixSQL.g:77:9: 'grant'
			{
			match("grant"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "GRANT"

	// $ANTLR start "GROUP"
	public final void mGROUP() throws RecognitionException {
		try {
			int _type = GROUP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:78:7: ( 'group' )
			// PhoenixSQL.g:78:9: 'group'
			{
			match("group"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "GROUP"

	// $ANTLR start "HAVING"
	public final void mHAVING() throws RecognitionException {
		try {
			int _type = HAVING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:79:8: ( 'having' )
			// PhoenixSQL.g:79:10: 'having'
			{
			match("having"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "HAVING"

	// $ANTLR start "IF"
	public final void mIF() throws RecognitionException {
		try {
			int _type = IF;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:80:4: ( 'if' )
			// PhoenixSQL.g:80:6: 'if'
			{
			match("if"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "IF"

	// $ANTLR start "IGNORE"
	public final void mIGNORE() throws RecognitionException {
		try {
			int _type = IGNORE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:81:8: ( 'ignore' )
			// PhoenixSQL.g:81:10: 'ignore'
			{
			match("ignore"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "IGNORE"

	// $ANTLR start "ILIKE"
	public final void mILIKE() throws RecognitionException {
		try {
			int _type = ILIKE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:82:7: ( 'ilike' )
			// PhoenixSQL.g:82:9: 'ilike'
			{
			match("ilike"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ILIKE"

	// $ANTLR start "IMMUTABLE"
	public final void mIMMUTABLE() throws RecognitionException {
		try {
			int _type = IMMUTABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:83:11: ( 'immutable' )
			// PhoenixSQL.g:83:13: 'immutable'
			{
			match("immutable"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "IMMUTABLE"

	// $ANTLR start "IN"
	public final void mIN() throws RecognitionException {
		try {
			int _type = IN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:84:4: ( 'in' )
			// PhoenixSQL.g:84:6: 'in'
			{
			match("in"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "IN"

	// $ANTLR start "INCLUDE"
	public final void mINCLUDE() throws RecognitionException {
		try {
			int _type = INCLUDE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:85:9: ( 'include' )
			// PhoenixSQL.g:85:11: 'include'
			{
			match("include"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INCLUDE"

	// $ANTLR start "INCREMENT"
	public final void mINCREMENT() throws RecognitionException {
		try {
			int _type = INCREMENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:86:11: ( 'increment' )
			// PhoenixSQL.g:86:13: 'increment'
			{
			match("increment"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INCREMENT"

	// $ANTLR start "INDEX"
	public final void mINDEX() throws RecognitionException {
		try {
			int _type = INDEX;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:87:7: ( 'index' )
			// PhoenixSQL.g:87:9: 'index'
			{
			match("index"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INDEX"

	// $ANTLR start "INNER"
	public final void mINNER() throws RecognitionException {
		try {
			int _type = INNER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:88:7: ( 'inner' )
			// PhoenixSQL.g:88:9: 'inner'
			{
			match("inner"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INNER"

	// $ANTLR start "INTO"
	public final void mINTO() throws RecognitionException {
		try {
			int _type = INTO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:89:6: ( 'into' )
			// PhoenixSQL.g:89:8: 'into'
			{
			match("into"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INTO"

	// $ANTLR start "IS"
	public final void mIS() throws RecognitionException {
		try {
			int _type = IS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:90:4: ( 'is' )
			// PhoenixSQL.g:90:6: 'is'
			{
			match("is"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "IS"

	// $ANTLR start "JAR"
	public final void mJAR() throws RecognitionException {
		try {
			int _type = JAR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:91:5: ( 'jar' )
			// PhoenixSQL.g:91:7: 'jar'
			{
			match("jar"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "JAR"

	// $ANTLR start "JARS"
	public final void mJARS() throws RecognitionException {
		try {
			int _type = JARS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:92:6: ( 'jars' )
			// PhoenixSQL.g:92:8: 'jars'
			{
			match("jars"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "JARS"

	// $ANTLR start "JOIN"
	public final void mJOIN() throws RecognitionException {
		try {
			int _type = JOIN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:93:6: ( 'join' )
			// PhoenixSQL.g:93:8: 'join'
			{
			match("join"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "JOIN"

	// $ANTLR start "KEY"
	public final void mKEY() throws RecognitionException {
		try {
			int _type = KEY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:94:5: ( 'key' )
			// PhoenixSQL.g:94:7: 'key'
			{
			match("key"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "KEY"

	// $ANTLR start "LAST"
	public final void mLAST() throws RecognitionException {
		try {
			int _type = LAST;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:95:6: ( 'last' )
			// PhoenixSQL.g:95:8: 'last'
			{
			match("last"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LAST"

	// $ANTLR start "LEFT"
	public final void mLEFT() throws RecognitionException {
		try {
			int _type = LEFT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:96:6: ( 'left' )
			// PhoenixSQL.g:96:8: 'left'
			{
			match("left"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LEFT"

	// $ANTLR start "LIKE"
	public final void mLIKE() throws RecognitionException {
		try {
			int _type = LIKE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:97:6: ( 'like' )
			// PhoenixSQL.g:97:8: 'like'
			{
			match("like"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LIKE"

	// $ANTLR start "LIMIT"
	public final void mLIMIT() throws RecognitionException {
		try {
			int _type = LIMIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:98:7: ( 'limit' )
			// PhoenixSQL.g:98:9: 'limit'
			{
			match("limit"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LIMIT"

	// $ANTLR start "LIST"
	public final void mLIST() throws RecognitionException {
		try {
			int _type = LIST;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:99:6: ( 'list' )
			// PhoenixSQL.g:99:8: 'list'
			{
			match("list"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LIST"

	// $ANTLR start "LOCAL"
	public final void mLOCAL() throws RecognitionException {
		try {
			int _type = LOCAL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:100:7: ( 'local' )
			// PhoenixSQL.g:100:9: 'local'
			{
			match("local"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LOCAL"

	// $ANTLR start "MAXVALUE"
	public final void mMAXVALUE() throws RecognitionException {
		try {
			int _type = MAXVALUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:101:10: ( 'maxvalue' )
			// PhoenixSQL.g:101:12: 'maxvalue'
			{
			match("maxvalue"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "MAXVALUE"

	// $ANTLR start "MINVALUE"
	public final void mMINVALUE() throws RecognitionException {
		try {
			int _type = MINVALUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:102:10: ( 'minvalue' )
			// PhoenixSQL.g:102:12: 'minvalue'
			{
			match("minvalue"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "MINVALUE"

	// $ANTLR start "NEXT"
	public final void mNEXT() throws RecognitionException {
		try {
			int _type = NEXT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:103:6: ( 'next' )
			// PhoenixSQL.g:103:8: 'next'
			{
			match("next"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NEXT"

	// $ANTLR start "NOT"
	public final void mNOT() throws RecognitionException {
		try {
			int _type = NOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:104:5: ( 'not' )
			// PhoenixSQL.g:104:7: 'not'
			{
			match("not"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NOT"

	// $ANTLR start "NOVERIFY"
	public final void mNOVERIFY() throws RecognitionException {
		try {
			int _type = NOVERIFY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:105:10: ( 'noverify' )
			// PhoenixSQL.g:105:12: 'noverify'
			{
			match("noverify"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NOVERIFY"

	// $ANTLR start "NULL"
	public final void mNULL() throws RecognitionException {
		try {
			int _type = NULL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:106:6: ( 'null' )
			// PhoenixSQL.g:106:8: 'null'
			{
			match("null"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NULL"

	// $ANTLR start "NULLS"
	public final void mNULLS() throws RecognitionException {
		try {
			int _type = NULLS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:107:7: ( 'nulls' )
			// PhoenixSQL.g:107:9: 'nulls'
			{
			match("nulls"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NULLS"

	// $ANTLR start "OFF"
	public final void mOFF() throws RecognitionException {
		try {
			int _type = OFF;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:108:5: ( 'off' )
			// PhoenixSQL.g:108:7: 'off'
			{
			match("off"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OFF"

	// $ANTLR start "OFFSET"
	public final void mOFFSET() throws RecognitionException {
		try {
			int _type = OFFSET;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:109:8: ( 'offset' )
			// PhoenixSQL.g:109:10: 'offset'
			{
			match("offset"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OFFSET"

	// $ANTLR start "ON"
	public final void mON() throws RecognitionException {
		try {
			int _type = ON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:110:4: ( 'on' )
			// PhoenixSQL.g:110:6: 'on'
			{
			match("on"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ON"

	// $ANTLR start "ONLY"
	public final void mONLY() throws RecognitionException {
		try {
			int _type = ONLY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:111:6: ( 'only' )
			// PhoenixSQL.g:111:8: 'only'
			{
			match("only"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ONLY"

	// $ANTLR start "OPEN"
	public final void mOPEN() throws RecognitionException {
		try {
			int _type = OPEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:112:6: ( 'open' )
			// PhoenixSQL.g:112:8: 'open'
			{
			match("open"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OPEN"

	// $ANTLR start "OR"
	public final void mOR() throws RecognitionException {
		try {
			int _type = OR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:113:4: ( 'or' )
			// PhoenixSQL.g:113:6: 'or'
			{
			match("or"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OR"

	// $ANTLR start "ORDER"
	public final void mORDER() throws RecognitionException {
		try {
			int _type = ORDER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:114:7: ( 'order' )
			// PhoenixSQL.g:114:9: 'order'
			{
			match("order"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ORDER"

	// $ANTLR start "OUTER"
	public final void mOUTER() throws RecognitionException {
		try {
			int _type = OUTER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:115:7: ( 'outer' )
			// PhoenixSQL.g:115:9: 'outer'
			{
			match("outer"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OUTER"

	// $ANTLR start "PRIMARY"
	public final void mPRIMARY() throws RecognitionException {
		try {
			int _type = PRIMARY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:116:9: ( 'primary' )
			// PhoenixSQL.g:116:11: 'primary'
			{
			match("primary"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PRIMARY"

	// $ANTLR start "REBUILD"
	public final void mREBUILD() throws RecognitionException {
		try {
			int _type = REBUILD;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:117:9: ( 'rebuild' )
			// PhoenixSQL.g:117:11: 'rebuild'
			{
			match("rebuild"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "REBUILD"

	// $ANTLR start "REGIONS"
	public final void mREGIONS() throws RecognitionException {
		try {
			int _type = REGIONS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:118:9: ( 'regions' )
			// PhoenixSQL.g:118:11: 'regions'
			{
			match("regions"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "REGIONS"

	// $ANTLR start "REPLACE"
	public final void mREPLACE() throws RecognitionException {
		try {
			int _type = REPLACE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:119:9: ( 'replace' )
			// PhoenixSQL.g:119:11: 'replace'
			{
			match("replace"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "REPLACE"

	// $ANTLR start "RETURNS"
	public final void mRETURNS() throws RecognitionException {
		try {
			int _type = RETURNS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:120:9: ( 'returns' )
			// PhoenixSQL.g:120:11: 'returns'
			{
			match("returns"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RETURNS"

	// $ANTLR start "REVOKE"
	public final void mREVOKE() throws RecognitionException {
		try {
			int _type = REVOKE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:121:8: ( 'revoke' )
			// PhoenixSQL.g:121:10: 'revoke'
			{
			match("revoke"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "REVOKE"

	// $ANTLR start "RIGHT"
	public final void mRIGHT() throws RecognitionException {
		try {
			int _type = RIGHT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:122:7: ( 'right' )
			// PhoenixSQL.g:122:9: 'right'
			{
			match("right"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RIGHT"

	// $ANTLR start "ROW"
	public final void mROW() throws RecognitionException {
		try {
			int _type = ROW;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:123:5: ( 'row' )
			// PhoenixSQL.g:123:7: 'row'
			{
			match("row"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ROW"

	// $ANTLR start "ROWS"
	public final void mROWS() throws RecognitionException {
		try {
			int _type = ROWS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:124:6: ( 'rows' )
			// PhoenixSQL.g:124:8: 'rows'
			{
			match("rows"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ROWS"

	// $ANTLR start "ROW_TIMESTAMP"
	public final void mROW_TIMESTAMP() throws RecognitionException {
		try {
			int _type = ROW_TIMESTAMP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:125:15: ( 'row_timestamp' )
			// PhoenixSQL.g:125:17: 'row_timestamp'
			{
			match("row_timestamp"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ROW_TIMESTAMP"

	// $ANTLR start "SAMPLING"
	public final void mSAMPLING() throws RecognitionException {
		try {
			int _type = SAMPLING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:126:10: ( 'sampling' )
			// PhoenixSQL.g:126:12: 'sampling'
			{
			match("sampling"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SAMPLING"

	// $ANTLR start "SCHEMA"
	public final void mSCHEMA() throws RecognitionException {
		try {
			int _type = SCHEMA;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:127:8: ( 'schema' )
			// PhoenixSQL.g:127:10: 'schema'
			{
			match("schema"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SCHEMA"

	// $ANTLR start "SCHEMAS"
	public final void mSCHEMAS() throws RecognitionException {
		try {
			int _type = SCHEMAS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:128:9: ( 'schemas' )
			// PhoenixSQL.g:128:11: 'schemas'
			{
			match("schemas"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SCHEMAS"

	// $ANTLR start "SELECT"
	public final void mSELECT() throws RecognitionException {
		try {
			int _type = SELECT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:129:8: ( 'select' )
			// PhoenixSQL.g:129:10: 'select'
			{
			match("select"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SELECT"

	// $ANTLR start "SEQUENCE"
	public final void mSEQUENCE() throws RecognitionException {
		try {
			int _type = SEQUENCE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:130:10: ( 'sequence' )
			// PhoenixSQL.g:130:12: 'sequence'
			{
			match("sequence"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SEQUENCE"

	// $ANTLR start "SESSION"
	public final void mSESSION() throws RecognitionException {
		try {
			int _type = SESSION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:131:9: ( 'session' )
			// PhoenixSQL.g:131:11: 'session'
			{
			match("session"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SESSION"

	// $ANTLR start "SET"
	public final void mSET() throws RecognitionException {
		try {
			int _type = SET;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:132:5: ( 'set' )
			// PhoenixSQL.g:132:7: 'set'
			{
			match("set"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SET"

	// $ANTLR start "SHOW"
	public final void mSHOW() throws RecognitionException {
		try {
			int _type = SHOW;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:133:6: ( 'show' )
			// PhoenixSQL.g:133:8: 'show'
			{
			match("show"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SHOW"

	// $ANTLR start "SOME"
	public final void mSOME() throws RecognitionException {
		try {
			int _type = SOME;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:134:6: ( 'some' )
			// PhoenixSQL.g:134:8: 'some'
			{
			match("some"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SOME"

	// $ANTLR start "SPLIT"
	public final void mSPLIT() throws RecognitionException {
		try {
			int _type = SPLIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:135:7: ( 'split' )
			// PhoenixSQL.g:135:9: 'split'
			{
			match("split"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SPLIT"

	// $ANTLR start "START"
	public final void mSTART() throws RecognitionException {
		try {
			int _type = START;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:136:7: ( 'start' )
			// PhoenixSQL.g:136:9: 'start'
			{
			match("start"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "START"

	// $ANTLR start "STATISTICS"
	public final void mSTATISTICS() throws RecognitionException {
		try {
			int _type = STATISTICS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:137:12: ( 'statistics' )
			// PhoenixSQL.g:137:14: 'statistics'
			{
			match("statistics"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "STATISTICS"

	// $ANTLR start "TABLE"
	public final void mTABLE() throws RecognitionException {
		try {
			int _type = TABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:138:7: ( 'table' )
			// PhoenixSQL.g:138:9: 'table'
			{
			match("table"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TABLE"

	// $ANTLR start "TABLES"
	public final void mTABLES() throws RecognitionException {
		try {
			int _type = TABLES;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:139:8: ( 'tables' )
			// PhoenixSQL.g:139:10: 'tables'
			{
			match("tables"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TABLES"

	// $ANTLR start "TABLESAMPLE"
	public final void mTABLESAMPLE() throws RecognitionException {
		try {
			int _type = TABLESAMPLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:140:13: ( 'tablesample' )
			// PhoenixSQL.g:140:15: 'tablesample'
			{
			match("tablesample"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TABLESAMPLE"

	// $ANTLR start "TEMPORARY"
	public final void mTEMPORARY() throws RecognitionException {
		try {
			int _type = TEMPORARY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:141:11: ( 'temporary' )
			// PhoenixSQL.g:141:13: 'temporary'
			{
			match("temporary"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TEMPORARY"

	// $ANTLR start "THEN"
	public final void mTHEN() throws RecognitionException {
		try {
			int _type = THEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:142:6: ( 'then' )
			// PhoenixSQL.g:142:8: 'then'
			{
			match("then"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "THEN"

	// $ANTLR start "TO"
	public final void mTO() throws RecognitionException {
		try {
			int _type = TO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:143:4: ( 'to' )
			// PhoenixSQL.g:143:6: 'to'
			{
			match("to"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TO"

	// $ANTLR start "TRACE"
	public final void mTRACE() throws RecognitionException {
		try {
			int _type = TRACE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:144:7: ( 'trace' )
			// PhoenixSQL.g:144:9: 'trace'
			{
			match("trace"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TRACE"

	// $ANTLR start "TRUE"
	public final void mTRUE() throws RecognitionException {
		try {
			int _type = TRUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:145:6: ( 'true' )
			// PhoenixSQL.g:145:8: 'true'
			{
			match("true"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TRUE"

	// $ANTLR start "UNCOVERED"
	public final void mUNCOVERED() throws RecognitionException {
		try {
			int _type = UNCOVERED;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:146:11: ( 'uncovered' )
			// PhoenixSQL.g:146:13: 'uncovered'
			{
			match("uncovered"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UNCOVERED"

	// $ANTLR start "UNION"
	public final void mUNION() throws RecognitionException {
		try {
			int _type = UNION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:147:7: ( 'union' )
			// PhoenixSQL.g:147:9: 'union'
			{
			match("union"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UNION"

	// $ANTLR start "UNUSABLE"
	public final void mUNUSABLE() throws RecognitionException {
		try {
			int _type = UNUSABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:148:10: ( 'unusable' )
			// PhoenixSQL.g:148:12: 'unusable'
			{
			match("unusable"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UNUSABLE"

	// $ANTLR start "UPDATE"
	public final void mUPDATE() throws RecognitionException {
		try {
			int _type = UPDATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:149:8: ( 'update' )
			// PhoenixSQL.g:149:10: 'update'
			{
			match("update"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UPDATE"

	// $ANTLR start "UPGRADE"
	public final void mUPGRADE() throws RecognitionException {
		try {
			int _type = UPGRADE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:150:9: ( 'upgrade' )
			// PhoenixSQL.g:150:11: 'upgrade'
			{
			match("upgrade"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UPGRADE"

	// $ANTLR start "UPSERT"
	public final void mUPSERT() throws RecognitionException {
		try {
			int _type = UPSERT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:151:8: ( 'upsert' )
			// PhoenixSQL.g:151:10: 'upsert'
			{
			match("upsert"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UPSERT"

	// $ANTLR start "USABLE"
	public final void mUSABLE() throws RecognitionException {
		try {
			int _type = USABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:152:8: ( 'usable' )
			// PhoenixSQL.g:152:10: 'usable'
			{
			match("usable"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "USABLE"

	// $ANTLR start "USE"
	public final void mUSE() throws RecognitionException {
		try {
			int _type = USE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:153:5: ( 'use' )
			// PhoenixSQL.g:153:7: 'use'
			{
			match("use"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "USE"

	// $ANTLR start "USING"
	public final void mUSING() throws RecognitionException {
		try {
			int _type = USING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:154:7: ( 'using' )
			// PhoenixSQL.g:154:9: 'using'
			{
			match("using"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "USING"

	// $ANTLR start "VALUE"
	public final void mVALUE() throws RecognitionException {
		try {
			int _type = VALUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:155:7: ( 'value' )
			// PhoenixSQL.g:155:9: 'value'
			{
			match("value"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "VALUE"

	// $ANTLR start "VALUES"
	public final void mVALUES() throws RecognitionException {
		try {
			int _type = VALUES;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:156:8: ( 'values' )
			// PhoenixSQL.g:156:10: 'values'
			{
			match("values"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "VALUES"

	// $ANTLR start "VIEW"
	public final void mVIEW() throws RecognitionException {
		try {
			int _type = VIEW;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:157:6: ( 'view' )
			// PhoenixSQL.g:157:8: 'view'
			{
			match("view"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "VIEW"

	// $ANTLR start "WHEN"
	public final void mWHEN() throws RecognitionException {
		try {
			int _type = WHEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:158:6: ( 'when' )
			// PhoenixSQL.g:158:8: 'when'
			{
			match("when"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "WHEN"

	// $ANTLR start "WHERE"
	public final void mWHERE() throws RecognitionException {
		try {
			int _type = WHERE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:159:7: ( 'where' )
			// PhoenixSQL.g:159:9: 'where'
			{
			match("where"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "WHERE"

	// $ANTLR start "WITH"
	public final void mWITH() throws RecognitionException {
		try {
			int _type = WITH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:160:6: ( 'with' )
			// PhoenixSQL.g:160:8: 'with'
			{
			match("with"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "WITH"

	// $ANTLR start "WITHIN"
	public final void mWITHIN() throws RecognitionException {
		try {
			int _type = WITHIN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:161:8: ( 'within' )
			// PhoenixSQL.g:161:10: 'within'
			{
			match("within"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "WITHIN"

	// $ANTLR start "HINT_START"
	public final void mHINT_START() throws RecognitionException {
		try {
			int _type = HINT_START;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1274:11: ( '/*+' )
			// PhoenixSQL.g:1274:13: '/*+'
			{
			match("/*+"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "HINT_START"

	// $ANTLR start "COMMENT_START"
	public final void mCOMMENT_START() throws RecognitionException {
		try {
			int _type = COMMENT_START;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1275:14: ( '/*' )
			// PhoenixSQL.g:1275:16: '/*'
			{
			match("/*"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COMMENT_START"

	// $ANTLR start "COMMENT_AND_HINT_END"
	public final void mCOMMENT_AND_HINT_END() throws RecognitionException {
		try {
			int _type = COMMENT_AND_HINT_END;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1276:21: ( '*/' )
			// PhoenixSQL.g:1276:23: '*/'
			{
			match("*/"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COMMENT_AND_HINT_END"

	// $ANTLR start "SL_COMMENT1"
	public final void mSL_COMMENT1() throws RecognitionException {
		try {
			int _type = SL_COMMENT1;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1277:12: ( '//' )
			// PhoenixSQL.g:1277:14: '//'
			{
			match("//"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SL_COMMENT1"

	// $ANTLR start "SL_COMMENT2"
	public final void mSL_COMMENT2() throws RecognitionException {
		try {
			int _type = SL_COMMENT2;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1278:12: ( '--' )
			// PhoenixSQL.g:1278:14: '--'
			{
			match("--"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SL_COMMENT2"

	// $ANTLR start "BIND_NAME"
	public final void mBIND_NAME() throws RecognitionException {
		try {
			int _type = BIND_NAME;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1282:5: ( COLON ( DIGIT )+ )
			// PhoenixSQL.g:1282:7: COLON ( DIGIT )+
			{
			mCOLON(); if (state.failed) return;

			// PhoenixSQL.g:1282:13: ( DIGIT )+
			int cnt1=0;
			loop1:
			while (true) {
				int alt1=2;
				int LA1_0 = input.LA(1);
				if ( ((LA1_0 >= '0' && LA1_0 <= '9')) ) {
					alt1=1;
				}

				switch (alt1) {
				case 1 :
					// PhoenixSQL.g:
					{
					if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
						input.consume();
						state.failed=false;
					}
					else {
						if (state.backtracking>0) {state.failed=true; return;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					if ( cnt1 >= 1 ) break loop1;
					if (state.backtracking>0) {state.failed=true; return;}
					EarlyExitException eee = new EarlyExitException(1, input);
					throw eee;
				}
				cnt1++;
			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BIND_NAME"

	// $ANTLR start "HEX_LITERAL"
	public final void mHEX_LITERAL() throws RecognitionException {
		try {
			int _type = HEX_LITERAL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken d=null;

			 StringBuilder sb = new StringBuilder();
			// PhoenixSQL.g:1287:5: ( X ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= HEX_DIGIT ( ' ' )* )* '\\'' )? )
			// PhoenixSQL.g:1288:5: X ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= HEX_DIGIT ( ' ' )* )* '\\'' )?
			{
			mX(); if (state.failed) return;

			if ( state.backtracking==0 ) { _type = NAME;}
			// PhoenixSQL.g:1289:5: ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= HEX_DIGIT ( ' ' )* )* '\\'' )?
			int alt6=3;
			int LA6_0 = input.LA(1);
			if ( ((LA6_0 >= '0' && LA6_0 <= '9')||(LA6_0 >= 'A' && LA6_0 <= 'Z')||LA6_0=='_'||(LA6_0 >= 'a' && LA6_0 <= 'z')||(LA6_0 >= '\u0080' && LA6_0 <= '\u2001')||(LA6_0 >= '\u2003' && LA6_0 <= '\uFFFE')) && (synpred1_PhoenixSQL())) {
				alt6=1;
			}
			else if ( (LA6_0=='\'') && (synpred2_PhoenixSQL())) {
				alt6=2;
			}
			switch (alt6) {
				case 1 :
					// PhoenixSQL.g:1290:5: ( FIELDCHAR )=> ( FIELDCHAR )+
					{
					// PhoenixSQL.g:1290:20: ( FIELDCHAR )+
					int cnt2=0;
					loop2:
					while (true) {
						int alt2=2;
						int LA2_0 = input.LA(1);
						if ( ((LA2_0 >= '0' && LA2_0 <= '9')||(LA2_0 >= 'A' && LA2_0 <= 'Z')||LA2_0=='_'||(LA2_0 >= 'a' && LA2_0 <= 'z')||(LA2_0 >= '\u0080' && LA2_0 <= '\u2001')||(LA2_0 >= '\u2003' && LA2_0 <= '\uFFFE')) ) {
							alt2=1;
						}

						switch (alt2) {
						case 1 :
							// PhoenixSQL.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
								input.consume();
								state.failed=false;
							}
							else {
								if (state.backtracking>0) {state.failed=true; return;}
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							if ( cnt2 >= 1 ) break loop2;
							if (state.backtracking>0) {state.failed=true; return;}
							EarlyExitException eee = new EarlyExitException(2, input);
							throw eee;
						}
						cnt2++;
					}

					}
					break;
				case 2 :
					// PhoenixSQL.g:1291:7: ( '\\'' )=> '\\'' ( ' ' )* (d= HEX_DIGIT ( ' ' )* )* '\\''
					{
					match('\''); if (state.failed) return;
					// PhoenixSQL.g:1291:22: ( ' ' )*
					loop3:
					while (true) {
						int alt3=2;
						int LA3_0 = input.LA(1);
						if ( (LA3_0==' ') ) {
							alt3=1;
						}

						switch (alt3) {
						case 1 :
							// PhoenixSQL.g:1291:22: ' '
							{
							match(' '); if (state.failed) return;
							}
							break;

						default :
							break loop3;
						}
					}

					// PhoenixSQL.g:1291:27: (d= HEX_DIGIT ( ' ' )* )*
					loop5:
					while (true) {
						int alt5=2;
						int LA5_0 = input.LA(1);
						if ( ((LA5_0 >= '0' && LA5_0 <= '9')||(LA5_0 >= 'A' && LA5_0 <= 'F')||(LA5_0 >= 'a' && LA5_0 <= 'f')) ) {
							alt5=1;
						}

						switch (alt5) {
						case 1 :
							// PhoenixSQL.g:1291:29: d= HEX_DIGIT ( ' ' )*
							{
							int dStart1197 = getCharIndex();
							int dStartLine1197 = getLine();
							int dStartCharPos1197 = getCharPositionInLine();
							mHEX_DIGIT(); if (state.failed) return;
							d = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, dStart1197, getCharIndex()-1);
							d.setLine(dStartLine1197);
							d.setCharPositionInLine(dStartCharPos1197);

							if ( state.backtracking==0 ) { sb.append(d.getText()); }
							// PhoenixSQL.g:1291:69: ( ' ' )*
							loop4:
							while (true) {
								int alt4=2;
								int LA4_0 = input.LA(1);
								if ( (LA4_0==' ') ) {
									alt4=1;
								}

								switch (alt4) {
								case 1 :
									// PhoenixSQL.g:1291:69: ' '
									{
									match(' '); if (state.failed) return;
									}
									break;

								default :
									break loop4;
								}
							}

							}
							break;

						default :
							break loop5;
						}
					}

					match('\''); if (state.failed) return;
					if ( state.backtracking==0 ) { _type=HEX_LITERAL; }
					}
					break;

			}

			if ( state.backtracking==0 ) { if (_type == HEX_LITERAL) { setText(sb.toString()); } }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "HEX_LITERAL"

	// $ANTLR start "BIN_LITERAL"
	public final void mBIN_LITERAL() throws RecognitionException {
		try {
			int _type = BIN_LITERAL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken d=null;

			 StringBuilder sb = new StringBuilder();
			// PhoenixSQL.g:1298:5: ( B ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= BIN_DIGIT ( ' ' )* )* '\\'' )? )
			// PhoenixSQL.g:1299:5: B ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= BIN_DIGIT ( ' ' )* )* '\\'' )?
			{
			mB(); if (state.failed) return;

			if ( state.backtracking==0 ) { _type = NAME;}
			// PhoenixSQL.g:1300:5: ( ( FIELDCHAR )=> ( FIELDCHAR )+ | ( '\\'' )=> '\\'' ( ' ' )* (d= BIN_DIGIT ( ' ' )* )* '\\'' )?
			int alt11=3;
			int LA11_0 = input.LA(1);
			if ( ((LA11_0 >= '0' && LA11_0 <= '9')||(LA11_0 >= 'A' && LA11_0 <= 'Z')||LA11_0=='_'||(LA11_0 >= 'a' && LA11_0 <= 'z')||(LA11_0 >= '\u0080' && LA11_0 <= '\u2001')||(LA11_0 >= '\u2003' && LA11_0 <= '\uFFFE')) && (synpred3_PhoenixSQL())) {
				alt11=1;
			}
			else if ( (LA11_0=='\'') && (synpred4_PhoenixSQL())) {
				alt11=2;
			}
			switch (alt11) {
				case 1 :
					// PhoenixSQL.g:1301:5: ( FIELDCHAR )=> ( FIELDCHAR )+
					{
					// PhoenixSQL.g:1301:20: ( FIELDCHAR )+
					int cnt7=0;
					loop7:
					while (true) {
						int alt7=2;
						int LA7_0 = input.LA(1);
						if ( ((LA7_0 >= '0' && LA7_0 <= '9')||(LA7_0 >= 'A' && LA7_0 <= 'Z')||LA7_0=='_'||(LA7_0 >= 'a' && LA7_0 <= 'z')||(LA7_0 >= '\u0080' && LA7_0 <= '\u2001')||(LA7_0 >= '\u2003' && LA7_0 <= '\uFFFE')) ) {
							alt7=1;
						}

						switch (alt7) {
						case 1 :
							// PhoenixSQL.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
								input.consume();
								state.failed=false;
							}
							else {
								if (state.backtracking>0) {state.failed=true; return;}
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							if ( cnt7 >= 1 ) break loop7;
							if (state.backtracking>0) {state.failed=true; return;}
							EarlyExitException eee = new EarlyExitException(7, input);
							throw eee;
						}
						cnt7++;
					}

					}
					break;
				case 2 :
					// PhoenixSQL.g:1302:7: ( '\\'' )=> '\\'' ( ' ' )* (d= BIN_DIGIT ( ' ' )* )* '\\''
					{
					match('\''); if (state.failed) return;
					// PhoenixSQL.g:1302:23: ( ' ' )*
					loop8:
					while (true) {
						int alt8=2;
						int LA8_0 = input.LA(1);
						if ( (LA8_0==' ') ) {
							alt8=1;
						}

						switch (alt8) {
						case 1 :
							// PhoenixSQL.g:1302:23: ' '
							{
							match(' '); if (state.failed) return;
							}
							break;

						default :
							break loop8;
						}
					}

					// PhoenixSQL.g:1302:28: (d= BIN_DIGIT ( ' ' )* )*
					loop10:
					while (true) {
						int alt10=2;
						int LA10_0 = input.LA(1);
						if ( ((LA10_0 >= '0' && LA10_0 <= '1')) ) {
							alt10=1;
						}

						switch (alt10) {
						case 1 :
							// PhoenixSQL.g:1302:30: d= BIN_DIGIT ( ' ' )*
							{
							int dStart1291 = getCharIndex();
							int dStartLine1291 = getLine();
							int dStartCharPos1291 = getCharPositionInLine();
							mBIN_DIGIT(); if (state.failed) return;
							d = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, dStart1291, getCharIndex()-1);
							d.setLine(dStartLine1291);
							d.setCharPositionInLine(dStartCharPos1291);

							if ( state.backtracking==0 ) { sb.append(d.getText()); }
							// PhoenixSQL.g:1302:70: ( ' ' )*
							loop9:
							while (true) {
								int alt9=2;
								int LA9_0 = input.LA(1);
								if ( (LA9_0==' ') ) {
									alt9=1;
								}

								switch (alt9) {
								case 1 :
									// PhoenixSQL.g:1302:70: ' '
									{
									match(' '); if (state.failed) return;
									}
									break;

								default :
									break loop9;
								}
							}

							}
							break;

						default :
							break loop10;
						}
					}

					match('\''); if (state.failed) return;
					if ( state.backtracking==0 ) { _type=BIN_LITERAL; }
					}
					break;

			}

			if ( state.backtracking==0 ) { if (_type == BIN_LITERAL) { setText(sb.toString()); } }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BIN_LITERAL"

	// $ANTLR start "NAME"
	public final void mNAME() throws RecognitionException {
		try {
			int _type = NAME;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1308:5: ( LETTER ( FIELDCHAR )* | '\\\"' ( DBL_QUOTE_CHAR )* '\\\"' )
			int alt14=2;
			int LA14_0 = input.LA(1);
			if ( ((LA14_0 >= 'A' && LA14_0 <= 'Z')||(LA14_0 >= 'a' && LA14_0 <= 'z')) ) {
				alt14=1;
			}
			else if ( (LA14_0=='\"') ) {
				alt14=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae =
					new NoViableAltException("", 14, 0, input);
				throw nvae;
			}

			switch (alt14) {
				case 1 :
					// PhoenixSQL.g:1308:10: LETTER ( FIELDCHAR )*
					{
					mLETTER(); if (state.failed) return;

					// PhoenixSQL.g:1308:17: ( FIELDCHAR )*
					loop12:
					while (true) {
						int alt12=2;
						int LA12_0 = input.LA(1);
						if ( ((LA12_0 >= '0' && LA12_0 <= '9')||(LA12_0 >= 'A' && LA12_0 <= 'Z')||LA12_0=='_'||(LA12_0 >= 'a' && LA12_0 <= 'z')||(LA12_0 >= '\u0080' && LA12_0 <= '\u2001')||(LA12_0 >= '\u2003' && LA12_0 <= '\uFFFE')) ) {
							alt12=1;
						}

						switch (alt12) {
						case 1 :
							// PhoenixSQL.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
								input.consume();
								state.failed=false;
							}
							else {
								if (state.backtracking>0) {state.failed=true; return;}
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							break loop12;
						}
					}

					}
					break;
				case 2 :
					// PhoenixSQL.g:1309:10: '\\\"' ( DBL_QUOTE_CHAR )* '\\\"'
					{
					match('\"'); if (state.failed) return;
					// PhoenixSQL.g:1309:15: ( DBL_QUOTE_CHAR )*
					loop13:
					while (true) {
						int alt13=2;
						int LA13_0 = input.LA(1);
						if ( ((LA13_0 >= '\u0000' && LA13_0 <= '!')||(LA13_0 >= '#' && LA13_0 <= '\uFFFF')) ) {
							alt13=1;
						}

						switch (alt13) {
						case 1 :
							// PhoenixSQL.g:1309:16: DBL_QUOTE_CHAR
							{
							mDBL_QUOTE_CHAR(); if (state.failed) return;

							}
							break;

						default :
							break loop13;
						}
					}

					match('\"'); if (state.failed) return;
					}
					break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NAME"

	// $ANTLR start "NUMBER"
	public final void mNUMBER() throws RecognitionException {
		try {
			int _type = NUMBER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1314:5: ( POSINTEGER )
			// PhoenixSQL.g:1314:9: POSINTEGER
			{
			mPOSINTEGER(); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NUMBER"

	// $ANTLR start "DECIMAL"
	public final void mDECIMAL() throws RecognitionException {
		try {
			int _type = DECIMAL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1318:2: ( ( POSINTEGER )? '.' POSINTEGER )
			// PhoenixSQL.g:1318:4: ( POSINTEGER )? '.' POSINTEGER
			{
			// PhoenixSQL.g:1318:4: ( POSINTEGER )?
			int alt15=2;
			int LA15_0 = input.LA(1);
			if ( ((LA15_0 >= '0' && LA15_0 <= '9')) ) {
				alt15=1;
			}
			switch (alt15) {
				case 1 :
					// PhoenixSQL.g:1318:4: POSINTEGER
					{
					mPOSINTEGER(); if (state.failed) return;

					}
					break;

			}

			match('.'); if (state.failed) return;
			mPOSINTEGER(); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DECIMAL"

	// $ANTLR start "DOUBLE"
	public final void mDOUBLE() throws RecognitionException {
		try {
			int _type = DOUBLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1322:5: ( '.' POSINTEGER Exponent | POSINTEGER '.' Exponent | POSINTEGER ( '.' ( POSINTEGER ( Exponent )? )? | Exponent ) )
			int alt19=3;
			alt19 = dfa19.predict(input);
			switch (alt19) {
				case 1 :
					// PhoenixSQL.g:1322:9: '.' POSINTEGER Exponent
					{
					match('.'); if (state.failed) return;
					mPOSINTEGER(); if (state.failed) return;

					mExponent(); if (state.failed) return;

					}
					break;
				case 2 :
					// PhoenixSQL.g:1323:9: POSINTEGER '.' Exponent
					{
					mPOSINTEGER(); if (state.failed) return;

					match('.'); if (state.failed) return;
					mExponent(); if (state.failed) return;

					}
					break;
				case 3 :
					// PhoenixSQL.g:1324:9: POSINTEGER ( '.' ( POSINTEGER ( Exponent )? )? | Exponent )
					{
					mPOSINTEGER(); if (state.failed) return;

					// PhoenixSQL.g:1324:20: ( '.' ( POSINTEGER ( Exponent )? )? | Exponent )
					int alt18=2;
					int LA18_0 = input.LA(1);
					if ( (LA18_0=='.') ) {
						alt18=1;
					}
					else if ( (LA18_0=='E'||LA18_0=='e') ) {
						alt18=2;
					}

					else {
						if (state.backtracking>0) {state.failed=true; return;}
						NoViableAltException nvae =
							new NoViableAltException("", 18, 0, input);
						throw nvae;
					}

					switch (alt18) {
						case 1 :
							// PhoenixSQL.g:1324:21: '.' ( POSINTEGER ( Exponent )? )?
							{
							match('.'); if (state.failed) return;
							// PhoenixSQL.g:1324:25: ( POSINTEGER ( Exponent )? )?
							int alt17=2;
							int LA17_0 = input.LA(1);
							if ( ((LA17_0 >= '0' && LA17_0 <= '9')) ) {
								alt17=1;
							}
							switch (alt17) {
								case 1 :
									// PhoenixSQL.g:1324:26: POSINTEGER ( Exponent )?
									{
									mPOSINTEGER(); if (state.failed) return;

									// PhoenixSQL.g:1324:37: ( Exponent )?
									int alt16=2;
									int LA16_0 = input.LA(1);
									if ( (LA16_0=='E'||LA16_0=='e') ) {
										alt16=1;
									}
									switch (alt16) {
										case 1 :
											// PhoenixSQL.g:1324:38: Exponent
											{
											mExponent(); if (state.failed) return;

											}
											break;

									}

									}
									break;

							}

							}
							break;
						case 2 :
							// PhoenixSQL.g:1324:53: Exponent
							{
							mExponent(); if (state.failed) return;

							}
							break;

					}

					}
					break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOUBLE"

	// $ANTLR start "Exponent"
	public final void mExponent() throws RecognitionException {
		try {
			int _type = Exponent;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1328:5: ( ( 'e' | 'E' ) ( PLUS | MINUS )? POSINTEGER )
			// PhoenixSQL.g:1328:10: ( 'e' | 'E' ) ( PLUS | MINUS )? POSINTEGER
			{
			if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PhoenixSQL.g:1328:22: ( PLUS | MINUS )?
			int alt20=2;
			int LA20_0 = input.LA(1);
			if ( (LA20_0=='+'||LA20_0=='-') ) {
				alt20=1;
			}
			switch (alt20) {
				case 1 :
					// PhoenixSQL.g:
					{
					if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
						input.consume();
						state.failed=false;
					}
					else {
						if (state.backtracking>0) {state.failed=true; return;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

			}

			mPOSINTEGER(); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "Exponent"

	// $ANTLR start "DOUBLE_QUOTE"
	public final void mDOUBLE_QUOTE() throws RecognitionException {
		try {
			int _type = DOUBLE_QUOTE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1332:5: ( '\"' )
			// PhoenixSQL.g:1332:9: '\"'
			{
			match('\"'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOUBLE_QUOTE"

	// $ANTLR start "EQ"
	public final void mEQ() throws RecognitionException {
		try {
			int _type = EQ;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1336:5: ( '=' )
			// PhoenixSQL.g:1336:9: '='
			{
			match('='); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EQ"

	// $ANTLR start "LT"
	public final void mLT() throws RecognitionException {
		try {
			int _type = LT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1340:5: ( '<' )
			// PhoenixSQL.g:1340:9: '<'
			{
			match('<'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LT"

	// $ANTLR start "GT"
	public final void mGT() throws RecognitionException {
		try {
			int _type = GT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1344:5: ( '>' )
			// PhoenixSQL.g:1344:9: '>'
			{
			match('>'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "GT"

	// $ANTLR start "DOUBLE_EQ"
	public final void mDOUBLE_EQ() throws RecognitionException {
		try {
			int _type = DOUBLE_EQ;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1348:5: ( '=' '=' )
			// PhoenixSQL.g:1348:9: '=' '='
			{
			match('='); if (state.failed) return;
			match('='); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOUBLE_EQ"

	// $ANTLR start "NOEQ1"
	public final void mNOEQ1() throws RecognitionException {
		try {
			int _type = NOEQ1;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1352:5: ( '!' '=' )
			// PhoenixSQL.g:1352:9: '!' '='
			{
			match('!'); if (state.failed) return;
			match('='); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NOEQ1"

	// $ANTLR start "NOEQ2"
	public final void mNOEQ2() throws RecognitionException {
		try {
			int _type = NOEQ2;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1356:5: ( '<' '>' )
			// PhoenixSQL.g:1356:9: '<' '>'
			{
			match('<'); if (state.failed) return;
			match('>'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NOEQ2"

	// $ANTLR start "CONCAT"
	public final void mCONCAT() throws RecognitionException {
		try {
			int _type = CONCAT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1360:5: ( '|' '|' )
			// PhoenixSQL.g:1360:9: '|' '|'
			{
			match('|'); if (state.failed) return;
			match('|'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CONCAT"

	// $ANTLR start "COMMA"
	public final void mCOMMA() throws RecognitionException {
		try {
			int _type = COMMA;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1364:5: ( ',' )
			// PhoenixSQL.g:1364:9: ','
			{
			match(','); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COMMA"

	// $ANTLR start "LPAREN"
	public final void mLPAREN() throws RecognitionException {
		try {
			int _type = LPAREN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1368:5: ( '(' )
			// PhoenixSQL.g:1368:9: '('
			{
			match('('); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LPAREN"

	// $ANTLR start "RPAREN"
	public final void mRPAREN() throws RecognitionException {
		try {
			int _type = RPAREN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1372:5: ( ')' )
			// PhoenixSQL.g:1372:9: ')'
			{
			match(')'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RPAREN"

	// $ANTLR start "SEMICOLON"
	public final void mSEMICOLON() throws RecognitionException {
		try {
			int _type = SEMICOLON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1376:5: ( ';' )
			// PhoenixSQL.g:1376:9: ';'
			{
			match(';'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SEMICOLON"

	// $ANTLR start "COLON"
	public final void mCOLON() throws RecognitionException {
		try {
			int _type = COLON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1380:5: ( ':' )
			// PhoenixSQL.g:1380:9: ':'
			{
			match(':'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COLON"

	// $ANTLR start "QUESTION"
	public final void mQUESTION() throws RecognitionException {
		try {
			int _type = QUESTION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1384:5: ( '?' )
			// PhoenixSQL.g:1384:9: '?'
			{
			match('?'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QUESTION"

	// $ANTLR start "LSQUARE"
	public final void mLSQUARE() throws RecognitionException {
		try {
			int _type = LSQUARE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1388:5: ( '[' )
			// PhoenixSQL.g:1388:9: '['
			{
			match('['); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LSQUARE"

	// $ANTLR start "RSQUARE"
	public final void mRSQUARE() throws RecognitionException {
		try {
			int _type = RSQUARE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1392:5: ( ']' )
			// PhoenixSQL.g:1392:9: ']'
			{
			match(']'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RSQUARE"

	// $ANTLR start "LCURLY"
	public final void mLCURLY() throws RecognitionException {
		try {
			int _type = LCURLY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1396:5: ( '{' )
			// PhoenixSQL.g:1396:9: '{'
			{
			match('{'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LCURLY"

	// $ANTLR start "RCURLY"
	public final void mRCURLY() throws RecognitionException {
		try {
			int _type = RCURLY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1400:5: ( '}' )
			// PhoenixSQL.g:1400:9: '}'
			{
			match('}'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RCURLY"

	// $ANTLR start "AT"
	public final void mAT() throws RecognitionException {
		try {
			int _type = AT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1404:5: ( '@' )
			// PhoenixSQL.g:1404:9: '@'
			{
			match('@'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "AT"

	// $ANTLR start "TILDE"
	public final void mTILDE() throws RecognitionException {
		try {
			int _type = TILDE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1408:5: ( '~' )
			// PhoenixSQL.g:1408:9: '~'
			{
			match('~'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TILDE"

	// $ANTLR start "PLUS"
	public final void mPLUS() throws RecognitionException {
		try {
			int _type = PLUS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1412:5: ( '+' )
			// PhoenixSQL.g:1412:9: '+'
			{
			match('+'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLUS"

	// $ANTLR start "MINUS"
	public final void mMINUS() throws RecognitionException {
		try {
			int _type = MINUS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1416:5: ( '-' )
			// PhoenixSQL.g:1416:9: '-'
			{
			match('-'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "MINUS"

	// $ANTLR start "ASTERISK"
	public final void mASTERISK() throws RecognitionException {
		try {
			int _type = ASTERISK;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1420:5: ( '*' )
			// PhoenixSQL.g:1420:9: '*'
			{
			match('*'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ASTERISK"

	// $ANTLR start "DIVIDE"
	public final void mDIVIDE() throws RecognitionException {
		try {
			int _type = DIVIDE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1424:5: ( '/' )
			// PhoenixSQL.g:1424:9: '/'
			{
			match('/'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DIVIDE"

	// $ANTLR start "PERCENT"
	public final void mPERCENT() throws RecognitionException {
		try {
			int _type = PERCENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1428:5: ( '%' )
			// PhoenixSQL.g:1428:9: '%'
			{
			match('%'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PERCENT"

	// $ANTLR start "OUTER_JOIN"
	public final void mOUTER_JOIN() throws RecognitionException {
		try {
			int _type = OUTER_JOIN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1432:5: ( '(' '+' ')' )
			// PhoenixSQL.g:1432:7: '(' '+' ')'
			{
			match('('); if (state.failed) return;
			match('+'); if (state.failed) return;
			match(')'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OUTER_JOIN"

	// $ANTLR start "FIELDCHAR"
	public final void mFIELDCHAR() throws RecognitionException {
		try {
			// PhoenixSQL.g:1438:5: ( LETTER | DIGIT | '_' | '\\u0080' .. '\\u2001' | '\\u2003' .. '\\ufffe' )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FIELDCHAR"

	// $ANTLR start "LETTER"
	public final void mLETTER() throws RecognitionException {
		try {
			// PhoenixSQL.g:1448:5: ( 'a' .. 'z' | 'A' .. 'Z' )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LETTER"

	// $ANTLR start "POSINTEGER"
	public final void mPOSINTEGER() throws RecognitionException {
		try {
			// PhoenixSQL.g:1454:5: ( ( DIGIT )+ )
			// PhoenixSQL.g:1454:9: ( DIGIT )+
			{
			// PhoenixSQL.g:1454:9: ( DIGIT )+
			int cnt21=0;
			loop21:
			while (true) {
				int alt21=2;
				int LA21_0 = input.LA(1);
				if ( ((LA21_0 >= '0' && LA21_0 <= '9')) ) {
					alt21=1;
				}

				switch (alt21) {
				case 1 :
					// PhoenixSQL.g:
					{
					if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
						input.consume();
						state.failed=false;
					}
					else {
						if (state.backtracking>0) {state.failed=true; return;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					if ( cnt21 >= 1 ) break loop21;
					if (state.backtracking>0) {state.failed=true; return;}
					EarlyExitException eee = new EarlyExitException(21, input);
					throw eee;
				}
				cnt21++;
			}

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "POSINTEGER"

	// $ANTLR start "DIGIT"
	public final void mDIGIT() throws RecognitionException {
		try {
			// PhoenixSQL.g:1459:5: ( '0' .. '9' )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DIGIT"

	// $ANTLR start "HEX_DIGIT"
	public final void mHEX_DIGIT() throws RecognitionException {
		try {
			// PhoenixSQL.g:1464:5: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "HEX_DIGIT"

	// $ANTLR start "BIN_DIGIT"
	public final void mBIN_DIGIT() throws RecognitionException {
		try {
			// PhoenixSQL.g:1469:5: ( ( '0' | '1' ) )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= '0' && input.LA(1) <= '1') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BIN_DIGIT"

	// $ANTLR start "STRING_LITERAL"
	public final void mSTRING_LITERAL() throws RecognitionException {
		try {
			int _type = STRING_LITERAL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken t=null;

			 StringBuilder sb = new StringBuilder(); 
			// PhoenixSQL.g:1474:5: ( '\\'' (t= CHAR |t= CHAR_ESC )* '\\'' )
			// PhoenixSQL.g:1474:9: '\\'' (t= CHAR |t= CHAR_ESC )* '\\''
			{
			match('\''); if (state.failed) return;
			// PhoenixSQL.g:1475:5: (t= CHAR |t= CHAR_ESC )*
			loop22:
			while (true) {
				int alt22=3;
				int LA22_0 = input.LA(1);
				if ( (LA22_0=='\'') ) {
					int LA22_1 = input.LA(2);
					if ( (LA22_1=='\'') ) {
						alt22=2;
					}

				}
				else if ( ((LA22_0 >= '\u0000' && LA22_0 <= '&')||(LA22_0 >= '(' && LA22_0 <= '[')||(LA22_0 >= ']' && LA22_0 <= '\uFFFF')) ) {
					alt22=1;
				}
				else if ( (LA22_0=='\\') ) {
					alt22=2;
				}

				switch (alt22) {
				case 1 :
					// PhoenixSQL.g:1475:7: t= CHAR
					{
					int tStart2210 = getCharIndex();
					int tStartLine2210 = getLine();
					int tStartCharPos2210 = getCharPositionInLine();
					mCHAR(); if (state.failed) return;
					t = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, tStart2210, getCharIndex()-1);
					t.setLine(tStartLine2210);
					t.setCharPositionInLine(tStartCharPos2210);

					if ( state.backtracking==0 ) { sb.append(t.getText()); }
					}
					break;
				case 2 :
					// PhoenixSQL.g:1476:7: t= CHAR_ESC
					{
					int tStart2223 = getCharIndex();
					int tStartLine2223 = getLine();
					int tStartCharPos2223 = getCharPositionInLine();
					mCHAR_ESC(); if (state.failed) return;
					t = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, tStart2223, getCharIndex()-1);
					t.setLine(tStartLine2223);
					t.setCharPositionInLine(tStartCharPos2223);

					if ( state.backtracking==0 ) { sb.append(getText()); }
					}
					break;

				default :
					break loop22;
				}
			}

			match('\''); if (state.failed) return;
			if ( state.backtracking==0 ) { setText(sb.toString()); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "STRING_LITERAL"

	// $ANTLR start "CHAR"
	public final void mCHAR() throws RecognitionException {
		try {
			// PhoenixSQL.g:1483:5: ( (~ ( '\\'' | '\\\\' ) ) )
			// PhoenixSQL.g:
			{
			if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CHAR"

	// $ANTLR start "DBL_QUOTE_CHAR"
	public final void mDBL_QUOTE_CHAR() throws RecognitionException {
		try {
			// PhoenixSQL.g:1488:5: ( (~ ( '\\\"' ) )+ )
			// PhoenixSQL.g:1488:9: (~ ( '\\\"' ) )+
			{
			// PhoenixSQL.g:1488:9: (~ ( '\\\"' ) )+
			int cnt23=0;
			loop23:
			while (true) {
				int alt23=2;
				int LA23_0 = input.LA(1);
				if ( ((LA23_0 >= '\u0000' && LA23_0 <= '!')||(LA23_0 >= '#' && LA23_0 <= '\uFFFF')) ) {
					alt23=1;
				}

				switch (alt23) {
				case 1 :
					// PhoenixSQL.g:
					{
					if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
						input.consume();
						state.failed=false;
					}
					else {
						if (state.backtracking>0) {state.failed=true; return;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					if ( cnt23 >= 1 ) break loop23;
					if (state.backtracking>0) {state.failed=true; return;}
					EarlyExitException eee = new EarlyExitException(23, input);
					throw eee;
				}
				cnt23++;
			}

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DBL_QUOTE_CHAR"

	// $ANTLR start "X"
	public final void mX() throws RecognitionException {
		try {
			// PhoenixSQL.g:1493:5: ( ( 'X' | 'x' ) )
			// PhoenixSQL.g:
			{
			if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "X"

	// $ANTLR start "B"
	public final void mB() throws RecognitionException {
		try {
			// PhoenixSQL.g:1498:5: ( ( 'B' | 'b' ) )
			// PhoenixSQL.g:
			{
			if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "B"

	// $ANTLR start "CHAR_ESC"
	public final void mCHAR_ESC() throws RecognitionException {
		try {
			// PhoenixSQL.g:1504:5: ( '\\\\' ( 'n' | 'r' | 't' | 'b' | 'f' | '\\\"' | '\\'' | '\\\\' | '_' | '%' |) | '\\'\\'' )
			int alt25=2;
			int LA25_0 = input.LA(1);
			if ( (LA25_0=='\\') ) {
				alt25=1;
			}
			else if ( (LA25_0=='\'') ) {
				alt25=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae =
					new NoViableAltException("", 25, 0, input);
				throw nvae;
			}

			switch (alt25) {
				case 1 :
					// PhoenixSQL.g:1504:9: '\\\\' ( 'n' | 'r' | 't' | 'b' | 'f' | '\\\"' | '\\'' | '\\\\' | '_' | '%' |)
					{
					match('\\'); if (state.failed) return;
					// PhoenixSQL.g:1505:9: ( 'n' | 'r' | 't' | 'b' | 'f' | '\\\"' | '\\'' | '\\\\' | '_' | '%' |)
					int alt24=11;
					switch ( input.LA(1) ) {
					case 'n':
						{
						alt24=1;
						}
						break;
					case 'r':
						{
						alt24=2;
						}
						break;
					case 't':
						{
						alt24=3;
						}
						break;
					case 'b':
						{
						alt24=4;
						}
						break;
					case 'f':
						{
						alt24=5;
						}
						break;
					case '\"':
						{
						alt24=6;
						}
						break;
					case '\'':
						{
						alt24=7;
						}
						break;
					case '\\':
						{
						alt24=8;
						}
						break;
					case '_':
						{
						alt24=9;
						}
						break;
					case '%':
						{
						alt24=10;
						}
						break;
					default:
						alt24=11;
					}
					switch (alt24) {
						case 1 :
							// PhoenixSQL.g:1505:11: 'n'
							{
							match('n'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\n"); }
							}
							break;
						case 2 :
							// PhoenixSQL.g:1506:11: 'r'
							{
							match('r'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\r"); }
							}
							break;
						case 3 :
							// PhoenixSQL.g:1507:11: 't'
							{
							match('t'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\t"); }
							}
							break;
						case 4 :
							// PhoenixSQL.g:1508:11: 'b'
							{
							match('b'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\b"); }
							}
							break;
						case 5 :
							// PhoenixSQL.g:1509:11: 'f'
							{
							match('f'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\f"); }
							}
							break;
						case 6 :
							// PhoenixSQL.g:1510:11: '\\\"'
							{
							match('\"'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\""); }
							}
							break;
						case 7 :
							// PhoenixSQL.g:1511:11: '\\''
							{
							match('\''); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\'"); }
							}
							break;
						case 8 :
							// PhoenixSQL.g:1512:11: '\\\\'
							{
							match('\\'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\\"); }
							}
							break;
						case 9 :
							// PhoenixSQL.g:1513:11: '_'
							{
							match('_'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\\_"); }
							}
							break;
						case 10 :
							// PhoenixSQL.g:1514:11: '%'
							{
							match('%'); if (state.failed) return;
							if ( state.backtracking==0 ) { setText("\\%"); }
							}
							break;
						case 11 :
							// PhoenixSQL.g:1515:17: 
							{
							if ( state.backtracking==0 ) { setText("\\"); }
							}
							break;

					}

					}
					break;
				case 2 :
					// PhoenixSQL.g:1517:9: '\\'\\''
					{
					match("''"); if (state.failed) return;

					if ( state.backtracking==0 ) { setText("\'"); }
					}
					break;

			}
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CHAR_ESC"

	// $ANTLR start "WS"
	public final void mWS() throws RecognitionException {
		try {
			int _type = WS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1521:5: ( ( ' ' | '\\t' | '\\u2002' ) )
			// PhoenixSQL.g:1521:9: ( ' ' | '\\t' | '\\u2002' )
			{
			if ( input.LA(1)=='\t'||input.LA(1)==' '||input.LA(1)=='\u2002' ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			if ( state.backtracking==0 ) { _channel=HIDDEN; }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "WS"

	// $ANTLR start "EOL"
	public final void mEOL() throws RecognitionException {
		try {
			int _type = EOL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1525:5: ( ( '\\r' | '\\n' ) )
			// PhoenixSQL.g:1525:8: ( '\\r' | '\\n' )
			{
			if ( input.LA(1)=='\n'||input.LA(1)=='\r' ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			if ( state.backtracking==0 ) { skip(); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EOL"

	// $ANTLR start "ML_HINT"
	public final void mML_HINT() throws RecognitionException {
		try {
			int _type = ML_HINT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken h=null;
			int t;

			 StringBuilder sb = new StringBuilder(); 
			// PhoenixSQL.g:1532:5: (h= HINT_START ( options {greedy=false; } :t= . )* COMMENT_AND_HINT_END )
			// PhoenixSQL.g:1532:7: h= HINT_START ( options {greedy=false; } :t= . )* COMMENT_AND_HINT_END
			{
			int hStart2648 = getCharIndex();
			int hStartLine2648 = getLine();
			int hStartCharPos2648 = getCharPositionInLine();
			mHINT_START(); if (state.failed) return;
			h = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, hStart2648, getCharIndex()-1);
			h.setLine(hStartLine2648);
			h.setCharPositionInLine(hStartCharPos2648);

			// PhoenixSQL.g:1532:20: ( options {greedy=false; } :t= . )*
			loop26:
			while (true) {
				int alt26=2;
				int LA26_0 = input.LA(1);
				if ( (LA26_0=='*') ) {
					int LA26_1 = input.LA(2);
					if ( (LA26_1=='/') ) {
						alt26=2;
					}
					else if ( ((LA26_1 >= '\u0000' && LA26_1 <= '.')||(LA26_1 >= '0' && LA26_1 <= '\uFFFF')) ) {
						alt26=1;
					}

				}
				else if ( ((LA26_0 >= '\u0000' && LA26_0 <= ')')||(LA26_0 >= '+' && LA26_0 <= '\uFFFF')) ) {
					alt26=1;
				}

				switch (alt26) {
				case 1 :
					// PhoenixSQL.g:1532:48: t= .
					{
					t = input.LA(1);
					matchAny(); if (state.failed) return;
					}
					break;

				default :
					break loop26;
				}
			}

			if ( state.backtracking==0 ) { sb.append(getText()); }
			mCOMMENT_AND_HINT_END(); if (state.failed) return;

			if ( state.backtracking==0 ) { setText(sb.substring(h.getText().length())); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ML_HINT"

	// $ANTLR start "ML_COMMENT"
	public final void mML_COMMENT() throws RecognitionException {
		try {
			int _type = ML_COMMENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1537:5: ( COMMENT_START (~ PLUS ) ( options {greedy=false; } : . )* COMMENT_AND_HINT_END )
			// PhoenixSQL.g:1537:7: COMMENT_START (~ PLUS ) ( options {greedy=false; } : . )* COMMENT_AND_HINT_END
			{
			mCOMMENT_START(); if (state.failed) return;

			if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '*')||(input.LA(1) >= ',' && input.LA(1) <= '\uFFFF') ) {
				input.consume();
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PhoenixSQL.g:1537:29: ( options {greedy=false; } : . )*
			loop27:
			while (true) {
				int alt27=2;
				int LA27_0 = input.LA(1);
				if ( (LA27_0=='*') ) {
					int LA27_1 = input.LA(2);
					if ( (LA27_1=='/') ) {
						alt27=2;
					}
					else if ( ((LA27_1 >= '\u0000' && LA27_1 <= '.')||(LA27_1 >= '0' && LA27_1 <= '\uFFFF')) ) {
						alt27=1;
					}

				}
				else if ( ((LA27_0 >= '\u0000' && LA27_0 <= ')')||(LA27_0 >= '+' && LA27_0 <= '\uFFFF')) ) {
					alt27=1;
				}

				switch (alt27) {
				case 1 :
					// PhoenixSQL.g:1537:57: .
					{
					matchAny(); if (state.failed) return;
					}
					break;

				default :
					break loop27;
				}
			}

			mCOMMENT_AND_HINT_END(); if (state.failed) return;

			if ( state.backtracking==0 ) { skip(); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ML_COMMENT"

	// $ANTLR start "SL_COMMENT"
	public final void mSL_COMMENT() throws RecognitionException {
		try {
			int _type = SL_COMMENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1542:5: ( ( SL_COMMENT1 | SL_COMMENT2 ) ( options {greedy=false; } : . )* EOL )
			// PhoenixSQL.g:1542:7: ( SL_COMMENT1 | SL_COMMENT2 ) ( options {greedy=false; } : . )* EOL
			{
			// PhoenixSQL.g:1542:7: ( SL_COMMENT1 | SL_COMMENT2 )
			int alt28=2;
			int LA28_0 = input.LA(1);
			if ( (LA28_0=='/') ) {
				alt28=1;
			}
			else if ( (LA28_0=='-') ) {
				alt28=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae =
					new NoViableAltException("", 28, 0, input);
				throw nvae;
			}

			switch (alt28) {
				case 1 :
					// PhoenixSQL.g:1542:8: SL_COMMENT1
					{
					mSL_COMMENT1(); if (state.failed) return;

					}
					break;
				case 2 :
					// PhoenixSQL.g:1542:22: SL_COMMENT2
					{
					mSL_COMMENT2(); if (state.failed) return;

					}
					break;

			}

			// PhoenixSQL.g:1542:35: ( options {greedy=false; } : . )*
			loop29:
			while (true) {
				int alt29=2;
				int LA29_0 = input.LA(1);
				if ( (LA29_0=='\n'||LA29_0=='\r') ) {
					alt29=2;
				}
				else if ( ((LA29_0 >= '\u0000' && LA29_0 <= '\t')||(LA29_0 >= '\u000B' && LA29_0 <= '\f')||(LA29_0 >= '\u000E' && LA29_0 <= '\uFFFF')) ) {
					alt29=1;
				}

				switch (alt29) {
				case 1 :
					// PhoenixSQL.g:1542:63: .
					{
					matchAny(); if (state.failed) return;
					}
					break;

				default :
					break loop29;
				}
			}

			mEOL(); if (state.failed) return;

			if ( state.backtracking==0 ) { skip(); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SL_COMMENT"

	// $ANTLR start "DOT"
	public final void mDOT() throws RecognitionException {
		try {
			int _type = DOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1547:5: ( '.' )
			// PhoenixSQL.g:1547:7: '.'
			{
			match('.'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOT"

	// $ANTLR start "OTHER"
	public final void mOTHER() throws RecognitionException {
		try {
			int _type = OTHER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PhoenixSQL.g:1551:5: ( . )
			// PhoenixSQL.g:1551:7: .
			{
			matchAny(); if (state.failed) return;
			if ( state.backtracking==0 ) { if (true) // to prevent compile error
			              throw new RuntimeException("Unexpected char: '" + getText() + "'"); }
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "OTHER"

	@Override
	public void mTokens() throws RecognitionException {
		// PhoenixSQL.g:1:8: ( ACTIVE | ADD | ALL | ALTER | AND | ANY | ARRAY | AS | ASC | ASYNC | BETWEEN | BY | CACHE | CASCADE | CASE | CAST | CLOSE | COLUMN | COLUMNS | COLUMN_QUALIFIER_COUNTER | CONSTANT | CONSTRAINT | CREATE | CURRENT | CURSOR | CYCLE | DECLARE | DEFAULT | DEFAULTVALUE | DELETE | DESC | DISABLE | DISTINCT | DROP | DUPLICATE | ELSE | ENCODED_QUALIFIER | END | EXECUTE | EXISTS | EXPLAIN | FALSE | FETCH | FIRST | FOR | FROM | FULL | FUNCTION | GRANT | GROUP | HAVING | IF | IGNORE | ILIKE | IMMUTABLE | IN | INCLUDE | INCREMENT | INDEX | INNER | INTO | IS | JAR | JARS | JOIN | KEY | LAST | LEFT | LIKE | LIMIT | LIST | LOCAL | MAXVALUE | MINVALUE | NEXT | NOT | NOVERIFY | NULL | NULLS | OFF | OFFSET | ON | ONLY | OPEN | OR | ORDER | OUTER | PRIMARY | REBUILD | REGIONS | REPLACE | RETURNS | REVOKE | RIGHT | ROW | ROWS | ROW_TIMESTAMP | SAMPLING | SCHEMA | SCHEMAS | SELECT | SEQUENCE | SESSION | SET | SHOW | SOME | SPLIT | START | STATISTICS | TABLE | TABLES | TABLESAMPLE | TEMPORARY | THEN | TO | TRACE | TRUE | UNCOVERED | UNION | UNUSABLE | UPDATE | UPGRADE | UPSERT | USABLE | USE | USING | VALUE | VALUES | VIEW | WHEN | WHERE | WITH | WITHIN | HINT_START | COMMENT_START | COMMENT_AND_HINT_END | SL_COMMENT1 | SL_COMMENT2 | BIND_NAME | HEX_LITERAL | BIN_LITERAL | NAME | NUMBER | DECIMAL | DOUBLE | Exponent | DOUBLE_QUOTE | EQ | LT | GT | DOUBLE_EQ | NOEQ1 | NOEQ2 | CONCAT | COMMA | LPAREN | RPAREN | SEMICOLON | COLON | QUESTION | LSQUARE | RSQUARE | LCURLY | RCURLY | AT | TILDE | PLUS | MINUS | ASTERISK | DIVIDE | PERCENT | OUTER_JOIN | STRING_LITERAL | WS | EOL | ML_HINT | ML_COMMENT | SL_COMMENT | DOT | OTHER )
		int alt30=180;
		alt30 = dfa30.predict(input);
		switch (alt30) {
			case 1 :
				// PhoenixSQL.g:1:10: ACTIVE
				{
				mACTIVE(); if (state.failed) return;

				}
				break;
			case 2 :
				// PhoenixSQL.g:1:17: ADD
				{
				mADD(); if (state.failed) return;

				}
				break;
			case 3 :
				// PhoenixSQL.g:1:21: ALL
				{
				mALL(); if (state.failed) return;

				}
				break;
			case 4 :
				// PhoenixSQL.g:1:25: ALTER
				{
				mALTER(); if (state.failed) return;

				}
				break;
			case 5 :
				// PhoenixSQL.g:1:31: AND
				{
				mAND(); if (state.failed) return;

				}
				break;
			case 6 :
				// PhoenixSQL.g:1:35: ANY
				{
				mANY(); if (state.failed) return;

				}
				break;
			case 7 :
				// PhoenixSQL.g:1:39: ARRAY
				{
				mARRAY(); if (state.failed) return;

				}
				break;
			case 8 :
				// PhoenixSQL.g:1:45: AS
				{
				mAS(); if (state.failed) return;

				}
				break;
			case 9 :
				// PhoenixSQL.g:1:48: ASC
				{
				mASC(); if (state.failed) return;

				}
				break;
			case 10 :
				// PhoenixSQL.g:1:52: ASYNC
				{
				mASYNC(); if (state.failed) return;

				}
				break;
			case 11 :
				// PhoenixSQL.g:1:58: BETWEEN
				{
				mBETWEEN(); if (state.failed) return;

				}
				break;
			case 12 :
				// PhoenixSQL.g:1:66: BY
				{
				mBY(); if (state.failed) return;

				}
				break;
			case 13 :
				// PhoenixSQL.g:1:69: CACHE
				{
				mCACHE(); if (state.failed) return;

				}
				break;
			case 14 :
				// PhoenixSQL.g:1:75: CASCADE
				{
				mCASCADE(); if (state.failed) return;

				}
				break;
			case 15 :
				// PhoenixSQL.g:1:83: CASE
				{
				mCASE(); if (state.failed) return;

				}
				break;
			case 16 :
				// PhoenixSQL.g:1:88: CAST
				{
				mCAST(); if (state.failed) return;

				}
				break;
			case 17 :
				// PhoenixSQL.g:1:93: CLOSE
				{
				mCLOSE(); if (state.failed) return;

				}
				break;
			case 18 :
				// PhoenixSQL.g:1:99: COLUMN
				{
				mCOLUMN(); if (state.failed) return;

				}
				break;
			case 19 :
				// PhoenixSQL.g:1:106: COLUMNS
				{
				mCOLUMNS(); if (state.failed) return;

				}
				break;
			case 20 :
				// PhoenixSQL.g:1:114: COLUMN_QUALIFIER_COUNTER
				{
				mCOLUMN_QUALIFIER_COUNTER(); if (state.failed) return;

				}
				break;
			case 21 :
				// PhoenixSQL.g:1:139: CONSTANT
				{
				mCONSTANT(); if (state.failed) return;

				}
				break;
			case 22 :
				// PhoenixSQL.g:1:148: CONSTRAINT
				{
				mCONSTRAINT(); if (state.failed) return;

				}
				break;
			case 23 :
				// PhoenixSQL.g:1:159: CREATE
				{
				mCREATE(); if (state.failed) return;

				}
				break;
			case 24 :
				// PhoenixSQL.g:1:166: CURRENT
				{
				mCURRENT(); if (state.failed) return;

				}
				break;
			case 25 :
				// PhoenixSQL.g:1:174: CURSOR
				{
				mCURSOR(); if (state.failed) return;

				}
				break;
			case 26 :
				// PhoenixSQL.g:1:181: CYCLE
				{
				mCYCLE(); if (state.failed) return;

				}
				break;
			case 27 :
				// PhoenixSQL.g:1:187: DECLARE
				{
				mDECLARE(); if (state.failed) return;

				}
				break;
			case 28 :
				// PhoenixSQL.g:1:195: DEFAULT
				{
				mDEFAULT(); if (state.failed) return;

				}
				break;
			case 29 :
				// PhoenixSQL.g:1:203: DEFAULTVALUE
				{
				mDEFAULTVALUE(); if (state.failed) return;

				}
				break;
			case 30 :
				// PhoenixSQL.g:1:216: DELETE
				{
				mDELETE(); if (state.failed) return;

				}
				break;
			case 31 :
				// PhoenixSQL.g:1:223: DESC
				{
				mDESC(); if (state.failed) return;

				}
				break;
			case 32 :
				// PhoenixSQL.g:1:228: DISABLE
				{
				mDISABLE(); if (state.failed) return;

				}
				break;
			case 33 :
				// PhoenixSQL.g:1:236: DISTINCT
				{
				mDISTINCT(); if (state.failed) return;

				}
				break;
			case 34 :
				// PhoenixSQL.g:1:245: DROP
				{
				mDROP(); if (state.failed) return;

				}
				break;
			case 35 :
				// PhoenixSQL.g:1:250: DUPLICATE
				{
				mDUPLICATE(); if (state.failed) return;

				}
				break;
			case 36 :
				// PhoenixSQL.g:1:260: ELSE
				{
				mELSE(); if (state.failed) return;

				}
				break;
			case 37 :
				// PhoenixSQL.g:1:265: ENCODED_QUALIFIER
				{
				mENCODED_QUALIFIER(); if (state.failed) return;

				}
				break;
			case 38 :
				// PhoenixSQL.g:1:283: END
				{
				mEND(); if (state.failed) return;

				}
				break;
			case 39 :
				// PhoenixSQL.g:1:287: EXECUTE
				{
				mEXECUTE(); if (state.failed) return;

				}
				break;
			case 40 :
				// PhoenixSQL.g:1:295: EXISTS
				{
				mEXISTS(); if (state.failed) return;

				}
				break;
			case 41 :
				// PhoenixSQL.g:1:302: EXPLAIN
				{
				mEXPLAIN(); if (state.failed) return;

				}
				break;
			case 42 :
				// PhoenixSQL.g:1:310: FALSE
				{
				mFALSE(); if (state.failed) return;

				}
				break;
			case 43 :
				// PhoenixSQL.g:1:316: FETCH
				{
				mFETCH(); if (state.failed) return;

				}
				break;
			case 44 :
				// PhoenixSQL.g:1:322: FIRST
				{
				mFIRST(); if (state.failed) return;

				}
				break;
			case 45 :
				// PhoenixSQL.g:1:328: FOR
				{
				mFOR(); if (state.failed) return;

				}
				break;
			case 46 :
				// PhoenixSQL.g:1:332: FROM
				{
				mFROM(); if (state.failed) return;

				}
				break;
			case 47 :
				// PhoenixSQL.g:1:337: FULL
				{
				mFULL(); if (state.failed) return;

				}
				break;
			case 48 :
				// PhoenixSQL.g:1:342: FUNCTION
				{
				mFUNCTION(); if (state.failed) return;

				}
				break;
			case 49 :
				// PhoenixSQL.g:1:351: GRANT
				{
				mGRANT(); if (state.failed) return;

				}
				break;
			case 50 :
				// PhoenixSQL.g:1:357: GROUP
				{
				mGROUP(); if (state.failed) return;

				}
				break;
			case 51 :
				// PhoenixSQL.g:1:363: HAVING
				{
				mHAVING(); if (state.failed) return;

				}
				break;
			case 52 :
				// PhoenixSQL.g:1:370: IF
				{
				mIF(); if (state.failed) return;

				}
				break;
			case 53 :
				// PhoenixSQL.g:1:373: IGNORE
				{
				mIGNORE(); if (state.failed) return;

				}
				break;
			case 54 :
				// PhoenixSQL.g:1:380: ILIKE
				{
				mILIKE(); if (state.failed) return;

				}
				break;
			case 55 :
				// PhoenixSQL.g:1:386: IMMUTABLE
				{
				mIMMUTABLE(); if (state.failed) return;

				}
				break;
			case 56 :
				// PhoenixSQL.g:1:396: IN
				{
				mIN(); if (state.failed) return;

				}
				break;
			case 57 :
				// PhoenixSQL.g:1:399: INCLUDE
				{
				mINCLUDE(); if (state.failed) return;

				}
				break;
			case 58 :
				// PhoenixSQL.g:1:407: INCREMENT
				{
				mINCREMENT(); if (state.failed) return;

				}
				break;
			case 59 :
				// PhoenixSQL.g:1:417: INDEX
				{
				mINDEX(); if (state.failed) return;

				}
				break;
			case 60 :
				// PhoenixSQL.g:1:423: INNER
				{
				mINNER(); if (state.failed) return;

				}
				break;
			case 61 :
				// PhoenixSQL.g:1:429: INTO
				{
				mINTO(); if (state.failed) return;

				}
				break;
			case 62 :
				// PhoenixSQL.g:1:434: IS
				{
				mIS(); if (state.failed) return;

				}
				break;
			case 63 :
				// PhoenixSQL.g:1:437: JAR
				{
				mJAR(); if (state.failed) return;

				}
				break;
			case 64 :
				// PhoenixSQL.g:1:441: JARS
				{
				mJARS(); if (state.failed) return;

				}
				break;
			case 65 :
				// PhoenixSQL.g:1:446: JOIN
				{
				mJOIN(); if (state.failed) return;

				}
				break;
			case 66 :
				// PhoenixSQL.g:1:451: KEY
				{
				mKEY(); if (state.failed) return;

				}
				break;
			case 67 :
				// PhoenixSQL.g:1:455: LAST
				{
				mLAST(); if (state.failed) return;

				}
				break;
			case 68 :
				// PhoenixSQL.g:1:460: LEFT
				{
				mLEFT(); if (state.failed) return;

				}
				break;
			case 69 :
				// PhoenixSQL.g:1:465: LIKE
				{
				mLIKE(); if (state.failed) return;

				}
				break;
			case 70 :
				// PhoenixSQL.g:1:470: LIMIT
				{
				mLIMIT(); if (state.failed) return;

				}
				break;
			case 71 :
				// PhoenixSQL.g:1:476: LIST
				{
				mLIST(); if (state.failed) return;

				}
				break;
			case 72 :
				// PhoenixSQL.g:1:481: LOCAL
				{
				mLOCAL(); if (state.failed) return;

				}
				break;
			case 73 :
				// PhoenixSQL.g:1:487: MAXVALUE
				{
				mMAXVALUE(); if (state.failed) return;

				}
				break;
			case 74 :
				// PhoenixSQL.g:1:496: MINVALUE
				{
				mMINVALUE(); if (state.failed) return;

				}
				break;
			case 75 :
				// PhoenixSQL.g:1:505: NEXT
				{
				mNEXT(); if (state.failed) return;

				}
				break;
			case 76 :
				// PhoenixSQL.g:1:510: NOT
				{
				mNOT(); if (state.failed) return;

				}
				break;
			case 77 :
				// PhoenixSQL.g:1:514: NOVERIFY
				{
				mNOVERIFY(); if (state.failed) return;

				}
				break;
			case 78 :
				// PhoenixSQL.g:1:523: NULL
				{
				mNULL(); if (state.failed) return;

				}
				break;
			case 79 :
				// PhoenixSQL.g:1:528: NULLS
				{
				mNULLS(); if (state.failed) return;

				}
				break;
			case 80 :
				// PhoenixSQL.g:1:534: OFF
				{
				mOFF(); if (state.failed) return;

				}
				break;
			case 81 :
				// PhoenixSQL.g:1:538: OFFSET
				{
				mOFFSET(); if (state.failed) return;

				}
				break;
			case 82 :
				// PhoenixSQL.g:1:545: ON
				{
				mON(); if (state.failed) return;

				}
				break;
			case 83 :
				// PhoenixSQL.g:1:548: ONLY
				{
				mONLY(); if (state.failed) return;

				}
				break;
			case 84 :
				// PhoenixSQL.g:1:553: OPEN
				{
				mOPEN(); if (state.failed) return;

				}
				break;
			case 85 :
				// PhoenixSQL.g:1:558: OR
				{
				mOR(); if (state.failed) return;

				}
				break;
			case 86 :
				// PhoenixSQL.g:1:561: ORDER
				{
				mORDER(); if (state.failed) return;

				}
				break;
			case 87 :
				// PhoenixSQL.g:1:567: OUTER
				{
				mOUTER(); if (state.failed) return;

				}
				break;
			case 88 :
				// PhoenixSQL.g:1:573: PRIMARY
				{
				mPRIMARY(); if (state.failed) return;

				}
				break;
			case 89 :
				// PhoenixSQL.g:1:581: REBUILD
				{
				mREBUILD(); if (state.failed) return;

				}
				break;
			case 90 :
				// PhoenixSQL.g:1:589: REGIONS
				{
				mREGIONS(); if (state.failed) return;

				}
				break;
			case 91 :
				// PhoenixSQL.g:1:597: REPLACE
				{
				mREPLACE(); if (state.failed) return;

				}
				break;
			case 92 :
				// PhoenixSQL.g:1:605: RETURNS
				{
				mRETURNS(); if (state.failed) return;

				}
				break;
			case 93 :
				// PhoenixSQL.g:1:613: REVOKE
				{
				mREVOKE(); if (state.failed) return;

				}
				break;
			case 94 :
				// PhoenixSQL.g:1:620: RIGHT
				{
				mRIGHT(); if (state.failed) return;

				}
				break;
			case 95 :
				// PhoenixSQL.g:1:626: ROW
				{
				mROW(); if (state.failed) return;

				}
				break;
			case 96 :
				// PhoenixSQL.g:1:630: ROWS
				{
				mROWS(); if (state.failed) return;

				}
				break;
			case 97 :
				// PhoenixSQL.g:1:635: ROW_TIMESTAMP
				{
				mROW_TIMESTAMP(); if (state.failed) return;

				}
				break;
			case 98 :
				// PhoenixSQL.g:1:649: SAMPLING
				{
				mSAMPLING(); if (state.failed) return;

				}
				break;
			case 99 :
				// PhoenixSQL.g:1:658: SCHEMA
				{
				mSCHEMA(); if (state.failed) return;

				}
				break;
			case 100 :
				// PhoenixSQL.g:1:665: SCHEMAS
				{
				mSCHEMAS(); if (state.failed) return;

				}
				break;
			case 101 :
				// PhoenixSQL.g:1:673: SELECT
				{
				mSELECT(); if (state.failed) return;

				}
				break;
			case 102 :
				// PhoenixSQL.g:1:680: SEQUENCE
				{
				mSEQUENCE(); if (state.failed) return;

				}
				break;
			case 103 :
				// PhoenixSQL.g:1:689: SESSION
				{
				mSESSION(); if (state.failed) return;

				}
				break;
			case 104 :
				// PhoenixSQL.g:1:697: SET
				{
				mSET(); if (state.failed) return;

				}
				break;
			case 105 :
				// PhoenixSQL.g:1:701: SHOW
				{
				mSHOW(); if (state.failed) return;

				}
				break;
			case 106 :
				// PhoenixSQL.g:1:706: SOME
				{
				mSOME(); if (state.failed) return;

				}
				break;
			case 107 :
				// PhoenixSQL.g:1:711: SPLIT
				{
				mSPLIT(); if (state.failed) return;

				}
				break;
			case 108 :
				// PhoenixSQL.g:1:717: START
				{
				mSTART(); if (state.failed) return;

				}
				break;
			case 109 :
				// PhoenixSQL.g:1:723: STATISTICS
				{
				mSTATISTICS(); if (state.failed) return;

				}
				break;
			case 110 :
				// PhoenixSQL.g:1:734: TABLE
				{
				mTABLE(); if (state.failed) return;

				}
				break;
			case 111 :
				// PhoenixSQL.g:1:740: TABLES
				{
				mTABLES(); if (state.failed) return;

				}
				break;
			case 112 :
				// PhoenixSQL.g:1:747: TABLESAMPLE
				{
				mTABLESAMPLE(); if (state.failed) return;

				}
				break;
			case 113 :
				// PhoenixSQL.g:1:759: TEMPORARY
				{
				mTEMPORARY(); if (state.failed) return;

				}
				break;
			case 114 :
				// PhoenixSQL.g:1:769: THEN
				{
				mTHEN(); if (state.failed) return;

				}
				break;
			case 115 :
				// PhoenixSQL.g:1:774: TO
				{
				mTO(); if (state.failed) return;

				}
				break;
			case 116 :
				// PhoenixSQL.g:1:777: TRACE
				{
				mTRACE(); if (state.failed) return;

				}
				break;
			case 117 :
				// PhoenixSQL.g:1:783: TRUE
				{
				mTRUE(); if (state.failed) return;

				}
				break;
			case 118 :
				// PhoenixSQL.g:1:788: UNCOVERED
				{
				mUNCOVERED(); if (state.failed) return;

				}
				break;
			case 119 :
				// PhoenixSQL.g:1:798: UNION
				{
				mUNION(); if (state.failed) return;

				}
				break;
			case 120 :
				// PhoenixSQL.g:1:804: UNUSABLE
				{
				mUNUSABLE(); if (state.failed) return;

				}
				break;
			case 121 :
				// PhoenixSQL.g:1:813: UPDATE
				{
				mUPDATE(); if (state.failed) return;

				}
				break;
			case 122 :
				// PhoenixSQL.g:1:820: UPGRADE
				{
				mUPGRADE(); if (state.failed) return;

				}
				break;
			case 123 :
				// PhoenixSQL.g:1:828: UPSERT
				{
				mUPSERT(); if (state.failed) return;

				}
				break;
			case 124 :
				// PhoenixSQL.g:1:835: USABLE
				{
				mUSABLE(); if (state.failed) return;

				}
				break;
			case 125 :
				// PhoenixSQL.g:1:842: USE
				{
				mUSE(); if (state.failed) return;

				}
				break;
			case 126 :
				// PhoenixSQL.g:1:846: USING
				{
				mUSING(); if (state.failed) return;

				}
				break;
			case 127 :
				// PhoenixSQL.g:1:852: VALUE
				{
				mVALUE(); if (state.failed) return;

				}
				break;
			case 128 :
				// PhoenixSQL.g:1:858: VALUES
				{
				mVALUES(); if (state.failed) return;

				}
				break;
			case 129 :
				// PhoenixSQL.g:1:865: VIEW
				{
				mVIEW(); if (state.failed) return;

				}
				break;
			case 130 :
				// PhoenixSQL.g:1:870: WHEN
				{
				mWHEN(); if (state.failed) return;

				}
				break;
			case 131 :
				// PhoenixSQL.g:1:875: WHERE
				{
				mWHERE(); if (state.failed) return;

				}
				break;
			case 132 :
				// PhoenixSQL.g:1:881: WITH
				{
				mWITH(); if (state.failed) return;

				}
				break;
			case 133 :
				// PhoenixSQL.g:1:886: WITHIN
				{
				mWITHIN(); if (state.failed) return;

				}
				break;
			case 134 :
				// PhoenixSQL.g:1:893: HINT_START
				{
				mHINT_START(); if (state.failed) return;

				}
				break;
			case 135 :
				// PhoenixSQL.g:1:904: COMMENT_START
				{
				mCOMMENT_START(); if (state.failed) return;

				}
				break;
			case 136 :
				// PhoenixSQL.g:1:918: COMMENT_AND_HINT_END
				{
				mCOMMENT_AND_HINT_END(); if (state.failed) return;

				}
				break;
			case 137 :
				// PhoenixSQL.g:1:939: SL_COMMENT1
				{
				mSL_COMMENT1(); if (state.failed) return;

				}
				break;
			case 138 :
				// PhoenixSQL.g:1:951: SL_COMMENT2
				{
				mSL_COMMENT2(); if (state.failed) return;

				}
				break;
			case 139 :
				// PhoenixSQL.g:1:963: BIND_NAME
				{
				mBIND_NAME(); if (state.failed) return;

				}
				break;
			case 140 :
				// PhoenixSQL.g:1:973: HEX_LITERAL
				{
				mHEX_LITERAL(); if (state.failed) return;

				}
				break;
			case 141 :
				// PhoenixSQL.g:1:985: BIN_LITERAL
				{
				mBIN_LITERAL(); if (state.failed) return;

				}
				break;
			case 142 :
				// PhoenixSQL.g:1:997: NAME
				{
				mNAME(); if (state.failed) return;

				}
				break;
			case 143 :
				// PhoenixSQL.g:1:1002: NUMBER
				{
				mNUMBER(); if (state.failed) return;

				}
				break;
			case 144 :
				// PhoenixSQL.g:1:1009: DECIMAL
				{
				mDECIMAL(); if (state.failed) return;

				}
				break;
			case 145 :
				// PhoenixSQL.g:1:1017: DOUBLE
				{
				mDOUBLE(); if (state.failed) return;

				}
				break;
			case 146 :
				// PhoenixSQL.g:1:1024: Exponent
				{
				mExponent(); if (state.failed) return;

				}
				break;
			case 147 :
				// PhoenixSQL.g:1:1033: DOUBLE_QUOTE
				{
				mDOUBLE_QUOTE(); if (state.failed) return;

				}
				break;
			case 148 :
				// PhoenixSQL.g:1:1046: EQ
				{
				mEQ(); if (state.failed) return;

				}
				break;
			case 149 :
				// PhoenixSQL.g:1:1049: LT
				{
				mLT(); if (state.failed) return;

				}
				break;
			case 150 :
				// PhoenixSQL.g:1:1052: GT
				{
				mGT(); if (state.failed) return;

				}
				break;
			case 151 :
				// PhoenixSQL.g:1:1055: DOUBLE_EQ
				{
				mDOUBLE_EQ(); if (state.failed) return;

				}
				break;
			case 152 :
				// PhoenixSQL.g:1:1065: NOEQ1
				{
				mNOEQ1(); if (state.failed) return;

				}
				break;
			case 153 :
				// PhoenixSQL.g:1:1071: NOEQ2
				{
				mNOEQ2(); if (state.failed) return;

				}
				break;
			case 154 :
				// PhoenixSQL.g:1:1077: CONCAT
				{
				mCONCAT(); if (state.failed) return;

				}
				break;
			case 155 :
				// PhoenixSQL.g:1:1084: COMMA
				{
				mCOMMA(); if (state.failed) return;

				}
				break;
			case 156 :
				// PhoenixSQL.g:1:1090: LPAREN
				{
				mLPAREN(); if (state.failed) return;

				}
				break;
			case 157 :
				// PhoenixSQL.g:1:1097: RPAREN
				{
				mRPAREN(); if (state.failed) return;

				}
				break;
			case 158 :
				// PhoenixSQL.g:1:1104: SEMICOLON
				{
				mSEMICOLON(); if (state.failed) return;

				}
				break;
			case 159 :
				// PhoenixSQL.g:1:1114: COLON
				{
				mCOLON(); if (state.failed) return;

				}
				break;
			case 160 :
				// PhoenixSQL.g:1:1120: QUESTION
				{
				mQUESTION(); if (state.failed) return;

				}
				break;
			case 161 :
				// PhoenixSQL.g:1:1129: LSQUARE
				{
				mLSQUARE(); if (state.failed) return;

				}
				break;
			case 162 :
				// PhoenixSQL.g:1:1137: RSQUARE
				{
				mRSQUARE(); if (state.failed) return;

				}
				break;
			case 163 :
				// PhoenixSQL.g:1:1145: LCURLY
				{
				mLCURLY(); if (state.failed) return;

				}
				break;
			case 164 :
				// PhoenixSQL.g:1:1152: RCURLY
				{
				mRCURLY(); if (state.failed) return;

				}
				break;
			case 165 :
				// PhoenixSQL.g:1:1159: AT
				{
				mAT(); if (state.failed) return;

				}
				break;
			case 166 :
				// PhoenixSQL.g:1:1162: TILDE
				{
				mTILDE(); if (state.failed) return;

				}
				break;
			case 167 :
				// PhoenixSQL.g:1:1168: PLUS
				{
				mPLUS(); if (state.failed) return;

				}
				break;
			case 168 :
				// PhoenixSQL.g:1:1173: MINUS
				{
				mMINUS(); if (state.failed) return;

				}
				break;
			case 169 :
				// PhoenixSQL.g:1:1179: ASTERISK
				{
				mASTERISK(); if (state.failed) return;

				}
				break;
			case 170 :
				// PhoenixSQL.g:1:1188: DIVIDE
				{
				mDIVIDE(); if (state.failed) return;

				}
				break;
			case 171 :
				// PhoenixSQL.g:1:1195: PERCENT
				{
				mPERCENT(); if (state.failed) return;

				}
				break;
			case 172 :
				// PhoenixSQL.g:1:1203: OUTER_JOIN
				{
				mOUTER_JOIN(); if (state.failed) return;

				}
				break;
			case 173 :
				// PhoenixSQL.g:1:1214: STRING_LITERAL
				{
				mSTRING_LITERAL(); if (state.failed) return;

				}
				break;
			case 174 :
				// PhoenixSQL.g:1:1229: WS
				{
				mWS(); if (state.failed) return;

				}
				break;
			case 175 :
				// PhoenixSQL.g:1:1232: EOL
				{
				mEOL(); if (state.failed) return;

				}
				break;
			case 176 :
				// PhoenixSQL.g:1:1236: ML_HINT
				{
				mML_HINT(); if (state.failed) return;

				}
				break;
			case 177 :
				// PhoenixSQL.g:1:1244: ML_COMMENT
				{
				mML_COMMENT(); if (state.failed) return;

				}
				break;
			case 178 :
				// PhoenixSQL.g:1:1255: SL_COMMENT
				{
				mSL_COMMENT(); if (state.failed) return;

				}
				break;
			case 179 :
				// PhoenixSQL.g:1:1266: DOT
				{
				mDOT(); if (state.failed) return;

				}
				break;
			case 180 :
				// PhoenixSQL.g:1:1270: OTHER
				{
				mOTHER(); if (state.failed) return;

				}
				break;

		}
	}

	// $ANTLR start synpred1_PhoenixSQL
	public final void synpred1_PhoenixSQL_fragment() throws RecognitionException {
		// PhoenixSQL.g:1290:5: ( FIELDCHAR )
		// PhoenixSQL.g:
		{
		if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
			input.consume();
			state.failed=false;
		}
		else {
			if (state.backtracking>0) {state.failed=true; return;}
			MismatchedSetException mse = new MismatchedSetException(null,input);
			recover(mse);
			throw mse;
		}
		}

	}
	// $ANTLR end synpred1_PhoenixSQL

	// $ANTLR start synpred2_PhoenixSQL
	public final void synpred2_PhoenixSQL_fragment() throws RecognitionException {
		// PhoenixSQL.g:1291:7: ( '\\'' )
		// PhoenixSQL.g:1291:8: '\\''
		{
		match('\''); if (state.failed) return;
		}

	}
	// $ANTLR end synpred2_PhoenixSQL

	// $ANTLR start synpred3_PhoenixSQL
	public final void synpred3_PhoenixSQL_fragment() throws RecognitionException {
		// PhoenixSQL.g:1301:5: ( FIELDCHAR )
		// PhoenixSQL.g:
		{
		if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z')||(input.LA(1) >= '\u0080' && input.LA(1) <= '\u2001')||(input.LA(1) >= '\u2003' && input.LA(1) <= '\uFFFE') ) {
			input.consume();
			state.failed=false;
		}
		else {
			if (state.backtracking>0) {state.failed=true; return;}
			MismatchedSetException mse = new MismatchedSetException(null,input);
			recover(mse);
			throw mse;
		}
		}

	}
	// $ANTLR end synpred3_PhoenixSQL

	// $ANTLR start synpred4_PhoenixSQL
	public final void synpred4_PhoenixSQL_fragment() throws RecognitionException {
		// PhoenixSQL.g:1302:7: ( '\\'' )
		// PhoenixSQL.g:1302:8: '\\''
		{
		match('\''); if (state.failed) return;
		}

	}
	// $ANTLR end synpred4_PhoenixSQL

	public final boolean synpred4_PhoenixSQL() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred4_PhoenixSQL_fragment(); // can never throw exception
		} catch (RecognitionException re) {
			System.err.println("impossible: "+re);
		}
		boolean success = !state.failed;
		input.rewind(start);
		state.backtracking--;
		state.failed=false;
		return success;
	}
	public final boolean synpred1_PhoenixSQL() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred1_PhoenixSQL_fragment(); // can never throw exception
		} catch (RecognitionException re) {
			System.err.println("impossible: "+re);
		}
		boolean success = !state.failed;
		input.rewind(start);
		state.backtracking--;
		state.failed=false;
		return success;
	}
	public final boolean synpred2_PhoenixSQL() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred2_PhoenixSQL_fragment(); // can never throw exception
		} catch (RecognitionException re) {
			System.err.println("impossible: "+re);
		}
		boolean success = !state.failed;
		input.rewind(start);
		state.backtracking--;
		state.failed=false;
		return success;
	}
	public final boolean synpred3_PhoenixSQL() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred3_PhoenixSQL_fragment(); // can never throw exception
		} catch (RecognitionException re) {
			System.err.println("impossible: "+re);
		}
		boolean success = !state.failed;
		input.rewind(start);
		state.backtracking--;
		state.failed=false;
		return success;
	}


	protected DFA19 dfa19 = new DFA19(this);
	protected DFA30 dfa30 = new DFA30(this);
	static final String DFA19_eotS =
		"\3\uffff\1\4\2\uffff";
	static final String DFA19_eofS =
		"\6\uffff";
	static final String DFA19_minS =
		"\1\56\1\uffff\1\56\1\105\2\uffff";
	static final String DFA19_maxS =
		"\1\71\1\uffff\2\145\2\uffff";
	static final String DFA19_acceptS =
		"\1\uffff\1\1\2\uffff\1\3\1\2";
	static final String DFA19_specialS =
		"\6\uffff}>";
	static final String[] DFA19_transitionS = {
			"\1\1\1\uffff\12\2",
			"",
			"\1\3\1\uffff\12\2\13\uffff\1\4\37\uffff\1\4",
			"\1\5\37\uffff\1\5",
			"",
			""
	};

	static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
	static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
	static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
	static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
	static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
	static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
	static final short[][] DFA19_transition;

	static {
		int numStates = DFA19_transitionS.length;
		DFA19_transition = new short[numStates][];
		for (int i=0; i";
	static final String[] DFA30_transitionS = {
			"\11\67\1\65\1\66\2\67\1\66\22\67\1\65\1\45\1\36\2\67\1\63\1\67\1\64\1"+
			"\50\1\51\1\30\1\62\1\47\1\31\1\40\1\27\12\37\1\32\1\52\1\43\1\42\1\44"+
			"\1\53\1\60\1\41\1\34\2\41\1\35\22\41\1\33\2\41\1\54\1\67\1\55\3\67\1"+
			"\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1"+
			"\20\1\41\1\21\1\22\1\23\1\24\1\25\1\26\1\33\2\41\1\56\1\46\1\57\1\61"+
			"\u1f83\67\1\65\udffd\67",
			"\1\70\1\71\7\uffff\1\72\1\uffff\1\73\3\uffff\1\74\1\75",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\4\102\1\77\23\102\1\100"+
			"\1\102\5\uffff\u1f82\102\1\uffff\udffc\102",
			"\1\103\12\uffff\1\104\2\uffff\1\105\2\uffff\1\106\2\uffff\1\107\3\uffff"+
			"\1\110",
			"\1\111\3\uffff\1\112\10\uffff\1\113\2\uffff\1\114",
			"\1\121\1\uffff\1\121\2\uffff\12\120\62\uffff\1\115\1\uffff\1\116\11"+
			"\uffff\1\117",
			"\1\122\3\uffff\1\123\3\uffff\1\124\5\uffff\1\125\2\uffff\1\126\2\uffff"+
			"\1\127",
			"\1\130",
			"\1\131",
			"\1\132\1\133\4\uffff\1\134\1\135\1\136\4\uffff\1\137",
			"\1\140\15\uffff\1\141",
			"\1\142",
			"\1\143\3\uffff\1\144\3\uffff\1\145\5\uffff\1\146",
			"\1\147\7\uffff\1\150",
			"\1\151\11\uffff\1\152\5\uffff\1\153",
			"\1\154\7\uffff\1\155\1\uffff\1\156\1\uffff\1\157\2\uffff\1\160",
			"\1\161",
			"\1\162\3\uffff\1\163\5\uffff\1\164",
			"\1\165\1\uffff\1\166\1\uffff\1\167\2\uffff\1\170\6\uffff\1\171\1\172"+
			"\3\uffff\1\173",
			"\1\174\3\uffff\1\175\2\uffff\1\176\6\uffff\1\177\2\uffff\1\u0080",
			"\1\u0081\1\uffff\1\u0082\2\uffff\1\u0083",
			"\1\u0084\7\uffff\1\u0085",
			"\1\u0086\1\u0087",
			"\1\u0088\4\uffff\1\u0089",
			"\1\u008b",
			"\1\u008d",
			"\12\u0090",
			"\12\u0092\7\uffff\32\u0092\4\uffff\1\u0092\1\uffff\32\u0092\5\uffff"+
			"\u1f82\u0092\1\uffff\udffc\u0092",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102\5\uffff\u1f82\102"+
			"\1\uffff\udffc\102",
			"\1\121\1\uffff\1\121\2\uffff\12\120",
			"\0\76",
			"\1\u0096\1\uffff\12\u0095\13\uffff\1\u0097\37\uffff\1\u0097",
			"\12\u0098",
			"",
			"\1\u009a",
			"\1\u009c",
			"",
			"\1\u009f",
			"\1\u00a0",
			"",
			"\1\u00a2",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"\0\u00af",
			"",
			"",
			"",
			"\1\u00b2",
			"\1\u00b3",
			"\1\u00b4\7\uffff\1\u00b5",
			"\1\u00b6\24\uffff\1\u00b7",
			"\1\u00b8",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\2\76\1\u00b9\25\76\1\u00ba"+
			"\1\76\5\uffff\u1f82\76\1\uffff\udffc\76",
			"",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\23\102\1\u00bc\6\102\5"+
			"\uffff\u1f82\102\1\uffff\udffc\102",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102\5\uffff\u1f82\102"+
			"\1\uffff\udffc\102",
			"",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102\5\uffff\u1f82\102"+
			"\1\uffff\udffc\102",
			"\1\u00be\17\uffff\1\u00bf",
			"\1\u00c0",
			"\1\u00c1\1\uffff\1\u00c2",
			"\1\u00c3",
			"\1\u00c4",
			"\1\u00c5",
			"\1\u00c6\2\uffff\1\u00c7\5\uffff\1\u00c8\6\uffff\1\u00c9",
			"\1\u00ca",
			"\1\u00cb",
			"\1\u00cc",
			"\1\u00cd",
			"\1\u00ce\1\u00cf",
			"\1\u00d0\3\uffff\1\u00d1\6\uffff\1\u00d2",
			"\12\120",
			"",
			"\1\u00d3",
			"\1\u00d4",
			"\1\u00d5",
			"\1\u00d6",
			"\1\u00d7",
			"\1\u00d8\1\uffff\1\u00d9",
			"\1\u00da\15\uffff\1\u00db",
			"\1\u00dc",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u00de",
			"\1\u00df",
			"\1\u00e0",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\2\76\1\u00e1\1\u00e2\11\76"+
			"\1\u00e3\5\76\1\u00e4\6\76\5\uffff\u1f82\76\1\uffff\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u00e7",
			"\1\u00e8",
			"\1\u00e9",
			"\1\u00ea",
			"\1\u00eb",
			"\1\u00ec\1\uffff\1\u00ed\5\uffff\1\u00ee",
			"\1\u00ef",
			"\1\u00f0",
			"\1\u00f1",
			"\1\u00f2",
			"\1\u00f3\1\uffff\1\u00f4",
			"\1\u00f5",
			"\1\u00f6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\13\76\1\u00f7\16\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u00f9",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\3\76\1\u00fa\26\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u00fc",
			"\1\u00fd",
			"\1\u00fe\4\uffff\1\u00ff\10\uffff\1\u0100\3\uffff\1\u0101\1\uffff\1"+
			"\u0102",
			"\1\u0103",
			"\1\u0104",
			"\1\u0105",
			"\1\u0106",
			"\1\u0107\4\uffff\1\u0108\1\uffff\1\u0109\1\u010a",
			"\1\u010b",
			"\1\u010c",
			"\1\u010d",
			"\1\u010e",
			"\1\u010f",
			"\1\u0110",
			"\1\u0111",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0113\23\uffff\1\u0114",
			"\1\u0115\5\uffff\1\u0116\13\uffff\1\u0117",
			"\1\u0118\2\uffff\1\u0119\13\uffff\1\u011a",
			"\1\u011b\3\uffff\1\u011c\3\uffff\1\u011d",
			"\1\u011e",
			"\1\u011f",
			"\1\u0120",
			"\1\u0121",
			"\53\u0124\1\u0122\uffd4\u0124",
			"\0\u0126",
			"",
			"",
			"",
			"\0\u0126",
			"",
			"",
			"",
			"",
			"\12\u0092\7\uffff\32\u0092\4\uffff\1\u0092\1\uffff\32\u0092\5\uffff"+
			"\u1f82\u0092\1\uffff\udffc\u0092",
			"",
			"",
			"\1\u0096\1\uffff\12\u0095\13\uffff\1\u0097\37\uffff\1\u0097",
			"\12\u0128",
			"",
			"\12\u0098\13\uffff\1\u0097\37\uffff\1\u0097",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"\1\u012a",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u012d",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0130",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0132",
			"",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\26\102\1\u0133\3\102\5"+
			"\uffff\u1f82\102\1\uffff\udffc\102",
			"",
			"\1\u0134",
			"\1\u0135\1\uffff\1\u0136\16\uffff\1\u0137",
			"\1\u0138",
			"\1\u0139",
			"\1\u013a",
			"\1\u013b",
			"\1\u013c\1\u013d",
			"\1\u013e",
			"\1\u013f",
			"\1\u0140",
			"\1\u0141",
			"\1\u0142",
			"\1\u0143\22\uffff\1\u0144",
			"\1\u0145",
			"\1\u0146",
			"\1\u0147",
			"\1\u0148",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u014a",
			"\1\u014b",
			"\1\u014c",
			"\1\u014d",
			"\1\u014e",
			"\1\u014f",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0151",
			"\1\u0152",
			"\1\u0153",
			"\1\u0154",
			"\1\u0155",
			"\1\u0156",
			"",
			"\1\u0157",
			"\1\u0158",
			"\1\u0159",
			"\1\u015a\5\uffff\1\u015b",
			"\1\u015c",
			"\1\u015d",
			"\1\u015e",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u015f\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u0161",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0163",
			"\1\u0164",
			"\1\u0165",
			"\1\u0166",
			"\1\u0167",
			"\1\u0168",
			"\1\u0169",
			"\1\u016a",
			"\1\u016b",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u016d",
			"\1\u016e",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u016f\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u0171",
			"",
			"\1\u0172",
			"\1\u0173",
			"",
			"\1\u0174",
			"\1\u0175",
			"\1\u0176",
			"\1\u0177",
			"\1\u0178",
			"\1\u0179",
			"\1\u017a",
			"\1\u017b",
			"\12\76\7\uffff\32\76\4\uffff\1\u017d\1\uffff\22\76\1\u017c\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u017f",
			"\1\u0180",
			"\1\u0181",
			"\1\u0182",
			"\1\u0183",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0185",
			"\1\u0186",
			"\1\u0187",
			"\1\u0188\1\uffff\1\u0189",
			"\1\u018a",
			"\1\u018b",
			"\1\u018c",
			"",
			"\1\u018d",
			"\1\u018e",
			"\1\u018f",
			"\1\u0190",
			"\1\u0191",
			"\1\u0192",
			"\1\u0193",
			"\1\u0194",
			"\1\u0195",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0197",
			"\1\u0198",
			"\1\u0199",
			"\1\u019a\3\uffff\1\u019b",
			"\1\u019c",
			"\0\u019e",
			"",
			"",
			"",
			"",
			"",
			"\12\u0128\13\uffff\1\u0097\37\uffff\1\u0097",
			"",
			"\1\u019f",
			"",
			"",
			"\1\u01a0",
			"",
			"",
			"\1\u01a1",
			"",
			"\1\u01a2",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\4\102\1\u01a3\25\102\5"+
			"\uffff\u1f82\102\1\uffff\udffc\102",
			"\1\u01a4",
			"\1\u01a5",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01a8",
			"\1\u01a9",
			"\1\u01aa",
			"\1\u01ab",
			"\1\u01ac",
			"\1\u01ad",
			"\1\u01ae",
			"\1\u01af",
			"\1\u01b0",
			"\1\u01b1",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01b3",
			"\1\u01b4",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01b6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01b8",
			"",
			"\1\u01b9",
			"\1\u01ba",
			"\1\u01bb",
			"\1\u01bc",
			"\1\u01bd",
			"\1\u01be",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01c1",
			"\1\u01c2",
			"\1\u01c3",
			"\1\u01c4",
			"\1\u01c5",
			"\1\u01c6",
			"\1\u01c7",
			"\1\u01c8",
			"\1\u01c9",
			"\1\u01ca",
			"\1\u01cb",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01d2",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01d4",
			"\1\u01d5",
			"\1\u01d6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u01d8",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u01d9\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u01db",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01de",
			"\1\u01df",
			"\1\u01e0",
			"\1\u01e1",
			"\1\u01e2",
			"\1\u01e3",
			"\1\u01e4",
			"\1\u01e5",
			"\1\u01e6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01e8",
			"",
			"\1\u01e9",
			"\1\u01ea",
			"\1\u01eb",
			"\1\u01ec",
			"\1\u01ed",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01f0",
			"\1\u01f1",
			"\1\u01f2",
			"\1\u01f3",
			"\1\u01f4",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01f6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u01f8",
			"\1\u01f9",
			"\1\u01fa",
			"\1\u01fb",
			"\1\u01fc",
			"\1\u01fd",
			"\1\u01fe",
			"",
			"\1\u01ff",
			"\1\u0200",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0203",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\10\76\1\u0204\21\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"",
			"",
			"\1\u0206",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\4\102\1\u020a\25\102\5"+
			"\uffff\u1f82\102\1\uffff\udffc\102",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u020c",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u020e",
			"\1\u020f\20\uffff\1\u0210",
			"\1\u0211",
			"\1\u0212",
			"\1\u0213",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0215",
			"\1\u0216",
			"\1\u0217",
			"",
			"\1\u0218",
			"\1\u0219",
			"",
			"\1\u021a",
			"",
			"\1\u021b",
			"\1\u021c",
			"\1\u021d",
			"\1\u021e",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"\1\u0222",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0225",
			"\1\u0226",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0228",
			"\1\u0229",
			"\1\u022a",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"",
			"",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u022f",
			"\1\u0230",
			"",
			"\1\u0231",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u0233",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0236",
			"\1\u0237",
			"\1\u0238",
			"\1\u0239",
			"\1\u023a",
			"\1\u023b",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u023d",
			"\1\u023e",
			"\1\u023f",
			"\1\u0240",
			"\1\u0241",
			"\1\u0242",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0245",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u0246\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u0248",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u024a",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u024c",
			"\1\u024d",
			"\1\u024e",
			"\1\u024f",
			"\1\u0250",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u0252\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0255",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\15\102\1\u0257\14\102\5"+
			"\uffff\u1f82\102\1\uffff\udffc\102",
			"",
			"\1\u0258",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\u025a\1\uffff\22\76\1\u0259\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\1\u025c",
			"\1\u025d",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u025f",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u0261",
			"\1\u0262",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0264",
			"\1\u0265",
			"\1\u0266",
			"\1\u0267",
			"\1\u0268",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u026a",
			"",
			"",
			"",
			"\1\u026b",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u026e",
			"\1\u026f",
			"\1\u0270",
			"",
			"",
			"",
			"",
			"\1\u0271",
			"\1\u0272",
			"\1\u0273",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"\1\u0275",
			"\1\u0276",
			"\1\u0277",
			"\1\u0278",
			"\1\u0279",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u027b",
			"\1\u027c",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\22\76\1\u027d\7\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0280",
			"\1\u0281",
			"",
			"",
			"\1\u0282",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\1\u0283\31\76\5\uffff\u1f82"+
			"\76\1\uffff\udffc\76",
			"",
			"\1\u0285",
			"",
			"\1\u0286",
			"",
			"\1\u0287",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0289",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102\5\uffff\u1f82\102"+
			"\1\uffff\udffc\102",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0291",
			"",
			"\1\u0292",
			"\1\u0293",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\25\76\1\u0296\4\76\5\uffff"+
			"\u1f82\76\1\uffff\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u0299",
			"\1\u029a",
			"\1\u029b",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u029e",
			"",
			"",
			"\1\u029f",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02a1",
			"\1\u02a2",
			"\1\u02a3",
			"\1\u02a4",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u02aa",
			"\1\u02ab",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"\1\u02ad",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02af",
			"\1\u02b0",
			"",
			"\1\u02b1",
			"\1\u02b2",
			"\1\u02b3",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"\1\u02b5",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02b7",
			"",
			"",
			"\1\u02b8",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02ba",
			"\1\u02bb",
			"",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02bd",
			"",
			"\1\u02be",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"",
			"",
			"",
			"\1\u02c2",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u02c5",
			"\1\u02c6",
			"\1\u02c7",
			"\1\u02c8",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u02ca",
			"",
			"\1\u02cb",
			"\1\u02cc",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02ce",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"",
			"",
			"\1\u02d1",
			"",
			"",
			"\1\u02d2",
			"\1\u02d3",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"",
			"\1\u02d6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02d8",
			"",
			"\1\u02d9",
			"",
			"",
			"\1\u02da",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02dc",
			"",
			"",
			"\1\u02dd",
			"",
			"\1\u02de",
			"\1\u02df",
			"\1\u02e0",
			"",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02e2",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02e4",
			"\1\u02e5",
			"",
			"\1\u02e6",
			"",
			"\1\u02e7",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02e9",
			"\1\u02ea",
			"",
			"\1\u02eb",
			"\1\u02ec",
			"\1\u02ed",
			"\1\u02ee",
			"\1\u02ef",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			"\1\u02f1",
			"",
			"\1\u02f2",
			"\1\u02f3",
			"\1\u02f4",
			"\1\u02f5",
			"\1\u02f6",
			"\12\76\7\uffff\32\76\4\uffff\1\76\1\uffff\32\76\5\uffff\u1f82\76\1\uffff"+
			"\udffc\76",
			""
	};

	static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS);
	static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS);
	static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS);
	static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS);
	static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS);
	static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS);
	static final short[][] DFA30_transition;

	static {
		int numStates = DFA30_transitionS.length;
		DFA30_transition = new short[numStates][];
		for (int i=0; i= '\u0000' && LA30_30 <= '\uFFFF')) ) {s = 62;}
						else s = 147;
						if ( s>=0 ) return s;
						break;

					case 1 : 
						int LA30_136 = input.LA(1);
						s = -1;
						if ( (LA30_136=='+') ) {s = 290;}
						else if ( ((LA30_136 >= '\u0000' && LA30_136 <= '*')||(LA30_136 >= ',' && LA30_136 <= '\uFFFF')) ) {s = 292;}
						else s = 291;
						if ( s>=0 ) return s;
						break;

					case 2 : 
						int LA30_290 = input.LA(1);
						s = -1;
						if ( ((LA30_290 >= '\u0000' && LA30_290 <= '\uFFFF')) ) {s = 414;}
						else s = 413;
						if ( s>=0 ) return s;
						break;

					case 3 : 
						int LA30_52 = input.LA(1);
						s = -1;
						if ( ((LA30_52 >= '\u0000' && LA30_52 <= '\uFFFF')) ) {s = 175;}
						else s = 55;
						if ( s>=0 ) return s;
						break;

					case 4 : 
						int LA30_137 = input.LA(1);
						s = -1;
						if ( ((LA30_137 >= '\u0000' && LA30_137 <= '\uFFFF')) ) {s = 294;}
						else s = 293;
						if ( s>=0 ) return s;
						break;

					case 5 : 
						int LA30_141 = input.LA(1);
						s = -1;
						if ( ((LA30_141 >= '\u0000' && LA30_141 <= '\uFFFF')) ) {s = 294;}
						else s = 295;
						if ( s>=0 ) return s;
						break;

					case 6 : 
						int LA30_0 = input.LA(1);
						s = -1;
						if ( (LA30_0=='a') ) {s = 1;}
						else if ( (LA30_0=='b') ) {s = 2;}
						else if ( (LA30_0=='c') ) {s = 3;}
						else if ( (LA30_0=='d') ) {s = 4;}
						else if ( (LA30_0=='e') ) {s = 5;}
						else if ( (LA30_0=='f') ) {s = 6;}
						else if ( (LA30_0=='g') ) {s = 7;}
						else if ( (LA30_0=='h') ) {s = 8;}
						else if ( (LA30_0=='i') ) {s = 9;}
						else if ( (LA30_0=='j') ) {s = 10;}
						else if ( (LA30_0=='k') ) {s = 11;}
						else if ( (LA30_0=='l') ) {s = 12;}
						else if ( (LA30_0=='m') ) {s = 13;}
						else if ( (LA30_0=='n') ) {s = 14;}
						else if ( (LA30_0=='o') ) {s = 15;}
						else if ( (LA30_0=='p') ) {s = 16;}
						else if ( (LA30_0=='r') ) {s = 17;}
						else if ( (LA30_0=='s') ) {s = 18;}
						else if ( (LA30_0=='t') ) {s = 19;}
						else if ( (LA30_0=='u') ) {s = 20;}
						else if ( (LA30_0=='v') ) {s = 21;}
						else if ( (LA30_0=='w') ) {s = 22;}
						else if ( (LA30_0=='/') ) {s = 23;}
						else if ( (LA30_0=='*') ) {s = 24;}
						else if ( (LA30_0=='-') ) {s = 25;}
						else if ( (LA30_0==':') ) {s = 26;}
						else if ( (LA30_0=='X'||LA30_0=='x') ) {s = 27;}
						else if ( (LA30_0=='B') ) {s = 28;}
						else if ( (LA30_0=='E') ) {s = 29;}
						else if ( (LA30_0=='\"') ) {s = 30;}
						else if ( ((LA30_0 >= '0' && LA30_0 <= '9')) ) {s = 31;}
						else if ( (LA30_0=='.') ) {s = 32;}
						else if ( (LA30_0=='A'||(LA30_0 >= 'C' && LA30_0 <= 'D')||(LA30_0 >= 'F' && LA30_0 <= 'W')||(LA30_0 >= 'Y' && LA30_0 <= 'Z')||LA30_0=='q'||(LA30_0 >= 'y' && LA30_0 <= 'z')) ) {s = 33;}
						else if ( (LA30_0=='=') ) {s = 34;}
						else if ( (LA30_0=='<') ) {s = 35;}
						else if ( (LA30_0=='>') ) {s = 36;}
						else if ( (LA30_0=='!') ) {s = 37;}
						else if ( (LA30_0=='|') ) {s = 38;}
						else if ( (LA30_0==',') ) {s = 39;}
						else if ( (LA30_0=='(') ) {s = 40;}
						else if ( (LA30_0==')') ) {s = 41;}
						else if ( (LA30_0==';') ) {s = 42;}
						else if ( (LA30_0=='?') ) {s = 43;}
						else if ( (LA30_0=='[') ) {s = 44;}
						else if ( (LA30_0==']') ) {s = 45;}
						else if ( (LA30_0=='{') ) {s = 46;}
						else if ( (LA30_0=='}') ) {s = 47;}
						else if ( (LA30_0=='@') ) {s = 48;}
						else if ( (LA30_0=='~') ) {s = 49;}
						else if ( (LA30_0=='+') ) {s = 50;}
						else if ( (LA30_0=='%') ) {s = 51;}
						else if ( (LA30_0=='\'') ) {s = 52;}
						else if ( (LA30_0=='\t'||LA30_0==' '||LA30_0=='\u2002') ) {s = 53;}
						else if ( (LA30_0=='\n'||LA30_0=='\r') ) {s = 54;}
						else if ( ((LA30_0 >= '\u0000' && LA30_0 <= '\b')||(LA30_0 >= '\u000B' && LA30_0 <= '\f')||(LA30_0 >= '\u000E' && LA30_0 <= '\u001F')||(LA30_0 >= '#' && LA30_0 <= '$')||LA30_0=='&'||LA30_0=='\\'||(LA30_0 >= '^' && LA30_0 <= '`')||(LA30_0 >= '\u007F' && LA30_0 <= '\u2001')||(LA30_0 >= '\u2003' && LA30_0 <= '\uFFFF')) ) {s = 55;}
						if ( s>=0 ) return s;
						break;
			}
			if (state.backtracking>0) {state.failed=true; return -1;}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 30, _s, input);
			error(nvae);
			throw nvae;
		}
	}

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy