org.n52.svalbard.odata.grammar.STAQueryOptionsGrammar Maven / Gradle / Ivy
The newest version!
// Generated from java-escape by ANTLR 4.11.1
package org.n52.svalbard.odata.grammar;
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", "CheckReturnValue"})
public class STAQueryOptionsGrammar extends Parser {
static { RuntimeMetaData.checkVersion("4.11.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
WS=1, EQ=2, COMMA=3, SP=4, SEMI=5, MINUS=6, SQ=7, AMPERSAND=8, OP=9, CP=10,
SIGN=11, SLASH=12, DOT=13, COLON=14, ALPHAPLUS=15, DIGIT=16, DIGITPLUS=17,
QO_COUNT=18, QO_EXPAND=19, QO_FILTER=20, QO_ORDERBY=21, QO_SKIP=22, QO_TOP=23,
QO_SELECT=24, True_LLC=25, False_LLC=26, ASC_LLC=27, DESC_LLC=28, LITERAL=29,
SubStringOf_LLC=30, StartsWith_LLC=31, EndsWith_LLC=32, Length_LLC=33,
IndexOf_LLC=34, Substring_LLC=35, ToLower_LLC=36, ToUpper_LLC=37, Trim_LLC=38,
Concat_LLC=39, Contains_LLC=40, Year_LLC=41, Month_LLC=42, Day_LLC=43,
Days_LLC=44, Hour_LLC=45, Minute_LLC=46, Second_LLC=47, Date_LLC=48, Time_LLC=49,
TotalOffsetMinutes_LLC=50, MinDateTime_LLC=51, MaxDateTime_LLC=52, Now_LLC=53,
Round_LLC=54, Floor_LLC=55, Ceiling_LLC=56, GeoDotDistance_LLC=57, GeoLength_LLC=58,
GeoDotIntersects_LLC=59, ST_equals_LLC=60, ST_disjoint_LLC=61, ST_touches_LLC=62,
ST_within_LLC=63, ST_overlaps_LLC=64, ST_crosses_LLC=65, ST_intersects_LLC=66,
ST_contains_LLC=67, ST_relate_LLC=68, And_LLC=69, Or_LLC=70, Not_LLC=71,
Eq_LLC=72, Ne_LLC=73, Lt_LLC=74, Le_LLC=75, Gt_LLC=76, Ge_LLC=77, Add_LLC=78,
Sub_LLC=79, Mul_LLC=80, Div_LLC=81, Mod_LLC=82, NotANumber_LXC=83, Infinity_LUC=84,
Null_LLC=85, Geography_LLC=86, Geometry_LLC=87, DIGIT4MINUS=88, FILTER_FloatingPointLiteral=89,
MultiLineStringOP_LUC=90, LineString_LUC=91, MultiPointOP_LUC=92, MultiPolygonOP_LUC=93,
Point_LUC=94, Polygon_LUC=95, Multi_LUC=96, CollectionOP_LUC=97, SRID_LLC=98,
DIGIT5=99, T=100, Z=101, DIGIT3=102, DIGIT2=103, DOLLAR=104;
public static final int
RULE_queryOptions = 0, RULE_systemQueryOption = 1, RULE_count = 2, RULE_expand = 3,
RULE_expandItem = 4, RULE_filter = 5, RULE_orderby = 6, RULE_orderbyItem = 7,
RULE_skip = 8, RULE_top = 9, RULE_select = 10, RULE_selectItem = 11, RULE_boolExpr = 12,
RULE_boolParenExpr = 13, RULE_anyExpr = 14, RULE_parenExpr = 15, RULE_arithmeticExpr = 16,
RULE_timeExpr = 17, RULE_textExpr = 18, RULE_geoExpr = 19, RULE_memberExpr = 20,
RULE_textMethodCallExpr = 21, RULE_arithmeticMethodCallExpr = 22, RULE_temporalMethodCallExpr = 23,
RULE_boolMethodCallExpr = 24, RULE_textOrMember = 25, RULE_temporalOrMemberOrISO8601Timestamp = 26,
RULE_geoOrMember = 27, RULE_iso8601Timestamp = 28, RULE_iso8601Timezone = 29,
RULE_substringMethodCallExpr = 30, RULE_toLowerMethodCallExpr = 31, RULE_toUpperMethodCallExpr = 32,
RULE_trimMethodCallExpr = 33, RULE_concatMethodCallExpr = 34, RULE_substringOfMethodCallExpr = 35,
RULE_startsWithMethodCallExpr = 36, RULE_endsWithMethodCallExpr = 37,
RULE_containsMethodCallExpr = 38, RULE_intersectsMethodCallExpr = 39,
RULE_st_commonMethodCallExpr = 40, RULE_st_equalsMethodCallExpr = 41,
RULE_st_disjointMethodCallExpr = 42, RULE_st_touchesMethodCallExpr = 43,
RULE_st_withinMethodCallExpr = 44, RULE_st_overlapsMethodCallExpr = 45,
RULE_st_crossesMethodCallExpr = 46, RULE_st_intersectsMethodCallExpr = 47,
RULE_st_containsMethodCallExpr = 48, RULE_st_relateMethodCallExpr = 49,
RULE_lengthMethodCallExpr = 50, RULE_indexOfMethodCallExpr = 51, RULE_yearMethodCallExpr = 52,
RULE_monthMethodCallExpr = 53, RULE_dayMethodCallExpr = 54, RULE_daysMethodCallExpr = 55,
RULE_hourMethodCallExpr = 56, RULE_minuteMethodCallExpr = 57, RULE_secondMethodCallExpr = 58,
RULE_timeMethodCallExpr = 59, RULE_dateMethodCallExpr = 60, RULE_roundMethodCallExpr = 61,
RULE_floorMethodCallExpr = 62, RULE_ceilingMethodCallExpr = 63, RULE_totalOffsetMinutesExpr = 64,
RULE_distanceMethodCallExpr = 65, RULE_geoLengthMethodCallExpr = 66, RULE_minDate = 67,
RULE_maxDate = 68, RULE_nowDate = 69, RULE_andExpr = 70, RULE_orExpr = 71,
RULE_notExpr = 72, RULE_eqExpr = 73, RULE_neExpr = 74, RULE_ltExpr = 75,
RULE_leExpr = 76, RULE_gtExpr = 77, RULE_geExpr = 78, RULE_addExpr = 79,
RULE_subExpr = 80, RULE_mulExpr = 81, RULE_divExpr = 82, RULE_modExpr = 83,
RULE_negateExpr = 84, RULE_numericLiteral = 85, RULE_decimalLiteral = 86,
RULE_escapedString = 87, RULE_geographyCollection = 88, RULE_fullCollectionLiteral = 89,
RULE_collectionLiteral = 90, RULE_geoLiteral = 91, RULE_geographyLineString = 92,
RULE_fullLineStringLiteral = 93, RULE_lineStringLiteral = 94, RULE_lineStringData = 95,
RULE_geographyMultiLineString = 96, RULE_fullMultiLineStringLiteral = 97,
RULE_multiLineStringLiteral = 98, RULE_geographyMultiPoint = 99, RULE_fullMultiPointLiteral = 100,
RULE_multiPointLiteral = 101, RULE_geographyMultiPolygon = 102, RULE_fullMultiPolygonLiteral = 103,
RULE_multiPolygonLiteral = 104, RULE_geographyPoint = 105, RULE_fullPointLiteral = 106,
RULE_sridLiteral = 107, RULE_pointLiteral = 108, RULE_pointData = 109,
RULE_positionLiteral = 110, RULE_coordinate = 111, RULE_geographyPolygon = 112,
RULE_fullPolygonLiteral = 113, RULE_polygonLiteral = 114, RULE_polygonData = 115,
RULE_ringLiteral = 116, RULE_geometryCollection = 117, RULE_geometryLineString = 118,
RULE_geometryMultiLineString = 119, RULE_geometryMultiPoint = 120, RULE_geometryMultiPolygon = 121,
RULE_geometryPoint = 122, RULE_geometryPolygon = 123, RULE_geographyPrefix = 124,
RULE_geometryPrefix = 125;
private static String[] makeRuleNames() {
return new String[] {
"queryOptions", "systemQueryOption", "count", "expand", "expandItem",
"filter", "orderby", "orderbyItem", "skip", "top", "select", "selectItem",
"boolExpr", "boolParenExpr", "anyExpr", "parenExpr", "arithmeticExpr",
"timeExpr", "textExpr", "geoExpr", "memberExpr", "textMethodCallExpr",
"arithmeticMethodCallExpr", "temporalMethodCallExpr", "boolMethodCallExpr",
"textOrMember", "temporalOrMemberOrISO8601Timestamp", "geoOrMember",
"iso8601Timestamp", "iso8601Timezone", "substringMethodCallExpr", "toLowerMethodCallExpr",
"toUpperMethodCallExpr", "trimMethodCallExpr", "concatMethodCallExpr",
"substringOfMethodCallExpr", "startsWithMethodCallExpr", "endsWithMethodCallExpr",
"containsMethodCallExpr", "intersectsMethodCallExpr", "st_commonMethodCallExpr",
"st_equalsMethodCallExpr", "st_disjointMethodCallExpr", "st_touchesMethodCallExpr",
"st_withinMethodCallExpr", "st_overlapsMethodCallExpr", "st_crossesMethodCallExpr",
"st_intersectsMethodCallExpr", "st_containsMethodCallExpr", "st_relateMethodCallExpr",
"lengthMethodCallExpr", "indexOfMethodCallExpr", "yearMethodCallExpr",
"monthMethodCallExpr", "dayMethodCallExpr", "daysMethodCallExpr", "hourMethodCallExpr",
"minuteMethodCallExpr", "secondMethodCallExpr", "timeMethodCallExpr",
"dateMethodCallExpr", "roundMethodCallExpr", "floorMethodCallExpr", "ceilingMethodCallExpr",
"totalOffsetMinutesExpr", "distanceMethodCallExpr", "geoLengthMethodCallExpr",
"minDate", "maxDate", "nowDate", "andExpr", "orExpr", "notExpr", "eqExpr",
"neExpr", "ltExpr", "leExpr", "gtExpr", "geExpr", "addExpr", "subExpr",
"mulExpr", "divExpr", "modExpr", "negateExpr", "numericLiteral", "decimalLiteral",
"escapedString", "geographyCollection", "fullCollectionLiteral", "collectionLiteral",
"geoLiteral", "geographyLineString", "fullLineStringLiteral", "lineStringLiteral",
"lineStringData", "geographyMultiLineString", "fullMultiLineStringLiteral",
"multiLineStringLiteral", "geographyMultiPoint", "fullMultiPointLiteral",
"multiPointLiteral", "geographyMultiPolygon", "fullMultiPolygonLiteral",
"multiPolygonLiteral", "geographyPoint", "fullPointLiteral", "sridLiteral",
"pointLiteral", "pointData", "positionLiteral", "coordinate", "geographyPolygon",
"fullPolygonLiteral", "polygonLiteral", "polygonData", "ringLiteral",
"geometryCollection", "geometryLineString", "geometryMultiLineString",
"geometryMultiPoint", "geometryMultiPolygon", "geometryPoint", "geometryPolygon",
"geographyPrefix", "geometryPrefix"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, "'='", "','", "' '", "';'", "'-'", null, null, "'('", "')'",
null, "'/'", "'.'", "':'", null, null, null, "'count'", "'expand'", "'filter'",
"'orderby'", "'skip'", "'top'", "'select'", "'true'", "'false'", "'asc'",
"'desc'", null, "'substringof'", "'startswith'", "'endswith'", "'length'",
"'indexof'", "'substring'", "'tolower'", "'toupper'", "'trim'", "'concat'",
"'contains'", "'year'", "'month'", "'day'", "'days'", "'hour'", "'minute'",
"'second'", "'date'", "'time'", "'totaloffsetminutes'", "'mindatetime'",
"'maxdatetime'", "'now'", "'round'", "'floor'", "'ceiling'", "'geo.distance'",
"'geo.length'", "'geo.intersects'", "'st_equals'", "'st_disjoint'", "'st_touches'",
"'st_within'", "'st_overlaps'", "'st_crosses'", "'st_intersects'", "'st_contains'",
"'st_relate'", "'and'", "'or'", "'not'", "'eq'", "'ne'", "'lt'", "'le'",
"'gt'", "'ge'", "'add'", "'sub'", "'mul'", "'div'", "'mod'", "'NaN'",
"'INF'", "'null'", null, null, null, null, null, "'LINESTRING'", null,
null, "'POINT'", "'POLYGON'", "'MULTI'", null, "'srid'", null, "'T'",
"'Z'", null, null, "'$'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "WS", "EQ", "COMMA", "SP", "SEMI", "MINUS", "SQ", "AMPERSAND",
"OP", "CP", "SIGN", "SLASH", "DOT", "COLON", "ALPHAPLUS", "DIGIT", "DIGITPLUS",
"QO_COUNT", "QO_EXPAND", "QO_FILTER", "QO_ORDERBY", "QO_SKIP", "QO_TOP",
"QO_SELECT", "True_LLC", "False_LLC", "ASC_LLC", "DESC_LLC", "LITERAL",
"SubStringOf_LLC", "StartsWith_LLC", "EndsWith_LLC", "Length_LLC", "IndexOf_LLC",
"Substring_LLC", "ToLower_LLC", "ToUpper_LLC", "Trim_LLC", "Concat_LLC",
"Contains_LLC", "Year_LLC", "Month_LLC", "Day_LLC", "Days_LLC", "Hour_LLC",
"Minute_LLC", "Second_LLC", "Date_LLC", "Time_LLC", "TotalOffsetMinutes_LLC",
"MinDateTime_LLC", "MaxDateTime_LLC", "Now_LLC", "Round_LLC", "Floor_LLC",
"Ceiling_LLC", "GeoDotDistance_LLC", "GeoLength_LLC", "GeoDotIntersects_LLC",
"ST_equals_LLC", "ST_disjoint_LLC", "ST_touches_LLC", "ST_within_LLC",
"ST_overlaps_LLC", "ST_crosses_LLC", "ST_intersects_LLC", "ST_contains_LLC",
"ST_relate_LLC", "And_LLC", "Or_LLC", "Not_LLC", "Eq_LLC", "Ne_LLC",
"Lt_LLC", "Le_LLC", "Gt_LLC", "Ge_LLC", "Add_LLC", "Sub_LLC", "Mul_LLC",
"Div_LLC", "Mod_LLC", "NotANumber_LXC", "Infinity_LUC", "Null_LLC", "Geography_LLC",
"Geometry_LLC", "DIGIT4MINUS", "FILTER_FloatingPointLiteral", "MultiLineStringOP_LUC",
"LineString_LUC", "MultiPointOP_LUC", "MultiPolygonOP_LUC", "Point_LUC",
"Polygon_LUC", "Multi_LUC", "CollectionOP_LUC", "SRID_LLC", "DIGIT5",
"T", "Z", "DIGIT3", "DIGIT2", "DOLLAR"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "java-escape"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public STAQueryOptionsGrammar(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class QueryOptionsContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(STAQueryOptionsGrammar.EOF, 0); }
public List systemQueryOption() {
return getRuleContexts(SystemQueryOptionContext.class);
}
public SystemQueryOptionContext systemQueryOption(int i) {
return getRuleContext(SystemQueryOptionContext.class,i);
}
public List AMPERSAND() { return getTokens(STAQueryOptionsGrammar.AMPERSAND); }
public TerminalNode AMPERSAND(int i) {
return getToken(STAQueryOptionsGrammar.AMPERSAND, i);
}
public QueryOptionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_queryOptions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterQueryOptions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitQueryOptions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitQueryOptions(this);
else return visitor.visitChildren(this);
}
}
public final QueryOptionsContext queryOptions() throws RecognitionException {
QueryOptionsContext _localctx = new QueryOptionsContext(_ctx, getState());
enterRule(_localctx, 0, RULE_queryOptions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(253);
_errHandler.sync(this);
_la = _input.LA(1);
if (((_la) & ~0x3f) == 0 && ((1L << _la) & 33292288L) != 0) {
{
setState(252);
systemQueryOption();
}
}
setState(259);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AMPERSAND) {
{
{
setState(255);
match(AMPERSAND);
setState(256);
systemQueryOption();
}
}
setState(261);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(262);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SystemQueryOptionContext extends ParserRuleContext {
public ExpandContext expand() {
return getRuleContext(ExpandContext.class,0);
}
public FilterContext filter() {
return getRuleContext(FilterContext.class,0);
}
public OrderbyContext orderby() {
return getRuleContext(OrderbyContext.class,0);
}
public CountContext count() {
return getRuleContext(CountContext.class,0);
}
public SkipContext skip() {
return getRuleContext(SkipContext.class,0);
}
public TopContext top() {
return getRuleContext(TopContext.class,0);
}
public SelectContext select() {
return getRuleContext(SelectContext.class,0);
}
public SystemQueryOptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_systemQueryOption; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSystemQueryOption(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSystemQueryOption(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSystemQueryOption(this);
else return visitor.visitChildren(this);
}
}
public final SystemQueryOptionContext systemQueryOption() throws RecognitionException {
SystemQueryOptionContext _localctx = new SystemQueryOptionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_systemQueryOption);
try {
setState(271);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QO_EXPAND:
enterOuterAlt(_localctx, 1);
{
setState(264);
expand();
}
break;
case QO_FILTER:
enterOuterAlt(_localctx, 2);
{
setState(265);
filter();
}
break;
case QO_ORDERBY:
enterOuterAlt(_localctx, 3);
{
setState(266);
orderby();
}
break;
case QO_COUNT:
enterOuterAlt(_localctx, 4);
{
setState(267);
count();
}
break;
case QO_SKIP:
enterOuterAlt(_localctx, 5);
{
setState(268);
skip();
}
break;
case QO_TOP:
enterOuterAlt(_localctx, 6);
{
setState(269);
top();
}
break;
case QO_SELECT:
enterOuterAlt(_localctx, 7);
{
setState(270);
select();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CountContext extends ParserRuleContext {
public TerminalNode QO_COUNT() { return getToken(STAQueryOptionsGrammar.QO_COUNT, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public TerminalNode True_LLC() { return getToken(STAQueryOptionsGrammar.True_LLC, 0); }
public TerminalNode False_LLC() { return getToken(STAQueryOptionsGrammar.False_LLC, 0); }
public CountContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_count; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterCount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitCount(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitCount(this);
else return visitor.visitChildren(this);
}
}
public final CountContext count() throws RecognitionException {
CountContext _localctx = new CountContext(_ctx, getState());
enterRule(_localctx, 4, RULE_count);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
match(QO_COUNT);
setState(274);
match(EQ);
setState(275);
_la = _input.LA(1);
if ( !(_la==True_LLC || _la==False_LLC) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpandContext extends ParserRuleContext {
public TerminalNode QO_EXPAND() { return getToken(STAQueryOptionsGrammar.QO_EXPAND, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public List expandItem() {
return getRuleContexts(ExpandItemContext.class);
}
public ExpandItemContext expandItem(int i) {
return getRuleContext(ExpandItemContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ExpandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterExpand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitExpand(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitExpand(this);
else return visitor.visitChildren(this);
}
}
public final ExpandContext expand() throws RecognitionException {
ExpandContext _localctx = new ExpandContext(_ctx, getState());
enterRule(_localctx, 6, RULE_expand);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(277);
match(QO_EXPAND);
setState(278);
match(EQ);
setState(279);
expandItem();
setState(290);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(280);
match(COMMA);
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(281);
match(SP);
}
}
setState(286);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(287);
expandItem();
}
}
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpandItemContext extends ParserRuleContext {
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List systemQueryOption() {
return getRuleContexts(SystemQueryOptionContext.class);
}
public SystemQueryOptionContext systemQueryOption(int i) {
return getRuleContext(SystemQueryOptionContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SEMI() { return getTokens(STAQueryOptionsGrammar.SEMI); }
public TerminalNode SEMI(int i) {
return getToken(STAQueryOptionsGrammar.SEMI, i);
}
public ExpandItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expandItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterExpandItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitExpandItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitExpandItem(this);
else return visitor.visitChildren(this);
}
}
public final ExpandItemContext expandItem() throws RecognitionException {
ExpandItemContext _localctx = new ExpandItemContext(_ctx, getState());
enterRule(_localctx, 8, RULE_expandItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(293);
memberExpr();
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OP) {
{
setState(294);
match(OP);
setState(295);
systemQueryOption();
setState(300);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SEMI) {
{
{
setState(296);
match(SEMI);
setState(297);
systemQueryOption();
}
}
setState(302);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(303);
match(CP);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FilterContext extends ParserRuleContext {
public TerminalNode QO_FILTER() { return getToken(STAQueryOptionsGrammar.QO_FILTER, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public BoolExprContext boolExpr() {
return getRuleContext(BoolExprContext.class,0);
}
public FilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_filter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFilter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFilter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFilter(this);
else return visitor.visitChildren(this);
}
}
public final FilterContext filter() throws RecognitionException {
FilterContext _localctx = new FilterContext(_ctx, getState());
enterRule(_localctx, 10, RULE_filter);
try {
enterOuterAlt(_localctx, 1);
{
setState(307);
match(QO_FILTER);
setState(308);
match(EQ);
setState(309);
boolExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrderbyContext extends ParserRuleContext {
public TerminalNode QO_ORDERBY() { return getToken(STAQueryOptionsGrammar.QO_ORDERBY, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public List orderbyItem() {
return getRuleContexts(OrderbyItemContext.class);
}
public OrderbyItemContext orderbyItem(int i) {
return getRuleContext(OrderbyItemContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public OrderbyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderby; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterOrderby(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitOrderby(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitOrderby(this);
else return visitor.visitChildren(this);
}
}
public final OrderbyContext orderby() throws RecognitionException {
OrderbyContext _localctx = new OrderbyContext(_ctx, getState());
enterRule(_localctx, 12, RULE_orderby);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(311);
match(QO_ORDERBY);
setState(312);
match(EQ);
setState(313);
orderbyItem();
setState(324);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(314);
match(COMMA);
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(315);
match(SP);
}
}
setState(320);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(321);
orderbyItem();
}
}
setState(326);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrderbyItemContext extends ParserRuleContext {
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public TerminalNode SP() { return getToken(STAQueryOptionsGrammar.SP, 0); }
public TerminalNode ASC_LLC() { return getToken(STAQueryOptionsGrammar.ASC_LLC, 0); }
public TerminalNode DESC_LLC() { return getToken(STAQueryOptionsGrammar.DESC_LLC, 0); }
public OrderbyItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderbyItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterOrderbyItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitOrderbyItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitOrderbyItem(this);
else return visitor.visitChildren(this);
}
}
public final OrderbyItemContext orderbyItem() throws RecognitionException {
OrderbyItemContext _localctx = new OrderbyItemContext(_ctx, getState());
enterRule(_localctx, 14, RULE_orderbyItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
memberExpr();
setState(330);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(328);
match(SP);
setState(329);
_la = _input.LA(1);
if ( !(_la==ASC_LLC || _la==DESC_LLC) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class SkipContext extends ParserRuleContext {
public TerminalNode QO_SKIP() { return getToken(STAQueryOptionsGrammar.QO_SKIP, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public SkipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_skip; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSkip(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSkip(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSkip(this);
else return visitor.visitChildren(this);
}
}
public final SkipContext skip() throws RecognitionException {
SkipContext _localctx = new SkipContext(_ctx, getState());
enterRule(_localctx, 16, RULE_skip);
try {
enterOuterAlt(_localctx, 1);
{
setState(332);
match(QO_SKIP);
setState(333);
match(EQ);
setState(334);
decimalLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TopContext extends ParserRuleContext {
public TerminalNode QO_TOP() { return getToken(STAQueryOptionsGrammar.QO_TOP, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_top; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTop(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTop(this);
else return visitor.visitChildren(this);
}
}
public final TopContext top() throws RecognitionException {
TopContext _localctx = new TopContext(_ctx, getState());
enterRule(_localctx, 18, RULE_top);
try {
enterOuterAlt(_localctx, 1);
{
setState(336);
match(QO_TOP);
setState(337);
match(EQ);
setState(338);
decimalLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectContext extends ParserRuleContext {
public TerminalNode QO_SELECT() { return getToken(STAQueryOptionsGrammar.QO_SELECT, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public List selectItem() {
return getRuleContexts(SelectItemContext.class);
}
public SelectItemContext selectItem(int i) {
return getRuleContext(SelectItemContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public SelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSelect(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSelect(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSelect(this);
else return visitor.visitChildren(this);
}
}
public final SelectContext select() throws RecognitionException {
SelectContext _localctx = new SelectContext(_ctx, getState());
enterRule(_localctx, 20, RULE_select);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(340);
match(QO_SELECT);
setState(341);
match(EQ);
setState(342);
selectItem();
setState(353);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(343);
match(COMMA);
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(344);
match(SP);
}
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(350);
selectItem();
}
}
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelectItemContext extends ParserRuleContext {
public TerminalNode ALPHAPLUS() { return getToken(STAQueryOptionsGrammar.ALPHAPLUS, 0); }
public SelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSelectItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSelectItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSelectItem(this);
else return visitor.visitChildren(this);
}
}
public final SelectItemContext selectItem() throws RecognitionException {
SelectItemContext _localctx = new SelectItemContext(_ctx, getState());
enterRule(_localctx, 22, RULE_selectItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(356);
match(ALPHAPLUS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BoolExprContext extends ParserRuleContext {
public BoolMethodCallExprContext boolMethodCallExpr() {
return getRuleContext(BoolMethodCallExprContext.class,0);
}
public NotExprContext notExpr() {
return getRuleContext(NotExprContext.class,0);
}
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public BoolParenExprContext boolParenExpr() {
return getRuleContext(BoolParenExprContext.class,0);
}
public AndExprContext andExpr() {
return getRuleContext(AndExprContext.class,0);
}
public OrExprContext orExpr() {
return getRuleContext(OrExprContext.class,0);
}
public EqExprContext eqExpr() {
return getRuleContext(EqExprContext.class,0);
}
public NeExprContext neExpr() {
return getRuleContext(NeExprContext.class,0);
}
public LtExprContext ltExpr() {
return getRuleContext(LtExprContext.class,0);
}
public LeExprContext leExpr() {
return getRuleContext(LeExprContext.class,0);
}
public GtExprContext gtExpr() {
return getRuleContext(GtExprContext.class,0);
}
public GeExprContext geExpr() {
return getRuleContext(GeExprContext.class,0);
}
public BoolExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boolExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterBoolExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitBoolExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitBoolExpr(this);
else return visitor.visitChildren(this);
}
}
public final BoolExprContext boolExpr() throws RecognitionException {
BoolExprContext _localctx = new BoolExprContext(_ctx, getState());
enterRule(_localctx, 24, RULE_boolExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(370);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(358);
boolMethodCallExpr();
}
break;
case 2:
{
setState(359);
notExpr();
}
break;
case 3:
{
setState(360);
anyExpr();
setState(367);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(361);
eqExpr();
}
break;
case 2:
{
setState(362);
neExpr();
}
break;
case 3:
{
setState(363);
ltExpr();
}
break;
case 4:
{
setState(364);
leExpr();
}
break;
case 5:
{
setState(365);
gtExpr();
}
break;
case 6:
{
setState(366);
geExpr();
}
break;
}
}
break;
case 4:
{
setState(369);
boolParenExpr();
}
break;
}
setState(374);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(372);
andExpr();
}
break;
case 2:
{
setState(373);
orExpr();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BoolParenExprContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public BoolExprContext boolExpr() {
return getRuleContext(BoolExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public BoolParenExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boolParenExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterBoolParenExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitBoolParenExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitBoolParenExpr(this);
else return visitor.visitChildren(this);
}
}
public final BoolParenExprContext boolParenExpr() throws RecognitionException {
BoolParenExprContext _localctx = new BoolParenExprContext(_ctx, getState());
enterRule(_localctx, 26, RULE_boolParenExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(376);
match(OP);
setState(380);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(377);
match(SP);
}
}
setState(382);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(383);
boolExpr();
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(384);
match(SP);
}
}
setState(389);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(390);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnyExprContext extends ParserRuleContext {
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public GeoExprContext geoExpr() {
return getRuleContext(GeoExprContext.class,0);
}
public TimeExprContext timeExpr() {
return getRuleContext(TimeExprContext.class,0);
}
public TextExprContext textExpr() {
return getRuleContext(TextExprContext.class,0);
}
public ParenExprContext parenExpr() {
return getRuleContext(ParenExprContext.class,0);
}
public AnyExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anyExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterAnyExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitAnyExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitAnyExpr(this);
else return visitor.visitChildren(this);
}
}
public final AnyExprContext anyExpr() throws RecognitionException {
AnyExprContext _localctx = new AnyExprContext(_ctx, getState());
enterRule(_localctx, 28, RULE_anyExpr);
try {
setState(398);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(392);
memberExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(393);
arithmeticExpr();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(394);
geoExpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(395);
timeExpr();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(396);
textExpr();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(397);
parenExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParenExprContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ParenExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parenExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterParenExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitParenExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitParenExpr(this);
else return visitor.visitChildren(this);
}
}
public final ParenExprContext parenExpr() throws RecognitionException {
ParenExprContext _localctx = new ParenExprContext(_ctx, getState());
enterRule(_localctx, 30, RULE_parenExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(400);
match(OP);
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(401);
match(SP);
}
}
setState(406);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(407);
anyExpr();
setState(411);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(408);
match(SP);
}
}
setState(413);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(414);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticExprContext extends ParserRuleContext {
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public NegateExprContext negateExpr() {
return getRuleContext(NegateExprContext.class,0);
}
public ArithmeticMethodCallExprContext arithmeticMethodCallExpr() {
return getRuleContext(ArithmeticMethodCallExprContext.class,0);
}
public List OP() { return getTokens(STAQueryOptionsGrammar.OP); }
public TerminalNode OP(int i) {
return getToken(STAQueryOptionsGrammar.OP, i);
}
public AddExprContext addExpr() {
return getRuleContext(AddExprContext.class,0);
}
public SubExprContext subExpr() {
return getRuleContext(SubExprContext.class,0);
}
public MulExprContext mulExpr() {
return getRuleContext(MulExprContext.class,0);
}
public DivExprContext divExpr() {
return getRuleContext(DivExprContext.class,0);
}
public ModExprContext modExpr() {
return getRuleContext(ModExprContext.class,0);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ArithmeticExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arithmeticExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterArithmeticExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitArithmeticExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitArithmeticExpr(this);
else return visitor.visitChildren(this);
}
}
public final ArithmeticExprContext arithmeticExpr() throws RecognitionException {
ArithmeticExprContext _localctx = new ArithmeticExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_arithmeticExpr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(423);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OP) {
{
setState(416);
match(OP);
setState(420);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(417);
match(SP);
}
}
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(429);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGIT:
case DIGITPLUS:
case FILTER_FloatingPointLiteral:
{
setState(425);
numericLiteral();
}
break;
case ALPHAPLUS:
case Time_LLC:
{
setState(426);
memberExpr();
}
break;
case MINUS:
{
setState(427);
negateExpr();
}
break;
case Length_LLC:
case IndexOf_LLC:
case Year_LLC:
case Month_LLC:
case Day_LLC:
case Days_LLC:
case Hour_LLC:
case Minute_LLC:
case Second_LLC:
case Date_LLC:
case TotalOffsetMinutes_LLC:
case Round_LLC:
case Floor_LLC:
case Ceiling_LLC:
case GeoDotDistance_LLC:
case GeoLength_LLC:
{
setState(428);
arithmeticMethodCallExpr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(436);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(431);
addExpr();
}
break;
case 2:
{
setState(432);
subExpr();
}
break;
case 3:
{
setState(433);
mulExpr();
}
break;
case 4:
{
setState(434);
divExpr();
}
break;
case 5:
{
setState(435);
modExpr();
}
break;
}
setState(445);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(438);
match(OP);
setState(442);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(439);
match(SP);
}
}
}
setState(444);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TimeExprContext extends ParserRuleContext {
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TimeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTimeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTimeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTimeExpr(this);
else return visitor.visitChildren(this);
}
}
public final TimeExprContext timeExpr() throws RecognitionException {
TimeExprContext _localctx = new TimeExprContext(_ctx, getState());
enterRule(_localctx, 34, RULE_timeExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(447);
temporalOrMemberOrISO8601Timestamp();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TextExprContext extends ParserRuleContext {
public EscapedStringContext escapedString() {
return getRuleContext(EscapedStringContext.class,0);
}
public TextMethodCallExprContext textMethodCallExpr() {
return getRuleContext(TextMethodCallExprContext.class,0);
}
public TextExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTextExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTextExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTextExpr(this);
else return visitor.visitChildren(this);
}
}
public final TextExprContext textExpr() throws RecognitionException {
TextExprContext _localctx = new TextExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_textExpr);
try {
setState(451);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGIT:
case DIGITPLUS:
case LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(449);
escapedString();
}
break;
case Substring_LLC:
case ToLower_LLC:
case ToUpper_LLC:
case Trim_LLC:
case Concat_LLC:
enterOuterAlt(_localctx, 2);
{
setState(450);
textMethodCallExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeoExprContext extends ParserRuleContext {
public GeographyCollectionContext geographyCollection() {
return getRuleContext(GeographyCollectionContext.class,0);
}
public GeographyLineStringContext geographyLineString() {
return getRuleContext(GeographyLineStringContext.class,0);
}
public GeographyMultiLineStringContext geographyMultiLineString() {
return getRuleContext(GeographyMultiLineStringContext.class,0);
}
public GeographyMultiPointContext geographyMultiPoint() {
return getRuleContext(GeographyMultiPointContext.class,0);
}
public GeographyMultiPolygonContext geographyMultiPolygon() {
return getRuleContext(GeographyMultiPolygonContext.class,0);
}
public GeographyPointContext geographyPoint() {
return getRuleContext(GeographyPointContext.class,0);
}
public GeographyPolygonContext geographyPolygon() {
return getRuleContext(GeographyPolygonContext.class,0);
}
public GeometryCollectionContext geometryCollection() {
return getRuleContext(GeometryCollectionContext.class,0);
}
public GeometryLineStringContext geometryLineString() {
return getRuleContext(GeometryLineStringContext.class,0);
}
public GeometryMultiLineStringContext geometryMultiLineString() {
return getRuleContext(GeometryMultiLineStringContext.class,0);
}
public GeometryMultiPointContext geometryMultiPoint() {
return getRuleContext(GeometryMultiPointContext.class,0);
}
public GeometryMultiPolygonContext geometryMultiPolygon() {
return getRuleContext(GeometryMultiPolygonContext.class,0);
}
public GeometryPointContext geometryPoint() {
return getRuleContext(GeometryPointContext.class,0);
}
public GeometryPolygonContext geometryPolygon() {
return getRuleContext(GeometryPolygonContext.class,0);
}
public GeoExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geoExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeoExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeoExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeoExpr(this);
else return visitor.visitChildren(this);
}
}
public final GeoExprContext geoExpr() throws RecognitionException {
GeoExprContext _localctx = new GeoExprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_geoExpr);
try {
setState(467);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(453);
geographyCollection();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(454);
geographyLineString();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(455);
geographyMultiLineString();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(456);
geographyMultiPoint();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(457);
geographyMultiPolygon();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(458);
geographyPoint();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(459);
geographyPolygon();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(460);
geometryCollection();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(461);
geometryLineString();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(462);
geometryMultiLineString();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(463);
geometryMultiPoint();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(464);
geometryMultiPolygon();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(465);
geometryPoint();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(466);
geometryPolygon();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MemberExprContext extends ParserRuleContext {
public List ALPHAPLUS() { return getTokens(STAQueryOptionsGrammar.ALPHAPLUS); }
public TerminalNode ALPHAPLUS(int i) {
return getToken(STAQueryOptionsGrammar.ALPHAPLUS, i);
}
public TerminalNode Time_LLC() { return getToken(STAQueryOptionsGrammar.Time_LLC, 0); }
public List SLASH() { return getTokens(STAQueryOptionsGrammar.SLASH); }
public TerminalNode SLASH(int i) {
return getToken(STAQueryOptionsGrammar.SLASH, i);
}
public MemberExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMemberExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMemberExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMemberExpr(this);
else return visitor.visitChildren(this);
}
}
public final MemberExprContext memberExpr() throws RecognitionException {
MemberExprContext _localctx = new MemberExprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_memberExpr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(473);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(469);
match(ALPHAPLUS);
setState(470);
match(SLASH);
}
}
}
setState(475);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
}
setState(476);
_la = _input.LA(1);
if ( !(_la==ALPHAPLUS || _la==Time_LLC) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class TextMethodCallExprContext extends ParserRuleContext {
public ToLowerMethodCallExprContext toLowerMethodCallExpr() {
return getRuleContext(ToLowerMethodCallExprContext.class,0);
}
public ToUpperMethodCallExprContext toUpperMethodCallExpr() {
return getRuleContext(ToUpperMethodCallExprContext.class,0);
}
public TrimMethodCallExprContext trimMethodCallExpr() {
return getRuleContext(TrimMethodCallExprContext.class,0);
}
public SubstringMethodCallExprContext substringMethodCallExpr() {
return getRuleContext(SubstringMethodCallExprContext.class,0);
}
public ConcatMethodCallExprContext concatMethodCallExpr() {
return getRuleContext(ConcatMethodCallExprContext.class,0);
}
public TextMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTextMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTextMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTextMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final TextMethodCallExprContext textMethodCallExpr() throws RecognitionException {
TextMethodCallExprContext _localctx = new TextMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_textMethodCallExpr);
try {
setState(483);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ToLower_LLC:
enterOuterAlt(_localctx, 1);
{
setState(478);
toLowerMethodCallExpr();
}
break;
case ToUpper_LLC:
enterOuterAlt(_localctx, 2);
{
setState(479);
toUpperMethodCallExpr();
}
break;
case Trim_LLC:
enterOuterAlt(_localctx, 3);
{
setState(480);
trimMethodCallExpr();
}
break;
case Substring_LLC:
enterOuterAlt(_localctx, 4);
{
setState(481);
substringMethodCallExpr();
}
break;
case Concat_LLC:
enterOuterAlt(_localctx, 5);
{
setState(482);
concatMethodCallExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticMethodCallExprContext extends ParserRuleContext {
public LengthMethodCallExprContext lengthMethodCallExpr() {
return getRuleContext(LengthMethodCallExprContext.class,0);
}
public IndexOfMethodCallExprContext indexOfMethodCallExpr() {
return getRuleContext(IndexOfMethodCallExprContext.class,0);
}
public YearMethodCallExprContext yearMethodCallExpr() {
return getRuleContext(YearMethodCallExprContext.class,0);
}
public MonthMethodCallExprContext monthMethodCallExpr() {
return getRuleContext(MonthMethodCallExprContext.class,0);
}
public DayMethodCallExprContext dayMethodCallExpr() {
return getRuleContext(DayMethodCallExprContext.class,0);
}
public DaysMethodCallExprContext daysMethodCallExpr() {
return getRuleContext(DaysMethodCallExprContext.class,0);
}
public HourMethodCallExprContext hourMethodCallExpr() {
return getRuleContext(HourMethodCallExprContext.class,0);
}
public MinuteMethodCallExprContext minuteMethodCallExpr() {
return getRuleContext(MinuteMethodCallExprContext.class,0);
}
public SecondMethodCallExprContext secondMethodCallExpr() {
return getRuleContext(SecondMethodCallExprContext.class,0);
}
public DateMethodCallExprContext dateMethodCallExpr() {
return getRuleContext(DateMethodCallExprContext.class,0);
}
public RoundMethodCallExprContext roundMethodCallExpr() {
return getRuleContext(RoundMethodCallExprContext.class,0);
}
public FloorMethodCallExprContext floorMethodCallExpr() {
return getRuleContext(FloorMethodCallExprContext.class,0);
}
public CeilingMethodCallExprContext ceilingMethodCallExpr() {
return getRuleContext(CeilingMethodCallExprContext.class,0);
}
public DistanceMethodCallExprContext distanceMethodCallExpr() {
return getRuleContext(DistanceMethodCallExprContext.class,0);
}
public GeoLengthMethodCallExprContext geoLengthMethodCallExpr() {
return getRuleContext(GeoLengthMethodCallExprContext.class,0);
}
public TotalOffsetMinutesExprContext totalOffsetMinutesExpr() {
return getRuleContext(TotalOffsetMinutesExprContext.class,0);
}
public ArithmeticMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arithmeticMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterArithmeticMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitArithmeticMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitArithmeticMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ArithmeticMethodCallExprContext arithmeticMethodCallExpr() throws RecognitionException {
ArithmeticMethodCallExprContext _localctx = new ArithmeticMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 44, RULE_arithmeticMethodCallExpr);
try {
setState(501);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Length_LLC:
enterOuterAlt(_localctx, 1);
{
setState(485);
lengthMethodCallExpr();
}
break;
case IndexOf_LLC:
enterOuterAlt(_localctx, 2);
{
setState(486);
indexOfMethodCallExpr();
}
break;
case Year_LLC:
enterOuterAlt(_localctx, 3);
{
setState(487);
yearMethodCallExpr();
}
break;
case Month_LLC:
enterOuterAlt(_localctx, 4);
{
setState(488);
monthMethodCallExpr();
}
break;
case Day_LLC:
enterOuterAlt(_localctx, 5);
{
setState(489);
dayMethodCallExpr();
}
break;
case Days_LLC:
enterOuterAlt(_localctx, 6);
{
setState(490);
daysMethodCallExpr();
}
break;
case Hour_LLC:
enterOuterAlt(_localctx, 7);
{
setState(491);
hourMethodCallExpr();
}
break;
case Minute_LLC:
enterOuterAlt(_localctx, 8);
{
setState(492);
minuteMethodCallExpr();
}
break;
case Second_LLC:
enterOuterAlt(_localctx, 9);
{
setState(493);
secondMethodCallExpr();
}
break;
case Date_LLC:
enterOuterAlt(_localctx, 10);
{
setState(494);
dateMethodCallExpr();
}
break;
case Round_LLC:
enterOuterAlt(_localctx, 11);
{
setState(495);
roundMethodCallExpr();
}
break;
case Floor_LLC:
enterOuterAlt(_localctx, 12);
{
setState(496);
floorMethodCallExpr();
}
break;
case Ceiling_LLC:
enterOuterAlt(_localctx, 13);
{
setState(497);
ceilingMethodCallExpr();
}
break;
case GeoDotDistance_LLC:
enterOuterAlt(_localctx, 14);
{
setState(498);
distanceMethodCallExpr();
}
break;
case GeoLength_LLC:
enterOuterAlt(_localctx, 15);
{
setState(499);
geoLengthMethodCallExpr();
}
break;
case TotalOffsetMinutes_LLC:
enterOuterAlt(_localctx, 16);
{
setState(500);
totalOffsetMinutesExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TemporalMethodCallExprContext extends ParserRuleContext {
public TimeMethodCallExprContext timeMethodCallExpr() {
return getRuleContext(TimeMethodCallExprContext.class,0);
}
public NowDateContext nowDate() {
return getRuleContext(NowDateContext.class,0);
}
public MinDateContext minDate() {
return getRuleContext(MinDateContext.class,0);
}
public MaxDateContext maxDate() {
return getRuleContext(MaxDateContext.class,0);
}
public TemporalMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_temporalMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTemporalMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTemporalMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTemporalMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final TemporalMethodCallExprContext temporalMethodCallExpr() throws RecognitionException {
TemporalMethodCallExprContext _localctx = new TemporalMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 46, RULE_temporalMethodCallExpr);
try {
setState(507);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Time_LLC:
enterOuterAlt(_localctx, 1);
{
setState(503);
timeMethodCallExpr();
}
break;
case Now_LLC:
enterOuterAlt(_localctx, 2);
{
setState(504);
nowDate();
}
break;
case MinDateTime_LLC:
enterOuterAlt(_localctx, 3);
{
setState(505);
minDate();
}
break;
case MaxDateTime_LLC:
enterOuterAlt(_localctx, 4);
{
setState(506);
maxDate();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BoolMethodCallExprContext extends ParserRuleContext {
public EndsWithMethodCallExprContext endsWithMethodCallExpr() {
return getRuleContext(EndsWithMethodCallExprContext.class,0);
}
public StartsWithMethodCallExprContext startsWithMethodCallExpr() {
return getRuleContext(StartsWithMethodCallExprContext.class,0);
}
public SubstringOfMethodCallExprContext substringOfMethodCallExpr() {
return getRuleContext(SubstringOfMethodCallExprContext.class,0);
}
public IntersectsMethodCallExprContext intersectsMethodCallExpr() {
return getRuleContext(IntersectsMethodCallExprContext.class,0);
}
public St_equalsMethodCallExprContext st_equalsMethodCallExpr() {
return getRuleContext(St_equalsMethodCallExprContext.class,0);
}
public St_disjointMethodCallExprContext st_disjointMethodCallExpr() {
return getRuleContext(St_disjointMethodCallExprContext.class,0);
}
public St_touchesMethodCallExprContext st_touchesMethodCallExpr() {
return getRuleContext(St_touchesMethodCallExprContext.class,0);
}
public St_withinMethodCallExprContext st_withinMethodCallExpr() {
return getRuleContext(St_withinMethodCallExprContext.class,0);
}
public St_overlapsMethodCallExprContext st_overlapsMethodCallExpr() {
return getRuleContext(St_overlapsMethodCallExprContext.class,0);
}
public St_crossesMethodCallExprContext st_crossesMethodCallExpr() {
return getRuleContext(St_crossesMethodCallExprContext.class,0);
}
public St_intersectsMethodCallExprContext st_intersectsMethodCallExpr() {
return getRuleContext(St_intersectsMethodCallExprContext.class,0);
}
public St_containsMethodCallExprContext st_containsMethodCallExpr() {
return getRuleContext(St_containsMethodCallExprContext.class,0);
}
public St_relateMethodCallExprContext st_relateMethodCallExpr() {
return getRuleContext(St_relateMethodCallExprContext.class,0);
}
public ContainsMethodCallExprContext containsMethodCallExpr() {
return getRuleContext(ContainsMethodCallExprContext.class,0);
}
public BoolMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boolMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterBoolMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitBoolMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitBoolMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final BoolMethodCallExprContext boolMethodCallExpr() throws RecognitionException {
BoolMethodCallExprContext _localctx = new BoolMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 48, RULE_boolMethodCallExpr);
try {
setState(523);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EndsWith_LLC:
enterOuterAlt(_localctx, 1);
{
setState(509);
endsWithMethodCallExpr();
}
break;
case StartsWith_LLC:
enterOuterAlt(_localctx, 2);
{
setState(510);
startsWithMethodCallExpr();
}
break;
case SubStringOf_LLC:
enterOuterAlt(_localctx, 3);
{
setState(511);
substringOfMethodCallExpr();
}
break;
case GeoDotIntersects_LLC:
enterOuterAlt(_localctx, 4);
{
setState(512);
intersectsMethodCallExpr();
}
break;
case ST_equals_LLC:
enterOuterAlt(_localctx, 5);
{
setState(513);
st_equalsMethodCallExpr();
}
break;
case ST_disjoint_LLC:
enterOuterAlt(_localctx, 6);
{
setState(514);
st_disjointMethodCallExpr();
}
break;
case ST_touches_LLC:
enterOuterAlt(_localctx, 7);
{
setState(515);
st_touchesMethodCallExpr();
}
break;
case ST_within_LLC:
enterOuterAlt(_localctx, 8);
{
setState(516);
st_withinMethodCallExpr();
}
break;
case ST_overlaps_LLC:
enterOuterAlt(_localctx, 9);
{
setState(517);
st_overlapsMethodCallExpr();
}
break;
case ST_crosses_LLC:
enterOuterAlt(_localctx, 10);
{
setState(518);
st_crossesMethodCallExpr();
}
break;
case ST_intersects_LLC:
enterOuterAlt(_localctx, 11);
{
setState(519);
st_intersectsMethodCallExpr();
}
break;
case ST_contains_LLC:
enterOuterAlt(_localctx, 12);
{
setState(520);
st_containsMethodCallExpr();
}
break;
case ST_relate_LLC:
enterOuterAlt(_localctx, 13);
{
setState(521);
st_relateMethodCallExpr();
}
break;
case Contains_LLC:
enterOuterAlt(_localctx, 14);
{
setState(522);
containsMethodCallExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TextOrMemberContext extends ParserRuleContext {
public TextExprContext textExpr() {
return getRuleContext(TextExprContext.class,0);
}
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public TextOrMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_textOrMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTextOrMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTextOrMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTextOrMember(this);
else return visitor.visitChildren(this);
}
}
public final TextOrMemberContext textOrMember() throws RecognitionException {
TextOrMemberContext _localctx = new TextOrMemberContext(_ctx, getState());
enterRule(_localctx, 50, RULE_textOrMember);
try {
enterOuterAlt(_localctx, 1);
{
setState(527);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGIT:
case DIGITPLUS:
case LITERAL:
case Substring_LLC:
case ToLower_LLC:
case ToUpper_LLC:
case Trim_LLC:
case Concat_LLC:
{
setState(525);
textExpr();
}
break;
case ALPHAPLUS:
case Time_LLC:
{
setState(526);
memberExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TemporalOrMemberOrISO8601TimestampContext extends ParserRuleContext {
public TemporalMethodCallExprContext temporalMethodCallExpr() {
return getRuleContext(TemporalMethodCallExprContext.class,0);
}
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public Iso8601TimestampContext iso8601Timestamp() {
return getRuleContext(Iso8601TimestampContext.class,0);
}
public TemporalOrMemberOrISO8601TimestampContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_temporalOrMemberOrISO8601Timestamp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTemporalOrMemberOrISO8601Timestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTemporalOrMemberOrISO8601Timestamp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTemporalOrMemberOrISO8601Timestamp(this);
else return visitor.visitChildren(this);
}
}
public final TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() throws RecognitionException {
TemporalOrMemberOrISO8601TimestampContext _localctx = new TemporalOrMemberOrISO8601TimestampContext(_ctx, getState());
enterRule(_localctx, 52, RULE_temporalOrMemberOrISO8601Timestamp);
try {
enterOuterAlt(_localctx, 1);
{
setState(532);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(529);
temporalMethodCallExpr();
}
break;
case 2:
{
setState(530);
memberExpr();
}
break;
case 3:
{
setState(531);
iso8601Timestamp();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeoOrMemberContext extends ParserRuleContext {
public GeoExprContext geoExpr() {
return getRuleContext(GeoExprContext.class,0);
}
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public GeoOrMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geoOrMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeoOrMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeoOrMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeoOrMember(this);
else return visitor.visitChildren(this);
}
}
public final GeoOrMemberContext geoOrMember() throws RecognitionException {
GeoOrMemberContext _localctx = new GeoOrMemberContext(_ctx, getState());
enterRule(_localctx, 54, RULE_geoOrMember);
try {
enterOuterAlt(_localctx, 1);
{
setState(536);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Geography_LLC:
case Geometry_LLC:
{
setState(534);
geoExpr();
}
break;
case ALPHAPLUS:
case Time_LLC:
{
setState(535);
memberExpr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Iso8601TimestampContext extends ParserRuleContext {
public TerminalNode DIGIT4MINUS() { return getToken(STAQueryOptionsGrammar.DIGIT4MINUS, 0); }
public List DIGIT2() { return getTokens(STAQueryOptionsGrammar.DIGIT2); }
public TerminalNode DIGIT2(int i) {
return getToken(STAQueryOptionsGrammar.DIGIT2, i);
}
public TerminalNode MINUS() { return getToken(STAQueryOptionsGrammar.MINUS, 0); }
public TerminalNode T() { return getToken(STAQueryOptionsGrammar.T, 0); }
public List COLON() { return getTokens(STAQueryOptionsGrammar.COLON); }
public TerminalNode COLON(int i) {
return getToken(STAQueryOptionsGrammar.COLON, i);
}
public Iso8601TimezoneContext iso8601Timezone() {
return getRuleContext(Iso8601TimezoneContext.class,0);
}
public TerminalNode DOT() { return getToken(STAQueryOptionsGrammar.DOT, 0); }
public TerminalNode DIGIT3() { return getToken(STAQueryOptionsGrammar.DIGIT3, 0); }
public Iso8601TimestampContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iso8601Timestamp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterIso8601Timestamp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitIso8601Timestamp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitIso8601Timestamp(this);
else return visitor.visitChildren(this);
}
}
public final Iso8601TimestampContext iso8601Timestamp() throws RecognitionException {
Iso8601TimestampContext _localctx = new Iso8601TimestampContext(_ctx, getState());
enterRule(_localctx, 56, RULE_iso8601Timestamp);
try {
enterOuterAlt(_localctx, 1);
{
setState(538);
match(DIGIT4MINUS);
setState(539);
match(DIGIT2);
setState(540);
match(MINUS);
setState(541);
match(DIGIT2);
setState(542);
match(T);
setState(543);
match(DIGIT2);
setState(544);
match(COLON);
setState(545);
match(DIGIT2);
setState(546);
match(COLON);
setState(551);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(547);
match(DIGIT2);
}
break;
case 2:
{
{
setState(548);
match(DIGIT2);
setState(549);
match(DOT);
setState(550);
match(DIGIT3);
}
}
break;
}
setState(553);
iso8601Timezone();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Iso8601TimezoneContext extends ParserRuleContext {
public TerminalNode Z() { return getToken(STAQueryOptionsGrammar.Z, 0); }
public TerminalNode SIGN() { return getToken(STAQueryOptionsGrammar.SIGN, 0); }
public List DIGIT2() { return getTokens(STAQueryOptionsGrammar.DIGIT2); }
public TerminalNode DIGIT2(int i) {
return getToken(STAQueryOptionsGrammar.DIGIT2, i);
}
public TerminalNode COLON() { return getToken(STAQueryOptionsGrammar.COLON, 0); }
public Iso8601TimezoneContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iso8601Timezone; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterIso8601Timezone(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitIso8601Timezone(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitIso8601Timezone(this);
else return visitor.visitChildren(this);
}
}
public final Iso8601TimezoneContext iso8601Timezone() throws RecognitionException {
Iso8601TimezoneContext _localctx = new Iso8601TimezoneContext(_ctx, getState());
enterRule(_localctx, 58, RULE_iso8601Timezone);
int _la;
try {
setState(562);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Z:
enterOuterAlt(_localctx, 1);
{
setState(555);
match(Z);
}
break;
case SIGN:
enterOuterAlt(_localctx, 2);
{
setState(556);
match(SIGN);
setState(557);
match(DIGIT2);
setState(560);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(558);
match(COLON);
setState(559);
match(DIGIT2);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubstringMethodCallExprContext extends ParserRuleContext {
public TerminalNode Substring_LLC() { return getToken(STAQueryOptionsGrammar.Substring_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TextOrMemberContext textOrMember() {
return getRuleContext(TextOrMemberContext.class,0);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public SubstringMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substringMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSubstringMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSubstringMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSubstringMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final SubstringMethodCallExprContext substringMethodCallExpr() throws RecognitionException {
SubstringMethodCallExprContext _localctx = new SubstringMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 60, RULE_substringMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(564);
match(Substring_LLC);
setState(565);
match(OP);
setState(569);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(566);
match(SP);
}
}
setState(571);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(572);
textOrMember();
setState(576);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(573);
match(SP);
}
}
setState(578);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(579);
match(COMMA);
setState(583);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(580);
match(SP);
}
}
setState(585);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(586);
arithmeticExpr();
setState(587);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ToLowerMethodCallExprContext extends ParserRuleContext {
public TerminalNode ToLower_LLC() { return getToken(STAQueryOptionsGrammar.ToLower_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TextOrMemberContext textOrMember() {
return getRuleContext(TextOrMemberContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ToLowerMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_toLowerMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterToLowerMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitToLowerMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitToLowerMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ToLowerMethodCallExprContext toLowerMethodCallExpr() throws RecognitionException {
ToLowerMethodCallExprContext _localctx = new ToLowerMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 62, RULE_toLowerMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(589);
match(ToLower_LLC);
setState(590);
match(OP);
setState(594);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(591);
match(SP);
}
}
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(597);
textOrMember();
setState(601);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(598);
match(SP);
}
}
setState(603);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(604);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ToUpperMethodCallExprContext extends ParserRuleContext {
public TerminalNode ToUpper_LLC() { return getToken(STAQueryOptionsGrammar.ToUpper_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TextOrMemberContext textOrMember() {
return getRuleContext(TextOrMemberContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ToUpperMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_toUpperMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterToUpperMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitToUpperMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitToUpperMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ToUpperMethodCallExprContext toUpperMethodCallExpr() throws RecognitionException {
ToUpperMethodCallExprContext _localctx = new ToUpperMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 64, RULE_toUpperMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(606);
match(ToUpper_LLC);
setState(607);
match(OP);
setState(611);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(608);
match(SP);
}
}
setState(613);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(614);
textOrMember();
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(615);
match(SP);
}
}
setState(620);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(621);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TrimMethodCallExprContext extends ParserRuleContext {
public TerminalNode Trim_LLC() { return getToken(STAQueryOptionsGrammar.Trim_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TextOrMemberContext textOrMember() {
return getRuleContext(TextOrMemberContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TrimMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTrimMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTrimMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTrimMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final TrimMethodCallExprContext trimMethodCallExpr() throws RecognitionException {
TrimMethodCallExprContext _localctx = new TrimMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 66, RULE_trimMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(623);
match(Trim_LLC);
setState(624);
match(OP);
setState(628);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(625);
match(SP);
}
}
setState(630);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(631);
textOrMember();
setState(635);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(632);
match(SP);
}
}
setState(637);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(638);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConcatMethodCallExprContext extends ParserRuleContext {
public TerminalNode Concat_LLC() { return getToken(STAQueryOptionsGrammar.Concat_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List textOrMember() {
return getRuleContexts(TextOrMemberContext.class);
}
public TextOrMemberContext textOrMember(int i) {
return getRuleContext(TextOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ConcatMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_concatMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterConcatMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitConcatMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitConcatMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ConcatMethodCallExprContext concatMethodCallExpr() throws RecognitionException {
ConcatMethodCallExprContext _localctx = new ConcatMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 68, RULE_concatMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(640);
match(Concat_LLC);
setState(641);
match(OP);
setState(645);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(642);
match(SP);
}
}
setState(647);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(648);
textOrMember();
setState(652);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(649);
match(SP);
}
}
setState(654);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(655);
match(COMMA);
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(656);
match(SP);
}
}
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(662);
textOrMember();
setState(666);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(663);
match(SP);
}
}
setState(668);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(669);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubstringOfMethodCallExprContext extends ParserRuleContext {
public TerminalNode SubStringOf_LLC() { return getToken(STAQueryOptionsGrammar.SubStringOf_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List textOrMember() {
return getRuleContexts(TextOrMemberContext.class);
}
public TextOrMemberContext textOrMember(int i) {
return getRuleContext(TextOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public SubstringOfMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_substringOfMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSubstringOfMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSubstringOfMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSubstringOfMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final SubstringOfMethodCallExprContext substringOfMethodCallExpr() throws RecognitionException {
SubstringOfMethodCallExprContext _localctx = new SubstringOfMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 70, RULE_substringOfMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(671);
match(SubStringOf_LLC);
setState(672);
match(OP);
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(673);
match(SP);
}
}
setState(678);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(679);
textOrMember();
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(680);
match(SP);
}
}
setState(685);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(686);
match(COMMA);
setState(690);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(687);
match(SP);
}
}
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(693);
textOrMember();
setState(697);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(694);
match(SP);
}
}
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(700);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StartsWithMethodCallExprContext extends ParserRuleContext {
public TerminalNode StartsWith_LLC() { return getToken(STAQueryOptionsGrammar.StartsWith_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List textOrMember() {
return getRuleContexts(TextOrMemberContext.class);
}
public TextOrMemberContext textOrMember(int i) {
return getRuleContext(TextOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public StartsWithMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_startsWithMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterStartsWithMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitStartsWithMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitStartsWithMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final StartsWithMethodCallExprContext startsWithMethodCallExpr() throws RecognitionException {
StartsWithMethodCallExprContext _localctx = new StartsWithMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_startsWithMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(702);
match(StartsWith_LLC);
setState(703);
match(OP);
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(704);
match(SP);
}
}
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(710);
textOrMember();
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(711);
match(SP);
}
}
setState(716);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(717);
match(COMMA);
setState(721);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(718);
match(SP);
}
}
setState(723);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(724);
textOrMember();
setState(728);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(725);
match(SP);
}
}
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(731);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EndsWithMethodCallExprContext extends ParserRuleContext {
public TerminalNode EndsWith_LLC() { return getToken(STAQueryOptionsGrammar.EndsWith_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List textOrMember() {
return getRuleContexts(TextOrMemberContext.class);
}
public TextOrMemberContext textOrMember(int i) {
return getRuleContext(TextOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public EndsWithMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_endsWithMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterEndsWithMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitEndsWithMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitEndsWithMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final EndsWithMethodCallExprContext endsWithMethodCallExpr() throws RecognitionException {
EndsWithMethodCallExprContext _localctx = new EndsWithMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 74, RULE_endsWithMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(733);
match(EndsWith_LLC);
setState(734);
match(OP);
setState(738);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(735);
match(SP);
}
}
setState(740);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(741);
textOrMember();
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(742);
match(SP);
}
}
setState(747);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(748);
match(COMMA);
setState(752);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(749);
match(SP);
}
}
setState(754);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(755);
textOrMember();
setState(759);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(756);
match(SP);
}
}
setState(761);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(762);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ContainsMethodCallExprContext extends ParserRuleContext {
public TerminalNode Contains_LLC() { return getToken(STAQueryOptionsGrammar.Contains_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public MemberExprContext memberExpr() {
return getRuleContext(MemberExprContext.class,0);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List boolExpr() {
return getRuleContexts(BoolExprContext.class);
}
public BoolExprContext boolExpr(int i) {
return getRuleContext(BoolExprContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public ContainsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_containsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterContainsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitContainsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitContainsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ContainsMethodCallExprContext containsMethodCallExpr() throws RecognitionException {
ContainsMethodCallExprContext _localctx = new ContainsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_containsMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(764);
match(Contains_LLC);
setState(765);
match(OP);
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(766);
match(SP);
}
}
setState(771);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(772);
memberExpr();
setState(776);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(773);
match(SP);
}
}
setState(778);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(779);
match(COMMA);
setState(783);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(780);
match(SP);
}
}
setState(785);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(786);
boolExpr();
setState(790);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(787);
match(SP);
}
}
setState(792);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(793);
match(COMMA);
setState(797);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(794);
match(SP);
}
}
setState(799);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(800);
boolExpr();
setState(804);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(801);
match(SP);
}
}
setState(806);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(807);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntersectsMethodCallExprContext extends ParserRuleContext {
public TerminalNode GeoDotIntersects_LLC() { return getToken(STAQueryOptionsGrammar.GeoDotIntersects_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List geoOrMember() {
return getRuleContexts(GeoOrMemberContext.class);
}
public GeoOrMemberContext geoOrMember(int i) {
return getRuleContext(GeoOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public IntersectsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intersectsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterIntersectsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitIntersectsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitIntersectsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final IntersectsMethodCallExprContext intersectsMethodCallExpr() throws RecognitionException {
IntersectsMethodCallExprContext _localctx = new IntersectsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 78, RULE_intersectsMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(809);
match(GeoDotIntersects_LLC);
setState(810);
match(OP);
setState(814);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(811);
match(SP);
}
}
setState(816);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(817);
geoOrMember();
setState(821);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(818);
match(SP);
}
}
setState(823);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(824);
match(COMMA);
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(825);
match(SP);
}
}
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(831);
geoOrMember();
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(832);
match(SP);
}
}
setState(837);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(838);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_commonMethodCallExprContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List geoOrMember() {
return getRuleContexts(GeoOrMemberContext.class);
}
public GeoOrMemberContext geoOrMember(int i) {
return getRuleContext(GeoOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public St_commonMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_commonMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_commonMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_commonMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_commonMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_commonMethodCallExprContext st_commonMethodCallExpr() throws RecognitionException {
St_commonMethodCallExprContext _localctx = new St_commonMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 80, RULE_st_commonMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(840);
match(OP);
setState(844);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(841);
match(SP);
}
}
setState(846);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(847);
geoOrMember();
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(848);
match(SP);
}
}
setState(853);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(854);
match(COMMA);
setState(858);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(855);
match(SP);
}
}
setState(860);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(861);
geoOrMember();
setState(865);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(862);
match(SP);
}
}
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(868);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_equalsMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_equals_LLC() { return getToken(STAQueryOptionsGrammar.ST_equals_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_equalsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_equalsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_equalsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_equalsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_equalsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_equalsMethodCallExprContext st_equalsMethodCallExpr() throws RecognitionException {
St_equalsMethodCallExprContext _localctx = new St_equalsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 82, RULE_st_equalsMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(870);
match(ST_equals_LLC);
setState(871);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_disjointMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_disjoint_LLC() { return getToken(STAQueryOptionsGrammar.ST_disjoint_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_disjointMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_disjointMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_disjointMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_disjointMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_disjointMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_disjointMethodCallExprContext st_disjointMethodCallExpr() throws RecognitionException {
St_disjointMethodCallExprContext _localctx = new St_disjointMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 84, RULE_st_disjointMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(873);
match(ST_disjoint_LLC);
setState(874);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_touchesMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_touches_LLC() { return getToken(STAQueryOptionsGrammar.ST_touches_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_touchesMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_touchesMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_touchesMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_touchesMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_touchesMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_touchesMethodCallExprContext st_touchesMethodCallExpr() throws RecognitionException {
St_touchesMethodCallExprContext _localctx = new St_touchesMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 86, RULE_st_touchesMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(876);
match(ST_touches_LLC);
setState(877);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_withinMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_within_LLC() { return getToken(STAQueryOptionsGrammar.ST_within_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_withinMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_withinMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_withinMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_withinMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_withinMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_withinMethodCallExprContext st_withinMethodCallExpr() throws RecognitionException {
St_withinMethodCallExprContext _localctx = new St_withinMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 88, RULE_st_withinMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(879);
match(ST_within_LLC);
setState(880);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_overlapsMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_overlaps_LLC() { return getToken(STAQueryOptionsGrammar.ST_overlaps_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_overlapsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_overlapsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_overlapsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_overlapsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_overlapsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_overlapsMethodCallExprContext st_overlapsMethodCallExpr() throws RecognitionException {
St_overlapsMethodCallExprContext _localctx = new St_overlapsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 90, RULE_st_overlapsMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(882);
match(ST_overlaps_LLC);
setState(883);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_crossesMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_crosses_LLC() { return getToken(STAQueryOptionsGrammar.ST_crosses_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_crossesMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_crossesMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_crossesMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_crossesMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_crossesMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_crossesMethodCallExprContext st_crossesMethodCallExpr() throws RecognitionException {
St_crossesMethodCallExprContext _localctx = new St_crossesMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 92, RULE_st_crossesMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(885);
match(ST_crosses_LLC);
setState(886);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_intersectsMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_intersects_LLC() { return getToken(STAQueryOptionsGrammar.ST_intersects_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_intersectsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_intersectsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_intersectsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_intersectsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_intersectsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_intersectsMethodCallExprContext st_intersectsMethodCallExpr() throws RecognitionException {
St_intersectsMethodCallExprContext _localctx = new St_intersectsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 94, RULE_st_intersectsMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(888);
match(ST_intersects_LLC);
setState(889);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_containsMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_contains_LLC() { return getToken(STAQueryOptionsGrammar.ST_contains_LLC, 0); }
public St_commonMethodCallExprContext st_commonMethodCallExpr() {
return getRuleContext(St_commonMethodCallExprContext.class,0);
}
public St_containsMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_containsMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_containsMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_containsMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_containsMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_containsMethodCallExprContext st_containsMethodCallExpr() throws RecognitionException {
St_containsMethodCallExprContext _localctx = new St_containsMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 96, RULE_st_containsMethodCallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(891);
match(ST_contains_LLC);
setState(892);
st_commonMethodCallExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class St_relateMethodCallExprContext extends ParserRuleContext {
public TerminalNode ST_relate_LLC() { return getToken(STAQueryOptionsGrammar.ST_relate_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List geoOrMember() {
return getRuleContexts(GeoOrMemberContext.class);
}
public GeoOrMemberContext geoOrMember(int i) {
return getRuleContext(GeoOrMemberContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public EscapedStringContext escapedString() {
return getRuleContext(EscapedStringContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public St_relateMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_st_relateMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSt_relateMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSt_relateMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSt_relateMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final St_relateMethodCallExprContext st_relateMethodCallExpr() throws RecognitionException {
St_relateMethodCallExprContext _localctx = new St_relateMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 98, RULE_st_relateMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(894);
match(ST_relate_LLC);
setState(895);
match(OP);
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(896);
match(SP);
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(902);
geoOrMember();
setState(906);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(903);
match(SP);
}
}
setState(908);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(909);
match(COMMA);
setState(913);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(910);
match(SP);
}
}
setState(915);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(916);
geoOrMember();
setState(920);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(917);
match(SP);
}
}
setState(922);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(923);
match(COMMA);
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(924);
match(SP);
}
}
setState(929);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(930);
escapedString();
setState(934);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(931);
match(SP);
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(937);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LengthMethodCallExprContext extends ParserRuleContext {
public TerminalNode Length_LLC() { return getToken(STAQueryOptionsGrammar.Length_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TextOrMemberContext textOrMember() {
return getRuleContext(TextOrMemberContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public LengthMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lengthMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterLengthMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitLengthMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitLengthMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final LengthMethodCallExprContext lengthMethodCallExpr() throws RecognitionException {
LengthMethodCallExprContext _localctx = new LengthMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 100, RULE_lengthMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(939);
match(Length_LLC);
setState(940);
match(OP);
setState(944);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(941);
match(SP);
}
}
setState(946);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(947);
textOrMember();
setState(951);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(948);
match(SP);
}
}
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(954);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IndexOfMethodCallExprContext extends ParserRuleContext {
public TerminalNode IndexOf_LLC() { return getToken(STAQueryOptionsGrammar.IndexOf_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List textOrMember() {
return getRuleContexts(TextOrMemberContext.class);
}
public TextOrMemberContext textOrMember(int i) {
return getRuleContext(TextOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public IndexOfMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexOfMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterIndexOfMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitIndexOfMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitIndexOfMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final IndexOfMethodCallExprContext indexOfMethodCallExpr() throws RecognitionException {
IndexOfMethodCallExprContext _localctx = new IndexOfMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 102, RULE_indexOfMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(956);
match(IndexOf_LLC);
setState(957);
match(OP);
setState(961);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(958);
match(SP);
}
}
setState(963);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(964);
textOrMember();
setState(968);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(965);
match(SP);
}
}
setState(970);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(971);
match(COMMA);
setState(975);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(972);
match(SP);
}
}
setState(977);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(978);
textOrMember();
setState(982);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(979);
match(SP);
}
}
setState(984);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(985);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class YearMethodCallExprContext extends ParserRuleContext {
public TerminalNode Year_LLC() { return getToken(STAQueryOptionsGrammar.Year_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public YearMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yearMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterYearMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitYearMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitYearMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final YearMethodCallExprContext yearMethodCallExpr() throws RecognitionException {
YearMethodCallExprContext _localctx = new YearMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 104, RULE_yearMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(987);
match(Year_LLC);
setState(988);
match(OP);
setState(992);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(989);
match(SP);
}
}
setState(994);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(995);
temporalOrMemberOrISO8601Timestamp();
setState(999);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(996);
match(SP);
}
}
setState(1001);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1002);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MonthMethodCallExprContext extends ParserRuleContext {
public TerminalNode Month_LLC() { return getToken(STAQueryOptionsGrammar.Month_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public MonthMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_monthMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMonthMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMonthMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMonthMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final MonthMethodCallExprContext monthMethodCallExpr() throws RecognitionException {
MonthMethodCallExprContext _localctx = new MonthMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 106, RULE_monthMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1004);
match(Month_LLC);
setState(1005);
match(OP);
setState(1009);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1006);
match(SP);
}
}
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1012);
temporalOrMemberOrISO8601Timestamp();
setState(1016);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1013);
match(SP);
}
}
setState(1018);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1019);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DayMethodCallExprContext extends ParserRuleContext {
public TerminalNode Day_LLC() { return getToken(STAQueryOptionsGrammar.Day_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public DayMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dayMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDayMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDayMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDayMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final DayMethodCallExprContext dayMethodCallExpr() throws RecognitionException {
DayMethodCallExprContext _localctx = new DayMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 108, RULE_dayMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1021);
match(Day_LLC);
setState(1022);
match(OP);
setState(1026);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1023);
match(SP);
}
}
setState(1028);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1029);
temporalOrMemberOrISO8601Timestamp();
setState(1033);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1030);
match(SP);
}
}
setState(1035);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1036);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DaysMethodCallExprContext extends ParserRuleContext {
public TerminalNode Days_LLC() { return getToken(STAQueryOptionsGrammar.Days_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public DaysMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_daysMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDaysMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDaysMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDaysMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final DaysMethodCallExprContext daysMethodCallExpr() throws RecognitionException {
DaysMethodCallExprContext _localctx = new DaysMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 110, RULE_daysMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1038);
match(Days_LLC);
setState(1039);
match(OP);
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1040);
match(SP);
}
}
setState(1045);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1046);
temporalOrMemberOrISO8601Timestamp();
setState(1050);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1047);
match(SP);
}
}
setState(1052);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1053);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HourMethodCallExprContext extends ParserRuleContext {
public TerminalNode Hour_LLC() { return getToken(STAQueryOptionsGrammar.Hour_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public HourMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hourMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterHourMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitHourMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitHourMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final HourMethodCallExprContext hourMethodCallExpr() throws RecognitionException {
HourMethodCallExprContext _localctx = new HourMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 112, RULE_hourMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1055);
match(Hour_LLC);
setState(1056);
match(OP);
setState(1060);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1057);
match(SP);
}
}
setState(1062);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1063);
temporalOrMemberOrISO8601Timestamp();
setState(1067);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1064);
match(SP);
}
}
setState(1069);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1070);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MinuteMethodCallExprContext extends ParserRuleContext {
public TerminalNode Minute_LLC() { return getToken(STAQueryOptionsGrammar.Minute_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public MinuteMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minuteMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMinuteMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMinuteMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMinuteMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final MinuteMethodCallExprContext minuteMethodCallExpr() throws RecognitionException {
MinuteMethodCallExprContext _localctx = new MinuteMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 114, RULE_minuteMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1072);
match(Minute_LLC);
setState(1073);
match(OP);
setState(1077);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1074);
match(SP);
}
}
setState(1079);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1080);
temporalOrMemberOrISO8601Timestamp();
setState(1084);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1081);
match(SP);
}
}
setState(1086);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1087);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SecondMethodCallExprContext extends ParserRuleContext {
public TerminalNode Second_LLC() { return getToken(STAQueryOptionsGrammar.Second_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public SecondMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSecondMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSecondMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSecondMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final SecondMethodCallExprContext secondMethodCallExpr() throws RecognitionException {
SecondMethodCallExprContext _localctx = new SecondMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 116, RULE_secondMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1089);
match(Second_LLC);
setState(1090);
match(OP);
setState(1094);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1091);
match(SP);
}
}
setState(1096);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1097);
temporalOrMemberOrISO8601Timestamp();
setState(1101);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1098);
match(SP);
}
}
setState(1103);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1104);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TimeMethodCallExprContext extends ParserRuleContext {
public TerminalNode Time_LLC() { return getToken(STAQueryOptionsGrammar.Time_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TimeMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTimeMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTimeMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTimeMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final TimeMethodCallExprContext timeMethodCallExpr() throws RecognitionException {
TimeMethodCallExprContext _localctx = new TimeMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 118, RULE_timeMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1106);
match(Time_LLC);
setState(1107);
match(OP);
setState(1111);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1108);
match(SP);
}
}
setState(1113);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1114);
temporalOrMemberOrISO8601Timestamp();
setState(1118);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1115);
match(SP);
}
}
setState(1120);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1121);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DateMethodCallExprContext extends ParserRuleContext {
public TerminalNode Date_LLC() { return getToken(STAQueryOptionsGrammar.Date_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public DateMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDateMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDateMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDateMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final DateMethodCallExprContext dateMethodCallExpr() throws RecognitionException {
DateMethodCallExprContext _localctx = new DateMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 120, RULE_dateMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1123);
match(Date_LLC);
setState(1124);
match(OP);
setState(1128);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1125);
match(SP);
}
}
setState(1130);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1131);
temporalOrMemberOrISO8601Timestamp();
setState(1135);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1132);
match(SP);
}
}
setState(1137);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1138);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RoundMethodCallExprContext extends ParserRuleContext {
public TerminalNode Round_LLC() { return getToken(STAQueryOptionsGrammar.Round_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public RoundMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_roundMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterRoundMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitRoundMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitRoundMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final RoundMethodCallExprContext roundMethodCallExpr() throws RecognitionException {
RoundMethodCallExprContext _localctx = new RoundMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 122, RULE_roundMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1140);
match(Round_LLC);
setState(1141);
match(OP);
setState(1145);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1142);
match(SP);
}
}
setState(1147);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1148);
arithmeticExpr();
setState(1152);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1149);
match(SP);
}
}
setState(1154);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1155);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FloorMethodCallExprContext extends ParserRuleContext {
public TerminalNode Floor_LLC() { return getToken(STAQueryOptionsGrammar.Floor_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public FloorMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_floorMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFloorMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFloorMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFloorMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final FloorMethodCallExprContext floorMethodCallExpr() throws RecognitionException {
FloorMethodCallExprContext _localctx = new FloorMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 124, RULE_floorMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1157);
match(Floor_LLC);
setState(1158);
match(OP);
setState(1162);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1159);
match(SP);
}
}
setState(1164);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1165);
arithmeticExpr();
setState(1169);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1166);
match(SP);
}
}
setState(1171);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1172);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CeilingMethodCallExprContext extends ParserRuleContext {
public TerminalNode Ceiling_LLC() { return getToken(STAQueryOptionsGrammar.Ceiling_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public CeilingMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ceilingMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterCeilingMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitCeilingMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitCeilingMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final CeilingMethodCallExprContext ceilingMethodCallExpr() throws RecognitionException {
CeilingMethodCallExprContext _localctx = new CeilingMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 126, RULE_ceilingMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1174);
match(Ceiling_LLC);
setState(1175);
match(OP);
setState(1179);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1176);
match(SP);
}
}
setState(1181);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1182);
arithmeticExpr();
setState(1186);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1183);
match(SP);
}
}
setState(1188);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1189);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TotalOffsetMinutesExprContext extends ParserRuleContext {
public TerminalNode TotalOffsetMinutes_LLC() { return getToken(STAQueryOptionsGrammar.TotalOffsetMinutes_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TemporalOrMemberOrISO8601TimestampContext temporalOrMemberOrISO8601Timestamp() {
return getRuleContext(TemporalOrMemberOrISO8601TimestampContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TotalOffsetMinutesExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_totalOffsetMinutesExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterTotalOffsetMinutesExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitTotalOffsetMinutesExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitTotalOffsetMinutesExpr(this);
else return visitor.visitChildren(this);
}
}
public final TotalOffsetMinutesExprContext totalOffsetMinutesExpr() throws RecognitionException {
TotalOffsetMinutesExprContext _localctx = new TotalOffsetMinutesExprContext(_ctx, getState());
enterRule(_localctx, 128, RULE_totalOffsetMinutesExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1191);
match(TotalOffsetMinutes_LLC);
setState(1192);
match(OP);
setState(1196);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1193);
match(SP);
}
}
setState(1198);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1199);
temporalOrMemberOrISO8601Timestamp();
setState(1203);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1200);
match(SP);
}
}
setState(1205);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1206);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DistanceMethodCallExprContext extends ParserRuleContext {
public TerminalNode GeoDotDistance_LLC() { return getToken(STAQueryOptionsGrammar.GeoDotDistance_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List geoOrMember() {
return getRuleContexts(GeoOrMemberContext.class);
}
public GeoOrMemberContext geoOrMember(int i) {
return getRuleContext(GeoOrMemberContext.class,i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public DistanceMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_distanceMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDistanceMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDistanceMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDistanceMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final DistanceMethodCallExprContext distanceMethodCallExpr() throws RecognitionException {
DistanceMethodCallExprContext _localctx = new DistanceMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 130, RULE_distanceMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1208);
match(GeoDotDistance_LLC);
setState(1209);
match(OP);
setState(1213);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1210);
match(SP);
}
}
setState(1215);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1216);
geoOrMember();
setState(1220);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1217);
match(SP);
}
}
setState(1222);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1223);
match(COMMA);
setState(1227);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1224);
match(SP);
}
}
setState(1229);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1230);
geoOrMember();
setState(1234);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1231);
match(SP);
}
}
setState(1236);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1237);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeoLengthMethodCallExprContext extends ParserRuleContext {
public TerminalNode GeoLength_LLC() { return getToken(STAQueryOptionsGrammar.GeoLength_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public GeoOrMemberContext geoOrMember() {
return getRuleContext(GeoOrMemberContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public GeoLengthMethodCallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geoLengthMethodCallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeoLengthMethodCallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeoLengthMethodCallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeoLengthMethodCallExpr(this);
else return visitor.visitChildren(this);
}
}
public final GeoLengthMethodCallExprContext geoLengthMethodCallExpr() throws RecognitionException {
GeoLengthMethodCallExprContext _localctx = new GeoLengthMethodCallExprContext(_ctx, getState());
enterRule(_localctx, 132, RULE_geoLengthMethodCallExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1239);
match(GeoLength_LLC);
setState(1240);
match(OP);
setState(1244);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1241);
match(SP);
}
}
setState(1246);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1247);
geoOrMember();
setState(1251);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1248);
match(SP);
}
}
setState(1253);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1254);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MinDateContext extends ParserRuleContext {
public TerminalNode MinDateTime_LLC() { return getToken(STAQueryOptionsGrammar.MinDateTime_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public MinDateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_minDate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMinDate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMinDate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMinDate(this);
else return visitor.visitChildren(this);
}
}
public final MinDateContext minDate() throws RecognitionException {
MinDateContext _localctx = new MinDateContext(_ctx, getState());
enterRule(_localctx, 134, RULE_minDate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1256);
match(MinDateTime_LLC);
setState(1257);
match(OP);
setState(1261);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1258);
match(SP);
}
}
setState(1263);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1264);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MaxDateContext extends ParserRuleContext {
public TerminalNode MaxDateTime_LLC() { return getToken(STAQueryOptionsGrammar.MaxDateTime_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public MaxDateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_maxDate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMaxDate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMaxDate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMaxDate(this);
else return visitor.visitChildren(this);
}
}
public final MaxDateContext maxDate() throws RecognitionException {
MaxDateContext _localctx = new MaxDateContext(_ctx, getState());
enterRule(_localctx, 136, RULE_maxDate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1266);
match(MaxDateTime_LLC);
setState(1267);
match(OP);
setState(1271);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1268);
match(SP);
}
}
setState(1273);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1274);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NowDateContext extends ParserRuleContext {
public TerminalNode Now_LLC() { return getToken(STAQueryOptionsGrammar.Now_LLC, 0); }
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public NowDateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nowDate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterNowDate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitNowDate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitNowDate(this);
else return visitor.visitChildren(this);
}
}
public final NowDateContext nowDate() throws RecognitionException {
NowDateContext _localctx = new NowDateContext(_ctx, getState());
enterRule(_localctx, 138, RULE_nowDate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1276);
match(Now_LLC);
setState(1277);
match(OP);
setState(1281);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1278);
match(SP);
}
}
setState(1283);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1284);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AndExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode And_LLC() { return getToken(STAQueryOptionsGrammar.And_LLC, 0); }
public BoolExprContext boolExpr() {
return getRuleContext(BoolExprContext.class,0);
}
public AndExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitAndExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitAndExpr(this);
else return visitor.visitChildren(this);
}
}
public final AndExprContext andExpr() throws RecognitionException {
AndExprContext _localctx = new AndExprContext(_ctx, getState());
enterRule(_localctx, 140, RULE_andExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1286);
match(SP);
setState(1287);
match(And_LLC);
setState(1288);
match(SP);
setState(1289);
boolExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Or_LLC() { return getToken(STAQueryOptionsGrammar.Or_LLC, 0); }
public BoolExprContext boolExpr() {
return getRuleContext(BoolExprContext.class,0);
}
public OrExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitOrExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitOrExpr(this);
else return visitor.visitChildren(this);
}
}
public final OrExprContext orExpr() throws RecognitionException {
OrExprContext _localctx = new OrExprContext(_ctx, getState());
enterRule(_localctx, 142, RULE_orExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1291);
match(SP);
setState(1292);
match(Or_LLC);
setState(1293);
match(SP);
setState(1294);
boolExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NotExprContext extends ParserRuleContext {
public TerminalNode Not_LLC() { return getToken(STAQueryOptionsGrammar.Not_LLC, 0); }
public TerminalNode SP() { return getToken(STAQueryOptionsGrammar.SP, 0); }
public BoolExprContext boolExpr() {
return getRuleContext(BoolExprContext.class,0);
}
public NotExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterNotExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitNotExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitNotExpr(this);
else return visitor.visitChildren(this);
}
}
public final NotExprContext notExpr() throws RecognitionException {
NotExprContext _localctx = new NotExprContext(_ctx, getState());
enterRule(_localctx, 144, RULE_notExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1296);
match(Not_LLC);
setState(1297);
match(SP);
setState(1298);
boolExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EqExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Eq_LLC() { return getToken(STAQueryOptionsGrammar.Eq_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public EqExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eqExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterEqExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitEqExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitEqExpr(this);
else return visitor.visitChildren(this);
}
}
public final EqExprContext eqExpr() throws RecognitionException {
EqExprContext _localctx = new EqExprContext(_ctx, getState());
enterRule(_localctx, 146, RULE_eqExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1300);
match(SP);
setState(1301);
match(Eq_LLC);
setState(1302);
match(SP);
setState(1303);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NeExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Ne_LLC() { return getToken(STAQueryOptionsGrammar.Ne_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public NeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_neExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterNeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitNeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitNeExpr(this);
else return visitor.visitChildren(this);
}
}
public final NeExprContext neExpr() throws RecognitionException {
NeExprContext _localctx = new NeExprContext(_ctx, getState());
enterRule(_localctx, 148, RULE_neExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1305);
match(SP);
setState(1306);
match(Ne_LLC);
setState(1307);
match(SP);
setState(1308);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LtExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Lt_LLC() { return getToken(STAQueryOptionsGrammar.Lt_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public LtExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ltExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterLtExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitLtExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitLtExpr(this);
else return visitor.visitChildren(this);
}
}
public final LtExprContext ltExpr() throws RecognitionException {
LtExprContext _localctx = new LtExprContext(_ctx, getState());
enterRule(_localctx, 150, RULE_ltExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1310);
match(SP);
setState(1311);
match(Lt_LLC);
setState(1312);
match(SP);
setState(1313);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LeExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Le_LLC() { return getToken(STAQueryOptionsGrammar.Le_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public LeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_leExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterLeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitLeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitLeExpr(this);
else return visitor.visitChildren(this);
}
}
public final LeExprContext leExpr() throws RecognitionException {
LeExprContext _localctx = new LeExprContext(_ctx, getState());
enterRule(_localctx, 152, RULE_leExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1315);
match(SP);
setState(1316);
match(Le_LLC);
setState(1317);
match(SP);
setState(1318);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GtExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Gt_LLC() { return getToken(STAQueryOptionsGrammar.Gt_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public GtExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gtExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGtExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGtExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGtExpr(this);
else return visitor.visitChildren(this);
}
}
public final GtExprContext gtExpr() throws RecognitionException {
GtExprContext _localctx = new GtExprContext(_ctx, getState());
enterRule(_localctx, 154, RULE_gtExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1320);
match(SP);
setState(1321);
match(Gt_LLC);
setState(1322);
match(SP);
setState(1323);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Ge_LLC() { return getToken(STAQueryOptionsGrammar.Ge_LLC, 0); }
public AnyExprContext anyExpr() {
return getRuleContext(AnyExprContext.class,0);
}
public GeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeExpr(this);
else return visitor.visitChildren(this);
}
}
public final GeExprContext geExpr() throws RecognitionException {
GeExprContext _localctx = new GeExprContext(_ctx, getState());
enterRule(_localctx, 156, RULE_geExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1325);
match(SP);
setState(1326);
match(Ge_LLC);
setState(1327);
match(SP);
setState(1328);
anyExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AddExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Add_LLC() { return getToken(STAQueryOptionsGrammar.Add_LLC, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public AddExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_addExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterAddExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitAddExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitAddExpr(this);
else return visitor.visitChildren(this);
}
}
public final AddExprContext addExpr() throws RecognitionException {
AddExprContext _localctx = new AddExprContext(_ctx, getState());
enterRule(_localctx, 158, RULE_addExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1330);
match(SP);
setState(1331);
match(Add_LLC);
setState(1332);
match(SP);
setState(1333);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Sub_LLC() { return getToken(STAQueryOptionsGrammar.Sub_LLC, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public SubExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSubExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSubExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSubExpr(this);
else return visitor.visitChildren(this);
}
}
public final SubExprContext subExpr() throws RecognitionException {
SubExprContext _localctx = new SubExprContext(_ctx, getState());
enterRule(_localctx, 160, RULE_subExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1335);
match(SP);
setState(1336);
match(Sub_LLC);
setState(1337);
match(SP);
setState(1338);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MulExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Mul_LLC() { return getToken(STAQueryOptionsGrammar.Mul_LLC, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public MulExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mulExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMulExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMulExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMulExpr(this);
else return visitor.visitChildren(this);
}
}
public final MulExprContext mulExpr() throws RecognitionException {
MulExprContext _localctx = new MulExprContext(_ctx, getState());
enterRule(_localctx, 162, RULE_mulExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1340);
match(SP);
setState(1341);
match(Mul_LLC);
setState(1342);
match(SP);
setState(1343);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DivExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Div_LLC() { return getToken(STAQueryOptionsGrammar.Div_LLC, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public DivExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_divExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDivExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDivExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDivExpr(this);
else return visitor.visitChildren(this);
}
}
public final DivExprContext divExpr() throws RecognitionException {
DivExprContext _localctx = new DivExprContext(_ctx, getState());
enterRule(_localctx, 164, RULE_divExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1345);
match(SP);
setState(1346);
match(Div_LLC);
setState(1347);
match(SP);
setState(1348);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ModExprContext extends ParserRuleContext {
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode Mod_LLC() { return getToken(STAQueryOptionsGrammar.Mod_LLC, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public ModExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterModExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitModExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitModExpr(this);
else return visitor.visitChildren(this);
}
}
public final ModExprContext modExpr() throws RecognitionException {
ModExprContext _localctx = new ModExprContext(_ctx, getState());
enterRule(_localctx, 166, RULE_modExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(1350);
match(SP);
setState(1351);
match(Mod_LLC);
setState(1352);
match(SP);
setState(1353);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NegateExprContext extends ParserRuleContext {
public TerminalNode MINUS() { return getToken(STAQueryOptionsGrammar.MINUS, 0); }
public ArithmeticExprContext arithmeticExpr() {
return getRuleContext(ArithmeticExprContext.class,0);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public NegateExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_negateExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterNegateExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitNegateExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitNegateExpr(this);
else return visitor.visitChildren(this);
}
}
public final NegateExprContext negateExpr() throws RecognitionException {
NegateExprContext _localctx = new NegateExprContext(_ctx, getState());
enterRule(_localctx, 168, RULE_negateExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1355);
match(MINUS);
setState(1359);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1356);
match(SP);
}
}
setState(1361);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1362);
arithmeticExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NumericLiteralContext extends ParserRuleContext {
public DecimalLiteralContext decimalLiteral() {
return getRuleContext(DecimalLiteralContext.class,0);
}
public TerminalNode FILTER_FloatingPointLiteral() { return getToken(STAQueryOptionsGrammar.FILTER_FloatingPointLiteral, 0); }
public NumericLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumericLiteralContext numericLiteral() throws RecognitionException {
NumericLiteralContext _localctx = new NumericLiteralContext(_ctx, getState());
enterRule(_localctx, 170, RULE_numericLiteral);
try {
setState(1366);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DIGIT:
case DIGITPLUS:
enterOuterAlt(_localctx, 1);
{
setState(1364);
decimalLiteral();
}
break;
case FILTER_FloatingPointLiteral:
enterOuterAlt(_localctx, 2);
{
setState(1365);
match(FILTER_FloatingPointLiteral);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DecimalLiteralContext extends ParserRuleContext {
public TerminalNode DIGIT() { return getToken(STAQueryOptionsGrammar.DIGIT, 0); }
public TerminalNode DIGITPLUS() { return getToken(STAQueryOptionsGrammar.DIGITPLUS, 0); }
public DecimalLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decimalLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
public final DecimalLiteralContext decimalLiteral() throws RecognitionException {
DecimalLiteralContext _localctx = new DecimalLiteralContext(_ctx, getState());
enterRule(_localctx, 172, RULE_decimalLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1368);
_la = _input.LA(1);
if ( !(_la==DIGIT || _la==DIGITPLUS) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class EscapedStringContext extends ParserRuleContext {
public TerminalNode LITERAL() { return getToken(STAQueryOptionsGrammar.LITERAL, 0); }
public TerminalNode DIGIT() { return getToken(STAQueryOptionsGrammar.DIGIT, 0); }
public TerminalNode DIGITPLUS() { return getToken(STAQueryOptionsGrammar.DIGITPLUS, 0); }
public EscapedStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_escapedString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterEscapedString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitEscapedString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitEscapedString(this);
else return visitor.visitChildren(this);
}
}
public final EscapedStringContext escapedString() throws RecognitionException {
EscapedStringContext _localctx = new EscapedStringContext(_ctx, getState());
enterRule(_localctx, 174, RULE_escapedString);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1370);
_la = _input.LA(1);
if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 537067520L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyCollectionContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullCollectionLiteralContext fullCollectionLiteral() {
return getRuleContext(FullCollectionLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyCollectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyCollection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyCollection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyCollection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyCollection(this);
else return visitor.visitChildren(this);
}
}
public final GeographyCollectionContext geographyCollection() throws RecognitionException {
GeographyCollectionContext _localctx = new GeographyCollectionContext(_ctx, getState());
enterRule(_localctx, 176, RULE_geographyCollection);
try {
enterOuterAlt(_localctx, 1);
{
setState(1372);
geographyPrefix();
setState(1373);
fullCollectionLiteral();
setState(1374);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullCollectionLiteralContext extends ParserRuleContext {
public CollectionLiteralContext collectionLiteral() {
return getRuleContext(CollectionLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullCollectionLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullCollectionLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullCollectionLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullCollectionLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullCollectionLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullCollectionLiteralContext fullCollectionLiteral() throws RecognitionException {
FullCollectionLiteralContext _localctx = new FullCollectionLiteralContext(_ctx, getState());
enterRule(_localctx, 178, RULE_fullCollectionLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1377);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1376);
sridLiteral();
}
}
setState(1379);
collectionLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CollectionLiteralContext extends ParserRuleContext {
public TerminalNode CollectionOP_LUC() { return getToken(STAQueryOptionsGrammar.CollectionOP_LUC, 0); }
public List geoLiteral() {
return getRuleContexts(GeoLiteralContext.class);
}
public GeoLiteralContext geoLiteral(int i) {
return getRuleContext(GeoLiteralContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public CollectionLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collectionLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterCollectionLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitCollectionLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitCollectionLiteral(this);
else return visitor.visitChildren(this);
}
}
public final CollectionLiteralContext collectionLiteral() throws RecognitionException {
CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState());
enterRule(_localctx, 180, RULE_collectionLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1381);
match(CollectionOP_LUC);
setState(1385);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1382);
match(SP);
}
}
setState(1387);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1388);
geoLiteral();
setState(1393);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1389);
match(COMMA);
setState(1390);
geoLiteral();
}
}
setState(1395);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1399);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1396);
match(SP);
}
}
setState(1401);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1402);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeoLiteralContext extends ParserRuleContext {
public CollectionLiteralContext collectionLiteral() {
return getRuleContext(CollectionLiteralContext.class,0);
}
public LineStringLiteralContext lineStringLiteral() {
return getRuleContext(LineStringLiteralContext.class,0);
}
public MultiPointLiteralContext multiPointLiteral() {
return getRuleContext(MultiPointLiteralContext.class,0);
}
public MultiLineStringLiteralContext multiLineStringLiteral() {
return getRuleContext(MultiLineStringLiteralContext.class,0);
}
public MultiPolygonLiteralContext multiPolygonLiteral() {
return getRuleContext(MultiPolygonLiteralContext.class,0);
}
public PointLiteralContext pointLiteral() {
return getRuleContext(PointLiteralContext.class,0);
}
public PolygonLiteralContext polygonLiteral() {
return getRuleContext(PolygonLiteralContext.class,0);
}
public GeoLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geoLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeoLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeoLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeoLiteral(this);
else return visitor.visitChildren(this);
}
}
public final GeoLiteralContext geoLiteral() throws RecognitionException {
GeoLiteralContext _localctx = new GeoLiteralContext(_ctx, getState());
enterRule(_localctx, 182, RULE_geoLiteral);
try {
setState(1411);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CollectionOP_LUC:
enterOuterAlt(_localctx, 1);
{
setState(1404);
collectionLiteral();
}
break;
case LineString_LUC:
enterOuterAlt(_localctx, 2);
{
setState(1405);
lineStringLiteral();
}
break;
case MultiPointOP_LUC:
enterOuterAlt(_localctx, 3);
{
setState(1406);
multiPointLiteral();
}
break;
case MultiLineStringOP_LUC:
enterOuterAlt(_localctx, 4);
{
setState(1407);
multiLineStringLiteral();
}
break;
case MultiPolygonOP_LUC:
enterOuterAlt(_localctx, 5);
{
setState(1408);
multiPolygonLiteral();
}
break;
case Point_LUC:
enterOuterAlt(_localctx, 6);
{
setState(1409);
pointLiteral();
}
break;
case Polygon_LUC:
enterOuterAlt(_localctx, 7);
{
setState(1410);
polygonLiteral();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyLineStringContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullLineStringLiteralContext fullLineStringLiteral() {
return getRuleContext(FullLineStringLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyLineStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyLineString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyLineString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyLineString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyLineString(this);
else return visitor.visitChildren(this);
}
}
public final GeographyLineStringContext geographyLineString() throws RecognitionException {
GeographyLineStringContext _localctx = new GeographyLineStringContext(_ctx, getState());
enterRule(_localctx, 184, RULE_geographyLineString);
try {
enterOuterAlt(_localctx, 1);
{
setState(1413);
geographyPrefix();
setState(1414);
fullLineStringLiteral();
setState(1415);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullLineStringLiteralContext extends ParserRuleContext {
public LineStringLiteralContext lineStringLiteral() {
return getRuleContext(LineStringLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullLineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullLineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullLineStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullLineStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullLineStringLiteralContext fullLineStringLiteral() throws RecognitionException {
FullLineStringLiteralContext _localctx = new FullLineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 186, RULE_fullLineStringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1417);
sridLiteral();
}
}
setState(1420);
lineStringLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LineStringLiteralContext extends ParserRuleContext {
public TerminalNode LineString_LUC() { return getToken(STAQueryOptionsGrammar.LineString_LUC, 0); }
public LineStringDataContext lineStringData() {
return getRuleContext(LineStringDataContext.class,0);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public LineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitLineStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitLineStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LineStringLiteralContext lineStringLiteral() throws RecognitionException {
LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 188, RULE_lineStringLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1422);
match(LineString_LUC);
setState(1426);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1423);
match(SP);
}
}
setState(1428);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1429);
lineStringData();
setState(1433);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1430);
match(SP);
}
}
}
setState(1435);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LineStringDataContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List positionLiteral() {
return getRuleContexts(PositionLiteralContext.class);
}
public PositionLiteralContext positionLiteral(int i) {
return getRuleContext(PositionLiteralContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public LineStringDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lineStringData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterLineStringData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitLineStringData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitLineStringData(this);
else return visitor.visitChildren(this);
}
}
public final LineStringDataContext lineStringData() throws RecognitionException {
LineStringDataContext _localctx = new LineStringDataContext(_ctx, getState());
enterRule(_localctx, 190, RULE_lineStringData);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1436);
match(OP);
setState(1437);
positionLiteral();
setState(1443);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1438);
match(COMMA);
setState(1440);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1439);
match(SP);
}
}
setState(1442);
positionLiteral();
}
}
setState(1445);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMA );
setState(1447);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyMultiLineStringContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullMultiLineStringLiteralContext fullMultiLineStringLiteral() {
return getRuleContext(FullMultiLineStringLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyMultiLineStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyMultiLineString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyMultiLineString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyMultiLineString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyMultiLineString(this);
else return visitor.visitChildren(this);
}
}
public final GeographyMultiLineStringContext geographyMultiLineString() throws RecognitionException {
GeographyMultiLineStringContext _localctx = new GeographyMultiLineStringContext(_ctx, getState());
enterRule(_localctx, 192, RULE_geographyMultiLineString);
try {
enterOuterAlt(_localctx, 1);
{
setState(1449);
geographyPrefix();
setState(1450);
fullMultiLineStringLiteral();
setState(1451);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullMultiLineStringLiteralContext extends ParserRuleContext {
public MultiLineStringLiteralContext multiLineStringLiteral() {
return getRuleContext(MultiLineStringLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullMultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullMultiLineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullMultiLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullMultiLineStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullMultiLineStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullMultiLineStringLiteralContext fullMultiLineStringLiteral() throws RecognitionException {
FullMultiLineStringLiteralContext _localctx = new FullMultiLineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 194, RULE_fullMultiLineStringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1453);
sridLiteral();
}
}
setState(1456);
multiLineStringLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiLineStringLiteralContext extends ParserRuleContext {
public TerminalNode MultiLineStringOP_LUC() { return getToken(STAQueryOptionsGrammar.MultiLineStringOP_LUC, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public List lineStringData() {
return getRuleContexts(LineStringDataContext.class);
}
public LineStringDataContext lineStringData(int i) {
return getRuleContext(LineStringDataContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiLineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMultiLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMultiLineStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMultiLineStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException {
MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 196, RULE_multiLineStringLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1458);
match(MultiLineStringOP_LUC);
setState(1462);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1459);
match(SP);
}
}
}
setState(1464);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
}
setState(1476);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OP) {
{
setState(1465);
lineStringData();
setState(1473);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1466);
match(COMMA);
setState(1468);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1467);
match(SP);
}
}
setState(1470);
lineStringData();
}
}
setState(1475);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1481);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1478);
match(SP);
}
}
setState(1483);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1484);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyMultiPointContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullMultiPointLiteralContext fullMultiPointLiteral() {
return getRuleContext(FullMultiPointLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyMultiPointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyMultiPoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyMultiPoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyMultiPoint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyMultiPoint(this);
else return visitor.visitChildren(this);
}
}
public final GeographyMultiPointContext geographyMultiPoint() throws RecognitionException {
GeographyMultiPointContext _localctx = new GeographyMultiPointContext(_ctx, getState());
enterRule(_localctx, 198, RULE_geographyMultiPoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1486);
geographyPrefix();
setState(1487);
fullMultiPointLiteral();
setState(1488);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullMultiPointLiteralContext extends ParserRuleContext {
public MultiPointLiteralContext multiPointLiteral() {
return getRuleContext(MultiPointLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullMultiPointLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullMultiPointLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullMultiPointLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullMultiPointLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullMultiPointLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullMultiPointLiteralContext fullMultiPointLiteral() throws RecognitionException {
FullMultiPointLiteralContext _localctx = new FullMultiPointLiteralContext(_ctx, getState());
enterRule(_localctx, 200, RULE_fullMultiPointLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1490);
sridLiteral();
}
}
setState(1493);
multiPointLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiPointLiteralContext extends ParserRuleContext {
public TerminalNode MultiPointOP_LUC() { return getToken(STAQueryOptionsGrammar.MultiPointOP_LUC, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public TerminalNode COMMA() { return getToken(STAQueryOptionsGrammar.COMMA, 0); }
public List pointData() {
return getRuleContexts(PointDataContext.class);
}
public PointDataContext pointData(int i) {
return getRuleContext(PointDataContext.class,i);
}
public MultiPointLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiPointLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMultiPointLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMultiPointLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMultiPointLiteral(this);
else return visitor.visitChildren(this);
}
}
public final MultiPointLiteralContext multiPointLiteral() throws RecognitionException {
MultiPointLiteralContext _localctx = new MultiPointLiteralContext(_ctx, getState());
enterRule(_localctx, 202, RULE_multiPointLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1495);
match(MultiPointOP_LUC);
setState(1499);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1496);
match(SP);
}
}
}
setState(1501);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
}
setState(1513);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA || _la==OP) {
{
setState(1505);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OP) {
{
{
setState(1502);
pointData();
}
}
setState(1507);
_errHandler.sync(this);
_la = _input.LA(1);
}
{
setState(1508);
match(COMMA);
setState(1510);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1509);
match(SP);
}
}
setState(1512);
pointData();
}
}
}
setState(1518);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1515);
match(SP);
}
}
setState(1520);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1521);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyMultiPolygonContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullMultiPolygonLiteralContext fullMultiPolygonLiteral() {
return getRuleContext(FullMultiPolygonLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyMultiPolygonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyMultiPolygon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyMultiPolygon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyMultiPolygon(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyMultiPolygon(this);
else return visitor.visitChildren(this);
}
}
public final GeographyMultiPolygonContext geographyMultiPolygon() throws RecognitionException {
GeographyMultiPolygonContext _localctx = new GeographyMultiPolygonContext(_ctx, getState());
enterRule(_localctx, 204, RULE_geographyMultiPolygon);
try {
enterOuterAlt(_localctx, 1);
{
setState(1523);
geographyPrefix();
setState(1524);
fullMultiPolygonLiteral();
setState(1525);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullMultiPolygonLiteralContext extends ParserRuleContext {
public MultiPolygonLiteralContext multiPolygonLiteral() {
return getRuleContext(MultiPolygonLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullMultiPolygonLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullMultiPolygonLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullMultiPolygonLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullMultiPolygonLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullMultiPolygonLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullMultiPolygonLiteralContext fullMultiPolygonLiteral() throws RecognitionException {
FullMultiPolygonLiteralContext _localctx = new FullMultiPolygonLiteralContext(_ctx, getState());
enterRule(_localctx, 206, RULE_fullMultiPolygonLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1528);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1527);
sridLiteral();
}
}
setState(1530);
multiPolygonLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiPolygonLiteralContext extends ParserRuleContext {
public TerminalNode MultiPolygonOP_LUC() { return getToken(STAQueryOptionsGrammar.MultiPolygonOP_LUC, 0); }
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public List polygonData() {
return getRuleContexts(PolygonDataContext.class);
}
public PolygonDataContext polygonData(int i) {
return getRuleContext(PolygonDataContext.class,i);
}
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public MultiPolygonLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiPolygonLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterMultiPolygonLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitMultiPolygonLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitMultiPolygonLiteral(this);
else return visitor.visitChildren(this);
}
}
public final MultiPolygonLiteralContext multiPolygonLiteral() throws RecognitionException {
MultiPolygonLiteralContext _localctx = new MultiPolygonLiteralContext(_ctx, getState());
enterRule(_localctx, 208, RULE_multiPolygonLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1532);
match(MultiPolygonOP_LUC);
setState(1536);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1533);
match(SP);
}
}
}
setState(1538);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
}
setState(1550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OP) {
{
setState(1539);
polygonData();
setState(1547);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1540);
match(COMMA);
setState(1542);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1541);
match(SP);
}
}
setState(1544);
polygonData();
}
}
setState(1549);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1555);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1552);
match(SP);
}
}
setState(1557);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1558);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyPointContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullPointLiteralContext fullPointLiteral() {
return getRuleContext(FullPointLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyPointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyPoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyPoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyPoint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyPoint(this);
else return visitor.visitChildren(this);
}
}
public final GeographyPointContext geographyPoint() throws RecognitionException {
GeographyPointContext _localctx = new GeographyPointContext(_ctx, getState());
enterRule(_localctx, 210, RULE_geographyPoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1560);
geographyPrefix();
setState(1561);
fullPointLiteral();
setState(1562);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullPointLiteralContext extends ParserRuleContext {
public PointLiteralContext pointLiteral() {
return getRuleContext(PointLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullPointLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullPointLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullPointLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullPointLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullPointLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullPointLiteralContext fullPointLiteral() throws RecognitionException {
FullPointLiteralContext _localctx = new FullPointLiteralContext(_ctx, getState());
enterRule(_localctx, 212, RULE_fullPointLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1565);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1564);
sridLiteral();
}
}
setState(1567);
pointLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SridLiteralContext extends ParserRuleContext {
public TerminalNode SRID_LLC() { return getToken(STAQueryOptionsGrammar.SRID_LLC, 0); }
public TerminalNode EQ() { return getToken(STAQueryOptionsGrammar.EQ, 0); }
public TerminalNode DIGIT5() { return getToken(STAQueryOptionsGrammar.DIGIT5, 0); }
public TerminalNode SEMI() { return getToken(STAQueryOptionsGrammar.SEMI, 0); }
public SridLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sridLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterSridLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitSridLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitSridLiteral(this);
else return visitor.visitChildren(this);
}
}
public final SridLiteralContext sridLiteral() throws RecognitionException {
SridLiteralContext _localctx = new SridLiteralContext(_ctx, getState());
enterRule(_localctx, 214, RULE_sridLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1569);
match(SRID_LLC);
setState(1570);
match(EQ);
setState(1571);
match(DIGIT5);
setState(1572);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PointLiteralContext extends ParserRuleContext {
public TerminalNode Point_LUC() { return getToken(STAQueryOptionsGrammar.Point_LUC, 0); }
public PointDataContext pointData() {
return getRuleContext(PointDataContext.class,0);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public PointLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pointLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterPointLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitPointLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitPointLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PointLiteralContext pointLiteral() throws RecognitionException {
PointLiteralContext _localctx = new PointLiteralContext(_ctx, getState());
enterRule(_localctx, 216, RULE_pointLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1574);
match(Point_LUC);
setState(1578);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1575);
match(SP);
}
}
setState(1580);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1581);
pointData();
setState(1585);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,157,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1582);
match(SP);
}
}
}
setState(1587);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,157,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PointDataContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public PositionLiteralContext positionLiteral() {
return getRuleContext(PositionLiteralContext.class,0);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public PointDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pointData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterPointData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitPointData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitPointData(this);
else return visitor.visitChildren(this);
}
}
public final PointDataContext pointData() throws RecognitionException {
PointDataContext _localctx = new PointDataContext(_ctx, getState());
enterRule(_localctx, 218, RULE_pointData);
try {
enterOuterAlt(_localctx, 1);
{
setState(1588);
match(OP);
setState(1589);
positionLiteral();
setState(1590);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PositionLiteralContext extends ParserRuleContext {
public List coordinate() {
return getRuleContexts(CoordinateContext.class);
}
public CoordinateContext coordinate(int i) {
return getRuleContext(CoordinateContext.class,i);
}
public TerminalNode SP() { return getToken(STAQueryOptionsGrammar.SP, 0); }
public PositionLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_positionLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterPositionLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitPositionLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitPositionLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PositionLiteralContext positionLiteral() throws RecognitionException {
PositionLiteralContext _localctx = new PositionLiteralContext(_ctx, getState());
enterRule(_localctx, 220, RULE_positionLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1592);
coordinate();
setState(1593);
match(SP);
setState(1594);
coordinate();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CoordinateContext extends ParserRuleContext {
public List decimalLiteral() {
return getRuleContexts(DecimalLiteralContext.class);
}
public DecimalLiteralContext decimalLiteral(int i) {
return getRuleContext(DecimalLiteralContext.class,i);
}
public TerminalNode DOT() { return getToken(STAQueryOptionsGrammar.DOT, 0); }
public TerminalNode MINUS() { return getToken(STAQueryOptionsGrammar.MINUS, 0); }
public CoordinateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_coordinate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterCoordinate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitCoordinate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitCoordinate(this);
else return visitor.visitChildren(this);
}
}
public final CoordinateContext coordinate() throws RecognitionException {
CoordinateContext _localctx = new CoordinateContext(_ctx, getState());
enterRule(_localctx, 222, RULE_coordinate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1597);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(1596);
match(MINUS);
}
}
setState(1604);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1599);
decimalLiteral();
setState(1600);
match(DOT);
setState(1601);
decimalLiteral();
}
break;
case 2:
{
setState(1603);
decimalLiteral();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyPolygonContext extends ParserRuleContext {
public GeographyPrefixContext geographyPrefix() {
return getRuleContext(GeographyPrefixContext.class,0);
}
public FullPolygonLiteralContext fullPolygonLiteral() {
return getRuleContext(FullPolygonLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeographyPolygonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyPolygon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyPolygon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyPolygon(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyPolygon(this);
else return visitor.visitChildren(this);
}
}
public final GeographyPolygonContext geographyPolygon() throws RecognitionException {
GeographyPolygonContext _localctx = new GeographyPolygonContext(_ctx, getState());
enterRule(_localctx, 224, RULE_geographyPolygon);
try {
enterOuterAlt(_localctx, 1);
{
setState(1606);
geographyPrefix();
setState(1607);
fullPolygonLiteral();
setState(1608);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FullPolygonLiteralContext extends ParserRuleContext {
public PolygonLiteralContext polygonLiteral() {
return getRuleContext(PolygonLiteralContext.class,0);
}
public SridLiteralContext sridLiteral() {
return getRuleContext(SridLiteralContext.class,0);
}
public FullPolygonLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fullPolygonLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterFullPolygonLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitFullPolygonLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitFullPolygonLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FullPolygonLiteralContext fullPolygonLiteral() throws RecognitionException {
FullPolygonLiteralContext _localctx = new FullPolygonLiteralContext(_ctx, getState());
enterRule(_localctx, 226, RULE_fullPolygonLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1611);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SRID_LLC) {
{
setState(1610);
sridLiteral();
}
}
setState(1613);
polygonLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PolygonLiteralContext extends ParserRuleContext {
public TerminalNode Polygon_LUC() { return getToken(STAQueryOptionsGrammar.Polygon_LUC, 0); }
public PolygonDataContext polygonData() {
return getRuleContext(PolygonDataContext.class,0);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public PolygonLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_polygonLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterPolygonLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitPolygonLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitPolygonLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PolygonLiteralContext polygonLiteral() throws RecognitionException {
PolygonLiteralContext _localctx = new PolygonLiteralContext(_ctx, getState());
enterRule(_localctx, 228, RULE_polygonLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1615);
match(Polygon_LUC);
setState(1619);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SP) {
{
{
setState(1616);
match(SP);
}
}
setState(1621);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1622);
polygonData();
setState(1626);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1623);
match(SP);
}
}
}
setState(1628);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PolygonDataContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List ringLiteral() {
return getRuleContexts(RingLiteralContext.class);
}
public RingLiteralContext ringLiteral(int i) {
return getRuleContext(RingLiteralContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public PolygonDataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_polygonData; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterPolygonData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitPolygonData(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitPolygonData(this);
else return visitor.visitChildren(this);
}
}
public final PolygonDataContext polygonData() throws RecognitionException {
PolygonDataContext _localctx = new PolygonDataContext(_ctx, getState());
enterRule(_localctx, 230, RULE_polygonData);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1629);
match(OP);
setState(1630);
ringLiteral();
setState(1638);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1631);
match(COMMA);
setState(1633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1632);
match(SP);
}
}
setState(1635);
ringLiteral();
}
}
setState(1640);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1641);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RingLiteralContext extends ParserRuleContext {
public TerminalNode OP() { return getToken(STAQueryOptionsGrammar.OP, 0); }
public List positionLiteral() {
return getRuleContexts(PositionLiteralContext.class);
}
public PositionLiteralContext positionLiteral(int i) {
return getRuleContext(PositionLiteralContext.class,i);
}
public TerminalNode CP() { return getToken(STAQueryOptionsGrammar.CP, 0); }
public List COMMA() { return getTokens(STAQueryOptionsGrammar.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(STAQueryOptionsGrammar.COMMA, i);
}
public List SP() { return getTokens(STAQueryOptionsGrammar.SP); }
public TerminalNode SP(int i) {
return getToken(STAQueryOptionsGrammar.SP, i);
}
public RingLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterRingLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitRingLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitRingLiteral(this);
else return visitor.visitChildren(this);
}
}
public final RingLiteralContext ringLiteral() throws RecognitionException {
RingLiteralContext _localctx = new RingLiteralContext(_ctx, getState());
enterRule(_localctx, 232, RULE_ringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1643);
match(OP);
setState(1644);
positionLiteral();
setState(1652);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1645);
match(COMMA);
setState(1647);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SP) {
{
setState(1646);
match(SP);
}
}
setState(1649);
positionLiteral();
}
}
setState(1654);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1655);
match(CP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryCollectionContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullCollectionLiteralContext fullCollectionLiteral() {
return getRuleContext(FullCollectionLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryCollectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryCollection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryCollection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryCollection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryCollection(this);
else return visitor.visitChildren(this);
}
}
public final GeometryCollectionContext geometryCollection() throws RecognitionException {
GeometryCollectionContext _localctx = new GeometryCollectionContext(_ctx, getState());
enterRule(_localctx, 234, RULE_geometryCollection);
try {
enterOuterAlt(_localctx, 1);
{
setState(1657);
geometryPrefix();
setState(1658);
fullCollectionLiteral();
setState(1659);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryLineStringContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullLineStringLiteralContext fullLineStringLiteral() {
return getRuleContext(FullLineStringLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryLineStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryLineString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryLineString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryLineString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryLineString(this);
else return visitor.visitChildren(this);
}
}
public final GeometryLineStringContext geometryLineString() throws RecognitionException {
GeometryLineStringContext _localctx = new GeometryLineStringContext(_ctx, getState());
enterRule(_localctx, 236, RULE_geometryLineString);
try {
enterOuterAlt(_localctx, 1);
{
setState(1661);
geometryPrefix();
setState(1662);
fullLineStringLiteral();
setState(1663);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryMultiLineStringContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullMultiLineStringLiteralContext fullMultiLineStringLiteral() {
return getRuleContext(FullMultiLineStringLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryMultiLineStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryMultiLineString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryMultiLineString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryMultiLineString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryMultiLineString(this);
else return visitor.visitChildren(this);
}
}
public final GeometryMultiLineStringContext geometryMultiLineString() throws RecognitionException {
GeometryMultiLineStringContext _localctx = new GeometryMultiLineStringContext(_ctx, getState());
enterRule(_localctx, 238, RULE_geometryMultiLineString);
try {
enterOuterAlt(_localctx, 1);
{
setState(1665);
geometryPrefix();
setState(1666);
fullMultiLineStringLiteral();
setState(1667);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryMultiPointContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullMultiPointLiteralContext fullMultiPointLiteral() {
return getRuleContext(FullMultiPointLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryMultiPointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryMultiPoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryMultiPoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryMultiPoint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryMultiPoint(this);
else return visitor.visitChildren(this);
}
}
public final GeometryMultiPointContext geometryMultiPoint() throws RecognitionException {
GeometryMultiPointContext _localctx = new GeometryMultiPointContext(_ctx, getState());
enterRule(_localctx, 240, RULE_geometryMultiPoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1669);
geometryPrefix();
setState(1670);
fullMultiPointLiteral();
setState(1671);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryMultiPolygonContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullMultiPolygonLiteralContext fullMultiPolygonLiteral() {
return getRuleContext(FullMultiPolygonLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryMultiPolygonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryMultiPolygon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryMultiPolygon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryMultiPolygon(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryMultiPolygon(this);
else return visitor.visitChildren(this);
}
}
public final GeometryMultiPolygonContext geometryMultiPolygon() throws RecognitionException {
GeometryMultiPolygonContext _localctx = new GeometryMultiPolygonContext(_ctx, getState());
enterRule(_localctx, 242, RULE_geometryMultiPolygon);
try {
enterOuterAlt(_localctx, 1);
{
setState(1673);
geometryPrefix();
setState(1674);
fullMultiPolygonLiteral();
setState(1675);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryPointContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullPointLiteralContext fullPointLiteral() {
return getRuleContext(FullPointLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryPointContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryPoint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryPoint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryPoint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryPoint(this);
else return visitor.visitChildren(this);
}
}
public final GeometryPointContext geometryPoint() throws RecognitionException {
GeometryPointContext _localctx = new GeometryPointContext(_ctx, getState());
enterRule(_localctx, 244, RULE_geometryPoint);
try {
enterOuterAlt(_localctx, 1);
{
setState(1677);
geometryPrefix();
setState(1678);
fullPointLiteral();
setState(1679);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryPolygonContext extends ParserRuleContext {
public GeometryPrefixContext geometryPrefix() {
return getRuleContext(GeometryPrefixContext.class,0);
}
public FullPolygonLiteralContext fullPolygonLiteral() {
return getRuleContext(FullPolygonLiteralContext.class,0);
}
public TerminalNode SQ() { return getToken(STAQueryOptionsGrammar.SQ, 0); }
public GeometryPolygonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryPolygon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryPolygon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryPolygon(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryPolygon(this);
else return visitor.visitChildren(this);
}
}
public final GeometryPolygonContext geometryPolygon() throws RecognitionException {
GeometryPolygonContext _localctx = new GeometryPolygonContext(_ctx, getState());
enterRule(_localctx, 246, RULE_geometryPolygon);
try {
enterOuterAlt(_localctx, 1);
{
setState(1681);
geometryPrefix();
setState(1682);
fullPolygonLiteral();
setState(1683);
match(SQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeographyPrefixContext extends ParserRuleContext {
public TerminalNode Geography_LLC() { return getToken(STAQueryOptionsGrammar.Geography_LLC, 0); }
public GeographyPrefixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geographyPrefix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeographyPrefix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeographyPrefix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeographyPrefix(this);
else return visitor.visitChildren(this);
}
}
public final GeographyPrefixContext geographyPrefix() throws RecognitionException {
GeographyPrefixContext _localctx = new GeographyPrefixContext(_ctx, getState());
enterRule(_localctx, 248, RULE_geographyPrefix);
try {
enterOuterAlt(_localctx, 1);
{
setState(1685);
match(Geography_LLC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GeometryPrefixContext extends ParserRuleContext {
public TerminalNode Geometry_LLC() { return getToken(STAQueryOptionsGrammar.Geometry_LLC, 0); }
public GeometryPrefixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_geometryPrefix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).enterGeometryPrefix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof STAQueryOptionsGrammarListener ) ((STAQueryOptionsGrammarListener)listener).exitGeometryPrefix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof STAQueryOptionsGrammarVisitor ) return ((STAQueryOptionsGrammarVisitor)visitor).visitGeometryPrefix(this);
else return visitor.visitChildren(this);
}
}
public final GeometryPrefixContext geometryPrefix() throws RecognitionException {
GeometryPrefixContext _localctx = new GeometryPrefixContext(_ctx, getState());
enterRule(_localctx, 250, RULE_geometryPrefix);
try {
enterOuterAlt(_localctx, 1);
{
setState(1687);
match(Geometry_LLC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\u0004\u0001h\u069a\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
"2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+
"7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+
"<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+
"A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+
"F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+
"K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+
"P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+
"U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+
"Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002"+
"_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002"+
"d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002"+
"i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002"+
"n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002"+
"s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002"+
"x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002"+
"}\u0007}\u0001\u0000\u0003\u0000\u00fe\b\u0000\u0001\u0000\u0001\u0000"+
"\u0005\u0000\u0102\b\u0000\n\u0000\f\u0000\u0105\t\u0000\u0001\u0000\u0001"+
"\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
"\u0001\u0001\u0001\u0003\u0001\u0110\b\u0001\u0001\u0002\u0001\u0002\u0001"+
"\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
"\u0003\u0005\u0003\u011b\b\u0003\n\u0003\f\u0003\u011e\t\u0003\u0001\u0003"+
"\u0005\u0003\u0121\b\u0003\n\u0003\f\u0003\u0124\t\u0003\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0005\u0004\u012b\b\u0004\n"+
"\u0004\f\u0004\u012e\t\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0132"+
"\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u013d\b\u0006\n"+
"\u0006\f\u0006\u0140\t\u0006\u0001\u0006\u0005\u0006\u0143\b\u0006\n\u0006"+
"\f\u0006\u0146\t\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007"+
"\u014b\b\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t"+
"\u0001\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u015a\b\n\n\n"+
"\f\n\u015d\t\n\u0001\n\u0005\n\u0160\b\n\n\n\f\n\u0163\t\n\u0001\u000b"+
"\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+
"\f\u0001\f\u0003\f\u0170\b\f\u0001\f\u0003\f\u0173\b\f\u0001\f\u0001\f"+
"\u0003\f\u0177\b\f\u0001\r\u0001\r\u0005\r\u017b\b\r\n\r\f\r\u017e\t\r"+
"\u0001\r\u0001\r\u0005\r\u0182\b\r\n\r\f\r\u0185\t\r\u0001\r\u0001\r\u0001"+
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003"+
"\u000e\u018f\b\u000e\u0001\u000f\u0001\u000f\u0005\u000f\u0193\b\u000f"+
"\n\u000f\f\u000f\u0196\t\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u019a"+
"\b\u000f\n\u000f\f\u000f\u019d\t\u000f\u0001\u000f\u0001\u000f\u0001\u0010"+
"\u0001\u0010\u0005\u0010\u01a3\b\u0010\n\u0010\f\u0010\u01a6\t\u0010\u0003"+
"\u0010\u01a8\b\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0003"+
"\u0010\u01ae\b\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+
"\u0010\u0003\u0010\u01b5\b\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u01b9"+
"\b\u0010\n\u0010\f\u0010\u01bc\t\u0010\u0003\u0010\u01be\b\u0010\u0001"+
"\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0003\u0012\u01c4\b\u0012\u0001"+
"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
"\u0013\u0001\u0013\u0003\u0013\u01d4\b\u0013\u0001\u0014\u0001\u0014\u0005"+
"\u0014\u01d8\b\u0014\n\u0014\f\u0014\u01db\t\u0014\u0001\u0014\u0001\u0014"+
"\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0003\u0015"+
"\u01e4\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
"\u01f6\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017"+
"\u01fc\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+
"\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u020c\b\u0018\u0001\u0019"+
"\u0001\u0019\u0003\u0019\u0210\b\u0019\u0001\u001a\u0001\u001a\u0001\u001a"+
"\u0003\u001a\u0215\b\u001a\u0001\u001b\u0001\u001b\u0003\u001b\u0219\b"+
"\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+
"\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+
"\u001c\u0001\u001c\u0003\u001c\u0228\b\u001c\u0001\u001c\u0001\u001c\u0001"+
"\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0003\u001d\u0231"+
"\b\u001d\u0003\u001d\u0233\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e"+
"\u0005\u001e\u0238\b\u001e\n\u001e\f\u001e\u023b\t\u001e\u0001\u001e\u0001"+
"\u001e\u0005\u001e\u023f\b\u001e\n\u001e\f\u001e\u0242\t\u001e\u0001\u001e"+
"\u0001\u001e\u0005\u001e\u0246\b\u001e\n\u001e\f\u001e\u0249\t\u001e\u0001"+
"\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0005"+
"\u001f\u0251\b\u001f\n\u001f\f\u001f\u0254\t\u001f\u0001\u001f\u0001\u001f"+
"\u0005\u001f\u0258\b\u001f\n\u001f\f\u001f\u025b\t\u001f\u0001\u001f\u0001"+
"\u001f\u0001 \u0001 \u0001 \u0005 \u0262\b \n \f \u0265\t \u0001 \u0001"+
" \u0005 \u0269\b \n \f \u026c\t \u0001 \u0001 \u0001!\u0001!\u0001!\u0005"+
"!\u0273\b!\n!\f!\u0276\t!\u0001!\u0001!\u0005!\u027a\b!\n!\f!\u027d\t"+
"!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0005\"\u0284\b\"\n\"\f\"\u0287"+
"\t\"\u0001\"\u0001\"\u0005\"\u028b\b\"\n\"\f\"\u028e\t\"\u0001\"\u0001"+
"\"\u0005\"\u0292\b\"\n\"\f\"\u0295\t\"\u0001\"\u0001\"\u0005\"\u0299\b"+
"\"\n\"\f\"\u029c\t\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0005#\u02a3"+
"\b#\n#\f#\u02a6\t#\u0001#\u0001#\u0005#\u02aa\b#\n#\f#\u02ad\t#\u0001"+
"#\u0001#\u0005#\u02b1\b#\n#\f#\u02b4\t#\u0001#\u0001#\u0005#\u02b8\b#"+
"\n#\f#\u02bb\t#\u0001#\u0001#\u0001$\u0001$\u0001$\u0005$\u02c2\b$\n$"+
"\f$\u02c5\t$\u0001$\u0001$\u0005$\u02c9\b$\n$\f$\u02cc\t$\u0001$\u0001"+
"$\u0005$\u02d0\b$\n$\f$\u02d3\t$\u0001$\u0001$\u0005$\u02d7\b$\n$\f$\u02da"+
"\t$\u0001$\u0001$\u0001%\u0001%\u0001%\u0005%\u02e1\b%\n%\f%\u02e4\t%"+
"\u0001%\u0001%\u0005%\u02e8\b%\n%\f%\u02eb\t%\u0001%\u0001%\u0005%\u02ef"+
"\b%\n%\f%\u02f2\t%\u0001%\u0001%\u0005%\u02f6\b%\n%\f%\u02f9\t%\u0001"+
"%\u0001%\u0001&\u0001&\u0001&\u0005&\u0300\b&\n&\f&\u0303\t&\u0001&\u0001"+
"&\u0005&\u0307\b&\n&\f&\u030a\t&\u0001&\u0001&\u0005&\u030e\b&\n&\f&\u0311"+
"\t&\u0001&\u0001&\u0005&\u0315\b&\n&\f&\u0318\t&\u0001&\u0001&\u0005&"+
"\u031c\b&\n&\f&\u031f\t&\u0001&\u0001&\u0005&\u0323\b&\n&\f&\u0326\t&"+
"\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0005\'\u032d\b\'\n\'\f\'\u0330"+
"\t\'\u0001\'\u0001\'\u0005\'\u0334\b\'\n\'\f\'\u0337\t\'\u0001\'\u0001"+
"\'\u0005\'\u033b\b\'\n\'\f\'\u033e\t\'\u0001\'\u0001\'\u0005\'\u0342\b"+
"\'\n\'\f\'\u0345\t\'\u0001\'\u0001\'\u0001(\u0001(\u0005(\u034b\b(\n("+
"\f(\u034e\t(\u0001(\u0001(\u0005(\u0352\b(\n(\f(\u0355\t(\u0001(\u0001"+
"(\u0005(\u0359\b(\n(\f(\u035c\t(\u0001(\u0001(\u0005(\u0360\b(\n(\f(\u0363"+
"\t(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001+\u0001"+
"+\u0001+\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001.\u0001.\u0001"+
".\u0001/\u0001/\u0001/\u00010\u00010\u00010\u00011\u00011\u00011\u0005"+
"1\u0382\b1\n1\f1\u0385\t1\u00011\u00011\u00051\u0389\b1\n1\f1\u038c\t"+
"1\u00011\u00011\u00051\u0390\b1\n1\f1\u0393\t1\u00011\u00011\u00051\u0397"+
"\b1\n1\f1\u039a\t1\u00011\u00011\u00051\u039e\b1\n1\f1\u03a1\t1\u0001"+
"1\u00011\u00051\u03a5\b1\n1\f1\u03a8\t1\u00011\u00011\u00012\u00012\u0001"+
"2\u00052\u03af\b2\n2\f2\u03b2\t2\u00012\u00012\u00052\u03b6\b2\n2\f2\u03b9"+
"\t2\u00012\u00012\u00013\u00013\u00013\u00053\u03c0\b3\n3\f3\u03c3\t3"+
"\u00013\u00013\u00053\u03c7\b3\n3\f3\u03ca\t3\u00013\u00013\u00053\u03ce"+
"\b3\n3\f3\u03d1\t3\u00013\u00013\u00053\u03d5\b3\n3\f3\u03d8\t3\u0001"+
"3\u00013\u00014\u00014\u00014\u00054\u03df\b4\n4\f4\u03e2\t4\u00014\u0001"+
"4\u00054\u03e6\b4\n4\f4\u03e9\t4\u00014\u00014\u00015\u00015\u00015\u0005"+
"5\u03f0\b5\n5\f5\u03f3\t5\u00015\u00015\u00055\u03f7\b5\n5\f5\u03fa\t"+
"5\u00015\u00015\u00016\u00016\u00016\u00056\u0401\b6\n6\f6\u0404\t6\u0001"+
"6\u00016\u00056\u0408\b6\n6\f6\u040b\t6\u00016\u00016\u00017\u00017\u0001"+
"7\u00057\u0412\b7\n7\f7\u0415\t7\u00017\u00017\u00057\u0419\b7\n7\f7\u041c"+
"\t7\u00017\u00017\u00018\u00018\u00018\u00058\u0423\b8\n8\f8\u0426\t8"+
"\u00018\u00018\u00058\u042a\b8\n8\f8\u042d\t8\u00018\u00018\u00019\u0001"+
"9\u00019\u00059\u0434\b9\n9\f9\u0437\t9\u00019\u00019\u00059\u043b\b9"+
"\n9\f9\u043e\t9\u00019\u00019\u0001:\u0001:\u0001:\u0005:\u0445\b:\n:"+
"\f:\u0448\t:\u0001:\u0001:\u0005:\u044c\b:\n:\f:\u044f\t:\u0001:\u0001"+
":\u0001;\u0001;\u0001;\u0005;\u0456\b;\n;\f;\u0459\t;\u0001;\u0001;\u0005"+
";\u045d\b;\n;\f;\u0460\t;\u0001;\u0001;\u0001<\u0001<\u0001<\u0005<\u0467"+
"\b<\n<\f<\u046a\t<\u0001<\u0001<\u0005<\u046e\b<\n<\f<\u0471\t<\u0001"+
"<\u0001<\u0001=\u0001=\u0001=\u0005=\u0478\b=\n=\f=\u047b\t=\u0001=\u0001"+
"=\u0005=\u047f\b=\n=\f=\u0482\t=\u0001=\u0001=\u0001>\u0001>\u0001>\u0005"+
">\u0489\b>\n>\f>\u048c\t>\u0001>\u0001>\u0005>\u0490\b>\n>\f>\u0493\t"+
">\u0001>\u0001>\u0001?\u0001?\u0001?\u0005?\u049a\b?\n?\f?\u049d\t?\u0001"+
"?\u0001?\u0005?\u04a1\b?\n?\f?\u04a4\t?\u0001?\u0001?\u0001@\u0001@\u0001"+
"@\u0005@\u04ab\b@\n@\f@\u04ae\t@\u0001@\u0001@\u0005@\u04b2\b@\n@\f@\u04b5"+
"\t@\u0001@\u0001@\u0001A\u0001A\u0001A\u0005A\u04bc\bA\nA\fA\u04bf\tA"+
"\u0001A\u0001A\u0005A\u04c3\bA\nA\fA\u04c6\tA\u0001A\u0001A\u0005A\u04ca"+
"\bA\nA\fA\u04cd\tA\u0001A\u0001A\u0005A\u04d1\bA\nA\fA\u04d4\tA\u0001"+
"A\u0001A\u0001B\u0001B\u0001B\u0005B\u04db\bB\nB\fB\u04de\tB\u0001B\u0001"+
"B\u0005B\u04e2\bB\nB\fB\u04e5\tB\u0001B\u0001B\u0001C\u0001C\u0001C\u0005"+
"C\u04ec\bC\nC\fC\u04ef\tC\u0001C\u0001C\u0001D\u0001D\u0001D\u0005D\u04f6"+
"\bD\nD\fD\u04f9\tD\u0001D\u0001D\u0001E\u0001E\u0001E\u0005E\u0500\bE"+
"\nE\fE\u0503\tE\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001I\u0001"+
"I\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001K\u0001"+
"K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001M\u0001"+
"M\u0001M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001"+
"O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001"+
"Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001"+
"S\u0001S\u0001S\u0001S\u0001T\u0001T\u0005T\u054e\bT\nT\fT\u0551\tT\u0001"+
"T\u0001T\u0001U\u0001U\u0003U\u0557\bU\u0001V\u0001V\u0001W\u0001W\u0001"+
"X\u0001X\u0001X\u0001X\u0001Y\u0003Y\u0562\bY\u0001Y\u0001Y\u0001Z\u0001"+
"Z\u0005Z\u0568\bZ\nZ\fZ\u056b\tZ\u0001Z\u0001Z\u0001Z\u0005Z\u0570\bZ"+
"\nZ\fZ\u0573\tZ\u0001Z\u0005Z\u0576\bZ\nZ\fZ\u0579\tZ\u0001Z\u0001Z\u0001"+
"[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0003[\u0584\b[\u0001\\\u0001"+
"\\\u0001\\\u0001\\\u0001]\u0003]\u058b\b]\u0001]\u0001]\u0001^\u0001^"+
"\u0005^\u0591\b^\n^\f^\u0594\t^\u0001^\u0001^\u0005^\u0598\b^\n^\f^\u059b"+
"\t^\u0001_\u0001_\u0001_\u0001_\u0003_\u05a1\b_\u0001_\u0004_\u05a4\b"+
"_\u000b_\f_\u05a5\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001a\u0003"+
"a\u05af\ba\u0001a\u0001a\u0001b\u0001b\u0005b\u05b5\bb\nb\fb\u05b8\tb"+
"\u0001b\u0001b\u0001b\u0003b\u05bd\bb\u0001b\u0005b\u05c0\bb\nb\fb\u05c3"+
"\tb\u0003b\u05c5\bb\u0001b\u0005b\u05c8\bb\nb\fb\u05cb\tb\u0001b\u0001"+
"b\u0001c\u0001c\u0001c\u0001c\u0001d\u0003d\u05d4\bd\u0001d\u0001d\u0001"+
"e\u0001e\u0005e\u05da\be\ne\fe\u05dd\te\u0001e\u0005e\u05e0\be\ne\fe\u05e3"+
"\te\u0001e\u0001e\u0003e\u05e7\be\u0001e\u0003e\u05ea\be\u0001e\u0005"+
"e\u05ed\be\ne\fe\u05f0\te\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001"+
"g\u0003g\u05f9\bg\u0001g\u0001g\u0001h\u0001h\u0005h\u05ff\bh\nh\fh\u0602"+
"\th\u0001h\u0001h\u0001h\u0003h\u0607\bh\u0001h\u0005h\u060a\bh\nh\fh"+
"\u060d\th\u0003h\u060f\bh\u0001h\u0005h\u0612\bh\nh\fh\u0615\th\u0001"+
"h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001j\u0003j\u061e\bj\u0001j\u0001"+
"j\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001l\u0005l\u0629\bl\nl"+
"\fl\u062c\tl\u0001l\u0001l\u0005l\u0630\bl\nl\fl\u0633\tl\u0001m\u0001"+
"m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001o\u0003o\u063e\bo\u0001"+
"o\u0001o\u0001o\u0001o\u0001o\u0003o\u0645\bo\u0001p\u0001p\u0001p\u0001"+
"p\u0001q\u0003q\u064c\bq\u0001q\u0001q\u0001r\u0001r\u0005r\u0652\br\n"+
"r\fr\u0655\tr\u0001r\u0001r\u0005r\u0659\br\nr\fr\u065c\tr\u0001s\u0001"+
"s\u0001s\u0001s\u0003s\u0662\bs\u0001s\u0005s\u0665\bs\ns\fs\u0668\ts"+
"\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0003t\u0670\bt\u0001t\u0005"+
"t\u0673\bt\nt\ft\u0676\tt\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001"+
"v\u0001v\u0001v\u0001v\u0001w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001"+
"x\u0001x\u0001y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001"+
"{\u0001{\u0001{\u0001{\u0001|\u0001|\u0001}\u0001}\u0001}\u0000\u0000"+
"~\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a"+
"\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+
"\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+
"\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+
"\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca"+
"\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2"+
"\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa"+
"\u0000\u0005\u0001\u0000\u0019\u001a\u0001\u0000\u001b\u001c\u0002\u0000"+
"\u000f\u000f11\u0001\u0000\u0010\u0011\u0002\u0000\u0010\u0011\u001d\u001d"+
"\u0709\u0000\u00fd\u0001\u0000\u0000\u0000\u0002\u010f\u0001\u0000\u0000"+
"\u0000\u0004\u0111\u0001\u0000\u0000\u0000\u0006\u0115\u0001\u0000\u0000"+
"\u0000\b\u0125\u0001\u0000\u0000\u0000\n\u0133\u0001\u0000\u0000\u0000"+
"\f\u0137\u0001\u0000\u0000\u0000\u000e\u0147\u0001\u0000\u0000\u0000\u0010"+
"\u014c\u0001\u0000\u0000\u0000\u0012\u0150\u0001\u0000\u0000\u0000\u0014"+
"\u0154\u0001\u0000\u0000\u0000\u0016\u0164\u0001\u0000\u0000\u0000\u0018"+
"\u0172\u0001\u0000\u0000\u0000\u001a\u0178\u0001\u0000\u0000\u0000\u001c"+
"\u018e\u0001\u0000\u0000\u0000\u001e\u0190\u0001\u0000\u0000\u0000 \u01a7"+
"\u0001\u0000\u0000\u0000\"\u01bf\u0001\u0000\u0000\u0000$\u01c3\u0001"+
"\u0000\u0000\u0000&\u01d3\u0001\u0000\u0000\u0000(\u01d9\u0001\u0000\u0000"+
"\u0000*\u01e3\u0001\u0000\u0000\u0000,\u01f5\u0001\u0000\u0000\u0000."+
"\u01fb\u0001\u0000\u0000\u00000\u020b\u0001\u0000\u0000\u00002\u020f\u0001"+
"\u0000\u0000\u00004\u0214\u0001\u0000\u0000\u00006\u0218\u0001\u0000\u0000"+
"\u00008\u021a\u0001\u0000\u0000\u0000:\u0232\u0001\u0000\u0000\u0000<"+
"\u0234\u0001\u0000\u0000\u0000>\u024d\u0001\u0000\u0000\u0000@\u025e\u0001"+
"\u0000\u0000\u0000B\u026f\u0001\u0000\u0000\u0000D\u0280\u0001\u0000\u0000"+
"\u0000F\u029f\u0001\u0000\u0000\u0000H\u02be\u0001\u0000\u0000\u0000J"+
"\u02dd\u0001\u0000\u0000\u0000L\u02fc\u0001\u0000\u0000\u0000N\u0329\u0001"+
"\u0000\u0000\u0000P\u0348\u0001\u0000\u0000\u0000R\u0366\u0001\u0000\u0000"+
"\u0000T\u0369\u0001\u0000\u0000\u0000V\u036c\u0001\u0000\u0000\u0000X"+
"\u036f\u0001\u0000\u0000\u0000Z\u0372\u0001\u0000\u0000\u0000\\\u0375"+
"\u0001\u0000\u0000\u0000^\u0378\u0001\u0000\u0000\u0000`\u037b\u0001\u0000"+
"\u0000\u0000b\u037e\u0001\u0000\u0000\u0000d\u03ab\u0001\u0000\u0000\u0000"+
"f\u03bc\u0001\u0000\u0000\u0000h\u03db\u0001\u0000\u0000\u0000j\u03ec"+
"\u0001\u0000\u0000\u0000l\u03fd\u0001\u0000\u0000\u0000n\u040e\u0001\u0000"+
"\u0000\u0000p\u041f\u0001\u0000\u0000\u0000r\u0430\u0001\u0000\u0000\u0000"+
"t\u0441\u0001\u0000\u0000\u0000v\u0452\u0001\u0000\u0000\u0000x\u0463"+
"\u0001\u0000\u0000\u0000z\u0474\u0001\u0000\u0000\u0000|\u0485\u0001\u0000"+
"\u0000\u0000~\u0496\u0001\u0000\u0000\u0000\u0080\u04a7\u0001\u0000\u0000"+
"\u0000\u0082\u04b8\u0001\u0000\u0000\u0000\u0084\u04d7\u0001\u0000\u0000"+
"\u0000\u0086\u04e8\u0001\u0000\u0000\u0000\u0088\u04f2\u0001\u0000\u0000"+
"\u0000\u008a\u04fc\u0001\u0000\u0000\u0000\u008c\u0506\u0001\u0000\u0000"+
"\u0000\u008e\u050b\u0001\u0000\u0000\u0000\u0090\u0510\u0001\u0000\u0000"+
"\u0000\u0092\u0514\u0001\u0000\u0000\u0000\u0094\u0519\u0001\u0000\u0000"+
"\u0000\u0096\u051e\u0001\u0000\u0000\u0000\u0098\u0523\u0001\u0000\u0000"+
"\u0000\u009a\u0528\u0001\u0000\u0000\u0000\u009c\u052d\u0001\u0000\u0000"+
"\u0000\u009e\u0532\u0001\u0000\u0000\u0000\u00a0\u0537\u0001\u0000\u0000"+
"\u0000\u00a2\u053c\u0001\u0000\u0000\u0000\u00a4\u0541\u0001\u0000\u0000"+
"\u0000\u00a6\u0546\u0001\u0000\u0000\u0000\u00a8\u054b\u0001\u0000\u0000"+
"\u0000\u00aa\u0556\u0001\u0000\u0000\u0000\u00ac\u0558\u0001\u0000\u0000"+
"\u0000\u00ae\u055a\u0001\u0000\u0000\u0000\u00b0\u055c\u0001\u0000\u0000"+
"\u0000\u00b2\u0561\u0001\u0000\u0000\u0000\u00b4\u0565\u0001\u0000\u0000"+
"\u0000\u00b6\u0583\u0001\u0000\u0000\u0000\u00b8\u0585\u0001\u0000\u0000"+
"\u0000\u00ba\u058a\u0001\u0000\u0000\u0000\u00bc\u058e\u0001\u0000\u0000"+
"\u0000\u00be\u059c\u0001\u0000\u0000\u0000\u00c0\u05a9\u0001\u0000\u0000"+
"\u0000\u00c2\u05ae\u0001\u0000\u0000\u0000\u00c4\u05b2\u0001\u0000\u0000"+
"\u0000\u00c6\u05ce\u0001\u0000\u0000\u0000\u00c8\u05d3\u0001\u0000\u0000"+
"\u0000\u00ca\u05d7\u0001\u0000\u0000\u0000\u00cc\u05f3\u0001\u0000\u0000"+
"\u0000\u00ce\u05f8\u0001\u0000\u0000\u0000\u00d0\u05fc\u0001\u0000\u0000"+
"\u0000\u00d2\u0618\u0001\u0000\u0000\u0000\u00d4\u061d\u0001\u0000\u0000"+
"\u0000\u00d6\u0621\u0001\u0000\u0000\u0000\u00d8\u0626\u0001\u0000\u0000"+
"\u0000\u00da\u0634\u0001\u0000\u0000\u0000\u00dc\u0638\u0001\u0000\u0000"+
"\u0000\u00de\u063d\u0001\u0000\u0000\u0000\u00e0\u0646\u0001\u0000\u0000"+
"\u0000\u00e2\u064b\u0001\u0000\u0000\u0000\u00e4\u064f\u0001\u0000\u0000"+
"\u0000\u00e6\u065d\u0001\u0000\u0000\u0000\u00e8\u066b\u0001\u0000\u0000"+
"\u0000\u00ea\u0679\u0001\u0000\u0000\u0000\u00ec\u067d\u0001\u0000\u0000"+
"\u0000\u00ee\u0681\u0001\u0000\u0000\u0000\u00f0\u0685\u0001\u0000\u0000"+
"\u0000\u00f2\u0689\u0001\u0000\u0000\u0000\u00f4\u068d\u0001\u0000\u0000"+
"\u0000\u00f6\u0691\u0001\u0000\u0000\u0000\u00f8\u0695\u0001\u0000\u0000"+
"\u0000\u00fa\u0697\u0001\u0000\u0000\u0000\u00fc\u00fe\u0003\u0002\u0001"+
"\u0000\u00fd\u00fc\u0001\u0000\u0000\u0000\u00fd\u00fe\u0001\u0000\u0000"+
"\u0000\u00fe\u0103\u0001\u0000\u0000\u0000\u00ff\u0100\u0005\b\u0000\u0000"+
"\u0100\u0102\u0003\u0002\u0001\u0000\u0101\u00ff\u0001\u0000\u0000\u0000"+
"\u0102\u0105\u0001\u0000\u0000\u0000\u0103\u0101\u0001\u0000\u0000\u0000"+
"\u0103\u0104\u0001\u0000\u0000\u0000\u0104\u0106\u0001\u0000\u0000\u0000"+
"\u0105\u0103\u0001\u0000\u0000\u0000\u0106\u0107\u0005\u0000\u0000\u0001"+
"\u0107\u0001\u0001\u0000\u0000\u0000\u0108\u0110\u0003\u0006\u0003\u0000"+
"\u0109\u0110\u0003\n\u0005\u0000\u010a\u0110\u0003\f\u0006\u0000\u010b"+
"\u0110\u0003\u0004\u0002\u0000\u010c\u0110\u0003\u0010\b\u0000\u010d\u0110"+
"\u0003\u0012\t\u0000\u010e\u0110\u0003\u0014\n\u0000\u010f\u0108\u0001"+
"\u0000\u0000\u0000\u010f\u0109\u0001\u0000\u0000\u0000\u010f\u010a\u0001"+
"\u0000\u0000\u0000\u010f\u010b\u0001\u0000\u0000\u0000\u010f\u010c\u0001"+
"\u0000\u0000\u0000\u010f\u010d\u0001\u0000\u0000\u0000\u010f\u010e\u0001"+
"\u0000\u0000\u0000\u0110\u0003\u0001\u0000\u0000\u0000\u0111\u0112\u0005"+
"\u0012\u0000\u0000\u0112\u0113\u0005\u0002\u0000\u0000\u0113\u0114\u0007"+
"\u0000\u0000\u0000\u0114\u0005\u0001\u0000\u0000\u0000\u0115\u0116\u0005"+
"\u0013\u0000\u0000\u0116\u0117\u0005\u0002\u0000\u0000\u0117\u0122\u0003"+
"\b\u0004\u0000\u0118\u011c\u0005\u0003\u0000\u0000\u0119\u011b\u0005\u0004"+
"\u0000\u0000\u011a\u0119\u0001\u0000\u0000\u0000\u011b\u011e\u0001\u0000"+
"\u0000\u0000\u011c\u011a\u0001\u0000\u0000\u0000\u011c\u011d\u0001\u0000"+
"\u0000\u0000\u011d\u011f\u0001\u0000\u0000\u0000\u011e\u011c\u0001\u0000"+
"\u0000\u0000\u011f\u0121\u0003\b\u0004\u0000\u0120\u0118\u0001\u0000\u0000"+
"\u0000\u0121\u0124\u0001\u0000\u0000\u0000\u0122\u0120\u0001\u0000\u0000"+
"\u0000\u0122\u0123\u0001\u0000\u0000\u0000\u0123\u0007\u0001\u0000\u0000"+
"\u0000\u0124\u0122\u0001\u0000\u0000\u0000\u0125\u0131\u0003(\u0014\u0000"+
"\u0126\u0127\u0005\t\u0000\u0000\u0127\u012c\u0003\u0002\u0001\u0000\u0128"+
"\u0129\u0005\u0005\u0000\u0000\u0129\u012b\u0003\u0002\u0001\u0000\u012a"+
"\u0128\u0001\u0000\u0000\u0000\u012b\u012e\u0001\u0000\u0000\u0000\u012c"+
"\u012a\u0001\u0000\u0000\u0000\u012c\u012d\u0001\u0000\u0000\u0000\u012d"+
"\u012f\u0001\u0000\u0000\u0000\u012e\u012c\u0001\u0000\u0000\u0000\u012f"+
"\u0130\u0005\n\u0000\u0000\u0130\u0132\u0001\u0000\u0000\u0000\u0131\u0126"+
"\u0001\u0000\u0000\u0000\u0131\u0132\u0001\u0000\u0000\u0000\u0132\t\u0001"+
"\u0000\u0000\u0000\u0133\u0134\u0005\u0014\u0000\u0000\u0134\u0135\u0005"+
"\u0002\u0000\u0000\u0135\u0136\u0003\u0018\f\u0000\u0136\u000b\u0001\u0000"+
"\u0000\u0000\u0137\u0138\u0005\u0015\u0000\u0000\u0138\u0139\u0005\u0002"+
"\u0000\u0000\u0139\u0144\u0003\u000e\u0007\u0000\u013a\u013e\u0005\u0003"+
"\u0000\u0000\u013b\u013d\u0005\u0004\u0000\u0000\u013c\u013b\u0001\u0000"+
"\u0000\u0000\u013d\u0140\u0001\u0000\u0000\u0000\u013e\u013c\u0001\u0000"+
"\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000\u013f\u0141\u0001\u0000"+
"\u0000\u0000\u0140\u013e\u0001\u0000\u0000\u0000\u0141\u0143\u0003\u000e"+
"\u0007\u0000\u0142\u013a\u0001\u0000\u0000\u0000\u0143\u0146\u0001\u0000"+
"\u0000\u0000\u0144\u0142\u0001\u0000\u0000\u0000\u0144\u0145\u0001\u0000"+
"\u0000\u0000\u0145\r\u0001\u0000\u0000\u0000\u0146\u0144\u0001\u0000\u0000"+
"\u0000\u0147\u014a\u0003(\u0014\u0000\u0148\u0149\u0005\u0004\u0000\u0000"+
"\u0149\u014b\u0007\u0001\u0000\u0000\u014a\u0148\u0001\u0000\u0000\u0000"+
"\u014a\u014b\u0001\u0000\u0000\u0000\u014b\u000f\u0001\u0000\u0000\u0000"+
"\u014c\u014d\u0005\u0016\u0000\u0000\u014d\u014e\u0005\u0002\u0000\u0000"+
"\u014e\u014f\u0003\u00acV\u0000\u014f\u0011\u0001\u0000\u0000\u0000\u0150"+
"\u0151\u0005\u0017\u0000\u0000\u0151\u0152\u0005\u0002\u0000\u0000\u0152"+
"\u0153\u0003\u00acV\u0000\u0153\u0013\u0001\u0000\u0000\u0000\u0154\u0155"+
"\u0005\u0018\u0000\u0000\u0155\u0156\u0005\u0002\u0000\u0000\u0156\u0161"+
"\u0003\u0016\u000b\u0000\u0157\u015b\u0005\u0003\u0000\u0000\u0158\u015a"+
"\u0005\u0004\u0000\u0000\u0159\u0158\u0001\u0000\u0000\u0000\u015a\u015d"+
"\u0001\u0000\u0000\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015b\u015c"+
"\u0001\u0000\u0000\u0000\u015c\u015e\u0001\u0000\u0000\u0000\u015d\u015b"+
"\u0001\u0000\u0000\u0000\u015e\u0160\u0003\u0016\u000b\u0000\u015f\u0157"+
"\u0001\u0000\u0000\u0000\u0160\u0163\u0001\u0000\u0000\u0000\u0161\u015f"+
"\u0001\u0000\u0000\u0000\u0161\u0162\u0001\u0000\u0000\u0000\u0162\u0015"+
"\u0001\u0000\u0000\u0000\u0163\u0161\u0001\u0000\u0000\u0000\u0164\u0165"+
"\u0005\u000f\u0000\u0000\u0165\u0017\u0001\u0000\u0000\u0000\u0166\u0173"+
"\u00030\u0018\u0000\u0167\u0173\u0003\u0090H\u0000\u0168\u016f\u0003\u001c"+
"\u000e\u0000\u0169\u0170\u0003\u0092I\u0000\u016a\u0170\u0003\u0094J\u0000"+
"\u016b\u0170\u0003\u0096K\u0000\u016c\u0170\u0003\u0098L\u0000\u016d\u0170"+
"\u0003\u009aM\u0000\u016e\u0170\u0003\u009cN\u0000\u016f\u0169\u0001\u0000"+
"\u0000\u0000\u016f\u016a\u0001\u0000\u0000\u0000\u016f\u016b\u0001\u0000"+
"\u0000\u0000\u016f\u016c\u0001\u0000\u0000\u0000\u016f\u016d\u0001\u0000"+
"\u0000\u0000\u016f\u016e\u0001\u0000\u0000\u0000\u0170\u0173\u0001\u0000"+
"\u0000\u0000\u0171\u0173\u0003\u001a\r\u0000\u0172\u0166\u0001\u0000\u0000"+
"\u0000\u0172\u0167\u0001\u0000\u0000\u0000\u0172\u0168\u0001\u0000\u0000"+
"\u0000\u0172\u0171\u0001\u0000\u0000\u0000\u0173\u0176\u0001\u0000\u0000"+
"\u0000\u0174\u0177\u0003\u008cF\u0000\u0175\u0177\u0003\u008eG\u0000\u0176"+
"\u0174\u0001\u0000\u0000\u0000\u0176\u0175\u0001\u0000\u0000\u0000\u0176"+
"\u0177\u0001\u0000\u0000\u0000\u0177\u0019\u0001\u0000\u0000\u0000\u0178"+
"\u017c\u0005\t\u0000\u0000\u0179\u017b\u0005\u0004\u0000\u0000\u017a\u0179"+
"\u0001\u0000\u0000\u0000\u017b\u017e\u0001\u0000\u0000\u0000\u017c\u017a"+
"\u0001\u0000\u0000\u0000\u017c\u017d\u0001\u0000\u0000\u0000\u017d\u017f"+
"\u0001\u0000\u0000\u0000\u017e\u017c\u0001\u0000\u0000\u0000\u017f\u0183"+
"\u0003\u0018\f\u0000\u0180\u0182\u0005\u0004\u0000\u0000\u0181\u0180\u0001"+
"\u0000\u0000\u0000\u0182\u0185\u0001\u0000\u0000\u0000\u0183\u0181\u0001"+
"\u0000\u0000\u0000\u0183\u0184\u0001\u0000\u0000\u0000\u0184\u0186\u0001"+
"\u0000\u0000\u0000\u0185\u0183\u0001\u0000\u0000\u0000\u0186\u0187\u0005"+
"\n\u0000\u0000\u0187\u001b\u0001\u0000\u0000\u0000\u0188\u018f\u0003("+
"\u0014\u0000\u0189\u018f\u0003 \u0010\u0000\u018a\u018f\u0003&\u0013\u0000"+
"\u018b\u018f\u0003\"\u0011\u0000\u018c\u018f\u0003$\u0012\u0000\u018d"+
"\u018f\u0003\u001e\u000f\u0000\u018e\u0188\u0001\u0000\u0000\u0000\u018e"+
"\u0189\u0001\u0000\u0000\u0000\u018e\u018a\u0001\u0000\u0000\u0000\u018e"+
"\u018b\u0001\u0000\u0000\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018e"+
"\u018d\u0001\u0000\u0000\u0000\u018f\u001d\u0001\u0000\u0000\u0000\u0190"+
"\u0194\u0005\t\u0000\u0000\u0191\u0193\u0005\u0004\u0000\u0000\u0192\u0191"+
"\u0001\u0000\u0000\u0000\u0193\u0196\u0001\u0000\u0000\u0000\u0194\u0192"+
"\u0001\u0000\u0000\u0000\u0194\u0195\u0001\u0000\u0000\u0000\u0195\u0197"+
"\u0001\u0000\u0000\u0000\u0196\u0194\u0001\u0000\u0000\u0000\u0197\u019b"+
"\u0003\u001c\u000e\u0000\u0198\u019a\u0005\u0004\u0000\u0000\u0199\u0198"+
"\u0001\u0000\u0000\u0000\u019a\u019d\u0001\u0000\u0000\u0000\u019b\u0199"+
"\u0001\u0000\u0000\u0000\u019b\u019c\u0001\u0000\u0000\u0000\u019c\u019e"+
"\u0001\u0000\u0000\u0000\u019d\u019b\u0001\u0000\u0000\u0000\u019e\u019f"+
"\u0005\n\u0000\u0000\u019f\u001f\u0001\u0000\u0000\u0000\u01a0\u01a4\u0005"+
"\t\u0000\u0000\u01a1\u01a3\u0005\u0004\u0000\u0000\u01a2\u01a1\u0001\u0000"+
"\u0000\u0000\u01a3\u01a6\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001\u0000"+
"\u0000\u0000\u01a4\u01a5\u0001\u0000\u0000\u0000\u01a5\u01a8\u0001\u0000"+
"\u0000\u0000\u01a6\u01a4\u0001\u0000\u0000\u0000\u01a7\u01a0\u0001\u0000"+
"\u0000\u0000\u01a7\u01a8\u0001\u0000\u0000\u0000\u01a8\u01ad\u0001\u0000"+
"\u0000\u0000\u01a9\u01ae\u0003\u00aaU\u0000\u01aa\u01ae\u0003(\u0014\u0000"+
"\u01ab\u01ae\u0003\u00a8T\u0000\u01ac\u01ae\u0003,\u0016\u0000\u01ad\u01a9"+
"\u0001\u0000\u0000\u0000\u01ad\u01aa\u0001\u0000\u0000\u0000\u01ad\u01ab"+
"\u0001\u0000\u0000\u0000\u01ad\u01ac\u0001\u0000\u0000\u0000\u01ae\u01b4"+
"\u0001\u0000\u0000\u0000\u01af\u01b5\u0003\u009eO\u0000\u01b0\u01b5\u0003"+
"\u00a0P\u0000\u01b1\u01b5\u0003\u00a2Q\u0000\u01b2\u01b5\u0003\u00a4R"+
"\u0000\u01b3\u01b5\u0003\u00a6S\u0000\u01b4\u01af\u0001\u0000\u0000\u0000"+
"\u01b4\u01b0\u0001\u0000\u0000\u0000\u01b4\u01b1\u0001\u0000\u0000\u0000"+
"\u01b4\u01b2\u0001\u0000\u0000\u0000\u01b4\u01b3\u0001\u0000\u0000\u0000"+
"\u01b4\u01b5\u0001\u0000\u0000\u0000\u01b5\u01bd\u0001\u0000\u0000\u0000"+
"\u01b6\u01ba\u0005\t\u0000\u0000\u01b7\u01b9\u0005\u0004\u0000\u0000\u01b8"+
"\u01b7\u0001\u0000\u0000\u0000\u01b9\u01bc\u0001\u0000\u0000\u0000\u01ba"+
"\u01b8\u0001\u0000\u0000\u0000\u01ba\u01bb\u0001\u0000\u0000\u0000\u01bb"+
"\u01be\u0001\u0000\u0000\u0000\u01bc\u01ba\u0001\u0000\u0000\u0000\u01bd"+
"\u01b6\u0001\u0000\u0000\u0000\u01bd\u01be\u0001\u0000\u0000\u0000\u01be"+
"!\u0001\u0000\u0000\u0000\u01bf\u01c0\u00034\u001a\u0000\u01c0#\u0001"+
"\u0000\u0000\u0000\u01c1\u01c4\u0003\u00aeW\u0000\u01c2\u01c4\u0003*\u0015"+
"\u0000\u01c3\u01c1\u0001\u0000\u0000\u0000\u01c3\u01c2\u0001\u0000\u0000"+
"\u0000\u01c4%\u0001\u0000\u0000\u0000\u01c5\u01d4\u0003\u00b0X\u0000\u01c6"+
"\u01d4\u0003\u00b8\\\u0000\u01c7\u01d4\u0003\u00c0`\u0000\u01c8\u01d4"+
"\u0003\u00c6c\u0000\u01c9\u01d4\u0003\u00ccf\u0000\u01ca\u01d4\u0003\u00d2"+
"i\u0000\u01cb\u01d4\u0003\u00e0p\u0000\u01cc\u01d4\u0003\u00eau\u0000"+
"\u01cd\u01d4\u0003\u00ecv\u0000\u01ce\u01d4\u0003\u00eew\u0000\u01cf\u01d4"+
"\u0003\u00f0x\u0000\u01d0\u01d4\u0003\u00f2y\u0000\u01d1\u01d4\u0003\u00f4"+
"z\u0000\u01d2\u01d4\u0003\u00f6{\u0000\u01d3\u01c5\u0001\u0000\u0000\u0000"+
"\u01d3\u01c6\u0001\u0000\u0000\u0000\u01d3\u01c7\u0001\u0000\u0000\u0000"+
"\u01d3\u01c8\u0001\u0000\u0000\u0000\u01d3\u01c9\u0001\u0000\u0000\u0000"+
"\u01d3\u01ca\u0001\u0000\u0000\u0000\u01d3\u01cb\u0001\u0000\u0000\u0000"+
"\u01d3\u01cc\u0001\u0000\u0000\u0000\u01d3\u01cd\u0001\u0000\u0000\u0000"+
"\u01d3\u01ce\u0001\u0000\u0000\u0000\u01d3\u01cf\u0001\u0000\u0000\u0000"+
"\u01d3\u01d0\u0001\u0000\u0000\u0000\u01d3\u01d1\u0001\u0000\u0000\u0000"+
"\u01d3\u01d2\u0001\u0000\u0000\u0000\u01d4\'\u0001\u0000\u0000\u0000\u01d5"+
"\u01d6\u0005\u000f\u0000\u0000\u01d6\u01d8\u0005\f\u0000\u0000\u01d7\u01d5"+
"\u0001\u0000\u0000\u0000\u01d8\u01db\u0001\u0000\u0000\u0000\u01d9\u01d7"+
"\u0001\u0000\u0000\u0000\u01d9\u01da\u0001\u0000\u0000\u0000\u01da\u01dc"+
"\u0001\u0000\u0000\u0000\u01db\u01d9\u0001\u0000\u0000\u0000\u01dc\u01dd"+
"\u0007\u0002\u0000\u0000\u01dd)\u0001\u0000\u0000\u0000\u01de\u01e4\u0003"+
">\u001f\u0000\u01df\u01e4\u0003@ \u0000\u01e0\u01e4\u0003B!\u0000\u01e1"+
"\u01e4\u0003<\u001e\u0000\u01e2\u01e4\u0003D\"\u0000\u01e3\u01de\u0001"+
"\u0000\u0000\u0000\u01e3\u01df\u0001\u0000\u0000\u0000\u01e3\u01e0\u0001"+
"\u0000\u0000\u0000\u01e3\u01e1\u0001\u0000\u0000\u0000\u01e3\u01e2\u0001"+
"\u0000\u0000\u0000\u01e4+\u0001\u0000\u0000\u0000\u01e5\u01f6\u0003d2"+
"\u0000\u01e6\u01f6\u0003f3\u0000\u01e7\u01f6\u0003h4\u0000\u01e8\u01f6"+
"\u0003j5\u0000\u01e9\u01f6\u0003l6\u0000\u01ea\u01f6\u0003n7\u0000\u01eb"+
"\u01f6\u0003p8\u0000\u01ec\u01f6\u0003r9\u0000\u01ed\u01f6\u0003t:\u0000"+
"\u01ee\u01f6\u0003x<\u0000\u01ef\u01f6\u0003z=\u0000\u01f0\u01f6\u0003"+
"|>\u0000\u01f1\u01f6\u0003~?\u0000\u01f2\u01f6\u0003\u0082A\u0000\u01f3"+
"\u01f6\u0003\u0084B\u0000\u01f4\u01f6\u0003\u0080@\u0000\u01f5\u01e5\u0001"+
"\u0000\u0000\u0000\u01f5\u01e6\u0001\u0000\u0000\u0000\u01f5\u01e7\u0001"+
"\u0000\u0000\u0000\u01f5\u01e8\u0001\u0000\u0000\u0000\u01f5\u01e9\u0001"+
"\u0000\u0000\u0000\u01f5\u01ea\u0001\u0000\u0000\u0000\u01f5\u01eb\u0001"+
"\u0000\u0000\u0000\u01f5\u01ec\u0001\u0000\u0000\u0000\u01f5\u01ed\u0001"+
"\u0000\u0000\u0000\u01f5\u01ee\u0001\u0000\u0000\u0000\u01f5\u01ef\u0001"+
"\u0000\u0000\u0000\u01f5\u01f0\u0001\u0000\u0000\u0000\u01f5\u01f1\u0001"+
"\u0000\u0000\u0000\u01f5\u01f2\u0001\u0000\u0000\u0000\u01f5\u01f3\u0001"+
"\u0000\u0000\u0000\u01f5\u01f4\u0001\u0000\u0000\u0000\u01f6-\u0001\u0000"+
"\u0000\u0000\u01f7\u01fc\u0003v;\u0000\u01f8\u01fc\u0003\u008aE\u0000"+
"\u01f9\u01fc\u0003\u0086C\u0000\u01fa\u01fc\u0003\u0088D\u0000\u01fb\u01f7"+
"\u0001\u0000\u0000\u0000\u01fb\u01f8\u0001\u0000\u0000\u0000\u01fb\u01f9"+
"\u0001\u0000\u0000\u0000\u01fb\u01fa\u0001\u0000\u0000\u0000\u01fc/\u0001"+
"\u0000\u0000\u0000\u01fd\u020c\u0003J%\u0000\u01fe\u020c\u0003H$\u0000"+
"\u01ff\u020c\u0003F#\u0000\u0200\u020c\u0003N\'\u0000\u0201\u020c\u0003"+
"R)\u0000\u0202\u020c\u0003T*\u0000\u0203\u020c\u0003V+\u0000\u0204\u020c"+
"\u0003X,\u0000\u0205\u020c\u0003Z-\u0000\u0206\u020c\u0003\\.\u0000\u0207"+
"\u020c\u0003^/\u0000\u0208\u020c\u0003`0\u0000\u0209\u020c\u0003b1\u0000"+
"\u020a\u020c\u0003L&\u0000\u020b\u01fd\u0001\u0000\u0000\u0000\u020b\u01fe"+
"\u0001\u0000\u0000\u0000\u020b\u01ff\u0001\u0000\u0000\u0000\u020b\u0200"+
"\u0001\u0000\u0000\u0000\u020b\u0201\u0001\u0000\u0000\u0000\u020b\u0202"+
"\u0001\u0000\u0000\u0000\u020b\u0203\u0001\u0000\u0000\u0000\u020b\u0204"+
"\u0001\u0000\u0000\u0000\u020b\u0205\u0001\u0000\u0000\u0000\u020b\u0206"+
"\u0001\u0000\u0000\u0000\u020b\u0207\u0001\u0000\u0000\u0000\u020b\u0208"+
"\u0001\u0000\u0000\u0000\u020b\u0209\u0001\u0000\u0000\u0000\u020b\u020a"+
"\u0001\u0000\u0000\u0000\u020c1\u0001\u0000\u0000\u0000\u020d\u0210\u0003"+
"$\u0012\u0000\u020e\u0210\u0003(\u0014\u0000\u020f\u020d\u0001\u0000\u0000"+
"\u0000\u020f\u020e\u0001\u0000\u0000\u0000\u02103\u0001\u0000\u0000\u0000"+
"\u0211\u0215\u0003.\u0017\u0000\u0212\u0215\u0003(\u0014\u0000\u0213\u0215"+
"\u00038\u001c\u0000\u0214\u0211\u0001\u0000\u0000\u0000\u0214\u0212\u0001"+
"\u0000\u0000\u0000\u0214\u0213\u0001\u0000\u0000\u0000\u02155\u0001\u0000"+
"\u0000\u0000\u0216\u0219\u0003&\u0013\u0000\u0217\u0219\u0003(\u0014\u0000"+
"\u0218\u0216\u0001\u0000\u0000\u0000\u0218\u0217\u0001\u0000\u0000\u0000"+
"\u02197\u0001\u0000\u0000\u0000\u021a\u021b\u0005X\u0000\u0000\u021b\u021c"+
"\u0005g\u0000\u0000\u021c\u021d\u0005\u0006\u0000\u0000\u021d\u021e\u0005"+
"g\u0000\u0000\u021e\u021f\u0005d\u0000\u0000\u021f\u0220\u0005g\u0000"+
"\u0000\u0220\u0221\u0005\u000e\u0000\u0000\u0221\u0222\u0005g\u0000\u0000"+
"\u0222\u0227\u0005\u000e\u0000\u0000\u0223\u0228\u0005g\u0000\u0000\u0224"+
"\u0225\u0005g\u0000\u0000\u0225\u0226\u0005\r\u0000\u0000\u0226\u0228"+
"\u0005f\u0000\u0000\u0227\u0223\u0001\u0000\u0000\u0000\u0227\u0224\u0001"+
"\u0000\u0000\u0000\u0228\u0229\u0001\u0000\u0000\u0000\u0229\u022a\u0003"+
":\u001d\u0000\u022a9\u0001\u0000\u0000\u0000\u022b\u0233\u0005e\u0000"+
"\u0000\u022c\u022d\u0005\u000b\u0000\u0000\u022d\u0230\u0005g\u0000\u0000"+
"\u022e\u022f\u0005\u000e\u0000\u0000\u022f\u0231\u0005g\u0000\u0000\u0230"+
"\u022e\u0001\u0000\u0000\u0000\u0230\u0231\u0001\u0000\u0000\u0000\u0231"+
"\u0233\u0001\u0000\u0000\u0000\u0232\u022b\u0001\u0000\u0000\u0000\u0232"+
"\u022c\u0001\u0000\u0000\u0000\u0233;\u0001\u0000\u0000\u0000\u0234\u0235"+
"\u0005#\u0000\u0000\u0235\u0239\u0005\t\u0000\u0000\u0236\u0238\u0005"+
"\u0004\u0000\u0000\u0237\u0236\u0001\u0000\u0000\u0000\u0238\u023b\u0001"+
"\u0000\u0000\u0000\u0239\u0237\u0001\u0000\u0000\u0000\u0239\u023a\u0001"+
"\u0000\u0000\u0000\u023a\u023c\u0001\u0000\u0000\u0000\u023b\u0239\u0001"+
"\u0000\u0000\u0000\u023c\u0240\u00032\u0019\u0000\u023d\u023f\u0005\u0004"+
"\u0000\u0000\u023e\u023d\u0001\u0000\u0000\u0000\u023f\u0242\u0001\u0000"+
"\u0000\u0000\u0240\u023e\u0001\u0000\u0000\u0000\u0240\u0241\u0001\u0000"+
"\u0000\u0000\u0241\u0243\u0001\u0000\u0000\u0000\u0242\u0240\u0001\u0000"+
"\u0000\u0000\u0243\u0247\u0005\u0003\u0000\u0000\u0244\u0246\u0005\u0004"+
"\u0000\u0000\u0245\u0244\u0001\u0000\u0000\u0000\u0246\u0249\u0001\u0000"+
"\u0000\u0000\u0247\u0245\u0001\u0000\u0000\u0000\u0247\u0248\u0001\u0000"+
"\u0000\u0000\u0248\u024a\u0001\u0000\u0000\u0000\u0249\u0247\u0001\u0000"+
"\u0000\u0000\u024a\u024b\u0003 \u0010\u0000\u024b\u024c\u0005\n\u0000"+
"\u0000\u024c=\u0001\u0000\u0000\u0000\u024d\u024e\u0005$\u0000\u0000\u024e"+
"\u0252\u0005\t\u0000\u0000\u024f\u0251\u0005\u0004\u0000\u0000\u0250\u024f"+
"\u0001\u0000\u0000\u0000\u0251\u0254\u0001\u0000\u0000\u0000\u0252\u0250"+
"\u0001\u0000\u0000\u0000\u0252\u0253\u0001\u0000\u0000\u0000\u0253\u0255"+
"\u0001\u0000\u0000\u0000\u0254\u0252\u0001\u0000\u0000\u0000\u0255\u0259"+
"\u00032\u0019\u0000\u0256\u0258\u0005\u0004\u0000\u0000\u0257\u0256\u0001"+
"\u0000\u0000\u0000\u0258\u025b\u0001\u0000\u0000\u0000\u0259\u0257\u0001"+
"\u0000\u0000\u0000\u0259\u025a\u0001\u0000\u0000\u0000\u025a\u025c\u0001"+
"\u0000\u0000\u0000\u025b\u0259\u0001\u0000\u0000\u0000\u025c\u025d\u0005"+
"\n\u0000\u0000\u025d?\u0001\u0000\u0000\u0000\u025e\u025f\u0005%\u0000"+
"\u0000\u025f\u0263\u0005\t\u0000\u0000\u0260\u0262\u0005\u0004\u0000\u0000"+
"\u0261\u0260\u0001\u0000\u0000\u0000\u0262\u0265\u0001\u0000\u0000\u0000"+
"\u0263\u0261\u0001\u0000\u0000\u0000\u0263\u0264\u0001\u0000\u0000\u0000"+
"\u0264\u0266\u0001\u0000\u0000\u0000\u0265\u0263\u0001\u0000\u0000\u0000"+
"\u0266\u026a\u00032\u0019\u0000\u0267\u0269\u0005\u0004\u0000\u0000\u0268"+
"\u0267\u0001\u0000\u0000\u0000\u0269\u026c\u0001\u0000\u0000\u0000\u026a"+
"\u0268\u0001\u0000\u0000\u0000\u026a\u026b\u0001\u0000\u0000\u0000\u026b"+
"\u026d\u0001\u0000\u0000\u0000\u026c\u026a\u0001\u0000\u0000\u0000\u026d"+
"\u026e\u0005\n\u0000\u0000\u026eA\u0001\u0000\u0000\u0000\u026f\u0270"+
"\u0005&\u0000\u0000\u0270\u0274\u0005\t\u0000\u0000\u0271\u0273\u0005"+
"\u0004\u0000\u0000\u0272\u0271\u0001\u0000\u0000\u0000\u0273\u0276\u0001"+
"\u0000\u0000\u0000\u0274\u0272\u0001\u0000\u0000\u0000\u0274\u0275\u0001"+
"\u0000\u0000\u0000\u0275\u0277\u0001\u0000\u0000\u0000\u0276\u0274\u0001"+
"\u0000\u0000\u0000\u0277\u027b\u00032\u0019\u0000\u0278\u027a\u0005\u0004"+
"\u0000\u0000\u0279\u0278\u0001\u0000\u0000\u0000\u027a\u027d\u0001\u0000"+
"\u0000\u0000\u027b\u0279\u0001\u0000\u0000\u0000\u027b\u027c\u0001\u0000"+
"\u0000\u0000\u027c\u027e\u0001\u0000\u0000\u0000\u027d\u027b\u0001\u0000"+
"\u0000\u0000\u027e\u027f\u0005\n\u0000\u0000\u027fC\u0001\u0000\u0000"+
"\u0000\u0280\u0281\u0005\'\u0000\u0000\u0281\u0285\u0005\t\u0000\u0000"+
"\u0282\u0284\u0005\u0004\u0000\u0000\u0283\u0282\u0001\u0000\u0000\u0000"+
"\u0284\u0287\u0001\u0000\u0000\u0000\u0285\u0283\u0001\u0000\u0000\u0000"+
"\u0285\u0286\u0001\u0000\u0000\u0000\u0286\u0288\u0001\u0000\u0000\u0000"+
"\u0287\u0285\u0001\u0000\u0000\u0000\u0288\u028c\u00032\u0019\u0000\u0289"+
"\u028b\u0005\u0004\u0000\u0000\u028a\u0289\u0001\u0000\u0000\u0000\u028b"+
"\u028e\u0001\u0000\u0000\u0000\u028c\u028a\u0001\u0000\u0000\u0000\u028c"+
"\u028d\u0001\u0000\u0000\u0000\u028d\u028f\u0001\u0000\u0000\u0000\u028e"+
"\u028c\u0001\u0000\u0000\u0000\u028f\u0293\u0005\u0003\u0000\u0000\u0290"+
"\u0292\u0005\u0004\u0000\u0000\u0291\u0290\u0001\u0000\u0000\u0000\u0292"+
"\u0295\u0001\u0000\u0000\u0000\u0293\u0291\u0001\u0000\u0000\u0000\u0293"+
"\u0294\u0001\u0000\u0000\u0000\u0294\u0296\u0001\u0000\u0000\u0000\u0295"+
"\u0293\u0001\u0000\u0000\u0000\u0296\u029a\u00032\u0019\u0000\u0297\u0299"+
"\u0005\u0004\u0000\u0000\u0298\u0297\u0001\u0000\u0000\u0000\u0299\u029c"+
"\u0001\u0000\u0000\u0000\u029a\u0298\u0001\u0000\u0000\u0000\u029a\u029b"+
"\u0001\u0000\u0000\u0000\u029b\u029d\u0001\u0000\u0000\u0000\u029c\u029a"+
"\u0001\u0000\u0000\u0000\u029d\u029e\u0005\n\u0000\u0000\u029eE\u0001"+
"\u0000\u0000\u0000\u029f\u02a0\u0005\u001e\u0000\u0000\u02a0\u02a4\u0005"+
"\t\u0000\u0000\u02a1\u02a3\u0005\u0004\u0000\u0000\u02a2\u02a1\u0001\u0000"+
"\u0000\u0000\u02a3\u02a6\u0001\u0000\u0000\u0000\u02a4\u02a2\u0001\u0000"+
"\u0000\u0000\u02a4\u02a5\u0001\u0000\u0000\u0000\u02a5\u02a7\u0001\u0000"+
"\u0000\u0000\u02a6\u02a4\u0001\u0000\u0000\u0000\u02a7\u02ab\u00032\u0019"+
"\u0000\u02a8\u02aa\u0005\u0004\u0000\u0000\u02a9\u02a8\u0001\u0000\u0000"+
"\u0000\u02aa\u02ad\u0001\u0000\u0000\u0000\u02ab\u02a9\u0001\u0000\u0000"+
"\u0000\u02ab\u02ac\u0001\u0000\u0000\u0000\u02ac\u02ae\u0001\u0000\u0000"+
"\u0000\u02ad\u02ab\u0001\u0000\u0000\u0000\u02ae\u02b2\u0005\u0003\u0000"+
"\u0000\u02af\u02b1\u0005\u0004\u0000\u0000\u02b0\u02af\u0001\u0000\u0000"+
"\u0000\u02b1\u02b4\u0001\u0000\u0000\u0000\u02b2\u02b0\u0001\u0000\u0000"+
"\u0000\u02b2\u02b3\u0001\u0000\u0000\u0000\u02b3\u02b5\u0001\u0000\u0000"+
"\u0000\u02b4\u02b2\u0001\u0000\u0000\u0000\u02b5\u02b9\u00032\u0019\u0000"+
"\u02b6\u02b8\u0005\u0004\u0000\u0000\u02b7\u02b6\u0001\u0000\u0000\u0000"+
"\u02b8\u02bb\u0001\u0000\u0000\u0000\u02b9\u02b7\u0001\u0000\u0000\u0000"+
"\u02b9\u02ba\u0001\u0000\u0000\u0000\u02ba\u02bc\u0001\u0000\u0000\u0000"+
"\u02bb\u02b9\u0001\u0000\u0000\u0000\u02bc\u02bd\u0005\n\u0000\u0000\u02bd"+
"G\u0001\u0000\u0000\u0000\u02be\u02bf\u0005\u001f\u0000\u0000\u02bf\u02c3"+
"\u0005\t\u0000\u0000\u02c0\u02c2\u0005\u0004\u0000\u0000\u02c1\u02c0\u0001"+
"\u0000\u0000\u0000\u02c2\u02c5\u0001\u0000\u0000\u0000\u02c3\u02c1\u0001"+
"\u0000\u0000\u0000\u02c3\u02c4\u0001\u0000\u0000\u0000\u02c4\u02c6\u0001"+
"\u0000\u0000\u0000\u02c5\u02c3\u0001\u0000\u0000\u0000\u02c6\u02ca\u0003"+
"2\u0019\u0000\u02c7\u02c9\u0005\u0004\u0000\u0000\u02c8\u02c7\u0001\u0000"+
"\u0000\u0000\u02c9\u02cc\u0001\u0000\u0000\u0000\u02ca\u02c8\u0001\u0000"+
"\u0000\u0000\u02ca\u02cb\u0001\u0000\u0000\u0000\u02cb\u02cd\u0001\u0000"+
"\u0000\u0000\u02cc\u02ca\u0001\u0000\u0000\u0000\u02cd\u02d1\u0005\u0003"+
"\u0000\u0000\u02ce\u02d0\u0005\u0004\u0000\u0000\u02cf\u02ce\u0001\u0000"+
"\u0000\u0000\u02d0\u02d3\u0001\u0000\u0000\u0000\u02d1\u02cf\u0001\u0000"+
"\u0000\u0000\u02d1\u02d2\u0001\u0000\u0000\u0000\u02d2\u02d4\u0001\u0000"+
"\u0000\u0000\u02d3\u02d1\u0001\u0000\u0000\u0000\u02d4\u02d8\u00032\u0019"+
"\u0000\u02d5\u02d7\u0005\u0004\u0000\u0000\u02d6\u02d5\u0001\u0000\u0000"+
"\u0000\u02d7\u02da\u0001\u0000\u0000\u0000\u02d8\u02d6\u0001\u0000\u0000"+
"\u0000\u02d8\u02d9\u0001\u0000\u0000\u0000\u02d9\u02db\u0001\u0000\u0000"+
"\u0000\u02da\u02d8\u0001\u0000\u0000\u0000\u02db\u02dc\u0005\n\u0000\u0000"+
"\u02dcI\u0001\u0000\u0000\u0000\u02dd\u02de\u0005 \u0000\u0000\u02de\u02e2"+
"\u0005\t\u0000\u0000\u02df\u02e1\u0005\u0004\u0000\u0000\u02e0\u02df\u0001"+
"\u0000\u0000\u0000\u02e1\u02e4\u0001\u0000\u0000\u0000\u02e2\u02e0\u0001"+
"\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000\u0000\u02e3\u02e5\u0001"+
"\u0000\u0000\u0000\u02e4\u02e2\u0001\u0000\u0000\u0000\u02e5\u02e9\u0003"+
"2\u0019\u0000\u02e6\u02e8\u0005\u0004\u0000\u0000\u02e7\u02e6\u0001\u0000"+
"\u0000\u0000\u02e8\u02eb\u0001\u0000\u0000\u0000\u02e9\u02e7\u0001\u0000"+
"\u0000\u0000\u02e9\u02ea\u0001\u0000\u0000\u0000\u02ea\u02ec\u0001\u0000"+
"\u0000\u0000\u02eb\u02e9\u0001\u0000\u0000\u0000\u02ec\u02f0\u0005\u0003"+
"\u0000\u0000\u02ed\u02ef\u0005\u0004\u0000\u0000\u02ee\u02ed\u0001\u0000"+
"\u0000\u0000\u02ef\u02f2\u0001\u0000\u0000\u0000\u02f0\u02ee\u0001\u0000"+
"\u0000\u0000\u02f0\u02f1\u0001\u0000\u0000\u0000\u02f1\u02f3\u0001\u0000"+
"\u0000\u0000\u02f2\u02f0\u0001\u0000\u0000\u0000\u02f3\u02f7\u00032\u0019"+
"\u0000\u02f4\u02f6\u0005\u0004\u0000\u0000\u02f5\u02f4\u0001\u0000\u0000"+
"\u0000\u02f6\u02f9\u0001\u0000\u0000\u0000\u02f7\u02f5\u0001\u0000\u0000"+
"\u0000\u02f7\u02f8\u0001\u0000\u0000\u0000\u02f8\u02fa\u0001\u0000\u0000"+
"\u0000\u02f9\u02f7\u0001\u0000\u0000\u0000\u02fa\u02fb\u0005\n\u0000\u0000"+
"\u02fbK\u0001\u0000\u0000\u0000\u02fc\u02fd\u0005(\u0000\u0000\u02fd\u0301"+
"\u0005\t\u0000\u0000\u02fe\u0300\u0005\u0004\u0000\u0000\u02ff\u02fe\u0001"+
"\u0000\u0000\u0000\u0300\u0303\u0001\u0000\u0000\u0000\u0301\u02ff\u0001"+
"\u0000\u0000\u0000\u0301\u0302\u0001\u0000\u0000\u0000\u0302\u0304\u0001"+
"\u0000\u0000\u0000\u0303\u0301\u0001\u0000\u0000\u0000\u0304\u0308\u0003"+
"(\u0014\u0000\u0305\u0307\u0005\u0004\u0000\u0000\u0306\u0305\u0001\u0000"+
"\u0000\u0000\u0307\u030a\u0001\u0000\u0000\u0000\u0308\u0306\u0001\u0000"+
"\u0000\u0000\u0308\u0309\u0001\u0000\u0000\u0000\u0309\u030b\u0001\u0000"+
"\u0000\u0000\u030a\u0308\u0001\u0000\u0000\u0000\u030b\u030f\u0005\u0003"+
"\u0000\u0000\u030c\u030e\u0005\u0004\u0000\u0000\u030d\u030c\u0001\u0000"+
"\u0000\u0000\u030e\u0311\u0001\u0000\u0000\u0000\u030f\u030d\u0001\u0000"+
"\u0000\u0000\u030f\u0310\u0001\u0000\u0000\u0000\u0310\u0312\u0001\u0000"+
"\u0000\u0000\u0311\u030f\u0001\u0000\u0000\u0000\u0312\u0316\u0003\u0018"+
"\f\u0000\u0313\u0315\u0005\u0004\u0000\u0000\u0314\u0313\u0001\u0000\u0000"+
"\u0000\u0315\u0318\u0001\u0000\u0000\u0000\u0316\u0314\u0001\u0000\u0000"+
"\u0000\u0316\u0317\u0001\u0000\u0000\u0000\u0317\u0319\u0001\u0000\u0000"+
"\u0000\u0318\u0316\u0001\u0000\u0000\u0000\u0319\u031d\u0005\u0003\u0000"+
"\u0000\u031a\u031c\u0005\u0004\u0000\u0000\u031b\u031a\u0001\u0000\u0000"+
"\u0000\u031c\u031f\u0001\u0000\u0000\u0000\u031d\u031b\u0001\u0000\u0000"+
"\u0000\u031d\u031e\u0001\u0000\u0000\u0000\u031e\u0320\u0001\u0000\u0000"+
"\u0000\u031f\u031d\u0001\u0000\u0000\u0000\u0320\u0324\u0003\u0018\f\u0000"+
"\u0321\u0323\u0005\u0004\u0000\u0000\u0322\u0321\u0001\u0000\u0000\u0000"+
"\u0323\u0326\u0001\u0000\u0000\u0000\u0324\u0322\u0001\u0000\u0000\u0000"+
"\u0324\u0325\u0001\u0000\u0000\u0000\u0325\u0327\u0001\u0000\u0000\u0000"+
"\u0326\u0324\u0001\u0000\u0000\u0000\u0327\u0328\u0005\n\u0000\u0000\u0328"+
"M\u0001\u0000\u0000\u0000\u0329\u032a\u0005;\u0000\u0000\u032a\u032e\u0005"+
"\t\u0000\u0000\u032b\u032d\u0005\u0004\u0000\u0000\u032c\u032b\u0001\u0000"+
"\u0000\u0000\u032d\u0330\u0001\u0000\u0000\u0000\u032e\u032c\u0001\u0000"+
"\u0000\u0000\u032e\u032f\u0001\u0000\u0000\u0000\u032f\u0331\u0001\u0000"+
"\u0000\u0000\u0330\u032e\u0001\u0000\u0000\u0000\u0331\u0335\u00036\u001b"+
"\u0000\u0332\u0334\u0005\u0004\u0000\u0000\u0333\u0332\u0001\u0000\u0000"+
"\u0000\u0334\u0337\u0001\u0000\u0000\u0000\u0335\u0333\u0001\u0000\u0000"+
"\u0000\u0335\u0336\u0001\u0000\u0000\u0000\u0336\u0338\u0001\u0000\u0000"+
"\u0000\u0337\u0335\u0001\u0000\u0000\u0000\u0338\u033c\u0005\u0003\u0000"+
"\u0000\u0339\u033b\u0005\u0004\u0000\u0000\u033a\u0339\u0001\u0000\u0000"+
"\u0000\u033b\u033e\u0001\u0000\u0000\u0000\u033c\u033a\u0001\u0000\u0000"+
"\u0000\u033c\u033d\u0001\u0000\u0000\u0000\u033d\u033f\u0001\u0000\u0000"+
"\u0000\u033e\u033c\u0001\u0000\u0000\u0000\u033f\u0343\u00036\u001b\u0000"+
"\u0340\u0342\u0005\u0004\u0000\u0000\u0341\u0340\u0001\u0000\u0000\u0000"+
"\u0342\u0345\u0001\u0000\u0000\u0000\u0343\u0341\u0001\u0000\u0000\u0000"+
"\u0343\u0344\u0001\u0000\u0000\u0000\u0344\u0346\u0001\u0000\u0000\u0000"+
"\u0345\u0343\u0001\u0000\u0000\u0000\u0346\u0347\u0005\n\u0000\u0000\u0347"+
"O\u0001\u0000\u0000\u0000\u0348\u034c\u0005\t\u0000\u0000\u0349\u034b"+
"\u0005\u0004\u0000\u0000\u034a\u0349\u0001\u0000\u0000\u0000\u034b\u034e"+
"\u0001\u0000\u0000\u0000\u034c\u034a\u0001\u0000\u0000\u0000\u034c\u034d"+
"\u0001\u0000\u0000\u0000\u034d\u034f\u0001\u0000\u0000\u0000\u034e\u034c"+
"\u0001\u0000\u0000\u0000\u034f\u0353\u00036\u001b\u0000\u0350\u0352\u0005"+
"\u0004\u0000\u0000\u0351\u0350\u0001\u0000\u0000\u0000\u0352\u0355\u0001"+
"\u0000\u0000\u0000\u0353\u0351\u0001\u0000\u0000\u0000\u0353\u0354\u0001"+
"\u0000\u0000\u0000\u0354\u0356\u0001\u0000\u0000\u0000\u0355\u0353\u0001"+
"\u0000\u0000\u0000\u0356\u035a\u0005\u0003\u0000\u0000\u0357\u0359\u0005"+
"\u0004\u0000\u0000\u0358\u0357\u0001\u0000\u0000\u0000\u0359\u035c\u0001"+
"\u0000\u0000\u0000\u035a\u0358\u0001\u0000\u0000\u0000\u035a\u035b\u0001"+
"\u0000\u0000\u0000\u035b\u035d\u0001\u0000\u0000\u0000\u035c\u035a\u0001"+
"\u0000\u0000\u0000\u035d\u0361\u00036\u001b\u0000\u035e\u0360\u0005\u0004"+
"\u0000\u0000\u035f\u035e\u0001\u0000\u0000\u0000\u0360\u0363\u0001\u0000"+
"\u0000\u0000\u0361\u035f\u0001\u0000\u0000\u0000\u0361\u0362\u0001\u0000"+
"\u0000\u0000\u0362\u0364\u0001\u0000\u0000\u0000\u0363\u0361\u0001\u0000"+
"\u0000\u0000\u0364\u0365\u0005\n\u0000\u0000\u0365Q\u0001\u0000\u0000"+
"\u0000\u0366\u0367\u0005<\u0000\u0000\u0367\u0368\u0003P(\u0000\u0368"+
"S\u0001\u0000\u0000\u0000\u0369\u036a\u0005=\u0000\u0000\u036a\u036b\u0003"+
"P(\u0000\u036bU\u0001\u0000\u0000\u0000\u036c\u036d\u0005>\u0000\u0000"+
"\u036d\u036e\u0003P(\u0000\u036eW\u0001\u0000\u0000\u0000\u036f\u0370"+
"\u0005?\u0000\u0000\u0370\u0371\u0003P(\u0000\u0371Y\u0001\u0000\u0000"+
"\u0000\u0372\u0373\u0005@\u0000\u0000\u0373\u0374\u0003P(\u0000\u0374"+
"[\u0001\u0000\u0000\u0000\u0375\u0376\u0005A\u0000\u0000\u0376\u0377\u0003"+
"P(\u0000\u0377]\u0001\u0000\u0000\u0000\u0378\u0379\u0005B\u0000\u0000"+
"\u0379\u037a\u0003P(\u0000\u037a_\u0001\u0000\u0000\u0000\u037b\u037c"+
"\u0005C\u0000\u0000\u037c\u037d\u0003P(\u0000\u037da\u0001\u0000\u0000"+
"\u0000\u037e\u037f\u0005D\u0000\u0000\u037f\u0383\u0005\t\u0000\u0000"+
"\u0380\u0382\u0005\u0004\u0000\u0000\u0381\u0380\u0001\u0000\u0000\u0000"+
"\u0382\u0385\u0001\u0000\u0000\u0000\u0383\u0381\u0001\u0000\u0000\u0000"+
"\u0383\u0384\u0001\u0000\u0000\u0000\u0384\u0386\u0001\u0000\u0000\u0000"+
"\u0385\u0383\u0001\u0000\u0000\u0000\u0386\u038a\u00036\u001b\u0000\u0387"+
"\u0389\u0005\u0004\u0000\u0000\u0388\u0387\u0001\u0000\u0000\u0000\u0389"+
"\u038c\u0001\u0000\u0000\u0000\u038a\u0388\u0001\u0000\u0000\u0000\u038a"+
"\u038b\u0001\u0000\u0000\u0000\u038b\u038d\u0001\u0000\u0000\u0000\u038c"+
"\u038a\u0001\u0000\u0000\u0000\u038d\u0391\u0005\u0003\u0000\u0000\u038e"+
"\u0390\u0005\u0004\u0000\u0000\u038f\u038e\u0001\u0000\u0000\u0000\u0390"+
"\u0393\u0001\u0000\u0000\u0000\u0391\u038f\u0001\u0000\u0000\u0000\u0391"+
"\u0392\u0001\u0000\u0000\u0000\u0392\u0394\u0001\u0000\u0000\u0000\u0393"+
"\u0391\u0001\u0000\u0000\u0000\u0394\u0398\u00036\u001b\u0000\u0395\u0397"+
"\u0005\u0004\u0000\u0000\u0396\u0395\u0001\u0000\u0000\u0000\u0397\u039a"+
"\u0001\u0000\u0000\u0000\u0398\u0396\u0001\u0000\u0000\u0000\u0398\u0399"+
"\u0001\u0000\u0000\u0000\u0399\u039b\u0001\u0000\u0000\u0000\u039a\u0398"+
"\u0001\u0000\u0000\u0000\u039b\u039f\u0005\u0003\u0000\u0000\u039c\u039e"+
"\u0005\u0004\u0000\u0000\u039d\u039c\u0001\u0000\u0000\u0000\u039e\u03a1"+
"\u0001\u0000\u0000\u0000\u039f\u039d\u0001\u0000\u0000\u0000\u039f\u03a0"+
"\u0001\u0000\u0000\u0000\u03a0\u03a2\u0001\u0000\u0000\u0000\u03a1\u039f"+
"\u0001\u0000\u0000\u0000\u03a2\u03a6\u0003\u00aeW\u0000\u03a3\u03a5\u0005"+
"\u0004\u0000\u0000\u03a4\u03a3\u0001\u0000\u0000\u0000\u03a5\u03a8\u0001"+
"\u0000\u0000\u0000\u03a6\u03a4\u0001\u0000\u0000\u0000\u03a6\u03a7\u0001"+
"\u0000\u0000\u0000\u03a7\u03a9\u0001\u0000\u0000\u0000\u03a8\u03a6\u0001"+
"\u0000\u0000\u0000\u03a9\u03aa\u0005\n\u0000\u0000\u03aac\u0001\u0000"+
"\u0000\u0000\u03ab\u03ac\u0005!\u0000\u0000\u03ac\u03b0\u0005\t\u0000"+
"\u0000\u03ad\u03af\u0005\u0004\u0000\u0000\u03ae\u03ad\u0001\u0000\u0000"+
"\u0000\u03af\u03b2\u0001\u0000\u0000\u0000\u03b0\u03ae\u0001\u0000\u0000"+
"\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1\u03b3\u0001\u0000\u0000"+
"\u0000\u03b2\u03b0\u0001\u0000\u0000\u0000\u03b3\u03b7\u00032\u0019\u0000"+
"\u03b4\u03b6\u0005\u0004\u0000\u0000\u03b5\u03b4\u0001\u0000\u0000\u0000"+
"\u03b6\u03b9\u0001\u0000\u0000\u0000\u03b7\u03b5\u0001\u0000\u0000\u0000"+
"\u03b7\u03b8\u0001\u0000\u0000\u0000\u03b8\u03ba\u0001\u0000\u0000\u0000"+
"\u03b9\u03b7\u0001\u0000\u0000\u0000\u03ba\u03bb\u0005\n\u0000\u0000\u03bb"+
"e\u0001\u0000\u0000\u0000\u03bc\u03bd\u0005\"\u0000\u0000\u03bd\u03c1"+
"\u0005\t\u0000\u0000\u03be\u03c0\u0005\u0004\u0000\u0000\u03bf\u03be\u0001"+
"\u0000\u0000\u0000\u03c0\u03c3\u0001\u0000\u0000\u0000\u03c1\u03bf\u0001"+
"\u0000\u0000\u0000\u03c1\u03c2\u0001\u0000\u0000\u0000\u03c2\u03c4\u0001"+
"\u0000\u0000\u0000\u03c3\u03c1\u0001\u0000\u0000\u0000\u03c4\u03c8\u0003"+
"2\u0019\u0000\u03c5\u03c7\u0005\u0004\u0000\u0000\u03c6\u03c5\u0001\u0000"+
"\u0000\u0000\u03c7\u03ca\u0001\u0000\u0000\u0000\u03c8\u03c6\u0001\u0000"+
"\u0000\u0000\u03c8\u03c9\u0001\u0000\u0000\u0000\u03c9\u03cb\u0001\u0000"+
"\u0000\u0000\u03ca\u03c8\u0001\u0000\u0000\u0000\u03cb\u03cf\u0005\u0003"+
"\u0000\u0000\u03cc\u03ce\u0005\u0004\u0000\u0000\u03cd\u03cc\u0001\u0000"+
"\u0000\u0000\u03ce\u03d1\u0001\u0000\u0000\u0000\u03cf\u03cd\u0001\u0000"+
"\u0000\u0000\u03cf\u03d0\u0001\u0000\u0000\u0000\u03d0\u03d2\u0001\u0000"+
"\u0000\u0000\u03d1\u03cf\u0001\u0000\u0000\u0000\u03d2\u03d6\u00032\u0019"+
"\u0000\u03d3\u03d5\u0005\u0004\u0000\u0000\u03d4\u03d3\u0001\u0000\u0000"+
"\u0000\u03d5\u03d8\u0001\u0000\u0000\u0000\u03d6\u03d4\u0001\u0000\u0000"+
"\u0000\u03d6\u03d7\u0001\u0000\u0000\u0000\u03d7\u03d9\u0001\u0000\u0000"+
"\u0000\u03d8\u03d6\u0001\u0000\u0000\u0000\u03d9\u03da\u0005\n\u0000\u0000"+
"\u03dag\u0001\u0000\u0000\u0000\u03db\u03dc\u0005)\u0000\u0000\u03dc\u03e0"+
"\u0005\t\u0000\u0000\u03dd\u03df\u0005\u0004\u0000\u0000\u03de\u03dd\u0001"+
"\u0000\u0000\u0000\u03df\u03e2\u0001\u0000\u0000\u0000\u03e0\u03de\u0001"+
"\u0000\u0000\u0000\u03e0\u03e1\u0001\u0000\u0000\u0000\u03e1\u03e3\u0001"+
"\u0000\u0000\u0000\u03e2\u03e0\u0001\u0000\u0000\u0000\u03e3\u03e7\u0003"+
"4\u001a\u0000\u03e4\u03e6\u0005\u0004\u0000\u0000\u03e5\u03e4\u0001\u0000"+
"\u0000\u0000\u03e6\u03e9\u0001\u0000\u0000\u0000\u03e7\u03e5\u0001\u0000"+
"\u0000\u0000\u03e7\u03e8\u0001\u0000\u0000\u0000\u03e8\u03ea\u0001\u0000"+
"\u0000\u0000\u03e9\u03e7\u0001\u0000\u0000\u0000\u03ea\u03eb\u0005\n\u0000"+
"\u0000\u03ebi\u0001\u0000\u0000\u0000\u03ec\u03ed\u0005*\u0000\u0000\u03ed"+
"\u03f1\u0005\t\u0000\u0000\u03ee\u03f0\u0005\u0004\u0000\u0000\u03ef\u03ee"+
"\u0001\u0000\u0000\u0000\u03f0\u03f3\u0001\u0000\u0000\u0000\u03f1\u03ef"+
"\u0001\u0000\u0000\u0000\u03f1\u03f2\u0001\u0000\u0000\u0000\u03f2\u03f4"+
"\u0001\u0000\u0000\u0000\u03f3\u03f1\u0001\u0000\u0000\u0000\u03f4\u03f8"+
"\u00034\u001a\u0000\u03f5\u03f7\u0005\u0004\u0000\u0000\u03f6\u03f5\u0001"+
"\u0000\u0000\u0000\u03f7\u03fa\u0001\u0000\u0000\u0000\u03f8\u03f6\u0001"+
"\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000\u03f9\u03fb\u0001"+
"\u0000\u0000\u0000\u03fa\u03f8\u0001\u0000\u0000\u0000\u03fb\u03fc\u0005"+
"\n\u0000\u0000\u03fck\u0001\u0000\u0000\u0000\u03fd\u03fe\u0005+\u0000"+
"\u0000\u03fe\u0402\u0005\t\u0000\u0000\u03ff\u0401\u0005\u0004\u0000\u0000"+
"\u0400\u03ff\u0001\u0000\u0000\u0000\u0401\u0404\u0001\u0000\u0000\u0000"+
"\u0402\u0400\u0001\u0000\u0000\u0000\u0402\u0403\u0001\u0000\u0000\u0000"+
"\u0403\u0405\u0001\u0000\u0000\u0000\u0404\u0402\u0001\u0000\u0000\u0000"+
"\u0405\u0409\u00034\u001a\u0000\u0406\u0408\u0005\u0004\u0000\u0000\u0407"+
"\u0406\u0001\u0000\u0000\u0000\u0408\u040b\u0001\u0000\u0000\u0000\u0409"+
"\u0407\u0001\u0000\u0000\u0000\u0409\u040a\u0001\u0000\u0000\u0000\u040a"+
"\u040c\u0001\u0000\u0000\u0000\u040b\u0409\u0001\u0000\u0000\u0000\u040c"+
"\u040d\u0005\n\u0000\u0000\u040dm\u0001\u0000\u0000\u0000\u040e\u040f"+
"\u0005,\u0000\u0000\u040f\u0413\u0005\t\u0000\u0000\u0410\u0412\u0005"+
"\u0004\u0000\u0000\u0411\u0410\u0001\u0000\u0000\u0000\u0412\u0415\u0001"+
"\u0000\u0000\u0000\u0413\u0411\u0001\u0000\u0000\u0000\u0413\u0414\u0001"+
"\u0000\u0000\u0000\u0414\u0416\u0001\u0000\u0000\u0000\u0415\u0413\u0001"+
"\u0000\u0000\u0000\u0416\u041a\u00034\u001a\u0000\u0417\u0419\u0005\u0004"+
"\u0000\u0000\u0418\u0417\u0001\u0000\u0000\u0000\u0419\u041c\u0001\u0000"+
"\u0000\u0000\u041a\u0418\u0001\u0000\u0000\u0000\u041a\u041b\u0001\u0000"+
"\u0000\u0000\u041b\u041d\u0001\u0000\u0000\u0000\u041c\u041a\u0001\u0000"+
"\u0000\u0000\u041d\u041e\u0005\n\u0000\u0000\u041eo\u0001\u0000\u0000"+
"\u0000\u041f\u0420\u0005-\u0000\u0000\u0420\u0424\u0005\t\u0000\u0000"+
"\u0421\u0423\u0005\u0004\u0000\u0000\u0422\u0421\u0001\u0000\u0000\u0000"+
"\u0423\u0426\u0001\u0000\u0000\u0000\u0424\u0422\u0001\u0000\u0000\u0000"+
"\u0424\u0425\u0001\u0000\u0000\u0000\u0425\u0427\u0001\u0000\u0000\u0000"+
"\u0426\u0424\u0001\u0000\u0000\u0000\u0427\u042b\u00034\u001a\u0000\u0428"+
"\u042a\u0005\u0004\u0000\u0000\u0429\u0428\u0001\u0000\u0000\u0000\u042a"+
"\u042d\u0001\u0000\u0000\u0000\u042b\u0429\u0001\u0000\u0000\u0000\u042b"+
"\u042c\u0001\u0000\u0000\u0000\u042c\u042e\u0001\u0000\u0000\u0000\u042d"+
"\u042b\u0001\u0000\u0000\u0000\u042e\u042f\u0005\n\u0000\u0000\u042fq"+
"\u0001\u0000\u0000\u0000\u0430\u0431\u0005.\u0000\u0000\u0431\u0435\u0005"+
"\t\u0000\u0000\u0432\u0434\u0005\u0004\u0000\u0000\u0433\u0432\u0001\u0000"+
"\u0000\u0000\u0434\u0437\u0001\u0000\u0000\u0000\u0435\u0433\u0001\u0000"+
"\u0000\u0000\u0435\u0436\u0001\u0000\u0000\u0000\u0436\u0438\u0001\u0000"+
"\u0000\u0000\u0437\u0435\u0001\u0000\u0000\u0000\u0438\u043c\u00034\u001a"+
"\u0000\u0439\u043b\u0005\u0004\u0000\u0000\u043a\u0439\u0001\u0000\u0000"+
"\u0000\u043b\u043e\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000\u0000"+
"\u0000\u043c\u043d\u0001\u0000\u0000\u0000\u043d\u043f\u0001\u0000\u0000"+
"\u0000\u043e\u043c\u0001\u0000\u0000\u0000\u043f\u0440\u0005\n\u0000\u0000"+
"\u0440s\u0001\u0000\u0000\u0000\u0441\u0442\u0005/\u0000\u0000\u0442\u0446"+
"\u0005\t\u0000\u0000\u0443\u0445\u0005\u0004\u0000\u0000\u0444\u0443\u0001"+
"\u0000\u0000\u0000\u0445\u0448\u0001\u0000\u0000\u0000\u0446\u0444\u0001"+
"\u0000\u0000\u0000\u0446\u0447\u0001\u0000\u0000\u0000\u0447\u0449\u0001"+
"\u0000\u0000\u0000\u0448\u0446\u0001\u0000\u0000\u0000\u0449\u044d\u0003"+
"4\u001a\u0000\u044a\u044c\u0005\u0004\u0000\u0000\u044b\u044a\u0001\u0000"+
"\u0000\u0000\u044c\u044f\u0001\u0000\u0000\u0000\u044d\u044b\u0001\u0000"+
"\u0000\u0000\u044d\u044e\u0001\u0000\u0000\u0000\u044e\u0450\u0001\u0000"+
"\u0000\u0000\u044f\u044d\u0001\u0000\u0000\u0000\u0450\u0451\u0005\n\u0000"+
"\u0000\u0451u\u0001\u0000\u0000\u0000\u0452\u0453\u00051\u0000\u0000\u0453"+
"\u0457\u0005\t\u0000\u0000\u0454\u0456\u0005\u0004\u0000\u0000\u0455\u0454"+
"\u0001\u0000\u0000\u0000\u0456\u0459\u0001\u0000\u0000\u0000\u0457\u0455"+
"\u0001\u0000\u0000\u0000\u0457\u0458\u0001\u0000\u0000\u0000\u0458\u045a"+
"\u0001\u0000\u0000\u0000\u0459\u0457\u0001\u0000\u0000\u0000\u045a\u045e"+
"\u00034\u001a\u0000\u045b\u045d\u0005\u0004\u0000\u0000\u045c\u045b\u0001"+
"\u0000\u0000\u0000\u045d\u0460\u0001\u0000\u0000\u0000\u045e\u045c\u0001"+
"\u0000\u0000\u0000\u045e\u045f\u0001\u0000\u0000\u0000\u045f\u0461\u0001"+
"\u0000\u0000\u0000\u0460\u045e\u0001\u0000\u0000\u0000\u0461\u0462\u0005"+
"\n\u0000\u0000\u0462w\u0001\u0000\u0000\u0000\u0463\u0464\u00050\u0000"+
"\u0000\u0464\u0468\u0005\t\u0000\u0000\u0465\u0467\u0005\u0004\u0000\u0000"+
"\u0466\u0465\u0001\u0000\u0000\u0000\u0467\u046a\u0001\u0000\u0000\u0000"+
"\u0468\u0466\u0001\u0000\u0000\u0000\u0468\u0469\u0001\u0000\u0000\u0000"+
"\u0469\u046b\u0001\u0000\u0000\u0000\u046a\u0468\u0001\u0000\u0000\u0000"+
"\u046b\u046f\u00034\u001a\u0000\u046c\u046e\u0005\u0004\u0000\u0000\u046d"+
"\u046c\u0001\u0000\u0000\u0000\u046e\u0471\u0001\u0000\u0000\u0000\u046f"+
"\u046d\u0001\u0000\u0000\u0000\u046f\u0470\u0001\u0000\u0000\u0000\u0470"+
"\u0472\u0001\u0000\u0000\u0000\u0471\u046f\u0001\u0000\u0000\u0000\u0472"+
"\u0473\u0005\n\u0000\u0000\u0473y\u0001\u0000\u0000\u0000\u0474\u0475"+
"\u00056\u0000\u0000\u0475\u0479\u0005\t\u0000\u0000\u0476\u0478\u0005"+
"\u0004\u0000\u0000\u0477\u0476\u0001\u0000\u0000\u0000\u0478\u047b\u0001"+
"\u0000\u0000\u0000\u0479\u0477\u0001\u0000\u0000\u0000\u0479\u047a\u0001"+
"\u0000\u0000\u0000\u047a\u047c\u0001\u0000\u0000\u0000\u047b\u0479\u0001"+
"\u0000\u0000\u0000\u047c\u0480\u0003 \u0010\u0000\u047d\u047f\u0005\u0004"+
"\u0000\u0000\u047e\u047d\u0001\u0000\u0000\u0000\u047f\u0482\u0001\u0000"+
"\u0000\u0000\u0480\u047e\u0001\u0000\u0000\u0000\u0480\u0481\u0001\u0000"+
"\u0000\u0000\u0481\u0483\u0001\u0000\u0000\u0000\u0482\u0480\u0001\u0000"+
"\u0000\u0000\u0483\u0484\u0005\n\u0000\u0000\u0484{\u0001\u0000\u0000"+
"\u0000\u0485\u0486\u00057\u0000\u0000\u0486\u048a\u0005\t\u0000\u0000"+
"\u0487\u0489\u0005\u0004\u0000\u0000\u0488\u0487\u0001\u0000\u0000\u0000"+
"\u0489\u048c\u0001\u0000\u0000\u0000\u048a\u0488\u0001\u0000\u0000\u0000"+
"\u048a\u048b\u0001\u0000\u0000\u0000\u048b\u048d\u0001\u0000\u0000\u0000"+
"\u048c\u048a\u0001\u0000\u0000\u0000\u048d\u0491\u0003 \u0010\u0000\u048e"+
"\u0490\u0005\u0004\u0000\u0000\u048f\u048e\u0001\u0000\u0000\u0000\u0490"+
"\u0493\u0001\u0000\u0000\u0000\u0491\u048f\u0001\u0000\u0000\u0000\u0491"+
"\u0492\u0001\u0000\u0000\u0000\u0492\u0494\u0001\u0000\u0000\u0000\u0493"+
"\u0491\u0001\u0000\u0000\u0000\u0494\u0495\u0005\n\u0000\u0000\u0495}"+
"\u0001\u0000\u0000\u0000\u0496\u0497\u00058\u0000\u0000\u0497\u049b\u0005"+
"\t\u0000\u0000\u0498\u049a\u0005\u0004\u0000\u0000\u0499\u0498\u0001\u0000"+
"\u0000\u0000\u049a\u049d\u0001\u0000\u0000\u0000\u049b\u0499\u0001\u0000"+
"\u0000\u0000\u049b\u049c\u0001\u0000\u0000\u0000\u049c\u049e\u0001\u0000"+
"\u0000\u0000\u049d\u049b\u0001\u0000\u0000\u0000\u049e\u04a2\u0003 \u0010"+
"\u0000\u049f\u04a1\u0005\u0004\u0000\u0000\u04a0\u049f\u0001\u0000\u0000"+
"\u0000\u04a1\u04a4\u0001\u0000\u0000\u0000\u04a2\u04a0\u0001\u0000\u0000"+
"\u0000\u04a2\u04a3\u0001\u0000\u0000\u0000\u04a3\u04a5\u0001\u0000\u0000"+
"\u0000\u04a4\u04a2\u0001\u0000\u0000\u0000\u04a5\u04a6\u0005\n\u0000\u0000"+
"\u04a6\u007f\u0001\u0000\u0000\u0000\u04a7\u04a8\u00052\u0000\u0000\u04a8"+
"\u04ac\u0005\t\u0000\u0000\u04a9\u04ab\u0005\u0004\u0000\u0000\u04aa\u04a9"+
"\u0001\u0000\u0000\u0000\u04ab\u04ae\u0001\u0000\u0000\u0000\u04ac\u04aa"+
"\u0001\u0000\u0000\u0000\u04ac\u04ad\u0001\u0000\u0000\u0000\u04ad\u04af"+
"\u0001\u0000\u0000\u0000\u04ae\u04ac\u0001\u0000\u0000\u0000\u04af\u04b3"+
"\u00034\u001a\u0000\u04b0\u04b2\u0005\u0004\u0000\u0000\u04b1\u04b0\u0001"+
"\u0000\u0000\u0000\u04b2\u04b5\u0001\u0000\u0000\u0000\u04b3\u04b1\u0001"+
"\u0000\u0000\u0000\u04b3\u04b4\u0001\u0000\u0000\u0000\u04b4\u04b6\u0001"+
"\u0000\u0000\u0000\u04b5\u04b3\u0001\u0000\u0000\u0000\u04b6\u04b7\u0005"+
"\n\u0000\u0000\u04b7\u0081\u0001\u0000\u0000\u0000\u04b8\u04b9\u00059"+
"\u0000\u0000\u04b9\u04bd\u0005\t\u0000\u0000\u04ba\u04bc\u0005\u0004\u0000"+
"\u0000\u04bb\u04ba\u0001\u0000\u0000\u0000\u04bc\u04bf\u0001\u0000\u0000"+
"\u0000\u04bd\u04bb\u0001\u0000\u0000\u0000\u04bd\u04be\u0001\u0000\u0000"+
"\u0000\u04be\u04c0\u0001\u0000\u0000\u0000\u04bf\u04bd\u0001\u0000\u0000"+
"\u0000\u04c0\u04c4\u00036\u001b\u0000\u04c1\u04c3\u0005\u0004\u0000\u0000"+
"\u04c2\u04c1\u0001\u0000\u0000\u0000\u04c3\u04c6\u0001\u0000\u0000\u0000"+
"\u04c4\u04c2\u0001\u0000\u0000\u0000\u04c4\u04c5\u0001\u0000\u0000\u0000"+
"\u04c5\u04c7\u0001\u0000\u0000\u0000\u04c6\u04c4\u0001\u0000\u0000\u0000"+
"\u04c7\u04cb\u0005\u0003\u0000\u0000\u04c8\u04ca\u0005\u0004\u0000\u0000"+
"\u04c9\u04c8\u0001\u0000\u0000\u0000\u04ca\u04cd\u0001\u0000\u0000\u0000"+
"\u04cb\u04c9\u0001\u0000\u0000\u0000\u04cb\u04cc\u0001\u0000\u0000\u0000"+
"\u04cc\u04ce\u0001\u0000\u0000\u0000\u04cd\u04cb\u0001\u0000\u0000\u0000"+
"\u04ce\u04d2\u00036\u001b\u0000\u04cf\u04d1\u0005\u0004\u0000\u0000\u04d0"+
"\u04cf\u0001\u0000\u0000\u0000\u04d1\u04d4\u0001\u0000\u0000\u0000\u04d2"+
"\u04d0\u0001\u0000\u0000\u0000\u04d2\u04d3\u0001\u0000\u0000\u0000\u04d3"+
"\u04d5\u0001\u0000\u0000\u0000\u04d4\u04d2\u0001\u0000\u0000\u0000\u04d5"+
"\u04d6\u0005\n\u0000\u0000\u04d6\u0083\u0001\u0000\u0000\u0000\u04d7\u04d8"+
"\u0005:\u0000\u0000\u04d8\u04dc\u0005\t\u0000\u0000\u04d9\u04db\u0005"+
"\u0004\u0000\u0000\u04da\u04d9\u0001\u0000\u0000\u0000\u04db\u04de\u0001"+
"\u0000\u0000\u0000\u04dc\u04da\u0001\u0000\u0000\u0000\u04dc\u04dd\u0001"+
"\u0000\u0000\u0000\u04dd\u04df\u0001\u0000\u0000\u0000\u04de\u04dc\u0001"+
"\u0000\u0000\u0000\u04df\u04e3\u00036\u001b\u0000\u04e0\u04e2\u0005\u0004"+
"\u0000\u0000\u04e1\u04e0\u0001\u0000\u0000\u0000\u04e2\u04e5\u0001\u0000"+
"\u0000\u0000\u04e3\u04e1\u0001\u0000\u0000\u0000\u04e3\u04e4\u0001\u0000"+
"\u0000\u0000\u04e4\u04e6\u0001\u0000\u0000\u0000\u04e5\u04e3\u0001\u0000"+
"\u0000\u0000\u04e6\u04e7\u0005\n\u0000\u0000\u04e7\u0085\u0001\u0000\u0000"+
"\u0000\u04e8\u04e9\u00053\u0000\u0000\u04e9\u04ed\u0005\t\u0000\u0000"+
"\u04ea\u04ec\u0005\u0004\u0000\u0000\u04eb\u04ea\u0001\u0000\u0000\u0000"+
"\u04ec\u04ef\u0001\u0000\u0000\u0000\u04ed\u04eb\u0001\u0000\u0000\u0000"+
"\u04ed\u04ee\u0001\u0000\u0000\u0000\u04ee\u04f0\u0001\u0000\u0000\u0000"+
"\u04ef\u04ed\u0001\u0000\u0000\u0000\u04f0\u04f1\u0005\n\u0000\u0000\u04f1"+
"\u0087\u0001\u0000\u0000\u0000\u04f2\u04f3\u00054\u0000\u0000\u04f3\u04f7"+
"\u0005\t\u0000\u0000\u04f4\u04f6\u0005\u0004\u0000\u0000\u04f5\u04f4\u0001"+
"\u0000\u0000\u0000\u04f6\u04f9\u0001\u0000\u0000\u0000\u04f7\u04f5\u0001"+
"\u0000\u0000\u0000\u04f7\u04f8\u0001\u0000\u0000\u0000\u04f8\u04fa\u0001"+
"\u0000\u0000\u0000\u04f9\u04f7\u0001\u0000\u0000\u0000\u04fa\u04fb\u0005"+
"\n\u0000\u0000\u04fb\u0089\u0001\u0000\u0000\u0000\u04fc\u04fd\u00055"+
"\u0000\u0000\u04fd\u0501\u0005\t\u0000\u0000\u04fe\u0500\u0005\u0004\u0000"+
"\u0000\u04ff\u04fe\u0001\u0000\u0000\u0000\u0500\u0503\u0001\u0000\u0000"+
"\u0000\u0501\u04ff\u0001\u0000\u0000\u0000\u0501\u0502\u0001\u0000\u0000"+
"\u0000\u0502\u0504\u0001\u0000\u0000\u0000\u0503\u0501\u0001\u0000\u0000"+
"\u0000\u0504\u0505\u0005\n\u0000\u0000\u0505\u008b\u0001\u0000\u0000\u0000"+
"\u0506\u0507\u0005\u0004\u0000\u0000\u0507\u0508\u0005E\u0000\u0000\u0508"+
"\u0509\u0005\u0004\u0000\u0000\u0509\u050a\u0003\u0018\f\u0000\u050a\u008d"+
"\u0001\u0000\u0000\u0000\u050b\u050c\u0005\u0004\u0000\u0000\u050c\u050d"+
"\u0005F\u0000\u0000\u050d\u050e\u0005\u0004\u0000\u0000\u050e\u050f\u0003"+
"\u0018\f\u0000\u050f\u008f\u0001\u0000\u0000\u0000\u0510\u0511\u0005G"+
"\u0000\u0000\u0511\u0512\u0005\u0004\u0000\u0000\u0512\u0513\u0003\u0018"+
"\f\u0000\u0513\u0091\u0001\u0000\u0000\u0000\u0514\u0515\u0005\u0004\u0000"+
"\u0000\u0515\u0516\u0005H\u0000\u0000\u0516\u0517\u0005\u0004\u0000\u0000"+
"\u0517\u0518\u0003\u001c\u000e\u0000\u0518\u0093\u0001\u0000\u0000\u0000"+
"\u0519\u051a\u0005\u0004\u0000\u0000\u051a\u051b\u0005I\u0000\u0000\u051b"+
"\u051c\u0005\u0004\u0000\u0000\u051c\u051d\u0003\u001c\u000e\u0000\u051d"+
"\u0095\u0001\u0000\u0000\u0000\u051e\u051f\u0005\u0004\u0000\u0000\u051f"+
"\u0520\u0005J\u0000\u0000\u0520\u0521\u0005\u0004\u0000\u0000\u0521\u0522"+
"\u0003\u001c\u000e\u0000\u0522\u0097\u0001\u0000\u0000\u0000\u0523\u0524"+
"\u0005\u0004\u0000\u0000\u0524\u0525\u0005K\u0000\u0000\u0525\u0526\u0005"+
"\u0004\u0000\u0000\u0526\u0527\u0003\u001c\u000e\u0000\u0527\u0099\u0001"+
"\u0000\u0000\u0000\u0528\u0529\u0005\u0004\u0000\u0000\u0529\u052a\u0005"+
"L\u0000\u0000\u052a\u052b\u0005\u0004\u0000\u0000\u052b\u052c\u0003\u001c"+
"\u000e\u0000\u052c\u009b\u0001\u0000\u0000\u0000\u052d\u052e\u0005\u0004"+
"\u0000\u0000\u052e\u052f\u0005M\u0000\u0000\u052f\u0530\u0005\u0004\u0000"+
"\u0000\u0530\u0531\u0003\u001c\u000e\u0000\u0531\u009d\u0001\u0000\u0000"+
"\u0000\u0532\u0533\u0005\u0004\u0000\u0000\u0533\u0534\u0005N\u0000\u0000"+
"\u0534\u0535\u0005\u0004\u0000\u0000\u0535\u0536\u0003 \u0010\u0000\u0536"+
"\u009f\u0001\u0000\u0000\u0000\u0537\u0538\u0005\u0004\u0000\u0000\u0538"+
"\u0539\u0005O\u0000\u0000\u0539\u053a\u0005\u0004\u0000\u0000\u053a\u053b"+
"\u0003 \u0010\u0000\u053b\u00a1\u0001\u0000\u0000\u0000\u053c\u053d\u0005"+
"\u0004\u0000\u0000\u053d\u053e\u0005P\u0000\u0000\u053e\u053f\u0005\u0004"+
"\u0000\u0000\u053f\u0540\u0003 \u0010\u0000\u0540\u00a3\u0001\u0000\u0000"+
"\u0000\u0541\u0542\u0005\u0004\u0000\u0000\u0542\u0543\u0005Q\u0000\u0000"+
"\u0543\u0544\u0005\u0004\u0000\u0000\u0544\u0545\u0003 \u0010\u0000\u0545"+
"\u00a5\u0001\u0000\u0000\u0000\u0546\u0547\u0005\u0004\u0000\u0000\u0547"+
"\u0548\u0005R\u0000\u0000\u0548\u0549\u0005\u0004\u0000\u0000\u0549\u054a"+
"\u0003 \u0010\u0000\u054a\u00a7\u0001\u0000\u0000\u0000\u054b\u054f\u0005"+
"\u0006\u0000\u0000\u054c\u054e\u0005\u0004\u0000\u0000\u054d\u054c\u0001"+
"\u0000\u0000\u0000\u054e\u0551\u0001\u0000\u0000\u0000\u054f\u054d\u0001"+
"\u0000\u0000\u0000\u054f\u0550\u0001\u0000\u0000\u0000\u0550\u0552\u0001"+
"\u0000\u0000\u0000\u0551\u054f\u0001\u0000\u0000\u0000\u0552\u0553\u0003"+
" \u0010\u0000\u0553\u00a9\u0001\u0000\u0000\u0000\u0554\u0557\u0003\u00ac"+
"V\u0000\u0555\u0557\u0005Y\u0000\u0000\u0556\u0554\u0001\u0000\u0000\u0000"+
"\u0556\u0555\u0001\u0000\u0000\u0000\u0557\u00ab\u0001\u0000\u0000\u0000"+
"\u0558\u0559\u0007\u0003\u0000\u0000\u0559\u00ad\u0001\u0000\u0000\u0000"+
"\u055a\u055b\u0007\u0004\u0000\u0000\u055b\u00af\u0001\u0000\u0000\u0000"+
"\u055c\u055d\u0003\u00f8|\u0000\u055d\u055e\u0003\u00b2Y\u0000\u055e\u055f"+
"\u0005\u0007\u0000\u0000\u055f\u00b1\u0001\u0000\u0000\u0000\u0560\u0562"+
"\u0003\u00d6k\u0000\u0561\u0560\u0001\u0000\u0000\u0000\u0561\u0562\u0001"+
"\u0000\u0000\u0000\u0562\u0563\u0001\u0000\u0000\u0000\u0563\u0564\u0003"+
"\u00b4Z\u0000\u0564\u00b3\u0001\u0000\u0000\u0000\u0565\u0569\u0005a\u0000"+
"\u0000\u0566\u0568\u0005\u0004\u0000\u0000\u0567\u0566\u0001\u0000\u0000"+
"\u0000\u0568\u056b\u0001\u0000\u0000\u0000\u0569\u0567\u0001\u0000\u0000"+
"\u0000\u0569\u056a\u0001\u0000\u0000\u0000\u056a\u056c\u0001\u0000\u0000"+
"\u0000\u056b\u0569\u0001\u0000\u0000\u0000\u056c\u0571\u0003\u00b6[\u0000"+
"\u056d\u056e\u0005\u0003\u0000\u0000\u056e\u0570\u0003\u00b6[\u0000\u056f"+
"\u056d\u0001\u0000\u0000\u0000\u0570\u0573\u0001\u0000\u0000\u0000\u0571"+
"\u056f\u0001\u0000\u0000\u0000\u0571\u0572\u0001\u0000\u0000\u0000\u0572"+
"\u0577\u0001\u0000\u0000\u0000\u0573\u0571\u0001\u0000\u0000\u0000\u0574"+
"\u0576\u0005\u0004\u0000\u0000\u0575\u0574\u0001\u0000\u0000\u0000\u0576"+
"\u0579\u0001\u0000\u0000\u0000\u0577\u0575\u0001\u0000\u0000\u0000\u0577"+
"\u0578\u0001\u0000\u0000\u0000\u0578\u057a\u0001\u0000\u0000\u0000\u0579"+
"\u0577\u0001\u0000\u0000\u0000\u057a\u057b\u0005\n\u0000\u0000\u057b\u00b5"+
"\u0001\u0000\u0000\u0000\u057c\u0584\u0003\u00b4Z\u0000\u057d\u0584\u0003"+
"\u00bc^\u0000\u057e\u0584\u0003\u00cae\u0000\u057f\u0584\u0003\u00c4b"+
"\u0000\u0580\u0584\u0003\u00d0h\u0000\u0581\u0584\u0003\u00d8l\u0000\u0582"+
"\u0584\u0003\u00e4r\u0000\u0583\u057c\u0001\u0000\u0000\u0000\u0583\u057d"+
"\u0001\u0000\u0000\u0000\u0583\u057e\u0001\u0000\u0000\u0000\u0583\u057f"+
"\u0001\u0000\u0000\u0000\u0583\u0580\u0001\u0000\u0000\u0000\u0583\u0581"+
"\u0001\u0000\u0000\u0000\u0583\u0582\u0001\u0000\u0000\u0000\u0584\u00b7"+
"\u0001\u0000\u0000\u0000\u0585\u0586\u0003\u00f8|\u0000\u0586\u0587\u0003"+
"\u00ba]\u0000\u0587\u0588\u0005\u0007\u0000\u0000\u0588\u00b9\u0001\u0000"+
"\u0000\u0000\u0589\u058b\u0003\u00d6k\u0000\u058a\u0589\u0001\u0000\u0000"+
"\u0000\u058a\u058b\u0001\u0000\u0000\u0000\u058b\u058c\u0001\u0000\u0000"+
"\u0000\u058c\u058d\u0003\u00bc^\u0000\u058d\u00bb\u0001\u0000\u0000\u0000"+
"\u058e\u0592\u0005[\u0000\u0000\u058f\u0591\u0005\u0004\u0000\u0000\u0590"+
"\u058f\u0001\u0000\u0000\u0000\u0591\u0594\u0001\u0000\u0000\u0000\u0592"+
"\u0590\u0001\u0000\u0000\u0000\u0592\u0593\u0001\u0000\u0000\u0000\u0593"+
"\u0595\u0001\u0000\u0000\u0000\u0594\u0592\u0001\u0000\u0000\u0000\u0595"+
"\u0599\u0003\u00be_\u0000\u0596\u0598\u0005\u0004\u0000\u0000\u0597\u0596"+
"\u0001\u0000\u0000\u0000\u0598\u059b\u0001\u0000\u0000\u0000\u0599\u0597"+
"\u0001\u0000\u0000\u0000\u0599\u059a\u0001\u0000\u0000\u0000\u059a\u00bd"+
"\u0001\u0000\u0000\u0000\u059b\u0599\u0001\u0000\u0000\u0000\u059c\u059d"+
"\u0005\t\u0000\u0000\u059d\u05a3\u0003\u00dcn\u0000\u059e\u05a0\u0005"+
"\u0003\u0000\u0000\u059f\u05a1\u0005\u0004\u0000\u0000\u05a0\u059f\u0001"+
"\u0000\u0000\u0000\u05a0\u05a1\u0001\u0000\u0000\u0000\u05a1\u05a2\u0001"+
"\u0000\u0000\u0000\u05a2\u05a4\u0003\u00dcn\u0000\u05a3\u059e\u0001\u0000"+
"\u0000\u0000\u05a4\u05a5\u0001\u0000\u0000\u0000\u05a5\u05a3\u0001\u0000"+
"\u0000\u0000\u05a5\u05a6\u0001\u0000\u0000\u0000\u05a6\u05a7\u0001\u0000"+
"\u0000\u0000\u05a7\u05a8\u0005\n\u0000\u0000\u05a8\u00bf\u0001\u0000\u0000"+
"\u0000\u05a9\u05aa\u0003\u00f8|\u0000\u05aa\u05ab\u0003\u00c2a\u0000\u05ab"+
"\u05ac\u0005\u0007\u0000\u0000\u05ac\u00c1\u0001\u0000\u0000\u0000\u05ad"+
"\u05af\u0003\u00d6k\u0000\u05ae\u05ad\u0001\u0000\u0000\u0000\u05ae\u05af"+
"\u0001\u0000\u0000\u0000\u05af\u05b0\u0001\u0000\u0000\u0000\u05b0\u05b1"+
"\u0003\u00c4b\u0000\u05b1\u00c3\u0001\u0000\u0000\u0000\u05b2\u05b6\u0005"+
"Z\u0000\u0000\u05b3\u05b5\u0005\u0004\u0000\u0000\u05b4\u05b3\u0001\u0000"+
"\u0000\u0000\u05b5\u05b8\u0001\u0000\u0000\u0000\u05b6\u05b4\u0001\u0000"+
"\u0000\u0000\u05b6\u05b7\u0001\u0000\u0000\u0000\u05b7\u05c4\u0001\u0000"+
"\u0000\u0000\u05b8\u05b6\u0001\u0000\u0000\u0000\u05b9\u05c1\u0003\u00be"+
"_\u0000\u05ba\u05bc\u0005\u0003\u0000\u0000\u05bb\u05bd\u0005\u0004\u0000"+
"\u0000\u05bc\u05bb\u0001\u0000\u0000\u0000\u05bc\u05bd\u0001\u0000\u0000"+
"\u0000\u05bd\u05be\u0001\u0000\u0000\u0000\u05be\u05c0\u0003\u00be_\u0000"+
"\u05bf\u05ba\u0001\u0000\u0000\u0000\u05c0\u05c3\u0001\u0000\u0000\u0000"+
"\u05c1\u05bf\u0001\u0000\u0000\u0000\u05c1\u05c2\u0001\u0000\u0000\u0000"+
"\u05c2\u05c5\u0001\u0000\u0000\u0000\u05c3\u05c1\u0001\u0000\u0000\u0000"+
"\u05c4\u05b9\u0001\u0000\u0000\u0000\u05c4\u05c5\u0001\u0000\u0000\u0000"+
"\u05c5\u05c9\u0001\u0000\u0000\u0000\u05c6\u05c8\u0005\u0004\u0000\u0000"+
"\u05c7\u05c6\u0001\u0000\u0000\u0000\u05c8\u05cb\u0001\u0000\u0000\u0000"+
"\u05c9\u05c7\u0001\u0000\u0000\u0000\u05c9\u05ca\u0001\u0000\u0000\u0000"+
"\u05ca\u05cc\u0001\u0000\u0000\u0000\u05cb\u05c9\u0001\u0000\u0000\u0000"+
"\u05cc\u05cd\u0005\n\u0000\u0000\u05cd\u00c5\u0001\u0000\u0000\u0000\u05ce"+
"\u05cf\u0003\u00f8|\u0000\u05cf\u05d0\u0003\u00c8d\u0000\u05d0\u05d1\u0005"+
"\u0007\u0000\u0000\u05d1\u00c7\u0001\u0000\u0000\u0000\u05d2\u05d4\u0003"+
"\u00d6k\u0000\u05d3\u05d2\u0001\u0000\u0000\u0000\u05d3\u05d4\u0001\u0000"+
"\u0000\u0000\u05d4\u05d5\u0001\u0000\u0000\u0000\u05d5\u05d6\u0003\u00ca"+
"e\u0000\u05d6\u00c9\u0001\u0000\u0000\u0000\u05d7\u05db\u0005\\\u0000"+
"\u0000\u05d8\u05da\u0005\u0004\u0000\u0000\u05d9\u05d8\u0001\u0000\u0000"+
"\u0000\u05da\u05dd\u0001\u0000\u0000\u0000\u05db\u05d9\u0001\u0000\u0000"+
"\u0000\u05db\u05dc\u0001\u0000\u0000\u0000\u05dc\u05e9\u0001\u0000\u0000"+
"\u0000\u05dd\u05db\u0001\u0000\u0000\u0000\u05de\u05e0\u0003\u00dam\u0000"+
"\u05df\u05de\u0001\u0000\u0000\u0000\u05e0\u05e3\u0001\u0000\u0000\u0000"+
"\u05e1\u05df\u0001\u0000\u0000\u0000\u05e1\u05e2\u0001\u0000\u0000\u0000"+
"\u05e2\u05e4\u0001\u0000\u0000\u0000\u05e3\u05e1\u0001\u0000\u0000\u0000"+
"\u05e4\u05e6\u0005\u0003\u0000\u0000\u05e5\u05e7\u0005\u0004\u0000\u0000"+
"\u05e6\u05e5\u0001\u0000\u0000\u0000\u05e6\u05e7\u0001\u0000\u0000\u0000"+
"\u05e7\u05e8\u0001\u0000\u0000\u0000\u05e8\u05ea\u0003\u00dam\u0000\u05e9"+
"\u05e1\u0001\u0000\u0000\u0000\u05e9\u05ea\u0001\u0000\u0000\u0000\u05ea"+
"\u05ee\u0001\u0000\u0000\u0000\u05eb\u05ed\u0005\u0004\u0000\u0000\u05ec"+
"\u05eb\u0001\u0000\u0000\u0000\u05ed\u05f0\u0001\u0000\u0000\u0000\u05ee"+
"\u05ec\u0001\u0000\u0000\u0000\u05ee\u05ef\u0001\u0000\u0000\u0000\u05ef"+
"\u05f1\u0001\u0000\u0000\u0000\u05f0\u05ee\u0001\u0000\u0000\u0000\u05f1"+
"\u05f2\u0005\n\u0000\u0000\u05f2\u00cb\u0001\u0000\u0000\u0000\u05f3\u05f4"+
"\u0003\u00f8|\u0000\u05f4\u05f5\u0003\u00ceg\u0000\u05f5\u05f6\u0005\u0007"+
"\u0000\u0000\u05f6\u00cd\u0001\u0000\u0000\u0000\u05f7\u05f9\u0003\u00d6"+
"k\u0000\u05f8\u05f7\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000"+
"\u0000\u05f9\u05fa\u0001\u0000\u0000\u0000\u05fa\u05fb\u0003\u00d0h\u0000"+
"\u05fb\u00cf\u0001\u0000\u0000\u0000\u05fc\u0600\u0005]\u0000\u0000\u05fd"+
"\u05ff\u0005\u0004\u0000\u0000\u05fe\u05fd\u0001\u0000\u0000\u0000\u05ff"+
"\u0602\u0001\u0000\u0000\u0000\u0600\u05fe\u0001\u0000\u0000\u0000\u0600"+
"\u0601\u0001\u0000\u0000\u0000\u0601\u060e\u0001\u0000\u0000\u0000\u0602"+
"\u0600\u0001\u0000\u0000\u0000\u0603\u060b\u0003\u00e6s\u0000\u0604\u0606"+
"\u0005\u0003\u0000\u0000\u0605\u0607\u0005\u0004\u0000\u0000\u0606\u0605"+
"\u0001\u0000\u0000\u0000\u0606\u0607\u0001\u0000\u0000\u0000\u0607\u0608"+
"\u0001\u0000\u0000\u0000\u0608\u060a\u0003\u00e6s\u0000\u0609\u0604\u0001"+
"\u0000\u0000\u0000\u060a\u060d\u0001\u0000\u0000\u0000\u060b\u0609\u0001"+
"\u0000\u0000\u0000\u060b\u060c\u0001\u0000\u0000\u0000\u060c\u060f\u0001"+
"\u0000\u0000\u0000\u060d\u060b\u0001\u0000\u0000\u0000\u060e\u0603\u0001"+
"\u0000\u0000\u0000\u060e\u060f\u0001\u0000\u0000\u0000\u060f\u0613\u0001"+
"\u0000\u0000\u0000\u0610\u0612\u0005\u0004\u0000\u0000\u0611\u0610\u0001"+
"\u0000\u0000\u0000\u0612\u0615\u0001\u0000\u0000\u0000\u0613\u0611\u0001"+
"\u0000\u0000\u0000\u0613\u0614\u0001\u0000\u0000\u0000\u0614\u0616\u0001"+
"\u0000\u0000\u0000\u0615\u0613\u0001\u0000\u0000\u0000\u0616\u0617\u0005"+
"\n\u0000\u0000\u0617\u00d1\u0001\u0000\u0000\u0000\u0618\u0619\u0003\u00f8"+
"|\u0000\u0619\u061a\u0003\u00d4j\u0000\u061a\u061b\u0005\u0007\u0000\u0000"+
"\u061b\u00d3\u0001\u0000\u0000\u0000\u061c\u061e\u0003\u00d6k\u0000\u061d"+
"\u061c\u0001\u0000\u0000\u0000\u061d\u061e\u0001\u0000\u0000\u0000\u061e"+
"\u061f\u0001\u0000\u0000\u0000\u061f\u0620\u0003\u00d8l\u0000\u0620\u00d5"+
"\u0001\u0000\u0000\u0000\u0621\u0622\u0005b\u0000\u0000\u0622\u0623\u0005"+
"\u0002\u0000\u0000\u0623\u0624\u0005c\u0000\u0000\u0624\u0625\u0005\u0005"+
"\u0000\u0000\u0625\u00d7\u0001\u0000\u0000\u0000\u0626\u062a\u0005^\u0000"+
"\u0000\u0627\u0629\u0005\u0004\u0000\u0000\u0628\u0627\u0001\u0000\u0000"+
"\u0000\u0629\u062c\u0001\u0000\u0000\u0000\u062a\u0628\u0001\u0000\u0000"+
"\u0000\u062a\u062b\u0001\u0000\u0000\u0000\u062b\u062d\u0001\u0000\u0000"+
"\u0000\u062c\u062a\u0001\u0000\u0000\u0000\u062d\u0631\u0003\u00dam\u0000"+
"\u062e\u0630\u0005\u0004\u0000\u0000\u062f\u062e\u0001\u0000\u0000\u0000"+
"\u0630\u0633\u0001\u0000\u0000\u0000\u0631\u062f\u0001\u0000\u0000\u0000"+
"\u0631\u0632\u0001\u0000\u0000\u0000\u0632\u00d9\u0001\u0000\u0000\u0000"+
"\u0633\u0631\u0001\u0000\u0000\u0000\u0634\u0635\u0005\t\u0000\u0000\u0635"+
"\u0636\u0003\u00dcn\u0000\u0636\u0637\u0005\n\u0000\u0000\u0637\u00db"+
"\u0001\u0000\u0000\u0000\u0638\u0639\u0003\u00deo\u0000\u0639\u063a\u0005"+
"\u0004\u0000\u0000\u063a\u063b\u0003\u00deo\u0000\u063b\u00dd\u0001\u0000"+
"\u0000\u0000\u063c\u063e\u0005\u0006\u0000\u0000\u063d\u063c\u0001\u0000"+
"\u0000\u0000\u063d\u063e\u0001\u0000\u0000\u0000\u063e\u0644\u0001\u0000"+
"\u0000\u0000\u063f\u0640\u0003\u00acV\u0000\u0640\u0641\u0005\r\u0000"+
"\u0000\u0641\u0642\u0003\u00acV\u0000\u0642\u0645\u0001\u0000\u0000\u0000"+
"\u0643\u0645\u0003\u00acV\u0000\u0644\u063f\u0001\u0000\u0000\u0000\u0644"+
"\u0643\u0001\u0000\u0000\u0000\u0645\u00df\u0001\u0000\u0000\u0000\u0646"+
"\u0647\u0003\u00f8|\u0000\u0647\u0648\u0003\u00e2q\u0000\u0648\u0649\u0005"+
"\u0007\u0000\u0000\u0649\u00e1\u0001\u0000\u0000\u0000\u064a\u064c\u0003"+
"\u00d6k\u0000\u064b\u064a\u0001\u0000\u0000\u0000\u064b\u064c\u0001\u0000"+
"\u0000\u0000\u064c\u064d\u0001\u0000\u0000\u0000\u064d\u064e\u0003\u00e4"+
"r\u0000\u064e\u00e3\u0001\u0000\u0000\u0000\u064f\u0653\u0005_\u0000\u0000"+
"\u0650\u0652\u0005\u0004\u0000\u0000\u0651\u0650\u0001\u0000\u0000\u0000"+
"\u0652\u0655\u0001\u0000\u0000\u0000\u0653\u0651\u0001\u0000\u0000\u0000"+
"\u0653\u0654\u0001\u0000\u0000\u0000\u0654\u0656\u0001\u0000\u0000\u0000"+
"\u0655\u0653\u0001\u0000\u0000\u0000\u0656\u065a\u0003\u00e6s\u0000\u0657"+
"\u0659\u0005\u0004\u0000\u0000\u0658\u0657\u0001\u0000\u0000\u0000\u0659"+
"\u065c\u0001\u0000\u0000\u0000\u065a\u0658\u0001\u0000\u0000\u0000\u065a"+
"\u065b\u0001\u0000\u0000\u0000\u065b\u00e5\u0001\u0000\u0000\u0000\u065c"+
"\u065a\u0001\u0000\u0000\u0000\u065d\u065e\u0005\t\u0000\u0000\u065e\u0666"+
"\u0003\u00e8t\u0000\u065f\u0661\u0005\u0003\u0000\u0000\u0660\u0662\u0005"+
"\u0004\u0000\u0000\u0661\u0660\u0001\u0000\u0000\u0000\u0661\u0662\u0001"+
"\u0000\u0000\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663\u0665\u0003"+
"\u00e8t\u0000\u0664\u065f\u0001\u0000\u0000\u0000\u0665\u0668\u0001\u0000"+
"\u0000\u0000\u0666\u0664\u0001\u0000\u0000\u0000\u0666\u0667\u0001\u0000"+
"\u0000\u0000\u0667\u0669\u0001\u0000\u0000\u0000\u0668\u0666\u0001\u0000"+
"\u0000\u0000\u0669\u066a\u0005\n\u0000\u0000\u066a\u00e7\u0001\u0000\u0000"+
"\u0000\u066b\u066c\u0005\t\u0000\u0000\u066c\u0674\u0003\u00dcn\u0000"+
"\u066d\u066f\u0005\u0003\u0000\u0000\u066e\u0670\u0005\u0004\u0000\u0000"+
"\u066f\u066e\u0001\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000\u0000"+
"\u0670\u0671\u0001\u0000\u0000\u0000\u0671\u0673\u0003\u00dcn\u0000\u0672"+
"\u066d\u0001\u0000\u0000\u0000\u0673\u0676\u0001\u0000\u0000\u0000\u0674"+
"\u0672\u0001\u0000\u0000\u0000\u0674\u0675\u0001\u0000\u0000\u0000\u0675"+
"\u0677\u0001\u0000\u0000\u0000\u0676\u0674\u0001\u0000\u0000\u0000\u0677"+
"\u0678\u0005\n\u0000\u0000\u0678\u00e9\u0001\u0000\u0000\u0000\u0679\u067a"+
"\u0003\u00fa}\u0000\u067a\u067b\u0003\u00b2Y\u0000\u067b\u067c\u0005\u0007"+
"\u0000\u0000\u067c\u00eb\u0001\u0000\u0000\u0000\u067d\u067e\u0003\u00fa"+
"}\u0000\u067e\u067f\u0003\u00ba]\u0000\u067f\u0680\u0005\u0007\u0000\u0000"+
"\u0680\u00ed\u0001\u0000\u0000\u0000\u0681\u0682\u0003\u00fa}\u0000\u0682"+
"\u0683\u0003\u00c2a\u0000\u0683\u0684\u0005\u0007\u0000\u0000\u0684\u00ef"+
"\u0001\u0000\u0000\u0000\u0685\u0686\u0003\u00fa}\u0000\u0686\u0687\u0003"+
"\u00c8d\u0000\u0687\u0688\u0005\u0007\u0000\u0000\u0688\u00f1\u0001\u0000"+
"\u0000\u0000\u0689\u068a\u0003\u00fa}\u0000\u068a\u068b\u0003\u00ceg\u0000"+
"\u068b\u068c\u0005\u0007\u0000\u0000\u068c\u00f3\u0001\u0000\u0000\u0000"+
"\u068d\u068e\u0003\u00fa}\u0000\u068e\u068f\u0003\u00d4j\u0000\u068f\u0690"+
"\u0005\u0007\u0000\u0000\u0690\u00f5\u0001\u0000\u0000\u0000\u0691\u0692"+
"\u0003\u00fa}\u0000\u0692\u0693\u0003\u00e2q\u0000\u0693\u0694\u0005\u0007"+
"\u0000\u0000\u0694\u00f7\u0001\u0000\u0000\u0000\u0695\u0696\u0005V\u0000"+
"\u0000\u0696\u00f9\u0001\u0000\u0000\u0000\u0697\u0698\u0005W\u0000\u0000"+
"\u0698\u00fb\u0001\u0000\u0000\u0000\u00a7\u00fd\u0103\u010f\u011c\u0122"+
"\u012c\u0131\u013e\u0144\u014a\u015b\u0161\u016f\u0172\u0176\u017c\u0183"+
"\u018e\u0194\u019b\u01a4\u01a7\u01ad\u01b4\u01ba\u01bd\u01c3\u01d3\u01d9"+
"\u01e3\u01f5\u01fb\u020b\u020f\u0214\u0218\u0227\u0230\u0232\u0239\u0240"+
"\u0247\u0252\u0259\u0263\u026a\u0274\u027b\u0285\u028c\u0293\u029a\u02a4"+
"\u02ab\u02b2\u02b9\u02c3\u02ca\u02d1\u02d8\u02e2\u02e9\u02f0\u02f7\u0301"+
"\u0308\u030f\u0316\u031d\u0324\u032e\u0335\u033c\u0343\u034c\u0353\u035a"+
"\u0361\u0383\u038a\u0391\u0398\u039f\u03a6\u03b0\u03b7\u03c1\u03c8\u03cf"+
"\u03d6\u03e0\u03e7\u03f1\u03f8\u0402\u0409\u0413\u041a\u0424\u042b\u0435"+
"\u043c\u0446\u044d\u0457\u045e\u0468\u046f\u0479\u0480\u048a\u0491\u049b"+
"\u04a2\u04ac\u04b3\u04bd\u04c4\u04cb\u04d2\u04dc\u04e3\u04ed\u04f7\u0501"+
"\u054f\u0556\u0561\u0569\u0571\u0577\u0583\u058a\u0592\u0599\u05a0\u05a5"+
"\u05ae\u05b6\u05bc\u05c1\u05c4\u05c9\u05d3\u05db\u05e1\u05e6\u05e9\u05ee"+
"\u05f8\u0600\u0606\u060b\u060e\u0613\u061d\u062a\u0631\u063d\u0644\u064b"+
"\u0653\u065a\u0661\u0666\u066f\u0674";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy