it.unibo.alchemist.model.internal.biochemistry.dsl.BiochemistrydslParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of alchemist-incarnation-biochemistry Show documentation
Show all versions of alchemist-incarnation-biochemistry Show documentation
Alchemist incarnation for biochemistry simulator
// Generated from it/unibo/alchemist/model/internal/biochemistry/dsl/Biochemistrydsl.g4 by ANTLR 4.13.2
package it.unibo.alchemist.model.biochemistry.dsl;
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", "this-escape"})
public class BiochemistrydslParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.2", 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, POSDOUBLE=19, LITERAL=20, WS=21, ErrorCharacter=22;
public static final int
RULE_reaction = 0, RULE_biochemicalReaction = 1, RULE_createJunction = 2,
RULE_junctionReaction = 3, RULE_javaConstructor = 4, RULE_javaClass = 5,
RULE_argList = 6, RULE_arg = 7, RULE_createJunctionLeft = 8, RULE_createJunctionRight = 9,
RULE_createJunctionJunction = 10, RULE_junctionReactionLeft = 11, RULE_junctionReactionRight = 12,
RULE_junctionReactionJunctionCondition = 13, RULE_junctionReactionJunction = 14,
RULE_biochemicalReactionLeft = 15, RULE_biochemicalReactionRight = 16,
RULE_customConditions = 17, RULE_customReactionType = 18, RULE_biochemicalReactionLeftContext = 19,
RULE_biochemicalReactionLeftInCellContext = 20, RULE_biochemicalReactionLeftInEnvContext = 21,
RULE_biochemicalReactionLeftInNeighborContext = 22, RULE_biochemicalReactionRightContext = 23,
RULE_biochemicalReactionRightInCellContext = 24, RULE_biochemicalReactionRightInEnvContext = 25,
RULE_biochemicalReactionRightInNeighborContext = 26, RULE_biochemicalReactionRightElem = 27,
RULE_customCondition = 28, RULE_junction = 29, RULE_junctionLeft = 30,
RULE_junctionRight = 31, RULE_biomolecule = 32, RULE_concentration = 33,
RULE_decimal = 34;
private static String[] makeRuleNames() {
return new String[] {
"reaction", "biochemicalReaction", "createJunction", "junctionReaction",
"javaConstructor", "javaClass", "argList", "arg", "createJunctionLeft",
"createJunctionRight", "createJunctionJunction", "junctionReactionLeft",
"junctionReactionRight", "junctionReactionJunctionCondition", "junctionReactionJunction",
"biochemicalReactionLeft", "biochemicalReactionRight", "customConditions",
"customReactionType", "biochemicalReactionLeftContext", "biochemicalReactionLeftInCellContext",
"biochemicalReactionLeftInEnvContext", "biochemicalReactionLeftInNeighborContext",
"biochemicalReactionRightContext", "biochemicalReactionRightInCellContext",
"biochemicalReactionRightInEnvContext", "biochemicalReactionRightInNeighborContext",
"biochemicalReactionRightElem", "customCondition", "junction", "junctionLeft",
"junctionRight", "biomolecule", "concentration", "decimal"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'-->'", "'('", "')'", "'.'", "','", "'+'", "'['", "']'", "'if'",
"'reaction'", "'type'", "'in'", "'cell'", "'env'", "'neighbor'", "'junction'",
"'-'", "':'"
};
}
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, "POSDOUBLE", "LITERAL", "WS",
"ErrorCharacter"
};
}
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 "Biochemistrydsl.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public BiochemistrydslParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class ReactionContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(BiochemistrydslParser.EOF, 0); }
public BiochemicalReactionContext biochemicalReaction() {
return getRuleContext(BiochemicalReactionContext.class,0);
}
public CreateJunctionContext createJunction() {
return getRuleContext(CreateJunctionContext.class,0);
}
public JunctionReactionContext junctionReaction() {
return getRuleContext(JunctionReactionContext.class,0);
}
public ReactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reaction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterReaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitReaction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitReaction(this);
else return visitor.visitChildren(this);
}
}
public final ReactionContext reaction() throws RecognitionException {
ReactionContext _localctx = new ReactionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_reaction);
try {
enterOuterAlt(_localctx, 1);
{
setState(73);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(70);
biochemicalReaction();
}
break;
case 2:
{
setState(71);
createJunction();
}
break;
case 3:
{
setState(72);
junctionReaction();
}
break;
}
setState(75);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BiochemicalReactionContext extends ParserRuleContext {
public BiochemicalReactionLeftContext biochemicalReactionLeft() {
return getRuleContext(BiochemicalReactionLeftContext.class,0);
}
public BiochemicalReactionRightContext biochemicalReactionRight() {
return getRuleContext(BiochemicalReactionRightContext.class,0);
}
public CustomConditionsContext customConditions() {
return getRuleContext(CustomConditionsContext.class,0);
}
public CustomReactionTypeContext customReactionType() {
return getRuleContext(CustomReactionTypeContext.class,0);
}
public BiochemicalReactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReaction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReaction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReaction(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionContext biochemicalReaction() throws RecognitionException {
BiochemicalReactionContext _localctx = new BiochemicalReactionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_biochemicalReaction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(77);
biochemicalReactionLeft();
setState(78);
match(T__0);
setState(79);
biochemicalReactionRight();
setState(81);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__8) {
{
setState(80);
customConditions();
}
}
setState(84);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(83);
customReactionType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreateJunctionContext extends ParserRuleContext {
public CreateJunctionLeftContext createJunctionLeft() {
return getRuleContext(CreateJunctionLeftContext.class,0);
}
public CreateJunctionRightContext createJunctionRight() {
return getRuleContext(CreateJunctionRightContext.class,0);
}
public CustomConditionsContext customConditions() {
return getRuleContext(CustomConditionsContext.class,0);
}
public CustomReactionTypeContext customReactionType() {
return getRuleContext(CustomReactionTypeContext.class,0);
}
public CreateJunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createJunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCreateJunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCreateJunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCreateJunction(this);
else return visitor.visitChildren(this);
}
}
public final CreateJunctionContext createJunction() throws RecognitionException {
CreateJunctionContext _localctx = new CreateJunctionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_createJunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(86);
createJunctionLeft();
setState(87);
match(T__0);
setState(88);
createJunctionRight();
setState(90);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__8) {
{
setState(89);
customConditions();
}
}
setState(93);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(92);
customReactionType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JunctionReactionContext extends ParserRuleContext {
public JunctionReactionLeftContext junctionReactionLeft() {
return getRuleContext(JunctionReactionLeftContext.class,0);
}
public JunctionReactionRightContext junctionReactionRight() {
return getRuleContext(JunctionReactionRightContext.class,0);
}
public CustomConditionsContext customConditions() {
return getRuleContext(CustomConditionsContext.class,0);
}
public CustomReactionTypeContext customReactionType() {
return getRuleContext(CustomReactionTypeContext.class,0);
}
public JunctionReactionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionReaction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionReaction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionReaction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionReaction(this);
else return visitor.visitChildren(this);
}
}
public final JunctionReactionContext junctionReaction() throws RecognitionException {
JunctionReactionContext _localctx = new JunctionReactionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_junctionReaction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(95);
junctionReactionLeft();
setState(96);
match(T__0);
setState(97);
junctionReactionRight();
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__8) {
{
setState(98);
customConditions();
}
}
setState(102);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(101);
customReactionType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JavaConstructorContext extends ParserRuleContext {
public JavaClassContext javaClass() {
return getRuleContext(JavaClassContext.class,0);
}
public ArgListContext argList() {
return getRuleContext(ArgListContext.class,0);
}
public JavaConstructorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_javaConstructor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJavaConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJavaConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJavaConstructor(this);
else return visitor.visitChildren(this);
}
}
public final JavaConstructorContext javaConstructor() throws RecognitionException {
JavaConstructorContext _localctx = new JavaConstructorContext(_ctx, getState());
enterRule(_localctx, 8, RULE_javaConstructor);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(104);
javaClass();
setState(105);
match(T__1);
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1703936L) != 0)) {
{
setState(106);
argList();
}
}
setState(109);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JavaClassContext extends ParserRuleContext {
public List LITERAL() { return getTokens(BiochemistrydslParser.LITERAL); }
public TerminalNode LITERAL(int i) {
return getToken(BiochemistrydslParser.LITERAL, i);
}
public JavaClassContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_javaClass; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJavaClass(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJavaClass(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJavaClass(this);
else return visitor.visitChildren(this);
}
}
public final JavaClassContext javaClass() throws RecognitionException {
JavaClassContext _localctx = new JavaClassContext(_ctx, getState());
enterRule(_localctx, 10, RULE_javaClass);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(115);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(111);
match(LITERAL);
setState(112);
match(T__3);
}
}
}
setState(117);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
setState(118);
match(LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArgListContext extends ParserRuleContext {
public List arg() {
return getRuleContexts(ArgContext.class);
}
public ArgContext arg(int i) {
return getRuleContext(ArgContext.class,i);
}
public ArgListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterArgList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitArgList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitArgList(this);
else return visitor.visitChildren(this);
}
}
public final ArgListContext argList() throws RecognitionException {
ArgListContext _localctx = new ArgListContext(_ctx, getState());
enterRule(_localctx, 12, RULE_argList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(120);
arg();
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(121);
match(T__4);
setState(122);
arg();
}
}
setState(127);
_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 ArgContext extends ParserRuleContext {
public DecimalContext decimal() {
return getRuleContext(DecimalContext.class,0);
}
public TerminalNode LITERAL() { return getToken(BiochemistrydslParser.LITERAL, 0); }
public ArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitArg(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitArg(this);
else return visitor.visitChildren(this);
}
}
public final ArgContext arg() throws RecognitionException {
ArgContext _localctx = new ArgContext(_ctx, getState());
enterRule(_localctx, 14, RULE_arg);
try {
setState(130);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__16:
case POSDOUBLE:
enterOuterAlt(_localctx, 1);
{
setState(128);
decimal();
}
break;
case LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(129);
match(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 CreateJunctionLeftContext extends ParserRuleContext {
public BiochemicalReactionLeftInCellContextContext biochemicalReactionLeftInCellContext() {
return getRuleContext(BiochemicalReactionLeftInCellContextContext.class,0);
}
public BiochemicalReactionLeftInNeighborContextContext biochemicalReactionLeftInNeighborContext() {
return getRuleContext(BiochemicalReactionLeftInNeighborContextContext.class,0);
}
public List biochemicalReactionLeftContext() {
return getRuleContexts(BiochemicalReactionLeftContextContext.class);
}
public BiochemicalReactionLeftContextContext biochemicalReactionLeftContext(int i) {
return getRuleContext(BiochemicalReactionLeftContextContext.class,i);
}
public CreateJunctionLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createJunctionLeft; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCreateJunctionLeft(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCreateJunctionLeft(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCreateJunctionLeft(this);
else return visitor.visitChildren(this);
}
}
public final CreateJunctionLeftContext createJunctionLeft() throws RecognitionException {
CreateJunctionLeftContext _localctx = new CreateJunctionLeftContext(_ctx, getState());
enterRule(_localctx, 16, RULE_createJunctionLeft);
int _la;
try {
int _alt;
setState(184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(137);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(132);
biochemicalReactionLeftContext();
setState(133);
match(T__5);
}
}
}
setState(139);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
setState(140);
biochemicalReactionLeftInCellContext();
setState(141);
match(T__5);
setState(147);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(142);
biochemicalReactionLeftContext();
setState(143);
match(T__5);
}
}
}
setState(149);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
setState(150);
biochemicalReactionLeftInNeighborContext();
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(151);
match(T__5);
setState(152);
biochemicalReactionLeftContext();
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
{
setState(163);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(158);
biochemicalReactionLeftContext();
setState(159);
match(T__5);
}
}
}
setState(165);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(166);
biochemicalReactionLeftInNeighborContext();
setState(167);
match(T__5);
setState(173);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(168);
biochemicalReactionLeftContext();
setState(169);
match(T__5);
}
}
}
setState(175);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
}
setState(176);
biochemicalReactionLeftInCellContext();
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(177);
match(T__5);
setState(178);
biochemicalReactionLeftContext();
}
}
setState(183);
_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 CreateJunctionRightContext extends ParserRuleContext {
public CreateJunctionJunctionContext createJunctionJunction() {
return getRuleContext(CreateJunctionJunctionContext.class,0);
}
public List biochemicalReactionRightContext() {
return getRuleContexts(BiochemicalReactionRightContextContext.class);
}
public BiochemicalReactionRightContextContext biochemicalReactionRightContext(int i) {
return getRuleContext(BiochemicalReactionRightContextContext.class,i);
}
public CreateJunctionRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createJunctionRight; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCreateJunctionRight(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCreateJunctionRight(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCreateJunctionRight(this);
else return visitor.visitChildren(this);
}
}
public final CreateJunctionRightContext createJunctionRight() throws RecognitionException {
CreateJunctionRightContext _localctx = new CreateJunctionRightContext(_ctx, getState());
enterRule(_localctx, 18, RULE_createJunctionRight);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(191);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(186);
biochemicalReactionRightContext();
setState(187);
match(T__5);
}
}
}
setState(193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
}
setState(194);
createJunctionJunction();
setState(199);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(195);
match(T__5);
setState(196);
biochemicalReactionRightContext();
}
}
setState(201);
_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 CreateJunctionJunctionContext extends ParserRuleContext {
public JunctionContext junction() {
return getRuleContext(JunctionContext.class,0);
}
public CreateJunctionJunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_createJunctionJunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCreateJunctionJunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCreateJunctionJunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCreateJunctionJunction(this);
else return visitor.visitChildren(this);
}
}
public final CreateJunctionJunctionContext createJunctionJunction() throws RecognitionException {
CreateJunctionJunctionContext _localctx = new CreateJunctionJunctionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_createJunctionJunction);
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
match(T__6);
setState(203);
junction();
setState(204);
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 JunctionReactionLeftContext extends ParserRuleContext {
public List junctionReactionJunctionCondition() {
return getRuleContexts(JunctionReactionJunctionConditionContext.class);
}
public JunctionReactionJunctionConditionContext junctionReactionJunctionCondition(int i) {
return getRuleContext(JunctionReactionJunctionConditionContext.class,i);
}
public List biochemicalReactionLeftContext() {
return getRuleContexts(BiochemicalReactionLeftContextContext.class);
}
public BiochemicalReactionLeftContextContext biochemicalReactionLeftContext(int i) {
return getRuleContext(BiochemicalReactionLeftContextContext.class,i);
}
public JunctionReactionLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionReactionLeft; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionReactionLeft(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionReactionLeft(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionReactionLeft(this);
else return visitor.visitChildren(this);
}
}
public final JunctionReactionLeftContext junctionReactionLeft() throws RecognitionException {
JunctionReactionLeftContext _localctx = new JunctionReactionLeftContext(_ctx, getState());
enterRule(_localctx, 22, RULE_junctionReactionLeft);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(211);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(206);
biochemicalReactionLeftContext();
setState(207);
match(T__5);
}
}
}
setState(213);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
}
setState(214);
junctionReactionJunctionCondition();
setState(222);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(215);
match(T__5);
setState(218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
{
setState(216);
biochemicalReactionLeftContext();
}
break;
case 2:
{
setState(217);
junctionReactionJunctionCondition();
}
break;
}
}
}
setState(224);
_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 JunctionReactionRightContext extends ParserRuleContext {
public List biochemicalReactionRightContext() {
return getRuleContexts(BiochemicalReactionRightContextContext.class);
}
public BiochemicalReactionRightContextContext biochemicalReactionRightContext(int i) {
return getRuleContext(BiochemicalReactionRightContextContext.class,i);
}
public List junctionReactionJunction() {
return getRuleContexts(JunctionReactionJunctionContext.class);
}
public JunctionReactionJunctionContext junctionReactionJunction(int i) {
return getRuleContext(JunctionReactionJunctionContext.class,i);
}
public JunctionReactionRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionReactionRight; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionReactionRight(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionReactionRight(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionReactionRight(this);
else return visitor.visitChildren(this);
}
}
public final JunctionReactionRightContext junctionReactionRight() throws RecognitionException {
JunctionReactionRightContext _localctx = new JunctionReactionRightContext(_ctx, getState());
enterRule(_localctx, 24, RULE_junctionReactionRight);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(227);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(225);
biochemicalReactionRightContext();
}
break;
case 2:
{
setState(226);
junctionReactionJunction();
}
break;
}
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(229);
match(T__5);
setState(232);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(230);
biochemicalReactionRightContext();
}
break;
case 2:
{
setState(231);
junctionReactionJunction();
}
break;
}
}
}
setState(238);
_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 JunctionReactionJunctionConditionContext extends ParserRuleContext {
public JunctionContext junction() {
return getRuleContext(JunctionContext.class,0);
}
public JunctionReactionJunctionConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionReactionJunctionCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionReactionJunctionCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionReactionJunctionCondition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionReactionJunctionCondition(this);
else return visitor.visitChildren(this);
}
}
public final JunctionReactionJunctionConditionContext junctionReactionJunctionCondition() throws RecognitionException {
JunctionReactionJunctionConditionContext _localctx = new JunctionReactionJunctionConditionContext(_ctx, getState());
enterRule(_localctx, 26, RULE_junctionReactionJunctionCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(239);
match(T__6);
setState(240);
junction();
setState(241);
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 JunctionReactionJunctionContext extends ParserRuleContext {
public JunctionContext junction() {
return getRuleContext(JunctionContext.class,0);
}
public JunctionReactionJunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionReactionJunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionReactionJunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionReactionJunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionReactionJunction(this);
else return visitor.visitChildren(this);
}
}
public final JunctionReactionJunctionContext junctionReactionJunction() throws RecognitionException {
JunctionReactionJunctionContext _localctx = new JunctionReactionJunctionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_junctionReactionJunction);
try {
enterOuterAlt(_localctx, 1);
{
setState(243);
match(T__6);
setState(244);
junction();
setState(245);
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 BiochemicalReactionLeftContext extends ParserRuleContext {
public List biochemicalReactionLeftContext() {
return getRuleContexts(BiochemicalReactionLeftContextContext.class);
}
public BiochemicalReactionLeftContextContext biochemicalReactionLeftContext(int i) {
return getRuleContext(BiochemicalReactionLeftContextContext.class,i);
}
public BiochemicalReactionLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionLeft; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionLeft(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionLeft(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionLeft(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionLeftContext biochemicalReactionLeft() throws RecognitionException {
BiochemicalReactionLeftContext _localctx = new BiochemicalReactionLeftContext(_ctx, getState());
enterRule(_localctx, 30, RULE_biochemicalReactionLeft);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
biochemicalReactionLeftContext();
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(248);
match(T__5);
setState(249);
biochemicalReactionLeftContext();
}
}
setState(254);
_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 BiochemicalReactionRightContext extends ParserRuleContext {
public List biochemicalReactionRightContext() {
return getRuleContexts(BiochemicalReactionRightContextContext.class);
}
public BiochemicalReactionRightContextContext biochemicalReactionRightContext(int i) {
return getRuleContext(BiochemicalReactionRightContextContext.class,i);
}
public BiochemicalReactionRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRight; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRight(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRight(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRight(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightContext biochemicalReactionRight() throws RecognitionException {
BiochemicalReactionRightContext _localctx = new BiochemicalReactionRightContext(_ctx, getState());
enterRule(_localctx, 32, RULE_biochemicalReactionRight);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(255);
biochemicalReactionRightContext();
setState(260);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(256);
match(T__5);
setState(257);
biochemicalReactionRightContext();
}
}
setState(262);
_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 CustomConditionsContext extends ParserRuleContext {
public List customCondition() {
return getRuleContexts(CustomConditionContext.class);
}
public CustomConditionContext customCondition(int i) {
return getRuleContext(CustomConditionContext.class,i);
}
public CustomConditionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_customConditions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCustomConditions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCustomConditions(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCustomConditions(this);
else return visitor.visitChildren(this);
}
}
public final CustomConditionsContext customConditions() throws RecognitionException {
CustomConditionsContext _localctx = new CustomConditionsContext(_ctx, getState());
enterRule(_localctx, 34, RULE_customConditions);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(263);
match(T__8);
setState(264);
customCondition();
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(265);
match(T__4);
setState(266);
customCondition();
}
}
setState(271);
_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 CustomReactionTypeContext extends ParserRuleContext {
public JavaConstructorContext javaConstructor() {
return getRuleContext(JavaConstructorContext.class,0);
}
public CustomReactionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_customReactionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCustomReactionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCustomReactionType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCustomReactionType(this);
else return visitor.visitChildren(this);
}
}
public final CustomReactionTypeContext customReactionType() throws RecognitionException {
CustomReactionTypeContext _localctx = new CustomReactionTypeContext(_ctx, getState());
enterRule(_localctx, 36, RULE_customReactionType);
try {
enterOuterAlt(_localctx, 1);
{
setState(272);
match(T__9);
setState(273);
match(T__10);
setState(274);
javaConstructor();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BiochemicalReactionLeftContextContext extends ParserRuleContext {
public BiochemicalReactionLeftInCellContextContext biochemicalReactionLeftInCellContext() {
return getRuleContext(BiochemicalReactionLeftInCellContextContext.class,0);
}
public BiochemicalReactionLeftInEnvContextContext biochemicalReactionLeftInEnvContext() {
return getRuleContext(BiochemicalReactionLeftInEnvContextContext.class,0);
}
public BiochemicalReactionLeftInNeighborContextContext biochemicalReactionLeftInNeighborContext() {
return getRuleContext(BiochemicalReactionLeftInNeighborContextContext.class,0);
}
public BiochemicalReactionLeftContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionLeftContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionLeftContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionLeftContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionLeftContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionLeftContextContext biochemicalReactionLeftContext() throws RecognitionException {
BiochemicalReactionLeftContextContext _localctx = new BiochemicalReactionLeftContextContext(_ctx, getState());
enterRule(_localctx, 38, RULE_biochemicalReactionLeftContext);
try {
setState(279);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(276);
biochemicalReactionLeftInCellContext();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(277);
biochemicalReactionLeftInEnvContext();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(278);
biochemicalReactionLeftInNeighborContext();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BiochemicalReactionLeftInCellContextContext extends ParserRuleContext {
public List biomolecule() {
return getRuleContexts(BiomoleculeContext.class);
}
public BiomoleculeContext biomolecule(int i) {
return getRuleContext(BiomoleculeContext.class,i);
}
public BiochemicalReactionLeftInCellContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionLeftInCellContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionLeftInCellContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionLeftInCellContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionLeftInCellContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionLeftInCellContextContext biochemicalReactionLeftInCellContext() throws RecognitionException {
BiochemicalReactionLeftInCellContextContext _localctx = new BiochemicalReactionLeftInCellContextContext(_ctx, getState());
enterRule(_localctx, 40, RULE_biochemicalReactionLeftInCellContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(281);
match(T__6);
setState(290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(282);
biomolecule();
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(283);
match(T__5);
setState(284);
biomolecule();
}
}
setState(289);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11) {
{
setState(292);
match(T__11);
setState(293);
match(T__12);
}
}
setState(296);
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 BiochemicalReactionLeftInEnvContextContext extends ParserRuleContext {
public List biomolecule() {
return getRuleContexts(BiomoleculeContext.class);
}
public BiomoleculeContext biomolecule(int i) {
return getRuleContext(BiomoleculeContext.class,i);
}
public BiochemicalReactionLeftInEnvContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionLeftInEnvContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionLeftInEnvContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionLeftInEnvContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionLeftInEnvContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionLeftInEnvContextContext biochemicalReactionLeftInEnvContext() throws RecognitionException {
BiochemicalReactionLeftInEnvContextContext _localctx = new BiochemicalReactionLeftInEnvContextContext(_ctx, getState());
enterRule(_localctx, 42, RULE_biochemicalReactionLeftInEnvContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(298);
match(T__6);
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(299);
biomolecule();
setState(304);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(300);
match(T__5);
setState(301);
biomolecule();
}
}
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(309);
match(T__11);
setState(310);
match(T__13);
setState(311);
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 BiochemicalReactionLeftInNeighborContextContext extends ParserRuleContext {
public List biomolecule() {
return getRuleContexts(BiomoleculeContext.class);
}
public BiomoleculeContext biomolecule(int i) {
return getRuleContext(BiomoleculeContext.class,i);
}
public BiochemicalReactionLeftInNeighborContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionLeftInNeighborContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionLeftInNeighborContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionLeftInNeighborContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionLeftInNeighborContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionLeftInNeighborContextContext biochemicalReactionLeftInNeighborContext() throws RecognitionException {
BiochemicalReactionLeftInNeighborContextContext _localctx = new BiochemicalReactionLeftInNeighborContextContext(_ctx, getState());
enterRule(_localctx, 44, RULE_biochemicalReactionLeftInNeighborContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(313);
match(T__6);
setState(322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(314);
biomolecule();
setState(319);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(315);
match(T__5);
setState(316);
biomolecule();
}
}
setState(321);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(324);
match(T__11);
setState(325);
match(T__14);
setState(326);
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 BiochemicalReactionRightContextContext extends ParserRuleContext {
public BiochemicalReactionRightInCellContextContext biochemicalReactionRightInCellContext() {
return getRuleContext(BiochemicalReactionRightInCellContextContext.class,0);
}
public BiochemicalReactionRightInEnvContextContext biochemicalReactionRightInEnvContext() {
return getRuleContext(BiochemicalReactionRightInEnvContextContext.class,0);
}
public BiochemicalReactionRightInNeighborContextContext biochemicalReactionRightInNeighborContext() {
return getRuleContext(BiochemicalReactionRightInNeighborContextContext.class,0);
}
public BiochemicalReactionRightContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRightContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRightContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRightContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRightContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightContextContext biochemicalReactionRightContext() throws RecognitionException {
BiochemicalReactionRightContextContext _localctx = new BiochemicalReactionRightContextContext(_ctx, getState());
enterRule(_localctx, 46, RULE_biochemicalReactionRightContext);
try {
setState(331);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(328);
biochemicalReactionRightInCellContext();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(329);
biochemicalReactionRightInEnvContext();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(330);
biochemicalReactionRightInNeighborContext();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BiochemicalReactionRightInCellContextContext extends ParserRuleContext {
public List biochemicalReactionRightElem() {
return getRuleContexts(BiochemicalReactionRightElemContext.class);
}
public BiochemicalReactionRightElemContext biochemicalReactionRightElem(int i) {
return getRuleContext(BiochemicalReactionRightElemContext.class,i);
}
public BiochemicalReactionRightInCellContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRightInCellContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRightInCellContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRightInCellContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRightInCellContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightInCellContextContext biochemicalReactionRightInCellContext() throws RecognitionException {
BiochemicalReactionRightInCellContextContext _localctx = new BiochemicalReactionRightInCellContextContext(_ctx, getState());
enterRule(_localctx, 48, RULE_biochemicalReactionRightInCellContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(333);
match(T__6);
setState(342);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(334);
biochemicalReactionRightElem();
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(335);
match(T__5);
setState(336);
biochemicalReactionRightElem();
}
}
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(346);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__11) {
{
setState(344);
match(T__11);
setState(345);
match(T__12);
}
}
setState(348);
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 BiochemicalReactionRightInEnvContextContext extends ParserRuleContext {
public List biochemicalReactionRightElem() {
return getRuleContexts(BiochemicalReactionRightElemContext.class);
}
public BiochemicalReactionRightElemContext biochemicalReactionRightElem(int i) {
return getRuleContext(BiochemicalReactionRightElemContext.class,i);
}
public BiochemicalReactionRightInEnvContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRightInEnvContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRightInEnvContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRightInEnvContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRightInEnvContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightInEnvContextContext biochemicalReactionRightInEnvContext() throws RecognitionException {
BiochemicalReactionRightInEnvContextContext _localctx = new BiochemicalReactionRightInEnvContextContext(_ctx, getState());
enterRule(_localctx, 50, RULE_biochemicalReactionRightInEnvContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(350);
match(T__6);
setState(359);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(351);
biochemicalReactionRightElem();
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(352);
match(T__5);
setState(353);
biochemicalReactionRightElem();
}
}
setState(358);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(361);
match(T__11);
setState(362);
match(T__13);
setState(363);
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 BiochemicalReactionRightInNeighborContextContext extends ParserRuleContext {
public List biochemicalReactionRightElem() {
return getRuleContexts(BiochemicalReactionRightElemContext.class);
}
public BiochemicalReactionRightElemContext biochemicalReactionRightElem(int i) {
return getRuleContext(BiochemicalReactionRightElemContext.class,i);
}
public BiochemicalReactionRightInNeighborContextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRightInNeighborContext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRightInNeighborContext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRightInNeighborContext(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRightInNeighborContext(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightInNeighborContextContext biochemicalReactionRightInNeighborContext() throws RecognitionException {
BiochemicalReactionRightInNeighborContextContext _localctx = new BiochemicalReactionRightInNeighborContextContext(_ctx, getState());
enterRule(_localctx, 52, RULE_biochemicalReactionRightInNeighborContext);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(365);
match(T__6);
setState(374);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE || _la==LITERAL) {
{
setState(366);
biochemicalReactionRightElem();
setState(371);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__5) {
{
{
setState(367);
match(T__5);
setState(368);
biochemicalReactionRightElem();
}
}
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(376);
match(T__11);
setState(377);
match(T__14);
setState(378);
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 BiochemicalReactionRightElemContext extends ParserRuleContext {
public BiomoleculeContext biomolecule() {
return getRuleContext(BiomoleculeContext.class,0);
}
public JavaConstructorContext javaConstructor() {
return getRuleContext(JavaConstructorContext.class,0);
}
public BiochemicalReactionRightElemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biochemicalReactionRightElem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiochemicalReactionRightElem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiochemicalReactionRightElem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiochemicalReactionRightElem(this);
else return visitor.visitChildren(this);
}
}
public final BiochemicalReactionRightElemContext biochemicalReactionRightElem() throws RecognitionException {
BiochemicalReactionRightElemContext _localctx = new BiochemicalReactionRightElemContext(_ctx, getState());
enterRule(_localctx, 54, RULE_biochemicalReactionRightElem);
try {
setState(382);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(380);
biomolecule();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(381);
javaConstructor();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CustomConditionContext extends ParserRuleContext {
public JavaConstructorContext javaConstructor() {
return getRuleContext(JavaConstructorContext.class,0);
}
public CustomConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_customCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterCustomCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitCustomCondition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitCustomCondition(this);
else return visitor.visitChildren(this);
}
}
public final CustomConditionContext customCondition() throws RecognitionException {
CustomConditionContext _localctx = new CustomConditionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_customCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(384);
javaConstructor();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JunctionContext extends ParserRuleContext {
public JunctionLeftContext junctionLeft() {
return getRuleContext(JunctionLeftContext.class,0);
}
public JunctionRightContext junctionRight() {
return getRuleContext(JunctionRightContext.class,0);
}
public JunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunction(this);
else return visitor.visitChildren(this);
}
}
public final JunctionContext junction() throws RecognitionException {
JunctionContext _localctx = new JunctionContext(_ctx, getState());
enterRule(_localctx, 58, RULE_junction);
try {
enterOuterAlt(_localctx, 1);
{
setState(386);
match(T__15);
setState(387);
junctionLeft();
setState(388);
match(T__16);
setState(389);
junctionRight();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JunctionLeftContext extends ParserRuleContext {
public List biomolecule() {
return getRuleContexts(BiomoleculeContext.class);
}
public BiomoleculeContext biomolecule(int i) {
return getRuleContext(BiomoleculeContext.class,i);
}
public JunctionLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionLeft; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionLeft(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionLeft(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionLeft(this);
else return visitor.visitChildren(this);
}
}
public final JunctionLeftContext junctionLeft() throws RecognitionException {
JunctionLeftContext _localctx = new JunctionLeftContext(_ctx, getState());
enterRule(_localctx, 60, RULE_junctionLeft);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(391);
biomolecule();
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__17) {
{
{
setState(392);
match(T__17);
setState(393);
biomolecule();
}
}
setState(398);
_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 JunctionRightContext extends ParserRuleContext {
public List biomolecule() {
return getRuleContexts(BiomoleculeContext.class);
}
public BiomoleculeContext biomolecule(int i) {
return getRuleContext(BiomoleculeContext.class,i);
}
public JunctionRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_junctionRight; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterJunctionRight(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitJunctionRight(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitJunctionRight(this);
else return visitor.visitChildren(this);
}
}
public final JunctionRightContext junctionRight() throws RecognitionException {
JunctionRightContext _localctx = new JunctionRightContext(_ctx, getState());
enterRule(_localctx, 62, RULE_junctionRight);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(399);
biomolecule();
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__17) {
{
{
setState(400);
match(T__17);
setState(401);
biomolecule();
}
}
setState(406);
_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 BiomoleculeContext extends ParserRuleContext {
public Token name;
public TerminalNode LITERAL() { return getToken(BiochemistrydslParser.LITERAL, 0); }
public ConcentrationContext concentration() {
return getRuleContext(ConcentrationContext.class,0);
}
public BiomoleculeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_biomolecule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterBiomolecule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitBiomolecule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitBiomolecule(this);
else return visitor.visitChildren(this);
}
}
public final BiomoleculeContext biomolecule() throws RecognitionException {
BiomoleculeContext _localctx = new BiomoleculeContext(_ctx, getState());
enterRule(_localctx, 64, RULE_biomolecule);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(408);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POSDOUBLE) {
{
setState(407);
concentration();
}
}
setState(410);
((BiomoleculeContext)_localctx).name = match(LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConcentrationContext extends ParserRuleContext {
public TerminalNode POSDOUBLE() { return getToken(BiochemistrydslParser.POSDOUBLE, 0); }
public ConcentrationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_concentration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterConcentration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitConcentration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitConcentration(this);
else return visitor.visitChildren(this);
}
}
public final ConcentrationContext concentration() throws RecognitionException {
ConcentrationContext _localctx = new ConcentrationContext(_ctx, getState());
enterRule(_localctx, 66, RULE_concentration);
try {
enterOuterAlt(_localctx, 1);
{
setState(412);
match(POSDOUBLE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DecimalContext extends ParserRuleContext {
public TerminalNode POSDOUBLE() { return getToken(BiochemistrydslParser.POSDOUBLE, 0); }
public DecimalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decimal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).enterDecimal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BiochemistrydslListener ) ((BiochemistrydslListener)listener).exitDecimal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BiochemistrydslVisitor ) return ((BiochemistrydslVisitor)visitor).visitDecimal(this);
else return visitor.visitChildren(this);
}
}
public final DecimalContext decimal() throws RecognitionException {
DecimalContext _localctx = new DecimalContext(_ctx, getState());
enterRule(_localctx, 68, RULE_decimal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__16) {
{
setState(414);
match(T__16);
}
}
setState(417);
match(POSDOUBLE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\u0004\u0001\u0016\u01a4\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"+
"\"\u0001\u0000\u0001\u0000\u0001\u0000\u0003\u0000J\b\u0000\u0001\u0000"+
"\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001"+
"R\b\u0001\u0001\u0001\u0003\u0001U\b\u0001\u0001\u0002\u0001\u0002\u0001"+
"\u0002\u0001\u0002\u0003\u0002[\b\u0002\u0001\u0002\u0003\u0002^\b\u0002"+
"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003d\b\u0003"+
"\u0001\u0003\u0003\u0003g\b\u0003\u0001\u0004\u0001\u0004\u0001\u0004"+
"\u0003\u0004l\b\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005"+
"\u0005\u0005r\b\u0005\n\u0005\f\u0005u\t\u0005\u0001\u0005\u0001\u0005"+
"\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006|\b\u0006\n\u0006\f\u0006"+
"\u007f\t\u0006\u0001\u0007\u0001\u0007\u0003\u0007\u0083\b\u0007\u0001"+
"\b\u0001\b\u0001\b\u0005\b\u0088\b\b\n\b\f\b\u008b\t\b\u0001\b\u0001\b"+
"\u0001\b\u0001\b\u0001\b\u0005\b\u0092\b\b\n\b\f\b\u0095\t\b\u0001\b\u0001"+
"\b\u0001\b\u0005\b\u009a\b\b\n\b\f\b\u009d\t\b\u0001\b\u0001\b\u0001\b"+
"\u0005\b\u00a2\b\b\n\b\f\b\u00a5\t\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0005\b\u00ac\b\b\n\b\f\b\u00af\t\b\u0001\b\u0001\b\u0001\b\u0005\b"+
"\u00b4\b\b\n\b\f\b\u00b7\t\b\u0003\b\u00b9\b\b\u0001\t\u0001\t\u0001\t"+
"\u0005\t\u00be\b\t\n\t\f\t\u00c1\t\t\u0001\t\u0001\t\u0001\t\u0005\t\u00c6"+
"\b\t\n\t\f\t\u00c9\t\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0005\u000b\u00d2\b\u000b\n\u000b\f\u000b\u00d5\t\u000b"+
"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u00db\b\u000b"+
"\u0005\u000b\u00dd\b\u000b\n\u000b\f\u000b\u00e0\t\u000b\u0001\f\u0001"+
"\f\u0003\f\u00e4\b\f\u0001\f\u0001\f\u0001\f\u0003\f\u00e9\b\f\u0005\f"+
"\u00eb\b\f\n\f\f\f\u00ee\t\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0005\u000f\u00fb\b\u000f\n\u000f\f\u000f\u00fe\t\u000f\u0001\u0010\u0001"+
"\u0010\u0001\u0010\u0005\u0010\u0103\b\u0010\n\u0010\f\u0010\u0106\t\u0010"+
"\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u010c\b\u0011"+
"\n\u0011\f\u0011\u010f\t\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+
"\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u0118\b\u0013\u0001"+
"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u011e\b\u0014\n"+
"\u0014\f\u0014\u0121\t\u0014\u0003\u0014\u0123\b\u0014\u0001\u0014\u0001"+
"\u0014\u0003\u0014\u0127\b\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001"+
"\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u012f\b\u0015\n\u0015\f\u0015"+
"\u0132\t\u0015\u0003\u0015\u0134\b\u0015\u0001\u0015\u0001\u0015\u0001"+
"\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0005"+
"\u0016\u013e\b\u0016\n\u0016\f\u0016\u0141\t\u0016\u0003\u0016\u0143\b"+
"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+
"\u0017\u0001\u0017\u0003\u0017\u014c\b\u0017\u0001\u0018\u0001\u0018\u0001"+
"\u0018\u0001\u0018\u0005\u0018\u0152\b\u0018\n\u0018\f\u0018\u0155\t\u0018"+
"\u0003\u0018\u0157\b\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u015b\b"+
"\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+
"\u0019\u0005\u0019\u0163\b\u0019\n\u0019\f\u0019\u0166\t\u0019\u0003\u0019"+
"\u0168\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a"+
"\u0001\u001a\u0001\u001a\u0001\u001a\u0005\u001a\u0172\b\u001a\n\u001a"+
"\f\u001a\u0175\t\u001a\u0003\u001a\u0177\b\u001a\u0001\u001a\u0001\u001a"+
"\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0003\u001b\u017f\b\u001b"+
"\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d"+
"\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u018b\b\u001e"+
"\n\u001e\f\u001e\u018e\t\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0005"+
"\u001f\u0193\b\u001f\n\u001f\f\u001f\u0196\t\u001f\u0001 \u0003 \u0199"+
"\b \u0001 \u0001 \u0001!\u0001!\u0001\"\u0003\"\u01a0\b\"\u0001\"\u0001"+
"\"\u0001\"\u0000\u0000#\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012"+
"\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BD\u0000\u0000\u01b5"+
"\u0000I\u0001\u0000\u0000\u0000\u0002M\u0001\u0000\u0000\u0000\u0004V"+
"\u0001\u0000\u0000\u0000\u0006_\u0001\u0000\u0000\u0000\bh\u0001\u0000"+
"\u0000\u0000\ns\u0001\u0000\u0000\u0000\fx\u0001\u0000\u0000\u0000\u000e"+
"\u0082\u0001\u0000\u0000\u0000\u0010\u00b8\u0001\u0000\u0000\u0000\u0012"+
"\u00bf\u0001\u0000\u0000\u0000\u0014\u00ca\u0001\u0000\u0000\u0000\u0016"+
"\u00d3\u0001\u0000\u0000\u0000\u0018\u00e3\u0001\u0000\u0000\u0000\u001a"+
"\u00ef\u0001\u0000\u0000\u0000\u001c\u00f3\u0001\u0000\u0000\u0000\u001e"+
"\u00f7\u0001\u0000\u0000\u0000 \u00ff\u0001\u0000\u0000\u0000\"\u0107"+
"\u0001\u0000\u0000\u0000$\u0110\u0001\u0000\u0000\u0000&\u0117\u0001\u0000"+
"\u0000\u0000(\u0119\u0001\u0000\u0000\u0000*\u012a\u0001\u0000\u0000\u0000"+
",\u0139\u0001\u0000\u0000\u0000.\u014b\u0001\u0000\u0000\u00000\u014d"+
"\u0001\u0000\u0000\u00002\u015e\u0001\u0000\u0000\u00004\u016d\u0001\u0000"+
"\u0000\u00006\u017e\u0001\u0000\u0000\u00008\u0180\u0001\u0000\u0000\u0000"+
":\u0182\u0001\u0000\u0000\u0000<\u0187\u0001\u0000\u0000\u0000>\u018f"+
"\u0001\u0000\u0000\u0000@\u0198\u0001\u0000\u0000\u0000B\u019c\u0001\u0000"+
"\u0000\u0000D\u019f\u0001\u0000\u0000\u0000FJ\u0003\u0002\u0001\u0000"+
"GJ\u0003\u0004\u0002\u0000HJ\u0003\u0006\u0003\u0000IF\u0001\u0000\u0000"+
"\u0000IG\u0001\u0000\u0000\u0000IH\u0001\u0000\u0000\u0000JK\u0001\u0000"+
"\u0000\u0000KL\u0005\u0000\u0000\u0001L\u0001\u0001\u0000\u0000\u0000"+
"MN\u0003\u001e\u000f\u0000NO\u0005\u0001\u0000\u0000OQ\u0003 \u0010\u0000"+
"PR\u0003\"\u0011\u0000QP\u0001\u0000\u0000\u0000QR\u0001\u0000\u0000\u0000"+
"RT\u0001\u0000\u0000\u0000SU\u0003$\u0012\u0000TS\u0001\u0000\u0000\u0000"+
"TU\u0001\u0000\u0000\u0000U\u0003\u0001\u0000\u0000\u0000VW\u0003\u0010"+
"\b\u0000WX\u0005\u0001\u0000\u0000XZ\u0003\u0012\t\u0000Y[\u0003\"\u0011"+
"\u0000ZY\u0001\u0000\u0000\u0000Z[\u0001\u0000\u0000\u0000[]\u0001\u0000"+
"\u0000\u0000\\^\u0003$\u0012\u0000]\\\u0001\u0000\u0000\u0000]^\u0001"+
"\u0000\u0000\u0000^\u0005\u0001\u0000\u0000\u0000_`\u0003\u0016\u000b"+
"\u0000`a\u0005\u0001\u0000\u0000ac\u0003\u0018\f\u0000bd\u0003\"\u0011"+
"\u0000cb\u0001\u0000\u0000\u0000cd\u0001\u0000\u0000\u0000df\u0001\u0000"+
"\u0000\u0000eg\u0003$\u0012\u0000fe\u0001\u0000\u0000\u0000fg\u0001\u0000"+
"\u0000\u0000g\u0007\u0001\u0000\u0000\u0000hi\u0003\n\u0005\u0000ik\u0005"+
"\u0002\u0000\u0000jl\u0003\f\u0006\u0000kj\u0001\u0000\u0000\u0000kl\u0001"+
"\u0000\u0000\u0000lm\u0001\u0000\u0000\u0000mn\u0005\u0003\u0000\u0000"+
"n\t\u0001\u0000\u0000\u0000op\u0005\u0014\u0000\u0000pr\u0005\u0004\u0000"+
"\u0000qo\u0001\u0000\u0000\u0000ru\u0001\u0000\u0000\u0000sq\u0001\u0000"+
"\u0000\u0000st\u0001\u0000\u0000\u0000tv\u0001\u0000\u0000\u0000us\u0001"+
"\u0000\u0000\u0000vw\u0005\u0014\u0000\u0000w\u000b\u0001\u0000\u0000"+
"\u0000x}\u0003\u000e\u0007\u0000yz\u0005\u0005\u0000\u0000z|\u0003\u000e"+
"\u0007\u0000{y\u0001\u0000\u0000\u0000|\u007f\u0001\u0000\u0000\u0000"+
"}{\u0001\u0000\u0000\u0000}~\u0001\u0000\u0000\u0000~\r\u0001\u0000\u0000"+
"\u0000\u007f}\u0001\u0000\u0000\u0000\u0080\u0083\u0003D\"\u0000\u0081"+
"\u0083\u0005\u0014\u0000\u0000\u0082\u0080\u0001\u0000\u0000\u0000\u0082"+
"\u0081\u0001\u0000\u0000\u0000\u0083\u000f\u0001\u0000\u0000\u0000\u0084"+
"\u0085\u0003&\u0013\u0000\u0085\u0086\u0005\u0006\u0000\u0000\u0086\u0088"+
"\u0001\u0000\u0000\u0000\u0087\u0084\u0001\u0000\u0000\u0000\u0088\u008b"+
"\u0001\u0000\u0000\u0000\u0089\u0087\u0001\u0000\u0000\u0000\u0089\u008a"+
"\u0001\u0000\u0000\u0000\u008a\u008c\u0001\u0000\u0000\u0000\u008b\u0089"+
"\u0001\u0000\u0000\u0000\u008c\u008d\u0003(\u0014\u0000\u008d\u0093\u0005"+
"\u0006\u0000\u0000\u008e\u008f\u0003&\u0013\u0000\u008f\u0090\u0005\u0006"+
"\u0000\u0000\u0090\u0092\u0001\u0000\u0000\u0000\u0091\u008e\u0001\u0000"+
"\u0000\u0000\u0092\u0095\u0001\u0000\u0000\u0000\u0093\u0091\u0001\u0000"+
"\u0000\u0000\u0093\u0094\u0001\u0000\u0000\u0000\u0094\u0096\u0001\u0000"+
"\u0000\u0000\u0095\u0093\u0001\u0000\u0000\u0000\u0096\u009b\u0003,\u0016"+
"\u0000\u0097\u0098\u0005\u0006\u0000\u0000\u0098\u009a\u0003&\u0013\u0000"+
"\u0099\u0097\u0001\u0000\u0000\u0000\u009a\u009d\u0001\u0000\u0000\u0000"+
"\u009b\u0099\u0001\u0000\u0000\u0000\u009b\u009c\u0001\u0000\u0000\u0000"+
"\u009c\u00b9\u0001\u0000\u0000\u0000\u009d\u009b\u0001\u0000\u0000\u0000"+
"\u009e\u009f\u0003&\u0013\u0000\u009f\u00a0\u0005\u0006\u0000\u0000\u00a0"+
"\u00a2\u0001\u0000\u0000\u0000\u00a1\u009e\u0001\u0000\u0000\u0000\u00a2"+
"\u00a5\u0001\u0000\u0000\u0000\u00a3\u00a1\u0001\u0000\u0000\u0000\u00a3"+
"\u00a4\u0001\u0000\u0000\u0000\u00a4\u00a6\u0001\u0000\u0000\u0000\u00a5"+
"\u00a3\u0001\u0000\u0000\u0000\u00a6\u00a7\u0003,\u0016\u0000\u00a7\u00ad"+
"\u0005\u0006\u0000\u0000\u00a8\u00a9\u0003&\u0013\u0000\u00a9\u00aa\u0005"+
"\u0006\u0000\u0000\u00aa\u00ac\u0001\u0000\u0000\u0000\u00ab\u00a8\u0001"+
"\u0000\u0000\u0000\u00ac\u00af\u0001\u0000\u0000\u0000\u00ad\u00ab\u0001"+
"\u0000\u0000\u0000\u00ad\u00ae\u0001\u0000\u0000\u0000\u00ae\u00b0\u0001"+
"\u0000\u0000\u0000\u00af\u00ad\u0001\u0000\u0000\u0000\u00b0\u00b5\u0003"+
"(\u0014\u0000\u00b1\u00b2\u0005\u0006\u0000\u0000\u00b2\u00b4\u0003&\u0013"+
"\u0000\u00b3\u00b1\u0001\u0000\u0000\u0000\u00b4\u00b7\u0001\u0000\u0000"+
"\u0000\u00b5\u00b3\u0001\u0000\u0000\u0000\u00b5\u00b6\u0001\u0000\u0000"+
"\u0000\u00b6\u00b9\u0001\u0000\u0000\u0000\u00b7\u00b5\u0001\u0000\u0000"+
"\u0000\u00b8\u0089\u0001\u0000\u0000\u0000\u00b8\u00a3\u0001\u0000\u0000"+
"\u0000\u00b9\u0011\u0001\u0000\u0000\u0000\u00ba\u00bb\u0003.\u0017\u0000"+
"\u00bb\u00bc\u0005\u0006\u0000\u0000\u00bc\u00be\u0001\u0000\u0000\u0000"+
"\u00bd\u00ba\u0001\u0000\u0000\u0000\u00be\u00c1\u0001\u0000\u0000\u0000"+
"\u00bf\u00bd\u0001\u0000\u0000\u0000\u00bf\u00c0\u0001\u0000\u0000\u0000"+
"\u00c0\u00c2\u0001\u0000\u0000\u0000\u00c1\u00bf\u0001\u0000\u0000\u0000"+
"\u00c2\u00c7\u0003\u0014\n\u0000\u00c3\u00c4\u0005\u0006\u0000\u0000\u00c4"+
"\u00c6\u0003.\u0017\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000\u00c6\u00c9"+
"\u0001\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000\u0000\u0000\u00c7\u00c8"+
"\u0001\u0000\u0000\u0000\u00c8\u0013\u0001\u0000\u0000\u0000\u00c9\u00c7"+
"\u0001\u0000\u0000\u0000\u00ca\u00cb\u0005\u0007\u0000\u0000\u00cb\u00cc"+
"\u0003:\u001d\u0000\u00cc\u00cd\u0005\b\u0000\u0000\u00cd\u0015\u0001"+
"\u0000\u0000\u0000\u00ce\u00cf\u0003&\u0013\u0000\u00cf\u00d0\u0005\u0006"+
"\u0000\u0000\u00d0\u00d2\u0001\u0000\u0000\u0000\u00d1\u00ce\u0001\u0000"+
"\u0000\u0000\u00d2\u00d5\u0001\u0000\u0000\u0000\u00d3\u00d1\u0001\u0000"+
"\u0000\u0000\u00d3\u00d4\u0001\u0000\u0000\u0000\u00d4\u00d6\u0001\u0000"+
"\u0000\u0000\u00d5\u00d3\u0001\u0000\u0000\u0000\u00d6\u00de\u0003\u001a"+
"\r\u0000\u00d7\u00da\u0005\u0006\u0000\u0000\u00d8\u00db\u0003&\u0013"+
"\u0000\u00d9\u00db\u0003\u001a\r\u0000\u00da\u00d8\u0001\u0000\u0000\u0000"+
"\u00da\u00d9\u0001\u0000\u0000\u0000\u00db\u00dd\u0001\u0000\u0000\u0000"+
"\u00dc\u00d7\u0001\u0000\u0000\u0000\u00dd\u00e0\u0001\u0000\u0000\u0000"+
"\u00de\u00dc\u0001\u0000\u0000\u0000\u00de\u00df\u0001\u0000\u0000\u0000"+
"\u00df\u0017\u0001\u0000\u0000\u0000\u00e0\u00de\u0001\u0000\u0000\u0000"+
"\u00e1\u00e4\u0003.\u0017\u0000\u00e2\u00e4\u0003\u001c\u000e\u0000\u00e3"+
"\u00e1\u0001\u0000\u0000\u0000\u00e3\u00e2\u0001\u0000\u0000\u0000\u00e4"+
"\u00ec\u0001\u0000\u0000\u0000\u00e5\u00e8\u0005\u0006\u0000\u0000\u00e6"+
"\u00e9\u0003.\u0017\u0000\u00e7\u00e9\u0003\u001c\u000e\u0000\u00e8\u00e6"+
"\u0001\u0000\u0000\u0000\u00e8\u00e7\u0001\u0000\u0000\u0000\u00e9\u00eb"+
"\u0001\u0000\u0000\u0000\u00ea\u00e5\u0001\u0000\u0000\u0000\u00eb\u00ee"+
"\u0001\u0000\u0000\u0000\u00ec\u00ea\u0001\u0000\u0000\u0000\u00ec\u00ed"+
"\u0001\u0000\u0000\u0000\u00ed\u0019\u0001\u0000\u0000\u0000\u00ee\u00ec"+
"\u0001\u0000\u0000\u0000\u00ef\u00f0\u0005\u0007\u0000\u0000\u00f0\u00f1"+
"\u0003:\u001d\u0000\u00f1\u00f2\u0005\b\u0000\u0000\u00f2\u001b\u0001"+
"\u0000\u0000\u0000\u00f3\u00f4\u0005\u0007\u0000\u0000\u00f4\u00f5\u0003"+
":\u001d\u0000\u00f5\u00f6\u0005\b\u0000\u0000\u00f6\u001d\u0001\u0000"+
"\u0000\u0000\u00f7\u00fc\u0003&\u0013\u0000\u00f8\u00f9\u0005\u0006\u0000"+
"\u0000\u00f9\u00fb\u0003&\u0013\u0000\u00fa\u00f8\u0001\u0000\u0000\u0000"+
"\u00fb\u00fe\u0001\u0000\u0000\u0000\u00fc\u00fa\u0001\u0000\u0000\u0000"+
"\u00fc\u00fd\u0001\u0000\u0000\u0000\u00fd\u001f\u0001\u0000\u0000\u0000"+
"\u00fe\u00fc\u0001\u0000\u0000\u0000\u00ff\u0104\u0003.\u0017\u0000\u0100"+
"\u0101\u0005\u0006\u0000\u0000\u0101\u0103\u0003.\u0017\u0000\u0102\u0100"+
"\u0001\u0000\u0000\u0000\u0103\u0106\u0001\u0000\u0000\u0000\u0104\u0102"+
"\u0001\u0000\u0000\u0000\u0104\u0105\u0001\u0000\u0000\u0000\u0105!\u0001"+
"\u0000\u0000\u0000\u0106\u0104\u0001\u0000\u0000\u0000\u0107\u0108\u0005"+
"\t\u0000\u0000\u0108\u010d\u00038\u001c\u0000\u0109\u010a\u0005\u0005"+
"\u0000\u0000\u010a\u010c\u00038\u001c\u0000\u010b\u0109\u0001\u0000\u0000"+
"\u0000\u010c\u010f\u0001\u0000\u0000\u0000\u010d\u010b\u0001\u0000\u0000"+
"\u0000\u010d\u010e\u0001\u0000\u0000\u0000\u010e#\u0001\u0000\u0000\u0000"+
"\u010f\u010d\u0001\u0000\u0000\u0000\u0110\u0111\u0005\n\u0000\u0000\u0111"+
"\u0112\u0005\u000b\u0000\u0000\u0112\u0113\u0003\b\u0004\u0000\u0113%"+
"\u0001\u0000\u0000\u0000\u0114\u0118\u0003(\u0014\u0000\u0115\u0118\u0003"+
"*\u0015\u0000\u0116\u0118\u0003,\u0016\u0000\u0117\u0114\u0001\u0000\u0000"+
"\u0000\u0117\u0115\u0001\u0000\u0000\u0000\u0117\u0116\u0001\u0000\u0000"+
"\u0000\u0118\'\u0001\u0000\u0000\u0000\u0119\u0122\u0005\u0007\u0000\u0000"+
"\u011a\u011f\u0003@ \u0000\u011b\u011c\u0005\u0006\u0000\u0000\u011c\u011e"+
"\u0003@ \u0000\u011d\u011b\u0001\u0000\u0000\u0000\u011e\u0121\u0001\u0000"+
"\u0000\u0000\u011f\u011d\u0001\u0000\u0000\u0000\u011f\u0120\u0001\u0000"+
"\u0000\u0000\u0120\u0123\u0001\u0000\u0000\u0000\u0121\u011f\u0001\u0000"+
"\u0000\u0000\u0122\u011a\u0001\u0000\u0000\u0000\u0122\u0123\u0001\u0000"+
"\u0000\u0000\u0123\u0126\u0001\u0000\u0000\u0000\u0124\u0125\u0005\f\u0000"+
"\u0000\u0125\u0127\u0005\r\u0000\u0000\u0126\u0124\u0001\u0000\u0000\u0000"+
"\u0126\u0127\u0001\u0000\u0000\u0000\u0127\u0128\u0001\u0000\u0000\u0000"+
"\u0128\u0129\u0005\b\u0000\u0000\u0129)\u0001\u0000\u0000\u0000\u012a"+
"\u0133\u0005\u0007\u0000\u0000\u012b\u0130\u0003@ \u0000\u012c\u012d\u0005"+
"\u0006\u0000\u0000\u012d\u012f\u0003@ \u0000\u012e\u012c\u0001\u0000\u0000"+
"\u0000\u012f\u0132\u0001\u0000\u0000\u0000\u0130\u012e\u0001\u0000\u0000"+
"\u0000\u0130\u0131\u0001\u0000\u0000\u0000\u0131\u0134\u0001\u0000\u0000"+
"\u0000\u0132\u0130\u0001\u0000\u0000\u0000\u0133\u012b\u0001\u0000\u0000"+
"\u0000\u0133\u0134\u0001\u0000\u0000\u0000\u0134\u0135\u0001\u0000\u0000"+
"\u0000\u0135\u0136\u0005\f\u0000\u0000\u0136\u0137\u0005\u000e\u0000\u0000"+
"\u0137\u0138\u0005\b\u0000\u0000\u0138+\u0001\u0000\u0000\u0000\u0139"+
"\u0142\u0005\u0007\u0000\u0000\u013a\u013f\u0003@ \u0000\u013b\u013c\u0005"+
"\u0006\u0000\u0000\u013c\u013e\u0003@ \u0000\u013d\u013b\u0001\u0000\u0000"+
"\u0000\u013e\u0141\u0001\u0000\u0000\u0000\u013f\u013d\u0001\u0000\u0000"+
"\u0000\u013f\u0140\u0001\u0000\u0000\u0000\u0140\u0143\u0001\u0000\u0000"+
"\u0000\u0141\u013f\u0001\u0000\u0000\u0000\u0142\u013a\u0001\u0000\u0000"+
"\u0000\u0142\u0143\u0001\u0000\u0000\u0000\u0143\u0144\u0001\u0000\u0000"+
"\u0000\u0144\u0145\u0005\f\u0000\u0000\u0145\u0146\u0005\u000f\u0000\u0000"+
"\u0146\u0147\u0005\b\u0000\u0000\u0147-\u0001\u0000\u0000\u0000\u0148"+
"\u014c\u00030\u0018\u0000\u0149\u014c\u00032\u0019\u0000\u014a\u014c\u0003"+
"4\u001a\u0000\u014b\u0148\u0001\u0000\u0000\u0000\u014b\u0149\u0001\u0000"+
"\u0000\u0000\u014b\u014a\u0001\u0000\u0000\u0000\u014c/\u0001\u0000\u0000"+
"\u0000\u014d\u0156\u0005\u0007\u0000\u0000\u014e\u0153\u00036\u001b\u0000"+
"\u014f\u0150\u0005\u0006\u0000\u0000\u0150\u0152\u00036\u001b\u0000\u0151"+
"\u014f\u0001\u0000\u0000\u0000\u0152\u0155\u0001\u0000\u0000\u0000\u0153"+
"\u0151\u0001\u0000\u0000\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154"+
"\u0157\u0001\u0000\u0000\u0000\u0155\u0153\u0001\u0000\u0000\u0000\u0156"+
"\u014e\u0001\u0000\u0000\u0000\u0156\u0157\u0001\u0000\u0000\u0000\u0157"+
"\u015a\u0001\u0000\u0000\u0000\u0158\u0159\u0005\f\u0000\u0000\u0159\u015b"+
"\u0005\r\u0000\u0000\u015a\u0158\u0001\u0000\u0000\u0000\u015a\u015b\u0001"+
"\u0000\u0000\u0000\u015b\u015c\u0001\u0000\u0000\u0000\u015c\u015d\u0005"+
"\b\u0000\u0000\u015d1\u0001\u0000\u0000\u0000\u015e\u0167\u0005\u0007"+
"\u0000\u0000\u015f\u0164\u00036\u001b\u0000\u0160\u0161\u0005\u0006\u0000"+
"\u0000\u0161\u0163\u00036\u001b\u0000\u0162\u0160\u0001\u0000\u0000\u0000"+
"\u0163\u0166\u0001\u0000\u0000\u0000\u0164\u0162\u0001\u0000\u0000\u0000"+
"\u0164\u0165\u0001\u0000\u0000\u0000\u0165\u0168\u0001\u0000\u0000\u0000"+
"\u0166\u0164\u0001\u0000\u0000\u0000\u0167\u015f\u0001\u0000\u0000\u0000"+
"\u0167\u0168\u0001\u0000\u0000\u0000\u0168\u0169\u0001\u0000\u0000\u0000"+
"\u0169\u016a\u0005\f\u0000\u0000\u016a\u016b\u0005\u000e\u0000\u0000\u016b"+
"\u016c\u0005\b\u0000\u0000\u016c3\u0001\u0000\u0000\u0000\u016d\u0176"+
"\u0005\u0007\u0000\u0000\u016e\u0173\u00036\u001b\u0000\u016f\u0170\u0005"+
"\u0006\u0000\u0000\u0170\u0172\u00036\u001b\u0000\u0171\u016f\u0001\u0000"+
"\u0000\u0000\u0172\u0175\u0001\u0000\u0000\u0000\u0173\u0171\u0001\u0000"+
"\u0000\u0000\u0173\u0174\u0001\u0000\u0000\u0000\u0174\u0177\u0001\u0000"+
"\u0000\u0000\u0175\u0173\u0001\u0000\u0000\u0000\u0176\u016e\u0001\u0000"+
"\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000\u0177\u0178\u0001\u0000"+
"\u0000\u0000\u0178\u0179\u0005\f\u0000\u0000\u0179\u017a\u0005\u000f\u0000"+
"\u0000\u017a\u017b\u0005\b\u0000\u0000\u017b5\u0001\u0000\u0000\u0000"+
"\u017c\u017f\u0003@ \u0000\u017d\u017f\u0003\b\u0004\u0000\u017e\u017c"+
"\u0001\u0000\u0000\u0000\u017e\u017d\u0001\u0000\u0000\u0000\u017f7\u0001"+
"\u0000\u0000\u0000\u0180\u0181\u0003\b\u0004\u0000\u01819\u0001\u0000"+
"\u0000\u0000\u0182\u0183\u0005\u0010\u0000\u0000\u0183\u0184\u0003<\u001e"+
"\u0000\u0184\u0185\u0005\u0011\u0000\u0000\u0185\u0186\u0003>\u001f\u0000"+
"\u0186;\u0001\u0000\u0000\u0000\u0187\u018c\u0003@ \u0000\u0188\u0189"+
"\u0005\u0012\u0000\u0000\u0189\u018b\u0003@ \u0000\u018a\u0188\u0001\u0000"+
"\u0000\u0000\u018b\u018e\u0001\u0000\u0000\u0000\u018c\u018a\u0001\u0000"+
"\u0000\u0000\u018c\u018d\u0001\u0000\u0000\u0000\u018d=\u0001\u0000\u0000"+
"\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018f\u0194\u0003@ \u0000\u0190"+
"\u0191\u0005\u0012\u0000\u0000\u0191\u0193\u0003@ \u0000\u0192\u0190\u0001"+
"\u0000\u0000\u0000\u0193\u0196\u0001\u0000\u0000\u0000\u0194\u0192\u0001"+
"\u0000\u0000\u0000\u0194\u0195\u0001\u0000\u0000\u0000\u0195?\u0001\u0000"+
"\u0000\u0000\u0196\u0194\u0001\u0000\u0000\u0000\u0197\u0199\u0003B!\u0000"+
"\u0198\u0197\u0001\u0000\u0000\u0000\u0198\u0199\u0001\u0000\u0000\u0000"+
"\u0199\u019a\u0001\u0000\u0000\u0000\u019a\u019b\u0005\u0014\u0000\u0000"+
"\u019bA\u0001\u0000\u0000\u0000\u019c\u019d\u0005\u0013\u0000\u0000\u019d"+
"C\u0001\u0000\u0000\u0000\u019e\u01a0\u0005\u0011\u0000\u0000\u019f\u019e"+
"\u0001\u0000\u0000\u0000\u019f\u01a0\u0001\u0000\u0000\u0000\u01a0\u01a1"+
"\u0001\u0000\u0000\u0000\u01a1\u01a2\u0005\u0013\u0000\u0000\u01a2E\u0001"+
"\u0000\u0000\u00002IQTZ]cfks}\u0082\u0089\u0093\u009b\u00a3\u00ad\u00b5"+
"\u00b8\u00bf\u00c7\u00d3\u00da\u00de\u00e3\u00e8\u00ec\u00fc\u0104\u010d"+
"\u0117\u011f\u0122\u0126\u0130\u0133\u013f\u0142\u014b\u0153\u0156\u015a"+
"\u0164\u0167\u0173\u0176\u017e\u018c\u0194\u0198\u019f";
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);
}
}
}