Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
it.uniroma2.art.coda.pearl.parser.antlr4.PearlParser Maven / Gradle / Ivy
// Generated from java-escape by ANTLR 4.11.1
package it.uniroma2.art.coda.pearl.parser.antlr4;
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 PearlParser 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
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38,
T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45,
T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52,
T__52=53, T__53=54, T__54=55, T__55=56, RULE_ID=57, REGEX_SYMBOL=58, WS=59,
NEWLINE=60, COMMENT=61, MULTILINE_COMMENT=62, IRIREF=63, VAR1=64, VAR2=65,
PNAME_NS=66, PNAME_LN=67, BLANK_NODE_LABEL=68, LANGTAGORANNOTATION=69,
AT=70, STRING_LITERAL1=71, STRING_LITERAL2=72, CONDITIONOPERATOR=73, REP_PLC=74,
JAVA_IDENTIFIER=75, INTEGER=76, DOUBLE=77;
public static final int
RULE_pearlUnit = 0, RULE_prologue = 1, RULE_prefixDecl = 2, RULE_annotationsDefinition = 3,
RULE_singleAnnotationDefinition = 4, RULE_metaAnnotation = 5, RULE_singleParamOrListOfNameParam = 6,
RULE_singleParamOrListOfParam = 7, RULE_singleParam = 8, RULE_paramsDefinition = 9,
RULE_paramType = 10, RULE_defaultValue = 11, RULE_baseRule = 12, RULE_standardRule = 13,
RULE_lazyRule = 14, RULE_forRegexRule = 15, RULE_uimaTypeName = 16, RULE_conditionClause = 17,
RULE_conditionDef = 18, RULE_depend = 19, RULE_dependParam = 20, RULE_bindingsClause = 21,
RULE_bindingDef = 22, RULE_ruleId = 23, RULE_nodesClause = 24, RULE_nodeDef = 25,
RULE_annotation = 26, RULE_projectionOperator = 27, RULE_converters = 28,
RULE_individualConverter = 29, RULE_converterAdditionalArguments = 30,
RULE_converterArgumentExpression = 31, RULE_converterPlaceholderArgument = 32,
RULE_converterMapArgument = 33, RULE_mapEntry = 34, RULE_featurePath = 35,
RULE_featurePathElement = 36, RULE_graphClause = 37, RULE_insertClause = 38,
RULE_deleteClause = 39, RULE_javaQualifiedName = 40, RULE_graph = 41,
RULE_graphElement = 42, RULE_optionalGraphElement = 43, RULE_graphTriple = 44,
RULE_graphSubject = 45, RULE_graphPredicate = 46, RULE_graphObject = 47,
RULE_propPath = 48, RULE_pathAlternative = 49, RULE_pathSequence = 50,
RULE_pathElt = 51, RULE_pathEltOrInverse = 52, RULE_pathPrimary = 53,
RULE_pathNegatedPropertySet = 54, RULE_pathOneInPropertySet = 55, RULE_var = 56,
RULE_placeholder = 57, RULE_iri = 58, RULE_literal = 59, RULE_string = 60,
RULE_blankNode = 61, RULE_prefixedName = 62, RULE_abbr = 63, RULE_whereClause = 64,
RULE_regex = 65, RULE_regexPattern = 66, RULE_regexWithOr = 67, RULE_regexSequenceElement = 68,
RULE_regexBaseElementWithSymbol = 69, RULE_regexBaseElement = 70;
private static String[] makeRuleNames() {
return new String[] {
"pearlUnit", "prologue", "prefixDecl", "annotationsDefinition", "singleAnnotationDefinition",
"metaAnnotation", "singleParamOrListOfNameParam", "singleParamOrListOfParam",
"singleParam", "paramsDefinition", "paramType", "defaultValue", "baseRule",
"standardRule", "lazyRule", "forRegexRule", "uimaTypeName", "conditionClause",
"conditionDef", "depend", "dependParam", "bindingsClause", "bindingDef",
"ruleId", "nodesClause", "nodeDef", "annotation", "projectionOperator",
"converters", "individualConverter", "converterAdditionalArguments",
"converterArgumentExpression", "converterPlaceholderArgument", "converterMapArgument",
"mapEntry", "featurePath", "featurePathElement", "graphClause", "insertClause",
"deleteClause", "javaQualifiedName", "graph", "graphElement", "optionalGraphElement",
"graphTriple", "graphSubject", "graphPredicate", "graphObject", "propPath",
"pathAlternative", "pathSequence", "pathElt", "pathEltOrInverse", "pathPrimary",
"pathNegatedPropertySet", "pathOneInPropertySet", "var", "placeholder",
"iri", "literal", "string", "blankNode", "prefixedName", "abbr", "whereClause",
"regex", "regexPattern", "regexWithOr", "regexSequenceElement", "regexBaseElementWithSymbol",
"regexBaseElement"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'prefix'", "'PREFIX'", "'Annotation'", "'ANNOTATION'", "'{'",
"'}'", "'('", "')'", "'='", "','", "'default'", "';'", "'[]'", "'rule'",
"'RULE'", "'dependsOn'", "'DEPENDSON'", "'dependson'", "'lazy'", "'forRegex'",
"'forregex'", "'FORREGEX'", "'conditions'", "'CONDITIONS'", "'['", "']'",
"'.'", "'as'", "'AS'", "'bindings'", "'BINDINGS'", "'nodes'", "'NODES'",
"'uri'", "'literal'", "'^^'", "'/'", "'graph'", "'GRAPH'", "'insert'",
"'INSERT'", "'delete'", "'DELETE'", "'optional'", "'OPTIONAL'", "'|'",
"'^'", "'a'", "'!'", "'..'", "'A'", "'where'", "'WHERE'", "'regex'",
"'REGEX'", "'->'", null, null, null, "'\\n'", null, null, null, null,
null, null, null, null, null, "'@'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, "RULE_ID", "REGEX_SYMBOL",
"WS", "NEWLINE", "COMMENT", "MULTILINE_COMMENT", "IRIREF", "VAR1", "VAR2",
"PNAME_NS", "PNAME_LN", "BLANK_NODE_LABEL", "LANGTAGORANNOTATION", "AT",
"STRING_LITERAL1", "STRING_LITERAL2", "CONDITIONOPERATOR", "REP_PLC",
"JAVA_IDENTIFIER", "INTEGER", "DOUBLE"
};
}
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 PearlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class PearlUnitContext extends ParserRuleContext {
public PrologueContext prologue() {
return getRuleContext(PrologueContext.class,0);
}
public AnnotationsDefinitionContext annotationsDefinition() {
return getRuleContext(AnnotationsDefinitionContext.class,0);
}
public List baseRule() {
return getRuleContexts(BaseRuleContext.class);
}
public BaseRuleContext baseRule(int i) {
return getRuleContext(BaseRuleContext.class,i);
}
public List regex() {
return getRuleContexts(RegexContext.class);
}
public RegexContext regex(int i) {
return getRuleContext(RegexContext.class,i);
}
public PearlUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pearlUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPearlUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPearlUnit(this);
}
}
public final PearlUnitContext pearlUnit() throws RecognitionException {
PearlUnitContext _localctx = new PearlUnitContext(_ctx, getState());
enterRule(_localctx, 0, RULE_pearlUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(142);
prologue();
setState(144);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(143);
annotationsDefinition();
}
break;
}
setState(150);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la - 14)) & ~0x3f) == 0 && ((1L << (_la - 14)) & 36032095553847779L) != 0) {
{
setState(148);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__13:
case T__14:
case T__18:
case T__19:
case T__20:
case T__21:
case LANGTAGORANNOTATION:
{
setState(146);
baseRule();
}
break;
case T__53:
case T__54:
{
setState(147);
regex();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(152);
_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 PrologueContext extends ParserRuleContext {
public List prefixDecl() {
return getRuleContexts(PrefixDeclContext.class);
}
public PrefixDeclContext prefixDecl(int i) {
return getRuleContext(PrefixDeclContext.class,i);
}
public PrologueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prologue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPrologue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPrologue(this);
}
}
public final PrologueContext prologue() throws RecognitionException {
PrologueContext _localctx = new PrologueContext(_ctx, getState());
enterRule(_localctx, 2, RULE_prologue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(156);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0 || _la==T__1) {
{
{
setState(153);
prefixDecl();
}
}
setState(158);
_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 PrefixDeclContext extends ParserRuleContext {
public TerminalNode PNAME_NS() { return getToken(PearlParser.PNAME_NS, 0); }
public TerminalNode IRIREF() { return getToken(PearlParser.IRIREF, 0); }
public PrefixDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPrefixDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPrefixDecl(this);
}
}
public final PrefixDeclContext prefixDecl() throws RecognitionException {
PrefixDeclContext _localctx = new PrefixDeclContext(_ctx, getState());
enterRule(_localctx, 4, RULE_prefixDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(159);
_la = _input.LA(1);
if ( !(_la==T__0 || _la==T__1) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(160);
match(PNAME_NS);
setState(161);
match(IRIREF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnotationsDefinitionContext extends ParserRuleContext {
public List singleAnnotationDefinition() {
return getRuleContexts(SingleAnnotationDefinitionContext.class);
}
public SingleAnnotationDefinitionContext singleAnnotationDefinition(int i) {
return getRuleContext(SingleAnnotationDefinitionContext.class,i);
}
public AnnotationsDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationsDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterAnnotationsDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitAnnotationsDefinition(this);
}
}
public final AnnotationsDefinitionContext annotationsDefinition() throws RecognitionException {
AnnotationsDefinitionContext _localctx = new AnnotationsDefinitionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_annotationsDefinition);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(164);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(163);
singleAnnotationDefinition();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(166);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SingleAnnotationDefinitionContext extends ParserRuleContext {
public Token annotationName;
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public List metaAnnotation() {
return getRuleContexts(MetaAnnotationContext.class);
}
public MetaAnnotationContext metaAnnotation(int i) {
return getRuleContext(MetaAnnotationContext.class,i);
}
public List paramsDefinition() {
return getRuleContexts(ParamsDefinitionContext.class);
}
public ParamsDefinitionContext paramsDefinition(int i) {
return getRuleContext(ParamsDefinitionContext.class,i);
}
public SingleAnnotationDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleAnnotationDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterSingleAnnotationDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitSingleAnnotationDefinition(this);
}
}
public final SingleAnnotationDefinitionContext singleAnnotationDefinition() throws RecognitionException {
SingleAnnotationDefinitionContext _localctx = new SingleAnnotationDefinitionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_singleAnnotationDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(171);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LANGTAGORANNOTATION) {
{
{
setState(168);
metaAnnotation();
}
}
setState(173);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(174);
_la = _input.LA(1);
if ( !(_la==T__2 || _la==T__3) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(175);
((SingleAnnotationDefinitionContext)_localctx).annotationName = match(JAVA_IDENTIFIER);
setState(184);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4) {
{
setState(176);
match(T__4);
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==JAVA_IDENTIFIER) {
{
{
setState(177);
paramsDefinition();
}
}
setState(182);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(183);
match(T__5);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MetaAnnotationContext extends ParserRuleContext {
public Token annotationName;
public TerminalNode LANGTAGORANNOTATION() { return getToken(PearlParser.LANGTAGORANNOTATION, 0); }
public SingleParamOrListOfNameParamContext singleParamOrListOfNameParam() {
return getRuleContext(SingleParamOrListOfNameParamContext.class,0);
}
public MetaAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metaAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterMetaAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitMetaAnnotation(this);
}
}
public final MetaAnnotationContext metaAnnotation() throws RecognitionException {
MetaAnnotationContext _localctx = new MetaAnnotationContext(_ctx, getState());
enterRule(_localctx, 10, RULE_metaAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(186);
((MetaAnnotationContext)_localctx).annotationName = match(LANGTAGORANNOTATION);
setState(191);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(187);
match(T__6);
setState(188);
singleParamOrListOfNameParam();
setState(189);
match(T__7);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SingleParamOrListOfNameParamContext extends ParserRuleContext {
public SingleParamOrListOfParamContext singleP;
public Token JAVA_IDENTIFIER;
public List names = new ArrayList();
public SingleParamOrListOfParamContext singleParamOrListOfParam;
public List params = new ArrayList();
public List singleParamOrListOfParam() {
return getRuleContexts(SingleParamOrListOfParamContext.class);
}
public SingleParamOrListOfParamContext singleParamOrListOfParam(int i) {
return getRuleContext(SingleParamOrListOfParamContext.class,i);
}
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public SingleParamOrListOfNameParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleParamOrListOfNameParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterSingleParamOrListOfNameParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitSingleParamOrListOfNameParam(this);
}
}
public final SingleParamOrListOfNameParamContext singleParamOrListOfNameParam() throws RecognitionException {
SingleParamOrListOfNameParamContext _localctx = new SingleParamOrListOfNameParamContext(_ctx, getState());
enterRule(_localctx, 12, RULE_singleParamOrListOfNameParam);
int _la;
try {
setState(206);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(193);
((SingleParamOrListOfNameParamContext)_localctx).singleP = singleParamOrListOfParam();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(194);
((SingleParamOrListOfNameParamContext)_localctx).JAVA_IDENTIFIER = match(JAVA_IDENTIFIER);
((SingleParamOrListOfNameParamContext)_localctx).names.add(((SingleParamOrListOfNameParamContext)_localctx).JAVA_IDENTIFIER);
setState(195);
match(T__8);
setState(196);
((SingleParamOrListOfNameParamContext)_localctx).singleParamOrListOfParam = singleParamOrListOfParam();
((SingleParamOrListOfNameParamContext)_localctx).params.add(((SingleParamOrListOfNameParamContext)_localctx).singleParamOrListOfParam);
setState(203);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(197);
match(T__9);
setState(198);
((SingleParamOrListOfNameParamContext)_localctx).JAVA_IDENTIFIER = match(JAVA_IDENTIFIER);
((SingleParamOrListOfNameParamContext)_localctx).names.add(((SingleParamOrListOfNameParamContext)_localctx).JAVA_IDENTIFIER);
setState(199);
match(T__8);
setState(200);
((SingleParamOrListOfNameParamContext)_localctx).singleParamOrListOfParam = singleParamOrListOfParam();
((SingleParamOrListOfNameParamContext)_localctx).params.add(((SingleParamOrListOfNameParamContext)_localctx).singleParamOrListOfParam);
}
}
setState(205);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SingleParamOrListOfParamContext extends ParserRuleContext {
public SingleParamContext value;
public SingleParamContext singleParam;
public List param = new ArrayList();
public List singleParam() {
return getRuleContexts(SingleParamContext.class);
}
public SingleParamContext singleParam(int i) {
return getRuleContext(SingleParamContext.class,i);
}
public SingleParamOrListOfParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleParamOrListOfParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterSingleParamOrListOfParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitSingleParamOrListOfParam(this);
}
}
public final SingleParamOrListOfParamContext singleParamOrListOfParam() throws RecognitionException {
SingleParamOrListOfParamContext _localctx = new SingleParamOrListOfParamContext(_ctx, getState());
enterRule(_localctx, 14, RULE_singleParamOrListOfParam);
int _la;
try {
setState(220);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case VAR2:
case PNAME_NS:
case PNAME_LN:
case STRING_LITERAL1:
case STRING_LITERAL2:
case JAVA_IDENTIFIER:
case INTEGER:
case DOUBLE:
enterOuterAlt(_localctx, 1);
{
setState(208);
((SingleParamOrListOfParamContext)_localctx).value = singleParam();
}
break;
case T__4:
enterOuterAlt(_localctx, 2);
{
setState(209);
match(T__4);
setState(210);
((SingleParamOrListOfParamContext)_localctx).singleParam = singleParam();
((SingleParamOrListOfParamContext)_localctx).param.add(((SingleParamOrListOfParamContext)_localctx).singleParam);
setState(215);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(211);
match(T__9);
setState(212);
((SingleParamOrListOfParamContext)_localctx).singleParam = singleParam();
((SingleParamOrListOfParamContext)_localctx).param.add(((SingleParamOrListOfParamContext)_localctx).singleParam);
}
}
setState(217);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(218);
match(T__5);
}
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 SingleParamContext extends ParserRuleContext {
public Token valueStr;
public PlaceholderContext plch;
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public TerminalNode INTEGER() { return getToken(PearlParser.INTEGER, 0); }
public TerminalNode DOUBLE() { return getToken(PearlParser.DOUBLE, 0); }
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public SingleParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterSingleParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitSingleParam(this);
}
}
public final SingleParamContext singleParam() throws RecognitionException {
SingleParamContext _localctx = new SingleParamContext(_ctx, getState());
enterRule(_localctx, 16, RULE_singleParam);
try {
setState(228);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JAVA_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(222);
((SingleParamContext)_localctx).valueStr = match(JAVA_IDENTIFIER);
}
break;
case INTEGER:
enterOuterAlt(_localctx, 2);
{
setState(223);
match(INTEGER);
}
break;
case DOUBLE:
enterOuterAlt(_localctx, 3);
{
setState(224);
match(DOUBLE);
}
break;
case VAR2:
enterOuterAlt(_localctx, 4);
{
setState(225);
((SingleParamContext)_localctx).plch = placeholder();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 5);
{
setState(226);
iri();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
enterOuterAlt(_localctx, 6);
{
setState(227);
literal();
}
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 ParamsDefinitionContext extends ParserRuleContext {
public Token paramName;
public ParamTypeContext paramType() {
return getRuleContext(ParamTypeContext.class,0);
}
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class,0);
}
public ParamsDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_paramsDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterParamsDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitParamsDefinition(this);
}
}
public final ParamsDefinitionContext paramsDefinition() throws RecognitionException {
ParamsDefinitionContext _localctx = new ParamsDefinitionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_paramsDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(230);
paramType();
setState(231);
((ParamsDefinitionContext)_localctx).paramName = match(JAVA_IDENTIFIER);
setState(232);
match(T__6);
setState(233);
match(T__7);
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(234);
match(T__10);
setState(235);
defaultValue();
}
}
setState(238);
match(T__11);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParamTypeContext extends ParserRuleContext {
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public ParamTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_paramType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterParamType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitParamType(this);
}
}
public final ParamTypeContext paramType() throws RecognitionException {
ParamTypeContext _localctx = new ParamTypeContext(_ctx, getState());
enterRule(_localctx, 20, RULE_paramType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(240);
match(JAVA_IDENTIFIER);
setState(242);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__12) {
{
setState(241);
match(T__12);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DefaultValueContext extends ParserRuleContext {
public Token valueStr;
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public TerminalNode INTEGER() { return getToken(PearlParser.INTEGER, 0); }
public TerminalNode DOUBLE() { return getToken(PearlParser.DOUBLE, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitDefaultValue(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 22, RULE_defaultValue);
try {
setState(249);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JAVA_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(244);
((DefaultValueContext)_localctx).valueStr = match(JAVA_IDENTIFIER);
}
break;
case INTEGER:
enterOuterAlt(_localctx, 2);
{
setState(245);
match(INTEGER);
}
break;
case DOUBLE:
enterOuterAlt(_localctx, 3);
{
setState(246);
match(DOUBLE);
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 4);
{
setState(247);
iri();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
enterOuterAlt(_localctx, 5);
{
setState(248);
literal();
}
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 BaseRuleContext extends ParserRuleContext {
public StandardRuleContext standardRule() {
return getRuleContext(StandardRuleContext.class,0);
}
public LazyRuleContext lazyRule() {
return getRuleContext(LazyRuleContext.class,0);
}
public ForRegexRuleContext forRegexRule() {
return getRuleContext(ForRegexRuleContext.class,0);
}
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public BaseRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_baseRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterBaseRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitBaseRule(this);
}
}
public final BaseRuleContext baseRule() throws RecognitionException {
BaseRuleContext _localctx = new BaseRuleContext(_ctx, getState());
enterRule(_localctx, 24, RULE_baseRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(254);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LANGTAGORANNOTATION) {
{
{
setState(251);
annotation();
}
}
setState(256);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(260);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__13:
case T__14:
{
setState(257);
standardRule();
}
break;
case T__18:
{
setState(258);
lazyRule();
}
break;
case T__19:
case T__20:
case T__21:
{
setState(259);
forRegexRule();
}
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 StandardRuleContext extends ParserRuleContext {
public UimaTypeNameContext uimaTypeName() {
return getRuleContext(UimaTypeNameContext.class,0);
}
public RuleIdContext ruleId() {
return getRuleContext(RuleIdContext.class,0);
}
public List depend() {
return getRuleContexts(DependContext.class);
}
public DependContext depend(int i) {
return getRuleContext(DependContext.class,i);
}
public ConditionClauseContext conditionClause() {
return getRuleContext(ConditionClauseContext.class,0);
}
public BindingsClauseContext bindingsClause() {
return getRuleContext(BindingsClauseContext.class,0);
}
public NodesClauseContext nodesClause() {
return getRuleContext(NodesClauseContext.class,0);
}
public InsertClauseContext insertClause() {
return getRuleContext(InsertClauseContext.class,0);
}
public GraphClauseContext graphClause() {
return getRuleContext(GraphClauseContext.class,0);
}
public DeleteClauseContext deleteClause() {
return getRuleContext(DeleteClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public StandardRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standardRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterStandardRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitStandardRule(this);
}
}
public final StandardRuleContext standardRule() throws RecognitionException {
StandardRuleContext _localctx = new StandardRuleContext(_ctx, getState());
enterRule(_localctx, 26, RULE_standardRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(262);
_la = _input.LA(1);
if ( !(_la==T__13 || _la==T__14) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(263);
uimaTypeName();
setState(264);
ruleId();
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
if (((_la) & ~0x3f) == 0 && ((1L << _la) & 458752L) != 0) {
{
setState(265);
_la = _input.LA(1);
if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 458752L) != 0) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(266);
depend();
setState(271);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(267);
match(T__9);
setState(268);
depend();
}
}
setState(273);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(276);
match(T__4);
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__22 || _la==T__23) {
{
setState(277);
conditionClause();
}
}
setState(281);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__29 || _la==T__30) {
{
setState(280);
bindingsClause();
}
}
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__31 || _la==T__32) {
{
setState(283);
nodesClause();
}
}
setState(288);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__39:
case T__40:
{
setState(286);
insertClause();
}
break;
case T__37:
case T__38:
{
setState(287);
graphClause();
}
break;
case T__5:
case T__41:
case T__42:
case T__51:
case T__52:
break;
default:
break;
}
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__41 || _la==T__42) {
{
setState(290);
deleteClause();
}
}
setState(294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__51 || _la==T__52) {
{
setState(293);
whereClause();
}
}
setState(296);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LazyRuleContext extends ParserRuleContext {
public UimaTypeNameContext uimaTypeName() {
return getRuleContext(UimaTypeNameContext.class,0);
}
public RuleIdContext ruleId() {
return getRuleContext(RuleIdContext.class,0);
}
public NodesClauseContext nodesClause() {
return getRuleContext(NodesClauseContext.class,0);
}
public LazyRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lazyRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterLazyRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitLazyRule(this);
}
}
public final LazyRuleContext lazyRule() throws RecognitionException {
LazyRuleContext _localctx = new LazyRuleContext(_ctx, getState());
enterRule(_localctx, 28, RULE_lazyRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(298);
match(T__18);
setState(299);
match(T__13);
setState(300);
uimaTypeName();
setState(301);
ruleId();
setState(302);
match(T__4);
setState(303);
nodesClause();
setState(304);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ForRegexRuleContext extends ParserRuleContext {
public UimaTypeNameContext uimaTypeName() {
return getRuleContext(UimaTypeNameContext.class,0);
}
public RuleIdContext ruleId() {
return getRuleContext(RuleIdContext.class,0);
}
public NodesClauseContext nodesClause() {
return getRuleContext(NodesClauseContext.class,0);
}
public ConditionClauseContext conditionClause() {
return getRuleContext(ConditionClauseContext.class,0);
}
public ForRegexRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forRegexRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterForRegexRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitForRegexRule(this);
}
}
public final ForRegexRuleContext forRegexRule() throws RecognitionException {
ForRegexRuleContext _localctx = new ForRegexRuleContext(_ctx, getState());
enterRule(_localctx, 30, RULE_forRegexRule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(306);
_la = _input.LA(1);
if ( !(((_la) & ~0x3f) == 0 && ((1L << _la) & 7340032L) != 0) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(307);
_la = _input.LA(1);
if ( !(_la==T__13 || _la==T__14) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(308);
uimaTypeName();
setState(309);
ruleId();
setState(310);
match(T__4);
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__22 || _la==T__23) {
{
setState(311);
conditionClause();
}
}
setState(314);
nodesClause();
setState(315);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UimaTypeNameContext extends ParserRuleContext {
public JavaQualifiedNameContext javaQualifiedName() {
return getRuleContext(JavaQualifiedNameContext.class,0);
}
public UimaTypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_uimaTypeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterUimaTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitUimaTypeName(this);
}
}
public final UimaTypeNameContext uimaTypeName() throws RecognitionException {
UimaTypeNameContext _localctx = new UimaTypeNameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_uimaTypeName);
try {
enterOuterAlt(_localctx, 1);
{
setState(317);
javaQualifiedName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionClauseContext extends ParserRuleContext {
public List conditionDef() {
return getRuleContexts(ConditionDefContext.class);
}
public ConditionDefContext conditionDef(int i) {
return getRuleContext(ConditionDefContext.class,i);
}
public ConditionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConditionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConditionClause(this);
}
}
public final ConditionClauseContext conditionClause() throws RecognitionException {
ConditionClauseContext _localctx = new ConditionClauseContext(_ctx, getState());
enterRule(_localctx, 34, RULE_conditionClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(319);
_la = _input.LA(1);
if ( !(_la==T__22 || _la==T__23) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(320);
match(T__8);
setState(321);
match(T__4);
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(322);
conditionDef();
}
}
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==REP_PLC || _la==JAVA_IDENTIFIER );
setState(327);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionDefContext extends ParserRuleContext {
public StringContext string;
public List values = new ArrayList();
public FeaturePathContext featurePath() {
return getRuleContext(FeaturePathContext.class,0);
}
public TerminalNode CONDITIONOPERATOR() { return getToken(PearlParser.CONDITIONOPERATOR, 0); }
public List string() {
return getRuleContexts(StringContext.class);
}
public StringContext string(int i) {
return getRuleContext(StringContext.class,i);
}
public ConditionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConditionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConditionDef(this);
}
}
public final ConditionDefContext conditionDef() throws RecognitionException {
ConditionDefContext _localctx = new ConditionDefContext(_ctx, getState());
enterRule(_localctx, 36, RULE_conditionDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(329);
featurePath();
setState(330);
match(CONDITIONOPERATOR);
setState(331);
match(T__24);
setState(332);
((ConditionDefContext)_localctx).string = string();
((ConditionDefContext)_localctx).values.add(((ConditionDefContext)_localctx).string);
setState(337);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(333);
match(T__9);
setState(334);
((ConditionDefContext)_localctx).string = string();
((ConditionDefContext)_localctx).values.add(((ConditionDefContext)_localctx).string);
}
}
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(340);
match(T__25);
setState(341);
match(T__26);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DependContext extends ParserRuleContext {
public Token dependType;
public Token JAVA_IDENTIFIER;
public List depRuleIds = new ArrayList();
public DependParamContext dependParam;
public List params = new ArrayList();
public Token depRuleIdAs;
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public List dependParam() {
return getRuleContexts(DependParamContext.class);
}
public DependParamContext dependParam(int i) {
return getRuleContext(DependParamContext.class,i);
}
public DependContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_depend; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterDepend(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitDepend(this);
}
}
public final DependContext depend() throws RecognitionException {
DependContext _localctx = new DependContext(_ctx, getState());
enterRule(_localctx, 38, RULE_depend);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(343);
((DependContext)_localctx).dependType = match(JAVA_IDENTIFIER);
setState(344);
match(T__6);
setState(347);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(345);
((DependContext)_localctx).JAVA_IDENTIFIER = match(JAVA_IDENTIFIER);
((DependContext)_localctx).depRuleIds.add(((DependContext)_localctx).JAVA_IDENTIFIER);
}
break;
case 2:
{
setState(346);
((DependContext)_localctx).dependParam = dependParam();
((DependContext)_localctx).params.add(((DependContext)_localctx).dependParam);
}
break;
}
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(349);
match(T__9);
setState(352);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(350);
((DependContext)_localctx).JAVA_IDENTIFIER = match(JAVA_IDENTIFIER);
((DependContext)_localctx).depRuleIds.add(((DependContext)_localctx).JAVA_IDENTIFIER);
}
break;
case 2:
{
setState(351);
((DependContext)_localctx).dependParam = dependParam();
((DependContext)_localctx).params.add(((DependContext)_localctx).dependParam);
}
break;
}
}
}
setState(358);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(359);
match(T__7);
setState(360);
_la = _input.LA(1);
if ( !(_la==T__27 || _la==T__28) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(361);
((DependContext)_localctx).depRuleIdAs = match(JAVA_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DependParamContext extends ParserRuleContext {
public Token name;
public Token value;
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public TerminalNode INTEGER() { return getToken(PearlParser.INTEGER, 0); }
public DependParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dependParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterDependParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitDependParam(this);
}
}
public final DependParamContext dependParam() throws RecognitionException {
DependParamContext _localctx = new DependParamContext(_ctx, getState());
enterRule(_localctx, 40, RULE_dependParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(363);
((DependParamContext)_localctx).name = match(JAVA_IDENTIFIER);
setState(364);
match(T__8);
setState(367);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JAVA_IDENTIFIER:
{
setState(365);
((DependParamContext)_localctx).value = match(JAVA_IDENTIFIER);
}
break;
case INTEGER:
{
setState(366);
((DependParamContext)_localctx).value = match(INTEGER);
}
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 BindingsClauseContext extends ParserRuleContext {
public List bindingDef() {
return getRuleContexts(BindingDefContext.class);
}
public BindingDefContext bindingDef(int i) {
return getRuleContext(BindingDefContext.class,i);
}
public BindingsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bindingsClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterBindingsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitBindingsClause(this);
}
}
public final BindingsClauseContext bindingsClause() throws RecognitionException {
BindingsClauseContext _localctx = new BindingsClauseContext(_ctx, getState());
enterRule(_localctx, 42, RULE_bindingsClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(369);
_la = _input.LA(1);
if ( !(_la==T__29 || _la==T__30) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(370);
match(T__8);
setState(371);
match(T__4);
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(372);
bindingDef();
}
}
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==JAVA_IDENTIFIER );
setState(377);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BindingDefContext extends ParserRuleContext {
public Token bindingId;
public Token bindingRuleId;
public FeaturePathContext featurePath() {
return getRuleContext(FeaturePathContext.class,0);
}
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public BindingDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bindingDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterBindingDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitBindingDef(this);
}
}
public final BindingDefContext bindingDef() throws RecognitionException {
BindingDefContext _localctx = new BindingDefContext(_ctx, getState());
enterRule(_localctx, 44, RULE_bindingDef);
try {
enterOuterAlt(_localctx, 1);
{
setState(379);
((BindingDefContext)_localctx).bindingId = match(JAVA_IDENTIFIER);
setState(380);
featurePath();
setState(381);
((BindingDefContext)_localctx).bindingRuleId = match(JAVA_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RuleIdContext extends ParserRuleContext {
public TerminalNode RULE_ID() { return getToken(PearlParser.RULE_ID, 0); }
public RuleIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ruleId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRuleId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRuleId(this);
}
}
public final RuleIdContext ruleId() throws RecognitionException {
RuleIdContext _localctx = new RuleIdContext(_ctx, getState());
enterRule(_localctx, 46, RULE_ruleId);
try {
enterOuterAlt(_localctx, 1);
{
setState(383);
match(RULE_ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NodesClauseContext extends ParserRuleContext {
public List nodeDef() {
return getRuleContexts(NodeDefContext.class);
}
public NodeDefContext nodeDef(int i) {
return getRuleContext(NodeDefContext.class,i);
}
public NodesClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nodesClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterNodesClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitNodesClause(this);
}
}
public final NodesClauseContext nodesClause() throws RecognitionException {
NodesClauseContext _localctx = new NodesClauseContext(_ctx, getState());
enterRule(_localctx, 48, RULE_nodesClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(385);
_la = _input.LA(1);
if ( !(_la==T__31 || _la==T__32) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(386);
match(T__8);
setState(387);
match(T__4);
setState(389);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(388);
nodeDef();
}
}
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LANGTAGORANNOTATION || _la==JAVA_IDENTIFIER );
setState(393);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NodeDefContext extends ParserRuleContext {
public Token nodeName;
public ProjectionOperatorContext projectionOperator() {
return getRuleContext(ProjectionOperatorContext.class,0);
}
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public FeaturePathContext featurePath() {
return getRuleContext(FeaturePathContext.class,0);
}
public NodeDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nodeDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterNodeDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitNodeDef(this);
}
}
public final NodeDefContext nodeDef() throws RecognitionException {
NodeDefContext _localctx = new NodeDefContext(_ctx, getState());
enterRule(_localctx, 50, RULE_nodeDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LANGTAGORANNOTATION) {
{
{
setState(395);
annotation();
}
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(401);
((NodeDefContext)_localctx).nodeName = match(JAVA_IDENTIFIER);
setState(402);
projectionOperator();
setState(408);
_errHandler.sync(this);
switch (_input.LA(1)) {
case REP_PLC:
case JAVA_IDENTIFIER:
{
{
setState(403);
featurePath();
setState(405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__26) {
{
setState(404);
match(T__26);
}
}
}
}
break;
case T__26:
{
setState(407);
match(T__26);
}
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 AnnotationContext extends ParserRuleContext {
public Token annotationName;
public TerminalNode LANGTAGORANNOTATION() { return getToken(PearlParser.LANGTAGORANNOTATION, 0); }
public SingleParamOrListOfNameParamContext singleParamOrListOfNameParam() {
return getRuleContext(SingleParamOrListOfNameParamContext.class,0);
}
public AnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 52, RULE_annotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(410);
((AnnotationContext)_localctx).annotationName = match(LANGTAGORANNOTATION);
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(411);
match(T__6);
setState(412);
singleParamOrListOfNameParam();
setState(413);
match(T__7);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ProjectionOperatorContext extends ParserRuleContext {
public Token type;
public Token rep_plc;
public ConvertersContext converters() {
return getRuleContext(ConvertersContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public TerminalNode LANGTAGORANNOTATION() { return getToken(PearlParser.LANGTAGORANNOTATION, 0); }
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public ProjectionOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_projectionOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterProjectionOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitProjectionOperator(this);
}
}
public final ProjectionOperatorContext projectionOperator() throws RecognitionException {
ProjectionOperatorContext _localctx = new ProjectionOperatorContext(_ctx, getState());
enterRule(_localctx, 54, RULE_projectionOperator);
int _la;
try {
setState(440);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(417);
((ProjectionOperatorContext)_localctx).type = match(T__33);
setState(419);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(418);
converters();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(421);
((ProjectionOperatorContext)_localctx).type = match(T__34);
setState(422);
match(T__35);
setState(423);
iri();
setState(425);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(424);
converters();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(427);
((ProjectionOperatorContext)_localctx).type = match(T__34);
setState(428);
match(LANGTAGORANNOTATION);
setState(430);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(429);
converters();
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(432);
((ProjectionOperatorContext)_localctx).type = match(T__34);
setState(434);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(433);
converters();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(436);
((ProjectionOperatorContext)_localctx).rep_plc = match(REP_PLC);
setState(438);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(437);
converters();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConvertersContext extends ParserRuleContext {
public List individualConverter() {
return getRuleContexts(IndividualConverterContext.class);
}
public IndividualConverterContext individualConverter(int i) {
return getRuleContext(IndividualConverterContext.class,i);
}
public ConvertersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_converters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConverters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConverters(this);
}
}
public final ConvertersContext converters() throws RecognitionException {
ConvertersContext _localctx = new ConvertersContext(_ctx, getState());
enterRule(_localctx, 56, RULE_converters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(442);
match(T__6);
setState(443);
individualConverter();
setState(448);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(444);
match(T__9);
setState(445);
individualConverter();
}
}
setState(450);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(451);
match(T__7);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IndividualConverterContext extends ParserRuleContext {
public Token rep_plc;
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public ConverterAdditionalArgumentsContext converterAdditionalArguments() {
return getRuleContext(ConverterAdditionalArgumentsContext.class,0);
}
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public IndividualConverterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_individualConverter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterIndividualConverter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitIndividualConverter(this);
}
}
public final IndividualConverterContext individualConverter() throws RecognitionException {
IndividualConverterContext _localctx = new IndividualConverterContext(_ctx, getState());
enterRule(_localctx, 58, RULE_individualConverter);
int _la;
try {
setState(461);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(453);
iri();
setState(455);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(454);
converterAdditionalArguments();
}
}
}
break;
case REP_PLC:
enterOuterAlt(_localctx, 2);
{
setState(457);
((IndividualConverterContext)_localctx).rep_plc = match(REP_PLC);
setState(459);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(458);
converterAdditionalArguments();
}
}
}
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 ConverterAdditionalArgumentsContext extends ParserRuleContext {
public List converterArgumentExpression() {
return getRuleContexts(ConverterArgumentExpressionContext.class);
}
public ConverterArgumentExpressionContext converterArgumentExpression(int i) {
return getRuleContext(ConverterArgumentExpressionContext.class,i);
}
public ConverterAdditionalArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_converterAdditionalArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConverterAdditionalArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConverterAdditionalArguments(this);
}
}
public final ConverterAdditionalArgumentsContext converterAdditionalArguments() throws RecognitionException {
ConverterAdditionalArgumentsContext _localctx = new ConverterAdditionalArgumentsContext(_ctx, getState());
enterRule(_localctx, 60, RULE_converterAdditionalArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(463);
match(T__6);
setState(472);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4 || _la==IRIREF || (((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 199L) != 0) {
{
setState(464);
converterArgumentExpression();
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(465);
match(T__9);
setState(466);
converterArgumentExpression();
}
}
setState(471);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(474);
match(T__7);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConverterArgumentExpressionContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public ConverterPlaceholderArgumentContext converterPlaceholderArgument() {
return getRuleContext(ConverterPlaceholderArgumentContext.class,0);
}
public ConverterMapArgumentContext converterMapArgument() {
return getRuleContext(ConverterMapArgumentContext.class,0);
}
public ConverterArgumentExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_converterArgumentExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConverterArgumentExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConverterArgumentExpression(this);
}
}
public final ConverterArgumentExpressionContext converterArgumentExpression() throws RecognitionException {
ConverterArgumentExpressionContext _localctx = new ConverterArgumentExpressionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_converterArgumentExpression);
try {
setState(480);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL1:
case STRING_LITERAL2:
enterOuterAlt(_localctx, 1);
{
setState(476);
literal();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 2);
{
setState(477);
iri();
}
break;
case VAR2:
enterOuterAlt(_localctx, 3);
{
setState(478);
converterPlaceholderArgument();
}
break;
case T__4:
enterOuterAlt(_localctx, 4);
{
setState(479);
converterMapArgument();
}
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 ConverterPlaceholderArgumentContext extends ParserRuleContext {
public TerminalNode VAR2() { return getToken(PearlParser.VAR2, 0); }
public ConverterPlaceholderArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_converterPlaceholderArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConverterPlaceholderArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConverterPlaceholderArgument(this);
}
}
public final ConverterPlaceholderArgumentContext converterPlaceholderArgument() throws RecognitionException {
ConverterPlaceholderArgumentContext _localctx = new ConverterPlaceholderArgumentContext(_ctx, getState());
enterRule(_localctx, 64, RULE_converterPlaceholderArgument);
try {
enterOuterAlt(_localctx, 1);
{
setState(482);
match(VAR2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConverterMapArgumentContext extends ParserRuleContext {
public List mapEntry() {
return getRuleContexts(MapEntryContext.class);
}
public MapEntryContext mapEntry(int i) {
return getRuleContext(MapEntryContext.class,i);
}
public ConverterMapArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_converterMapArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterConverterMapArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitConverterMapArgument(this);
}
}
public final ConverterMapArgumentContext converterMapArgument() throws RecognitionException {
ConverterMapArgumentContext _localctx = new ConverterMapArgumentContext(_ctx, getState());
enterRule(_localctx, 66, RULE_converterMapArgument);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(484);
match(T__4);
setState(493);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==JAVA_IDENTIFIER) {
{
setState(485);
mapEntry();
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(486);
match(T__9);
setState(487);
mapEntry();
}
}
setState(492);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(495);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MapEntryContext extends ParserRuleContext {
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public ConverterPlaceholderArgumentContext converterPlaceholderArgument() {
return getRuleContext(ConverterPlaceholderArgumentContext.class,0);
}
public MapEntryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapEntry; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterMapEntry(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitMapEntry(this);
}
}
public final MapEntryContext mapEntry() throws RecognitionException {
MapEntryContext _localctx = new MapEntryContext(_ctx, getState());
enterRule(_localctx, 68, RULE_mapEntry);
try {
setState(506);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(497);
match(JAVA_IDENTIFIER);
setState(498);
match(T__8);
setState(499);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(500);
match(JAVA_IDENTIFIER);
setState(501);
match(T__8);
setState(502);
iri();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(503);
match(JAVA_IDENTIFIER);
setState(504);
match(T__8);
setState(505);
converterPlaceholderArgument();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FeaturePathContext extends ParserRuleContext {
public Token rep_plc;
public List featurePathElement() {
return getRuleContexts(FeaturePathElementContext.class);
}
public FeaturePathElementContext featurePathElement(int i) {
return getRuleContext(FeaturePathElementContext.class,i);
}
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public FeaturePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_featurePath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterFeaturePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitFeaturePath(this);
}
}
public final FeaturePathContext featurePath() throws RecognitionException {
FeaturePathContext _localctx = new FeaturePathContext(_ctx, getState());
enterRule(_localctx, 70, RULE_featurePath);
int _la;
try {
setState(517);
_errHandler.sync(this);
switch (_input.LA(1)) {
case JAVA_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(508);
featurePathElement();
setState(513);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__36) {
{
{
setState(509);
match(T__36);
setState(510);
featurePathElement();
}
}
setState(515);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case REP_PLC:
enterOuterAlt(_localctx, 2);
{
setState(516);
((FeaturePathContext)_localctx).rep_plc = match(REP_PLC);
}
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 FeaturePathElementContext extends ParserRuleContext {
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public TerminalNode INTEGER() { return getToken(PearlParser.INTEGER, 0); }
public FeaturePathElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_featurePathElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterFeaturePathElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitFeaturePathElement(this);
}
}
public final FeaturePathElementContext featurePathElement() throws RecognitionException {
FeaturePathElementContext _localctx = new FeaturePathElementContext(_ctx, getState());
enterRule(_localctx, 72, RULE_featurePathElement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(519);
match(JAVA_IDENTIFIER);
setState(523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__24) {
{
setState(520);
match(T__24);
setState(521);
match(INTEGER);
setState(522);
match(T__25);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GraphClauseContext extends ParserRuleContext {
public GraphContext graph() {
return getRuleContext(GraphContext.class,0);
}
public GraphClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphClause(this);
}
}
public final GraphClauseContext graphClause() throws RecognitionException {
GraphClauseContext _localctx = new GraphClauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_graphClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(525);
_la = _input.LA(1);
if ( !(_la==T__37 || _la==T__38) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(526);
match(T__8);
setState(527);
graph();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InsertClauseContext extends ParserRuleContext {
public GraphContext graph() {
return getRuleContext(GraphContext.class,0);
}
public InsertClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterInsertClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitInsertClause(this);
}
}
public final InsertClauseContext insertClause() throws RecognitionException {
InsertClauseContext _localctx = new InsertClauseContext(_ctx, getState());
enterRule(_localctx, 76, RULE_insertClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(529);
_la = _input.LA(1);
if ( !(_la==T__39 || _la==T__40) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(530);
match(T__8);
setState(531);
graph();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DeleteClauseContext extends ParserRuleContext {
public GraphContext graph() {
return getRuleContext(GraphContext.class,0);
}
public DeleteClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterDeleteClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitDeleteClause(this);
}
}
public final DeleteClauseContext deleteClause() throws RecognitionException {
DeleteClauseContext _localctx = new DeleteClauseContext(_ctx, getState());
enterRule(_localctx, 78, RULE_deleteClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(533);
_la = _input.LA(1);
if ( !(_la==T__41 || _la==T__42) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(534);
match(T__8);
setState(535);
graph();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JavaQualifiedNameContext extends ParserRuleContext {
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public JavaQualifiedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_javaQualifiedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterJavaQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitJavaQualifiedName(this);
}
}
public final JavaQualifiedNameContext javaQualifiedName() throws RecognitionException {
JavaQualifiedNameContext _localctx = new JavaQualifiedNameContext(_ctx, getState());
enterRule(_localctx, 80, RULE_javaQualifiedName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(537);
match(JAVA_IDENTIFIER);
setState(542);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__26) {
{
{
setState(538);
match(T__26);
setState(539);
match(JAVA_IDENTIFIER);
}
}
setState(544);
_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 GraphContext extends ParserRuleContext {
public List graphElement() {
return getRuleContexts(GraphElementContext.class);
}
public GraphElementContext graphElement(int i) {
return getRuleContext(GraphElementContext.class,i);
}
public GraphContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graph; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraph(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraph(this);
}
}
public final GraphContext graph() throws RecognitionException {
GraphContext _localctx = new GraphContext(_ctx, getState());
enterRule(_localctx, 82, RULE_graph);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(545);
match(T__4);
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(546);
graphElement();
}
}
setState(549);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & 1140326403L) != 0 );
setState(551);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GraphElementContext extends ParserRuleContext {
public OptionalGraphElementContext optionalGraphElement() {
return getRuleContext(OptionalGraphElementContext.class,0);
}
public GraphTripleContext graphTriple() {
return getRuleContext(GraphTripleContext.class,0);
}
public List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public GraphElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphElement(this);
}
}
public final GraphElementContext graphElement() throws RecognitionException {
GraphElementContext _localctx = new GraphElementContext(_ctx, getState());
enterRule(_localctx, 84, RULE_graphElement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(561);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case VAR1:
case VAR2:
case PNAME_NS:
case PNAME_LN:
case BLANK_NODE_LABEL:
case LANGTAGORANNOTATION:
case REP_PLC:
{
{
setState(556);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LANGTAGORANNOTATION) {
{
{
setState(553);
annotation();
}
}
setState(558);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(559);
graphTriple();
}
}
break;
case T__43:
case T__44:
{
setState(560);
optionalGraphElement();
}
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 OptionalGraphElementContext extends ParserRuleContext {
public List graphElement() {
return getRuleContexts(GraphElementContext.class);
}
public GraphElementContext graphElement(int i) {
return getRuleContext(GraphElementContext.class,i);
}
public OptionalGraphElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionalGraphElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterOptionalGraphElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitOptionalGraphElement(this);
}
}
public final OptionalGraphElementContext optionalGraphElement() throws RecognitionException {
OptionalGraphElementContext _localctx = new OptionalGraphElementContext(_ctx, getState());
enterRule(_localctx, 86, RULE_optionalGraphElement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(563);
_la = _input.LA(1);
if ( !(_la==T__43 || _la==T__44) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(564);
match(T__4);
setState(566);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(565);
graphElement();
}
}
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la - 44)) & ~0x3f) == 0 && ((1L << (_la - 44)) & 1140326403L) != 0 );
setState(570);
match(T__5);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GraphTripleContext extends ParserRuleContext {
public GraphSubjectContext graphSubject() {
return getRuleContext(GraphSubjectContext.class,0);
}
public GraphPredicateContext graphPredicate() {
return getRuleContext(GraphPredicateContext.class,0);
}
public GraphObjectContext graphObject() {
return getRuleContext(GraphObjectContext.class,0);
}
public GraphTripleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphTriple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphTriple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphTriple(this);
}
}
public final GraphTripleContext graphTriple() throws RecognitionException {
GraphTripleContext _localctx = new GraphTripleContext(_ctx, getState());
enterRule(_localctx, 88, RULE_graphTriple);
try {
enterOuterAlt(_localctx, 1);
{
setState(572);
graphSubject();
setState(573);
graphPredicate();
setState(574);
graphObject();
setState(575);
match(T__26);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GraphSubjectContext extends ParserRuleContext {
public Token rep_plc;
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public BlankNodeContext blankNode() {
return getRuleContext(BlankNodeContext.class,0);
}
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public GraphSubjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphSubject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphSubject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphSubject(this);
}
}
public final GraphSubjectContext graphSubject() throws RecognitionException {
GraphSubjectContext _localctx = new GraphSubjectContext(_ctx, getState());
enterRule(_localctx, 90, RULE_graphSubject);
try {
setState(582);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
enterOuterAlt(_localctx, 1);
{
setState(577);
var();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 2);
{
setState(578);
iri();
}
break;
case BLANK_NODE_LABEL:
enterOuterAlt(_localctx, 3);
{
setState(579);
blankNode();
}
break;
case VAR2:
enterOuterAlt(_localctx, 4);
{
setState(580);
placeholder();
}
break;
case REP_PLC:
enterOuterAlt(_localctx, 5);
{
setState(581);
((GraphSubjectContext)_localctx).rep_plc = match(REP_PLC);
}
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 GraphPredicateContext extends ParserRuleContext {
public Token rep_plc;
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public AbbrContext abbr() {
return getRuleContext(AbbrContext.class,0);
}
public PropPathContext propPath() {
return getRuleContext(PropPathContext.class,0);
}
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public GraphPredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphPredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphPredicate(this);
}
}
public final GraphPredicateContext graphPredicate() throws RecognitionException {
GraphPredicateContext _localctx = new GraphPredicateContext(_ctx, getState());
enterRule(_localctx, 92, RULE_graphPredicate);
try {
setState(590);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(584);
var();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(585);
iri();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(586);
abbr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(587);
propPath();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(588);
placeholder();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(589);
((GraphPredicateContext)_localctx).rep_plc = match(REP_PLC);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GraphObjectContext extends ParserRuleContext {
public Token rep_plc;
public VarContext var() {
return getRuleContext(VarContext.class,0);
}
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public BlankNodeContext blankNode() {
return getRuleContext(BlankNodeContext.class,0);
}
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public TerminalNode REP_PLC() { return getToken(PearlParser.REP_PLC, 0); }
public GraphObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_graphObject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterGraphObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitGraphObject(this);
}
}
public final GraphObjectContext graphObject() throws RecognitionException {
GraphObjectContext _localctx = new GraphObjectContext(_ctx, getState());
enterRule(_localctx, 94, RULE_graphObject);
try {
setState(598);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR1:
enterOuterAlt(_localctx, 1);
{
setState(592);
var();
}
break;
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 2);
{
setState(593);
iri();
}
break;
case STRING_LITERAL1:
case STRING_LITERAL2:
enterOuterAlt(_localctx, 3);
{
setState(594);
literal();
}
break;
case BLANK_NODE_LABEL:
enterOuterAlt(_localctx, 4);
{
setState(595);
blankNode();
}
break;
case VAR2:
enterOuterAlt(_localctx, 5);
{
setState(596);
placeholder();
}
break;
case REP_PLC:
enterOuterAlt(_localctx, 6);
{
setState(597);
((GraphObjectContext)_localctx).rep_plc = match(REP_PLC);
}
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 PropPathContext extends ParserRuleContext {
public PathAlternativeContext pathAlternative() {
return getRuleContext(PathAlternativeContext.class,0);
}
public PropPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPropPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPropPath(this);
}
}
public final PropPathContext propPath() throws RecognitionException {
PropPathContext _localctx = new PropPathContext(_ctx, getState());
enterRule(_localctx, 96, RULE_propPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(600);
pathAlternative();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PathAlternativeContext extends ParserRuleContext {
public List pathSequence() {
return getRuleContexts(PathSequenceContext.class);
}
public PathSequenceContext pathSequence(int i) {
return getRuleContext(PathSequenceContext.class,i);
}
public PathAlternativeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathAlternative; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathAlternative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathAlternative(this);
}
}
public final PathAlternativeContext pathAlternative() throws RecognitionException {
PathAlternativeContext _localctx = new PathAlternativeContext(_ctx, getState());
enterRule(_localctx, 98, RULE_pathAlternative);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(602);
pathSequence();
setState(607);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__45) {
{
{
setState(603);
match(T__45);
setState(604);
pathSequence();
}
}
setState(609);
_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 PathSequenceContext extends ParserRuleContext {
public List pathEltOrInverse() {
return getRuleContexts(PathEltOrInverseContext.class);
}
public PathEltOrInverseContext pathEltOrInverse(int i) {
return getRuleContext(PathEltOrInverseContext.class,i);
}
public PathSequenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathSequence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathSequence(this);
}
}
public final PathSequenceContext pathSequence() throws RecognitionException {
PathSequenceContext _localctx = new PathSequenceContext(_ctx, getState());
enterRule(_localctx, 100, RULE_pathSequence);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(610);
pathEltOrInverse();
setState(615);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__36) {
{
{
setState(611);
match(T__36);
setState(612);
pathEltOrInverse();
}
}
setState(617);
_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 PathEltContext extends ParserRuleContext {
public PathPrimaryContext pathPrimary() {
return getRuleContext(PathPrimaryContext.class,0);
}
public TerminalNode REGEX_SYMBOL() { return getToken(PearlParser.REGEX_SYMBOL, 0); }
public PathEltContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathElt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathElt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathElt(this);
}
}
public final PathEltContext pathElt() throws RecognitionException {
PathEltContext _localctx = new PathEltContext(_ctx, getState());
enterRule(_localctx, 102, RULE_pathElt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(618);
pathPrimary();
setState(620);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==REGEX_SYMBOL) {
{
setState(619);
match(REGEX_SYMBOL);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PathEltOrInverseContext extends ParserRuleContext {
public PathEltContext pathElt() {
return getRuleContext(PathEltContext.class,0);
}
public PathEltOrInverseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathEltOrInverse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathEltOrInverse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathEltOrInverse(this);
}
}
public final PathEltOrInverseContext pathEltOrInverse() throws RecognitionException {
PathEltOrInverseContext _localctx = new PathEltOrInverseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_pathEltOrInverse);
try {
setState(625);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__6:
case T__47:
case T__48:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(622);
pathElt();
}
break;
case T__46:
enterOuterAlt(_localctx, 2);
{
setState(623);
match(T__46);
setState(624);
pathElt();
}
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 PathPrimaryContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public PathNegatedPropertySetContext pathNegatedPropertySet() {
return getRuleContext(PathNegatedPropertySetContext.class,0);
}
public PathAlternativeContext pathAlternative() {
return getRuleContext(PathAlternativeContext.class,0);
}
public PathPrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathPrimary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathPrimary(this);
}
}
public final PathPrimaryContext pathPrimary() throws RecognitionException {
PathPrimaryContext _localctx = new PathPrimaryContext(_ctx, getState());
enterRule(_localctx, 106, RULE_pathPrimary);
try {
setState(635);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(627);
iri();
}
break;
case T__47:
enterOuterAlt(_localctx, 2);
{
setState(628);
match(T__47);
}
break;
case T__48:
enterOuterAlt(_localctx, 3);
{
setState(629);
match(T__48);
setState(630);
pathNegatedPropertySet();
}
break;
case T__6:
enterOuterAlt(_localctx, 4);
{
setState(631);
match(T__6);
setState(632);
pathAlternative();
setState(633);
match(T__7);
}
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 PathNegatedPropertySetContext extends ParserRuleContext {
public List pathOneInPropertySet() {
return getRuleContexts(PathOneInPropertySetContext.class);
}
public PathOneInPropertySetContext pathOneInPropertySet(int i) {
return getRuleContext(PathOneInPropertySetContext.class,i);
}
public PathNegatedPropertySetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathNegatedPropertySet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathNegatedPropertySet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathNegatedPropertySet(this);
}
}
public final PathNegatedPropertySetContext pathNegatedPropertySet() throws RecognitionException {
PathNegatedPropertySetContext _localctx = new PathNegatedPropertySetContext(_ctx, getState());
enterRule(_localctx, 108, RULE_pathNegatedPropertySet);
int _la;
try {
setState(649);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__46:
case T__47:
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(637);
pathOneInPropertySet();
}
break;
case T__6:
enterOuterAlt(_localctx, 2);
{
setState(638);
match(T__6);
setState(639);
pathOneInPropertySet();
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__45) {
{
{
setState(640);
match(T__45);
setState(641);
pathOneInPropertySet();
}
}
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(647);
match(T__7);
}
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 PathOneInPropertySetContext extends ParserRuleContext {
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public PathOneInPropertySetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathOneInPropertySet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPathOneInPropertySet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPathOneInPropertySet(this);
}
}
public final PathOneInPropertySetContext pathOneInPropertySet() throws RecognitionException {
PathOneInPropertySetContext _localctx = new PathOneInPropertySetContext(_ctx, getState());
enterRule(_localctx, 110, RULE_pathOneInPropertySet);
try {
setState(658);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(651);
iri();
}
break;
case T__47:
enterOuterAlt(_localctx, 2);
{
setState(652);
match(T__47);
}
break;
case T__46:
enterOuterAlt(_localctx, 3);
{
setState(653);
match(T__46);
setState(656);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
case PNAME_NS:
case PNAME_LN:
{
setState(654);
iri();
}
break;
case T__47:
{
setState(655);
match(T__47);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VarContext extends ParserRuleContext {
public TerminalNode VAR1() { return getToken(PearlParser.VAR1, 0); }
public VarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterVar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitVar(this);
}
}
public final VarContext var() throws RecognitionException {
VarContext _localctx = new VarContext(_ctx, getState());
enterRule(_localctx, 112, RULE_var);
try {
enterOuterAlt(_localctx, 1);
{
setState(660);
match(VAR1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PlaceholderContext extends ParserRuleContext {
public Token separator;
public TerminalNode VAR2() { return getToken(PearlParser.VAR2, 0); }
public TerminalNode JAVA_IDENTIFIER() { return getToken(PearlParser.JAVA_IDENTIFIER, 0); }
public PlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_placeholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPlaceholder(this);
}
}
public final PlaceholderContext placeholder() throws RecognitionException {
PlaceholderContext _localctx = new PlaceholderContext(_ctx, getState());
enterRule(_localctx, 114, RULE_placeholder);
try {
setState(669);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(662);
match(VAR2);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(663);
match(VAR2);
setState(664);
((PlaceholderContext)_localctx).separator = match(T__26);
setState(665);
match(JAVA_IDENTIFIER);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(666);
match(VAR2);
setState(667);
((PlaceholderContext)_localctx).separator = match(T__49);
setState(668);
match(JAVA_IDENTIFIER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IriContext extends ParserRuleContext {
public TerminalNode IRIREF() { return getToken(PearlParser.IRIREF, 0); }
public PrefixedNameContext prefixedName() {
return getRuleContext(PrefixedNameContext.class,0);
}
public IriContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iri; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterIri(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitIri(this);
}
}
public final IriContext iri() throws RecognitionException {
IriContext _localctx = new IriContext(_ctx, getState());
enterRule(_localctx, 116, RULE_iri);
try {
setState(673);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IRIREF:
enterOuterAlt(_localctx, 1);
{
setState(671);
match(IRIREF);
}
break;
case PNAME_NS:
case PNAME_LN:
enterOuterAlt(_localctx, 2);
{
setState(672);
prefixedName();
}
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 LiteralContext extends ParserRuleContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode LANGTAGORANNOTATION() { return getToken(PearlParser.LANGTAGORANNOTATION, 0); }
public IriContext iri() {
return getRuleContext(IriContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 118, RULE_literal);
try {
enterOuterAlt(_localctx, 1);
{
setState(675);
string();
setState(679);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LANGTAGORANNOTATION:
{
setState(676);
match(LANGTAGORANNOTATION);
}
break;
case T__35:
{
{
setState(677);
match(T__35);
setState(678);
iri();
}
}
break;
case T__5:
case T__7:
case T__9:
case T__11:
case T__26:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL1() { return getToken(PearlParser.STRING_LITERAL1, 0); }
public TerminalNode STRING_LITERAL2() { return getToken(PearlParser.STRING_LITERAL2, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitString(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 120, RULE_string);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(681);
_la = _input.LA(1);
if ( !(_la==STRING_LITERAL1 || _la==STRING_LITERAL2) ) {
_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 BlankNodeContext extends ParserRuleContext {
public TerminalNode BLANK_NODE_LABEL() { return getToken(PearlParser.BLANK_NODE_LABEL, 0); }
public BlankNodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blankNode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterBlankNode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitBlankNode(this);
}
}
public final BlankNodeContext blankNode() throws RecognitionException {
BlankNodeContext _localctx = new BlankNodeContext(_ctx, getState());
enterRule(_localctx, 122, RULE_blankNode);
try {
enterOuterAlt(_localctx, 1);
{
setState(683);
match(BLANK_NODE_LABEL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrefixedNameContext extends ParserRuleContext {
public Token pn;
public TerminalNode PNAME_LN() { return getToken(PearlParser.PNAME_LN, 0); }
public TerminalNode PNAME_NS() { return getToken(PearlParser.PNAME_NS, 0); }
public PrefixedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterPrefixedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitPrefixedName(this);
}
}
public final PrefixedNameContext prefixedName() throws RecognitionException {
PrefixedNameContext _localctx = new PrefixedNameContext(_ctx, getState());
enterRule(_localctx, 124, RULE_prefixedName);
try {
setState(687);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PNAME_LN:
enterOuterAlt(_localctx, 1);
{
setState(685);
match(PNAME_LN);
}
break;
case PNAME_NS:
enterOuterAlt(_localctx, 2);
{
setState(686);
((PrefixedNameContext)_localctx).pn = match(PNAME_NS);
}
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 AbbrContext extends ParserRuleContext {
public AbbrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abbr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterAbbr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitAbbr(this);
}
}
public final AbbrContext abbr() throws RecognitionException {
AbbrContext _localctx = new AbbrContext(_ctx, getState());
enterRule(_localctx, 126, RULE_abbr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(689);
_la = _input.LA(1);
if ( !(_la==T__47 || _la==T__50) ) {
_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 WhereClauseContext extends ParserRuleContext {
public GraphContext graph() {
return getRuleContext(GraphContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitWhereClause(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_whereClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(691);
_la = _input.LA(1);
if ( !(_la==T__51 || _la==T__52) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(692);
match(T__8);
setState(693);
graph();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RegexContext extends ParserRuleContext {
public RuleIdContext ruleId() {
return getRuleContext(RuleIdContext.class,0);
}
public RegexPatternContext regexPattern() {
return getRuleContext(RegexPatternContext.class,0);
}
public GraphClauseContext graphClause() {
return getRuleContext(GraphClauseContext.class,0);
}
public RegexContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regex; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegex(this);
}
}
public final RegexContext regex() throws RecognitionException {
RegexContext _localctx = new RegexContext(_ctx, getState());
enterRule(_localctx, 130, RULE_regex);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(695);
_la = _input.LA(1);
if ( !(_la==T__53 || _la==T__54) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(696);
ruleId();
setState(697);
regexPattern();
setState(698);
match(T__55);
setState(699);
graphClause();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RegexPatternContext extends ParserRuleContext {
public RegexWithOrContext regexWithOr() {
return getRuleContext(RegexWithOrContext.class,0);
}
public RegexPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegexPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegexPattern(this);
}
}
public final RegexPatternContext regexPattern() throws RecognitionException {
RegexPatternContext _localctx = new RegexPatternContext(_ctx, getState());
enterRule(_localctx, 132, RULE_regexPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(701);
regexWithOr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RegexWithOrContext extends ParserRuleContext {
public List regexSequenceElement() {
return getRuleContexts(RegexSequenceElementContext.class);
}
public RegexSequenceElementContext regexSequenceElement(int i) {
return getRuleContext(RegexSequenceElementContext.class,i);
}
public RegexWithOrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexWithOr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegexWithOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegexWithOr(this);
}
}
public final RegexWithOrContext regexWithOr() throws RecognitionException {
RegexWithOrContext _localctx = new RegexWithOrContext(_ctx, getState());
enterRule(_localctx, 134, RULE_regexWithOr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(703);
regexSequenceElement();
setState(708);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__45) {
{
{
setState(704);
match(T__45);
setState(705);
regexSequenceElement();
}
}
setState(710);
_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 RegexSequenceElementContext extends ParserRuleContext {
public List regexBaseElementWithSymbol() {
return getRuleContexts(RegexBaseElementWithSymbolContext.class);
}
public RegexBaseElementWithSymbolContext regexBaseElementWithSymbol(int i) {
return getRuleContext(RegexBaseElementWithSymbolContext.class,i);
}
public RegexSequenceElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexSequenceElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegexSequenceElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegexSequenceElement(this);
}
}
public final RegexSequenceElementContext regexSequenceElement() throws RecognitionException {
RegexSequenceElementContext _localctx = new RegexSequenceElementContext(_ctx, getState());
enterRule(_localctx, 136, RULE_regexSequenceElement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(712);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(711);
regexBaseElementWithSymbol();
}
}
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__6 || _la==T__24 );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RegexBaseElementWithSymbolContext extends ParserRuleContext {
public RegexBaseElementContext regexBaseElement() {
return getRuleContext(RegexBaseElementContext.class,0);
}
public TerminalNode REGEX_SYMBOL() { return getToken(PearlParser.REGEX_SYMBOL, 0); }
public RegexBaseElementWithSymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexBaseElementWithSymbol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegexBaseElementWithSymbol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegexBaseElementWithSymbol(this);
}
}
public final RegexBaseElementWithSymbolContext regexBaseElementWithSymbol() throws RecognitionException {
RegexBaseElementWithSymbolContext _localctx = new RegexBaseElementWithSymbolContext(_ctx, getState());
enterRule(_localctx, 138, RULE_regexBaseElementWithSymbol);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(716);
regexBaseElement();
setState(718);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==REGEX_SYMBOL) {
{
setState(717);
match(REGEX_SYMBOL);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RegexBaseElementContext extends ParserRuleContext {
public Token maxDist;
public Token regexRuleId;
public Token internalId;
public List JAVA_IDENTIFIER() { return getTokens(PearlParser.JAVA_IDENTIFIER); }
public TerminalNode JAVA_IDENTIFIER(int i) {
return getToken(PearlParser.JAVA_IDENTIFIER, i);
}
public TerminalNode INTEGER() { return getToken(PearlParser.INTEGER, 0); }
public RegexWithOrContext regexWithOr() {
return getRuleContext(RegexWithOrContext.class,0);
}
public RegexBaseElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regexBaseElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).enterRegexBaseElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PearlListener ) ((PearlListener)listener).exitRegexBaseElement(this);
}
}
public final RegexBaseElementContext regexBaseElement() throws RecognitionException {
RegexBaseElementContext _localctx = new RegexBaseElementContext(_ctx, getState());
enterRule(_localctx, 140, RULE_regexBaseElement);
int _la;
try {
setState(732);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__24:
enterOuterAlt(_localctx, 1);
{
setState(720);
match(T__24);
setState(722);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INTEGER) {
{
setState(721);
((RegexBaseElementContext)_localctx).maxDist = match(INTEGER);
}
}
setState(724);
((RegexBaseElementContext)_localctx).regexRuleId = match(JAVA_IDENTIFIER);
setState(725);
_la = _input.LA(1);
if ( !(_la==T__27 || _la==T__28) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(726);
((RegexBaseElementContext)_localctx).internalId = match(JAVA_IDENTIFIER);
setState(727);
match(T__25);
}
break;
case T__6:
enterOuterAlt(_localctx, 2);
{
setState(728);
match(T__6);
setState(729);
regexWithOr();
setState(730);
match(T__7);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\u0004\u0001M\u02df\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\u0001\u0000\u0001\u0000\u0003\u0000\u0091\b\u0000\u0001\u0000"+
"\u0001\u0000\u0005\u0000\u0095\b\u0000\n\u0000\f\u0000\u0098\t\u0000\u0001"+
"\u0001\u0005\u0001\u009b\b\u0001\n\u0001\f\u0001\u009e\t\u0001\u0001\u0002"+
"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0004\u0003\u00a5\b\u0003"+
"\u000b\u0003\f\u0003\u00a6\u0001\u0004\u0005\u0004\u00aa\b\u0004\n\u0004"+
"\f\u0004\u00ad\t\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
"\u0005\u0004\u00b3\b\u0004\n\u0004\f\u0004\u00b6\t\u0004\u0001\u0004\u0003"+
"\u0004\u00b9\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
"\u0005\u0003\u0005\u00c0\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u00ca"+
"\b\u0006\n\u0006\f\u0006\u00cd\t\u0006\u0003\u0006\u00cf\b\u0006\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u00d6"+
"\b\u0007\n\u0007\f\u0007\u00d9\t\u0007\u0001\u0007\u0001\u0007\u0003\u0007"+
"\u00dd\b\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b"+
"\u00e5\b\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u00ed"+
"\b\t\u0001\t\u0001\t\u0001\n\u0001\n\u0003\n\u00f3\b\n\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u00fa\b\u000b\u0001"+
"\f\u0005\f\u00fd\b\f\n\f\f\f\u0100\t\f\u0001\f\u0001\f\u0001\f\u0003\f"+
"\u0105\b\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0005"+
"\r\u010e\b\r\n\r\f\r\u0111\t\r\u0003\r\u0113\b\r\u0001\r\u0001\r\u0003"+
"\r\u0117\b\r\u0001\r\u0003\r\u011a\b\r\u0001\r\u0003\r\u011d\b\r\u0001"+
"\r\u0001\r\u0003\r\u0121\b\r\u0001\r\u0003\r\u0124\b\r\u0001\r\u0003\r"+
"\u0127\b\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0139\b\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011"+
"\u0001\u0011\u0001\u0011\u0001\u0011\u0004\u0011\u0144\b\u0011\u000b\u0011"+
"\f\u0011\u0145\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012"+
"\u0001\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u0150\b\u0012\n\u0012"+
"\f\u0012\u0153\t\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013"+
"\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u015c\b\u0013\u0001\u0013"+
"\u0001\u0013\u0001\u0013\u0003\u0013\u0161\b\u0013\u0005\u0013\u0163\b"+
"\u0013\n\u0013\f\u0013\u0166\t\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+
"\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014"+
"\u0170\b\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0004\u0015"+
"\u0176\b\u0015\u000b\u0015\f\u0015\u0177\u0001\u0015\u0001\u0015\u0001"+
"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001"+
"\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0004\u0018\u0186\b\u0018\u000b"+
"\u0018\f\u0018\u0187\u0001\u0018\u0001\u0018\u0001\u0019\u0005\u0019\u018d"+
"\b\u0019\n\u0019\f\u0019\u0190\t\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
"\u0001\u0019\u0003\u0019\u0196\b\u0019\u0001\u0019\u0003\u0019\u0199\b"+
"\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003"+
"\u001a\u01a0\b\u001a\u0001\u001b\u0001\u001b\u0003\u001b\u01a4\b\u001b"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u01aa\b\u001b"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u01af\b\u001b\u0001\u001b"+
"\u0001\u001b\u0003\u001b\u01b3\b\u001b\u0001\u001b\u0001\u001b\u0003\u001b"+
"\u01b7\b\u001b\u0003\u001b\u01b9\b\u001b\u0001\u001c\u0001\u001c\u0001"+
"\u001c\u0001\u001c\u0005\u001c\u01bf\b\u001c\n\u001c\f\u001c\u01c2\t\u001c"+
"\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0003\u001d\u01c8\b\u001d"+
"\u0001\u001d\u0001\u001d\u0003\u001d\u01cc\b\u001d\u0003\u001d\u01ce\b"+
"\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u01d4"+
"\b\u001e\n\u001e\f\u001e\u01d7\t\u001e\u0003\u001e\u01d9\b\u001e\u0001"+
"\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0003"+
"\u001f\u01e1\b\u001f\u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0005!"+
"\u01e9\b!\n!\f!\u01ec\t!\u0003!\u01ee\b!\u0001!\u0001!\u0001\"\u0001\""+
"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u01fb"+
"\b\"\u0001#\u0001#\u0001#\u0005#\u0200\b#\n#\f#\u0203\t#\u0001#\u0003"+
"#\u0206\b#\u0001$\u0001$\u0001$\u0001$\u0003$\u020c\b$\u0001%\u0001%\u0001"+
"%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+
"(\u0001(\u0001(\u0005(\u021d\b(\n(\f(\u0220\t(\u0001)\u0001)\u0004)\u0224"+
"\b)\u000b)\f)\u0225\u0001)\u0001)\u0001*\u0005*\u022b\b*\n*\f*\u022e\t"+
"*\u0001*\u0001*\u0003*\u0232\b*\u0001+\u0001+\u0001+\u0004+\u0237\b+\u000b"+
"+\f+\u0238\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001-\u0001"+
"-\u0001-\u0001-\u0001-\u0003-\u0247\b-\u0001.\u0001.\u0001.\u0001.\u0001"+
".\u0001.\u0003.\u024f\b.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0003"+
"/\u0257\b/\u00010\u00010\u00011\u00011\u00011\u00051\u025e\b1\n1\f1\u0261"+
"\t1\u00012\u00012\u00012\u00052\u0266\b2\n2\f2\u0269\t2\u00013\u00013"+
"\u00033\u026d\b3\u00014\u00014\u00014\u00034\u0272\b4\u00015\u00015\u0001"+
"5\u00015\u00015\u00015\u00015\u00015\u00035\u027c\b5\u00016\u00016\u0001"+
"6\u00016\u00016\u00056\u0283\b6\n6\f6\u0286\t6\u00016\u00016\u00036\u028a"+
"\b6\u00017\u00017\u00017\u00017\u00017\u00037\u0291\b7\u00037\u0293\b"+
"7\u00018\u00018\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0003"+
"9\u029e\b9\u0001:\u0001:\u0003:\u02a2\b:\u0001;\u0001;\u0001;\u0001;\u0003"+
";\u02a8\b;\u0001<\u0001<\u0001=\u0001=\u0001>\u0001>\u0003>\u02b0\b>\u0001"+
"?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001"+
"A\u0001A\u0001B\u0001B\u0001C\u0001C\u0001C\u0005C\u02c3\bC\nC\fC\u02c6"+
"\tC\u0001D\u0004D\u02c9\bD\u000bD\fD\u02ca\u0001E\u0001E\u0003E\u02cf"+
"\bE\u0001F\u0001F\u0003F\u02d3\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0001F\u0001F\u0003F\u02dd\bF\u0001F\u0000\u0000G\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\u0000\u0011\u0001\u0000\u0001\u0002\u0001\u0000\u0003"+
"\u0004\u0001\u0000\u000e\u000f\u0001\u0000\u0010\u0012\u0001\u0000\u0014"+
"\u0016\u0001\u0000\u0017\u0018\u0001\u0000\u001c\u001d\u0001\u0000\u001e"+
"\u001f\u0001\u0000 !\u0001\u0000&\'\u0001\u0000()\u0001\u0000*+\u0001"+
"\u0000,-\u0001\u0000GH\u0002\u00000033\u0001\u000045\u0001\u000067\u030b"+
"\u0000\u008e\u0001\u0000\u0000\u0000\u0002\u009c\u0001\u0000\u0000\u0000"+
"\u0004\u009f\u0001\u0000\u0000\u0000\u0006\u00a4\u0001\u0000\u0000\u0000"+
"\b\u00ab\u0001\u0000\u0000\u0000\n\u00ba\u0001\u0000\u0000\u0000\f\u00ce"+
"\u0001\u0000\u0000\u0000\u000e\u00dc\u0001\u0000\u0000\u0000\u0010\u00e4"+
"\u0001\u0000\u0000\u0000\u0012\u00e6\u0001\u0000\u0000\u0000\u0014\u00f0"+
"\u0001\u0000\u0000\u0000\u0016\u00f9\u0001\u0000\u0000\u0000\u0018\u00fe"+
"\u0001\u0000\u0000\u0000\u001a\u0106\u0001\u0000\u0000\u0000\u001c\u012a"+
"\u0001\u0000\u0000\u0000\u001e\u0132\u0001\u0000\u0000\u0000 \u013d\u0001"+
"\u0000\u0000\u0000\"\u013f\u0001\u0000\u0000\u0000$\u0149\u0001\u0000"+
"\u0000\u0000&\u0157\u0001\u0000\u0000\u0000(\u016b\u0001\u0000\u0000\u0000"+
"*\u0171\u0001\u0000\u0000\u0000,\u017b\u0001\u0000\u0000\u0000.\u017f"+
"\u0001\u0000\u0000\u00000\u0181\u0001\u0000\u0000\u00002\u018e\u0001\u0000"+
"\u0000\u00004\u019a\u0001\u0000\u0000\u00006\u01b8\u0001\u0000\u0000\u0000"+
"8\u01ba\u0001\u0000\u0000\u0000:\u01cd\u0001\u0000\u0000\u0000<\u01cf"+
"\u0001\u0000\u0000\u0000>\u01e0\u0001\u0000\u0000\u0000@\u01e2\u0001\u0000"+
"\u0000\u0000B\u01e4\u0001\u0000\u0000\u0000D\u01fa\u0001\u0000\u0000\u0000"+
"F\u0205\u0001\u0000\u0000\u0000H\u0207\u0001\u0000\u0000\u0000J\u020d"+
"\u0001\u0000\u0000\u0000L\u0211\u0001\u0000\u0000\u0000N\u0215\u0001\u0000"+
"\u0000\u0000P\u0219\u0001\u0000\u0000\u0000R\u0221\u0001\u0000\u0000\u0000"+
"T\u0231\u0001\u0000\u0000\u0000V\u0233\u0001\u0000\u0000\u0000X\u023c"+
"\u0001\u0000\u0000\u0000Z\u0246\u0001\u0000\u0000\u0000\\\u024e\u0001"+
"\u0000\u0000\u0000^\u0256\u0001\u0000\u0000\u0000`\u0258\u0001\u0000\u0000"+
"\u0000b\u025a\u0001\u0000\u0000\u0000d\u0262\u0001\u0000\u0000\u0000f"+
"\u026a\u0001\u0000\u0000\u0000h\u0271\u0001\u0000\u0000\u0000j\u027b\u0001"+
"\u0000\u0000\u0000l\u0289\u0001\u0000\u0000\u0000n\u0292\u0001\u0000\u0000"+
"\u0000p\u0294\u0001\u0000\u0000\u0000r\u029d\u0001\u0000\u0000\u0000t"+
"\u02a1\u0001\u0000\u0000\u0000v\u02a3\u0001\u0000\u0000\u0000x\u02a9\u0001"+
"\u0000\u0000\u0000z\u02ab\u0001\u0000\u0000\u0000|\u02af\u0001\u0000\u0000"+
"\u0000~\u02b1\u0001\u0000\u0000\u0000\u0080\u02b3\u0001\u0000\u0000\u0000"+
"\u0082\u02b7\u0001\u0000\u0000\u0000\u0084\u02bd\u0001\u0000\u0000\u0000"+
"\u0086\u02bf\u0001\u0000\u0000\u0000\u0088\u02c8\u0001\u0000\u0000\u0000"+
"\u008a\u02cc\u0001\u0000\u0000\u0000\u008c\u02dc\u0001\u0000\u0000\u0000"+
"\u008e\u0090\u0003\u0002\u0001\u0000\u008f\u0091\u0003\u0006\u0003\u0000"+
"\u0090\u008f\u0001\u0000\u0000\u0000\u0090\u0091\u0001\u0000\u0000\u0000"+
"\u0091\u0096\u0001\u0000\u0000\u0000\u0092\u0095\u0003\u0018\f\u0000\u0093"+
"\u0095\u0003\u0082A\u0000\u0094\u0092\u0001\u0000\u0000\u0000\u0094\u0093"+
"\u0001\u0000\u0000\u0000\u0095\u0098\u0001\u0000\u0000\u0000\u0096\u0094"+
"\u0001\u0000\u0000\u0000\u0096\u0097\u0001\u0000\u0000\u0000\u0097\u0001"+
"\u0001\u0000\u0000\u0000\u0098\u0096\u0001\u0000\u0000\u0000\u0099\u009b"+
"\u0003\u0004\u0002\u0000\u009a\u0099\u0001\u0000\u0000\u0000\u009b\u009e"+
"\u0001\u0000\u0000\u0000\u009c\u009a\u0001\u0000\u0000\u0000\u009c\u009d"+
"\u0001\u0000\u0000\u0000\u009d\u0003\u0001\u0000\u0000\u0000\u009e\u009c"+
"\u0001\u0000\u0000\u0000\u009f\u00a0\u0007\u0000\u0000\u0000\u00a0\u00a1"+
"\u0005B\u0000\u0000\u00a1\u00a2\u0005?\u0000\u0000\u00a2\u0005\u0001\u0000"+
"\u0000\u0000\u00a3\u00a5\u0003\b\u0004\u0000\u00a4\u00a3\u0001\u0000\u0000"+
"\u0000\u00a5\u00a6\u0001\u0000\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000"+
"\u0000\u00a6\u00a7\u0001\u0000\u0000\u0000\u00a7\u0007\u0001\u0000\u0000"+
"\u0000\u00a8\u00aa\u0003\n\u0005\u0000\u00a9\u00a8\u0001\u0000\u0000\u0000"+
"\u00aa\u00ad\u0001\u0000\u0000\u0000\u00ab\u00a9\u0001\u0000\u0000\u0000"+
"\u00ab\u00ac\u0001\u0000\u0000\u0000\u00ac\u00ae\u0001\u0000\u0000\u0000"+
"\u00ad\u00ab\u0001\u0000\u0000\u0000\u00ae\u00af\u0007\u0001\u0000\u0000"+
"\u00af\u00b8\u0005K\u0000\u0000\u00b0\u00b4\u0005\u0005\u0000\u0000\u00b1"+
"\u00b3\u0003\u0012\t\u0000\u00b2\u00b1\u0001\u0000\u0000\u0000\u00b3\u00b6"+
"\u0001\u0000\u0000\u0000\u00b4\u00b2\u0001\u0000\u0000\u0000\u00b4\u00b5"+
"\u0001\u0000\u0000\u0000\u00b5\u00b7\u0001\u0000\u0000\u0000\u00b6\u00b4"+
"\u0001\u0000\u0000\u0000\u00b7\u00b9\u0005\u0006\u0000\u0000\u00b8\u00b0"+
"\u0001\u0000\u0000\u0000\u00b8\u00b9\u0001\u0000\u0000\u0000\u00b9\t\u0001"+
"\u0000\u0000\u0000\u00ba\u00bf\u0005E\u0000\u0000\u00bb\u00bc\u0005\u0007"+
"\u0000\u0000\u00bc\u00bd\u0003\f\u0006\u0000\u00bd\u00be\u0005\b\u0000"+
"\u0000\u00be\u00c0\u0001\u0000\u0000\u0000\u00bf\u00bb\u0001\u0000\u0000"+
"\u0000\u00bf\u00c0\u0001\u0000\u0000\u0000\u00c0\u000b\u0001\u0000\u0000"+
"\u0000\u00c1\u00cf\u0003\u000e\u0007\u0000\u00c2\u00c3\u0005K\u0000\u0000"+
"\u00c3\u00c4\u0005\t\u0000\u0000\u00c4\u00cb\u0003\u000e\u0007\u0000\u00c5"+
"\u00c6\u0005\n\u0000\u0000\u00c6\u00c7\u0005K\u0000\u0000\u00c7\u00c8"+
"\u0005\t\u0000\u0000\u00c8\u00ca\u0003\u000e\u0007\u0000\u00c9\u00c5\u0001"+
"\u0000\u0000\u0000\u00ca\u00cd\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001"+
"\u0000\u0000\u0000\u00cb\u00cc\u0001\u0000\u0000\u0000\u00cc\u00cf\u0001"+
"\u0000\u0000\u0000\u00cd\u00cb\u0001\u0000\u0000\u0000\u00ce\u00c1\u0001"+
"\u0000\u0000\u0000\u00ce\u00c2\u0001\u0000\u0000\u0000\u00cf\r\u0001\u0000"+
"\u0000\u0000\u00d0\u00dd\u0003\u0010\b\u0000\u00d1\u00d2\u0005\u0005\u0000"+
"\u0000\u00d2\u00d7\u0003\u0010\b\u0000\u00d3\u00d4\u0005\n\u0000\u0000"+
"\u00d4\u00d6\u0003\u0010\b\u0000\u00d5\u00d3\u0001\u0000\u0000\u0000\u00d6"+
"\u00d9\u0001\u0000\u0000\u0000\u00d7\u00d5\u0001\u0000\u0000\u0000\u00d7"+
"\u00d8\u0001\u0000\u0000\u0000\u00d8\u00da\u0001\u0000\u0000\u0000\u00d9"+
"\u00d7\u0001\u0000\u0000\u0000\u00da\u00db\u0005\u0006\u0000\u0000\u00db"+
"\u00dd\u0001\u0000\u0000\u0000\u00dc\u00d0\u0001\u0000\u0000\u0000\u00dc"+
"\u00d1\u0001\u0000\u0000\u0000\u00dd\u000f\u0001\u0000\u0000\u0000\u00de"+
"\u00e5\u0005K\u0000\u0000\u00df\u00e5\u0005L\u0000\u0000\u00e0\u00e5\u0005"+
"M\u0000\u0000\u00e1\u00e5\u0003r9\u0000\u00e2\u00e5\u0003t:\u0000\u00e3"+
"\u00e5\u0003v;\u0000\u00e4\u00de\u0001\u0000\u0000\u0000\u00e4\u00df\u0001"+
"\u0000\u0000\u0000\u00e4\u00e0\u0001\u0000\u0000\u0000\u00e4\u00e1\u0001"+
"\u0000\u0000\u0000\u00e4\u00e2\u0001\u0000\u0000\u0000\u00e4\u00e3\u0001"+
"\u0000\u0000\u0000\u00e5\u0011\u0001\u0000\u0000\u0000\u00e6\u00e7\u0003"+
"\u0014\n\u0000\u00e7\u00e8\u0005K\u0000\u0000\u00e8\u00e9\u0005\u0007"+
"\u0000\u0000\u00e9\u00ec\u0005\b\u0000\u0000\u00ea\u00eb\u0005\u000b\u0000"+
"\u0000\u00eb\u00ed\u0003\u0016\u000b\u0000\u00ec\u00ea\u0001\u0000\u0000"+
"\u0000\u00ec\u00ed\u0001\u0000\u0000\u0000\u00ed\u00ee\u0001\u0000\u0000"+
"\u0000\u00ee\u00ef\u0005\f\u0000\u0000\u00ef\u0013\u0001\u0000\u0000\u0000"+
"\u00f0\u00f2\u0005K\u0000\u0000\u00f1\u00f3\u0005\r\u0000\u0000\u00f2"+
"\u00f1\u0001\u0000\u0000\u0000\u00f2\u00f3\u0001\u0000\u0000\u0000\u00f3"+
"\u0015\u0001\u0000\u0000\u0000\u00f4\u00fa\u0005K\u0000\u0000\u00f5\u00fa"+
"\u0005L\u0000\u0000\u00f6\u00fa\u0005M\u0000\u0000\u00f7\u00fa\u0003t"+
":\u0000\u00f8\u00fa\u0003v;\u0000\u00f9\u00f4\u0001\u0000\u0000\u0000"+
"\u00f9\u00f5\u0001\u0000\u0000\u0000\u00f9\u00f6\u0001\u0000\u0000\u0000"+
"\u00f9\u00f7\u0001\u0000\u0000\u0000\u00f9\u00f8\u0001\u0000\u0000\u0000"+
"\u00fa\u0017\u0001\u0000\u0000\u0000\u00fb\u00fd\u00034\u001a\u0000\u00fc"+
"\u00fb\u0001\u0000\u0000\u0000\u00fd\u0100\u0001\u0000\u0000\u0000\u00fe"+
"\u00fc\u0001\u0000\u0000\u0000\u00fe\u00ff\u0001\u0000\u0000\u0000\u00ff"+
"\u0104\u0001\u0000\u0000\u0000\u0100\u00fe\u0001\u0000\u0000\u0000\u0101"+
"\u0105\u0003\u001a\r\u0000\u0102\u0105\u0003\u001c\u000e\u0000\u0103\u0105"+
"\u0003\u001e\u000f\u0000\u0104\u0101\u0001\u0000\u0000\u0000\u0104\u0102"+
"\u0001\u0000\u0000\u0000\u0104\u0103\u0001\u0000\u0000\u0000\u0105\u0019"+
"\u0001\u0000\u0000\u0000\u0106\u0107\u0007\u0002\u0000\u0000\u0107\u0108"+
"\u0003 \u0010\u0000\u0108\u0112\u0003.\u0017\u0000\u0109\u010a\u0007\u0003"+
"\u0000\u0000\u010a\u010f\u0003&\u0013\u0000\u010b\u010c\u0005\n\u0000"+
"\u0000\u010c\u010e\u0003&\u0013\u0000\u010d\u010b\u0001\u0000\u0000\u0000"+
"\u010e\u0111\u0001\u0000\u0000\u0000\u010f\u010d\u0001\u0000\u0000\u0000"+
"\u010f\u0110\u0001\u0000\u0000\u0000\u0110\u0113\u0001\u0000\u0000\u0000"+
"\u0111\u010f\u0001\u0000\u0000\u0000\u0112\u0109\u0001\u0000\u0000\u0000"+
"\u0112\u0113\u0001\u0000\u0000\u0000\u0113\u0114\u0001\u0000\u0000\u0000"+
"\u0114\u0116\u0005\u0005\u0000\u0000\u0115\u0117\u0003\"\u0011\u0000\u0116"+
"\u0115\u0001\u0000\u0000\u0000\u0116\u0117\u0001\u0000\u0000\u0000\u0117"+
"\u0119\u0001\u0000\u0000\u0000\u0118\u011a\u0003*\u0015\u0000\u0119\u0118"+
"\u0001\u0000\u0000\u0000\u0119\u011a\u0001\u0000\u0000\u0000\u011a\u011c"+
"\u0001\u0000\u0000\u0000\u011b\u011d\u00030\u0018\u0000\u011c\u011b\u0001"+
"\u0000\u0000\u0000\u011c\u011d\u0001\u0000\u0000\u0000\u011d\u0120\u0001"+
"\u0000\u0000\u0000\u011e\u0121\u0003L&\u0000\u011f\u0121\u0003J%\u0000"+
"\u0120\u011e\u0001\u0000\u0000\u0000\u0120\u011f\u0001\u0000\u0000\u0000"+
"\u0120\u0121\u0001\u0000\u0000\u0000\u0121\u0123\u0001\u0000\u0000\u0000"+
"\u0122\u0124\u0003N\'\u0000\u0123\u0122\u0001\u0000\u0000\u0000\u0123"+
"\u0124\u0001\u0000\u0000\u0000\u0124\u0126\u0001\u0000\u0000\u0000\u0125"+
"\u0127\u0003\u0080@\u0000\u0126\u0125\u0001\u0000\u0000\u0000\u0126\u0127"+
"\u0001\u0000\u0000\u0000\u0127\u0128\u0001\u0000\u0000\u0000\u0128\u0129"+
"\u0005\u0006\u0000\u0000\u0129\u001b\u0001\u0000\u0000\u0000\u012a\u012b"+
"\u0005\u0013\u0000\u0000\u012b\u012c\u0005\u000e\u0000\u0000\u012c\u012d"+
"\u0003 \u0010\u0000\u012d\u012e\u0003.\u0017\u0000\u012e\u012f\u0005\u0005"+
"\u0000\u0000\u012f\u0130\u00030\u0018\u0000\u0130\u0131\u0005\u0006\u0000"+
"\u0000\u0131\u001d\u0001\u0000\u0000\u0000\u0132\u0133\u0007\u0004\u0000"+
"\u0000\u0133\u0134\u0007\u0002\u0000\u0000\u0134\u0135\u0003 \u0010\u0000"+
"\u0135\u0136\u0003.\u0017\u0000\u0136\u0138\u0005\u0005\u0000\u0000\u0137"+
"\u0139\u0003\"\u0011\u0000\u0138\u0137\u0001\u0000\u0000\u0000\u0138\u0139"+
"\u0001\u0000\u0000\u0000\u0139\u013a\u0001\u0000\u0000\u0000\u013a\u013b"+
"\u00030\u0018\u0000\u013b\u013c\u0005\u0006\u0000\u0000\u013c\u001f\u0001"+
"\u0000\u0000\u0000\u013d\u013e\u0003P(\u0000\u013e!\u0001\u0000\u0000"+
"\u0000\u013f\u0140\u0007\u0005\u0000\u0000\u0140\u0141\u0005\t\u0000\u0000"+
"\u0141\u0143\u0005\u0005\u0000\u0000\u0142\u0144\u0003$\u0012\u0000\u0143"+
"\u0142\u0001\u0000\u0000\u0000\u0144\u0145\u0001\u0000\u0000\u0000\u0145"+
"\u0143\u0001\u0000\u0000\u0000\u0145\u0146\u0001\u0000\u0000\u0000\u0146"+
"\u0147\u0001\u0000\u0000\u0000\u0147\u0148\u0005\u0006\u0000\u0000\u0148"+
"#\u0001\u0000\u0000\u0000\u0149\u014a\u0003F#\u0000\u014a\u014b\u0005"+
"I\u0000\u0000\u014b\u014c\u0005\u0019\u0000\u0000\u014c\u0151\u0003x<"+
"\u0000\u014d\u014e\u0005\n\u0000\u0000\u014e\u0150\u0003x<\u0000\u014f"+
"\u014d\u0001\u0000\u0000\u0000\u0150\u0153\u0001\u0000\u0000\u0000\u0151"+
"\u014f\u0001\u0000\u0000\u0000\u0151\u0152\u0001\u0000\u0000\u0000\u0152"+
"\u0154\u0001\u0000\u0000\u0000\u0153\u0151\u0001\u0000\u0000\u0000\u0154"+
"\u0155\u0005\u001a\u0000\u0000\u0155\u0156\u0005\u001b\u0000\u0000\u0156"+
"%\u0001\u0000\u0000\u0000\u0157\u0158\u0005K\u0000\u0000\u0158\u015b\u0005"+
"\u0007\u0000\u0000\u0159\u015c\u0005K\u0000\u0000\u015a\u015c\u0003(\u0014"+
"\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015b\u015a\u0001\u0000\u0000"+
"\u0000\u015c\u0164\u0001\u0000\u0000\u0000\u015d\u0160\u0005\n\u0000\u0000"+
"\u015e\u0161\u0005K\u0000\u0000\u015f\u0161\u0003(\u0014\u0000\u0160\u015e"+
"\u0001\u0000\u0000\u0000\u0160\u015f\u0001\u0000\u0000\u0000\u0161\u0163"+
"\u0001\u0000\u0000\u0000\u0162\u015d\u0001\u0000\u0000\u0000\u0163\u0166"+
"\u0001\u0000\u0000\u0000\u0164\u0162\u0001\u0000\u0000\u0000\u0164\u0165"+
"\u0001\u0000\u0000\u0000\u0165\u0167\u0001\u0000\u0000\u0000\u0166\u0164"+
"\u0001\u0000\u0000\u0000\u0167\u0168\u0005\b\u0000\u0000\u0168\u0169\u0007"+
"\u0006\u0000\u0000\u0169\u016a\u0005K\u0000\u0000\u016a\'\u0001\u0000"+
"\u0000\u0000\u016b\u016c\u0005K\u0000\u0000\u016c\u016f\u0005\t\u0000"+
"\u0000\u016d\u0170\u0005K\u0000\u0000\u016e\u0170\u0005L\u0000\u0000\u016f"+
"\u016d\u0001\u0000\u0000\u0000\u016f\u016e\u0001\u0000\u0000\u0000\u0170"+
")\u0001\u0000\u0000\u0000\u0171\u0172\u0007\u0007\u0000\u0000\u0172\u0173"+
"\u0005\t\u0000\u0000\u0173\u0175\u0005\u0005\u0000\u0000\u0174\u0176\u0003"+
",\u0016\u0000\u0175\u0174\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000"+
"\u0000\u0000\u0177\u0175\u0001\u0000\u0000\u0000\u0177\u0178\u0001\u0000"+
"\u0000\u0000\u0178\u0179\u0001\u0000\u0000\u0000\u0179\u017a\u0005\u0006"+
"\u0000\u0000\u017a+\u0001\u0000\u0000\u0000\u017b\u017c\u0005K\u0000\u0000"+
"\u017c\u017d\u0003F#\u0000\u017d\u017e\u0005K\u0000\u0000\u017e-\u0001"+
"\u0000\u0000\u0000\u017f\u0180\u00059\u0000\u0000\u0180/\u0001\u0000\u0000"+
"\u0000\u0181\u0182\u0007\b\u0000\u0000\u0182\u0183\u0005\t\u0000\u0000"+
"\u0183\u0185\u0005\u0005\u0000\u0000\u0184\u0186\u00032\u0019\u0000\u0185"+
"\u0184\u0001\u0000\u0000\u0000\u0186\u0187\u0001\u0000\u0000\u0000\u0187"+
"\u0185\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000\u0000\u0000\u0188"+
"\u0189\u0001\u0000\u0000\u0000\u0189\u018a\u0005\u0006\u0000\u0000\u018a"+
"1\u0001\u0000\u0000\u0000\u018b\u018d\u00034\u001a\u0000\u018c\u018b\u0001"+
"\u0000\u0000\u0000\u018d\u0190\u0001\u0000\u0000\u0000\u018e\u018c\u0001"+
"\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000\u0000\u018f\u0191\u0001"+
"\u0000\u0000\u0000\u0190\u018e\u0001\u0000\u0000\u0000\u0191\u0192\u0005"+
"K\u0000\u0000\u0192\u0198\u00036\u001b\u0000\u0193\u0195\u0003F#\u0000"+
"\u0194\u0196\u0005\u001b\u0000\u0000\u0195\u0194\u0001\u0000\u0000\u0000"+
"\u0195\u0196\u0001\u0000\u0000\u0000\u0196\u0199\u0001\u0000\u0000\u0000"+
"\u0197\u0199\u0005\u001b\u0000\u0000\u0198\u0193\u0001\u0000\u0000\u0000"+
"\u0198\u0197\u0001\u0000\u0000\u0000\u01993\u0001\u0000\u0000\u0000\u019a"+
"\u019f\u0005E\u0000\u0000\u019b\u019c\u0005\u0007\u0000\u0000\u019c\u019d"+
"\u0003\f\u0006\u0000\u019d\u019e\u0005\b\u0000\u0000\u019e\u01a0\u0001"+
"\u0000\u0000\u0000\u019f\u019b\u0001\u0000\u0000\u0000\u019f\u01a0\u0001"+
"\u0000\u0000\u0000\u01a05\u0001\u0000\u0000\u0000\u01a1\u01a3\u0005\""+
"\u0000\u0000\u01a2\u01a4\u00038\u001c\u0000\u01a3\u01a2\u0001\u0000\u0000"+
"\u0000\u01a3\u01a4\u0001\u0000\u0000\u0000\u01a4\u01b9\u0001\u0000\u0000"+
"\u0000\u01a5\u01a6\u0005#\u0000\u0000\u01a6\u01a7\u0005$\u0000\u0000\u01a7"+
"\u01a9\u0003t:\u0000\u01a8\u01aa\u00038\u001c\u0000\u01a9\u01a8\u0001"+
"\u0000\u0000\u0000\u01a9\u01aa\u0001\u0000\u0000\u0000\u01aa\u01b9\u0001"+
"\u0000\u0000\u0000\u01ab\u01ac\u0005#\u0000\u0000\u01ac\u01ae\u0005E\u0000"+
"\u0000\u01ad\u01af\u00038\u001c\u0000\u01ae\u01ad\u0001\u0000\u0000\u0000"+
"\u01ae\u01af\u0001\u0000\u0000\u0000\u01af\u01b9\u0001\u0000\u0000\u0000"+
"\u01b0\u01b2\u0005#\u0000\u0000\u01b1\u01b3\u00038\u001c\u0000\u01b2\u01b1"+
"\u0001\u0000\u0000\u0000\u01b2\u01b3\u0001\u0000\u0000\u0000\u01b3\u01b9"+
"\u0001\u0000\u0000\u0000\u01b4\u01b6\u0005J\u0000\u0000\u01b5\u01b7\u0003"+
"8\u001c\u0000\u01b6\u01b5\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000"+
"\u0000\u0000\u01b7\u01b9\u0001\u0000\u0000\u0000\u01b8\u01a1\u0001\u0000"+
"\u0000\u0000\u01b8\u01a5\u0001\u0000\u0000\u0000\u01b8\u01ab\u0001\u0000"+
"\u0000\u0000\u01b8\u01b0\u0001\u0000\u0000\u0000\u01b8\u01b4\u0001\u0000"+
"\u0000\u0000\u01b97\u0001\u0000\u0000\u0000\u01ba\u01bb\u0005\u0007\u0000"+
"\u0000\u01bb\u01c0\u0003:\u001d\u0000\u01bc\u01bd\u0005\n\u0000\u0000"+
"\u01bd\u01bf\u0003:\u001d\u0000\u01be\u01bc\u0001\u0000\u0000\u0000\u01bf"+
"\u01c2\u0001\u0000\u0000\u0000\u01c0\u01be\u0001\u0000\u0000\u0000\u01c0"+
"\u01c1\u0001\u0000\u0000\u0000\u01c1\u01c3\u0001\u0000\u0000\u0000\u01c2"+
"\u01c0\u0001\u0000\u0000\u0000\u01c3\u01c4\u0005\b\u0000\u0000\u01c49"+
"\u0001\u0000\u0000\u0000\u01c5\u01c7\u0003t:\u0000\u01c6\u01c8\u0003<"+
"\u001e\u0000\u01c7\u01c6\u0001\u0000\u0000\u0000\u01c7\u01c8\u0001\u0000"+
"\u0000\u0000\u01c8\u01ce\u0001\u0000\u0000\u0000\u01c9\u01cb\u0005J\u0000"+
"\u0000\u01ca\u01cc\u0003<\u001e\u0000\u01cb\u01ca\u0001\u0000\u0000\u0000"+
"\u01cb\u01cc\u0001\u0000\u0000\u0000\u01cc\u01ce\u0001\u0000\u0000\u0000"+
"\u01cd\u01c5\u0001\u0000\u0000\u0000\u01cd\u01c9\u0001\u0000\u0000\u0000"+
"\u01ce;\u0001\u0000\u0000\u0000\u01cf\u01d8\u0005\u0007\u0000\u0000\u01d0"+
"\u01d5\u0003>\u001f\u0000\u01d1\u01d2\u0005\n\u0000\u0000\u01d2\u01d4"+
"\u0003>\u001f\u0000\u01d3\u01d1\u0001\u0000\u0000\u0000\u01d4\u01d7\u0001"+
"\u0000\u0000\u0000\u01d5\u01d3\u0001\u0000\u0000\u0000\u01d5\u01d6\u0001"+
"\u0000\u0000\u0000\u01d6\u01d9\u0001\u0000\u0000\u0000\u01d7\u01d5\u0001"+
"\u0000\u0000\u0000\u01d8\u01d0\u0001\u0000\u0000\u0000\u01d8\u01d9\u0001"+
"\u0000\u0000\u0000\u01d9\u01da\u0001\u0000\u0000\u0000\u01da\u01db\u0005"+
"\b\u0000\u0000\u01db=\u0001\u0000\u0000\u0000\u01dc\u01e1\u0003v;\u0000"+
"\u01dd\u01e1\u0003t:\u0000\u01de\u01e1\u0003@ \u0000\u01df\u01e1\u0003"+
"B!\u0000\u01e0\u01dc\u0001\u0000\u0000\u0000\u01e0\u01dd\u0001\u0000\u0000"+
"\u0000\u01e0\u01de\u0001\u0000\u0000\u0000\u01e0\u01df\u0001\u0000\u0000"+
"\u0000\u01e1?\u0001\u0000\u0000\u0000\u01e2\u01e3\u0005A\u0000\u0000\u01e3"+
"A\u0001\u0000\u0000\u0000\u01e4\u01ed\u0005\u0005\u0000\u0000\u01e5\u01ea"+
"\u0003D\"\u0000\u01e6\u01e7\u0005\n\u0000\u0000\u01e7\u01e9\u0003D\"\u0000"+
"\u01e8\u01e6\u0001\u0000\u0000\u0000\u01e9\u01ec\u0001\u0000\u0000\u0000"+
"\u01ea\u01e8\u0001\u0000\u0000\u0000\u01ea\u01eb\u0001\u0000\u0000\u0000"+
"\u01eb\u01ee\u0001\u0000\u0000\u0000\u01ec\u01ea\u0001\u0000\u0000\u0000"+
"\u01ed\u01e5\u0001\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000\u0000"+
"\u01ee\u01ef\u0001\u0000\u0000\u0000\u01ef\u01f0\u0005\u0006\u0000\u0000"+
"\u01f0C\u0001\u0000\u0000\u0000\u01f1\u01f2\u0005K\u0000\u0000\u01f2\u01f3"+
"\u0005\t\u0000\u0000\u01f3\u01fb\u0003v;\u0000\u01f4\u01f5\u0005K\u0000"+
"\u0000\u01f5\u01f6\u0005\t\u0000\u0000\u01f6\u01fb\u0003t:\u0000\u01f7"+
"\u01f8\u0005K\u0000\u0000\u01f8\u01f9\u0005\t\u0000\u0000\u01f9\u01fb"+
"\u0003@ \u0000\u01fa\u01f1\u0001\u0000\u0000\u0000\u01fa\u01f4\u0001\u0000"+
"\u0000\u0000\u01fa\u01f7\u0001\u0000\u0000\u0000\u01fbE\u0001\u0000\u0000"+
"\u0000\u01fc\u0201\u0003H$\u0000\u01fd\u01fe\u0005%\u0000\u0000\u01fe"+
"\u0200\u0003H$\u0000\u01ff\u01fd\u0001\u0000\u0000\u0000\u0200\u0203\u0001"+
"\u0000\u0000\u0000\u0201\u01ff\u0001\u0000\u0000\u0000\u0201\u0202\u0001"+
"\u0000\u0000\u0000\u0202\u0206\u0001\u0000\u0000\u0000\u0203\u0201\u0001"+
"\u0000\u0000\u0000\u0204\u0206\u0005J\u0000\u0000\u0205\u01fc\u0001\u0000"+
"\u0000\u0000\u0205\u0204\u0001\u0000\u0000\u0000\u0206G\u0001\u0000\u0000"+
"\u0000\u0207\u020b\u0005K\u0000\u0000\u0208\u0209\u0005\u0019\u0000\u0000"+
"\u0209\u020a\u0005L\u0000\u0000\u020a\u020c\u0005\u001a\u0000\u0000\u020b"+
"\u0208\u0001\u0000\u0000\u0000\u020b\u020c\u0001\u0000\u0000\u0000\u020c"+
"I\u0001\u0000\u0000\u0000\u020d\u020e\u0007\t\u0000\u0000\u020e\u020f"+
"\u0005\t\u0000\u0000\u020f\u0210\u0003R)\u0000\u0210K\u0001\u0000\u0000"+
"\u0000\u0211\u0212\u0007\n\u0000\u0000\u0212\u0213\u0005\t\u0000\u0000"+
"\u0213\u0214\u0003R)\u0000\u0214M\u0001\u0000\u0000\u0000\u0215\u0216"+
"\u0007\u000b\u0000\u0000\u0216\u0217\u0005\t\u0000\u0000\u0217\u0218\u0003"+
"R)\u0000\u0218O\u0001\u0000\u0000\u0000\u0219\u021e\u0005K\u0000\u0000"+
"\u021a\u021b\u0005\u001b\u0000\u0000\u021b\u021d\u0005K\u0000\u0000\u021c"+
"\u021a\u0001\u0000\u0000\u0000\u021d\u0220\u0001\u0000\u0000\u0000\u021e"+
"\u021c\u0001\u0000\u0000\u0000\u021e\u021f\u0001\u0000\u0000\u0000\u021f"+
"Q\u0001\u0000\u0000\u0000\u0220\u021e\u0001\u0000\u0000\u0000\u0221\u0223"+
"\u0005\u0005\u0000\u0000\u0222\u0224\u0003T*\u0000\u0223\u0222\u0001\u0000"+
"\u0000\u0000\u0224\u0225\u0001\u0000\u0000\u0000\u0225\u0223\u0001\u0000"+
"\u0000\u0000\u0225\u0226\u0001\u0000\u0000\u0000\u0226\u0227\u0001\u0000"+
"\u0000\u0000\u0227\u0228\u0005\u0006\u0000\u0000\u0228S\u0001\u0000\u0000"+
"\u0000\u0229\u022b\u00034\u001a\u0000\u022a\u0229\u0001\u0000\u0000\u0000"+
"\u022b\u022e\u0001\u0000\u0000\u0000\u022c\u022a\u0001\u0000\u0000\u0000"+
"\u022c\u022d\u0001\u0000\u0000\u0000\u022d\u022f\u0001\u0000\u0000\u0000"+
"\u022e\u022c\u0001\u0000\u0000\u0000\u022f\u0232\u0003X,\u0000\u0230\u0232"+
"\u0003V+\u0000\u0231\u022c\u0001\u0000\u0000\u0000\u0231\u0230\u0001\u0000"+
"\u0000\u0000\u0232U\u0001\u0000\u0000\u0000\u0233\u0234\u0007\f\u0000"+
"\u0000\u0234\u0236\u0005\u0005\u0000\u0000\u0235\u0237\u0003T*\u0000\u0236"+
"\u0235\u0001\u0000\u0000\u0000\u0237\u0238\u0001\u0000\u0000\u0000\u0238"+
"\u0236\u0001\u0000\u0000\u0000\u0238\u0239\u0001\u0000\u0000\u0000\u0239"+
"\u023a\u0001\u0000\u0000\u0000\u023a\u023b\u0005\u0006\u0000\u0000\u023b"+
"W\u0001\u0000\u0000\u0000\u023c\u023d\u0003Z-\u0000\u023d\u023e\u0003"+
"\\.\u0000\u023e\u023f\u0003^/\u0000\u023f\u0240\u0005\u001b\u0000\u0000"+
"\u0240Y\u0001\u0000\u0000\u0000\u0241\u0247\u0003p8\u0000\u0242\u0247"+
"\u0003t:\u0000\u0243\u0247\u0003z=\u0000\u0244\u0247\u0003r9\u0000\u0245"+
"\u0247\u0005J\u0000\u0000\u0246\u0241\u0001\u0000\u0000\u0000\u0246\u0242"+
"\u0001\u0000\u0000\u0000\u0246\u0243\u0001\u0000\u0000\u0000\u0246\u0244"+
"\u0001\u0000\u0000\u0000\u0246\u0245\u0001\u0000\u0000\u0000\u0247[\u0001"+
"\u0000\u0000\u0000\u0248\u024f\u0003p8\u0000\u0249\u024f\u0003t:\u0000"+
"\u024a\u024f\u0003~?\u0000\u024b\u024f\u0003`0\u0000\u024c\u024f\u0003"+
"r9\u0000\u024d\u024f\u0005J\u0000\u0000\u024e\u0248\u0001\u0000\u0000"+
"\u0000\u024e\u0249\u0001\u0000\u0000\u0000\u024e\u024a\u0001\u0000\u0000"+
"\u0000\u024e\u024b\u0001\u0000\u0000\u0000\u024e\u024c\u0001\u0000\u0000"+
"\u0000\u024e\u024d\u0001\u0000\u0000\u0000\u024f]\u0001\u0000\u0000\u0000"+
"\u0250\u0257\u0003p8\u0000\u0251\u0257\u0003t:\u0000\u0252\u0257\u0003"+
"v;\u0000\u0253\u0257\u0003z=\u0000\u0254\u0257\u0003r9\u0000\u0255\u0257"+
"\u0005J\u0000\u0000\u0256\u0250\u0001\u0000\u0000\u0000\u0256\u0251\u0001"+
"\u0000\u0000\u0000\u0256\u0252\u0001\u0000\u0000\u0000\u0256\u0253\u0001"+
"\u0000\u0000\u0000\u0256\u0254\u0001\u0000\u0000\u0000\u0256\u0255\u0001"+
"\u0000\u0000\u0000\u0257_\u0001\u0000\u0000\u0000\u0258\u0259\u0003b1"+
"\u0000\u0259a\u0001\u0000\u0000\u0000\u025a\u025f\u0003d2\u0000\u025b"+
"\u025c\u0005.\u0000\u0000\u025c\u025e\u0003d2\u0000\u025d\u025b\u0001"+
"\u0000\u0000\u0000\u025e\u0261\u0001\u0000\u0000\u0000\u025f\u025d\u0001"+
"\u0000\u0000\u0000\u025f\u0260\u0001\u0000\u0000\u0000\u0260c\u0001\u0000"+
"\u0000\u0000\u0261\u025f\u0001\u0000\u0000\u0000\u0262\u0267\u0003h4\u0000"+
"\u0263\u0264\u0005%\u0000\u0000\u0264\u0266\u0003h4\u0000\u0265\u0263"+
"\u0001\u0000\u0000\u0000\u0266\u0269\u0001\u0000\u0000\u0000\u0267\u0265"+
"\u0001\u0000\u0000\u0000\u0267\u0268\u0001\u0000\u0000\u0000\u0268e\u0001"+
"\u0000\u0000\u0000\u0269\u0267\u0001\u0000\u0000\u0000\u026a\u026c\u0003"+
"j5\u0000\u026b\u026d\u0005:\u0000\u0000\u026c\u026b\u0001\u0000\u0000"+
"\u0000\u026c\u026d\u0001\u0000\u0000\u0000\u026dg\u0001\u0000\u0000\u0000"+
"\u026e\u0272\u0003f3\u0000\u026f\u0270\u0005/\u0000\u0000\u0270\u0272"+
"\u0003f3\u0000\u0271\u026e\u0001\u0000\u0000\u0000\u0271\u026f\u0001\u0000"+
"\u0000\u0000\u0272i\u0001\u0000\u0000\u0000\u0273\u027c\u0003t:\u0000"+
"\u0274\u027c\u00050\u0000\u0000\u0275\u0276\u00051\u0000\u0000\u0276\u027c"+
"\u0003l6\u0000\u0277\u0278\u0005\u0007\u0000\u0000\u0278\u0279\u0003b"+
"1\u0000\u0279\u027a\u0005\b\u0000\u0000\u027a\u027c\u0001\u0000\u0000"+
"\u0000\u027b\u0273\u0001\u0000\u0000\u0000\u027b\u0274\u0001\u0000\u0000"+
"\u0000\u027b\u0275\u0001\u0000\u0000\u0000\u027b\u0277\u0001\u0000\u0000"+
"\u0000\u027ck\u0001\u0000\u0000\u0000\u027d\u028a\u0003n7\u0000\u027e"+
"\u027f\u0005\u0007\u0000\u0000\u027f\u0284\u0003n7\u0000\u0280\u0281\u0005"+
".\u0000\u0000\u0281\u0283\u0003n7\u0000\u0282\u0280\u0001\u0000\u0000"+
"\u0000\u0283\u0286\u0001\u0000\u0000\u0000\u0284\u0282\u0001\u0000\u0000"+
"\u0000\u0284\u0285\u0001\u0000\u0000\u0000\u0285\u0287\u0001\u0000\u0000"+
"\u0000\u0286\u0284\u0001\u0000\u0000\u0000\u0287\u0288\u0005\b\u0000\u0000"+
"\u0288\u028a\u0001\u0000\u0000\u0000\u0289\u027d\u0001\u0000\u0000\u0000"+
"\u0289\u027e\u0001\u0000\u0000\u0000\u028am\u0001\u0000\u0000\u0000\u028b"+
"\u0293\u0003t:\u0000\u028c\u0293\u00050\u0000\u0000\u028d\u0290\u0005"+
"/\u0000\u0000\u028e\u0291\u0003t:\u0000\u028f\u0291\u00050\u0000\u0000"+
"\u0290\u028e\u0001\u0000\u0000\u0000\u0290\u028f\u0001\u0000\u0000\u0000"+
"\u0291\u0293\u0001\u0000\u0000\u0000\u0292\u028b\u0001\u0000\u0000\u0000"+
"\u0292\u028c\u0001\u0000\u0000\u0000\u0292\u028d\u0001\u0000\u0000\u0000"+
"\u0293o\u0001\u0000\u0000\u0000\u0294\u0295\u0005@\u0000\u0000\u0295q"+
"\u0001\u0000\u0000\u0000\u0296\u029e\u0005A\u0000\u0000\u0297\u0298\u0005"+
"A\u0000\u0000\u0298\u0299\u0005\u001b\u0000\u0000\u0299\u029e\u0005K\u0000"+
"\u0000\u029a\u029b\u0005A\u0000\u0000\u029b\u029c\u00052\u0000\u0000\u029c"+
"\u029e\u0005K\u0000\u0000\u029d\u0296\u0001\u0000\u0000\u0000\u029d\u0297"+
"\u0001\u0000\u0000\u0000\u029d\u029a\u0001\u0000\u0000\u0000\u029es\u0001"+
"\u0000\u0000\u0000\u029f\u02a2\u0005?\u0000\u0000\u02a0\u02a2\u0003|>"+
"\u0000\u02a1\u029f\u0001\u0000\u0000\u0000\u02a1\u02a0\u0001\u0000\u0000"+
"\u0000\u02a2u\u0001\u0000\u0000\u0000\u02a3\u02a7\u0003x<\u0000\u02a4"+
"\u02a8\u0005E\u0000\u0000\u02a5\u02a6\u0005$\u0000\u0000\u02a6\u02a8\u0003"+
"t:\u0000\u02a7\u02a4\u0001\u0000\u0000\u0000\u02a7\u02a5\u0001\u0000\u0000"+
"\u0000\u02a7\u02a8\u0001\u0000\u0000\u0000\u02a8w\u0001\u0000\u0000\u0000"+
"\u02a9\u02aa\u0007\r\u0000\u0000\u02aay\u0001\u0000\u0000\u0000\u02ab"+
"\u02ac\u0005D\u0000\u0000\u02ac{\u0001\u0000\u0000\u0000\u02ad\u02b0\u0005"+
"C\u0000\u0000\u02ae\u02b0\u0005B\u0000\u0000\u02af\u02ad\u0001\u0000\u0000"+
"\u0000\u02af\u02ae\u0001\u0000\u0000\u0000\u02b0}\u0001\u0000\u0000\u0000"+
"\u02b1\u02b2\u0007\u000e\u0000\u0000\u02b2\u007f\u0001\u0000\u0000\u0000"+
"\u02b3\u02b4\u0007\u000f\u0000\u0000\u02b4\u02b5\u0005\t\u0000\u0000\u02b5"+
"\u02b6\u0003R)\u0000\u02b6\u0081\u0001\u0000\u0000\u0000\u02b7\u02b8\u0007"+
"\u0010\u0000\u0000\u02b8\u02b9\u0003.\u0017\u0000\u02b9\u02ba\u0003\u0084"+
"B\u0000\u02ba\u02bb\u00058\u0000\u0000\u02bb\u02bc\u0003J%\u0000\u02bc"+
"\u0083\u0001\u0000\u0000\u0000\u02bd\u02be\u0003\u0086C\u0000\u02be\u0085"+
"\u0001\u0000\u0000\u0000\u02bf\u02c4\u0003\u0088D\u0000\u02c0\u02c1\u0005"+
".\u0000\u0000\u02c1\u02c3\u0003\u0088D\u0000\u02c2\u02c0\u0001\u0000\u0000"+
"\u0000\u02c3\u02c6\u0001\u0000\u0000\u0000\u02c4\u02c2\u0001\u0000\u0000"+
"\u0000\u02c4\u02c5\u0001\u0000\u0000\u0000\u02c5\u0087\u0001\u0000\u0000"+
"\u0000\u02c6\u02c4\u0001\u0000\u0000\u0000\u02c7\u02c9\u0003\u008aE\u0000"+
"\u02c8\u02c7\u0001\u0000\u0000\u0000\u02c9\u02ca\u0001\u0000\u0000\u0000"+
"\u02ca\u02c8\u0001\u0000\u0000\u0000\u02ca\u02cb\u0001\u0000\u0000\u0000"+
"\u02cb\u0089\u0001\u0000\u0000\u0000\u02cc\u02ce\u0003\u008cF\u0000\u02cd"+
"\u02cf\u0005:\u0000\u0000\u02ce\u02cd\u0001\u0000\u0000\u0000\u02ce\u02cf"+
"\u0001\u0000\u0000\u0000\u02cf\u008b\u0001\u0000\u0000\u0000\u02d0\u02d2"+
"\u0005\u0019\u0000\u0000\u02d1\u02d3\u0005L\u0000\u0000\u02d2\u02d1\u0001"+
"\u0000\u0000\u0000\u02d2\u02d3\u0001\u0000\u0000\u0000\u02d3\u02d4\u0001"+
"\u0000\u0000\u0000\u02d4\u02d5\u0005K\u0000\u0000\u02d5\u02d6\u0007\u0006"+
"\u0000\u0000\u02d6\u02d7\u0005K\u0000\u0000\u02d7\u02dd\u0005\u001a\u0000"+
"\u0000\u02d8\u02d9\u0005\u0007\u0000\u0000\u02d9\u02da\u0003\u0086C\u0000"+
"\u02da\u02db\u0005\b\u0000\u0000\u02db\u02dd\u0001\u0000\u0000\u0000\u02dc"+
"\u02d0\u0001\u0000\u0000\u0000\u02dc\u02d8\u0001\u0000\u0000\u0000\u02dd"+
"\u008d\u0001\u0000\u0000\u0000U\u0090\u0094\u0096\u009c\u00a6\u00ab\u00b4"+
"\u00b8\u00bf\u00cb\u00ce\u00d7\u00dc\u00e4\u00ec\u00f2\u00f9\u00fe\u0104"+
"\u010f\u0112\u0116\u0119\u011c\u0120\u0123\u0126\u0138\u0145\u0151\u015b"+
"\u0160\u0164\u016f\u0177\u0187\u018e\u0195\u0198\u019f\u01a3\u01a9\u01ae"+
"\u01b2\u01b6\u01b8\u01c0\u01c7\u01cb\u01cd\u01d5\u01d8\u01e0\u01ea\u01ed"+
"\u01fa\u0201\u0205\u020b\u021e\u0225\u022c\u0231\u0238\u0246\u024e\u0256"+
"\u025f\u0267\u026c\u0271\u027b\u0284\u0289\u0290\u0292\u029d\u02a1\u02a7"+
"\u02af\u02c4\u02ca\u02ce\u02d2\u02dc";
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);
}
}
}
