• Home
• com.distkv
• dst-parser
• 0.1.2
• source code
• DstNewSQLParser.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.distkv.dst.parser.generated.DstNewSQLParser Maven / Gradle / Ivy

// Generated from DstNewSQL.g4 by ANTLR 4.7

package com.distkv.dst.parser.generated;

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 DstNewSQLParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7", 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, T__21=22, T__22=23, T__23=24, 
		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
		NEGATIVE_INT=32, POSITIVE_INT=33, ZERO=34, STRING=35, WS=36;
	public static final int
		RULE_statement = 0, RULE_conceptStatement = 1, RULE_strStatement = 2, 
		RULE_strPut = 3, RULE_strGet = 4, RULE_strDrop = 5, RULE_listStatement = 6, 
		RULE_listPut = 7, RULE_listLput = 8, RULE_listRput = 9, RULE_listGet = 10, 
		RULE_listRemove = 11, RULE_listMRemove = 12, RULE_listDrop = 13, RULE_listGetAll = 14, 
		RULE_listGetOne = 15, RULE_listGetRange = 16, RULE_listRemoveOne = 17, 
		RULE_listRemoveRange = 18, RULE_setStatement = 19, RULE_setPut = 20, RULE_setGet = 21, 
		RULE_setPutItem = 22, RULE_setRemoveItem = 23, RULE_setExists = 24, RULE_setDrop = 25, 
		RULE_dictStatement = 26, RULE_dictPut = 27, RULE_dictGet = 28, RULE_dictPutItem = 29, 
		RULE_dictGetItem = 30, RULE_dictPopItem = 31, RULE_dictRemoveItem = 32, 
		RULE_dictDrop = 33, RULE_slistStatement = 34, RULE_slistPut = 35, RULE_slistTop = 36, 
		RULE_slistIncrScore = 37, RULE_slistPutMember = 38, RULE_slistRemoveMember = 39, 
		RULE_slistDrop = 40, RULE_slistGetMember = 41, RULE_slistIncrScoreDefault = 42, 
		RULE_slistIncrScoreDelta = 43, RULE_keyValuePairs = 44, RULE_keyValuePair = 45, 
		RULE_itemKey = 46, RULE_itemValue = 47, RULE_sortedListEntityPairs = 48, 
		RULE_sortedListEntity = 49, RULE_itemMember = 50, RULE_itemScore = 51, 
		RULE_topCount = 52, RULE_key = 53, RULE_value = 54, RULE_valueArray = 55, 
		RULE_index = 56, RULE_anyInt = 57;
	public static final String[] ruleNames = {
		"statement", "conceptStatement", "strStatement", "strPut", "strGet", "strDrop", 
		"listStatement", "listPut", "listLput", "listRput", "listGet", "listRemove", 
		"listMRemove", "listDrop", "listGetAll", "listGetOne", "listGetRange", 
		"listRemoveOne", "listRemoveRange", "setStatement", "setPut", "setGet", 
		"setPutItem", "setRemoveItem", "setExists", "setDrop", "dictStatement", 
		"dictPut", "dictGet", "dictPutItem", "dictGetItem", "dictPopItem", "dictRemoveItem", 
		"dictDrop", "slistStatement", "slistPut", "slistTop", "slistIncrScore", 
		"slistPutMember", "slistRemoveMember", "slistDrop", "slistGetMember", 
		"slistIncrScoreDefault", "slistIncrScoreDelta", "keyValuePairs", "keyValuePair", 
		"itemKey", "itemValue", "sortedListEntityPairs", "sortedListEntity", "itemMember", 
		"itemScore", "topCount", "key", "value", "valueArray", "index", "anyInt"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'str.put'", "'str.get'", "'str.drop'", "'list.put'", "'list.lput'", 
		"'list.rput'", "'list.get'", "'list.remove'", "'list.mremove'", "'list.drop'", 
		"'set.put'", "'set.get'", "'set.putItem'", "'set.remove'", "'set.removeItem'", 
		"'set.exists'", "'set.drop'", "'dict.put'", "'dict.get'", "'dict.putItem'", 
		"'dict.getItem'", "'dict.popItem'", "'dict.removeItem'", "'dict.drop'", 
		"'slist.put'", "'slist.top'", "'slist.incrScore'", "'slist.putMember'", 
		"'slist.removeMember'", "'slist.drop'", "'slist.getMember'", null, null, 
		"'0'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		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, "NEGATIVE_INT", "POSITIVE_INT", 
		"ZERO", "STRING", "WS"
	};
	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 "DstNewSQL.g4"; }

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

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

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

	public DstNewSQLParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class StatementContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(DstNewSQLParser.EOF, 0); }
		public ConceptStatementContext conceptStatement() {
			return getRuleContext(ConceptStatementContext.class,0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_statement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(116);
			conceptStatement();
			}
			setState(117);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConceptStatementContext extends ParserRuleContext {
		public StrStatementContext strStatement() {
			return getRuleContext(StrStatementContext.class,0);
		}
		public ListStatementContext listStatement() {
			return getRuleContext(ListStatementContext.class,0);
		}
		public SetStatementContext setStatement() {
			return getRuleContext(SetStatementContext.class,0);
		}
		public DictStatementContext dictStatement() {
			return getRuleContext(DictStatementContext.class,0);
		}
		public SlistStatementContext slistStatement() {
			return getRuleContext(SlistStatementContext.class,0);
		}
		public ConceptStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conceptStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterConceptStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitConceptStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitConceptStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConceptStatementContext conceptStatement() throws RecognitionException {
		ConceptStatementContext _localctx = new ConceptStatementContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_conceptStatement);
		try {
			setState(124);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__0:
			case T__1:
			case T__2:
				enterOuterAlt(_localctx, 1);
				{
				setState(119);
				strStatement();
				}
				break;
			case T__3:
			case T__4:
			case T__5:
			case T__6:
			case T__7:
			case T__8:
			case T__9:
				enterOuterAlt(_localctx, 2);
				{
				setState(120);
				listStatement();
				}
				break;
			case T__10:
			case T__11:
			case T__12:
			case T__13:
			case T__14:
			case T__15:
			case T__16:
				enterOuterAlt(_localctx, 3);
				{
				setState(121);
				setStatement();
				}
				break;
			case T__17:
			case T__18:
			case T__19:
			case T__20:
			case T__21:
			case T__22:
			case T__23:
				enterOuterAlt(_localctx, 4);
				{
				setState(122);
				dictStatement();
				}
				break;
			case T__24:
			case T__25:
			case T__26:
			case T__27:
			case T__28:
			case T__29:
			case T__30:
				enterOuterAlt(_localctx, 5);
				{
				setState(123);
				slistStatement();
				}
				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 StrStatementContext extends ParserRuleContext {
		public StrPutContext strPut() {
			return getRuleContext(StrPutContext.class,0);
		}
		public StrGetContext strGet() {
			return getRuleContext(StrGetContext.class,0);
		}
		public StrDropContext strDrop() {
			return getRuleContext(StrDropContext.class,0);
		}
		public StrStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_strStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterStrStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitStrStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitStrStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StrStatementContext strStatement() throws RecognitionException {
		StrStatementContext _localctx = new StrStatementContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_strStatement);
		try {
			setState(129);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__0:
				enterOuterAlt(_localctx, 1);
				{
				setState(126);
				strPut();
				}
				break;
			case T__1:
				enterOuterAlt(_localctx, 2);
				{
				setState(127);
				strGet();
				}
				break;
			case T__2:
				enterOuterAlt(_localctx, 3);
				{
				setState(128);
				strDrop();
				}
				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 StrPutContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ValueContext value() {
			return getRuleContext(ValueContext.class,0);
		}
		public StrPutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_strPut; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterStrPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitStrPut(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitStrPut(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StrPutContext strPut() throws RecognitionException {
		StrPutContext _localctx = new StrPutContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_strPut);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(131);
			match(T__0);
			setState(132);
			key();
			setState(133);
			value();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StrGetContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public StrGetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_strGet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterStrGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitStrGet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitStrGet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StrGetContext strGet() throws RecognitionException {
		StrGetContext _localctx = new StrGetContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_strGet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(135);
			match(T__1);
			setState(136);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StrDropContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public StrDropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_strDrop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterStrDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitStrDrop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitStrDrop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StrDropContext strDrop() throws RecognitionException {
		StrDropContext _localctx = new StrDropContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_strDrop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(138);
			match(T__2);
			setState(139);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListStatementContext extends ParserRuleContext {
		public ListPutContext listPut() {
			return getRuleContext(ListPutContext.class,0);
		}
		public ListLputContext listLput() {
			return getRuleContext(ListLputContext.class,0);
		}
		public ListRputContext listRput() {
			return getRuleContext(ListRputContext.class,0);
		}
		public ListGetContext listGet() {
			return getRuleContext(ListGetContext.class,0);
		}
		public ListRemoveContext listRemove() {
			return getRuleContext(ListRemoveContext.class,0);
		}
		public ListMRemoveContext listMRemove() {
			return getRuleContext(ListMRemoveContext.class,0);
		}
		public ListDropContext listDrop() {
			return getRuleContext(ListDropContext.class,0);
		}
		public ListStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListStatementContext listStatement() throws RecognitionException {
		ListStatementContext _localctx = new ListStatementContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_listStatement);
		try {
			setState(148);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__3:
				enterOuterAlt(_localctx, 1);
				{
				setState(141);
				listPut();
				}
				break;
			case T__4:
				enterOuterAlt(_localctx, 2);
				{
				setState(142);
				listLput();
				}
				break;
			case T__5:
				enterOuterAlt(_localctx, 3);
				{
				setState(143);
				listRput();
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 4);
				{
				setState(144);
				listGet();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 5);
				{
				setState(145);
				listRemove();
				}
				break;
			case T__8:
				enterOuterAlt(_localctx, 6);
				{
				setState(146);
				listMRemove();
				}
				break;
			case T__9:
				enterOuterAlt(_localctx, 7);
				{
				setState(147);
				listDrop();
				}
				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 ListPutContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ValueArrayContext valueArray() {
			return getRuleContext(ValueArrayContext.class,0);
		}
		public ListPutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listPut; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListPut(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListPut(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListPutContext listPut() throws RecognitionException {
		ListPutContext _localctx = new ListPutContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_listPut);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(150);
			match(T__3);
			setState(151);
			key();
			setState(152);
			valueArray();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListLputContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ValueArrayContext valueArray() {
			return getRuleContext(ValueArrayContext.class,0);
		}
		public ListLputContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listLput; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListLput(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListLput(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListLput(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListLputContext listLput() throws RecognitionException {
		ListLputContext _localctx = new ListLputContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_listLput);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(154);
			match(T__4);
			setState(155);
			key();
			setState(156);
			valueArray();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListRputContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ValueArrayContext valueArray() {
			return getRuleContext(ValueArrayContext.class,0);
		}
		public ListRputContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listRput; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListRput(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListRput(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListRput(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListRputContext listRput() throws RecognitionException {
		ListRputContext _localctx = new ListRputContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_listRput);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(158);
			match(T__5);
			setState(159);
			key();
			setState(160);
			valueArray();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListGetContext extends ParserRuleContext {
		public ListGetAllContext listGetAll() {
			return getRuleContext(ListGetAllContext.class,0);
		}
		public ListGetOneContext listGetOne() {
			return getRuleContext(ListGetOneContext.class,0);
		}
		public ListGetRangeContext listGetRange() {
			return getRuleContext(ListGetRangeContext.class,0);
		}
		public ListGetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listGet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListGet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListGet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListGetContext listGet() throws RecognitionException {
		ListGetContext _localctx = new ListGetContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_listGet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(162);
			match(T__6);
			setState(166);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				{
				setState(163);
				listGetAll();
				}
				break;
			case 2:
				{
				setState(164);
				listGetOne();
				}
				break;
			case 3:
				{
				setState(165);
				listGetRange();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListRemoveContext extends ParserRuleContext {
		public ListRemoveOneContext listRemoveOne() {
			return getRuleContext(ListRemoveOneContext.class,0);
		}
		public ListRemoveRangeContext listRemoveRange() {
			return getRuleContext(ListRemoveRangeContext.class,0);
		}
		public ListRemoveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listRemove; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListRemove(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListRemove(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListRemove(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListRemoveContext listRemove() throws RecognitionException {
		ListRemoveContext _localctx = new ListRemoveContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_listRemove);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(168);
			match(T__7);
			setState(171);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
			case 1:
				{
				setState(169);
				listRemoveOne();
				}
				break;
			case 2:
				{
				setState(170);
				listRemoveRange();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListMRemoveContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public List index() {
			return getRuleContexts(IndexContext.class);
		}
		public IndexContext index(int i) {
			return getRuleContext(IndexContext.class,i);
		}
		public ListMRemoveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listMRemove; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListMRemove(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListMRemove(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListMRemove(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListMRemoveContext listMRemove() throws RecognitionException {
		ListMRemoveContext _localctx = new ListMRemoveContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_listMRemove);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(173);
			match(T__8);
			setState(174);
			key();
			setState(176); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(175);
				index();
				}
				}
				setState(178); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==POSITIVE_INT || _la==ZERO );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListDropContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ListDropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listDrop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListDrop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListDrop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListDropContext listDrop() throws RecognitionException {
		ListDropContext _localctx = new ListDropContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_listDrop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(180);
			match(T__9);
			setState(181);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListGetAllContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ListGetAllContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listGetAll; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListGetAll(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListGetAll(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListGetAll(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListGetAllContext listGetAll() throws RecognitionException {
		ListGetAllContext _localctx = new ListGetAllContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_listGetAll);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(183);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListGetOneContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public ListGetOneContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listGetOne; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListGetOne(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListGetOne(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListGetOne(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListGetOneContext listGetOne() throws RecognitionException {
		ListGetOneContext _localctx = new ListGetOneContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_listGetOne);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(185);
			key();
			setState(186);
			index();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListGetRangeContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public List index() {
			return getRuleContexts(IndexContext.class);
		}
		public IndexContext index(int i) {
			return getRuleContext(IndexContext.class,i);
		}
		public ListGetRangeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listGetRange; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListGetRange(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListGetRange(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListGetRange(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListGetRangeContext listGetRange() throws RecognitionException {
		ListGetRangeContext _localctx = new ListGetRangeContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_listGetRange);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(188);
			key();
			setState(189);
			index();
			setState(190);
			index();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListRemoveOneContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public IndexContext index() {
			return getRuleContext(IndexContext.class,0);
		}
		public ListRemoveOneContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listRemoveOne; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListRemoveOne(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListRemoveOne(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListRemoveOne(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListRemoveOneContext listRemoveOne() throws RecognitionException {
		ListRemoveOneContext _localctx = new ListRemoveOneContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_listRemoveOne);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(192);
			key();
			setState(193);
			index();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListRemoveRangeContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public List index() {
			return getRuleContexts(IndexContext.class);
		}
		public IndexContext index(int i) {
			return getRuleContext(IndexContext.class,i);
		}
		public ListRemoveRangeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listRemoveRange; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterListRemoveRange(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitListRemoveRange(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitListRemoveRange(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListRemoveRangeContext listRemoveRange() throws RecognitionException {
		ListRemoveRangeContext _localctx = new ListRemoveRangeContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_listRemoveRange);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(195);
			key();
			setState(196);
			index();
			setState(197);
			index();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetStatementContext extends ParserRuleContext {
		public SetPutContext setPut() {
			return getRuleContext(SetPutContext.class,0);
		}
		public SetGetContext setGet() {
			return getRuleContext(SetGetContext.class,0);
		}
		public SetPutItemContext setPutItem() {
			return getRuleContext(SetPutItemContext.class,0);
		}
		public SetRemoveItemContext setRemoveItem() {
			return getRuleContext(SetRemoveItemContext.class,0);
		}
		public SetExistsContext setExists() {
			return getRuleContext(SetExistsContext.class,0);
		}
		public SetDropContext setDrop() {
			return getRuleContext(SetDropContext.class,0);
		}
		public SetStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetStatementContext setStatement() throws RecognitionException {
		SetStatementContext _localctx = new SetStatementContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_setStatement);
		try {
			setState(205);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__10:
				enterOuterAlt(_localctx, 1);
				{
				setState(199);
				setPut();
				}
				break;
			case T__11:
				enterOuterAlt(_localctx, 2);
				{
				setState(200);
				setGet();
				}
				break;
			case T__12:
				enterOuterAlt(_localctx, 3);
				{
				setState(201);
				setPutItem();
				}
				break;
			case T__13:
			case T__14:
				enterOuterAlt(_localctx, 4);
				{
				setState(202);
				setRemoveItem();
				}
				break;
			case T__15:
				enterOuterAlt(_localctx, 5);
				{
				setState(203);
				setExists();
				}
				break;
			case T__16:
				enterOuterAlt(_localctx, 6);
				{
				setState(204);
				setDrop();
				}
				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 SetPutContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ValueArrayContext valueArray() {
			return getRuleContext(ValueArrayContext.class,0);
		}
		public SetPutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setPut; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetPut(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetPut(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetPutContext setPut() throws RecognitionException {
		SetPutContext _localctx = new SetPutContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_setPut);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(207);
			match(T__10);
			setState(208);
			key();
			setState(209);
			valueArray();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetGetContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public SetGetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setGet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetGet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetGet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetGetContext setGet() throws RecognitionException {
		SetGetContext _localctx = new SetGetContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_setGet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(211);
			match(T__11);
			setState(212);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetPutItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemValueContext itemValue() {
			return getRuleContext(ItemValueContext.class,0);
		}
		public SetPutItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setPutItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetPutItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetPutItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetPutItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetPutItemContext setPutItem() throws RecognitionException {
		SetPutItemContext _localctx = new SetPutItemContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_setPutItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(214);
			match(T__12);
			setState(215);
			key();
			setState(216);
			itemValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetRemoveItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemValueContext itemValue() {
			return getRuleContext(ItemValueContext.class,0);
		}
		public SetRemoveItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setRemoveItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetRemoveItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetRemoveItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetRemoveItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetRemoveItemContext setRemoveItem() throws RecognitionException {
		SetRemoveItemContext _localctx = new SetRemoveItemContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_setRemoveItem);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(218);
			_la = _input.LA(1);
			if ( !(_la==T__13 || _la==T__14) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(219);
			key();
			setState(220);
			itemValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetExistsContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemValueContext itemValue() {
			return getRuleContext(ItemValueContext.class,0);
		}
		public SetExistsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setExists; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetExists(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetExists(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetExists(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetExistsContext setExists() throws RecognitionException {
		SetExistsContext _localctx = new SetExistsContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_setExists);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(222);
			match(T__15);
			setState(223);
			key();
			setState(224);
			itemValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetDropContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public SetDropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setDrop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSetDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSetDrop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSetDrop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetDropContext setDrop() throws RecognitionException {
		SetDropContext _localctx = new SetDropContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_setDrop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(226);
			match(T__16);
			setState(227);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictStatementContext extends ParserRuleContext {
		public DictPutContext dictPut() {
			return getRuleContext(DictPutContext.class,0);
		}
		public DictGetContext dictGet() {
			return getRuleContext(DictGetContext.class,0);
		}
		public DictPutItemContext dictPutItem() {
			return getRuleContext(DictPutItemContext.class,0);
		}
		public DictGetItemContext dictGetItem() {
			return getRuleContext(DictGetItemContext.class,0);
		}
		public DictPopItemContext dictPopItem() {
			return getRuleContext(DictPopItemContext.class,0);
		}
		public DictRemoveItemContext dictRemoveItem() {
			return getRuleContext(DictRemoveItemContext.class,0);
		}
		public DictDropContext dictDrop() {
			return getRuleContext(DictDropContext.class,0);
		}
		public DictStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictStatementContext dictStatement() throws RecognitionException {
		DictStatementContext _localctx = new DictStatementContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_dictStatement);
		try {
			setState(236);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__17:
				enterOuterAlt(_localctx, 1);
				{
				setState(229);
				dictPut();
				}
				break;
			case T__18:
				enterOuterAlt(_localctx, 2);
				{
				setState(230);
				dictGet();
				}
				break;
			case T__19:
				enterOuterAlt(_localctx, 3);
				{
				setState(231);
				dictPutItem();
				}
				break;
			case T__20:
				enterOuterAlt(_localctx, 4);
				{
				setState(232);
				dictGetItem();
				}
				break;
			case T__21:
				enterOuterAlt(_localctx, 5);
				{
				setState(233);
				dictPopItem();
				}
				break;
			case T__22:
				enterOuterAlt(_localctx, 6);
				{
				setState(234);
				dictRemoveItem();
				}
				break;
			case T__23:
				enterOuterAlt(_localctx, 7);
				{
				setState(235);
				dictDrop();
				}
				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 DictPutContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public KeyValuePairsContext keyValuePairs() {
			return getRuleContext(KeyValuePairsContext.class,0);
		}
		public DictPutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictPut; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictPut(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictPut(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictPutContext dictPut() throws RecognitionException {
		DictPutContext _localctx = new DictPutContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_dictPut);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(238);
			match(T__17);
			setState(239);
			key();
			setState(240);
			keyValuePairs();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictGetContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public DictGetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictGet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictGet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictGet(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictGet(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictGetContext dictGet() throws RecognitionException {
		DictGetContext _localctx = new DictGetContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_dictGet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(242);
			match(T__18);
			setState(243);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictPutItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemKeyContext itemKey() {
			return getRuleContext(ItemKeyContext.class,0);
		}
		public ItemValueContext itemValue() {
			return getRuleContext(ItemValueContext.class,0);
		}
		public DictPutItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictPutItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictPutItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictPutItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictPutItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictPutItemContext dictPutItem() throws RecognitionException {
		DictPutItemContext _localctx = new DictPutItemContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_dictPutItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(245);
			match(T__19);
			setState(246);
			key();
			setState(247);
			itemKey();
			setState(248);
			itemValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictGetItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemKeyContext itemKey() {
			return getRuleContext(ItemKeyContext.class,0);
		}
		public DictGetItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictGetItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictGetItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictGetItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictGetItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictGetItemContext dictGetItem() throws RecognitionException {
		DictGetItemContext _localctx = new DictGetItemContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_dictGetItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(250);
			match(T__20);
			setState(251);
			key();
			setState(252);
			itemKey();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictPopItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemKeyContext itemKey() {
			return getRuleContext(ItemKeyContext.class,0);
		}
		public DictPopItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictPopItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictPopItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictPopItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictPopItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictPopItemContext dictPopItem() throws RecognitionException {
		DictPopItemContext _localctx = new DictPopItemContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_dictPopItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(254);
			match(T__21);
			setState(255);
			key();
			setState(256);
			itemKey();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictRemoveItemContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemKeyContext itemKey() {
			return getRuleContext(ItemKeyContext.class,0);
		}
		public DictRemoveItemContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictRemoveItem; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictRemoveItem(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictRemoveItem(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictRemoveItem(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictRemoveItemContext dictRemoveItem() throws RecognitionException {
		DictRemoveItemContext _localctx = new DictRemoveItemContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_dictRemoveItem);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(258);
			match(T__22);
			setState(259);
			key();
			setState(260);
			itemKey();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DictDropContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public DictDropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dictDrop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterDictDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitDictDrop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitDictDrop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DictDropContext dictDrop() throws RecognitionException {
		DictDropContext _localctx = new DictDropContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_dictDrop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(262);
			match(T__23);
			setState(263);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistStatementContext extends ParserRuleContext {
		public SlistPutContext slistPut() {
			return getRuleContext(SlistPutContext.class,0);
		}
		public SlistTopContext slistTop() {
			return getRuleContext(SlistTopContext.class,0);
		}
		public SlistIncrScoreContext slistIncrScore() {
			return getRuleContext(SlistIncrScoreContext.class,0);
		}
		public SlistPutMemberContext slistPutMember() {
			return getRuleContext(SlistPutMemberContext.class,0);
		}
		public SlistRemoveMemberContext slistRemoveMember() {
			return getRuleContext(SlistRemoveMemberContext.class,0);
		}
		public SlistDropContext slistDrop() {
			return getRuleContext(SlistDropContext.class,0);
		}
		public SlistGetMemberContext slistGetMember() {
			return getRuleContext(SlistGetMemberContext.class,0);
		}
		public SlistStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistStatement(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistStatementContext slistStatement() throws RecognitionException {
		SlistStatementContext _localctx = new SlistStatementContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_slistStatement);
		try {
			setState(272);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case T__24:
				enterOuterAlt(_localctx, 1);
				{
				setState(265);
				slistPut();
				}
				break;
			case T__25:
				enterOuterAlt(_localctx, 2);
				{
				setState(266);
				slistTop();
				}
				break;
			case T__26:
				enterOuterAlt(_localctx, 3);
				{
				setState(267);
				slistIncrScore();
				}
				break;
			case T__27:
				enterOuterAlt(_localctx, 4);
				{
				setState(268);
				slistPutMember();
				}
				break;
			case T__28:
				enterOuterAlt(_localctx, 5);
				{
				setState(269);
				slistRemoveMember();
				}
				break;
			case T__29:
				enterOuterAlt(_localctx, 6);
				{
				setState(270);
				slistDrop();
				}
				break;
			case T__30:
				enterOuterAlt(_localctx, 7);
				{
				setState(271);
				slistGetMember();
				}
				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 SlistPutContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public SortedListEntityPairsContext sortedListEntityPairs() {
			return getRuleContext(SortedListEntityPairsContext.class,0);
		}
		public SlistPutContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistPut; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistPut(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistPut(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistPut(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistPutContext slistPut() throws RecognitionException {
		SlistPutContext _localctx = new SlistPutContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_slistPut);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(274);
			match(T__24);
			setState(275);
			key();
			setState(276);
			sortedListEntityPairs();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistTopContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public TopCountContext topCount() {
			return getRuleContext(TopCountContext.class,0);
		}
		public SlistTopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistTop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistTop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistTop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistTop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistTopContext slistTop() throws RecognitionException {
		SlistTopContext _localctx = new SlistTopContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_slistTop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(278);
			match(T__25);
			setState(279);
			key();
			setState(280);
			topCount();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistIncrScoreContext extends ParserRuleContext {
		public SlistIncrScoreDefaultContext slistIncrScoreDefault() {
			return getRuleContext(SlistIncrScoreDefaultContext.class,0);
		}
		public SlistIncrScoreDeltaContext slistIncrScoreDelta() {
			return getRuleContext(SlistIncrScoreDeltaContext.class,0);
		}
		public SlistIncrScoreContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistIncrScore; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistIncrScore(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistIncrScore(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistIncrScore(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistIncrScoreContext slistIncrScore() throws RecognitionException {
		SlistIncrScoreContext _localctx = new SlistIncrScoreContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_slistIncrScore);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(282);
			match(T__26);
			setState(285);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(283);
				slistIncrScoreDefault();
				}
				break;
			case 2:
				{
				setState(284);
				slistIncrScoreDelta();
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistPutMemberContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public ItemScoreContext itemScore() {
			return getRuleContext(ItemScoreContext.class,0);
		}
		public SlistPutMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistPutMember; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistPutMember(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistPutMember(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistPutMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistPutMemberContext slistPutMember() throws RecognitionException {
		SlistPutMemberContext _localctx = new SlistPutMemberContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_slistPutMember);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			match(T__27);
			setState(288);
			key();
			setState(289);
			itemMember();
			setState(290);
			itemScore();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistRemoveMemberContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public SlistRemoveMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistRemoveMember; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistRemoveMember(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistRemoveMember(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistRemoveMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistRemoveMemberContext slistRemoveMember() throws RecognitionException {
		SlistRemoveMemberContext _localctx = new SlistRemoveMemberContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_slistRemoveMember);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(292);
			match(T__28);
			setState(293);
			key();
			setState(294);
			itemMember();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistDropContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public SlistDropContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistDrop; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistDrop(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistDrop(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistDrop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistDropContext slistDrop() throws RecognitionException {
		SlistDropContext _localctx = new SlistDropContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_slistDrop);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(296);
			match(T__29);
			setState(297);
			key();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistGetMemberContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public SlistGetMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistGetMember; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistGetMember(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistGetMember(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistGetMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistGetMemberContext slistGetMember() throws RecognitionException {
		SlistGetMemberContext _localctx = new SlistGetMemberContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_slistGetMember);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(299);
			match(T__30);
			setState(300);
			key();
			setState(301);
			itemMember();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistIncrScoreDefaultContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public SlistIncrScoreDefaultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistIncrScoreDefault; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistIncrScoreDefault(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistIncrScoreDefault(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistIncrScoreDefault(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistIncrScoreDefaultContext slistIncrScoreDefault() throws RecognitionException {
		SlistIncrScoreDefaultContext _localctx = new SlistIncrScoreDefaultContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_slistIncrScoreDefault);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(303);
			key();
			setState(304);
			itemMember();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SlistIncrScoreDeltaContext extends ParserRuleContext {
		public KeyContext key() {
			return getRuleContext(KeyContext.class,0);
		}
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public AnyIntContext anyInt() {
			return getRuleContext(AnyIntContext.class,0);
		}
		public SlistIncrScoreDeltaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_slistIncrScoreDelta; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSlistIncrScoreDelta(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSlistIncrScoreDelta(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSlistIncrScoreDelta(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SlistIncrScoreDeltaContext slistIncrScoreDelta() throws RecognitionException {
		SlistIncrScoreDeltaContext _localctx = new SlistIncrScoreDeltaContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_slistIncrScoreDelta);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(306);
			key();
			setState(307);
			itemMember();
			setState(308);
			anyInt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KeyValuePairsContext extends ParserRuleContext {
		public List keyValuePair() {
			return getRuleContexts(KeyValuePairContext.class);
		}
		public KeyValuePairContext keyValuePair(int i) {
			return getRuleContext(KeyValuePairContext.class,i);
		}
		public KeyValuePairsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyValuePairs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterKeyValuePairs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitKeyValuePairs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitKeyValuePairs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeyValuePairsContext keyValuePairs() throws RecognitionException {
		KeyValuePairsContext _localctx = new KeyValuePairsContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_keyValuePairs);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(311); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(310);
				keyValuePair();
				}
				}
				setState(313); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==STRING );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KeyValuePairContext extends ParserRuleContext {
		public ItemKeyContext itemKey() {
			return getRuleContext(ItemKeyContext.class,0);
		}
		public ItemValueContext itemValue() {
			return getRuleContext(ItemValueContext.class,0);
		}
		public KeyValuePairContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_keyValuePair; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterKeyValuePair(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitKeyValuePair(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitKeyValuePair(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeyValuePairContext keyValuePair() throws RecognitionException {
		KeyValuePairContext _localctx = new KeyValuePairContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_keyValuePair);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(315);
			itemKey();
			setState(316);
			itemValue();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ItemKeyContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(DstNewSQLParser.STRING, 0); }
		public ItemKeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_itemKey; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterItemKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitItemKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitItemKey(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ItemKeyContext itemKey() throws RecognitionException {
		ItemKeyContext _localctx = new ItemKeyContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_itemKey);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(318);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ItemValueContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(DstNewSQLParser.STRING, 0); }
		public ItemValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_itemValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterItemValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitItemValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitItemValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ItemValueContext itemValue() throws RecognitionException {
		ItemValueContext _localctx = new ItemValueContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_itemValue);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(320);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SortedListEntityPairsContext extends ParserRuleContext {
		public List sortedListEntity() {
			return getRuleContexts(SortedListEntityContext.class);
		}
		public SortedListEntityContext sortedListEntity(int i) {
			return getRuleContext(SortedListEntityContext.class,i);
		}
		public SortedListEntityPairsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sortedListEntityPairs; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSortedListEntityPairs(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSortedListEntityPairs(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSortedListEntityPairs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SortedListEntityPairsContext sortedListEntityPairs() throws RecognitionException {
		SortedListEntityPairsContext _localctx = new SortedListEntityPairsContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_sortedListEntityPairs);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(323); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(322);
				sortedListEntity();
				}
				}
				setState(325); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==STRING );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SortedListEntityContext extends ParserRuleContext {
		public ItemMemberContext itemMember() {
			return getRuleContext(ItemMemberContext.class,0);
		}
		public ItemScoreContext itemScore() {
			return getRuleContext(ItemScoreContext.class,0);
		}
		public SortedListEntityContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sortedListEntity; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterSortedListEntity(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitSortedListEntity(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitSortedListEntity(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SortedListEntityContext sortedListEntity() throws RecognitionException {
		SortedListEntityContext _localctx = new SortedListEntityContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_sortedListEntity);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(327);
			itemMember();
			setState(328);
			itemScore();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ItemMemberContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(DstNewSQLParser.STRING, 0); }
		public ItemMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_itemMember; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterItemMember(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitItemMember(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitItemMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ItemMemberContext itemMember() throws RecognitionException {
		ItemMemberContext _localctx = new ItemMemberContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_itemMember);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(330);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ItemScoreContext extends ParserRuleContext {
		public AnyIntContext anyInt() {
			return getRuleContext(AnyIntContext.class,0);
		}
		public ItemScoreContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_itemScore; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterItemScore(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitItemScore(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitItemScore(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ItemScoreContext itemScore() throws RecognitionException {
		ItemScoreContext _localctx = new ItemScoreContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_itemScore);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(332);
			anyInt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TopCountContext extends ParserRuleContext {
		public TerminalNode POSITIVE_INT() { return getToken(DstNewSQLParser.POSITIVE_INT, 0); }
		public TopCountContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_topCount; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterTopCount(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitTopCount(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitTopCount(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TopCountContext topCount() throws RecognitionException {
		TopCountContext _localctx = new TopCountContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_topCount);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(334);
			match(POSITIVE_INT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class KeyContext extends ParserRuleContext {
		public TerminalNode STRING() { return getToken(DstNewSQLParser.STRING, 0); }
		public KeyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_key; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterKey(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitKey(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitKey(this);
			else return visitor.visitChildren(this);
		}
	}

	public final KeyContext key() throws RecognitionException {
		KeyContext _localctx = new KeyContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_key);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(336);
			match(STRING);
			}
		}
		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 TerminalNode STRING() { return getToken(DstNewSQLParser.STRING, 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 DstNewSQLListener ) ((DstNewSQLListener)listener).enterValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitValue(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueContext value() throws RecognitionException {
		ValueContext _localctx = new ValueContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_value);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(338);
			match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ValueArrayContext extends ParserRuleContext {
		public List STRING() { return getTokens(DstNewSQLParser.STRING); }
		public TerminalNode STRING(int i) {
			return getToken(DstNewSQLParser.STRING, i);
		}
		public ValueArrayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_valueArray; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterValueArray(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitValueArray(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitValueArray(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueArrayContext valueArray() throws RecognitionException {
		ValueArrayContext _localctx = new ValueArrayContext(_ctx, getState());
		enterRule(_localctx, 110, RULE_valueArray);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(341); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(340);
				match(STRING);
				}
				}
				setState(343); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==STRING );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IndexContext extends ParserRuleContext {
		public TerminalNode POSITIVE_INT() { return getToken(DstNewSQLParser.POSITIVE_INT, 0); }
		public TerminalNode ZERO() { return getToken(DstNewSQLParser.ZERO, 0); }
		public IndexContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_index; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterIndex(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitIndex(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitIndex(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexContext index() throws RecognitionException {
		IndexContext _localctx = new IndexContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_index);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(345);
			_la = _input.LA(1);
			if ( !(_la==POSITIVE_INT || _la==ZERO) ) {
			_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 AnyIntContext extends ParserRuleContext {
		public TerminalNode NEGATIVE_INT() { return getToken(DstNewSQLParser.NEGATIVE_INT, 0); }
		public TerminalNode POSITIVE_INT() { return getToken(DstNewSQLParser.POSITIVE_INT, 0); }
		public TerminalNode ZERO() { return getToken(DstNewSQLParser.ZERO, 0); }
		public AnyIntContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anyInt; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).enterAnyInt(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof DstNewSQLListener ) ((DstNewSQLListener)listener).exitAnyInt(this);
		}
		@Override
		public  T accept(ParseTreeVisitor visitor) {
			if ( visitor instanceof DstNewSQLVisitor ) return ((DstNewSQLVisitor)visitor).visitAnyInt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AnyIntContext anyInt() throws RecognitionException {
		AnyIntContext _localctx = new AnyIntContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_anyInt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(347);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NEGATIVE_INT) | (1L << POSITIVE_INT) | (1L << ZERO))) != 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\3&\u0160\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;\3\2\3\2\3\2"+
		"\3\3\3\3\3\3\3\3\3\3\5\3\177\n\3\3\4\3\4\3\4\5\4\u0084\n\4\3\5\3\5\3\5"+
		"\3\5\3\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u0097\n\b"+
		"\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\5"+
		"\f\u00a9\n\f\3\r\3\r\3\r\5\r\u00ae\n\r\3\16\3\16\3\16\6\16\u00b3\n\16"+
		"\r\16\16\16\u00b4\3\17\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3"+
		"\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3"+
		"\25\5\25\u00d0\n\25\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30"+
		"\3\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\34\3\34"+
		"\3\34\3\34\3\34\3\34\3\34\5\34\u00ef\n\34\3\35\3\35\3\35\3\35\3\36\3\36"+
		"\3\36\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3\""+
		"\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\5$\u0113\n$\3%\3%\3%\3%\3&\3&\3&\3&\3\'"+
		"\3\'\3\'\5\'\u0120\n\'\3(\3(\3(\3(\3(\3)\3)\3)\3)\3*\3*\3*\3+\3+\3+\3"+
		"+\3,\3,\3,\3-\3-\3-\3-\3.\6.\u013a\n.\r.\16.\u013b\3/\3/\3/\3\60\3\60"+
		"\3\61\3\61\3\62\6\62\u0146\n\62\r\62\16\62\u0147\3\63\3\63\3\63\3\64\3"+
		"\64\3\65\3\65\3\66\3\66\3\67\3\67\38\38\39\69\u0158\n9\r9\169\u0159\3"+
		":\3:\3;\3;\3;\2\2<\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+
		"\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt\2\5\3\2\20\21\3\2#$\3\2\"$\2"+
		"\u014a\2v\3\2\2\2\4~\3\2\2\2\6\u0083\3\2\2\2\b\u0085\3\2\2\2\n\u0089\3"+
		"\2\2\2\f\u008c\3\2\2\2\16\u0096\3\2\2\2\20\u0098\3\2\2\2\22\u009c\3\2"+
		"\2\2\24\u00a0\3\2\2\2\26\u00a4\3\2\2\2\30\u00aa\3\2\2\2\32\u00af\3\2\2"+
		"\2\34\u00b6\3\2\2\2\36\u00b9\3\2\2\2 \u00bb\3\2\2\2\"\u00be\3\2\2\2$\u00c2"+
		"\3\2\2\2&\u00c5\3\2\2\2(\u00cf\3\2\2\2*\u00d1\3\2\2\2,\u00d5\3\2\2\2."+
		"\u00d8\3\2\2\2\60\u00dc\3\2\2\2\62\u00e0\3\2\2\2\64\u00e4\3\2\2\2\66\u00ee"+
		"\3\2\2\28\u00f0\3\2\2\2:\u00f4\3\2\2\2<\u00f7\3\2\2\2>\u00fc\3\2\2\2@"+
		"\u0100\3\2\2\2B\u0104\3\2\2\2D\u0108\3\2\2\2F\u0112\3\2\2\2H\u0114\3\2"+
		"\2\2J\u0118\3\2\2\2L\u011c\3\2\2\2N\u0121\3\2\2\2P\u0126\3\2\2\2R\u012a"+
		"\3\2\2\2T\u012d\3\2\2\2V\u0131\3\2\2\2X\u0134\3\2\2\2Z\u0139\3\2\2\2\\"+
		"\u013d\3\2\2\2^\u0140\3\2\2\2`\u0142\3\2\2\2b\u0145\3\2\2\2d\u0149\3\2"+
		"\2\2f\u014c\3\2\2\2h\u014e\3\2\2\2j\u0150\3\2\2\2l\u0152\3\2\2\2n\u0154"+
		"\3\2\2\2p\u0157\3\2\2\2r\u015b\3\2\2\2t\u015d\3\2\2\2vw\5\4\3\2wx\7\2"+
		"\2\3x\3\3\2\2\2y\177\5\6\4\2z\177\5\16\b\2{\177\5(\25\2|\177\5\66\34\2"+
		"}\177\5F$\2~y\3\2\2\2~z\3\2\2\2~{\3\2\2\2~|\3\2\2\2~}\3\2\2\2\177\5\3"+
		"\2\2\2\u0080\u0084\5\b\5\2\u0081\u0084\5\n\6\2\u0082\u0084\5\f\7\2\u0083"+
		"\u0080\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0082\3\2\2\2\u0084\7\3\2\2\2"+
		"\u0085\u0086\7\3\2\2\u0086\u0087\5l\67\2\u0087\u0088\5n8\2\u0088\t\3\2"+
		"\2\2\u0089\u008a\7\4\2\2\u008a\u008b\5l\67\2\u008b\13\3\2\2\2\u008c\u008d"+
		"\7\5\2\2\u008d\u008e\5l\67\2\u008e\r\3\2\2\2\u008f\u0097\5\20\t\2\u0090"+
		"\u0097\5\22\n\2\u0091\u0097\5\24\13\2\u0092\u0097\5\26\f\2\u0093\u0097"+
		"\5\30\r\2\u0094\u0097\5\32\16\2\u0095\u0097\5\34\17\2\u0096\u008f\3\2"+
		"\2\2\u0096\u0090\3\2\2\2\u0096\u0091\3\2\2\2\u0096\u0092\3\2\2\2\u0096"+
		"\u0093\3\2\2\2\u0096\u0094\3\2\2\2\u0096\u0095\3\2\2\2\u0097\17\3\2\2"+
		"\2\u0098\u0099\7\6\2\2\u0099\u009a\5l\67\2\u009a\u009b\5p9\2\u009b\21"+
		"\3\2\2\2\u009c\u009d\7\7\2\2\u009d\u009e\5l\67\2\u009e\u009f\5p9\2\u009f"+
		"\23\3\2\2\2\u00a0\u00a1\7\b\2\2\u00a1\u00a2\5l\67\2\u00a2\u00a3\5p9\2"+
		"\u00a3\25\3\2\2\2\u00a4\u00a8\7\t\2\2\u00a5\u00a9\5\36\20\2\u00a6\u00a9"+
		"\5 \21\2\u00a7\u00a9\5\"\22\2\u00a8\u00a5\3\2\2\2\u00a8\u00a6\3\2\2\2"+
		"\u00a8\u00a7\3\2\2\2\u00a9\27\3\2\2\2\u00aa\u00ad\7\n\2\2\u00ab\u00ae"+
		"\5$\23\2\u00ac\u00ae\5&\24\2\u00ad\u00ab\3\2\2\2\u00ad\u00ac\3\2\2\2\u00ae"+
		"\31\3\2\2\2\u00af\u00b0\7\13\2\2\u00b0\u00b2\5l\67\2\u00b1\u00b3\5r:\2"+
		"\u00b2\u00b1\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5"+
		"\3\2\2\2\u00b5\33\3\2\2\2\u00b6\u00b7\7\f\2\2\u00b7\u00b8\5l\67\2\u00b8"+
		"\35\3\2\2\2\u00b9\u00ba\5l\67\2\u00ba\37\3\2\2\2\u00bb\u00bc\5l\67\2\u00bc"+
		"\u00bd\5r:\2\u00bd!\3\2\2\2\u00be\u00bf\5l\67\2\u00bf\u00c0\5r:\2\u00c0"+
		"\u00c1\5r:\2\u00c1#\3\2\2\2\u00c2\u00c3\5l\67\2\u00c3\u00c4\5r:\2\u00c4"+
		"%\3\2\2\2\u00c5\u00c6\5l\67\2\u00c6\u00c7\5r:\2\u00c7\u00c8\5r:\2\u00c8"+
		"\'\3\2\2\2\u00c9\u00d0\5*\26\2\u00ca\u00d0\5,\27\2\u00cb\u00d0\5.\30\2"+
		"\u00cc\u00d0\5\60\31\2\u00cd\u00d0\5\62\32\2\u00ce\u00d0\5\64\33\2\u00cf"+
		"\u00c9\3\2\2\2\u00cf\u00ca\3\2\2\2\u00cf\u00cb\3\2\2\2\u00cf\u00cc\3\2"+
		"\2\2\u00cf\u00cd\3\2\2\2\u00cf\u00ce\3\2\2\2\u00d0)\3\2\2\2\u00d1\u00d2"+
		"\7\r\2\2\u00d2\u00d3\5l\67\2\u00d3\u00d4\5p9\2\u00d4+\3\2\2\2\u00d5\u00d6"+
		"\7\16\2\2\u00d6\u00d7\5l\67\2\u00d7-\3\2\2\2\u00d8\u00d9\7\17\2\2\u00d9"+
		"\u00da\5l\67\2\u00da\u00db\5`\61\2\u00db/\3\2\2\2\u00dc\u00dd\t\2\2\2"+
		"\u00dd\u00de\5l\67\2\u00de\u00df\5`\61\2\u00df\61\3\2\2\2\u00e0\u00e1"+
		"\7\22\2\2\u00e1\u00e2\5l\67\2\u00e2\u00e3\5`\61\2\u00e3\63\3\2\2\2\u00e4"+
		"\u00e5\7\23\2\2\u00e5\u00e6\5l\67\2\u00e6\65\3\2\2\2\u00e7\u00ef\58\35"+
		"\2\u00e8\u00ef\5:\36\2\u00e9\u00ef\5<\37\2\u00ea\u00ef\5> \2\u00eb\u00ef"+
		"\5@!\2\u00ec\u00ef\5B\"\2\u00ed\u00ef\5D#\2\u00ee\u00e7\3\2\2\2\u00ee"+
		"\u00e8\3\2\2\2\u00ee\u00e9\3\2\2\2\u00ee\u00ea\3\2\2\2\u00ee\u00eb\3\2"+
		"\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ed\3\2\2\2\u00ef\67\3\2\2\2\u00f0\u00f1"+
		"\7\24\2\2\u00f1\u00f2\5l\67\2\u00f2\u00f3\5Z.\2\u00f39\3\2\2\2\u00f4\u00f5"+
		"\7\25\2\2\u00f5\u00f6\5l\67\2\u00f6;\3\2\2\2\u00f7\u00f8\7\26\2\2\u00f8"+
		"\u00f9\5l\67\2\u00f9\u00fa\5^\60\2\u00fa\u00fb\5`\61\2\u00fb=\3\2\2\2"+
		"\u00fc\u00fd\7\27\2\2\u00fd\u00fe\5l\67\2\u00fe\u00ff\5^\60\2\u00ff?\3"+
		"\2\2\2\u0100\u0101\7\30\2\2\u0101\u0102\5l\67\2\u0102\u0103\5^\60\2\u0103"+
		"A\3\2\2\2\u0104\u0105\7\31\2\2\u0105\u0106\5l\67\2\u0106\u0107\5^\60\2"+
		"\u0107C\3\2\2\2\u0108\u0109\7\32\2\2\u0109\u010a\5l\67\2\u010aE\3\2\2"+
		"\2\u010b\u0113\5H%\2\u010c\u0113\5J&\2\u010d\u0113\5L\'\2\u010e\u0113"+
		"\5N(\2\u010f\u0113\5P)\2\u0110\u0113\5R*\2\u0111\u0113\5T+\2\u0112\u010b"+
		"\3\2\2\2\u0112\u010c\3\2\2\2\u0112\u010d\3\2\2\2\u0112\u010e\3\2\2\2\u0112"+
		"\u010f\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113G\3\2\2\2"+
		"\u0114\u0115\7\33\2\2\u0115\u0116\5l\67\2\u0116\u0117\5b\62\2\u0117I\3"+
		"\2\2\2\u0118\u0119\7\34\2\2\u0119\u011a\5l\67\2\u011a\u011b\5j\66\2\u011b"+
		"K\3\2\2\2\u011c\u011f\7\35\2\2\u011d\u0120\5V,\2\u011e\u0120\5X-\2\u011f"+
		"\u011d\3\2\2\2\u011f\u011e\3\2\2\2\u0120M\3\2\2\2\u0121\u0122\7\36\2\2"+
		"\u0122\u0123\5l\67\2\u0123\u0124\5f\64\2\u0124\u0125\5h\65\2\u0125O\3"+
		"\2\2\2\u0126\u0127\7\37\2\2\u0127\u0128\5l\67\2\u0128\u0129\5f\64\2\u0129"+
		"Q\3\2\2\2\u012a\u012b\7 \2\2\u012b\u012c\5l\67\2\u012cS\3\2\2\2\u012d"+
		"\u012e\7!\2\2\u012e\u012f\5l\67\2\u012f\u0130\5f\64\2\u0130U\3\2\2\2\u0131"+
		"\u0132\5l\67\2\u0132\u0133\5f\64\2\u0133W\3\2\2\2\u0134\u0135\5l\67\2"+
		"\u0135\u0136\5f\64\2\u0136\u0137\5t;\2\u0137Y\3\2\2\2\u0138\u013a\5\\"+
		"/\2\u0139\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u0139\3\2\2\2\u013b"+
		"\u013c\3\2\2\2\u013c[\3\2\2\2\u013d\u013e\5^\60\2\u013e\u013f\5`\61\2"+
		"\u013f]\3\2\2\2\u0140\u0141\7%\2\2\u0141_\3\2\2\2\u0142\u0143\7%\2\2\u0143"+
		"a\3\2\2\2\u0144\u0146\5d\63\2\u0145\u0144\3\2\2\2\u0146\u0147\3\2\2\2"+
		"\u0147\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148c\3\2\2\2\u0149\u014a\5"+
		"f\64\2\u014a\u014b\5h\65\2\u014be\3\2\2\2\u014c\u014d\7%\2\2\u014dg\3"+
		"\2\2\2\u014e\u014f\5t;\2\u014fi\3\2\2\2\u0150\u0151\7#\2\2\u0151k\3\2"+
		"\2\2\u0152\u0153\7%\2\2\u0153m\3\2\2\2\u0154\u0155\7%\2\2\u0155o\3\2\2"+
		"\2\u0156\u0158\7%\2\2\u0157\u0156\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u0157"+
		"\3\2\2\2\u0159\u015a\3\2\2\2\u015aq\3\2\2\2\u015b\u015c\t\3\2\2\u015c"+
		"s\3\2\2\2\u015d\u015e\t\4\2\2\u015eu\3\2\2\2\17~\u0083\u0096\u00a8\u00ad"+
		"\u00b4\u00cf\u00ee\u0112\u011f\u013b\u0147\u0159";
	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);
		}
	}
}