• Home
• org.intermine
• intermine-objectstore
• 5.1.0
• source code
• SqlParser.java

×

Project download

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

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

org.intermine.sql.query.SqlParser Maven / Gradle / Ivy

// $ANTLR : "intermine_sql.g" -> "SqlParser.java"$

package org.intermine.sql.query;

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import java.util.IdentityHashMap;
import antlr.collections.AST;
import java.util.Hashtable;
import antlr.ASTFactory;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;

public class SqlParser extends antlr.LLkParser       implements SqlTokenTypes
 {

protected SqlParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public SqlParser(TokenBuffer tokenBuf) {
  this(tokenBuf,6);
}

protected SqlParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public SqlParser(TokenStream lexer) {
  this(lexer,6);
}

public SqlParser(ParserSharedInputState state) {
  super(state,6);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

	IdentityHashMap start_ruleCache = new IdentityHashMap();
	public final void start_rule() throws RecognitionException, TokenStreamException {
		Object retval = start_ruleCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST start_rule_AST = null;
				
				sql();
				astFactory.addASTChild(currentAST, returnAST);
				{
				switch ( LA(1)) {
				case SEMI:
				{
					match(SEMI);
					break;
				}
				case EOF:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				start_rule_AST = (AST)currentAST.root;
				returnAST = start_rule_AST;
				start_ruleCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				start_ruleCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				start_ruleCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap sqlCache = new IdentityHashMap();
	public final void sql() throws RecognitionException, TokenStreamException {
		Object retval = sqlCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST sql_AST = null;
				
				sql_statement();
				astFactory.addASTChild(currentAST, returnAST);
				{
				_loop478:
				do {
					if ((LA(1)==LITERAL_union)) {
						match(LITERAL_union);
						sql_statement();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						break _loop478;
					}
					
				} while (true);
				}
				sql_AST = (AST)currentAST.root;
				returnAST = sql_AST;
				sqlCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				sqlCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				sqlCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap sql_statementCache = new IdentityHashMap();
	public final void sql_statement() throws RecognitionException, TokenStreamException {
		Object retval = sql_statementCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST sql_statement_AST = null;
				
				select_command();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					sql_statement_AST = (AST)currentAST.root;
					sql_statement_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SQL_STATEMENT,"SQL_STATEMENT")).add(sql_statement_AST));
					currentAST.root = sql_statement_AST;
					currentAST.child = sql_statement_AST!=null &&sql_statement_AST.getFirstChild()!=null ?
						sql_statement_AST.getFirstChild() : sql_statement_AST;
					currentAST.advanceChildToEnd();
				}
				sql_statement_AST = (AST)currentAST.root;
				returnAST = sql_statement_AST;
				sql_statementCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				sql_statementCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				sql_statementCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap select_commandCache = new IdentityHashMap();
	public final void select_command() throws RecognitionException, TokenStreamException {
		Object retval = select_commandCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST select_command_AST = null;
				
				{
				switch ( LA(1)) {
				case LITERAL_explain:
				{
					AST tmp114_AST = null;
					tmp114_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp114_AST);
					match(LITERAL_explain);
					break;
				}
				case LITERAL_select:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				match(LITERAL_select);
				{
				switch ( LA(1)) {
				case LITERAL_all:
				{
					match(LITERAL_all);
					break;
				}
				case LITERAL_distinct:
				{
					AST tmp117_AST = null;
					tmp117_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp117_AST);
					match(LITERAL_distinct);
					break;
				}
				case INTEGER:
				case IDENTIFIER:
				case QUOTED_STRING:
				case ESCAPED_STRING:
				case FLOAT:
				case LITERAL_true:
				case LITERAL_false:
				case LITERAL_null:
				case LITERAL_count:
				case LITERAL_max:
				case LITERAL_min:
				case LITERAL_sum:
				case LITERAL_avg:
				case LITERAL_lower:
				case LITERAL_upper:
				case LITERAL_greatest:
				case LITERAL_least:
				case LITERAL_strpos:
				case LITERAL_substr:
				case LITERAL_coalesce:
				case LITERAL_stddev:
				case OPEN_PAREN:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				select_list();
				astFactory.addASTChild(currentAST, returnAST);
				{
				switch ( LA(1)) {
				case LITERAL_from:
				{
					from_list();
					astFactory.addASTChild(currentAST, returnAST);
					{
					switch ( LA(1)) {
					case LITERAL_where:
					{
						where_clause();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					case EOF:
					case SEMI:
					case LITERAL_union:
					case LITERAL_group:
					case LITERAL_order:
					case LITERAL_limit:
					case CLOSE_PAREN:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					switch ( LA(1)) {
					case LITERAL_group:
					{
						group_clause();
						astFactory.addASTChild(currentAST, returnAST);
						{
						switch ( LA(1)) {
						case LITERAL_having:
						{
							having_clause();
							astFactory.addASTChild(currentAST, returnAST);
							break;
						}
						case EOF:
						case SEMI:
						case LITERAL_union:
						case LITERAL_order:
						case LITERAL_limit:
						case CLOSE_PAREN:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
						break;
					}
					case EOF:
					case SEMI:
					case LITERAL_union:
					case LITERAL_order:
					case LITERAL_limit:
					case CLOSE_PAREN:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					switch ( LA(1)) {
					case LITERAL_order:
					{
						order_clause();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					case EOF:
					case SEMI:
					case LITERAL_union:
					case LITERAL_limit:
					case CLOSE_PAREN:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					{
					switch ( LA(1)) {
					case LITERAL_limit:
					{
						limit_clause();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					case EOF:
					case SEMI:
					case LITERAL_union:
					case CLOSE_PAREN:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					break;
				}
				case EOF:
				case SEMI:
				case LITERAL_union:
				case CLOSE_PAREN:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				select_command_AST = (AST)currentAST.root;
				returnAST = select_command_AST;
				select_commandCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				select_commandCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				select_commandCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap select_listCache = new IdentityHashMap();
	public final void select_list() throws RecognitionException, TokenStreamException {
		Object retval = select_listCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST select_list_AST = null;
				
				select_value();
				astFactory.addASTChild(currentAST, returnAST);
				{
				_loop491:
				do {
					if ((LA(1)==COMMA)) {
						match(COMMA);
						select_value();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						break _loop491;
					}
					
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					select_list_AST = (AST)currentAST.root;
					select_list_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SELECT_LIST,"SELECT_LIST")).add(select_list_AST));
					currentAST.root = select_list_AST;
					currentAST.child = select_list_AST!=null &&select_list_AST.getFirstChild()!=null ?
						select_list_AST.getFirstChild() : select_list_AST;
					currentAST.advanceChildToEnd();
				}
				select_list_AST = (AST)currentAST.root;
				returnAST = select_list_AST;
				select_listCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				select_listCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				select_listCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap from_listCache = new IdentityHashMap();
	public final void from_list() throws RecognitionException, TokenStreamException {
		Object retval = from_listCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST from_list_AST = null;
				
				match(LITERAL_from);
				abstract_table();
				astFactory.addASTChild(currentAST, returnAST);
				{
				_loop494:
				do {
					if ((LA(1)==COMMA)) {
						match(COMMA);
						abstract_table();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						break _loop494;
					}
					
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					from_list_AST = (AST)currentAST.root;
					from_list_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FROM_LIST,"FROM_LIST")).add(from_list_AST));
					currentAST.root = from_list_AST;
					currentAST.child = from_list_AST!=null &&from_list_AST.getFirstChild()!=null ?
						from_list_AST.getFirstChild() : from_list_AST;
					currentAST.advanceChildToEnd();
				}
				from_list_AST = (AST)currentAST.root;
				returnAST = from_list_AST;
				from_listCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				from_listCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				from_listCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap where_clauseCache = new IdentityHashMap();
	public final void where_clause() throws RecognitionException, TokenStreamException {
		Object retval = where_clauseCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST where_clause_AST = null;
				
				match(LITERAL_where);
				abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					where_clause_AST = (AST)currentAST.root;
					where_clause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(WHERE_CLAUSE,"WHERE_CLAUSE")).add(where_clause_AST));
					currentAST.root = where_clause_AST;
					currentAST.child = where_clause_AST!=null &&where_clause_AST.getFirstChild()!=null ?
						where_clause_AST.getFirstChild() : where_clause_AST;
					currentAST.advanceChildToEnd();
				}
				where_clause_AST = (AST)currentAST.root;
				returnAST = where_clause_AST;
				where_clauseCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				where_clauseCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				where_clauseCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap group_clauseCache = new IdentityHashMap();
	public final void group_clause() throws RecognitionException, TokenStreamException {
		Object retval = group_clauseCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST group_clause_AST = null;
				
				match(LITERAL_group);
				match(LITERAL_by);
				abstract_value();
				astFactory.addASTChild(currentAST, returnAST);
				{
				_loop498:
				do {
					if ((LA(1)==COMMA)) {
						match(COMMA);
						abstract_value();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						break _loop498;
					}
					
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					group_clause_AST = (AST)currentAST.root;
					group_clause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(GROUP_CLAUSE,"GROUP_CLAUSE")).add(group_clause_AST));
					currentAST.root = group_clause_AST;
					currentAST.child = group_clause_AST!=null &&group_clause_AST.getFirstChild()!=null ?
						group_clause_AST.getFirstChild() : group_clause_AST;
					currentAST.advanceChildToEnd();
				}
				group_clause_AST = (AST)currentAST.root;
				returnAST = group_clause_AST;
				group_clauseCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				group_clauseCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				group_clauseCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap having_clauseCache = new IdentityHashMap();
	public final void having_clause() throws RecognitionException, TokenStreamException {
		Object retval = having_clauseCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST having_clause_AST = null;
				
				match(LITERAL_having);
				abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					having_clause_AST = (AST)currentAST.root;
					having_clause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(HAVING_CLAUSE,"HAVING_CLAUSE")).add(having_clause_AST));
					currentAST.root = having_clause_AST;
					currentAST.child = having_clause_AST!=null &&having_clause_AST.getFirstChild()!=null ?
						having_clause_AST.getFirstChild() : having_clause_AST;
					currentAST.advanceChildToEnd();
				}
				having_clause_AST = (AST)currentAST.root;
				returnAST = having_clause_AST;
				having_clauseCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				having_clauseCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				having_clauseCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap order_clauseCache = new IdentityHashMap();
	public final void order_clause() throws RecognitionException, TokenStreamException {
		Object retval = order_clauseCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST order_clause_AST = null;
				
				match(LITERAL_order);
				match(LITERAL_by);
				orderby_value();
				astFactory.addASTChild(currentAST, returnAST);
				{
				_loop502:
				do {
					if ((LA(1)==COMMA)) {
						match(COMMA);
						orderby_value();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						break _loop502;
					}
					
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					order_clause_AST = (AST)currentAST.root;
					order_clause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ORDER_CLAUSE,"ORDER_CLAUSE")).add(order_clause_AST));
					currentAST.root = order_clause_AST;
					currentAST.child = order_clause_AST!=null &&order_clause_AST.getFirstChild()!=null ?
						order_clause_AST.getFirstChild() : order_clause_AST;
					currentAST.advanceChildToEnd();
				}
				order_clause_AST = (AST)currentAST.root;
				returnAST = order_clause_AST;
				order_clauseCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				order_clauseCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				order_clauseCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap limit_clauseCache = new IdentityHashMap();
	public final void limit_clause() throws RecognitionException, TokenStreamException {
		Object retval = limit_clauseCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST limit_clause_AST = null;
				
				match(LITERAL_limit);
				AST tmp130_AST = null;
				tmp130_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp130_AST);
				match(INTEGER);
				{
				switch ( LA(1)) {
				case LITERAL_offset:
				{
					match(LITERAL_offset);
					AST tmp132_AST = null;
					tmp132_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp132_AST);
					match(INTEGER);
					break;
				}
				case EOF:
				case SEMI:
				case LITERAL_union:
				case CLOSE_PAREN:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					limit_clause_AST = (AST)currentAST.root;
					limit_clause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(LIMIT_CLAUSE,"LIMIT_CLAUSE")).add(limit_clause_AST));
					currentAST.root = limit_clause_AST;
					currentAST.child = limit_clause_AST!=null &&limit_clause_AST.getFirstChild()!=null ?
						limit_clause_AST.getFirstChild() : limit_clause_AST;
					currentAST.advanceChildToEnd();
				}
				limit_clause_AST = (AST)currentAST.root;
				returnAST = limit_clause_AST;
				limit_clauseCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				limit_clauseCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				limit_clauseCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap select_valueCache = new IdentityHashMap();
	public final void select_value() throws RecognitionException, TokenStreamException {
		Object retval = select_valueCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST select_value_AST = null;
				
				{
				boolean synPredMatched508 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_3.member(LA(4))) && (_tokenSet_4.member(LA(5))) && (_tokenSet_5.member(LA(6))))) {
					int _m508 = mark();
					synPredMatched508 = true;
					inputState.guessing++;
					try {
						{
						unsafe_function();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched508 = false;
					}
					rewind(_m508);
inputState.guessing--;
				}
				if ( synPredMatched508 ) {
					unsafe_function();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_as);
					field_alias();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					boolean synPredMatched510 = false;
					if (((_tokenSet_0.member(LA(1))) && (_tokenSet_6.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_3.member(LA(4))) && (_tokenSet_7.member(LA(5))) && (_tokenSet_8.member(LA(6))))) {
						int _m510 = mark();
						synPredMatched510 = true;
						inputState.guessing++;
						try {
							{
							typecast();
							}
						}
						catch (RecognitionException pe) {
							synPredMatched510 = false;
						}
						rewind(_m510);
inputState.guessing--;
					}
					if ( synPredMatched510 ) {
						typecast();
						astFactory.addASTChild(currentAST, returnAST);
						match(LITERAL_as);
						field_alias();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else if ((LA(1)==IDENTIFIER) && (_tokenSet_9.member(LA(2))) && (_tokenSet_10.member(LA(3))) && (_tokenSet_11.member(LA(4))) && (_tokenSet_12.member(LA(5))) && (_tokenSet_13.member(LA(6)))) {
						field();
						astFactory.addASTChild(currentAST, returnAST);
						{
						switch ( LA(1)) {
						case LITERAL_as:
						{
							match(LITERAL_as);
							field_alias();
							astFactory.addASTChild(currentAST, returnAST);
							break;
						}
						case EOF:
						case SEMI:
						case LITERAL_union:
						case COMMA:
						case LITERAL_from:
						case CLOSE_PAREN:
						{
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
					}
					else if ((_tokenSet_14.member(LA(1))) && (LA(2)==LITERAL_as)) {
						constant();
						astFactory.addASTChild(currentAST, returnAST);
						match(LITERAL_as);
						field_alias();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else if (((LA(1) >= LITERAL_count && LA(1) <= LITERAL_stddev)) && (LA(2)==OPEN_PAREN) && (_tokenSet_15.member(LA(3))) && (_tokenSet_16.member(LA(4))) && (_tokenSet_17.member(LA(5))) && (_tokenSet_4.member(LA(6)))) {
						safe_function();
						astFactory.addASTChild(currentAST, returnAST);
						match(LITERAL_as);
						field_alias();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else if ((LA(1)==OPEN_PAREN) && (_tokenSet_0.member(LA(2))) && (_tokenSet_18.member(LA(3))) && (_tokenSet_17.member(LA(4))) && (_tokenSet_4.member(LA(5))) && (_tokenSet_5.member(LA(6)))) {
						paren_value();
						astFactory.addASTChild(currentAST, returnAST);
						match(LITERAL_as);
						field_alias();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					if ( inputState.guessing==0 ) {
						select_value_AST = (AST)currentAST.root;
						select_value_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SELECT_VALUE,"SELECT_VALUE")).add(select_value_AST));
						currentAST.root = select_value_AST;
						currentAST.child = select_value_AST!=null &&select_value_AST.getFirstChild()!=null ?
							select_value_AST.getFirstChild() : select_value_AST;
						currentAST.advanceChildToEnd();
					}
					select_value_AST = (AST)currentAST.root;
					returnAST = select_value_AST;
					select_valueCache.put(LT(1), returnAST);
				} catch (RecognitionException e) {
					select_valueCache.put(LT(1), e);
					throw e;
				} catch (TokenStreamException e) {
					select_valueCache.put(LT(1), e);
					throw e;
				}
			}
		}
		
	IdentityHashMap abstract_tableCache = new IdentityHashMap();
	public final void abstract_table() throws RecognitionException, TokenStreamException {
		Object retval = abstract_tableCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST abstract_table_AST = null;
				
				switch ( LA(1)) {
				case IDENTIFIER:
				{
					table();
					astFactory.addASTChild(currentAST, returnAST);
					abstract_table_AST = (AST)currentAST.root;
					break;
				}
				case OPEN_PAREN:
				{
					subquery();
					astFactory.addASTChild(currentAST, returnAST);
					abstract_table_AST = (AST)currentAST.root;
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				returnAST = abstract_table_AST;
				abstract_tableCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				abstract_tableCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				abstract_tableCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap abstract_constraintCache = new IdentityHashMap();
	public final void abstract_constraint() throws RecognitionException, TokenStreamException {
		Object retval = abstract_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST abstract_constraint_AST = null;
				
				boolean synPredMatched567 = false;
				if (((LA(1)==IDENTIFIER) && (LA(2)==DOT) && (LA(3)==IDENTIFIER) && (LA(4)==GT) && (_tokenSet_14.member(LA(5))) && (LA(6)==LITERAL_or))) {
					int _m567 = mark();
					synPredMatched567 = true;
					inputState.guessing++;
					try {
						{
						gornull_constraint();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched567 = false;
					}
					rewind(_m567);
inputState.guessing--;
				}
				if ( synPredMatched567 ) {
					gornull_constraint();
					astFactory.addASTChild(currentAST, returnAST);
					abstract_constraint_AST = (AST)currentAST.root;
				}
				else {
					boolean synPredMatched569 = false;
					if (((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_21.member(LA(3))) && (_tokenSet_22.member(LA(4))) && (_tokenSet_23.member(LA(5))) && (_tokenSet_24.member(LA(6))))) {
						int _m569 = mark();
						synPredMatched569 = true;
						inputState.guessing++;
						try {
							{
							constraint_set();
							}
						}
						catch (RecognitionException pe) {
							synPredMatched569 = false;
						}
						rewind(_m569);
inputState.guessing--;
					}
					if ( synPredMatched569 ) {
						constraint_set();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_constraint_AST = (AST)currentAST.root;
					}
					else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_21.member(LA(3))) && (_tokenSet_25.member(LA(4))) && (_tokenSet_26.member(LA(5))) && (_tokenSet_27.member(LA(6)))) {
						safe_abstract_constraint();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_constraint_AST = (AST)currentAST.root;
					}
					else {
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					returnAST = abstract_constraint_AST;
					abstract_constraintCache.put(LT(1), returnAST);
				} catch (RecognitionException e) {
					abstract_constraintCache.put(LT(1), e);
					throw e;
				} catch (TokenStreamException e) {
					abstract_constraintCache.put(LT(1), e);
					throw e;
				}
			}
		}
		
	IdentityHashMap abstract_valueCache = new IdentityHashMap();
	public final void abstract_value() throws RecognitionException, TokenStreamException {
		Object retval = abstract_valueCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST abstract_value_AST = null;
				
				boolean synPredMatched518 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_28.member(LA(4))) && (_tokenSet_29.member(LA(5))) && (_tokenSet_30.member(LA(6))))) {
					int _m518 = mark();
					synPredMatched518 = true;
					inputState.guessing++;
					try {
						{
						unsafe_function();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched518 = false;
					}
					rewind(_m518);
inputState.guessing--;
				}
				if ( synPredMatched518 ) {
					unsafe_function();
					astFactory.addASTChild(currentAST, returnAST);
					abstract_value_AST = (AST)currentAST.root;
				}
				else {
					boolean synPredMatched520 = false;
					if (((_tokenSet_0.member(LA(1))) && (_tokenSet_6.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_28.member(LA(4))) && (_tokenSet_29.member(LA(5))) && (_tokenSet_30.member(LA(6))))) {
						int _m520 = mark();
						synPredMatched520 = true;
						inputState.guessing++;
						try {
							{
							typecast();
							}
						}
						catch (RecognitionException pe) {
							synPredMatched520 = false;
						}
						rewind(_m520);
inputState.guessing--;
					}
					if ( synPredMatched520 ) {
						typecast();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_value_AST = (AST)currentAST.root;
					}
					else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_31.member(LA(2)))) {
						constant();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_value_AST = (AST)currentAST.root;
					}
					else if ((LA(1)==IDENTIFIER) && (_tokenSet_32.member(LA(2))) && (_tokenSet_33.member(LA(3))) && (_tokenSet_34.member(LA(4))) && (_tokenSet_13.member(LA(5))) && (_tokenSet_13.member(LA(6)))) {
						field();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_value_AST = (AST)currentAST.root;
					}
					else if (((LA(1) >= LITERAL_count && LA(1) <= LITERAL_stddev)) && (LA(2)==OPEN_PAREN) && (_tokenSet_15.member(LA(3))) && (_tokenSet_16.member(LA(4))) && (_tokenSet_35.member(LA(5))) && (_tokenSet_29.member(LA(6)))) {
						safe_function();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_value_AST = (AST)currentAST.root;
					}
					else if ((LA(1)==OPEN_PAREN) && (_tokenSet_0.member(LA(2))) && (_tokenSet_18.member(LA(3))) && (_tokenSet_35.member(LA(4))) && (_tokenSet_29.member(LA(5))) && (_tokenSet_30.member(LA(6)))) {
						paren_value();
						astFactory.addASTChild(currentAST, returnAST);
						abstract_value_AST = (AST)currentAST.root;
					}
					else {
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					returnAST = abstract_value_AST;
					abstract_valueCache.put(LT(1), returnAST);
				} catch (RecognitionException e) {
					abstract_valueCache.put(LT(1), e);
					throw e;
				} catch (TokenStreamException e) {
					abstract_valueCache.put(LT(1), e);
					throw e;
				}
			}
		}
		
	IdentityHashMap orderby_valueCache = new IdentityHashMap();
	public final void orderby_value() throws RecognitionException, TokenStreamException {
		Object retval = orderby_valueCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST orderby_value_AST = null;
				
				boolean synPredMatched515 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_36.member(LA(2))) && (_tokenSet_37.member(LA(3))) && (_tokenSet_38.member(LA(4))) && (_tokenSet_39.member(LA(5))) && (_tokenSet_40.member(LA(6))))) {
					int _m515 = mark();
					synPredMatched515 = true;
					inputState.guessing++;
					try {
						{
						abstract_value();
						match(LITERAL_desc);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched515 = false;
					}
					rewind(_m515);
inputState.guessing--;
				}
				if ( synPredMatched515 ) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_desc);
					if ( inputState.guessing==0 ) {
						orderby_value_AST = (AST)currentAST.root;
						orderby_value_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ORDER_DESC,"ORDER_DESC")).add(orderby_value_AST));
						currentAST.root = orderby_value_AST;
						currentAST.child = orderby_value_AST!=null &&orderby_value_AST.getFirstChild()!=null ?
							orderby_value_AST.getFirstChild() : orderby_value_AST;
						currentAST.advanceChildToEnd();
					}
					orderby_value_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_41.member(LA(2))) && (_tokenSet_42.member(LA(3))) && (_tokenSet_39.member(LA(4))) && (_tokenSet_27.member(LA(5))) && (_tokenSet_13.member(LA(6)))) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					orderby_value_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = orderby_value_AST;
				orderby_valueCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				orderby_valueCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				orderby_valueCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap unsafe_functionCache = new IdentityHashMap();
	public final void unsafe_function() throws RecognitionException, TokenStreamException {
		Object retval = unsafe_functionCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST unsafe_function_AST = null;
				
				{
				boolean synPredMatched549 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_43.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
					int _m549 = mark();
					synPredMatched549 = true;
					inputState.guessing++;
					try {
						{
						safe_abstract_value();
						match(PLUS);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched549 = false;
					}
					rewind(_m549);
inputState.guessing--;
				}
				if ( synPredMatched549 ) {
					safe_abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					{
					int _cnt551=0;
					_loop551:
					do {
						if ((LA(1)==PLUS)) {
							AST tmp140_AST = null;
							tmp140_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp140_AST);
							match(PLUS);
							safe_abstract_value();
							astFactory.addASTChild(currentAST, returnAST);
						}
						else {
							if ( _cnt551>=1 ) { break _loop551; } else {throw new NoViableAltException(LT(1), getFilename());}
						}
						
						_cnt551++;
					} while (true);
					}
				}
				else {
					boolean synPredMatched553 = false;
					if (((_tokenSet_0.member(LA(1))) && (_tokenSet_46.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
						int _m553 = mark();
						synPredMatched553 = true;
						inputState.guessing++;
						try {
							{
							safe_abstract_value();
							match(PERCENT);
							}
						}
						catch (RecognitionException pe) {
							synPredMatched553 = false;
						}
						rewind(_m553);
inputState.guessing--;
					}
					if ( synPredMatched553 ) {
						safe_abstract_value();
						astFactory.addASTChild(currentAST, returnAST);
						AST tmp141_AST = null;
						tmp141_AST = astFactory.create(LT(1));
						astFactory.addASTChild(currentAST, tmp141_AST);
						match(PERCENT);
						safe_abstract_value();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						boolean synPredMatched555 = false;
						if (((_tokenSet_0.member(LA(1))) && (_tokenSet_47.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
							int _m555 = mark();
							synPredMatched555 = true;
							inputState.guessing++;
							try {
								{
								safe_abstract_value();
								match(ASTERISK);
								}
							}
							catch (RecognitionException pe) {
								synPredMatched555 = false;
							}
							rewind(_m555);
inputState.guessing--;
						}
						if ( synPredMatched555 ) {
							safe_abstract_value();
							astFactory.addASTChild(currentAST, returnAST);
							{
							int _cnt557=0;
							_loop557:
							do {
								if ((LA(1)==ASTERISK)) {
									AST tmp142_AST = null;
									tmp142_AST = astFactory.create(LT(1));
									astFactory.addASTChild(currentAST, tmp142_AST);
									match(ASTERISK);
									safe_abstract_value();
									astFactory.addASTChild(currentAST, returnAST);
								}
								else {
									if ( _cnt557>=1 ) { break _loop557; } else {throw new NoViableAltException(LT(1), getFilename());}
								}
								
								_cnt557++;
							} while (true);
							}
						}
						else {
							boolean synPredMatched559 = false;
							if (((_tokenSet_0.member(LA(1))) && (_tokenSet_48.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
								int _m559 = mark();
								synPredMatched559 = true;
								inputState.guessing++;
								try {
									{
									safe_abstract_value();
									match(DIVIDE);
									}
								}
								catch (RecognitionException pe) {
									synPredMatched559 = false;
								}
								rewind(_m559);
inputState.guessing--;
							}
							if ( synPredMatched559 ) {
								safe_abstract_value();
								astFactory.addASTChild(currentAST, returnAST);
								AST tmp143_AST = null;
								tmp143_AST = astFactory.create(LT(1));
								astFactory.addASTChild(currentAST, tmp143_AST);
								match(DIVIDE);
								safe_abstract_value();
								astFactory.addASTChild(currentAST, returnAST);
							}
							else {
								boolean synPredMatched561 = false;
								if (((_tokenSet_0.member(LA(1))) && (_tokenSet_49.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
									int _m561 = mark();
									synPredMatched561 = true;
									inputState.guessing++;
									try {
										{
										safe_abstract_value();
										match(POWER);
										}
									}
									catch (RecognitionException pe) {
										synPredMatched561 = false;
									}
									rewind(_m561);
inputState.guessing--;
								}
								if ( synPredMatched561 ) {
									safe_abstract_value();
									astFactory.addASTChild(currentAST, returnAST);
									AST tmp144_AST = null;
									tmp144_AST = astFactory.create(LT(1));
									astFactory.addASTChild(currentAST, tmp144_AST);
									match(POWER);
									safe_abstract_value();
									astFactory.addASTChild(currentAST, returnAST);
								}
								else {
									boolean synPredMatched563 = false;
									if (((_tokenSet_0.member(LA(1))) && (_tokenSet_50.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
										int _m563 = mark();
										synPredMatched563 = true;
										inputState.guessing++;
										try {
											{
											safe_abstract_value();
											match(MINUS);
											}
										}
										catch (RecognitionException pe) {
											synPredMatched563 = false;
										}
										rewind(_m563);
inputState.guessing--;
									}
									if ( synPredMatched563 ) {
										safe_abstract_value();
										astFactory.addASTChild(currentAST, returnAST);
										AST tmp145_AST = null;
										tmp145_AST = astFactory.create(LT(1));
										astFactory.addASTChild(currentAST, tmp145_AST);
										match(MINUS);
										safe_abstract_value();
										astFactory.addASTChild(currentAST, returnAST);
									}
									else {
										throw new NoViableAltException(LT(1), getFilename());
									}
									}}}}}
									}
									if ( inputState.guessing==0 ) {
										unsafe_function_AST = (AST)currentAST.root;
										unsafe_function_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(UNSAFE_FUNCTION,"UNSAFE_FUNCTION")).add(unsafe_function_AST));
										currentAST.root = unsafe_function_AST;
										currentAST.child = unsafe_function_AST!=null &&unsafe_function_AST.getFirstChild()!=null ?
											unsafe_function_AST.getFirstChild() : unsafe_function_AST;
										currentAST.advanceChildToEnd();
									}
									unsafe_function_AST = (AST)currentAST.root;
									returnAST = unsafe_function_AST;
									unsafe_functionCache.put(LT(1), returnAST);
								} catch (RecognitionException e) {
									unsafe_functionCache.put(LT(1), e);
									throw e;
								} catch (TokenStreamException e) {
									unsafe_functionCache.put(LT(1), e);
									throw e;
								}
							}
						}
						
	IdentityHashMap field_aliasCache = new IdentityHashMap();
	public final void field_alias() throws RecognitionException, TokenStreamException {
		Object retval = field_aliasCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST field_alias_AST = null;
				
				{
				switch ( LA(1)) {
				case ALIAS:
				{
					AST tmp146_AST = null;
					tmp146_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp146_AST);
					match(ALIAS);
					break;
				}
				case IDENTIFIER:
				{
					AST tmp147_AST = null;
					tmp147_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp147_AST);
					match(IDENTIFIER);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					field_alias_AST = (AST)currentAST.root;
					field_alias_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_ALIAS,"FIELD_ALIAS")).add(field_alias_AST));
					currentAST.root = field_alias_AST;
					currentAST.child = field_alias_AST!=null &&field_alias_AST.getFirstChild()!=null ?
						field_alias_AST.getFirstChild() : field_alias_AST;
					currentAST.advanceChildToEnd();
				}
				field_alias_AST = (AST)currentAST.root;
				returnAST = field_alias_AST;
				field_aliasCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				field_aliasCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				field_aliasCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap typecastCache = new IdentityHashMap();
	public final void typecast() throws RecognitionException, TokenStreamException {
		Object retval = typecastCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST typecast_AST = null;
				
				{
				switch ( LA(1)) {
				case INTEGER:
				case QUOTED_STRING:
				case ESCAPED_STRING:
				case FLOAT:
				case LITERAL_true:
				case LITERAL_false:
				case LITERAL_null:
				{
					constant();
					astFactory.addASTChild(currentAST, returnAST);
					break;
				}
				case IDENTIFIER:
				{
					field();
					astFactory.addASTChild(currentAST, returnAST);
					break;
				}
				case LITERAL_count:
				case LITERAL_max:
				case LITERAL_min:
				case LITERAL_sum:
				case LITERAL_avg:
				case LITERAL_lower:
				case LITERAL_upper:
				case LITERAL_greatest:
				case LITERAL_least:
				case LITERAL_strpos:
				case LITERAL_substr:
				case LITERAL_coalesce:
				case LITERAL_stddev:
				{
					safe_function();
					astFactory.addASTChild(currentAST, returnAST);
					break;
				}
				case OPEN_PAREN:
				{
					paren_value();
					astFactory.addASTChild(currentAST, returnAST);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				{
				int _cnt542=0;
				_loop542:
				do {
					if ((LA(1)==COLONTYPE)) {
						match(COLONTYPE);
						{
						switch ( LA(1)) {
						case LITERAL_boolean:
						{
							AST tmp149_AST = null;
							tmp149_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp149_AST);
							match(LITERAL_boolean);
							break;
						}
						case LITERAL_real:
						{
							AST tmp150_AST = null;
							tmp150_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp150_AST);
							match(LITERAL_real);
							break;
						}
						case LITERAL_double:
						{
							AST tmp151_AST = null;
							tmp151_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp151_AST);
							match(LITERAL_double);
							match(LITERAL_precision);
							break;
						}
						case LITERAL_smallint:
						{
							AST tmp153_AST = null;
							tmp153_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp153_AST);
							match(LITERAL_smallint);
							break;
						}
						case LITERAL_integer:
						{
							AST tmp154_AST = null;
							tmp154_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp154_AST);
							match(LITERAL_integer);
							break;
						}
						case LITERAL_bigint:
						{
							AST tmp155_AST = null;
							tmp155_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp155_AST);
							match(LITERAL_bigint);
							break;
						}
						case LITERAL_numeric:
						{
							AST tmp156_AST = null;
							tmp156_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp156_AST);
							match(LITERAL_numeric);
							break;
						}
						case LITERAL_text:
						{
							AST tmp157_AST = null;
							tmp157_AST = astFactory.create(LT(1));
							astFactory.addASTChild(currentAST, tmp157_AST);
							match(LITERAL_text);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
					}
					else {
						if ( _cnt542>=1 ) { break _loop542; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt542++;
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					typecast_AST = (AST)currentAST.root;
					typecast_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPECAST,"TYPECAST")).add(typecast_AST));
					currentAST.root = typecast_AST;
					currentAST.child = typecast_AST!=null &&typecast_AST.getFirstChild()!=null ?
						typecast_AST.getFirstChild() : typecast_AST;
					currentAST.advanceChildToEnd();
				}
				typecast_AST = (AST)currentAST.root;
				returnAST = typecast_AST;
				typecastCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				typecastCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				typecastCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap fieldCache = new IdentityHashMap();
	public final void field() throws RecognitionException, TokenStreamException {
		Object retval = fieldCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST field_AST = null;
				
				{
				if ((LA(1)==IDENTIFIER) && (LA(2)==DOT)) {
					table_alias();
					astFactory.addASTChild(currentAST, returnAST);
					match(DOT);
				}
				else if ((LA(1)==IDENTIFIER) && (_tokenSet_51.member(LA(2)))) {
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				}
				field_name();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					field_AST = (AST)currentAST.root;
					field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD,"FIELD")).add(field_AST));
					currentAST.root = field_AST;
					currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
						field_AST.getFirstChild() : field_AST;
					currentAST.advanceChildToEnd();
				}
				field_AST = (AST)currentAST.root;
				returnAST = field_AST;
				fieldCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				fieldCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				fieldCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap constantCache = new IdentityHashMap();
	public final void constant() throws RecognitionException, TokenStreamException {
		Object retval = constantCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST constant_AST = null;
				
				{
				switch ( LA(1)) {
				case QUOTED_STRING:
				{
					AST tmp159_AST = null;
					tmp159_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp159_AST);
					match(QUOTED_STRING);
					break;
				}
				case ESCAPED_STRING:
				{
					AST tmp160_AST = null;
					tmp160_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp160_AST);
					match(ESCAPED_STRING);
					break;
				}
				case INTEGER:
				{
					AST tmp161_AST = null;
					tmp161_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp161_AST);
					match(INTEGER);
					break;
				}
				case FLOAT:
				{
					AST tmp162_AST = null;
					tmp162_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp162_AST);
					match(FLOAT);
					break;
				}
				case LITERAL_true:
				{
					AST tmp163_AST = null;
					tmp163_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp163_AST);
					match(LITERAL_true);
					break;
				}
				case LITERAL_false:
				{
					AST tmp164_AST = null;
					tmp164_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp164_AST);
					match(LITERAL_false);
					break;
				}
				case LITERAL_null:
				{
					AST tmp165_AST = null;
					tmp165_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp165_AST);
					match(LITERAL_null);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					constant_AST = (AST)currentAST.root;
					constant_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CONSTANT,"CONSTANT")).add(constant_AST));
					currentAST.root = constant_AST;
					currentAST.child = constant_AST!=null &&constant_AST.getFirstChild()!=null ?
						constant_AST.getFirstChild() : constant_AST;
					currentAST.advanceChildToEnd();
				}
				constant_AST = (AST)currentAST.root;
				returnAST = constant_AST;
				constantCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				constantCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				constantCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap safe_functionCache = new IdentityHashMap();
	public final void safe_function() throws RecognitionException, TokenStreamException {
		Object retval = safe_functionCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST safe_function_AST = null;
				
				{
				switch ( LA(1)) {
				case LITERAL_count:
				{
					AST tmp166_AST = null;
					tmp166_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp166_AST);
					match(LITERAL_count);
					match(OPEN_PAREN);
					match(ASTERISK);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_max:
				{
					AST tmp170_AST = null;
					tmp170_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp170_AST);
					match(LITERAL_max);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_min:
				{
					AST tmp173_AST = null;
					tmp173_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp173_AST);
					match(LITERAL_min);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_sum:
				{
					AST tmp176_AST = null;
					tmp176_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp176_AST);
					match(LITERAL_sum);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_avg:
				{
					AST tmp179_AST = null;
					tmp179_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp179_AST);
					match(LITERAL_avg);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_lower:
				{
					AST tmp182_AST = null;
					tmp182_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp182_AST);
					match(LITERAL_lower);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_upper:
				{
					AST tmp185_AST = null;
					tmp185_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp185_AST);
					match(LITERAL_upper);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_greatest:
				{
					AST tmp188_AST = null;
					tmp188_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp188_AST);
					match(LITERAL_greatest);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(COMMA);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_least:
				{
					AST tmp192_AST = null;
					tmp192_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp192_AST);
					match(LITERAL_least);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(COMMA);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_strpos:
				{
					AST tmp196_AST = null;
					tmp196_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp196_AST);
					match(LITERAL_strpos);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(COMMA);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_substr:
				{
					AST tmp200_AST = null;
					tmp200_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp200_AST);
					match(LITERAL_substr);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(COMMA);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					{
					switch ( LA(1)) {
					case COMMA:
					{
						match(COMMA);
						abstract_value();
						astFactory.addASTChild(currentAST, returnAST);
						break;
					}
					case CLOSE_PAREN:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_coalesce:
				{
					AST tmp205_AST = null;
					tmp205_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp205_AST);
					match(LITERAL_coalesce);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(COMMA);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				case LITERAL_stddev:
				{
					AST tmp209_AST = null;
					tmp209_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp209_AST);
					match(LITERAL_stddev);
					match(OPEN_PAREN);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					safe_function_AST = (AST)currentAST.root;
					safe_function_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SAFE_FUNCTION,"SAFE_FUNCTION")).add(safe_function_AST));
					currentAST.root = safe_function_AST;
					currentAST.child = safe_function_AST!=null &&safe_function_AST.getFirstChild()!=null ?
						safe_function_AST.getFirstChild() : safe_function_AST;
					currentAST.advanceChildToEnd();
				}
				safe_function_AST = (AST)currentAST.root;
				returnAST = safe_function_AST;
				safe_functionCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				safe_functionCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				safe_functionCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap paren_valueCache = new IdentityHashMap();
	public final void paren_value() throws RecognitionException, TokenStreamException {
		Object retval = paren_valueCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST paren_value_AST = null;
				
				match(OPEN_PAREN);
				abstract_value();
				astFactory.addASTChild(currentAST, returnAST);
				match(CLOSE_PAREN);
				paren_value_AST = (AST)currentAST.root;
				returnAST = paren_value_AST;
				paren_valueCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				paren_valueCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				paren_valueCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap tableCache = new IdentityHashMap();
	public final void table() throws RecognitionException, TokenStreamException {
		Object retval = tableCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST table_AST = null;
				
				table_name();
				astFactory.addASTChild(currentAST, returnAST);
				{
				switch ( LA(1)) {
				case IDENTIFIER:
				case LITERAL_as:
				{
					{
					switch ( LA(1)) {
					case LITERAL_as:
					{
						match(LITERAL_as);
						break;
					}
					case IDENTIFIER:
					{
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					table_alias();
					astFactory.addASTChild(currentAST, returnAST);
					break;
				}
				case EOF:
				case SEMI:
				case LITERAL_union:
				case COMMA:
				case LITERAL_where:
				case LITERAL_group:
				case LITERAL_order:
				case LITERAL_limit:
				case CLOSE_PAREN:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				if ( inputState.guessing==0 ) {
					table_AST = (AST)currentAST.root;
					table_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TABLE,"TABLE")).add(table_AST));
					currentAST.root = table_AST;
					currentAST.child = table_AST!=null &&table_AST.getFirstChild()!=null ?
						table_AST.getFirstChild() : table_AST;
					currentAST.advanceChildToEnd();
				}
				table_AST = (AST)currentAST.root;
				returnAST = table_AST;
				tableCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				tableCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				tableCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap subqueryCache = new IdentityHashMap();
	public final void subquery() throws RecognitionException, TokenStreamException {
		Object retval = subqueryCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST subquery_AST = null;
				
				match(OPEN_PAREN);
				sql();
				astFactory.addASTChild(currentAST, returnAST);
				match(CLOSE_PAREN);
				{
				switch ( LA(1)) {
				case LITERAL_as:
				{
					match(LITERAL_as);
					break;
				}
				case IDENTIFIER:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				}
				table_alias();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					subquery_AST = (AST)currentAST.root;
					subquery_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SUBQUERY,"SUBQUERY")).add(subquery_AST));
					currentAST.root = subquery_AST;
					currentAST.child = subquery_AST!=null &&subquery_AST.getFirstChild()!=null ?
						subquery_AST.getFirstChild() : subquery_AST;
					currentAST.advanceChildToEnd();
				}
				subquery_AST = (AST)currentAST.root;
				returnAST = subquery_AST;
				subqueryCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				subqueryCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				subqueryCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap safe_abstract_valueCache = new IdentityHashMap();
	public final void safe_abstract_value() throws RecognitionException, TokenStreamException {
		Object retval = safe_abstract_valueCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST safe_abstract_value_AST = null;
				
				boolean synPredMatched523 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_6.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_44.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6))))) {
					int _m523 = mark();
					synPredMatched523 = true;
					inputState.guessing++;
					try {
						{
						typecast();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched523 = false;
					}
					rewind(_m523);
inputState.guessing--;
				}
				if ( synPredMatched523 ) {
					typecast();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_value_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_14.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
					constant();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_value_AST = (AST)currentAST.root;
				}
				else if ((LA(1)==IDENTIFIER) && (_tokenSet_53.member(LA(2))) && (_tokenSet_54.member(LA(3))) && (_tokenSet_55.member(LA(4))) && (_tokenSet_13.member(LA(5))) && (_tokenSet_13.member(LA(6)))) {
					field();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_value_AST = (AST)currentAST.root;
				}
				else if (((LA(1) >= LITERAL_count && LA(1) <= LITERAL_stddev)) && (LA(2)==OPEN_PAREN) && (_tokenSet_15.member(LA(3))) && (_tokenSet_16.member(LA(4))) && (_tokenSet_56.member(LA(5))) && (_tokenSet_45.member(LA(6)))) {
					safe_function();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_value_AST = (AST)currentAST.root;
				}
				else if ((LA(1)==OPEN_PAREN) && (_tokenSet_0.member(LA(2))) && (_tokenSet_18.member(LA(3))) && (_tokenSet_56.member(LA(4))) && (_tokenSet_45.member(LA(5))) && (_tokenSet_13.member(LA(6)))) {
					paren_value();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_value_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = safe_abstract_value_AST;
				safe_abstract_valueCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				safe_abstract_valueCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				safe_abstract_valueCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap table_aliasCache = new IdentityHashMap();
	public final void table_alias() throws RecognitionException, TokenStreamException {
		Object retval = table_aliasCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST table_alias_AST = null;
				
				AST tmp218_AST = null;
				tmp218_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp218_AST);
				match(IDENTIFIER);
				if ( inputState.guessing==0 ) {
					table_alias_AST = (AST)currentAST.root;
					table_alias_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TABLE_ALIAS,"TABLE_ALIAS")).add(table_alias_AST));
					currentAST.root = table_alias_AST;
					currentAST.child = table_alias_AST!=null &&table_alias_AST.getFirstChild()!=null ?
						table_alias_AST.getFirstChild() : table_alias_AST;
					currentAST.advanceChildToEnd();
				}
				table_alias_AST = (AST)currentAST.root;
				returnAST = table_alias_AST;
				table_aliasCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				table_aliasCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				table_aliasCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap table_nameCache = new IdentityHashMap();
	public final void table_name() throws RecognitionException, TokenStreamException {
		Object retval = table_nameCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST table_name_AST = null;
				
				AST tmp219_AST = null;
				tmp219_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp219_AST);
				match(IDENTIFIER);
				if ( inputState.guessing==0 ) {
					table_name_AST = (AST)currentAST.root;
					table_name_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TABLE_NAME,"TABLE_NAME")).add(table_name_AST));
					currentAST.root = table_name_AST;
					currentAST.child = table_name_AST!=null &&table_name_AST.getFirstChild()!=null ?
						table_name_AST.getFirstChild() : table_name_AST;
					currentAST.advanceChildToEnd();
				}
				table_name_AST = (AST)currentAST.root;
				returnAST = table_name_AST;
				table_nameCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				table_nameCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				table_nameCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap field_nameCache = new IdentityHashMap();
	public final void field_name() throws RecognitionException, TokenStreamException {
		Object retval = field_nameCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST field_name_AST = null;
				
				AST tmp220_AST = null;
				tmp220_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp220_AST);
				match(IDENTIFIER);
				if ( inputState.guessing==0 ) {
					field_name_AST = (AST)currentAST.root;
					field_name_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_NAME,"FIELD_NAME")).add(field_name_AST));
					currentAST.root = field_name_AST;
					currentAST.child = field_name_AST!=null &&field_name_AST.getFirstChild()!=null ?
						field_name_AST.getFirstChild() : field_name_AST;
					currentAST.advanceChildToEnd();
				}
				field_name_AST = (AST)currentAST.root;
				returnAST = field_name_AST;
				field_nameCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				field_nameCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				field_nameCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap gornull_constraintCache = new IdentityHashMap();
	public final void gornull_constraint() throws RecognitionException, TokenStreamException {
		Object retval = gornull_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST gornull_constraint_AST = null;
				Token  a = null;
				AST a_AST = null;
				Token  b = null;
				AST b_AST = null;
				AST c_AST = null;
				Token  d = null;
				AST d_AST = null;
				Token  e = null;
				AST e_AST = null;
				
				a = LT(1);
				a_AST = astFactory.create(a);
				astFactory.addASTChild(currentAST, a_AST);
				match(IDENTIFIER);
				match(DOT);
				b = LT(1);
				b_AST = astFactory.create(b);
				astFactory.addASTChild(currentAST, b_AST);
				match(IDENTIFIER);
				match(GT);
				constant();
				c_AST = (AST)returnAST;
				astFactory.addASTChild(currentAST, returnAST);
				match(LITERAL_or);
				d = LT(1);
				d_AST = astFactory.create(d);
				astFactory.addASTChild(currentAST, d_AST);
				match(IDENTIFIER);
				match(DOT);
				e = LT(1);
				e_AST = astFactory.create(e);
				astFactory.addASTChild(currentAST, e_AST);
				match(IDENTIFIER);
				match(LITERAL_is);
				match(LITERAL_null);
				if (!( a_AST.getText().equals(d_AST.getText()) && b_AST.getText().equals(e_AST.getText()) ))
				  throw new SemanticException(" a_AST.getText().equals(d_AST.getText()) && b_AST.getText().equals(e_AST.getText()) ");
				if ( inputState.guessing==0 ) {
					gornull_constraint_AST = (AST)currentAST.root;
					gornull_constraint_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(CONSTRAINT,"CONSTRAINT")).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(FIELD,"FIELD")).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TABLE_ALIAS,"TABLE_ALIAS")).add(a_AST))).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_NAME,"FIELD_NAME")).add(b_AST))))).add((AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(GORNULL,"n>")))).add(c_AST));
					currentAST.root = gornull_constraint_AST;
					currentAST.child = gornull_constraint_AST!=null &&gornull_constraint_AST.getFirstChild()!=null ?
						gornull_constraint_AST.getFirstChild() : gornull_constraint_AST;
					currentAST.advanceChildToEnd();
				}
				gornull_constraint_AST = (AST)currentAST.root;
				returnAST = gornull_constraint_AST;
				gornull_constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				gornull_constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				gornull_constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap constraint_setCache = new IdentityHashMap();
	public final void constraint_set() throws RecognitionException, TokenStreamException {
		Object retval = constraint_setCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST constraint_set_AST = null;
				
				boolean synPredMatched585 = false;
				if (((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_21.member(LA(3))) && (_tokenSet_57.member(LA(4))) && (_tokenSet_23.member(LA(5))) && (_tokenSet_24.member(LA(6))))) {
					int _m585 = mark();
					synPredMatched585 = true;
					inputState.guessing++;
					try {
						{
						safe_abstract_constraint();
						match(LITERAL_and);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched585 = false;
					}
					rewind(_m585);
inputState.guessing--;
				}
				if ( synPredMatched585 ) {
					and_constraint_set();
					astFactory.addASTChild(currentAST, returnAST);
					constraint_set_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))) && (_tokenSet_21.member(LA(3))) && (_tokenSet_58.member(LA(4))) && (_tokenSet_23.member(LA(5))) && (_tokenSet_24.member(LA(6)))) {
					or_constraint_set();
					astFactory.addASTChild(currentAST, returnAST);
					constraint_set_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = constraint_set_AST;
				constraint_setCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				constraint_setCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				constraint_setCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap safe_abstract_constraintCache = new IdentityHashMap();
	public final void safe_abstract_constraint() throws RecognitionException, TokenStreamException {
		Object retval = safe_abstract_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST safe_abstract_constraint_AST = null;
				
				boolean synPredMatched572 = false;
				if (((LA(1)==OPEN_PAREN) && (_tokenSet_19.member(LA(2))) && (_tokenSet_20.member(LA(3))) && (_tokenSet_21.member(LA(4))) && (_tokenSet_22.member(LA(5))) && (_tokenSet_59.member(LA(6))))) {
					int _m572 = mark();
					synPredMatched572 = true;
					inputState.guessing++;
					try {
						{
						paren_constraint();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched572 = false;
					}
					rewind(_m572);
inputState.guessing--;
				}
				if ( synPredMatched572 ) {
					paren_constraint();
					astFactory.addASTChild(currentAST, returnAST);
					safe_abstract_constraint_AST = (AST)currentAST.root;
				}
				else {
					boolean synPredMatched574 = false;
					if (((_tokenSet_0.member(LA(1))) && (_tokenSet_60.member(LA(2))) && (_tokenSet_61.member(LA(3))) && (_tokenSet_62.member(LA(4))) && (_tokenSet_63.member(LA(5))) && (_tokenSet_64.member(LA(6))))) {
						int _m574 = mark();
						synPredMatched574 = true;
						inputState.guessing++;
						try {
							{
							subquery_constraint();
							}
						}
						catch (RecognitionException pe) {
							synPredMatched574 = false;
						}
						rewind(_m574);
inputState.guessing--;
					}
					if ( synPredMatched574 ) {
						subquery_constraint();
						astFactory.addASTChild(currentAST, returnAST);
						safe_abstract_constraint_AST = (AST)currentAST.root;
					}
					else {
						boolean synPredMatched576 = false;
						if (((_tokenSet_0.member(LA(1))) && (_tokenSet_60.member(LA(2))) && (_tokenSet_61.member(LA(3))) && (_tokenSet_65.member(LA(4))) && (_tokenSet_65.member(LA(5))) && (_tokenSet_66.member(LA(6))))) {
							int _m576 = mark();
							synPredMatched576 = true;
							inputState.guessing++;
							try {
								{
								inlist_constraint();
								}
							}
							catch (RecognitionException pe) {
								synPredMatched576 = false;
							}
							rewind(_m576);
inputState.guessing--;
						}
						if ( synPredMatched576 ) {
							inlist_constraint();
							astFactory.addASTChild(currentAST, returnAST);
							safe_abstract_constraint_AST = (AST)currentAST.root;
						}
						else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_67.member(LA(2))) && (_tokenSet_68.member(LA(3))) && (_tokenSet_69.member(LA(4))) && (_tokenSet_70.member(LA(5))) && (_tokenSet_71.member(LA(6)))) {
							constraint();
							astFactory.addASTChild(currentAST, returnAST);
							safe_abstract_constraint_AST = (AST)currentAST.root;
						}
						else if ((LA(1)==LITERAL_not)) {
							not_constraint();
							astFactory.addASTChild(currentAST, returnAST);
							safe_abstract_constraint_AST = (AST)currentAST.root;
						}
						else {
							throw new NoViableAltException(LT(1), getFilename());
						}
						}}
						returnAST = safe_abstract_constraint_AST;
						safe_abstract_constraintCache.put(LT(1), returnAST);
					} catch (RecognitionException e) {
						safe_abstract_constraintCache.put(LT(1), e);
						throw e;
					} catch (TokenStreamException e) {
						safe_abstract_constraintCache.put(LT(1), e);
						throw e;
					}
				}
			}
			
	IdentityHashMap paren_constraintCache = new IdentityHashMap();
	public final void paren_constraint() throws RecognitionException, TokenStreamException {
		Object retval = paren_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST paren_constraint_AST = null;
				
				match(OPEN_PAREN);
				abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				match(CLOSE_PAREN);
				paren_constraint_AST = (AST)currentAST.root;
				returnAST = paren_constraint_AST;
				paren_constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				paren_constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				paren_constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap subquery_constraintCache = new IdentityHashMap();
	public final void subquery_constraint() throws RecognitionException, TokenStreamException {
		Object retval = subquery_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST subquery_constraint_AST = null;
				
				boolean synPredMatched594 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_72.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_73.member(LA(4))) && (_tokenSet_74.member(LA(5))) && (_tokenSet_75.member(LA(6))))) {
					int _m594 = mark();
					synPredMatched594 = true;
					inputState.guessing++;
					try {
						{
						abstract_value();
						match(LITERAL_in);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched594 = false;
					}
					rewind(_m594);
inputState.guessing--;
				}
				if ( synPredMatched594 ) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_in);
					match(OPEN_PAREN);
					sql();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					if ( inputState.guessing==0 ) {
						subquery_constraint_AST = (AST)currentAST.root;
						subquery_constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SUBQUERY_CONSTRAINT,"SUBQUERY_CONSTRAINT")).add(subquery_constraint_AST));
						currentAST.root = subquery_constraint_AST;
						currentAST.child = subquery_constraint_AST!=null &&subquery_constraint_AST.getFirstChild()!=null ?
							subquery_constraint_AST.getFirstChild() : subquery_constraint_AST;
						currentAST.advanceChildToEnd();
					}
					subquery_constraint_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_76.member(LA(2))) && (_tokenSet_61.member(LA(3))) && (_tokenSet_77.member(LA(4))) && (_tokenSet_62.member(LA(5))) && (_tokenSet_78.member(LA(6)))) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_not);
					match(LITERAL_in);
					match(OPEN_PAREN);
					sql();
					astFactory.addASTChild(currentAST, returnAST);
					match(CLOSE_PAREN);
					if ( inputState.guessing==0 ) {
						subquery_constraint_AST = (AST)currentAST.root;
						subquery_constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(NOT_CONSTRAINT,"NOT_CONSTRAINT")).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SUBQUERY_CONSTRAINT,"SUBQUERY_CONSTRAINT")).add(subquery_constraint_AST))));
						currentAST.root = subquery_constraint_AST;
						currentAST.child = subquery_constraint_AST!=null &&subquery_constraint_AST.getFirstChild()!=null ?
							subquery_constraint_AST.getFirstChild() : subquery_constraint_AST;
						currentAST.advanceChildToEnd();
					}
					subquery_constraint_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = subquery_constraint_AST;
				subquery_constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				subquery_constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				subquery_constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap inlist_constraintCache = new IdentityHashMap();
	public final void inlist_constraint() throws RecognitionException, TokenStreamException {
		Object retval = inlist_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST inlist_constraint_AST = null;
				
				boolean synPredMatched597 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_72.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_79.member(LA(4))) && (_tokenSet_79.member(LA(5))) && (_tokenSet_80.member(LA(6))))) {
					int _m597 = mark();
					synPredMatched597 = true;
					inputState.guessing++;
					try {
						{
						abstract_value();
						match(LITERAL_in);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched597 = false;
					}
					rewind(_m597);
inputState.guessing--;
				}
				if ( synPredMatched597 ) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_in);
					match(OPEN_PAREN);
					constant();
					astFactory.addASTChild(currentAST, returnAST);
					{
					_loop599:
					do {
						if ((LA(1)==COMMA)) {
							match(COMMA);
							constant();
							astFactory.addASTChild(currentAST, returnAST);
						}
						else {
							break _loop599;
						}
						
					} while (true);
					}
					match(CLOSE_PAREN);
					if ( inputState.guessing==0 ) {
						inlist_constraint_AST = (AST)currentAST.root;
						inlist_constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INLIST_CONSTRAINT,"INLIST_CONSTRAINT")).add(inlist_constraint_AST));
						currentAST.root = inlist_constraint_AST;
						currentAST.child = inlist_constraint_AST!=null &&inlist_constraint_AST.getFirstChild()!=null ?
							inlist_constraint_AST.getFirstChild() : inlist_constraint_AST;
						currentAST.advanceChildToEnd();
					}
					inlist_constraint_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_76.member(LA(2))) && (_tokenSet_61.member(LA(3))) && (_tokenSet_77.member(LA(4))) && (_tokenSet_65.member(LA(5))) && (_tokenSet_65.member(LA(6)))) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					match(LITERAL_not);
					match(LITERAL_in);
					match(OPEN_PAREN);
					constant();
					astFactory.addASTChild(currentAST, returnAST);
					{
					_loop601:
					do {
						if ((LA(1)==COMMA)) {
							match(COMMA);
							constant();
							astFactory.addASTChild(currentAST, returnAST);
						}
						else {
							break _loop601;
						}
						
					} while (true);
					}
					match(CLOSE_PAREN);
					if ( inputState.guessing==0 ) {
						inlist_constraint_AST = (AST)currentAST.root;
						inlist_constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(NOT_CONSTRAINT,"NOT_CONSTRAINT")).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INLIST_CONSTRAINT,"INLIST_CONSTRAINT")).add(inlist_constraint_AST))));
						currentAST.root = inlist_constraint_AST;
						currentAST.child = inlist_constraint_AST!=null &&inlist_constraint_AST.getFirstChild()!=null ?
							inlist_constraint_AST.getFirstChild() : inlist_constraint_AST;
						currentAST.advanceChildToEnd();
					}
					inlist_constraint_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = inlist_constraint_AST;
				inlist_constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				inlist_constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				inlist_constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap constraintCache = new IdentityHashMap();
	public final void constraint() throws RecognitionException, TokenStreamException {
		Object retval = constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST constraint_AST = null;
				
				boolean synPredMatched579 = false;
				if (((_tokenSet_0.member(LA(1))) && (_tokenSet_81.member(LA(2))) && (_tokenSet_82.member(LA(3))) && (_tokenSet_83.member(LA(4))) && (_tokenSet_84.member(LA(5))) && (_tokenSet_71.member(LA(6))))) {
					int _m579 = mark();
					synPredMatched579 = true;
					inputState.guessing++;
					try {
						{
						abstract_value();
						comparison_op();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched579 = false;
					}
					rewind(_m579);
inputState.guessing--;
				}
				if ( synPredMatched579 ) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					comparison_op();
					astFactory.addASTChild(currentAST, returnAST);
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					if ( inputState.guessing==0 ) {
						constraint_AST = (AST)currentAST.root;
						constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CONSTRAINT,"CONSTRAINT")).add(constraint_AST));
						currentAST.root = constraint_AST;
						currentAST.child = constraint_AST!=null &&constraint_AST.getFirstChild()!=null ?
							constraint_AST.getFirstChild() : constraint_AST;
						currentAST.advanceChildToEnd();
					}
					constraint_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_85.member(LA(2))) && (_tokenSet_86.member(LA(3))) && (_tokenSet_87.member(LA(4))) && (_tokenSet_88.member(LA(5))) && (_tokenSet_71.member(LA(6)))) {
					abstract_value();
					astFactory.addASTChild(currentAST, returnAST);
					null_comparison();
					astFactory.addASTChild(currentAST, returnAST);
					if ( inputState.guessing==0 ) {
						constraint_AST = (AST)currentAST.root;
						constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(NULL_CONSTRAINT,"NULL_CONSTRAINT")).add(constraint_AST));
						currentAST.root = constraint_AST;
						currentAST.child = constraint_AST!=null &&constraint_AST.getFirstChild()!=null ?
							constraint_AST.getFirstChild() : constraint_AST;
						currentAST.advanceChildToEnd();
					}
					constraint_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = constraint_AST;
				constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap not_constraintCache = new IdentityHashMap();
	public final void not_constraint() throws RecognitionException, TokenStreamException {
		Object retval = not_constraintCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST not_constraint_AST = null;
				
				match(LITERAL_not);
				safe_abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				if ( inputState.guessing==0 ) {
					not_constraint_AST = (AST)currentAST.root;
					not_constraint_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(NOT_CONSTRAINT,"NOT_CONSTRAINT")).add(not_constraint_AST));
					currentAST.root = not_constraint_AST;
					currentAST.child = not_constraint_AST!=null &¬_constraint_AST.getFirstChild()!=null ?
						not_constraint_AST.getFirstChild() : not_constraint_AST;
					currentAST.advanceChildToEnd();
				}
				not_constraint_AST = (AST)currentAST.root;
				returnAST = not_constraint_AST;
				not_constraintCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				not_constraintCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				not_constraintCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap comparison_opCache = new IdentityHashMap();
	public final void comparison_op() throws RecognitionException, TokenStreamException {
		Object retval = comparison_opCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST comparison_op_AST = null;
				
				switch ( LA(1)) {
				case EQ:
				{
					AST tmp246_AST = null;
					tmp246_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp246_AST);
					match(EQ);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case LT:
				{
					AST tmp247_AST = null;
					tmp247_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp247_AST);
					match(LT);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case GT:
				{
					AST tmp248_AST = null;
					tmp248_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp248_AST);
					match(GT);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case NOT_EQ:
				{
					AST tmp249_AST = null;
					tmp249_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp249_AST);
					match(NOT_EQ);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case LE:
				{
					AST tmp250_AST = null;
					tmp250_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp250_AST);
					match(LE);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case GE:
				{
					AST tmp251_AST = null;
					tmp251_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp251_AST);
					match(GE);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case GORNULL:
				{
					AST tmp252_AST = null;
					tmp252_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp252_AST);
					match(GORNULL);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case LITERAL_not:
				{
					AST tmp253_AST = null;
					tmp253_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp253_AST);
					match(LITERAL_not);
					AST tmp254_AST = null;
					tmp254_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp254_AST);
					match(LITERAL_like);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				case LITERAL_like:
				{
					AST tmp255_AST = null;
					tmp255_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp255_AST);
					match(LITERAL_like);
					comparison_op_AST = (AST)currentAST.root;
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				}
				returnAST = comparison_op_AST;
				comparison_opCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				comparison_opCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				comparison_opCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap null_comparisonCache = new IdentityHashMap();
	public final void null_comparison() throws RecognitionException, TokenStreamException {
		Object retval = null_comparisonCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST null_comparison_AST = null;
				
				if ((LA(1)==LITERAL_is) && (LA(2)==LITERAL_null)) {
					match(LITERAL_is);
					match(LITERAL_null);
					null_comparison_AST = (AST)currentAST.root;
				}
				else if ((LA(1)==LITERAL_is) && (LA(2)==LITERAL_not)) {
					match(LITERAL_is);
					AST tmp259_AST = null;
					tmp259_AST = astFactory.create(LT(1));
					astFactory.addASTChild(currentAST, tmp259_AST);
					match(LITERAL_not);
					match(LITERAL_null);
					null_comparison_AST = (AST)currentAST.root;
				}
				else {
					throw new NoViableAltException(LT(1), getFilename());
				}
				
				returnAST = null_comparison_AST;
				null_comparisonCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				null_comparisonCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				null_comparisonCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap and_constraint_setCache = new IdentityHashMap();
	public final void and_constraint_set() throws RecognitionException, TokenStreamException {
		Object retval = and_constraint_setCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST and_constraint_set_AST = null;
				
				safe_abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				{
				int _cnt591=0;
				_loop591:
				do {
					if ((LA(1)==LITERAL_and)) {
						match(LITERAL_and);
						safe_abstract_constraint();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						if ( _cnt591>=1 ) { break _loop591; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt591++;
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					and_constraint_set_AST = (AST)currentAST.root;
					and_constraint_set_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(AND_CONSTRAINT_SET,"AND_CONSTRAINT_SET")).add(and_constraint_set_AST));
					currentAST.root = and_constraint_set_AST;
					currentAST.child = and_constraint_set_AST!=null &&and_constraint_set_AST.getFirstChild()!=null ?
						and_constraint_set_AST.getFirstChild() : and_constraint_set_AST;
					currentAST.advanceChildToEnd();
				}
				and_constraint_set_AST = (AST)currentAST.root;
				returnAST = and_constraint_set_AST;
				and_constraint_setCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				and_constraint_setCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				and_constraint_setCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	IdentityHashMap or_constraint_setCache = new IdentityHashMap();
	public final void or_constraint_set() throws RecognitionException, TokenStreamException {
		Object retval = or_constraint_setCache.get(LT(1));
		if (retval instanceof RecognitionException) {
			throw (RecognitionException) retval;
		} else if (retval instanceof TokenStreamException) {
			throw (TokenStreamException) retval;
		} else if ((retval instanceof AST) && (inputState.guessing != 0)) {
			returnAST = (AST) retval;
		} else {
			try {
				
				returnAST = null;
				ASTPair currentAST = new ASTPair();
				AST or_constraint_set_AST = null;
				
				safe_abstract_constraint();
				astFactory.addASTChild(currentAST, returnAST);
				{
				int _cnt588=0;
				_loop588:
				do {
					if ((LA(1)==LITERAL_or)) {
						match(LITERAL_or);
						safe_abstract_constraint();
						astFactory.addASTChild(currentAST, returnAST);
					}
					else {
						if ( _cnt588>=1 ) { break _loop588; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt588++;
				} while (true);
				}
				if ( inputState.guessing==0 ) {
					or_constraint_set_AST = (AST)currentAST.root;
					or_constraint_set_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OR_CONSTRAINT_SET,"OR_CONSTRAINT_SET")).add(or_constraint_set_AST));
					currentAST.root = or_constraint_set_AST;
					currentAST.child = or_constraint_set_AST!=null &&or_constraint_set_AST.getFirstChild()!=null ?
						or_constraint_set_AST.getFirstChild() : or_constraint_set_AST;
					currentAST.advanceChildToEnd();
				}
				or_constraint_set_AST = (AST)currentAST.root;
				returnAST = or_constraint_set_AST;
				or_constraint_setCache.put(LT(1), returnAST);
			} catch (RecognitionException e) {
				or_constraint_setCache.put(LT(1), e);
				throw e;
			} catch (TokenStreamException e) {
				or_constraint_setCache.put(LT(1), e);
				throw e;
			}
		}
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"SQL_STATEMENT",
		"SELECT_LIST",
		"FROM_LIST",
		"WHERE_CLAUSE",
		"GROUP_CLAUSE",
		"HAVING_CLAUSE",
		"ORDER_CLAUSE",
		"LIMIT_CLAUSE",
		"SELECT_VALUE",
		"TABLE_ALIAS",
		"FIELD_ALIAS",
		"TABLE",
		"TABLE_NAME",
		"SUBQUERY",
		"CONSTANT",
		"FIELD",
		"FIELD_NAME",
		"SAFE_FUNCTION",
		"UNSAFE_FUNCTION",
		"CONSTRAINT",
		"NULL_CONSTRAINT",
		"NOT_CONSTRAINT",
		"AND_CONSTRAINT_SET",
		"OR_CONSTRAINT_SET",
		"SUBQUERY_CONSTRAINT",
		"INLIST_CONSTRAINT",
		"ORDER_DESC",
		"\"explain\"",
		"\"distinct\"",
		"INTEGER",
		"ALIAS",
		"IDENTIFIER",
		"QUOTED_STRING",
		"ESCAPED_STRING",
		"FLOAT",
		"\"true\"",
		"\"false\"",
		"\"null\"",
		"TYPECAST",
		"\"boolean\"",
		"\"real\"",
		"\"double\"",
		"\"smallint\"",
		"\"integer\"",
		"\"bigint\"",
		"\"numeric\"",
		"\"text\"",
		"\"count\"",
		"\"max\"",
		"\"min\"",
		"\"sum\"",
		"\"avg\"",
		"\"lower\"",
		"\"upper\"",
		"\"greatest\"",
		"\"least\"",
		"\"strpos\"",
		"\"substr\"",
		"\"coalesce\"",
		"\"stddev\"",
		"PLUS",
		"PERCENT",
		"ASTERISK",
		"DIVIDE",
		"POWER",
		"MINUS",
		"NOT_EQ",
		"GE",
		"LE",
		"GT",
		"\"not\"",
		"\"like\"",
		"EQ",
		"LT",
		"GORNULL",
		"SEMI",
		"\"union\"",
		"\"select\"",
		"\"all\"",
		"COMMA",
		"\"from\"",
		"\"where\"",
		"\"group\"",
		"\"by\"",
		"\"having\"",
		"\"order\"",
		"\"limit\"",
		"\"offset\"",
		"\"as\"",
		"\"desc\"",
		"OPEN_PAREN",
		"CLOSE_PAREN",
		"DOT",
		"COLONTYPE",
		"\"precision\"",
		"\"or\"",
		"\"is\"",
		"\"and\"",
		"\"in\"",
		"AT_SIGN",
		"OVERLAP",
		"INSIDE",
		"SURROUND",
		"VERTBAR",
		"WS"
	};
	
	protected void buildTokenTypeASTClassMap() {
		tokenTypeToASTClassMap=null;
	};
	
	private static final long[] mk_tokenSet_0() {
		long[] data = { -2247427536977920L, 1073741824L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	private static final long[] mk_tokenSet_1() {
		long[] data = { -2247427536977920L, 13958643775L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
	private static final long[] mk_tokenSet_2() {
		long[] data = { -4423816314880L, 16106127423L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
	private static final long[] mk_tokenSet_3() {
		long[] data = { -4423816314880L, 33554956351L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
	private static final long[] mk_tokenSet_4() {
		long[] data = { -4406636445696L, 33286520895L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
	private static final long[] mk_tokenSet_5() {
		long[] data = { -4423816314878L, 33556103231L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
	private static final long[] mk_tokenSet_6() {
		long[] data = { -2247427536977920L, 13958643712L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
	private static final long[] mk_tokenSet_7() {
		long[] data = { -4406636445696L, 33554956351L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
	private static final long[] mk_tokenSet_8() {
		long[] data = { -4406636445694L, 33556103231L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
	private static final long[] mk_tokenSet_9() {
		long[] data = { 2L, 6712557568L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
	private static final long[] mk_tokenSet_10() {
		long[] data = { -2247408209625086L, 175393439744L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
	private static final long[] mk_tokenSet_11() {
		long[] data = { -2247421094526974L, 188290663487L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
	private static final long[] mk_tokenSet_12() {
		long[] data = { -4400193994750L, 532022296575L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
	private static final long[] mk_tokenSet_13() {
		long[] data = { -4400193994750L, 549755813887L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
	private static final long[] mk_tokenSet_14() {
		long[] data = { 4337916968960L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
	private static final long[] mk_tokenSet_15() {
		long[] data = { -2247427536977920L, 1073741828L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
	private static final long[] mk_tokenSet_16() {
		long[] data = { -2247427536977920L, 16106651711L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
	private static final long[] mk_tokenSet_17() {
		long[] data = { -4423816314880L, 16374562879L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
	private static final long[] mk_tokenSet_18() {
		long[] data = { -2247427536977920L, 16106127423L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
	private static final long[] mk_tokenSet_19() {
		long[] data = { -2247427536977920L, 1073742848L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
	private static final long[] mk_tokenSet_20() {
		long[] data = { -2247427536977920L, 357556060159L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
	private static final long[] mk_tokenSet_21() {
		long[] data = { -4423816314880L, 359703543807L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
	private static final long[] mk_tokenSet_22() {
		long[] data = { -4421668831232L, 548682760191L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
	private static final long[] mk_tokenSet_23() {
		long[] data = { -4417373863936L, 548683022335L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
	private static final long[] mk_tokenSet_24() {
		long[] data = { -4417373863936L, 548952571903L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
	private static final long[] mk_tokenSet_25() {
		long[] data = { -4421668831230L, 376989024255L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
	private static final long[] mk_tokenSet_26() {
		long[] data = { -4417373863934L, 549064802303L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
	private static final long[] mk_tokenSet_27() {
		long[] data = { -4417373863934L, 549202165759L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
	private static final long[] mk_tokenSet_28() {
		long[] data = { -4423816314878L, 549341233151L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
	private static final long[] mk_tokenSet_29() {
		long[] data = { -4421668831230L, 549618188287L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
	private static final long[] mk_tokenSet_30() {
		long[] data = { -4400193994750L, 549754765311L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
	private static final long[] mk_tokenSet_31() {
		long[] data = { 2L, 518202720192L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
	private static final long[] mk_tokenSet_32() {
		long[] data = { 2L, 522497687488L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
	private static final long[] mk_tokenSet_33() {
		long[] data = { -2247425389494270L, 528143351807L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
	private static final long[] mk_tokenSet_34() {
		long[] data = { -4400193994750L, 532574896127L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
	private static final long[] mk_tokenSet_35() {
		long[] data = { -4423816314878L, 532161363967L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
	private static final long[] mk_tokenSet_36() {
		long[] data = { -2247427536977920L, 14495514687L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
	private static final long[] mk_tokenSet_37() {
		long[] data = { -4423816314878L, 16173858879L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
	private static final long[] mk_tokenSet_38() {
		long[] data = { -4421668831230L, 205995606079L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
	private static final long[] mk_tokenSet_39() {
		long[] data = { -4417373863934L, 206140572735L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
	private static final long[] mk_tokenSet_40() {
		long[] data = { -4417373863934L, 549739036671L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
	private static final long[] mk_tokenSet_41() {
		long[] data = { -2247427536977918L, 16173858879L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
	private static final long[] mk_tokenSet_42() {
		long[] data = { -4421668831230L, 188278341695L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
	private static final long[] mk_tokenSet_43() {
		long[] data = { -2247427536977920L, 13958643713L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
	private static final long[] mk_tokenSet_44() {
		long[] data = { -4423816314878L, 549609668607L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
	private static final long[] mk_tokenSet_45() {
		long[] data = { -4404488962046L, 549618188287L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
	private static final long[] mk_tokenSet_46() {
		long[] data = { -2247427536977920L, 13958643714L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
	private static final long[] mk_tokenSet_47() {
		long[] data = { -2247427536977920L, 13958643716L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
	private static final long[] mk_tokenSet_48() {
		long[] data = { -2247427536977920L, 13958643720L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
	private static final long[] mk_tokenSet_49() {
		long[] data = { -2247427536977920L, 13958643728L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
	private static final long[] mk_tokenSet_50() {
		long[] data = { -2247427536977920L, 13958643744L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
	private static final long[] mk_tokenSet_51() {
		long[] data = { 2L, 527062138879L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
	private static final long[] mk_tokenSet_52() {
		long[] data = { 2L, 518471155711L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
	private static final long[] mk_tokenSet_53() {
		long[] data = { 2L, 522766123007L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
	private static final long[] mk_tokenSet_54() {
		long[] data = { -2247408209625086L, 528143351807L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
	private static final long[] mk_tokenSet_55() {
		long[] data = { -4400193994750L, 532575944703L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
	private static final long[] mk_tokenSet_56() {
		long[] data = { -4423816314878L, 532429799423L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
	private static final long[] mk_tokenSet_57() {
		long[] data = { -4421668831232L, 514323021823L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
	private static final long[] mk_tokenSet_58() {
		long[] data = { -4421668831232L, 411243806719L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
	private static final long[] mk_tokenSet_59() {
		long[] data = { -4417373863934L, 548787978239L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
	private static final long[] mk_tokenSet_60() {
		long[] data = { -2247427536977920L, 288836551743L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
	private static final long[] mk_tokenSet_61() {
		long[] data = { -4423816314880L, 290984034367L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
	private static final long[] mk_tokenSet_62() {
		long[] data = { -4421668831232L, 308164559935L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
	private static final long[] mk_tokenSet_63() {
		long[] data = { -4417373863936L, 308164822079L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
	private static final long[] mk_tokenSet_64() {
		long[] data = { -4417373863936L, 308434371647L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
	private static final long[] mk_tokenSet_65() {
		long[] data = { -4423816314880L, 308164428863L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
	private static final long[] mk_tokenSet_66() {
		long[] data = { -4423816314878L, 480068076607L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
	private static final long[] mk_tokenSet_67() {
		long[] data = { -2247427536977920L, 82678153215L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
	private static final long[] mk_tokenSet_68() {
		long[] data = { -4423816314880L, 16106130495L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
	private static final long[] mk_tokenSet_69() {
		long[] data = { -4423816314878L, 273909678079L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
	private static final long[] mk_tokenSet_70() {
		long[] data = { -4421668831230L, 274186633215L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
	private static final long[] mk_tokenSet_71() {
		long[] data = { -4417373863934L, 549201117183L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
	private static final long[] mk_tokenSet_72() {
		long[] data = { -2247427536977920L, 288836550719L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
	private static final long[] mk_tokenSet_73() {
		long[] data = { -4421668831232L, 308164558911L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
	private static final long[] mk_tokenSet_74() {
		long[] data = { -4419521347584L, 308164821055L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
	private static final long[] mk_tokenSet_75() {
		long[] data = { -4417373863936L, 308434370623L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
	private static final long[] mk_tokenSet_76() {
		long[] data = { -2247427536977920L, 13958644799L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
	private static final long[] mk_tokenSet_77() {
		long[] data = { -4423816314880L, 33286521919L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
	private static final long[] mk_tokenSet_78() {
		long[] data = { -4419521347584L, 308164822079L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
	private static final long[] mk_tokenSet_79() {
		long[] data = { -4423816314880L, 308164427839L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
	private static final long[] mk_tokenSet_80() {
		long[] data = { -4423816314878L, 480068075583L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80());
	private static final long[] mk_tokenSet_81() {
		long[] data = { -2247427536977920L, 13958676479L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81());
	private static final long[] mk_tokenSet_82() {
		long[] data = { -4423816314880L, 16106129471L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82());
	private static final long[] mk_tokenSet_83() {
		long[] data = { -4423816314878L, 205190201343L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83());
	private static final long[] mk_tokenSet_84() {
		long[] data = { -4421668831230L, 205467156479L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84());
	private static final long[] mk_tokenSet_85() {
		long[] data = { -2247427536977920L, 82678120511L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85());
	private static final long[] mk_tokenSet_86() {
		long[] data = { -4423816314880L, 16106128447L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86());
	private static final long[] mk_tokenSet_87() {
		long[] data = { -4423816314878L, 273909645375L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87());
	private static final long[] mk_tokenSet_88() {
		long[] data = { -4421668831230L, 274186601535L, 0L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88());
	
	}