• Home
• com.datastax.oss
• dsbulk-cql
• 1.11.0
• source code
• CqlParser.java

×

Project download

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

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

com.datastax.oss.dsbulk.generated.cql3.CqlParser Maven / Gradle / Ivy

// Generated from com/datastax/oss/dsbulk/generated/cql3/Cql.g4 by ANTLR 4.9.3
package com.datastax.oss.dsbulk.generated.cql3;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class CqlParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, K_SELECT=22, K_FROM=23, K_AS=24, 
		K_WHERE=25, K_AND=26, K_KEY=27, K_INSERT=28, K_UPDATE=29, K_LIMIT=30, 
		K_PER=31, K_PARTITION=32, K_USING=33, K_DISTINCT=34, K_COUNT=35, K_SET=36, 
		K_BEGIN=37, K_UNLOGGED=38, K_BATCH=39, K_APPLY=40, K_DELETE=41, K_IN=42, 
		K_INTO=43, K_VALUES=44, K_TIMESTAMP=45, K_TTL=46, K_CAST=47, K_TYPE=48, 
		K_ORDER=49, K_BY=50, K_ASC=51, K_DESC=52, K_ALLOW=53, K_FILTERING=54, 
		K_IF=55, K_IS=56, K_CONTAINS=57, K_GROUP=58, K_CLUSTERING=59, K_ASCII=60, 
		K_BIGINT=61, K_BLOB=62, K_BOOLEAN=63, K_COUNTER=64, K_DECIMAL=65, K_DOUBLE=66, 
		K_DURATION=67, K_FLOAT=68, K_INET=69, K_INT=70, K_SMALLINT=71, K_TINYINT=72, 
		K_TEXT=73, K_UUID=74, K_VARCHAR=75, K_VARINT=76, K_TIMEUUID=77, K_TOKEN=78, 
		K_WRITETIME=79, K_DATE=80, K_TIME=81, K_VECTOR=82, K_NULL=83, K_NOT=84, 
		K_EXISTS=85, K_MAP=86, K_LIST=87, K_NAN=88, K_INFINITY=89, K_TUPLE=90, 
		K_FROZEN=91, K_JSON=92, K_DEFAULT=93, K_UNSET=94, K_LIKE=95, K_ANN_OF=96, 
		STRING_LITERAL=97, QUOTED_NAME=98, EMPTY_QUOTED_NAME=99, INTEGER=100, 
		QMARK=101, FLOAT=102, BOOLEAN=103, DURATION=104, IDENT=105, HEXNUMBER=106, 
		UUID=107, WS=108, COMMENT=109, MULTILINE_COMMENT=110, EOS=111;
	public static final int
		RULE_cqlStatement = 0, RULE_selectStatement = 1, RULE_selectClause = 2, 
		RULE_selector = 3, RULE_unaliasedSelector = 4, RULE_selectionFunctionArgs = 5, 
		RULE_whereClause = 6, RULE_relationOrExpression = 7, RULE_customIndexExpression = 8, 
		RULE_orderByClause = 9, RULE_groupByClause = 10, RULE_perPartitionLimitClause = 11, 
		RULE_limitClause = 12, RULE_insertStatement = 13, RULE_normalInsertStatement = 14, 
		RULE_jsonInsertStatement = 15, RULE_jsonValue = 16, RULE_usingClause = 17, 
		RULE_usingClauseObjective = 18, RULE_updateStatement = 19, RULE_updateConditions = 20, 
		RULE_deleteStatement = 21, RULE_deleteSelection = 22, RULE_deleteOp = 23, 
		RULE_usingClauseDelete = 24, RULE_batchStatement = 25, RULE_batchStatementObjective = 26, 
		RULE_cident = 27, RULE_fident = 28, RULE_noncolIdent = 29, RULE_keyspaceName = 30, 
		RULE_columnFamilyName = 31, RULE_userTypeName = 32, RULE_ksName = 33, 
		RULE_cfName = 34, RULE_idxName = 35, RULE_constant = 36, RULE_setOrMapLiteral = 37, 
		RULE_collectionLiteral = 38, RULE_usertypeLiteral = 39, RULE_tupleLiteral = 40, 
		RULE_value = 41, RULE_intValue = 42, RULE_functionName = 43, RULE_allowedFunctionName = 44, 
		RULE_function = 45, RULE_functionArgs = 46, RULE_term = 47, RULE_columnOperation = 48, 
		RULE_columnOperationDifferentiator = 49, RULE_normalColumnOperation = 50, 
		RULE_shorthandColumnOperation = 51, RULE_collectionColumnOperation = 52, 
		RULE_udtColumnOperation = 53, RULE_columnCondition = 54, RULE_relationType = 55, 
		RULE_relation = 56, RULE_inMarker = 57, RULE_tupleOfIdentifiers = 58, 
		RULE_singleColumnInValues = 59, RULE_tupleOfTupleLiterals = 60, RULE_markerForTuple = 61, 
		RULE_tupleOfMarkersForTuples = 62, RULE_inMarkerForTuple = 63, RULE_comparatorType = 64, 
		RULE_nativeType = 65, RULE_collectionType = 66, RULE_tupleType = 67, RULE_nonTypeIdent = 68, 
		RULE_unreservedKeyword = 69, RULE_unreservedFunctionKeyword = 70, RULE_basicUnreservedKeyword = 71;
	private static String[] makeRuleNames() {
		return new String[] {
			"cqlStatement", "selectStatement", "selectClause", "selector", "unaliasedSelector", 
			"selectionFunctionArgs", "whereClause", "relationOrExpression", "customIndexExpression", 
			"orderByClause", "groupByClause", "perPartitionLimitClause", "limitClause", 
			"insertStatement", "normalInsertStatement", "jsonInsertStatement", "jsonValue", 
			"usingClause", "usingClauseObjective", "updateStatement", "updateConditions", 
			"deleteStatement", "deleteSelection", "deleteOp", "usingClauseDelete", 
			"batchStatement", "batchStatementObjective", "cident", "fident", "noncolIdent", 
			"keyspaceName", "columnFamilyName", "userTypeName", "ksName", "cfName", 
			"idxName", "constant", "setOrMapLiteral", "collectionLiteral", "usertypeLiteral", 
			"tupleLiteral", "value", "intValue", "functionName", "allowedFunctionName", 
			"function", "functionArgs", "term", "columnOperation", "columnOperationDifferentiator", 
			"normalColumnOperation", "shorthandColumnOperation", "collectionColumnOperation", 
			"udtColumnOperation", "columnCondition", "relationType", "relation", 
			"inMarker", "tupleOfIdentifiers", "singleColumnInValues", "tupleOfTupleLiterals", 
			"markerForTuple", "tupleOfMarkersForTuples", "inMarkerForTuple", "comparatorType", 
			"nativeType", "collectionType", "tupleType", "nonTypeIdent", "unreservedKeyword", 
			"unreservedFunctionKeyword", "basicUnreservedKeyword"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "','", "'*'", "'('", "')'", "'.'", "'expr('", "':'", "'['", "']'", 
			"'-'", "'{'", "'}'", "'='", "'+'", "'+='", "'-='", "'<'", "'<='", "'>'", 
			"'>='", "'!='", null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, "'?'", null, 
			null, null, null, null, null, null, null, null, "';'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, null, null, null, null, "K_SELECT", 
			"K_FROM", "K_AS", "K_WHERE", "K_AND", "K_KEY", "K_INSERT", "K_UPDATE", 
			"K_LIMIT", "K_PER", "K_PARTITION", "K_USING", "K_DISTINCT", "K_COUNT", 
			"K_SET", "K_BEGIN", "K_UNLOGGED", "K_BATCH", "K_APPLY", "K_DELETE", "K_IN", 
			"K_INTO", "K_VALUES", "K_TIMESTAMP", "K_TTL", "K_CAST", "K_TYPE", "K_ORDER", 
			"K_BY", "K_ASC", "K_DESC", "K_ALLOW", "K_FILTERING", "K_IF", "K_IS", 
			"K_CONTAINS", "K_GROUP", "K_CLUSTERING", "K_ASCII", "K_BIGINT", "K_BLOB", 
			"K_BOOLEAN", "K_COUNTER", "K_DECIMAL", "K_DOUBLE", "K_DURATION", "K_FLOAT", 
			"K_INET", "K_INT", "K_SMALLINT", "K_TINYINT", "K_TEXT", "K_UUID", "K_VARCHAR", 
			"K_VARINT", "K_TIMEUUID", "K_TOKEN", "K_WRITETIME", "K_DATE", "K_TIME", 
			"K_VECTOR", "K_NULL", "K_NOT", "K_EXISTS", "K_MAP", "K_LIST", "K_NAN", 
			"K_INFINITY", "K_TUPLE", "K_FROZEN", "K_JSON", "K_DEFAULT", "K_UNSET", 
			"K_LIKE", "K_ANN_OF", "STRING_LITERAL", "QUOTED_NAME", "EMPTY_QUOTED_NAME", 
			"INTEGER", "QMARK", "FLOAT", "BOOLEAN", "DURATION", "IDENT", "HEXNUMBER", 
			"UUID", "WS", "COMMENT", "MULTILINE_COMMENT", "EOS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "Cql.g4"; }

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

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

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

	public CqlParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class CqlStatementContext extends ParserRuleContext {
		public SelectStatementContext selectStatement() {
			return getRuleContext(SelectStatementContext.class,0);
		}
		public InsertStatementContext insertStatement() {
			return getRuleContext(InsertStatementContext.class,0);
		}
		public UpdateStatementContext updateStatement() {
			return getRuleContext(UpdateStatementContext.class,0);
		}
		public DeleteStatementContext deleteStatement() {
			return getRuleContext(DeleteStatementContext.class,0);
		}
		public BatchStatementContext batchStatement() {
			return getRuleContext(BatchStatementContext.class,0);
		}
		public CqlStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cqlStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCqlStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCqlStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCqlStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CqlStatementContext cqlStatement() throws RecognitionException {
		CqlStatementContext _localctx = new CqlStatementContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_cqlStatement);
		try {
			setState(149);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_SELECT:
				enterOuterAlt(_localctx, 1);
				{
				setState(144);
				selectStatement();
				}
				break;
			case K_INSERT:
				enterOuterAlt(_localctx, 2);
				{
				setState(145);
				insertStatement();
				}
				break;
			case K_UPDATE:
				enterOuterAlt(_localctx, 3);
				{
				setState(146);
				updateStatement();
				}
				break;
			case K_DELETE:
				enterOuterAlt(_localctx, 4);
				{
				setState(147);
				deleteStatement();
				}
				break;
			case K_BEGIN:
				enterOuterAlt(_localctx, 5);
				{
				setState(148);
				batchStatement();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectStatementContext extends ParserRuleContext {
		public TerminalNode K_SELECT() { return getToken(CqlParser.K_SELECT, 0); }
		public TerminalNode K_FROM() { return getToken(CqlParser.K_FROM, 0); }
		public ColumnFamilyNameContext columnFamilyName() {
			return getRuleContext(ColumnFamilyNameContext.class,0);
		}
		public SelectClauseContext selectClause() {
			return getRuleContext(SelectClauseContext.class,0);
		}
		public TerminalNode K_JSON() { return getToken(CqlParser.K_JSON, 0); }
		public TerminalNode K_WHERE() { return getToken(CqlParser.K_WHERE, 0); }
		public WhereClauseContext whereClause() {
			return getRuleContext(WhereClauseContext.class,0);
		}
		public TerminalNode K_GROUP() { return getToken(CqlParser.K_GROUP, 0); }
		public List K_BY() { return getTokens(CqlParser.K_BY); }
		public TerminalNode K_BY(int i) {
			return getToken(CqlParser.K_BY, i);
		}
		public List groupByClause() {
			return getRuleContexts(GroupByClauseContext.class);
		}
		public GroupByClauseContext groupByClause(int i) {
			return getRuleContext(GroupByClauseContext.class,i);
		}
		public TerminalNode K_ORDER() { return getToken(CqlParser.K_ORDER, 0); }
		public List orderByClause() {
			return getRuleContexts(OrderByClauseContext.class);
		}
		public OrderByClauseContext orderByClause(int i) {
			return getRuleContext(OrderByClauseContext.class,i);
		}
		public PerPartitionLimitClauseContext perPartitionLimitClause() {
			return getRuleContext(PerPartitionLimitClauseContext.class,0);
		}
		public LimitClauseContext limitClause() {
			return getRuleContext(LimitClauseContext.class,0);
		}
		public TerminalNode K_ALLOW() { return getToken(CqlParser.K_ALLOW, 0); }
		public TerminalNode K_FILTERING() { return getToken(CqlParser.K_FILTERING, 0); }
		public TerminalNode K_DISTINCT() { return getToken(CqlParser.K_DISTINCT, 0); }
		public SelectStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSelectStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSelectStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSelectStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectStatementContext selectStatement() throws RecognitionException {
		SelectStatementContext _localctx = new SelectStatementContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_selectStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(151);
			match(K_SELECT);
			setState(153);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				{
				setState(152);
				match(K_JSON);
				}
				break;
			}
			{
			setState(156);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
			case 1:
				{
				setState(155);
				match(K_DISTINCT);
				}
				break;
			}
			setState(158);
			selectClause();
			}
			setState(160);
			match(K_FROM);
			setState(161);
			columnFamilyName();
			setState(164);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_WHERE) {
				{
				setState(162);
				match(K_WHERE);
				setState(163);
				whereClause();
				}
			}

			setState(176);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_GROUP) {
				{
				setState(166);
				match(K_GROUP);
				setState(167);
				match(K_BY);
				setState(168);
				groupByClause();
				setState(173);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(169);
					match(T__0);
					setState(170);
					groupByClause();
					}
					}
					setState(175);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(188);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ORDER) {
				{
				setState(178);
				match(K_ORDER);
				setState(179);
				match(K_BY);
				setState(180);
				orderByClause();
				setState(185);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(181);
					match(T__0);
					setState(182);
					orderByClause();
					}
					}
					setState(187);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(191);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_PER) {
				{
				setState(190);
				perPartitionLimitClause();
				}
			}

			setState(194);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_LIMIT) {
				{
				setState(193);
				limitClause();
				}
			}

			setState(198);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ALLOW) {
				{
				setState(196);
				match(K_ALLOW);
				setState(197);
				match(K_FILTERING);
				}
			}

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

	public static class SelectClauseContext extends ParserRuleContext {
		public List selector() {
			return getRuleContexts(SelectorContext.class);
		}
		public SelectorContext selector(int i) {
			return getRuleContext(SelectorContext.class,i);
		}
		public SelectClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSelectClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSelectClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSelectClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectClauseContext selectClause() throws RecognitionException {
		SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_selectClause);
		int _la;
		try {
			setState(209);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__2:
			case T__6:
			case T__7:
			case T__9:
			case T__10:
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_TOKEN:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_NULL:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_NAN:
			case K_INFINITY:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
			case STRING_LITERAL:
			case QUOTED_NAME:
			case INTEGER:
			case QMARK:
			case FLOAT:
			case BOOLEAN:
			case DURATION:
			case IDENT:
			case HEXNUMBER:
			case UUID:
				enterOuterAlt(_localctx, 1);
				{
				setState(200);
				selector();
				setState(205);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(201);
					match(T__0);
					setState(202);
					selector();
					}
					}
					setState(207);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			case T__1:
				enterOuterAlt(_localctx, 2);
				{
				setState(208);
				match(T__1);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectorContext extends ParserRuleContext {
		public UnaliasedSelectorContext unaliasedSelector() {
			return getRuleContext(UnaliasedSelectorContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(CqlParser.K_AS, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public SelectorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selector; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSelector(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSelector(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSelector(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectorContext selector() throws RecognitionException {
		SelectorContext _localctx = new SelectorContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_selector);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(211);
			unaliasedSelector();
			setState(214);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_AS) {
				{
				setState(212);
				match(K_AS);
				setState(213);
				noncolIdent();
				}
			}

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

	public static class UnaliasedSelectorContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public ComparatorTypeContext comparatorType() {
			return getRuleContext(ComparatorTypeContext.class,0);
		}
		public TerminalNode K_COUNT() { return getToken(CqlParser.K_COUNT, 0); }
		public TerminalNode K_WRITETIME() { return getToken(CqlParser.K_WRITETIME, 0); }
		public TerminalNode K_TTL() { return getToken(CqlParser.K_TTL, 0); }
		public TerminalNode K_CAST() { return getToken(CqlParser.K_CAST, 0); }
		public UnaliasedSelectorContext unaliasedSelector() {
			return getRuleContext(UnaliasedSelectorContext.class,0);
		}
		public TerminalNode K_AS() { return getToken(CqlParser.K_AS, 0); }
		public NativeTypeContext nativeType() {
			return getRuleContext(NativeTypeContext.class,0);
		}
		public FunctionNameContext functionName() {
			return getRuleContext(FunctionNameContext.class,0);
		}
		public SelectionFunctionArgsContext selectionFunctionArgs() {
			return getRuleContext(SelectionFunctionArgsContext.class,0);
		}
		public List fident() {
			return getRuleContexts(FidentContext.class);
		}
		public FidentContext fident(int i) {
			return getRuleContext(FidentContext.class,i);
		}
		public UnaliasedSelectorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unaliasedSelector; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUnaliasedSelector(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUnaliasedSelector(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUnaliasedSelector(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnaliasedSelectorContext unaliasedSelector() throws RecognitionException {
		UnaliasedSelectorContext _localctx = new UnaliasedSelectorContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_unaliasedSelector);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(247);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(216);
				cident();
				}
				break;
			case 2:
				{
				setState(217);
				value();
				}
				break;
			case 3:
				{
				setState(218);
				match(T__2);
				setState(219);
				comparatorType();
				setState(220);
				match(T__3);
				setState(221);
				value();
				}
				break;
			case 4:
				{
				setState(223);
				match(K_COUNT);
				setState(224);
				match(T__2);
				setState(225);
				match(T__1);
				setState(226);
				match(T__3);
				}
				break;
			case 5:
				{
				setState(227);
				match(K_WRITETIME);
				setState(228);
				match(T__2);
				setState(229);
				cident();
				setState(230);
				match(T__3);
				}
				break;
			case 6:
				{
				setState(232);
				match(K_TTL);
				setState(233);
				match(T__2);
				setState(234);
				cident();
				setState(235);
				match(T__3);
				}
				break;
			case 7:
				{
				setState(237);
				match(K_CAST);
				setState(238);
				match(T__2);
				setState(239);
				unaliasedSelector();
				setState(240);
				match(K_AS);
				setState(241);
				nativeType();
				setState(242);
				match(T__3);
				}
				break;
			case 8:
				{
				setState(244);
				functionName();
				setState(245);
				selectionFunctionArgs();
				}
				break;
			}
			setState(253);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__4) {
				{
				{
				setState(249);
				match(T__4);
				setState(250);
				fident();
				}
				}
				setState(255);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SelectionFunctionArgsContext extends ParserRuleContext {
		public List unaliasedSelector() {
			return getRuleContexts(UnaliasedSelectorContext.class);
		}
		public UnaliasedSelectorContext unaliasedSelector(int i) {
			return getRuleContext(UnaliasedSelectorContext.class,i);
		}
		public SelectionFunctionArgsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_selectionFunctionArgs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSelectionFunctionArgs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSelectionFunctionArgs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSelectionFunctionArgs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SelectionFunctionArgsContext selectionFunctionArgs() throws RecognitionException {
		SelectionFunctionArgsContext _localctx = new SelectionFunctionArgsContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_selectionFunctionArgs);
		int _la;
		try {
			setState(269);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(256);
				match(T__2);
				setState(257);
				match(T__3);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(258);
				match(T__2);
				setState(259);
				unaliasedSelector();
				setState(264);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(260);
					match(T__0);
					setState(261);
					unaliasedSelector();
					}
					}
					setState(266);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(267);
				match(T__3);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WhereClauseContext extends ParserRuleContext {
		public List relationOrExpression() {
			return getRuleContexts(RelationOrExpressionContext.class);
		}
		public RelationOrExpressionContext relationOrExpression(int i) {
			return getRuleContext(RelationOrExpressionContext.class,i);
		}
		public List K_AND() { return getTokens(CqlParser.K_AND); }
		public TerminalNode K_AND(int i) {
			return getToken(CqlParser.K_AND, i);
		}
		public WhereClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_whereClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterWhereClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitWhereClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitWhereClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final WhereClauseContext whereClause() throws RecognitionException {
		WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_whereClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(271);
			relationOrExpression();
			setState(276);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_AND) {
				{
				{
				setState(272);
				match(K_AND);
				setState(273);
				relationOrExpression();
				}
				}
				setState(278);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RelationOrExpressionContext extends ParserRuleContext {
		public RelationContext relation() {
			return getRuleContext(RelationContext.class,0);
		}
		public CustomIndexExpressionContext customIndexExpression() {
			return getRuleContext(CustomIndexExpressionContext.class,0);
		}
		public RelationOrExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationOrExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterRelationOrExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitRelationOrExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitRelationOrExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationOrExpressionContext relationOrExpression() throws RecognitionException {
		RelationOrExpressionContext _localctx = new RelationOrExpressionContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_relationOrExpression);
		try {
			setState(281);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__2:
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_TOKEN:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
			case QUOTED_NAME:
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(279);
				relation();
				}
				break;
			case T__5:
				enterOuterAlt(_localctx, 2);
				{
				setState(280);
				customIndexExpression();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CustomIndexExpressionContext extends ParserRuleContext {
		public IdxNameContext idxName() {
			return getRuleContext(IdxNameContext.class,0);
		}
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public CustomIndexExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_customIndexExpression; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCustomIndexExpression(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCustomIndexExpression(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCustomIndexExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CustomIndexExpressionContext customIndexExpression() throws RecognitionException {
		CustomIndexExpressionContext _localctx = new CustomIndexExpressionContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_customIndexExpression);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(283);
			match(T__5);
			setState(284);
			idxName();
			setState(285);
			match(T__0);
			setState(286);
			term();
			setState(287);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OrderByClauseContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public TerminalNode K_ASC() { return getToken(CqlParser.K_ASC, 0); }
		public TerminalNode K_DESC() { return getToken(CqlParser.K_DESC, 0); }
		public OrderByClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_orderByClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterOrderByClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitOrderByClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitOrderByClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OrderByClauseContext orderByClause() throws RecognitionException {
		OrderByClauseContext _localctx = new OrderByClauseContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_orderByClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(289);
			cident();
			setState(291);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_ASC || _la==K_DESC) {
				{
				setState(290);
				_la = _input.LA(1);
				if ( !(_la==K_ASC || _la==K_DESC) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

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

	public static class GroupByClauseContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public GroupByClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_groupByClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterGroupByClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitGroupByClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitGroupByClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GroupByClauseContext groupByClause() throws RecognitionException {
		GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_groupByClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(293);
			cident();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PerPartitionLimitClauseContext extends ParserRuleContext {
		public TerminalNode K_PER() { return getToken(CqlParser.K_PER, 0); }
		public TerminalNode K_PARTITION() { return getToken(CqlParser.K_PARTITION, 0); }
		public TerminalNode K_LIMIT() { return getToken(CqlParser.K_LIMIT, 0); }
		public IntValueContext intValue() {
			return getRuleContext(IntValueContext.class,0);
		}
		public PerPartitionLimitClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_perPartitionLimitClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterPerPartitionLimitClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitPerPartitionLimitClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitPerPartitionLimitClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PerPartitionLimitClauseContext perPartitionLimitClause() throws RecognitionException {
		PerPartitionLimitClauseContext _localctx = new PerPartitionLimitClauseContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_perPartitionLimitClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(295);
			match(K_PER);
			setState(296);
			match(K_PARTITION);
			setState(297);
			match(K_LIMIT);
			setState(298);
			intValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LimitClauseContext extends ParserRuleContext {
		public TerminalNode K_LIMIT() { return getToken(CqlParser.K_LIMIT, 0); }
		public IntValueContext intValue() {
			return getRuleContext(IntValueContext.class,0);
		}
		public LimitClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_limitClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterLimitClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitLimitClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitLimitClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LimitClauseContext limitClause() throws RecognitionException {
		LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_limitClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(300);
			match(K_LIMIT);
			setState(301);
			intValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InsertStatementContext extends ParserRuleContext {
		public TerminalNode K_INSERT() { return getToken(CqlParser.K_INSERT, 0); }
		public TerminalNode K_INTO() { return getToken(CqlParser.K_INTO, 0); }
		public ColumnFamilyNameContext columnFamilyName() {
			return getRuleContext(ColumnFamilyNameContext.class,0);
		}
		public NormalInsertStatementContext normalInsertStatement() {
			return getRuleContext(NormalInsertStatementContext.class,0);
		}
		public TerminalNode K_JSON() { return getToken(CqlParser.K_JSON, 0); }
		public JsonInsertStatementContext jsonInsertStatement() {
			return getRuleContext(JsonInsertStatementContext.class,0);
		}
		public InsertStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_insertStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterInsertStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitInsertStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitInsertStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InsertStatementContext insertStatement() throws RecognitionException {
		InsertStatementContext _localctx = new InsertStatementContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_insertStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(303);
			match(K_INSERT);
			setState(304);
			match(K_INTO);
			setState(305);
			columnFamilyName();
			setState(309);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__2:
				{
				setState(306);
				normalInsertStatement();
				}
				break;
			case K_JSON:
				{
				setState(307);
				match(K_JSON);
				setState(308);
				jsonInsertStatement();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NormalInsertStatementContext extends ParserRuleContext {
		public List cident() {
			return getRuleContexts(CidentContext.class);
		}
		public CidentContext cident(int i) {
			return getRuleContext(CidentContext.class,i);
		}
		public TerminalNode K_VALUES() { return getToken(CqlParser.K_VALUES, 0); }
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public TerminalNode K_IF() { return getToken(CqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(CqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(CqlParser.K_EXISTS, 0); }
		public UsingClauseContext usingClause() {
			return getRuleContext(UsingClauseContext.class,0);
		}
		public NormalInsertStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_normalInsertStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterNormalInsertStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitNormalInsertStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitNormalInsertStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NormalInsertStatementContext normalInsertStatement() throws RecognitionException {
		NormalInsertStatementContext _localctx = new NormalInsertStatementContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_normalInsertStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(311);
			match(T__2);
			setState(312);
			cident();
			setState(317);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(313);
				match(T__0);
				setState(314);
				cident();
				}
				}
				setState(319);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(320);
			match(T__3);
			setState(321);
			match(K_VALUES);
			setState(322);
			match(T__2);
			setState(323);
			term();
			setState(328);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(324);
				match(T__0);
				setState(325);
				term();
				}
				}
				setState(330);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(331);
			match(T__3);
			setState(335);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(332);
				match(K_IF);
				setState(333);
				match(K_NOT);
				setState(334);
				match(K_EXISTS);
				}
			}

			setState(338);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_USING) {
				{
				setState(337);
				usingClause();
				}
			}

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

	public static class JsonInsertStatementContext extends ParserRuleContext {
		public JsonValueContext jsonValue() {
			return getRuleContext(JsonValueContext.class,0);
		}
		public TerminalNode K_DEFAULT() { return getToken(CqlParser.K_DEFAULT, 0); }
		public TerminalNode K_IF() { return getToken(CqlParser.K_IF, 0); }
		public TerminalNode K_NOT() { return getToken(CqlParser.K_NOT, 0); }
		public TerminalNode K_EXISTS() { return getToken(CqlParser.K_EXISTS, 0); }
		public UsingClauseContext usingClause() {
			return getRuleContext(UsingClauseContext.class,0);
		}
		public TerminalNode K_NULL() { return getToken(CqlParser.K_NULL, 0); }
		public TerminalNode K_UNSET() { return getToken(CqlParser.K_UNSET, 0); }
		public JsonInsertStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_jsonInsertStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterJsonInsertStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitJsonInsertStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitJsonInsertStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JsonInsertStatementContext jsonInsertStatement() throws RecognitionException {
		JsonInsertStatementContext _localctx = new JsonInsertStatementContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_jsonInsertStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(340);
			jsonValue();
			setState(343);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_DEFAULT) {
				{
				setState(341);
				match(K_DEFAULT);
				setState(342);
				_la = _input.LA(1);
				if ( !(_la==K_NULL || _la==K_UNSET) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(348);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(345);
				match(K_IF);
				setState(346);
				match(K_NOT);
				setState(347);
				match(K_EXISTS);
				}
			}

			setState(351);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_USING) {
				{
				setState(350);
				usingClause();
				}
			}

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

	public static class JsonValueContext extends ParserRuleContext {
		public TerminalNode STRING_LITERAL() { return getToken(CqlParser.STRING_LITERAL, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public JsonValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_jsonValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterJsonValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitJsonValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitJsonValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final JsonValueContext jsonValue() throws RecognitionException {
		JsonValueContext _localctx = new JsonValueContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_jsonValue);
		try {
			setState(357);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(353);
				match(STRING_LITERAL);
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 2);
				{
				setState(354);
				match(T__6);
				setState(355);
				noncolIdent();
				}
				break;
			case QMARK:
				enterOuterAlt(_localctx, 3);
				{
				setState(356);
				match(QMARK);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UsingClauseContext extends ParserRuleContext {
		public TerminalNode K_USING() { return getToken(CqlParser.K_USING, 0); }
		public List usingClauseObjective() {
			return getRuleContexts(UsingClauseObjectiveContext.class);
		}
		public UsingClauseObjectiveContext usingClauseObjective(int i) {
			return getRuleContext(UsingClauseObjectiveContext.class,i);
		}
		public List K_AND() { return getTokens(CqlParser.K_AND); }
		public TerminalNode K_AND(int i) {
			return getToken(CqlParser.K_AND, i);
		}
		public UsingClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUsingClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUsingClause(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUsingClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsingClauseContext usingClause() throws RecognitionException {
		UsingClauseContext _localctx = new UsingClauseContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_usingClause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(359);
			match(K_USING);
			setState(360);
			usingClauseObjective();
			setState(365);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_AND) {
				{
				{
				setState(361);
				match(K_AND);
				setState(362);
				usingClauseObjective();
				}
				}
				setState(367);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UsingClauseObjectiveContext extends ParserRuleContext {
		public TerminalNode K_TIMESTAMP() { return getToken(CqlParser.K_TIMESTAMP, 0); }
		public IntValueContext intValue() {
			return getRuleContext(IntValueContext.class,0);
		}
		public TerminalNode K_TTL() { return getToken(CqlParser.K_TTL, 0); }
		public UsingClauseObjectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingClauseObjective; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUsingClauseObjective(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUsingClauseObjective(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUsingClauseObjective(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsingClauseObjectiveContext usingClauseObjective() throws RecognitionException {
		UsingClauseObjectiveContext _localctx = new UsingClauseObjectiveContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_usingClauseObjective);
		try {
			setState(372);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_TIMESTAMP:
				enterOuterAlt(_localctx, 1);
				{
				setState(368);
				match(K_TIMESTAMP);
				setState(369);
				intValue();
				}
				break;
			case K_TTL:
				enterOuterAlt(_localctx, 2);
				{
				setState(370);
				match(K_TTL);
				setState(371);
				intValue();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UpdateStatementContext extends ParserRuleContext {
		public TerminalNode K_UPDATE() { return getToken(CqlParser.K_UPDATE, 0); }
		public ColumnFamilyNameContext columnFamilyName() {
			return getRuleContext(ColumnFamilyNameContext.class,0);
		}
		public TerminalNode K_SET() { return getToken(CqlParser.K_SET, 0); }
		public List columnOperation() {
			return getRuleContexts(ColumnOperationContext.class);
		}
		public ColumnOperationContext columnOperation(int i) {
			return getRuleContext(ColumnOperationContext.class,i);
		}
		public TerminalNode K_WHERE() { return getToken(CqlParser.K_WHERE, 0); }
		public WhereClauseContext whereClause() {
			return getRuleContext(WhereClauseContext.class,0);
		}
		public UsingClauseContext usingClause() {
			return getRuleContext(UsingClauseContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(CqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(CqlParser.K_EXISTS, 0); }
		public UpdateConditionsContext updateConditions() {
			return getRuleContext(UpdateConditionsContext.class,0);
		}
		public UpdateStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_updateStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUpdateStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUpdateStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUpdateStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UpdateStatementContext updateStatement() throws RecognitionException {
		UpdateStatementContext _localctx = new UpdateStatementContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_updateStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(374);
			match(K_UPDATE);
			setState(375);
			columnFamilyName();
			setState(377);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_USING) {
				{
				setState(376);
				usingClause();
				}
			}

			setState(379);
			match(K_SET);
			setState(380);
			columnOperation();
			setState(385);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(381);
				match(T__0);
				setState(382);
				columnOperation();
				}
				}
				setState(387);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(388);
			match(K_WHERE);
			setState(389);
			whereClause();
			setState(395);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(390);
				match(K_IF);
				setState(393);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
				case 1:
					{
					setState(391);
					match(K_EXISTS);
					}
					break;
				case 2:
					{
					setState(392);
					updateConditions();
					}
					break;
				}
				}
			}

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

	public static class UpdateConditionsContext extends ParserRuleContext {
		public List columnCondition() {
			return getRuleContexts(ColumnConditionContext.class);
		}
		public ColumnConditionContext columnCondition(int i) {
			return getRuleContext(ColumnConditionContext.class,i);
		}
		public List K_AND() { return getTokens(CqlParser.K_AND); }
		public TerminalNode K_AND(int i) {
			return getToken(CqlParser.K_AND, i);
		}
		public UpdateConditionsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_updateConditions; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUpdateConditions(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUpdateConditions(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUpdateConditions(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UpdateConditionsContext updateConditions() throws RecognitionException {
		UpdateConditionsContext _localctx = new UpdateConditionsContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_updateConditions);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(397);
			columnCondition();
			setState(402);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==K_AND) {
				{
				{
				setState(398);
				match(K_AND);
				setState(399);
				columnCondition();
				}
				}
				setState(404);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeleteStatementContext extends ParserRuleContext {
		public TerminalNode K_DELETE() { return getToken(CqlParser.K_DELETE, 0); }
		public TerminalNode K_FROM() { return getToken(CqlParser.K_FROM, 0); }
		public ColumnFamilyNameContext columnFamilyName() {
			return getRuleContext(ColumnFamilyNameContext.class,0);
		}
		public TerminalNode K_WHERE() { return getToken(CqlParser.K_WHERE, 0); }
		public WhereClauseContext whereClause() {
			return getRuleContext(WhereClauseContext.class,0);
		}
		public DeleteSelectionContext deleteSelection() {
			return getRuleContext(DeleteSelectionContext.class,0);
		}
		public UsingClauseDeleteContext usingClauseDelete() {
			return getRuleContext(UsingClauseDeleteContext.class,0);
		}
		public TerminalNode K_IF() { return getToken(CqlParser.K_IF, 0); }
		public TerminalNode K_EXISTS() { return getToken(CqlParser.K_EXISTS, 0); }
		public UpdateConditionsContext updateConditions() {
			return getRuleContext(UpdateConditionsContext.class,0);
		}
		public DeleteStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterDeleteStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitDeleteStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitDeleteStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteStatementContext deleteStatement() throws RecognitionException {
		DeleteStatementContext _localctx = new DeleteStatementContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_deleteStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(405);
			match(K_DELETE);
			setState(407);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_AS) | (1L << K_KEY) | (1L << K_PER) | (1L << K_PARTITION) | (1L << K_DISTINCT) | (1L << K_COUNT) | (1L << K_VALUES) | (1L << K_TIMESTAMP) | (1L << K_TTL) | (1L << K_CAST) | (1L << K_TYPE) | (1L << K_FILTERING) | (1L << K_CONTAINS) | (1L << K_GROUP) | (1L << K_CLUSTERING) | (1L << K_ASCII) | (1L << K_BIGINT) | (1L << K_BLOB) | (1L << K_BOOLEAN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_COUNTER - 64)) | (1L << (K_DECIMAL - 64)) | (1L << (K_DOUBLE - 64)) | (1L << (K_DURATION - 64)) | (1L << (K_FLOAT - 64)) | (1L << (K_INET - 64)) | (1L << (K_INT - 64)) | (1L << (K_SMALLINT - 64)) | (1L << (K_TINYINT - 64)) | (1L << (K_TEXT - 64)) | (1L << (K_UUID - 64)) | (1L << (K_VARCHAR - 64)) | (1L << (K_VARINT - 64)) | (1L << (K_TIMEUUID - 64)) | (1L << (K_WRITETIME - 64)) | (1L << (K_DATE - 64)) | (1L << (K_TIME - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_MAP - 64)) | (1L << (K_LIST - 64)) | (1L << (K_TUPLE - 64)) | (1L << (K_FROZEN - 64)) | (1L << (K_JSON - 64)) | (1L << (K_LIKE - 64)) | (1L << (QUOTED_NAME - 64)) | (1L << (IDENT - 64)))) != 0)) {
				{
				setState(406);
				deleteSelection();
				}
			}

			setState(409);
			match(K_FROM);
			setState(410);
			columnFamilyName();
			setState(412);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_USING) {
				{
				setState(411);
				usingClauseDelete();
				}
			}

			setState(414);
			match(K_WHERE);
			setState(415);
			whereClause();
			setState(421);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_IF) {
				{
				setState(416);
				match(K_IF);
				setState(419);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
				case 1:
					{
					setState(417);
					match(K_EXISTS);
					}
					break;
				case 2:
					{
					setState(418);
					updateConditions();
					}
					break;
				}
				}
			}

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

	public static class DeleteSelectionContext extends ParserRuleContext {
		public List deleteOp() {
			return getRuleContexts(DeleteOpContext.class);
		}
		public DeleteOpContext deleteOp(int i) {
			return getRuleContext(DeleteOpContext.class,i);
		}
		public DeleteSelectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteSelection; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterDeleteSelection(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitDeleteSelection(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitDeleteSelection(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteSelectionContext deleteSelection() throws RecognitionException {
		DeleteSelectionContext _localctx = new DeleteSelectionContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_deleteSelection);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(423);
			deleteOp();
			setState(428);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(424);
				match(T__0);
				setState(425);
				deleteOp();
				}
				}
				setState(430);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DeleteOpContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public FidentContext fident() {
			return getRuleContext(FidentContext.class,0);
		}
		public DeleteOpContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deleteOp; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterDeleteOp(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitDeleteOp(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitDeleteOp(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DeleteOpContext deleteOp() throws RecognitionException {
		DeleteOpContext _localctx = new DeleteOpContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_deleteOp);
		try {
			setState(441);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(431);
				cident();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(432);
				cident();
				setState(433);
				match(T__7);
				setState(434);
				term();
				setState(435);
				match(T__8);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(437);
				cident();
				setState(438);
				match(T__4);
				setState(439);
				fident();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UsingClauseDeleteContext extends ParserRuleContext {
		public TerminalNode K_USING() { return getToken(CqlParser.K_USING, 0); }
		public TerminalNode K_TIMESTAMP() { return getToken(CqlParser.K_TIMESTAMP, 0); }
		public IntValueContext intValue() {
			return getRuleContext(IntValueContext.class,0);
		}
		public UsingClauseDeleteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingClauseDelete; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUsingClauseDelete(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUsingClauseDelete(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUsingClauseDelete(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsingClauseDeleteContext usingClauseDelete() throws RecognitionException {
		UsingClauseDeleteContext _localctx = new UsingClauseDeleteContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_usingClauseDelete);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(443);
			match(K_USING);
			setState(444);
			match(K_TIMESTAMP);
			setState(445);
			intValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BatchStatementContext extends ParserRuleContext {
		public TerminalNode K_BEGIN() { return getToken(CqlParser.K_BEGIN, 0); }
		public List K_BATCH() { return getTokens(CqlParser.K_BATCH); }
		public TerminalNode K_BATCH(int i) {
			return getToken(CqlParser.K_BATCH, i);
		}
		public TerminalNode K_APPLY() { return getToken(CqlParser.K_APPLY, 0); }
		public UsingClauseContext usingClause() {
			return getRuleContext(UsingClauseContext.class,0);
		}
		public List batchStatementObjective() {
			return getRuleContexts(BatchStatementObjectiveContext.class);
		}
		public BatchStatementObjectiveContext batchStatementObjective(int i) {
			return getRuleContext(BatchStatementObjectiveContext.class,i);
		}
		public TerminalNode K_UNLOGGED() { return getToken(CqlParser.K_UNLOGGED, 0); }
		public TerminalNode K_COUNTER() { return getToken(CqlParser.K_COUNTER, 0); }
		public List EOS() { return getTokens(CqlParser.EOS); }
		public TerminalNode EOS(int i) {
			return getToken(CqlParser.EOS, i);
		}
		public BatchStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_batchStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterBatchStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitBatchStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitBatchStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BatchStatementContext batchStatement() throws RecognitionException {
		BatchStatementContext _localctx = new BatchStatementContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_batchStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(447);
			match(K_BEGIN);
			setState(449);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_UNLOGGED || _la==K_COUNTER) {
				{
				setState(448);
				_la = _input.LA(1);
				if ( !(_la==K_UNLOGGED || _la==K_COUNTER) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(451);
			match(K_BATCH);
			setState(453);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==K_USING) {
				{
				setState(452);
				usingClause();
				}
			}

			setState(461);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_INSERT) | (1L << K_UPDATE) | (1L << K_DELETE))) != 0)) {
				{
				{
				setState(455);
				batchStatementObjective();
				setState(457);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==EOS) {
					{
					setState(456);
					match(EOS);
					}
				}

				}
				}
				setState(463);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(464);
			match(K_APPLY);
			setState(465);
			match(K_BATCH);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BatchStatementObjectiveContext extends ParserRuleContext {
		public InsertStatementContext insertStatement() {
			return getRuleContext(InsertStatementContext.class,0);
		}
		public UpdateStatementContext updateStatement() {
			return getRuleContext(UpdateStatementContext.class,0);
		}
		public DeleteStatementContext deleteStatement() {
			return getRuleContext(DeleteStatementContext.class,0);
		}
		public BatchStatementObjectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_batchStatementObjective; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterBatchStatementObjective(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitBatchStatementObjective(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitBatchStatementObjective(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BatchStatementObjectiveContext batchStatementObjective() throws RecognitionException {
		BatchStatementObjectiveContext _localctx = new BatchStatementObjectiveContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_batchStatementObjective);
		try {
			setState(470);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_INSERT:
				enterOuterAlt(_localctx, 1);
				{
				setState(467);
				insertStatement();
				}
				break;
			case K_UPDATE:
				enterOuterAlt(_localctx, 2);
				{
				setState(468);
				updateStatement();
				}
				break;
			case K_DELETE:
				enterOuterAlt(_localctx, 3);
				{
				setState(469);
				deleteStatement();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CidentContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public CidentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cident; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCident(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCident(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCident(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CidentContext cident() throws RecognitionException {
		CidentContext _localctx = new CidentContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_cident);
		try {
			setState(475);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(472);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(473);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(474);
				unreservedKeyword();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FidentContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public FidentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fident; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterFident(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitFident(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitFident(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FidentContext fident() throws RecognitionException {
		FidentContext _localctx = new FidentContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_fident);
		try {
			setState(480);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(477);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(478);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(479);
				unreservedKeyword();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NoncolIdentContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public NoncolIdentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_noncolIdent; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterNoncolIdent(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitNoncolIdent(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitNoncolIdent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NoncolIdentContext noncolIdent() throws RecognitionException {
		NoncolIdentContext _localctx = new NoncolIdentContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_noncolIdent);
		try {
			setState(485);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(482);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(483);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(484);
				unreservedKeyword();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KeyspaceNameContext extends ParserRuleContext {
		public KsNameContext ksName() {
			return getRuleContext(KsNameContext.class,0);
		}
		public KeyspaceNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyspaceName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterKeyspaceName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitKeyspaceName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitKeyspaceName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeyspaceNameContext keyspaceName() throws RecognitionException {
		KeyspaceNameContext _localctx = new KeyspaceNameContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_keyspaceName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(487);
			ksName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnFamilyNameContext extends ParserRuleContext {
		public CfNameContext cfName() {
			return getRuleContext(CfNameContext.class,0);
		}
		public KsNameContext ksName() {
			return getRuleContext(KsNameContext.class,0);
		}
		public ColumnFamilyNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnFamilyName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterColumnFamilyName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitColumnFamilyName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitColumnFamilyName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnFamilyNameContext columnFamilyName() throws RecognitionException {
		ColumnFamilyNameContext _localctx = new ColumnFamilyNameContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_columnFamilyName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(492);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
			case 1:
				{
				setState(489);
				ksName();
				setState(490);
				match(T__4);
				}
				break;
			}
			setState(494);
			cfName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UserTypeNameContext extends ParserRuleContext {
		public NonTypeIdentContext nonTypeIdent() {
			return getRuleContext(NonTypeIdentContext.class,0);
		}
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public UserTypeNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_userTypeName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUserTypeName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUserTypeName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUserTypeName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UserTypeNameContext userTypeName() throws RecognitionException {
		UserTypeNameContext _localctx = new UserTypeNameContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_userTypeName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(499);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
			case 1:
				{
				setState(496);
				noncolIdent();
				setState(497);
				match(T__4);
				}
				break;
			}
			setState(501);
			nonTypeIdent();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KsNameContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public KsNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ksName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterKsName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitKsName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitKsName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KsNameContext ksName() throws RecognitionException {
		KsNameContext _localctx = new KsNameContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_ksName);
		try {
			setState(507);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(503);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(504);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(505);
				unreservedKeyword();
				}
				break;
			case QMARK:
				enterOuterAlt(_localctx, 4);
				{
				setState(506);
				match(QMARK);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CfNameContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public CfNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cfName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCfName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCfName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCfName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CfNameContext cfName() throws RecognitionException {
		CfNameContext _localctx = new CfNameContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_cfName);
		try {
			setState(513);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(509);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(510);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(511);
				unreservedKeyword();
				}
				break;
			case QMARK:
				enterOuterAlt(_localctx, 4);
				{
				setState(512);
				match(QMARK);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IdxNameContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedKeywordContext unreservedKeyword() {
			return getRuleContext(UnreservedKeywordContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public IdxNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_idxName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterIdxName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitIdxName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitIdxName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdxNameContext idxName() throws RecognitionException {
		IdxNameContext _localctx = new IdxNameContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_idxName);
		try {
			setState(519);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(515);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(516);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_KEY:
			case K_PER:
			case K_PARTITION:
			case K_DISTINCT:
			case K_COUNT:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TTL:
			case K_CAST:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_WRITETIME:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_JSON:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(517);
				unreservedKeyword();
				}
				break;
			case QMARK:
				enterOuterAlt(_localctx, 4);
				{
				setState(518);
				match(QMARK);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConstantContext extends ParserRuleContext {
		public TerminalNode STRING_LITERAL() { return getToken(CqlParser.STRING_LITERAL, 0); }
		public TerminalNode INTEGER() { return getToken(CqlParser.INTEGER, 0); }
		public TerminalNode FLOAT() { return getToken(CqlParser.FLOAT, 0); }
		public TerminalNode BOOLEAN() { return getToken(CqlParser.BOOLEAN, 0); }
		public TerminalNode DURATION() { return getToken(CqlParser.DURATION, 0); }
		public TerminalNode UUID() { return getToken(CqlParser.UUID, 0); }
		public TerminalNode HEXNUMBER() { return getToken(CqlParser.HEXNUMBER, 0); }
		public TerminalNode K_NAN() { return getToken(CqlParser.K_NAN, 0); }
		public TerminalNode K_INFINITY() { return getToken(CqlParser.K_INFINITY, 0); }
		public ConstantContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constant; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterConstant(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitConstant(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitConstant(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstantContext constant() throws RecognitionException {
		ConstantContext _localctx = new ConstantContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_constant);
		int _la;
		try {
			setState(532);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(521);
				match(STRING_LITERAL);
				}
				break;
			case INTEGER:
				enterOuterAlt(_localctx, 2);
				{
				setState(522);
				match(INTEGER);
				}
				break;
			case FLOAT:
				enterOuterAlt(_localctx, 3);
				{
				setState(523);
				match(FLOAT);
				}
				break;
			case BOOLEAN:
				enterOuterAlt(_localctx, 4);
				{
				setState(524);
				match(BOOLEAN);
				}
				break;
			case DURATION:
				enterOuterAlt(_localctx, 5);
				{
				setState(525);
				match(DURATION);
				}
				break;
			case UUID:
				enterOuterAlt(_localctx, 6);
				{
				setState(526);
				match(UUID);
				}
				break;
			case HEXNUMBER:
				enterOuterAlt(_localctx, 7);
				{
				setState(527);
				match(HEXNUMBER);
				}
				break;
			case T__9:
			case K_NAN:
			case K_INFINITY:
				enterOuterAlt(_localctx, 8);
				{
				setState(529);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__9) {
					{
					setState(528);
					match(T__9);
					}
				}

				setState(531);
				_la = _input.LA(1);
				if ( !(_la==K_NAN || _la==K_INFINITY) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetOrMapLiteralContext extends ParserRuleContext {
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public SetOrMapLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setOrMapLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSetOrMapLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSetOrMapLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSetOrMapLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetOrMapLiteralContext setOrMapLiteral() throws RecognitionException {
		SetOrMapLiteralContext _localctx = new SetOrMapLiteralContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_setOrMapLiteral);
		int _la;
		try {
			setState(553);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__6:
				enterOuterAlt(_localctx, 1);
				{
				setState(534);
				match(T__6);
				setState(535);
				term();
				setState(543);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(536);
					match(T__0);
					setState(537);
					term();
					setState(538);
					match(T__6);
					setState(539);
					term();
					}
					}
					setState(545);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			case T__0:
			case T__11:
				enterOuterAlt(_localctx, 2);
				{
				setState(550);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(546);
					match(T__0);
					setState(547);
					term();
					}
					}
					setState(552);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CollectionLiteralContext extends ParserRuleContext {
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public SetOrMapLiteralContext setOrMapLiteral() {
			return getRuleContext(SetOrMapLiteralContext.class,0);
		}
		public CollectionLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collectionLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCollectionLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCollectionLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCollectionLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CollectionLiteralContext collectionLiteral() throws RecognitionException {
		CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_collectionLiteral);
		int _la;
		try {
			setState(574);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(555);
				match(T__7);
				setState(564);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__6) | (1L << T__7) | (1L << T__9) | (1L << T__10) | (1L << K_AS) | (1L << K_KEY) | (1L << K_PER) | (1L << K_PARTITION) | (1L << K_DISTINCT) | (1L << K_COUNT) | (1L << K_VALUES) | (1L << K_TIMESTAMP) | (1L << K_TTL) | (1L << K_CAST) | (1L << K_TYPE) | (1L << K_FILTERING) | (1L << K_CONTAINS) | (1L << K_GROUP) | (1L << K_CLUSTERING) | (1L << K_ASCII) | (1L << K_BIGINT) | (1L << K_BLOB) | (1L << K_BOOLEAN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_COUNTER - 64)) | (1L << (K_DECIMAL - 64)) | (1L << (K_DOUBLE - 64)) | (1L << (K_DURATION - 64)) | (1L << (K_FLOAT - 64)) | (1L << (K_INET - 64)) | (1L << (K_INT - 64)) | (1L << (K_SMALLINT - 64)) | (1L << (K_TINYINT - 64)) | (1L << (K_TEXT - 64)) | (1L << (K_UUID - 64)) | (1L << (K_VARCHAR - 64)) | (1L << (K_VARINT - 64)) | (1L << (K_TIMEUUID - 64)) | (1L << (K_TOKEN - 64)) | (1L << (K_WRITETIME - 64)) | (1L << (K_DATE - 64)) | (1L << (K_TIME - 64)) | (1L << (K_NULL - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_MAP - 64)) | (1L << (K_LIST - 64)) | (1L << (K_NAN - 64)) | (1L << (K_INFINITY - 64)) | (1L << (K_TUPLE - 64)) | (1L << (K_FROZEN - 64)) | (1L << (K_JSON - 64)) | (1L << (K_LIKE - 64)) | (1L << (STRING_LITERAL - 64)) | (1L << (QUOTED_NAME - 64)) | (1L << (INTEGER - 64)) | (1L << (QMARK - 64)) | (1L << (FLOAT - 64)) | (1L << (BOOLEAN - 64)) | (1L << (DURATION - 64)) | (1L << (IDENT - 64)) | (1L << (HEXNUMBER - 64)) | (1L << (UUID - 64)))) != 0)) {
					{
					setState(556);
					term();
					setState(561);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==T__0) {
						{
						{
						setState(557);
						match(T__0);
						setState(558);
						term();
						}
						}
						setState(563);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					}
				}

				setState(566);
				match(T__8);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(567);
				match(T__10);
				setState(568);
				term();
				setState(569);
				setOrMapLiteral();
				setState(570);
				match(T__11);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(572);
				match(T__10);
				setState(573);
				match(T__11);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UsertypeLiteralContext extends ParserRuleContext {
		public List fident() {
			return getRuleContexts(FidentContext.class);
		}
		public FidentContext fident(int i) {
			return getRuleContext(FidentContext.class,i);
		}
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public UsertypeLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usertypeLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUsertypeLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUsertypeLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUsertypeLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsertypeLiteralContext usertypeLiteral() throws RecognitionException {
		UsertypeLiteralContext _localctx = new UsertypeLiteralContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_usertypeLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(576);
			match(T__10);
			setState(577);
			fident();
			setState(578);
			match(T__6);
			setState(579);
			term();
			setState(587);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(580);
				match(T__0);
				setState(581);
				fident();
				setState(582);
				match(T__6);
				setState(583);
				term();
				}
				}
				setState(589);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(590);
			match(T__11);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TupleLiteralContext extends ParserRuleContext {
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public TupleLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTupleLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTupleLiteral(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTupleLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleLiteralContext tupleLiteral() throws RecognitionException {
		TupleLiteralContext _localctx = new TupleLiteralContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_tupleLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(592);
			match(T__2);
			setState(593);
			term();
			setState(598);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(594);
				match(T__0);
				setState(595);
				term();
				}
				}
				setState(600);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(601);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ValueContext extends ParserRuleContext {
		public ConstantContext constant() {
			return getRuleContext(ConstantContext.class,0);
		}
		public CollectionLiteralContext collectionLiteral() {
			return getRuleContext(CollectionLiteralContext.class,0);
		}
		public UsertypeLiteralContext usertypeLiteral() {
			return getRuleContext(UsertypeLiteralContext.class,0);
		}
		public TupleLiteralContext tupleLiteral() {
			return getRuleContext(TupleLiteralContext.class,0);
		}
		public TerminalNode K_NULL() { return getToken(CqlParser.K_NULL, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public ValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_value; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueContext value() throws RecognitionException {
		ValueContext _localctx = new ValueContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_value);
		try {
			setState(611);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(603);
				constant();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(604);
				collectionLiteral();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(605);
				usertypeLiteral();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(606);
				tupleLiteral();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(607);
				match(K_NULL);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(608);
				match(T__6);
				setState(609);
				noncolIdent();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(610);
				match(QMARK);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IntValueContext extends ParserRuleContext {
		public TerminalNode INTEGER() { return getToken(CqlParser.INTEGER, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public IntValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_intValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterIntValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitIntValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitIntValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IntValueContext intValue() throws RecognitionException {
		IntValueContext _localctx = new IntValueContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_intValue);
		try {
			setState(617);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case INTEGER:
				enterOuterAlt(_localctx, 1);
				{
				setState(613);
				match(INTEGER);
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 2);
				{
				setState(614);
				match(T__6);
				setState(615);
				noncolIdent();
				}
				break;
			case QMARK:
				enterOuterAlt(_localctx, 3);
				{
				setState(616);
				match(QMARK);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionNameContext extends ParserRuleContext {
		public AllowedFunctionNameContext allowedFunctionName() {
			return getRuleContext(AllowedFunctionNameContext.class,0);
		}
		public KeyspaceNameContext keyspaceName() {
			return getRuleContext(KeyspaceNameContext.class,0);
		}
		public FunctionNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterFunctionName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitFunctionName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitFunctionName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionNameContext functionName() throws RecognitionException {
		FunctionNameContext _localctx = new FunctionNameContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_functionName);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(622);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
			case 1:
				{
				setState(619);
				keyspaceName();
				setState(620);
				match(T__4);
				}
				break;
			}
			setState(624);
			allowedFunctionName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AllowedFunctionNameContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public UnreservedFunctionKeywordContext unreservedFunctionKeyword() {
			return getRuleContext(UnreservedFunctionKeywordContext.class,0);
		}
		public TerminalNode K_TOKEN() { return getToken(CqlParser.K_TOKEN, 0); }
		public TerminalNode K_COUNT() { return getToken(CqlParser.K_COUNT, 0); }
		public AllowedFunctionNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_allowedFunctionName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterAllowedFunctionName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitAllowedFunctionName(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitAllowedFunctionName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AllowedFunctionNameContext allowedFunctionName() throws RecognitionException {
		AllowedFunctionNameContext _localctx = new AllowedFunctionNameContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_allowedFunctionName);
		try {
			setState(631);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(626);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(627);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_PER:
			case K_PARTITION:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(628);
				unreservedFunctionKeyword();
				}
				break;
			case K_TOKEN:
				enterOuterAlt(_localctx, 4);
				{
				setState(629);
				match(K_TOKEN);
				}
				break;
			case K_COUNT:
				enterOuterAlt(_localctx, 5);
				{
				setState(630);
				match(K_COUNT);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionContext extends ParserRuleContext {
		public FunctionNameContext functionName() {
			return getRuleContext(FunctionNameContext.class,0);
		}
		public FunctionArgsContext functionArgs() {
			return getRuleContext(FunctionArgsContext.class,0);
		}
		public FunctionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterFunction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitFunction(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitFunction(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionContext function() throws RecognitionException {
		FunctionContext _localctx = new FunctionContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_function);
		try {
			setState(642);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(633);
				functionName();
				setState(634);
				match(T__2);
				setState(635);
				match(T__3);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(637);
				functionName();
				setState(638);
				match(T__2);
				setState(639);
				functionArgs();
				setState(640);
				match(T__3);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FunctionArgsContext extends ParserRuleContext {
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public FunctionArgsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_functionArgs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterFunctionArgs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitFunctionArgs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitFunctionArgs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FunctionArgsContext functionArgs() throws RecognitionException {
		FunctionArgsContext _localctx = new FunctionArgsContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_functionArgs);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(644);
			term();
			setState(649);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(645);
				match(T__0);
				setState(646);
				term();
				}
				}
				setState(651);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TermContext extends ParserRuleContext {
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public FunctionContext function() {
			return getRuleContext(FunctionContext.class,0);
		}
		public ComparatorTypeContext comparatorType() {
			return getRuleContext(ComparatorTypeContext.class,0);
		}
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public TermContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_term; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTerm(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTerm(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTerm(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TermContext term() throws RecognitionException {
		TermContext _localctx = new TermContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_term);
		try {
			setState(659);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(652);
				value();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(653);
				function();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(654);
				match(T__2);
				setState(655);
				comparatorType();
				setState(656);
				match(T__3);
				setState(657);
				term();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnOperationContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public ColumnOperationDifferentiatorContext columnOperationDifferentiator() {
			return getRuleContext(ColumnOperationDifferentiatorContext.class,0);
		}
		public ColumnOperationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnOperation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterColumnOperation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitColumnOperation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitColumnOperation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnOperationContext columnOperation() throws RecognitionException {
		ColumnOperationContext _localctx = new ColumnOperationContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_columnOperation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(661);
			cident();
			setState(662);
			columnOperationDifferentiator();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnOperationDifferentiatorContext extends ParserRuleContext {
		public NormalColumnOperationContext normalColumnOperation() {
			return getRuleContext(NormalColumnOperationContext.class,0);
		}
		public ShorthandColumnOperationContext shorthandColumnOperation() {
			return getRuleContext(ShorthandColumnOperationContext.class,0);
		}
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public CollectionColumnOperationContext collectionColumnOperation() {
			return getRuleContext(CollectionColumnOperationContext.class,0);
		}
		public FidentContext fident() {
			return getRuleContext(FidentContext.class,0);
		}
		public UdtColumnOperationContext udtColumnOperation() {
			return getRuleContext(UdtColumnOperationContext.class,0);
		}
		public ColumnOperationDifferentiatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnOperationDifferentiator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterColumnOperationDifferentiator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitColumnOperationDifferentiator(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitColumnOperationDifferentiator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnOperationDifferentiatorContext columnOperationDifferentiator() throws RecognitionException {
		ColumnOperationDifferentiatorContext _localctx = new ColumnOperationDifferentiatorContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_columnOperationDifferentiator);
		try {
			setState(676);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__12:
				enterOuterAlt(_localctx, 1);
				{
				setState(664);
				match(T__12);
				setState(665);
				normalColumnOperation();
				}
				break;
			case T__14:
			case T__15:
				enterOuterAlt(_localctx, 2);
				{
				setState(666);
				shorthandColumnOperation();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 3);
				{
				setState(667);
				match(T__7);
				setState(668);
				term();
				setState(669);
				match(T__8);
				setState(670);
				collectionColumnOperation();
				}
				break;
			case T__4:
				enterOuterAlt(_localctx, 4);
				{
				setState(672);
				match(T__4);
				setState(673);
				fident();
				setState(674);
				udtColumnOperation();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NormalColumnOperationContext extends ParserRuleContext {
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public TerminalNode INTEGER() { return getToken(CqlParser.INTEGER, 0); }
		public NormalColumnOperationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_normalColumnOperation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterNormalColumnOperation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitNormalColumnOperation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitNormalColumnOperation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NormalColumnOperationContext normalColumnOperation() throws RecognitionException {
		NormalColumnOperationContext _localctx = new NormalColumnOperationContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_normalColumnOperation);
		int _la;
		try {
			setState(690);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(678);
				term();
				setState(681);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==T__13) {
					{
					setState(679);
					match(T__13);
					setState(680);
					cident();
					}
				}

				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(683);
				cident();
				setState(684);
				_la = _input.LA(1);
				if ( !(_la==T__9 || _la==T__13) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(685);
				term();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(687);
				cident();
				setState(688);
				match(INTEGER);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ShorthandColumnOperationContext extends ParserRuleContext {
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public ShorthandColumnOperationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_shorthandColumnOperation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterShorthandColumnOperation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitShorthandColumnOperation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitShorthandColumnOperation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ShorthandColumnOperationContext shorthandColumnOperation() throws RecognitionException {
		ShorthandColumnOperationContext _localctx = new ShorthandColumnOperationContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_shorthandColumnOperation);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(692);
			_la = _input.LA(1);
			if ( !(_la==T__14 || _la==T__15) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(693);
			term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CollectionColumnOperationContext extends ParserRuleContext {
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public CollectionColumnOperationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collectionColumnOperation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCollectionColumnOperation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCollectionColumnOperation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCollectionColumnOperation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CollectionColumnOperationContext collectionColumnOperation() throws RecognitionException {
		CollectionColumnOperationContext _localctx = new CollectionColumnOperationContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_collectionColumnOperation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(695);
			match(T__12);
			setState(696);
			term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UdtColumnOperationContext extends ParserRuleContext {
		public TermContext term() {
			return getRuleContext(TermContext.class,0);
		}
		public UdtColumnOperationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_udtColumnOperation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUdtColumnOperation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUdtColumnOperation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUdtColumnOperation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UdtColumnOperationContext udtColumnOperation() throws RecognitionException {
		UdtColumnOperationContext _localctx = new UdtColumnOperationContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_udtColumnOperation);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(698);
			match(T__12);
			setState(699);
			term();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ColumnConditionContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public RelationTypeContext relationType() {
			return getRuleContext(RelationTypeContext.class,0);
		}
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public TerminalNode K_IN() { return getToken(CqlParser.K_IN, 0); }
		public FidentContext fident() {
			return getRuleContext(FidentContext.class,0);
		}
		public SingleColumnInValuesContext singleColumnInValues() {
			return getRuleContext(SingleColumnInValuesContext.class,0);
		}
		public InMarkerContext inMarker() {
			return getRuleContext(InMarkerContext.class,0);
		}
		public ColumnConditionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_columnCondition; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterColumnCondition(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitColumnCondition(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitColumnCondition(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ColumnConditionContext columnCondition() throws RecognitionException {
		ColumnConditionContext _localctx = new ColumnConditionContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_columnCondition);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(701);
			cident();
			setState(735);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__12:
			case T__16:
			case T__17:
			case T__18:
			case T__19:
			case T__20:
				{
				setState(702);
				relationType();
				setState(703);
				term();
				}
				break;
			case K_IN:
				{
				setState(705);
				match(K_IN);
				setState(708);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case T__2:
					{
					setState(706);
					singleColumnInValues();
					}
					break;
				case T__6:
				case QMARK:
					{
					setState(707);
					inMarker();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case T__7:
				{
				setState(710);
				match(T__7);
				setState(711);
				term();
				setState(712);
				match(T__8);
				setState(721);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case T__12:
				case T__16:
				case T__17:
				case T__18:
				case T__19:
				case T__20:
					{
					setState(713);
					relationType();
					setState(714);
					term();
					}
					break;
				case K_IN:
					{
					setState(716);
					match(K_IN);
					setState(719);
					_errHandler.sync(this);
					switch (_input.LA(1)) {
					case T__2:
						{
						setState(717);
						singleColumnInValues();
						}
						break;
					case T__6:
					case QMARK:
						{
						setState(718);
						inMarker();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case T__4:
				{
				setState(723);
				match(T__4);
				setState(724);
				fident();
				setState(733);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case T__12:
				case T__16:
				case T__17:
				case T__18:
				case T__19:
				case T__20:
					{
					setState(725);
					relationType();
					setState(726);
					term();
					}
					break;
				case K_IN:
					{
					setState(728);
					match(K_IN);
					setState(731);
					_errHandler.sync(this);
					switch (_input.LA(1)) {
					case T__2:
						{
						setState(729);
						singleColumnInValues();
						}
						break;
					case T__6:
					case QMARK:
						{
						setState(730);
						inMarker();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RelationTypeContext extends ParserRuleContext {
		public RelationTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relationType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterRelationType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitRelationType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitRelationType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationTypeContext relationType() throws RecognitionException {
		RelationTypeContext _localctx = new RelationTypeContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_relationType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(737);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__12) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RelationContext extends ParserRuleContext {
		public CidentContext cident() {
			return getRuleContext(CidentContext.class,0);
		}
		public RelationTypeContext relationType() {
			return getRuleContext(RelationTypeContext.class,0);
		}
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public TerminalNode K_LIKE() { return getToken(CqlParser.K_LIKE, 0); }
		public TerminalNode K_IS() { return getToken(CqlParser.K_IS, 0); }
		public TerminalNode K_NOT() { return getToken(CqlParser.K_NOT, 0); }
		public TerminalNode K_NULL() { return getToken(CqlParser.K_NULL, 0); }
		public TerminalNode K_TOKEN() { return getToken(CqlParser.K_TOKEN, 0); }
		public TupleOfIdentifiersContext tupleOfIdentifiers() {
			return getRuleContext(TupleOfIdentifiersContext.class,0);
		}
		public TerminalNode K_IN() { return getToken(CqlParser.K_IN, 0); }
		public InMarkerContext inMarker() {
			return getRuleContext(InMarkerContext.class,0);
		}
		public SingleColumnInValuesContext singleColumnInValues() {
			return getRuleContext(SingleColumnInValuesContext.class,0);
		}
		public TerminalNode K_CONTAINS() { return getToken(CqlParser.K_CONTAINS, 0); }
		public TerminalNode K_KEY() { return getToken(CqlParser.K_KEY, 0); }
		public TerminalNode K_ANN_OF() { return getToken(CqlParser.K_ANN_OF, 0); }
		public TupleLiteralContext tupleLiteral() {
			return getRuleContext(TupleLiteralContext.class,0);
		}
		public MarkerForTupleContext markerForTuple() {
			return getRuleContext(MarkerForTupleContext.class,0);
		}
		public InMarkerForTupleContext inMarkerForTuple() {
			return getRuleContext(InMarkerForTupleContext.class,0);
		}
		public TupleOfTupleLiteralsContext tupleOfTupleLiterals() {
			return getRuleContext(TupleOfTupleLiteralsContext.class,0);
		}
		public TupleOfMarkersForTuplesContext tupleOfMarkersForTuples() {
			return getRuleContext(TupleOfMarkersForTuplesContext.class,0);
		}
		public RelationContext relation() {
			return getRuleContext(RelationContext.class,0);
		}
		public RelationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_relation; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterRelation(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitRelation(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitRelation(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RelationContext relation() throws RecognitionException {
		RelationContext _localctx = new RelationContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_relation);
		try {
			setState(804);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(739);
				cident();
				setState(740);
				relationType();
				setState(741);
				term();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(743);
				cident();
				setState(744);
				match(K_LIKE);
				setState(745);
				term();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(747);
				cident();
				setState(748);
				match(K_IS);
				setState(749);
				match(K_NOT);
				setState(750);
				match(K_NULL);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(752);
				match(K_TOKEN);
				setState(753);
				tupleOfIdentifiers();
				setState(754);
				relationType();
				setState(755);
				term();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(757);
				cident();
				setState(758);
				match(K_IN);
				setState(759);
				inMarker();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(761);
				cident();
				setState(762);
				match(K_IN);
				setState(763);
				singleColumnInValues();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(765);
				cident();
				setState(766);
				match(K_CONTAINS);
				setState(768);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
				case 1:
					{
					setState(767);
					match(K_KEY);
					}
					break;
				}
				setState(770);
				term();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(772);
				cident();
				setState(773);
				match(T__7);
				setState(774);
				term();
				setState(775);
				match(T__8);
				setState(776);
				relationType();
				setState(777);
				term();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(779);
				cident();
				setState(780);
				match(K_ANN_OF);
				setState(781);
				term();
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(783);
				tupleOfIdentifiers();
				setState(798);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
				case 1:
					{
					setState(784);
					match(K_IN);
					setState(790);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
					case 1:
						{
						setState(785);
						match(T__2);
						setState(786);
						match(T__3);
						}
						break;
					case 2:
						{
						setState(787);
						inMarkerForTuple();
						}
						break;
					case 3:
						{
						setState(788);
						tupleOfTupleLiterals();
						}
						break;
					case 4:
						{
						setState(789);
						tupleOfMarkersForTuples();
						}
						break;
					}
					}
					break;
				case 2:
					{
					setState(792);
					relationType();
					setState(793);
					tupleLiteral();
					}
					break;
				case 3:
					{
					setState(795);
					relationType();
					setState(796);
					markerForTuple();
					}
					break;
				}
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(800);
				match(T__2);
				setState(801);
				relation();
				setState(802);
				match(T__3);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InMarkerContext extends ParserRuleContext {
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public InMarkerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inMarker; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterInMarker(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitInMarker(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitInMarker(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InMarkerContext inMarker() throws RecognitionException {
		InMarkerContext _localctx = new InMarkerContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_inMarker);
		try {
			setState(809);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case QMARK:
				enterOuterAlt(_localctx, 1);
				{
				setState(806);
				match(QMARK);
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 2);
				{
				setState(807);
				match(T__6);
				setState(808);
				noncolIdent();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TupleOfIdentifiersContext extends ParserRuleContext {
		public List cident() {
			return getRuleContexts(CidentContext.class);
		}
		public CidentContext cident(int i) {
			return getRuleContext(CidentContext.class,i);
		}
		public TupleOfIdentifiersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleOfIdentifiers; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTupleOfIdentifiers(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTupleOfIdentifiers(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTupleOfIdentifiers(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleOfIdentifiersContext tupleOfIdentifiers() throws RecognitionException {
		TupleOfIdentifiersContext _localctx = new TupleOfIdentifiersContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_tupleOfIdentifiers);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(811);
			match(T__2);
			setState(812);
			cident();
			setState(817);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(813);
				match(T__0);
				setState(814);
				cident();
				}
				}
				setState(819);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(820);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SingleColumnInValuesContext extends ParserRuleContext {
		public List term() {
			return getRuleContexts(TermContext.class);
		}
		public TermContext term(int i) {
			return getRuleContext(TermContext.class,i);
		}
		public SingleColumnInValuesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_singleColumnInValues; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterSingleColumnInValues(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitSingleColumnInValues(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitSingleColumnInValues(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SingleColumnInValuesContext singleColumnInValues() throws RecognitionException {
		SingleColumnInValuesContext _localctx = new SingleColumnInValuesContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_singleColumnInValues);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(822);
			match(T__2);
			setState(831);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__6) | (1L << T__7) | (1L << T__9) | (1L << T__10) | (1L << K_AS) | (1L << K_KEY) | (1L << K_PER) | (1L << K_PARTITION) | (1L << K_DISTINCT) | (1L << K_COUNT) | (1L << K_VALUES) | (1L << K_TIMESTAMP) | (1L << K_TTL) | (1L << K_CAST) | (1L << K_TYPE) | (1L << K_FILTERING) | (1L << K_CONTAINS) | (1L << K_GROUP) | (1L << K_CLUSTERING) | (1L << K_ASCII) | (1L << K_BIGINT) | (1L << K_BLOB) | (1L << K_BOOLEAN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_COUNTER - 64)) | (1L << (K_DECIMAL - 64)) | (1L << (K_DOUBLE - 64)) | (1L << (K_DURATION - 64)) | (1L << (K_FLOAT - 64)) | (1L << (K_INET - 64)) | (1L << (K_INT - 64)) | (1L << (K_SMALLINT - 64)) | (1L << (K_TINYINT - 64)) | (1L << (K_TEXT - 64)) | (1L << (K_UUID - 64)) | (1L << (K_VARCHAR - 64)) | (1L << (K_VARINT - 64)) | (1L << (K_TIMEUUID - 64)) | (1L << (K_TOKEN - 64)) | (1L << (K_WRITETIME - 64)) | (1L << (K_DATE - 64)) | (1L << (K_TIME - 64)) | (1L << (K_NULL - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_MAP - 64)) | (1L << (K_LIST - 64)) | (1L << (K_NAN - 64)) | (1L << (K_INFINITY - 64)) | (1L << (K_TUPLE - 64)) | (1L << (K_FROZEN - 64)) | (1L << (K_JSON - 64)) | (1L << (K_LIKE - 64)) | (1L << (STRING_LITERAL - 64)) | (1L << (QUOTED_NAME - 64)) | (1L << (INTEGER - 64)) | (1L << (QMARK - 64)) | (1L << (FLOAT - 64)) | (1L << (BOOLEAN - 64)) | (1L << (DURATION - 64)) | (1L << (IDENT - 64)) | (1L << (HEXNUMBER - 64)) | (1L << (UUID - 64)))) != 0)) {
				{
				setState(823);
				term();
				setState(828);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__0) {
					{
					{
					setState(824);
					match(T__0);
					setState(825);
					term();
					}
					}
					setState(830);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

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

	public static class TupleOfTupleLiteralsContext extends ParserRuleContext {
		public List tupleLiteral() {
			return getRuleContexts(TupleLiteralContext.class);
		}
		public TupleLiteralContext tupleLiteral(int i) {
			return getRuleContext(TupleLiteralContext.class,i);
		}
		public TupleOfTupleLiteralsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleOfTupleLiterals; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTupleOfTupleLiterals(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTupleOfTupleLiterals(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTupleOfTupleLiterals(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleOfTupleLiteralsContext tupleOfTupleLiterals() throws RecognitionException {
		TupleOfTupleLiteralsContext _localctx = new TupleOfTupleLiteralsContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_tupleOfTupleLiterals);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(835);
			match(T__2);
			setState(836);
			tupleLiteral();
			setState(841);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(837);
				match(T__0);
				setState(838);
				tupleLiteral();
				}
				}
				setState(843);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(844);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MarkerForTupleContext extends ParserRuleContext {
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public MarkerForTupleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_markerForTuple; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterMarkerForTuple(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitMarkerForTuple(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitMarkerForTuple(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MarkerForTupleContext markerForTuple() throws RecognitionException {
		MarkerForTupleContext _localctx = new MarkerForTupleContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_markerForTuple);
		try {
			setState(849);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case QMARK:
				enterOuterAlt(_localctx, 1);
				{
				setState(846);
				match(QMARK);
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 2);
				{
				setState(847);
				match(T__6);
				setState(848);
				noncolIdent();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TupleOfMarkersForTuplesContext extends ParserRuleContext {
		public List markerForTuple() {
			return getRuleContexts(MarkerForTupleContext.class);
		}
		public MarkerForTupleContext markerForTuple(int i) {
			return getRuleContext(MarkerForTupleContext.class,i);
		}
		public TupleOfMarkersForTuplesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleOfMarkersForTuples; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTupleOfMarkersForTuples(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTupleOfMarkersForTuples(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTupleOfMarkersForTuples(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleOfMarkersForTuplesContext tupleOfMarkersForTuples() throws RecognitionException {
		TupleOfMarkersForTuplesContext _localctx = new TupleOfMarkersForTuplesContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_tupleOfMarkersForTuples);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(851);
			match(T__2);
			setState(852);
			markerForTuple();
			setState(857);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(853);
				match(T__0);
				setState(854);
				markerForTuple();
				}
				}
				setState(859);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(860);
			match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InMarkerForTupleContext extends ParserRuleContext {
		public TerminalNode QMARK() { return getToken(CqlParser.QMARK, 0); }
		public NoncolIdentContext noncolIdent() {
			return getRuleContext(NoncolIdentContext.class,0);
		}
		public InMarkerForTupleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_inMarkerForTuple; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterInMarkerForTuple(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitInMarkerForTuple(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitInMarkerForTuple(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InMarkerForTupleContext inMarkerForTuple() throws RecognitionException {
		InMarkerForTupleContext _localctx = new InMarkerForTupleContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_inMarkerForTuple);
		try {
			setState(865);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case QMARK:
				enterOuterAlt(_localctx, 1);
				{
				setState(862);
				match(QMARK);
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 2);
				{
				setState(863);
				match(T__6);
				setState(864);
				noncolIdent();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ComparatorTypeContext extends ParserRuleContext {
		public NativeTypeContext nativeType() {
			return getRuleContext(NativeTypeContext.class,0);
		}
		public CollectionTypeContext collectionType() {
			return getRuleContext(CollectionTypeContext.class,0);
		}
		public TupleTypeContext tupleType() {
			return getRuleContext(TupleTypeContext.class,0);
		}
		public UserTypeNameContext userTypeName() {
			return getRuleContext(UserTypeNameContext.class,0);
		}
		public TerminalNode K_FROZEN() { return getToken(CqlParser.K_FROZEN, 0); }
		public ComparatorTypeContext comparatorType() {
			return getRuleContext(ComparatorTypeContext.class,0);
		}
		public ComparatorTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_comparatorType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterComparatorType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitComparatorType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitComparatorType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ComparatorTypeContext comparatorType() throws RecognitionException {
		ComparatorTypeContext _localctx = new ComparatorTypeContext(_ctx, getState());
		enterRule(_localctx, 128, RULE_comparatorType);
		try {
			setState(876);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(867);
				nativeType();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(868);
				collectionType();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(869);
				tupleType();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(870);
				userTypeName();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(871);
				match(K_FROZEN);
				setState(872);
				match(T__16);
				setState(873);
				comparatorType();
				setState(874);
				match(T__18);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NativeTypeContext extends ParserRuleContext {
		public TerminalNode K_ASCII() { return getToken(CqlParser.K_ASCII, 0); }
		public TerminalNode K_BIGINT() { return getToken(CqlParser.K_BIGINT, 0); }
		public TerminalNode K_BLOB() { return getToken(CqlParser.K_BLOB, 0); }
		public TerminalNode K_BOOLEAN() { return getToken(CqlParser.K_BOOLEAN, 0); }
		public TerminalNode K_COUNTER() { return getToken(CqlParser.K_COUNTER, 0); }
		public TerminalNode K_DECIMAL() { return getToken(CqlParser.K_DECIMAL, 0); }
		public TerminalNode K_DOUBLE() { return getToken(CqlParser.K_DOUBLE, 0); }
		public TerminalNode K_DURATION() { return getToken(CqlParser.K_DURATION, 0); }
		public TerminalNode K_FLOAT() { return getToken(CqlParser.K_FLOAT, 0); }
		public TerminalNode K_INET() { return getToken(CqlParser.K_INET, 0); }
		public TerminalNode K_INT() { return getToken(CqlParser.K_INT, 0); }
		public TerminalNode K_SMALLINT() { return getToken(CqlParser.K_SMALLINT, 0); }
		public TerminalNode K_TEXT() { return getToken(CqlParser.K_TEXT, 0); }
		public TerminalNode K_TIMESTAMP() { return getToken(CqlParser.K_TIMESTAMP, 0); }
		public TerminalNode K_TINYINT() { return getToken(CqlParser.K_TINYINT, 0); }
		public TerminalNode K_UUID() { return getToken(CqlParser.K_UUID, 0); }
		public TerminalNode K_VARCHAR() { return getToken(CqlParser.K_VARCHAR, 0); }
		public TerminalNode K_VARINT() { return getToken(CqlParser.K_VARINT, 0); }
		public TerminalNode K_TIMEUUID() { return getToken(CqlParser.K_TIMEUUID, 0); }
		public TerminalNode K_DATE() { return getToken(CqlParser.K_DATE, 0); }
		public TerminalNode K_TIME() { return getToken(CqlParser.K_TIME, 0); }
		public NativeTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nativeType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterNativeType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitNativeType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitNativeType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NativeTypeContext nativeType() throws RecognitionException {
		NativeTypeContext _localctx = new NativeTypeContext(_ctx, getState());
		enterRule(_localctx, 130, RULE_nativeType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(878);
			_la = _input.LA(1);
			if ( !(((((_la - 45)) & ~0x3f) == 0 && ((1L << (_la - 45)) & ((1L << (K_TIMESTAMP - 45)) | (1L << (K_ASCII - 45)) | (1L << (K_BIGINT - 45)) | (1L << (K_BLOB - 45)) | (1L << (K_BOOLEAN - 45)) | (1L << (K_COUNTER - 45)) | (1L << (K_DECIMAL - 45)) | (1L << (K_DOUBLE - 45)) | (1L << (K_DURATION - 45)) | (1L << (K_FLOAT - 45)) | (1L << (K_INET - 45)) | (1L << (K_INT - 45)) | (1L << (K_SMALLINT - 45)) | (1L << (K_TINYINT - 45)) | (1L << (K_TEXT - 45)) | (1L << (K_UUID - 45)) | (1L << (K_VARCHAR - 45)) | (1L << (K_VARINT - 45)) | (1L << (K_TIMEUUID - 45)) | (1L << (K_DATE - 45)) | (1L << (K_TIME - 45)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CollectionTypeContext extends ParserRuleContext {
		public TerminalNode K_MAP() { return getToken(CqlParser.K_MAP, 0); }
		public List comparatorType() {
			return getRuleContexts(ComparatorTypeContext.class);
		}
		public ComparatorTypeContext comparatorType(int i) {
			return getRuleContext(ComparatorTypeContext.class,i);
		}
		public TerminalNode K_LIST() { return getToken(CqlParser.K_LIST, 0); }
		public TerminalNode K_SET() { return getToken(CqlParser.K_SET, 0); }
		public CollectionTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collectionType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterCollectionType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitCollectionType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitCollectionType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CollectionTypeContext collectionType() throws RecognitionException {
		CollectionTypeContext _localctx = new CollectionTypeContext(_ctx, getState());
		enterRule(_localctx, 132, RULE_collectionType);
		try {
			setState(897);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_MAP:
				enterOuterAlt(_localctx, 1);
				{
				setState(880);
				match(K_MAP);
				setState(881);
				match(T__16);
				setState(882);
				comparatorType();
				setState(883);
				match(T__0);
				setState(884);
				comparatorType();
				setState(885);
				match(T__18);
				}
				break;
			case K_LIST:
				enterOuterAlt(_localctx, 2);
				{
				setState(887);
				match(K_LIST);
				setState(888);
				match(T__16);
				setState(889);
				comparatorType();
				setState(890);
				match(T__18);
				}
				break;
			case K_SET:
				enterOuterAlt(_localctx, 3);
				{
				setState(892);
				match(K_SET);
				setState(893);
				match(T__16);
				setState(894);
				comparatorType();
				setState(895);
				match(T__18);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TupleTypeContext extends ParserRuleContext {
		public TerminalNode K_TUPLE() { return getToken(CqlParser.K_TUPLE, 0); }
		public List comparatorType() {
			return getRuleContexts(ComparatorTypeContext.class);
		}
		public ComparatorTypeContext comparatorType(int i) {
			return getRuleContext(ComparatorTypeContext.class,i);
		}
		public TupleTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterTupleType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitTupleType(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitTupleType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleTypeContext tupleType() throws RecognitionException {
		TupleTypeContext _localctx = new TupleTypeContext(_ctx, getState());
		enterRule(_localctx, 134, RULE_tupleType);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(899);
			match(K_TUPLE);
			setState(900);
			match(T__16);
			setState(901);
			comparatorType();
			setState(906);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__0) {
				{
				{
				setState(902);
				match(T__0);
				setState(903);
				comparatorType();
				}
				}
				setState(908);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(909);
			match(T__18);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NonTypeIdentContext extends ParserRuleContext {
		public TerminalNode IDENT() { return getToken(CqlParser.IDENT, 0); }
		public TerminalNode QUOTED_NAME() { return getToken(CqlParser.QUOTED_NAME, 0); }
		public BasicUnreservedKeywordContext basicUnreservedKeyword() {
			return getRuleContext(BasicUnreservedKeywordContext.class,0);
		}
		public TerminalNode K_KEY() { return getToken(CqlParser.K_KEY, 0); }
		public NonTypeIdentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nonTypeIdent; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterNonTypeIdent(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitNonTypeIdent(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitNonTypeIdent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NonTypeIdentContext nonTypeIdent() throws RecognitionException {
		NonTypeIdentContext _localctx = new NonTypeIdentContext(_ctx, getState());
		enterRule(_localctx, 136, RULE_nonTypeIdent);
		try {
			setState(915);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IDENT:
				enterOuterAlt(_localctx, 1);
				{
				setState(911);
				match(IDENT);
				}
				break;
			case QUOTED_NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(912);
				match(QUOTED_NAME);
				}
				break;
			case K_AS:
			case K_PER:
			case K_PARTITION:
			case K_VALUES:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_LIKE:
				enterOuterAlt(_localctx, 3);
				{
				setState(913);
				basicUnreservedKeyword();
				}
				break;
			case K_KEY:
				enterOuterAlt(_localctx, 4);
				{
				setState(914);
				match(K_KEY);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnreservedKeywordContext extends ParserRuleContext {
		public UnreservedFunctionKeywordContext unreservedFunctionKeyword() {
			return getRuleContext(UnreservedFunctionKeywordContext.class,0);
		}
		public TerminalNode K_TTL() { return getToken(CqlParser.K_TTL, 0); }
		public TerminalNode K_COUNT() { return getToken(CqlParser.K_COUNT, 0); }
		public TerminalNode K_WRITETIME() { return getToken(CqlParser.K_WRITETIME, 0); }
		public TerminalNode K_KEY() { return getToken(CqlParser.K_KEY, 0); }
		public TerminalNode K_CAST() { return getToken(CqlParser.K_CAST, 0); }
		public TerminalNode K_JSON() { return getToken(CqlParser.K_JSON, 0); }
		public TerminalNode K_DISTINCT() { return getToken(CqlParser.K_DISTINCT, 0); }
		public UnreservedKeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unreservedKeyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUnreservedKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUnreservedKeyword(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUnreservedKeyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnreservedKeywordContext unreservedKeyword() throws RecognitionException {
		UnreservedKeywordContext _localctx = new UnreservedKeywordContext(_ctx, getState());
		enterRule(_localctx, 138, RULE_unreservedKeyword);
		int _la;
		try {
			setState(919);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_AS:
			case K_PER:
			case K_PARTITION:
			case K_VALUES:
			case K_TIMESTAMP:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_DATE:
			case K_TIME:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_LIKE:
				enterOuterAlt(_localctx, 1);
				{
				setState(917);
				unreservedFunctionKeyword();
				}
				break;
			case K_KEY:
			case K_DISTINCT:
			case K_COUNT:
			case K_TTL:
			case K_CAST:
			case K_WRITETIME:
			case K_JSON:
				enterOuterAlt(_localctx, 2);
				{
				setState(918);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_KEY) | (1L << K_DISTINCT) | (1L << K_COUNT) | (1L << K_TTL) | (1L << K_CAST))) != 0) || _la==K_WRITETIME || _la==K_JSON) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UnreservedFunctionKeywordContext extends ParserRuleContext {
		public BasicUnreservedKeywordContext basicUnreservedKeyword() {
			return getRuleContext(BasicUnreservedKeywordContext.class,0);
		}
		public NativeTypeContext nativeType() {
			return getRuleContext(NativeTypeContext.class,0);
		}
		public UnreservedFunctionKeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_unreservedFunctionKeyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterUnreservedFunctionKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitUnreservedFunctionKeyword(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitUnreservedFunctionKeyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UnreservedFunctionKeywordContext unreservedFunctionKeyword() throws RecognitionException {
		UnreservedFunctionKeywordContext _localctx = new UnreservedFunctionKeywordContext(_ctx, getState());
		enterRule(_localctx, 140, RULE_unreservedFunctionKeyword);
		try {
			setState(923);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case K_AS:
			case K_PER:
			case K_PARTITION:
			case K_VALUES:
			case K_TYPE:
			case K_FILTERING:
			case K_CONTAINS:
			case K_GROUP:
			case K_CLUSTERING:
			case K_EXISTS:
			case K_MAP:
			case K_LIST:
			case K_TUPLE:
			case K_FROZEN:
			case K_LIKE:
				enterOuterAlt(_localctx, 1);
				{
				setState(921);
				basicUnreservedKeyword();
				}
				break;
			case K_TIMESTAMP:
			case K_ASCII:
			case K_BIGINT:
			case K_BLOB:
			case K_BOOLEAN:
			case K_COUNTER:
			case K_DECIMAL:
			case K_DOUBLE:
			case K_DURATION:
			case K_FLOAT:
			case K_INET:
			case K_INT:
			case K_SMALLINT:
			case K_TINYINT:
			case K_TEXT:
			case K_UUID:
			case K_VARCHAR:
			case K_VARINT:
			case K_TIMEUUID:
			case K_DATE:
			case K_TIME:
				enterOuterAlt(_localctx, 2);
				{
				setState(922);
				nativeType();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BasicUnreservedKeywordContext extends ParserRuleContext {
		public TerminalNode K_AS() { return getToken(CqlParser.K_AS, 0); }
		public TerminalNode K_CLUSTERING() { return getToken(CqlParser.K_CLUSTERING, 0); }
		public TerminalNode K_TYPE() { return getToken(CqlParser.K_TYPE, 0); }
		public TerminalNode K_VALUES() { return getToken(CqlParser.K_VALUES, 0); }
		public TerminalNode K_MAP() { return getToken(CqlParser.K_MAP, 0); }
		public TerminalNode K_LIST() { return getToken(CqlParser.K_LIST, 0); }
		public TerminalNode K_FILTERING() { return getToken(CqlParser.K_FILTERING, 0); }
		public TerminalNode K_EXISTS() { return getToken(CqlParser.K_EXISTS, 0); }
		public TerminalNode K_CONTAINS() { return getToken(CqlParser.K_CONTAINS, 0); }
		public TerminalNode K_FROZEN() { return getToken(CqlParser.K_FROZEN, 0); }
		public TerminalNode K_TUPLE() { return getToken(CqlParser.K_TUPLE, 0); }
		public TerminalNode K_LIKE() { return getToken(CqlParser.K_LIKE, 0); }
		public TerminalNode K_PER() { return getToken(CqlParser.K_PER, 0); }
		public TerminalNode K_PARTITION() { return getToken(CqlParser.K_PARTITION, 0); }
		public TerminalNode K_GROUP() { return getToken(CqlParser.K_GROUP, 0); }
		public BasicUnreservedKeywordContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_basicUnreservedKeyword; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).enterBasicUnreservedKeyword(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof CqlListener ) ((CqlListener)listener).exitBasicUnreservedKeyword(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof CqlVisitor ) return ((CqlVisitor)visitor).visitBasicUnreservedKeyword(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BasicUnreservedKeywordContext basicUnreservedKeyword() throws RecognitionException {
		BasicUnreservedKeywordContext _localctx = new BasicUnreservedKeywordContext(_ctx, getState());
		enterRule(_localctx, 142, RULE_basicUnreservedKeyword);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(925);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_AS) | (1L << K_PER) | (1L << K_PARTITION) | (1L << K_VALUES) | (1L << K_TYPE) | (1L << K_FILTERING) | (1L << K_CONTAINS) | (1L << K_GROUP) | (1L << K_CLUSTERING))) != 0) || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (K_EXISTS - 85)) | (1L << (K_MAP - 85)) | (1L << (K_LIST - 85)) | (1L << (K_TUPLE - 85)) | (1L << (K_FROZEN - 85)) | (1L << (K_LIKE - 85)))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3q\u03a2\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
		"\tI\3\2\3\2\3\2\3\2\3\2\5\2\u0098\n\2\3\3\3\3\5\3\u009c\n\3\3\3\5\3\u009f"+
		"\n\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00a7\n\3\3\3\3\3\3\3\3\3\3\3\7\3\u00ae"+
		"\n\3\f\3\16\3\u00b1\13\3\5\3\u00b3\n\3\3\3\3\3\3\3\3\3\3\3\7\3\u00ba\n"+
		"\3\f\3\16\3\u00bd\13\3\5\3\u00bf\n\3\3\3\5\3\u00c2\n\3\3\3\5\3\u00c5\n"+
		"\3\3\3\3\3\5\3\u00c9\n\3\3\4\3\4\3\4\7\4\u00ce\n\4\f\4\16\4\u00d1\13\4"+
		"\3\4\5\4\u00d4\n\4\3\5\3\5\3\5\5\5\u00d9\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3"+
		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6"+
		"\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00fa\n\6\3\6\3\6\7\6\u00fe\n\6\f\6\16"+
		"\6\u0101\13\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u0109\n\7\f\7\16\7\u010c\13"+
		"\7\3\7\3\7\5\7\u0110\n\7\3\b\3\b\3\b\7\b\u0115\n\b\f\b\16\b\u0118\13\b"+
		"\3\t\3\t\5\t\u011c\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\5\13\u0126\n"+
		"\13\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17"+
		"\3\17\5\17\u0138\n\17\3\20\3\20\3\20\3\20\7\20\u013e\n\20\f\20\16\20\u0141"+
		"\13\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u0149\n\20\f\20\16\20\u014c"+
		"\13\20\3\20\3\20\3\20\3\20\5\20\u0152\n\20\3\20\5\20\u0155\n\20\3\21\3"+
		"\21\3\21\5\21\u015a\n\21\3\21\3\21\3\21\5\21\u015f\n\21\3\21\5\21\u0162"+
		"\n\21\3\22\3\22\3\22\3\22\5\22\u0168\n\22\3\23\3\23\3\23\3\23\7\23\u016e"+
		"\n\23\f\23\16\23\u0171\13\23\3\24\3\24\3\24\3\24\5\24\u0177\n\24\3\25"+
		"\3\25\3\25\5\25\u017c\n\25\3\25\3\25\3\25\3\25\7\25\u0182\n\25\f\25\16"+
		"\25\u0185\13\25\3\25\3\25\3\25\3\25\3\25\5\25\u018c\n\25\5\25\u018e\n"+
		"\25\3\26\3\26\3\26\7\26\u0193\n\26\f\26\16\26\u0196\13\26\3\27\3\27\5"+
		"\27\u019a\n\27\3\27\3\27\3\27\5\27\u019f\n\27\3\27\3\27\3\27\3\27\3\27"+
		"\5\27\u01a6\n\27\5\27\u01a8\n\27\3\30\3\30\3\30\7\30\u01ad\n\30\f\30\16"+
		"\30\u01b0\13\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31"+
		"\u01bc\n\31\3\32\3\32\3\32\3\32\3\33\3\33\5\33\u01c4\n\33\3\33\3\33\5"+
		"\33\u01c8\n\33\3\33\3\33\5\33\u01cc\n\33\7\33\u01ce\n\33\f\33\16\33\u01d1"+
		"\13\33\3\33\3\33\3\33\3\34\3\34\3\34\5\34\u01d9\n\34\3\35\3\35\3\35\5"+
		"\35\u01de\n\35\3\36\3\36\3\36\5\36\u01e3\n\36\3\37\3\37\3\37\5\37\u01e8"+
		"\n\37\3 \3 \3!\3!\3!\5!\u01ef\n!\3!\3!\3\"\3\"\3\"\5\"\u01f6\n\"\3\"\3"+
		"\"\3#\3#\3#\3#\5#\u01fe\n#\3$\3$\3$\3$\5$\u0204\n$\3%\3%\3%\3%\5%\u020a"+
		"\n%\3&\3&\3&\3&\3&\3&\3&\3&\5&\u0214\n&\3&\5&\u0217\n&\3\'\3\'\3\'\3\'"+
		"\3\'\3\'\3\'\7\'\u0220\n\'\f\'\16\'\u0223\13\'\3\'\3\'\7\'\u0227\n\'\f"+
		"\'\16\'\u022a\13\'\5\'\u022c\n\'\3(\3(\3(\3(\7(\u0232\n(\f(\16(\u0235"+
		"\13(\5(\u0237\n(\3(\3(\3(\3(\3(\3(\3(\3(\5(\u0241\n(\3)\3)\3)\3)\3)\3"+
		")\3)\3)\3)\7)\u024c\n)\f)\16)\u024f\13)\3)\3)\3*\3*\3*\3*\7*\u0257\n*"+
		"\f*\16*\u025a\13*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\5+\u0266\n+\3,\3,\3,\3"+
		",\5,\u026c\n,\3-\3-\3-\5-\u0271\n-\3-\3-\3.\3.\3.\3.\3.\5.\u027a\n.\3"+
		"/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u0285\n/\3\60\3\60\3\60\7\60\u028a\n\60\f"+
		"\60\16\60\u028d\13\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u0296\n"+
		"\61\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3"+
		"\63\3\63\5\63\u02a7\n\63\3\64\3\64\3\64\5\64\u02ac\n\64\3\64\3\64\3\64"+
		"\3\64\3\64\3\64\3\64\5\64\u02b5\n\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67"+
		"\3\67\3\67\38\38\38\38\38\38\38\58\u02c7\n8\38\38\38\38\38\38\38\38\3"+
		"8\58\u02d2\n8\58\u02d4\n8\38\38\38\38\38\38\38\38\58\u02de\n8\58\u02e0"+
		"\n8\58\u02e2\n8\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:"+
		"\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\5:\u0303\n:\3:\3:\3:\3:\3:\3:"+
		"\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\5:\u0319\n:\3:\3:\3:\3:\3:"+
		"\3:\5:\u0321\n:\3:\3:\3:\3:\5:\u0327\n:\3;\3;\3;\5;\u032c\n;\3<\3<\3<"+
		"\3<\7<\u0332\n<\f<\16<\u0335\13<\3<\3<\3=\3=\3=\3=\7=\u033d\n=\f=\16="+
		"\u0340\13=\5=\u0342\n=\3=\3=\3>\3>\3>\3>\7>\u034a\n>\f>\16>\u034d\13>"+
		"\3>\3>\3?\3?\3?\5?\u0354\n?\3@\3@\3@\3@\7@\u035a\n@\f@\16@\u035d\13@\3"+
		"@\3@\3A\3A\3A\5A\u0364\nA\3B\3B\3B\3B\3B\3B\3B\3B\3B\5B\u036f\nB\3C\3"+
		"C\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\3D\5D\u0384\nD\3E\3"+
		"E\3E\3E\3E\7E\u038b\nE\fE\16E\u038e\13E\3E\3E\3F\3F\3F\3F\5F\u0396\nF"+
		"\3G\3G\5G\u039a\nG\3H\3H\5H\u039e\nH\3I\3I\3I\2\2J\2\4\6\b\n\f\16\20\22"+
		"\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp"+
		"rtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\2\f\3\2"+
		"\65\66\4\2UU``\4\2((BB\3\2Z[\4\2\f\f\20\20\3\2\21\22\4\2\17\17\23\27\5"+
		"\2//>ORS\7\2\35\35$%\60\61QQ^^\13\2\32\32!\"..\62\6288;=WY\\]aa\2\u03fa"+
		"\2\u0097\3\2\2\2\4\u0099\3\2\2\2\6\u00d3\3\2\2\2\b\u00d5\3\2\2\2\n\u00f9"+
		"\3\2\2\2\f\u010f\3\2\2\2\16\u0111\3\2\2\2\20\u011b\3\2\2\2\22\u011d\3"+
		"\2\2\2\24\u0123\3\2\2\2\26\u0127\3\2\2\2\30\u0129\3\2\2\2\32\u012e\3\2"+
		"\2\2\34\u0131\3\2\2\2\36\u0139\3\2\2\2 \u0156\3\2\2\2\"\u0167\3\2\2\2"+
		"$\u0169\3\2\2\2&\u0176\3\2\2\2(\u0178\3\2\2\2*\u018f\3\2\2\2,\u0197\3"+
		"\2\2\2.\u01a9\3\2\2\2\60\u01bb\3\2\2\2\62\u01bd\3\2\2\2\64\u01c1\3\2\2"+
		"\2\66\u01d8\3\2\2\28\u01dd\3\2\2\2:\u01e2\3\2\2\2<\u01e7\3\2\2\2>\u01e9"+
		"\3\2\2\2@\u01ee\3\2\2\2B\u01f5\3\2\2\2D\u01fd\3\2\2\2F\u0203\3\2\2\2H"+
		"\u0209\3\2\2\2J\u0216\3\2\2\2L\u022b\3\2\2\2N\u0240\3\2\2\2P\u0242\3\2"+
		"\2\2R\u0252\3\2\2\2T\u0265\3\2\2\2V\u026b\3\2\2\2X\u0270\3\2\2\2Z\u0279"+
		"\3\2\2\2\\\u0284\3\2\2\2^\u0286\3\2\2\2`\u0295\3\2\2\2b\u0297\3\2\2\2"+
		"d\u02a6\3\2\2\2f\u02b4\3\2\2\2h\u02b6\3\2\2\2j\u02b9\3\2\2\2l\u02bc\3"+
		"\2\2\2n\u02bf\3\2\2\2p\u02e3\3\2\2\2r\u0326\3\2\2\2t\u032b\3\2\2\2v\u032d"+
		"\3\2\2\2x\u0338\3\2\2\2z\u0345\3\2\2\2|\u0353\3\2\2\2~\u0355\3\2\2\2\u0080"+
		"\u0363\3\2\2\2\u0082\u036e\3\2\2\2\u0084\u0370\3\2\2\2\u0086\u0383\3\2"+
		"\2\2\u0088\u0385\3\2\2\2\u008a\u0395\3\2\2\2\u008c\u0399\3\2\2\2\u008e"+
		"\u039d\3\2\2\2\u0090\u039f\3\2\2\2\u0092\u0098\5\4\3\2\u0093\u0098\5\34"+
		"\17\2\u0094\u0098\5(\25\2\u0095\u0098\5,\27\2\u0096\u0098\5\64\33\2\u0097"+
		"\u0092\3\2\2\2\u0097\u0093\3\2\2\2\u0097\u0094\3\2\2\2\u0097\u0095\3\2"+
		"\2\2\u0097\u0096\3\2\2\2\u0098\3\3\2\2\2\u0099\u009b\7\30\2\2\u009a\u009c"+
		"\7^\2\2\u009b\u009a\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009e\3\2\2\2\u009d"+
		"\u009f\7$\2\2\u009e\u009d\3\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\3\2"+
		"\2\2\u00a0\u00a1\5\6\4\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7\31\2\2\u00a3"+
		"\u00a6\5@!\2\u00a4\u00a5\7\33\2\2\u00a5\u00a7\5\16\b\2\u00a6\u00a4\3\2"+
		"\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00b2\3\2\2\2\u00a8\u00a9\7<\2\2\u00a9"+
		"\u00aa\7\64\2\2\u00aa\u00af\5\26\f\2\u00ab\u00ac\7\3\2\2\u00ac\u00ae\5"+
		"\26\f\2\u00ad\u00ab\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af\u00ad\3\2\2\2\u00af"+
		"\u00b0\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b2\u00a8\3\2"+
		"\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00be\3\2\2\2\u00b4\u00b5\7\63\2\2\u00b5"+
		"\u00b6\7\64\2\2\u00b6\u00bb\5\24\13\2\u00b7\u00b8\7\3\2\2\u00b8\u00ba"+
		"\5\24\13\2\u00b9\u00b7\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2"+
		"\u00bb\u00bc\3\2\2\2\u00bc\u00bf\3\2\2\2\u00bd\u00bb\3\2\2\2\u00be\u00b4"+
		"\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c1\3\2\2\2\u00c0\u00c2\5\30\r\2"+
		"\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c4\3\2\2\2\u00c3\u00c5"+
		"\5\32\16\2\u00c4\u00c3\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c8\3\2\2\2"+
		"\u00c6\u00c7\7\67\2\2\u00c7\u00c9\78\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c9"+
		"\3\2\2\2\u00c9\5\3\2\2\2\u00ca\u00cf\5\b\5\2\u00cb\u00cc\7\3\2\2\u00cc"+
		"\u00ce\5\b\5\2\u00cd\u00cb\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00cd\3\2"+
		"\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d4\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d2"+
		"\u00d4\7\4\2\2\u00d3\u00ca\3\2\2\2\u00d3\u00d2\3\2\2\2\u00d4\7\3\2\2\2"+
		"\u00d5\u00d8\5\n\6\2\u00d6\u00d7\7\32\2\2\u00d7\u00d9\5<\37\2\u00d8\u00d6"+
		"\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\t\3\2\2\2\u00da\u00fa\58\35\2\u00db"+
		"\u00fa\5T+\2\u00dc\u00dd\7\5\2\2\u00dd\u00de\5\u0082B\2\u00de\u00df\7"+
		"\6\2\2\u00df\u00e0\5T+\2\u00e0\u00fa\3\2\2\2\u00e1\u00e2\7%\2\2\u00e2"+
		"\u00e3\7\5\2\2\u00e3\u00e4\7\4\2\2\u00e4\u00fa\7\6\2\2\u00e5\u00e6\7Q"+
		"\2\2\u00e6\u00e7\7\5\2\2\u00e7\u00e8\58\35\2\u00e8\u00e9\7\6\2\2\u00e9"+
		"\u00fa\3\2\2\2\u00ea\u00eb\7\60\2\2\u00eb\u00ec\7\5\2\2\u00ec\u00ed\5"+
		"8\35\2\u00ed\u00ee\7\6\2\2\u00ee\u00fa\3\2\2\2\u00ef\u00f0\7\61\2\2\u00f0"+
		"\u00f1\7\5\2\2\u00f1\u00f2\5\n\6\2\u00f2\u00f3\7\32\2\2\u00f3\u00f4\5"+
		"\u0084C\2\u00f4\u00f5\7\6\2\2\u00f5\u00fa\3\2\2\2\u00f6\u00f7\5X-\2\u00f7"+
		"\u00f8\5\f\7\2\u00f8\u00fa\3\2\2\2\u00f9\u00da\3\2\2\2\u00f9\u00db\3\2"+
		"\2\2\u00f9\u00dc\3\2\2\2\u00f9\u00e1\3\2\2\2\u00f9\u00e5\3\2\2\2\u00f9"+
		"\u00ea\3\2\2\2\u00f9\u00ef\3\2\2\2\u00f9\u00f6\3\2\2\2\u00fa\u00ff\3\2"+
		"\2\2\u00fb\u00fc\7\7\2\2\u00fc\u00fe\5:\36\2\u00fd\u00fb\3\2\2\2\u00fe"+
		"\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\13\3\2\2"+
		"\2\u0101\u00ff\3\2\2\2\u0102\u0103\7\5\2\2\u0103\u0110\7\6\2\2\u0104\u0105"+
		"\7\5\2\2\u0105\u010a\5\n\6\2\u0106\u0107\7\3\2\2\u0107\u0109\5\n\6\2\u0108"+
		"\u0106\3\2\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2"+
		"\2\2\u010b\u010d\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u010e\7\6\2\2\u010e"+
		"\u0110\3\2\2\2\u010f\u0102\3\2\2\2\u010f\u0104\3\2\2\2\u0110\r\3\2\2\2"+
		"\u0111\u0116\5\20\t\2\u0112\u0113\7\34\2\2\u0113\u0115\5\20\t\2\u0114"+
		"\u0112\3\2\2\2\u0115\u0118\3\2\2\2\u0116\u0114\3\2\2\2\u0116\u0117\3\2"+
		"\2\2\u0117\17\3\2\2\2\u0118\u0116\3\2\2\2\u0119\u011c\5r:\2\u011a\u011c"+
		"\5\22\n\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2\2\2\u011c\21\3\2\2\2\u011d"+
		"\u011e\7\b\2\2\u011e\u011f\5H%\2\u011f\u0120\7\3\2\2\u0120\u0121\5`\61"+
		"\2\u0121\u0122\7\6\2\2\u0122\23\3\2\2\2\u0123\u0125\58\35\2\u0124\u0126"+
		"\t\2\2\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2\2\2\u0126\25\3\2\2\2\u0127"+
		"\u0128\58\35\2\u0128\27\3\2\2\2\u0129\u012a\7!\2\2\u012a\u012b\7\"\2\2"+
		"\u012b\u012c\7 \2\2\u012c\u012d\5V,\2\u012d\31\3\2\2\2\u012e\u012f\7 "+
		"\2\2\u012f\u0130\5V,\2\u0130\33\3\2\2\2\u0131\u0132\7\36\2\2\u0132\u0133"+
		"\7-\2\2\u0133\u0137\5@!\2\u0134\u0138\5\36\20\2\u0135\u0136\7^\2\2\u0136"+
		"\u0138\5 \21\2\u0137\u0134\3\2\2\2\u0137\u0135\3\2\2\2\u0138\35\3\2\2"+
		"\2\u0139\u013a\7\5\2\2\u013a\u013f\58\35\2\u013b\u013c\7\3\2\2\u013c\u013e"+
		"\58\35\2\u013d\u013b\3\2\2\2\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f"+
		"\u0140\3\2\2\2\u0140\u0142\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0143\7\6"+
		"\2\2\u0143\u0144\7.\2\2\u0144\u0145\7\5\2\2\u0145\u014a\5`\61\2\u0146"+
		"\u0147\7\3\2\2\u0147\u0149\5`\61\2\u0148\u0146\3\2\2\2\u0149\u014c\3\2"+
		"\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u014d\3\2\2\2\u014c"+
		"\u014a\3\2\2\2\u014d\u0151\7\6\2\2\u014e\u014f\79\2\2\u014f\u0150\7V\2"+
		"\2\u0150\u0152\7W\2\2\u0151\u014e\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154"+
		"\3\2\2\2\u0153\u0155\5$\23\2\u0154\u0153\3\2\2\2\u0154\u0155\3\2\2\2\u0155"+
		"\37\3\2\2\2\u0156\u0159\5\"\22\2\u0157\u0158\7_\2\2\u0158\u015a\t\3\2"+
		"\2\u0159\u0157\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015e\3\2\2\2\u015b\u015c"+
		"\79\2\2\u015c\u015d\7V\2\2\u015d\u015f\7W\2\2\u015e\u015b\3\2\2\2\u015e"+
		"\u015f\3\2\2\2\u015f\u0161\3\2\2\2\u0160\u0162\5$\23\2\u0161\u0160\3\2"+
		"\2\2\u0161\u0162\3\2\2\2\u0162!\3\2\2\2\u0163\u0168\7c\2\2\u0164\u0165"+
		"\7\t\2\2\u0165\u0168\5<\37\2\u0166\u0168\7g\2\2\u0167\u0163\3\2\2\2\u0167"+
		"\u0164\3\2\2\2\u0167\u0166\3\2\2\2\u0168#\3\2\2\2\u0169\u016a\7#\2\2\u016a"+
		"\u016f\5&\24\2\u016b\u016c\7\34\2\2\u016c\u016e\5&\24\2\u016d\u016b\3"+
		"\2\2\2\u016e\u0171\3\2\2\2\u016f\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170"+
		"%\3\2\2\2\u0171\u016f\3\2\2\2\u0172\u0173\7/\2\2\u0173\u0177\5V,\2\u0174"+
		"\u0175\7\60\2\2\u0175\u0177\5V,\2\u0176\u0172\3\2\2\2\u0176\u0174\3\2"+
		"\2\2\u0177\'\3\2\2\2\u0178\u0179\7\37\2\2\u0179\u017b\5@!\2\u017a\u017c"+
		"\5$\23\2\u017b\u017a\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017d\3\2\2\2\u017d"+
		"\u017e\7&\2\2\u017e\u0183\5b\62\2\u017f\u0180\7\3\2\2\u0180\u0182\5b\62"+
		"\2\u0181\u017f\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0183\u0184"+
		"\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0183\3\2\2\2\u0186\u0187\7\33\2\2"+
		"\u0187\u018d\5\16\b\2\u0188\u018b\79\2\2\u0189\u018c\7W\2\2\u018a\u018c"+
		"\5*\26\2\u018b\u0189\3\2\2\2\u018b\u018a\3\2\2\2\u018c\u018e\3\2\2\2\u018d"+
		"\u0188\3\2\2\2\u018d\u018e\3\2\2\2\u018e)\3\2\2\2\u018f\u0194\5n8\2\u0190"+
		"\u0191\7\34\2\2\u0191\u0193\5n8\2\u0192\u0190\3\2\2\2\u0193\u0196\3\2"+
		"\2\2\u0194\u0192\3\2\2\2\u0194\u0195\3\2\2\2\u0195+\3\2\2\2\u0196\u0194"+
		"\3\2\2\2\u0197\u0199\7+\2\2\u0198\u019a\5.\30\2\u0199\u0198\3\2\2\2\u0199"+
		"\u019a\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019c\7\31\2\2\u019c\u019e\5"+
		"@!\2\u019d\u019f\5\62\32\2\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f"+
		"\u01a0\3\2\2\2\u01a0\u01a1\7\33\2\2\u01a1\u01a7\5\16\b\2\u01a2\u01a5\7"+
		"9\2\2\u01a3\u01a6\7W\2\2\u01a4\u01a6\5*\26\2\u01a5\u01a3\3\2\2\2\u01a5"+
		"\u01a4\3\2\2\2\u01a6\u01a8\3\2\2\2\u01a7\u01a2\3\2\2\2\u01a7\u01a8\3\2"+
		"\2\2\u01a8-\3\2\2\2\u01a9\u01ae\5\60\31\2\u01aa\u01ab\7\3\2\2\u01ab\u01ad"+
		"\5\60\31\2\u01ac\u01aa\3\2\2\2\u01ad\u01b0\3\2\2\2\u01ae\u01ac\3\2\2\2"+
		"\u01ae\u01af\3\2\2\2\u01af/\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b1\u01bc\5"+
		"8\35\2\u01b2\u01b3\58\35\2\u01b3\u01b4\7\n\2\2\u01b4\u01b5\5`\61\2\u01b5"+
		"\u01b6\7\13\2\2\u01b6\u01bc\3\2\2\2\u01b7\u01b8\58\35\2\u01b8\u01b9\7"+
		"\7\2\2\u01b9\u01ba\5:\36\2\u01ba\u01bc\3\2\2\2\u01bb\u01b1\3\2\2\2\u01bb"+
		"\u01b2\3\2\2\2\u01bb\u01b7\3\2\2\2\u01bc\61\3\2\2\2\u01bd\u01be\7#\2\2"+
		"\u01be\u01bf\7/\2\2\u01bf\u01c0\5V,\2\u01c0\63\3\2\2\2\u01c1\u01c3\7\'"+
		"\2\2\u01c2\u01c4\t\4\2\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4"+
		"\u01c5\3\2\2\2\u01c5\u01c7\7)\2\2\u01c6\u01c8\5$\23\2\u01c7\u01c6\3\2"+
		"\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01cf\3\2\2\2\u01c9\u01cb\5\66\34\2\u01ca"+
		"\u01cc\7q\2\2\u01cb\u01ca\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01ce\3\2"+
		"\2\2\u01cd\u01c9\3\2\2\2\u01ce\u01d1\3\2\2\2\u01cf\u01cd\3\2\2\2\u01cf"+
		"\u01d0\3\2\2\2\u01d0\u01d2\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d2\u01d3\7*"+
		"\2\2\u01d3\u01d4\7)\2\2\u01d4\65\3\2\2\2\u01d5\u01d9\5\34\17\2\u01d6\u01d9"+
		"\5(\25\2\u01d7\u01d9\5,\27\2\u01d8\u01d5\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d8"+
		"\u01d7\3\2\2\2\u01d9\67\3\2\2\2\u01da\u01de\7k\2\2\u01db\u01de\7d\2\2"+
		"\u01dc\u01de\5\u008cG\2\u01dd\u01da\3\2\2\2\u01dd\u01db\3\2\2\2\u01dd"+
		"\u01dc\3\2\2\2\u01de9\3\2\2\2\u01df\u01e3\7k\2\2\u01e0\u01e3\7d\2\2\u01e1"+
		"\u01e3\5\u008cG\2\u01e2\u01df\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e1"+
		"\3\2\2\2\u01e3;\3\2\2\2\u01e4\u01e8\7k\2\2\u01e5\u01e8\7d\2\2\u01e6\u01e8"+
		"\5\u008cG\2\u01e7\u01e4\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e7\u01e6\3\2\2"+
		"\2\u01e8=\3\2\2\2\u01e9\u01ea\5D#\2\u01ea?\3\2\2\2\u01eb\u01ec\5D#\2\u01ec"+
		"\u01ed\7\7\2\2\u01ed\u01ef\3\2\2\2\u01ee\u01eb\3\2\2\2\u01ee\u01ef\3\2"+
		"\2\2\u01ef\u01f0\3\2\2\2\u01f0\u01f1\5F$\2\u01f1A\3\2\2\2\u01f2\u01f3"+
		"\5<\37\2\u01f3\u01f4\7\7\2\2\u01f4\u01f6\3\2\2\2\u01f5\u01f2\3\2\2\2\u01f5"+
		"\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u01f8\5\u008aF\2\u01f8C\3\2\2"+
		"\2\u01f9\u01fe\7k\2\2\u01fa\u01fe\7d\2\2\u01fb\u01fe\5\u008cG\2\u01fc"+
		"\u01fe\7g\2\2\u01fd\u01f9\3\2\2\2\u01fd\u01fa\3\2\2\2\u01fd\u01fb\3\2"+
		"\2\2\u01fd\u01fc\3\2\2\2\u01feE\3\2\2\2\u01ff\u0204\7k\2\2\u0200\u0204"+
		"\7d\2\2\u0201\u0204\5\u008cG\2\u0202\u0204\7g\2\2\u0203\u01ff\3\2\2\2"+
		"\u0203\u0200\3\2\2\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2\2\u0204G\3"+
		"\2\2\2\u0205\u020a\7k\2\2\u0206\u020a\7d\2\2\u0207\u020a\5\u008cG\2\u0208"+
		"\u020a\7g\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2"+
		"\2\2\u0209\u0208\3\2\2\2\u020aI\3\2\2\2\u020b\u0217\7c\2\2\u020c\u0217"+
		"\7f\2\2\u020d\u0217\7h\2\2\u020e\u0217\7i\2\2\u020f\u0217\7j\2\2\u0210"+
		"\u0217\7m\2\2\u0211\u0217\7l\2\2\u0212\u0214\7\f\2\2\u0213\u0212\3\2\2"+
		"\2\u0213\u0214\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0217\t\5\2\2\u0216\u020b"+
		"\3\2\2\2\u0216\u020c\3\2\2\2\u0216\u020d\3\2\2\2\u0216\u020e\3\2\2\2\u0216"+
		"\u020f\3\2\2\2\u0216\u0210\3\2\2\2\u0216\u0211\3\2\2\2\u0216\u0213\3\2"+
		"\2\2\u0217K\3\2\2\2\u0218\u0219\7\t\2\2\u0219\u0221\5`\61\2\u021a\u021b"+
		"\7\3\2\2\u021b\u021c\5`\61\2\u021c\u021d\7\t\2\2\u021d\u021e\5`\61\2\u021e"+
		"\u0220\3\2\2\2\u021f\u021a\3\2\2\2\u0220\u0223\3\2\2\2\u0221\u021f\3\2"+
		"\2\2\u0221\u0222\3\2\2\2\u0222\u022c\3\2\2\2\u0223\u0221\3\2\2\2\u0224"+
		"\u0225\7\3\2\2\u0225\u0227\5`\61\2\u0226\u0224\3\2\2\2\u0227\u022a\3\2"+
		"\2\2\u0228\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022c\3\2\2\2\u022a"+
		"\u0228\3\2\2\2\u022b\u0218\3\2\2\2\u022b\u0228\3\2\2\2\u022cM\3\2\2\2"+
		"\u022d\u0236\7\n\2\2\u022e\u0233\5`\61\2\u022f\u0230\7\3\2\2\u0230\u0232"+
		"\5`\61\2\u0231\u022f\3\2\2\2\u0232\u0235\3\2\2\2\u0233\u0231\3\2\2\2\u0233"+
		"\u0234\3\2\2\2\u0234\u0237\3\2\2\2\u0235\u0233\3\2\2\2\u0236\u022e\3\2"+
		"\2\2\u0236\u0237\3\2\2\2\u0237\u0238\3\2\2\2\u0238\u0241\7\13\2\2\u0239"+
		"\u023a\7\r\2\2\u023a\u023b\5`\61\2\u023b\u023c\5L\'\2\u023c\u023d\7\16"+
		"\2\2\u023d\u0241\3\2\2\2\u023e\u023f\7\r\2\2\u023f\u0241\7\16\2\2\u0240"+
		"\u022d\3\2\2\2\u0240\u0239\3\2\2\2\u0240\u023e\3\2\2\2\u0241O\3\2\2\2"+
		"\u0242\u0243\7\r\2\2\u0243\u0244\5:\36\2\u0244\u0245\7\t\2\2\u0245\u024d"+
		"\5`\61\2\u0246\u0247\7\3\2\2\u0247\u0248\5:\36\2\u0248\u0249\7\t\2\2\u0249"+
		"\u024a\5`\61\2\u024a\u024c\3\2\2\2\u024b\u0246\3\2\2\2\u024c\u024f\3\2"+
		"\2\2\u024d\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024e\u0250\3\2\2\2\u024f"+
		"\u024d\3\2\2\2\u0250\u0251\7\16\2\2\u0251Q\3\2\2\2\u0252\u0253\7\5\2\2"+
		"\u0253\u0258\5`\61\2\u0254\u0255\7\3\2\2\u0255\u0257\5`\61\2\u0256\u0254"+
		"\3\2\2\2\u0257\u025a\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0259\3\2\2\2\u0259"+
		"\u025b\3\2\2\2\u025a\u0258\3\2\2\2\u025b\u025c\7\6\2\2\u025cS\3\2\2\2"+
		"\u025d\u0266\5J&\2\u025e\u0266\5N(\2\u025f\u0266\5P)\2\u0260\u0266\5R"+
		"*\2\u0261\u0266\7U\2\2\u0262\u0263\7\t\2\2\u0263\u0266\5<\37\2\u0264\u0266"+
		"\7g\2\2\u0265\u025d\3\2\2\2\u0265\u025e\3\2\2\2\u0265\u025f\3\2\2\2\u0265"+
		"\u0260\3\2\2\2\u0265\u0261\3\2\2\2\u0265\u0262\3\2\2\2\u0265\u0264\3\2"+
		"\2\2\u0266U\3\2\2\2\u0267\u026c\7f\2\2\u0268\u0269\7\t\2\2\u0269\u026c"+
		"\5<\37\2\u026a\u026c\7g\2\2\u026b\u0267\3\2\2\2\u026b\u0268\3\2\2\2\u026b"+
		"\u026a\3\2\2\2\u026cW\3\2\2\2\u026d\u026e\5> \2\u026e\u026f\7\7\2\2\u026f"+
		"\u0271\3\2\2\2\u0270\u026d\3\2\2\2\u0270\u0271\3\2\2\2\u0271\u0272\3\2"+
		"\2\2\u0272\u0273\5Z.\2\u0273Y\3\2\2\2\u0274\u027a\7k\2\2\u0275\u027a\7"+
		"d\2\2\u0276\u027a\5\u008eH\2\u0277\u027a\7P\2\2\u0278\u027a\7%\2\2\u0279"+
		"\u0274\3\2\2\2\u0279\u0275\3\2\2\2\u0279\u0276\3\2\2\2\u0279\u0277\3\2"+
		"\2\2\u0279\u0278\3\2\2\2\u027a[\3\2\2\2\u027b\u027c\5X-\2\u027c\u027d"+
		"\7\5\2\2\u027d\u027e\7\6\2\2\u027e\u0285\3\2\2\2\u027f\u0280\5X-\2\u0280"+
		"\u0281\7\5\2\2\u0281\u0282\5^\60\2\u0282\u0283\7\6\2\2\u0283\u0285\3\2"+
		"\2\2\u0284\u027b\3\2\2\2\u0284\u027f\3\2\2\2\u0285]\3\2\2\2\u0286\u028b"+
		"\5`\61\2\u0287\u0288\7\3\2\2\u0288\u028a\5`\61\2\u0289\u0287\3\2\2\2\u028a"+
		"\u028d\3\2\2\2\u028b\u0289\3\2\2\2\u028b\u028c\3\2\2\2\u028c_\3\2\2\2"+
		"\u028d\u028b\3\2\2\2\u028e\u0296\5T+\2\u028f\u0296\5\\/\2\u0290\u0291"+
		"\7\5\2\2\u0291\u0292\5\u0082B\2\u0292\u0293\7\6\2\2\u0293\u0294\5`\61"+
		"\2\u0294\u0296\3\2\2\2\u0295\u028e\3\2\2\2\u0295\u028f\3\2\2\2\u0295\u0290"+
		"\3\2\2\2\u0296a\3\2\2\2\u0297\u0298\58\35\2\u0298\u0299\5d\63\2\u0299"+
		"c\3\2\2\2\u029a\u029b\7\17\2\2\u029b\u02a7\5f\64\2\u029c\u02a7\5h\65\2"+
		"\u029d\u029e\7\n\2\2\u029e\u029f\5`\61\2\u029f\u02a0\7\13\2\2\u02a0\u02a1"+
		"\5j\66\2\u02a1\u02a7\3\2\2\2\u02a2\u02a3\7\7\2\2\u02a3\u02a4\5:\36\2\u02a4"+
		"\u02a5\5l\67\2\u02a5\u02a7\3\2\2\2\u02a6\u029a\3\2\2\2\u02a6\u029c\3\2"+
		"\2\2\u02a6\u029d\3\2\2\2\u02a6\u02a2\3\2\2\2\u02a7e\3\2\2\2\u02a8\u02ab"+
		"\5`\61\2\u02a9\u02aa\7\20\2\2\u02aa\u02ac\58\35\2\u02ab\u02a9\3\2\2\2"+
		"\u02ab\u02ac\3\2\2\2\u02ac\u02b5\3\2\2\2\u02ad\u02ae\58\35\2\u02ae\u02af"+
		"\t\6\2\2\u02af\u02b0\5`\61\2\u02b0\u02b5\3\2\2\2\u02b1\u02b2\58\35\2\u02b2"+
		"\u02b3\7f\2\2\u02b3\u02b5\3\2\2\2\u02b4\u02a8\3\2\2\2\u02b4\u02ad\3\2"+
		"\2\2\u02b4\u02b1\3\2\2\2\u02b5g\3\2\2\2\u02b6\u02b7\t\7\2\2\u02b7\u02b8"+
		"\5`\61\2\u02b8i\3\2\2\2\u02b9\u02ba\7\17\2\2\u02ba\u02bb\5`\61\2\u02bb"+
		"k\3\2\2\2\u02bc\u02bd\7\17\2\2\u02bd\u02be\5`\61\2\u02bem\3\2\2\2\u02bf"+
		"\u02e1\58\35\2\u02c0\u02c1\5p9\2\u02c1\u02c2\5`\61\2\u02c2\u02e2\3\2\2"+
		"\2\u02c3\u02c6\7,\2\2\u02c4\u02c7\5x=\2\u02c5\u02c7\5t;\2\u02c6\u02c4"+
		"\3\2\2\2\u02c6\u02c5\3\2\2\2\u02c7\u02e2\3\2\2\2\u02c8\u02c9\7\n\2\2\u02c9"+
		"\u02ca\5`\61\2\u02ca\u02d3\7\13\2\2\u02cb\u02cc\5p9\2\u02cc\u02cd\5`\61"+
		"\2\u02cd\u02d4\3\2\2\2\u02ce\u02d1\7,\2\2\u02cf\u02d2\5x=\2\u02d0\u02d2"+
		"\5t;\2\u02d1\u02cf\3\2\2\2\u02d1\u02d0\3\2\2\2\u02d2\u02d4\3\2\2\2\u02d3"+
		"\u02cb\3\2\2\2\u02d3\u02ce\3\2\2\2\u02d4\u02e2\3\2\2\2\u02d5\u02d6\7\7"+
		"\2\2\u02d6\u02df\5:\36\2\u02d7\u02d8\5p9\2\u02d8\u02d9\5`\61\2\u02d9\u02e0"+
		"\3\2\2\2\u02da\u02dd\7,\2\2\u02db\u02de\5x=\2\u02dc\u02de\5t;\2\u02dd"+
		"\u02db\3\2\2\2\u02dd\u02dc\3\2\2\2\u02de\u02e0\3\2\2\2\u02df\u02d7\3\2"+
		"\2\2\u02df\u02da\3\2\2\2\u02e0\u02e2\3\2\2\2\u02e1\u02c0\3\2\2\2\u02e1"+
		"\u02c3\3\2\2\2\u02e1\u02c8\3\2\2\2\u02e1\u02d5\3\2\2\2\u02e2o\3\2\2\2"+
		"\u02e3\u02e4\t\b\2\2\u02e4q\3\2\2\2\u02e5\u02e6\58\35\2\u02e6\u02e7\5"+
		"p9\2\u02e7\u02e8\5`\61\2\u02e8\u0327\3\2\2\2\u02e9\u02ea\58\35\2\u02ea"+
		"\u02eb\7a\2\2\u02eb\u02ec\5`\61\2\u02ec\u0327\3\2\2\2\u02ed\u02ee\58\35"+
		"\2\u02ee\u02ef\7:\2\2\u02ef\u02f0\7V\2\2\u02f0\u02f1\7U\2\2\u02f1\u0327"+
		"\3\2\2\2\u02f2\u02f3\7P\2\2\u02f3\u02f4\5v<\2\u02f4\u02f5\5p9\2\u02f5"+
		"\u02f6\5`\61\2\u02f6\u0327\3\2\2\2\u02f7\u02f8\58\35\2\u02f8\u02f9\7,"+
		"\2\2\u02f9\u02fa\5t;\2\u02fa\u0327\3\2\2\2\u02fb\u02fc\58\35\2\u02fc\u02fd"+
		"\7,\2\2\u02fd\u02fe\5x=\2\u02fe\u0327\3\2\2\2\u02ff\u0300\58\35\2\u0300"+
		"\u0302\7;\2\2\u0301\u0303\7\35\2\2\u0302\u0301\3\2\2\2\u0302\u0303\3\2"+
		"\2\2\u0303\u0304\3\2\2\2\u0304\u0305\5`\61\2\u0305\u0327\3\2\2\2\u0306"+
		"\u0307\58\35\2\u0307\u0308\7\n\2\2\u0308\u0309\5`\61\2\u0309\u030a\7\13"+
		"\2\2\u030a\u030b\5p9\2\u030b\u030c\5`\61\2\u030c\u0327\3\2\2\2\u030d\u030e"+
		"\58\35\2\u030e\u030f\7b\2\2\u030f\u0310\5`\61\2\u0310\u0327\3\2\2\2\u0311"+
		"\u0320\5v<\2\u0312\u0318\7,\2\2\u0313\u0314\7\5\2\2\u0314\u0319\7\6\2"+
		"\2\u0315\u0319\5\u0080A\2\u0316\u0319\5z>\2\u0317\u0319\5~@\2\u0318\u0313"+
		"\3\2\2\2\u0318\u0315\3\2\2\2\u0318\u0316\3\2\2\2\u0318\u0317\3\2\2\2\u0319"+
		"\u0321\3\2\2\2\u031a\u031b\5p9\2\u031b\u031c\5R*\2\u031c\u0321\3\2\2\2"+
		"\u031d\u031e\5p9\2\u031e\u031f\5|?\2\u031f\u0321\3\2\2\2\u0320\u0312\3"+
		"\2\2\2\u0320\u031a\3\2\2\2\u0320\u031d\3\2\2\2\u0321\u0327\3\2\2\2\u0322"+
		"\u0323\7\5\2\2\u0323\u0324\5r:\2\u0324\u0325\7\6\2\2\u0325\u0327\3\2\2"+
		"\2\u0326\u02e5\3\2\2\2\u0326\u02e9\3\2\2\2\u0326\u02ed\3\2\2\2\u0326\u02f2"+
		"\3\2\2\2\u0326\u02f7\3\2\2\2\u0326\u02fb\3\2\2\2\u0326\u02ff\3\2\2\2\u0326"+
		"\u0306\3\2\2\2\u0326\u030d\3\2\2\2\u0326\u0311\3\2\2\2\u0326\u0322\3\2"+
		"\2\2\u0327s\3\2\2\2\u0328\u032c\7g\2\2\u0329\u032a\7\t\2\2\u032a\u032c"+
		"\5<\37\2\u032b\u0328\3\2\2\2\u032b\u0329\3\2\2\2\u032cu\3\2\2\2\u032d"+
		"\u032e\7\5\2\2\u032e\u0333\58\35\2\u032f\u0330\7\3\2\2\u0330\u0332\58"+
		"\35\2\u0331\u032f\3\2\2\2\u0332\u0335\3\2\2\2\u0333\u0331\3\2\2\2\u0333"+
		"\u0334\3\2\2\2\u0334\u0336\3\2\2\2\u0335\u0333\3\2\2\2\u0336\u0337\7\6"+
		"\2\2\u0337w\3\2\2\2\u0338\u0341\7\5\2\2\u0339\u033e\5`\61\2\u033a\u033b"+
		"\7\3\2\2\u033b\u033d\5`\61\2\u033c\u033a\3\2\2\2\u033d\u0340\3\2\2\2\u033e"+
		"\u033c\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u0342\3\2\2\2\u0340\u033e\3\2"+
		"\2\2\u0341\u0339\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2\u0343"+
		"\u0344\7\6\2\2\u0344y\3\2\2\2\u0345\u0346\7\5\2\2\u0346\u034b\5R*\2\u0347"+
		"\u0348\7\3\2\2\u0348\u034a\5R*\2\u0349\u0347\3\2\2\2\u034a\u034d\3\2\2"+
		"\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u034e\3\2\2\2\u034d\u034b"+
		"\3\2\2\2\u034e\u034f\7\6\2\2\u034f{\3\2\2\2\u0350\u0354\7g\2\2\u0351\u0352"+
		"\7\t\2\2\u0352\u0354\5<\37\2\u0353\u0350\3\2\2\2\u0353\u0351\3\2\2\2\u0354"+
		"}\3\2\2\2\u0355\u0356\7\5\2\2\u0356\u035b\5|?\2\u0357\u0358\7\3\2\2\u0358"+
		"\u035a\5|?\2\u0359\u0357\3\2\2\2\u035a\u035d\3\2\2\2\u035b\u0359\3\2\2"+
		"\2\u035b\u035c\3\2\2\2\u035c\u035e\3\2\2\2\u035d\u035b\3\2\2\2\u035e\u035f"+
		"\7\6\2\2\u035f\177\3\2\2\2\u0360\u0364\7g\2\2\u0361\u0362\7\t\2\2\u0362"+
		"\u0364\5<\37\2\u0363\u0360\3\2\2\2\u0363\u0361\3\2\2\2\u0364\u0081\3\2"+
		"\2\2\u0365\u036f\5\u0084C\2\u0366\u036f\5\u0086D\2\u0367\u036f\5\u0088"+
		"E\2\u0368\u036f\5B\"\2\u0369\u036a\7]\2\2\u036a\u036b\7\23\2\2\u036b\u036c"+
		"\5\u0082B\2\u036c\u036d\7\25\2\2\u036d\u036f\3\2\2\2\u036e\u0365\3\2\2"+
		"\2\u036e\u0366\3\2\2\2\u036e\u0367\3\2\2\2\u036e\u0368\3\2\2\2\u036e\u0369"+
		"\3\2\2\2\u036f\u0083\3\2\2\2\u0370\u0371\t\t\2\2\u0371\u0085\3\2\2\2\u0372"+
		"\u0373\7X\2\2\u0373\u0374\7\23\2\2\u0374\u0375\5\u0082B\2\u0375\u0376"+
		"\7\3\2\2\u0376\u0377\5\u0082B\2\u0377\u0378\7\25\2\2\u0378\u0384\3\2\2"+
		"\2\u0379\u037a\7Y\2\2\u037a\u037b\7\23\2\2\u037b\u037c\5\u0082B\2\u037c"+
		"\u037d\7\25\2\2\u037d\u0384\3\2\2\2\u037e\u037f\7&\2\2\u037f\u0380\7\23"+
		"\2\2\u0380\u0381\5\u0082B\2\u0381\u0382\7\25\2\2\u0382\u0384\3\2\2\2\u0383"+
		"\u0372\3\2\2\2\u0383\u0379\3\2\2\2\u0383\u037e\3\2\2\2\u0384\u0087\3\2"+
		"\2\2\u0385\u0386\7\\\2\2\u0386\u0387\7\23\2\2\u0387\u038c\5\u0082B\2\u0388"+
		"\u0389\7\3\2\2\u0389\u038b\5\u0082B\2\u038a\u0388\3\2\2\2\u038b\u038e"+
		"\3\2\2\2\u038c\u038a\3\2\2\2\u038c\u038d\3\2\2\2\u038d\u038f\3\2\2\2\u038e"+
		"\u038c\3\2\2\2\u038f\u0390\7\25\2\2\u0390\u0089\3\2\2\2\u0391\u0396\7"+
		"k\2\2\u0392\u0396\7d\2\2\u0393\u0396\5\u0090I\2\u0394\u0396\7\35\2\2\u0395"+
		"\u0391\3\2\2\2\u0395\u0392\3\2\2\2\u0395\u0393\3\2\2\2\u0395\u0394\3\2"+
		"\2\2\u0396\u008b\3\2\2\2\u0397\u039a\5\u008eH\2\u0398\u039a\t\n\2\2\u0399"+
		"\u0397\3\2\2\2\u0399\u0398\3\2\2\2\u039a\u008d\3\2\2\2\u039b\u039e\5\u0090"+
		"I\2\u039c\u039e\5\u0084C\2\u039d\u039b\3\2\2\2\u039d\u039c\3\2\2\2\u039e"+
		"\u008f\3\2\2\2\u039f\u03a0\t\13\2\2\u03a0\u0091\3\2\2\2f\u0097\u009b\u009e"+
		"\u00a6\u00af\u00b2\u00bb\u00be\u00c1\u00c4\u00c8\u00cf\u00d3\u00d8\u00f9"+
		"\u00ff\u010a\u010f\u0116\u011b\u0125\u0137\u013f\u014a\u0151\u0154\u0159"+
		"\u015e\u0161\u0167\u016f\u0176\u017b\u0183\u018b\u018d\u0194\u0199\u019e"+
		"\u01a5\u01a7\u01ae\u01bb\u01c3\u01c7\u01cb\u01cf\u01d8\u01dd\u01e2\u01e7"+
		"\u01ee\u01f5\u01fd\u0203\u0209\u0213\u0216\u0221\u0228\u022b\u0233\u0236"+
		"\u0240\u024d\u0258\u0265\u026b\u0270\u0279\u0284\u028b\u0295\u02a6\u02ab"+
		"\u02b4\u02c6\u02d1\u02d3\u02dd\u02df\u02e1\u0302\u0318\u0320\u0326\u032b"+
		"\u0333\u033e\u0341\u034b\u0353\u035b\u0363\u036e\u0383\u038c\u0395\u0399"+
		"\u039d";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}