com.github.triceo.robozonky.strategy.natural.NaturalLanguageStrategyParser Maven / Gradle / Ivy
// Generated from com/github/triceo/robozonky/strategy/natural/NaturalLanguageStrategy.g4 by ANTLR 4.7
package com.github.triceo.robozonky.strategy.natural;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import com.github.triceo.robozonky.api.remote.enums.*;
import com.github.triceo.robozonky.api.remote.entities.*;
import com.github.triceo.robozonky.strategy.natural.*;
import com.github.triceo.robozonky.strategy.natural.*;
import java.math.BigInteger;
import java.util.Collection;
import java.util.LinkedHashSet;
import com.github.triceo.robozonky.api.remote.enums.*;
import com.github.triceo.robozonky.api.remote.entities.*;
import com.github.triceo.robozonky.strategy.natural.*;
import com.github.triceo.robozonky.strategy.natural.*;
import java.math.BigInteger;
import com.github.triceo.robozonky.strategy.natural.*;
import java.util.Collection;
import com.github.triceo.robozonky.strategy.natural.*;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class NaturalLanguageStrategyParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38,
T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, KC=44, DOT=45, DELIM=46,
UP_TO=47, OR=48, COMMA=49, REGION_A=50, REGION_B=51, REGION_C=52, REGION_E=53,
REGION_H=54, REGION_J=55, REGION_K=56, REGION_L=57, REGION_M=58, REGION_P=59,
REGION_S=60, REGION_T=61, REGION_U=62, REGION_Z=63, RATING_AAAAA=64, RATING_AAAA=65,
RATING_AAA=66, RATING_AA=67, RATING_A=68, RATING_B=69, RATING_C=70, RATING_D=71,
INCOME_EMPLOYMENT=72, INCOME_ENTREPRENEUR=73, INCOME_LIBERAL_PROFESSION=74,
INCOME_MATERNITY_LEAVE=75, INCOME_PENSION=76, INCOME_SELF_EMPLOYMENT=77,
INCOME_STUDENT=78, INCOME_UNEMPLOYED=79, INCOME_OTHER=80, PURPOSE_AUTO_MOTO=81,
PURPOSE_CESTOVANI=82, PURPOSE_DOMACNOST=83, PURPOSE_ELEKTRONIKA=84, PURPOSE_REFINANCOVANI_PUJCEK=85,
PURPOSE_VLASTNI_PROJEKT=86, PURPOSE_VZDELANI=87, PURPOSE_ZDRAVI=88, PURPOSE_JINE=89,
INTEGER=90, COMMENT=91, WHITESPACE=92;
public static final int
RULE_primaryExpression = 0, RULE_complexExpression = 1, RULE_defaultExpression = 2,
RULE_defaultInvestmentSizeExpression = 3, RULE_defaultInvestmentShareExpression = 4,
RULE_targetPortfolioSizeExpression = 5, RULE_targetBalanceExpression = 6,
RULE_confirmationExpression = 7, RULE_portfolioExpression = 8, RULE_ratingCondition = 9,
RULE_ratingExpression = 10, RULE_ratingEnumeratedExpression = 11, RULE_regionExpression = 12,
RULE_incomeExpression = 13, RULE_purposeExpression = 14, RULE_investmentSizeExpression = 15,
RULE_investmentSizeRatingExpression = 16, RULE_portfolioStructureExpression = 17,
RULE_portfolioStructureRatingExpression = 18, RULE_marketplaceFilterExpression = 19,
RULE_marketplaceFilter = 20, RULE_marketplaceFilterConditions = 21, RULE_marketplaceFilterCondition = 22,
RULE_regionCondition = 23, RULE_incomeCondition = 24, RULE_purposeCondition = 25,
RULE_storyCondition = 26, RULE_termCondition = 27, RULE_termConditionRangeOpen = 28,
RULE_termConditionRangeClosedLeft = 29, RULE_termConditionRangeClosedRight = 30,
RULE_amountCondition = 31, RULE_amountConditionRangeOpen = 32, RULE_amountConditionRangeClosedLeft = 33,
RULE_amountConditionRangeClosedRight = 34;
public static final String[] ruleNames = {
"primaryExpression", "complexExpression", "defaultExpression", "defaultInvestmentSizeExpression",
"defaultInvestmentShareExpression", "targetPortfolioSizeExpression", "targetBalanceExpression",
"confirmationExpression", "portfolioExpression", "ratingCondition", "ratingExpression",
"ratingEnumeratedExpression", "regionExpression", "incomeExpression",
"purposeExpression", "investmentSizeExpression", "investmentSizeRatingExpression",
"portfolioStructureExpression", "portfolioStructureRatingExpression",
"marketplaceFilterExpression", "marketplaceFilter", "marketplaceFilterConditions",
"marketplaceFilterCondition", "regionCondition", "incomeCondition", "purposeCondition",
"storyCondition", "termCondition", "termConditionRangeOpen", "termConditionRangeClosedLeft",
"termConditionRangeClosedRight", "amountCondition", "amountConditionRangeOpen",
"amountConditionRangeClosedLeft", "amountConditionRangeClosedRight"
};
private static final String[] _LITERAL_NAMES = {
null, "'Obecn\u00E1 nastaven\u00ED'", "'\u00DAprava struktury portfolia'",
"'V\u00FD\u0161e investice'", "'Filtrov\u00E1n\u00ED tr\u017Ei\u0161t\u011B'",
"'B\u011B\u017En\u00E1 v\u00FD\u0161e investice je '", "' '", "'Investovat maxim\u00E1ln\u011B '",
"' % v\u00FD\u0161e \u00FAv\u011Bru'", "'C\u00EDlov\u00E1 z\u016Fstatkov\u00E1 \u010D\u00E1stka je '",
"'Investovat pouze pokud disponibiln\u00ED z\u016Fstatek p\u0159es\u00E1hne '",
"'Potvrzovat mobilem investice do \u00FAv\u011Br\u016F, kde '", "'Robot m\u00E1 udr\u017Eovat '",
"'konzervativn\u00ED'", "'balancovan\u00E9'", "'progresivn\u00ED'", "'pr\u00E1zdn\u00E9'",
"' portfolio'", "'rating je '", "'lep\u0161\u00ED ne\u017E '", "'hor\u0161\u00ED ne\u017E '",
"'Do \u00FAv\u011Br\u016F v ratingu '", "' investovat'", "'Prost\u0159edky v ratingu '",
"' tvo\u0159\u00ED '", "' % aktu\u00E1ln\u00ED z\u016Fstatkov\u00E9 \u010D\u00E1stky'",
"'Ignorovat \u00FAv\u011Br, kde: '", "'(Ale ne kdy\u017E: '", "')'", "'; '",
"'kraj klienta je '", "'klient je '", "'\u00FA\u010Del je '", "'p\u0159\u00EDb\u011Bh je '",
"'velmi kr\u00E1tk\u00FD'", "'krat\u0161\u00ED ne\u017E pr\u016Fm\u011Brn\u00FD'",
"'pr\u016Fm\u011Brn\u011B dlouh\u00FD'", "'del\u0161\u00ED ne\u017E pr\u016Fm\u011Brn\u00FD'",
"'d\u00E9lka '", "' m\u011Bs\u00EDc\u016F'", "'je '", "'p\u0159esahuje '",
"'nedosahuje '", "'v\u00FD\u0161e '", "'K\u010D'", "'.'", "'- '", "' a\u017E '",
"' nebo '", "', '", "'Praha'", "'Jihomoravsk\u00FD'", "'Jiho\u010Desk\u00FD'",
"'Pardubick\u00FD'", "'Kr\u00E1lov\u00E9hradeck\u00FD'", "'Vyso\u010Dina'",
"'Karlovarsk\u00FD'", "'Libereck\u00FD'", "'Olomouck\u00FD'", "'Plze\u0148sk\u00FD'",
"'St\u0159edo\u010Desk\u00FD'", "'Moravskoslezsk\u00FD'", "'\u00DAsteck\u00FD'",
"'Zl\u00EDnsk\u00FD'", "'A**'", "'A*'", "'A++'", "'A+'", "'A'", "'B'",
"'C'", "'D'", "'zam\u011Bstnanec'", "'podnikatel'", "'svobodn\u00E9 povol\u00E1n\u00ED'",
"'na rodi\u010Dovsk\u00E9 dovolen\u00E9'", "'d\u016Fchodce'", "'OSV\u010C'",
"'student'", "'bez zam\u011Bstn\u00E1n\u00ED'", "'ostatn\u00ED'", "'auto-moto'",
"'cestov\u00E1n\u00ED'", "'dom\u00E1cnost'", "'elektronika'", "'refinancov\u00E1n\u00ED p\u016Fj\u010Dek'",
"'vlastn\u00ED projekt'", "'vzd\u011Bl\u00E1n\u00ED'", "'zdrav\u00ED'",
"'jin\u00E9'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, "KC", "DOT", "DELIM",
"UP_TO", "OR", "COMMA", "REGION_A", "REGION_B", "REGION_C", "REGION_E",
"REGION_H", "REGION_J", "REGION_K", "REGION_L", "REGION_M", "REGION_P",
"REGION_S", "REGION_T", "REGION_U", "REGION_Z", "RATING_AAAAA", "RATING_AAAA",
"RATING_AAA", "RATING_AA", "RATING_A", "RATING_B", "RATING_C", "RATING_D",
"INCOME_EMPLOYMENT", "INCOME_ENTREPRENEUR", "INCOME_LIBERAL_PROFESSION",
"INCOME_MATERNITY_LEAVE", "INCOME_PENSION", "INCOME_SELF_EMPLOYMENT",
"INCOME_STUDENT", "INCOME_UNEMPLOYED", "INCOME_OTHER", "PURPOSE_AUTO_MOTO",
"PURPOSE_CESTOVANI", "PURPOSE_DOMACNOST", "PURPOSE_ELEKTRONIKA", "PURPOSE_REFINANCOVANI_PUJCEK",
"PURPOSE_VLASTNI_PROJEKT", "PURPOSE_VZDELANI", "PURPOSE_ZDRAVI", "PURPOSE_JINE",
"INTEGER", "COMMENT", "WHITESPACE"
};
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 "NaturalLanguageStrategy.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public NaturalLanguageStrategyParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class PrimaryExpressionContext extends ParserRuleContext {
public ParsedStrategy result;
public PortfolioExpressionContext s;
public ComplexExpressionContext c;
public PortfolioExpressionContext portfolioExpression() {
return getRuleContext(PortfolioExpressionContext.class,0);
}
public ComplexExpressionContext complexExpression() {
return getRuleContext(ComplexExpressionContext.class,0);
}
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_primaryExpression);
try {
setState(76);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__11:
enterOuterAlt(_localctx, 1);
{
{
setState(70);
((PrimaryExpressionContext)_localctx).s = portfolioExpression();
((PrimaryExpressionContext)_localctx).result = new ParsedStrategy(((PrimaryExpressionContext)_localctx).s.result);
}
}
break;
case DELIM:
enterOuterAlt(_localctx, 2);
{
{
setState(73);
((PrimaryExpressionContext)_localctx).c = complexExpression();
((PrimaryExpressionContext)_localctx).result = ((PrimaryExpressionContext)_localctx).c.result;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ComplexExpressionContext extends ParserRuleContext {
public ParsedStrategy result;
public DefaultExpressionContext d;
public PortfolioStructureExpressionContext p;
public InvestmentSizeExpressionContext i;
public MarketplaceFilterExpressionContext m;
public List DELIM() { return getTokens(NaturalLanguageStrategyParser.DELIM); }
public TerminalNode DELIM(int i) {
return getToken(NaturalLanguageStrategyParser.DELIM, i);
}
public TerminalNode EOF() { return getToken(NaturalLanguageStrategyParser.EOF, 0); }
public DefaultExpressionContext defaultExpression() {
return getRuleContext(DefaultExpressionContext.class,0);
}
public PortfolioStructureExpressionContext portfolioStructureExpression() {
return getRuleContext(PortfolioStructureExpressionContext.class,0);
}
public InvestmentSizeExpressionContext investmentSizeExpression() {
return getRuleContext(InvestmentSizeExpressionContext.class,0);
}
public MarketplaceFilterExpressionContext marketplaceFilterExpression() {
return getRuleContext(MarketplaceFilterExpressionContext.class,0);
}
public ComplexExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_complexExpression; }
}
public final ComplexExpressionContext complexExpression() throws RecognitionException {
ComplexExpressionContext _localctx = new ComplexExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_complexExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(78);
match(DELIM);
setState(79);
match(T__0);
setState(80);
((ComplexExpressionContext)_localctx).d = defaultExpression();
Collection portfolioStructures = Collections.emptyList();
setState(87);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(82);
match(DELIM);
setState(83);
match(T__1);
setState(84);
((ComplexExpressionContext)_localctx).p = portfolioStructureExpression();
portfolioStructures = ((ComplexExpressionContext)_localctx).p.result;
}
break;
}
Collection investmentSizes = Collections.emptyList();
setState(95);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(90);
match(DELIM);
setState(91);
match(T__2);
setState(92);
((ComplexExpressionContext)_localctx).i = investmentSizeExpression();
investmentSizes = ((ComplexExpressionContext)_localctx).i.result;
}
break;
}
Collection filters = Collections.emptyList();
setState(103);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DELIM) {
{
setState(98);
match(DELIM);
setState(99);
match(T__3);
setState(100);
((ComplexExpressionContext)_localctx).m = marketplaceFilterExpression();
filters = ((ComplexExpressionContext)_localctx).m.result;
}
}
setState(105);
match(EOF);
((ComplexExpressionContext)_localctx).result = new ParsedStrategy(((ComplexExpressionContext)_localctx).d.result, portfolioStructures, investmentSizes, filters);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultExpressionContext extends ParserRuleContext {
public DefaultValues result;
public PortfolioExpressionContext r;
public TargetPortfolioSizeExpressionContext p;
public DefaultInvestmentSizeExpressionContext d;
public DefaultInvestmentShareExpressionContext s;
public TargetBalanceExpressionContext b;
public ConfirmationExpressionContext c;
public PortfolioExpressionContext portfolioExpression() {
return getRuleContext(PortfolioExpressionContext.class,0);
}
public TargetPortfolioSizeExpressionContext targetPortfolioSizeExpression() {
return getRuleContext(TargetPortfolioSizeExpressionContext.class,0);
}
public DefaultInvestmentSizeExpressionContext defaultInvestmentSizeExpression() {
return getRuleContext(DefaultInvestmentSizeExpressionContext.class,0);
}
public DefaultInvestmentShareExpressionContext defaultInvestmentShareExpression() {
return getRuleContext(DefaultInvestmentShareExpressionContext.class,0);
}
public TargetBalanceExpressionContext targetBalanceExpression() {
return getRuleContext(TargetBalanceExpressionContext.class,0);
}
public ConfirmationExpressionContext confirmationExpression() {
return getRuleContext(ConfirmationExpressionContext.class,0);
}
public DefaultExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultExpression; }
}
public final DefaultExpressionContext defaultExpression() throws RecognitionException {
DefaultExpressionContext _localctx = new DefaultExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_defaultExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
((DefaultExpressionContext)_localctx).r = portfolioExpression();
((DefaultExpressionContext)_localctx).result = new DefaultValues(((DefaultExpressionContext)_localctx).r.result);
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__8) {
{
setState(110);
((DefaultExpressionContext)_localctx).p = targetPortfolioSizeExpression();
_localctx.result.setTargetPortfolioSize(((DefaultExpressionContext)_localctx).p.result);
}
}
setState(118);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4) {
{
setState(115);
((DefaultExpressionContext)_localctx).d = defaultInvestmentSizeExpression();
_localctx.result.setInvestmentSize(((DefaultExpressionContext)_localctx).d.result);
}
}
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__6) {
{
setState(120);
((DefaultExpressionContext)_localctx).s = defaultInvestmentShareExpression();
_localctx.result.setInvestmentShare(((DefaultExpressionContext)_localctx).s.result);
}
}
setState(128);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(125);
((DefaultExpressionContext)_localctx).b = targetBalanceExpression();
_localctx.result.setMinimumBalance(((DefaultExpressionContext)_localctx).b.result);
}
}
setState(133);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__10) {
{
setState(130);
((DefaultExpressionContext)_localctx).c = confirmationExpression();
_localctx.result.setConfirmationCondition(((DefaultExpressionContext)_localctx).c.result);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultInvestmentSizeExpressionContext extends ParserRuleContext {
public DefaultInvestmentSize result;
public Token maximumInvestmentInCzk;
public Token minimumInvestmentInCzk;
public TerminalNode KC() { return getToken(NaturalLanguageStrategyParser.KC, 0); }
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public TerminalNode UP_TO() { return getToken(NaturalLanguageStrategyParser.UP_TO, 0); }
public List INTEGER() { return getTokens(NaturalLanguageStrategyParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(NaturalLanguageStrategyParser.INTEGER, i);
}
public DefaultInvestmentSizeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultInvestmentSizeExpression; }
}
public final DefaultInvestmentSizeExpressionContext defaultInvestmentSizeExpression() throws RecognitionException {
DefaultInvestmentSizeExpressionContext _localctx = new DefaultInvestmentSizeExpressionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_defaultInvestmentSizeExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
match(T__4);
setState(142);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
{
setState(136);
((DefaultInvestmentSizeExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((DefaultInvestmentSizeExpressionContext)_localctx).result = new DefaultInvestmentSize(Integer.parseInt(((DefaultInvestmentSizeExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
case 2:
{
{
setState(138);
((DefaultInvestmentSizeExpressionContext)_localctx).minimumInvestmentInCzk = match(INTEGER);
setState(139);
match(UP_TO);
setState(140);
((DefaultInvestmentSizeExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((DefaultInvestmentSizeExpressionContext)_localctx).result = new DefaultInvestmentSize(Integer.parseInt(((DefaultInvestmentSizeExpressionContext)_localctx).minimumInvestmentInCzk.getText()),
Integer.parseInt(((DefaultInvestmentSizeExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
}
setState(144);
match(T__5);
setState(145);
match(KC);
setState(146);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultInvestmentShareExpressionContext extends ParserRuleContext {
public DefaultInvestmentShare result;
public Token maximumInvestmentInCzk;
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public DefaultInvestmentShareExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultInvestmentShareExpression; }
}
public final DefaultInvestmentShareExpressionContext defaultInvestmentShareExpression() throws RecognitionException {
DefaultInvestmentShareExpressionContext _localctx = new DefaultInvestmentShareExpressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_defaultInvestmentShareExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(148);
match(T__6);
setState(149);
((DefaultInvestmentShareExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((DefaultInvestmentShareExpressionContext)_localctx).result = new DefaultInvestmentShare(Integer.parseInt(((DefaultInvestmentShareExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
setState(151);
match(T__7);
setState(152);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TargetPortfolioSizeExpressionContext extends ParserRuleContext {
public int result;
public Token maximumInvestmentInCzk;
public TerminalNode KC() { return getToken(NaturalLanguageStrategyParser.KC, 0); }
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public TargetPortfolioSizeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetPortfolioSizeExpression; }
}
public final TargetPortfolioSizeExpressionContext targetPortfolioSizeExpression() throws RecognitionException {
TargetPortfolioSizeExpressionContext _localctx = new TargetPortfolioSizeExpressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_targetPortfolioSizeExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(154);
match(T__8);
setState(155);
((TargetPortfolioSizeExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
setState(156);
match(T__5);
setState(157);
match(KC);
setState(158);
match(DOT);
((TargetPortfolioSizeExpressionContext)_localctx).result = Integer.parseInt(((TargetPortfolioSizeExpressionContext)_localctx).maximumInvestmentInCzk.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TargetBalanceExpressionContext extends ParserRuleContext {
public int result;
public Token balance;
public TerminalNode KC() { return getToken(NaturalLanguageStrategyParser.KC, 0); }
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public TargetBalanceExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetBalanceExpression; }
}
public final TargetBalanceExpressionContext targetBalanceExpression() throws RecognitionException {
TargetBalanceExpressionContext _localctx = new TargetBalanceExpressionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_targetBalanceExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(161);
match(T__9);
setState(162);
((TargetBalanceExpressionContext)_localctx).balance = match(INTEGER);
setState(163);
match(T__5);
setState(164);
match(KC);
setState(165);
match(DOT);
((TargetBalanceExpressionContext)_localctx).result = Integer.parseInt(((TargetBalanceExpressionContext)_localctx).balance.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConfirmationExpressionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public RatingConditionContext r;
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public RatingConditionContext ratingCondition() {
return getRuleContext(RatingConditionContext.class,0);
}
public ConfirmationExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_confirmationExpression; }
}
public final ConfirmationExpressionContext confirmationExpression() throws RecognitionException {
ConfirmationExpressionContext _localctx = new ConfirmationExpressionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_confirmationExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(168);
match(T__10);
setState(169);
((ConfirmationExpressionContext)_localctx).r = ratingCondition();
setState(170);
match(DOT);
((ConfirmationExpressionContext)_localctx).result = ((ConfirmationExpressionContext)_localctx).r.result;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PortfolioExpressionContext extends ParserRuleContext {
public DefaultPortfolio result;
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public PortfolioExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_portfolioExpression; }
}
public final PortfolioExpressionContext portfolioExpression() throws RecognitionException {
PortfolioExpressionContext _localctx = new PortfolioExpressionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_portfolioExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(173);
match(T__11);
setState(182);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__12:
{
{
setState(174);
match(T__12);
((PortfolioExpressionContext)_localctx).result = DefaultPortfolio.CONSERVATIVE;
}
}
break;
case T__13:
{
{
setState(176);
match(T__13);
((PortfolioExpressionContext)_localctx).result = DefaultPortfolio.BALANCED;
}
}
break;
case T__14:
{
{
setState(178);
match(T__14);
((PortfolioExpressionContext)_localctx).result = DefaultPortfolio.PROGRESSIVE;
}
}
break;
case T__15:
{
{
setState(180);
match(T__15);
((PortfolioExpressionContext)_localctx).result = DefaultPortfolio.EMPTY;
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(184);
match(T__16);
setState(185);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RatingConditionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public RatingEnumeratedExpressionContext r1;
public RatingExpressionContext r2;
public RatingExpressionContext r3;
public RatingEnumeratedExpressionContext ratingEnumeratedExpression() {
return getRuleContext(RatingEnumeratedExpressionContext.class,0);
}
public RatingExpressionContext ratingExpression() {
return getRuleContext(RatingExpressionContext.class,0);
}
public RatingConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratingCondition; }
}
public final RatingConditionContext ratingCondition() throws RecognitionException {
RatingConditionContext _localctx = new RatingConditionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_ratingCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(187);
match(T__17);
setState(199);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RATING_AAAAA:
case RATING_AAAA:
case RATING_AAA:
case RATING_AA:
case RATING_A:
case RATING_B:
case RATING_C:
case RATING_D:
{
{
setState(188);
((RatingConditionContext)_localctx).r1 = ratingEnumeratedExpression();
AbstractEnumeratedCondition c = new LoanRatingEnumeratedCondition();
c.add(((RatingConditionContext)_localctx).r1.result);
((RatingConditionContext)_localctx).result = c;
}
}
break;
case T__18:
{
{
setState(191);
match(T__18);
setState(192);
((RatingConditionContext)_localctx).r2 = ratingExpression();
((RatingConditionContext)_localctx).result = new LoanRatingBetterOrEqualCondition(((RatingConditionContext)_localctx).r2.result);
}
}
break;
case T__19:
{
{
setState(195);
match(T__19);
setState(196);
((RatingConditionContext)_localctx).r3 = ratingExpression();
((RatingConditionContext)_localctx).result = new LoanRatingWorseOrEqualCondition(((RatingConditionContext)_localctx).r3.result);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RatingExpressionContext extends ParserRuleContext {
public Rating result;
public Token r;
public TerminalNode RATING_AAAAA() { return getToken(NaturalLanguageStrategyParser.RATING_AAAAA, 0); }
public TerminalNode RATING_AAAA() { return getToken(NaturalLanguageStrategyParser.RATING_AAAA, 0); }
public TerminalNode RATING_AAA() { return getToken(NaturalLanguageStrategyParser.RATING_AAA, 0); }
public TerminalNode RATING_AA() { return getToken(NaturalLanguageStrategyParser.RATING_AA, 0); }
public TerminalNode RATING_A() { return getToken(NaturalLanguageStrategyParser.RATING_A, 0); }
public TerminalNode RATING_B() { return getToken(NaturalLanguageStrategyParser.RATING_B, 0); }
public TerminalNode RATING_C() { return getToken(NaturalLanguageStrategyParser.RATING_C, 0); }
public TerminalNode RATING_D() { return getToken(NaturalLanguageStrategyParser.RATING_D, 0); }
public RatingExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratingExpression; }
}
public final RatingExpressionContext ratingExpression() throws RecognitionException {
RatingExpressionContext _localctx = new RatingExpressionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_ratingExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(201);
((RatingExpressionContext)_localctx).r = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (RATING_AAAAA - 64)) | (1L << (RATING_AAAA - 64)) | (1L << (RATING_AAA - 64)) | (1L << (RATING_AA - 64)) | (1L << (RATING_A - 64)) | (1L << (RATING_B - 64)) | (1L << (RATING_C - 64)) | (1L << (RATING_D - 64)))) != 0)) ) {
((RatingExpressionContext)_localctx).r = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((RatingExpressionContext)_localctx).result = Rating.findByCode(((RatingExpressionContext)_localctx).r.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RatingEnumeratedExpressionContext extends ParserRuleContext {
public Collection result;
public RatingExpressionContext r1;
public RatingExpressionContext r2;
public RatingExpressionContext r3;
public List ratingExpression() {
return getRuleContexts(RatingExpressionContext.class);
}
public RatingExpressionContext ratingExpression(int i) {
return getRuleContext(RatingExpressionContext.class,i);
}
public TerminalNode OR() { return getToken(NaturalLanguageStrategyParser.OR, 0); }
public List COMMA() { return getTokens(NaturalLanguageStrategyParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(NaturalLanguageStrategyParser.COMMA, i);
}
public RatingEnumeratedExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratingEnumeratedExpression; }
}
public final RatingEnumeratedExpressionContext ratingEnumeratedExpression() throws RecognitionException {
RatingEnumeratedExpressionContext _localctx = new RatingEnumeratedExpressionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_ratingEnumeratedExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
((RatingEnumeratedExpressionContext)_localctx).result = new LinkedHashSet();
setState(218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(211);
_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(205);
((RatingEnumeratedExpressionContext)_localctx).r1 = ratingExpression();
setState(206);
match(COMMA);
_localctx.result.add(((RatingEnumeratedExpressionContext)_localctx).r1.result);
}
}
}
setState(213);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
setState(214);
((RatingEnumeratedExpressionContext)_localctx).r2 = ratingExpression();
setState(215);
match(OR);
_localctx.result.add(((RatingEnumeratedExpressionContext)_localctx).r2.result);
}
break;
}
setState(220);
((RatingEnumeratedExpressionContext)_localctx).r3 = ratingExpression();
_localctx.result.add(((RatingEnumeratedExpressionContext)_localctx).r3.result);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegionExpressionContext extends ParserRuleContext {
public Region result;
public Token r;
public TerminalNode REGION_A() { return getToken(NaturalLanguageStrategyParser.REGION_A, 0); }
public TerminalNode REGION_B() { return getToken(NaturalLanguageStrategyParser.REGION_B, 0); }
public TerminalNode REGION_C() { return getToken(NaturalLanguageStrategyParser.REGION_C, 0); }
public TerminalNode REGION_E() { return getToken(NaturalLanguageStrategyParser.REGION_E, 0); }
public TerminalNode REGION_H() { return getToken(NaturalLanguageStrategyParser.REGION_H, 0); }
public TerminalNode REGION_J() { return getToken(NaturalLanguageStrategyParser.REGION_J, 0); }
public TerminalNode REGION_K() { return getToken(NaturalLanguageStrategyParser.REGION_K, 0); }
public TerminalNode REGION_L() { return getToken(NaturalLanguageStrategyParser.REGION_L, 0); }
public TerminalNode REGION_M() { return getToken(NaturalLanguageStrategyParser.REGION_M, 0); }
public TerminalNode REGION_P() { return getToken(NaturalLanguageStrategyParser.REGION_P, 0); }
public TerminalNode REGION_S() { return getToken(NaturalLanguageStrategyParser.REGION_S, 0); }
public TerminalNode REGION_T() { return getToken(NaturalLanguageStrategyParser.REGION_T, 0); }
public TerminalNode REGION_U() { return getToken(NaturalLanguageStrategyParser.REGION_U, 0); }
public TerminalNode REGION_Z() { return getToken(NaturalLanguageStrategyParser.REGION_Z, 0); }
public RegionExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regionExpression; }
}
public final RegionExpressionContext regionExpression() throws RecognitionException {
RegionExpressionContext _localctx = new RegionExpressionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_regionExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(223);
((RegionExpressionContext)_localctx).r = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REGION_A) | (1L << REGION_B) | (1L << REGION_C) | (1L << REGION_E) | (1L << REGION_H) | (1L << REGION_J) | (1L << REGION_K) | (1L << REGION_L) | (1L << REGION_M) | (1L << REGION_P) | (1L << REGION_S) | (1L << REGION_T) | (1L << REGION_U) | (1L << REGION_Z))) != 0)) ) {
((RegionExpressionContext)_localctx).r = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((RegionExpressionContext)_localctx).result = Region.findByCode(((RegionExpressionContext)_localctx).r.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IncomeExpressionContext extends ParserRuleContext {
public MainIncomeType result;
public Token r;
public TerminalNode INCOME_EMPLOYMENT() { return getToken(NaturalLanguageStrategyParser.INCOME_EMPLOYMENT, 0); }
public TerminalNode INCOME_ENTREPRENEUR() { return getToken(NaturalLanguageStrategyParser.INCOME_ENTREPRENEUR, 0); }
public TerminalNode INCOME_SELF_EMPLOYMENT() { return getToken(NaturalLanguageStrategyParser.INCOME_SELF_EMPLOYMENT, 0); }
public TerminalNode INCOME_PENSION() { return getToken(NaturalLanguageStrategyParser.INCOME_PENSION, 0); }
public TerminalNode INCOME_MATERNITY_LEAVE() { return getToken(NaturalLanguageStrategyParser.INCOME_MATERNITY_LEAVE, 0); }
public TerminalNode INCOME_STUDENT() { return getToken(NaturalLanguageStrategyParser.INCOME_STUDENT, 0); }
public TerminalNode INCOME_UNEMPLOYED() { return getToken(NaturalLanguageStrategyParser.INCOME_UNEMPLOYED, 0); }
public TerminalNode INCOME_LIBERAL_PROFESSION() { return getToken(NaturalLanguageStrategyParser.INCOME_LIBERAL_PROFESSION, 0); }
public TerminalNode INCOME_OTHER() { return getToken(NaturalLanguageStrategyParser.INCOME_OTHER, 0); }
public IncomeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_incomeExpression; }
}
public final IncomeExpressionContext incomeExpression() throws RecognitionException {
IncomeExpressionContext _localctx = new IncomeExpressionContext(_ctx, getState());
enterRule(_localctx, 26, RULE_incomeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(226);
((IncomeExpressionContext)_localctx).r = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (INCOME_EMPLOYMENT - 72)) | (1L << (INCOME_ENTREPRENEUR - 72)) | (1L << (INCOME_LIBERAL_PROFESSION - 72)) | (1L << (INCOME_MATERNITY_LEAVE - 72)) | (1L << (INCOME_PENSION - 72)) | (1L << (INCOME_SELF_EMPLOYMENT - 72)) | (1L << (INCOME_STUDENT - 72)) | (1L << (INCOME_UNEMPLOYED - 72)) | (1L << (INCOME_OTHER - 72)))) != 0)) ) {
((IncomeExpressionContext)_localctx).r = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((IncomeExpressionContext)_localctx).result = MainIncomeType.findByCode(((IncomeExpressionContext)_localctx).r.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PurposeExpressionContext extends ParserRuleContext {
public Purpose result;
public Token r;
public TerminalNode PURPOSE_AUTO_MOTO() { return getToken(NaturalLanguageStrategyParser.PURPOSE_AUTO_MOTO, 0); }
public TerminalNode PURPOSE_CESTOVANI() { return getToken(NaturalLanguageStrategyParser.PURPOSE_CESTOVANI, 0); }
public TerminalNode PURPOSE_DOMACNOST() { return getToken(NaturalLanguageStrategyParser.PURPOSE_DOMACNOST, 0); }
public TerminalNode PURPOSE_ELEKTRONIKA() { return getToken(NaturalLanguageStrategyParser.PURPOSE_ELEKTRONIKA, 0); }
public TerminalNode PURPOSE_REFINANCOVANI_PUJCEK() { return getToken(NaturalLanguageStrategyParser.PURPOSE_REFINANCOVANI_PUJCEK, 0); }
public TerminalNode PURPOSE_VLASTNI_PROJEKT() { return getToken(NaturalLanguageStrategyParser.PURPOSE_VLASTNI_PROJEKT, 0); }
public TerminalNode PURPOSE_VZDELANI() { return getToken(NaturalLanguageStrategyParser.PURPOSE_VZDELANI, 0); }
public TerminalNode PURPOSE_ZDRAVI() { return getToken(NaturalLanguageStrategyParser.PURPOSE_ZDRAVI, 0); }
public TerminalNode PURPOSE_JINE() { return getToken(NaturalLanguageStrategyParser.PURPOSE_JINE, 0); }
public PurposeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_purposeExpression; }
}
public final PurposeExpressionContext purposeExpression() throws RecognitionException {
PurposeExpressionContext _localctx = new PurposeExpressionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_purposeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(229);
((PurposeExpressionContext)_localctx).r = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & ((1L << (PURPOSE_AUTO_MOTO - 81)) | (1L << (PURPOSE_CESTOVANI - 81)) | (1L << (PURPOSE_DOMACNOST - 81)) | (1L << (PURPOSE_ELEKTRONIKA - 81)) | (1L << (PURPOSE_REFINANCOVANI_PUJCEK - 81)) | (1L << (PURPOSE_VLASTNI_PROJEKT - 81)) | (1L << (PURPOSE_VZDELANI - 81)) | (1L << (PURPOSE_ZDRAVI - 81)) | (1L << (PURPOSE_JINE - 81)))) != 0)) ) {
((PurposeExpressionContext)_localctx).r = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((PurposeExpressionContext)_localctx).result = Purpose.findByCode(((PurposeExpressionContext)_localctx).r.getText());
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InvestmentSizeExpressionContext extends ParserRuleContext {
public Collection result;
public InvestmentSizeRatingExpressionContext i;
public List investmentSizeRatingExpression() {
return getRuleContexts(InvestmentSizeRatingExpressionContext.class);
}
public InvestmentSizeRatingExpressionContext investmentSizeRatingExpression(int i) {
return getRuleContext(InvestmentSizeRatingExpressionContext.class,i);
}
public InvestmentSizeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_investmentSizeExpression; }
}
public final InvestmentSizeExpressionContext investmentSizeExpression() throws RecognitionException {
InvestmentSizeExpressionContext _localctx = new InvestmentSizeExpressionContext(_ctx, getState());
enterRule(_localctx, 30, RULE_investmentSizeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
Collection result = new LinkedHashSet<>();
setState(236);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(233);
((InvestmentSizeExpressionContext)_localctx).i = investmentSizeRatingExpression();
result.add(((InvestmentSizeExpressionContext)_localctx).i.result);
}
}
setState(238);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__20 );
((InvestmentSizeExpressionContext)_localctx).result = result;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InvestmentSizeRatingExpressionContext extends ParserRuleContext {
public InvestmentSize result;
public RatingExpressionContext r;
public Token amount;
public Token maximumInvestmentInCzk;
public Token minimumInvestmentInCzk;
public TerminalNode KC() { return getToken(NaturalLanguageStrategyParser.KC, 0); }
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public RatingExpressionContext ratingExpression() {
return getRuleContext(RatingExpressionContext.class,0);
}
public TerminalNode UP_TO() { return getToken(NaturalLanguageStrategyParser.UP_TO, 0); }
public List INTEGER() { return getTokens(NaturalLanguageStrategyParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(NaturalLanguageStrategyParser.INTEGER, i);
}
public InvestmentSizeRatingExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_investmentSizeRatingExpression; }
}
public final InvestmentSizeRatingExpressionContext investmentSizeRatingExpression() throws RecognitionException {
InvestmentSizeRatingExpressionContext _localctx = new InvestmentSizeRatingExpressionContext(_ctx, getState());
enterRule(_localctx, 32, RULE_investmentSizeRatingExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(242);
match(T__20);
setState(243);
((InvestmentSizeRatingExpressionContext)_localctx).r = ratingExpression();
setState(244);
match(T__21);
setState(256);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
{
setState(245);
match(T__5);
setState(246);
((InvestmentSizeRatingExpressionContext)_localctx).amount = match(INTEGER);
((InvestmentSizeRatingExpressionContext)_localctx).result = new InvestmentSize(((InvestmentSizeRatingExpressionContext)_localctx).r.result, Integer.parseInt(((InvestmentSizeRatingExpressionContext)_localctx).amount.getText()),
Integer.parseInt(((InvestmentSizeRatingExpressionContext)_localctx).amount.getText()));
}
}
break;
case 2:
{
{
setState(248);
match(UP_TO);
setState(249);
((InvestmentSizeRatingExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((InvestmentSizeRatingExpressionContext)_localctx).result = new InvestmentSize(((InvestmentSizeRatingExpressionContext)_localctx).r.result, Integer.parseInt(((InvestmentSizeRatingExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
case 3:
{
{
setState(251);
match(T__5);
setState(252);
((InvestmentSizeRatingExpressionContext)_localctx).minimumInvestmentInCzk = match(INTEGER);
setState(253);
match(UP_TO);
setState(254);
((InvestmentSizeRatingExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((InvestmentSizeRatingExpressionContext)_localctx).result = new InvestmentSize(((InvestmentSizeRatingExpressionContext)_localctx).r.result, Integer.parseInt(((InvestmentSizeRatingExpressionContext)_localctx).minimumInvestmentInCzk.getText()),
Integer.parseInt(((InvestmentSizeRatingExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
}
setState(258);
match(T__5);
setState(259);
match(KC);
setState(260);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PortfolioStructureExpressionContext extends ParserRuleContext {
public Collection result;
public PortfolioStructureRatingExpressionContext i;
public List portfolioStructureRatingExpression() {
return getRuleContexts(PortfolioStructureRatingExpressionContext.class);
}
public PortfolioStructureRatingExpressionContext portfolioStructureRatingExpression(int i) {
return getRuleContext(PortfolioStructureRatingExpressionContext.class,i);
}
public PortfolioStructureExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_portfolioStructureExpression; }
}
public final PortfolioStructureExpressionContext portfolioStructureExpression() throws RecognitionException {
PortfolioStructureExpressionContext _localctx = new PortfolioStructureExpressionContext(_ctx, getState());
enterRule(_localctx, 34, RULE_portfolioStructureExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
Collection result = new LinkedHashSet<>();
setState(266);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(263);
((PortfolioStructureExpressionContext)_localctx).i = portfolioStructureRatingExpression();
result.add(((PortfolioStructureExpressionContext)_localctx).i.result);
}
}
setState(268);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__22 );
((PortfolioStructureExpressionContext)_localctx).result = result;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PortfolioStructureRatingExpressionContext extends ParserRuleContext {
public PortfolioShare result;
public RatingExpressionContext r;
public Token maximumInvestmentInCzk;
public Token minimumInvestmentInCzk;
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public RatingExpressionContext ratingExpression() {
return getRuleContext(RatingExpressionContext.class,0);
}
public TerminalNode UP_TO() { return getToken(NaturalLanguageStrategyParser.UP_TO, 0); }
public List INTEGER() { return getTokens(NaturalLanguageStrategyParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(NaturalLanguageStrategyParser.INTEGER, i);
}
public PortfolioStructureRatingExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_portfolioStructureRatingExpression; }
}
public final PortfolioStructureRatingExpressionContext portfolioStructureRatingExpression() throws RecognitionException {
PortfolioStructureRatingExpressionContext _localctx = new PortfolioStructureRatingExpressionContext(_ctx, getState());
enterRule(_localctx, 36, RULE_portfolioStructureRatingExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(272);
match(T__22);
setState(273);
((PortfolioStructureRatingExpressionContext)_localctx).r = ratingExpression();
setState(274);
match(T__23);
setState(281);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
{
setState(275);
((PortfolioStructureRatingExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((PortfolioStructureRatingExpressionContext)_localctx).result = new PortfolioShare(((PortfolioStructureRatingExpressionContext)_localctx).r.result, Integer.parseInt(((PortfolioStructureRatingExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
case 2:
{
{
setState(277);
((PortfolioStructureRatingExpressionContext)_localctx).minimumInvestmentInCzk = match(INTEGER);
setState(278);
match(UP_TO);
setState(279);
((PortfolioStructureRatingExpressionContext)_localctx).maximumInvestmentInCzk = match(INTEGER);
((PortfolioStructureRatingExpressionContext)_localctx).result = new PortfolioShare(((PortfolioStructureRatingExpressionContext)_localctx).r.result, Integer.parseInt(((PortfolioStructureRatingExpressionContext)_localctx).minimumInvestmentInCzk.getText()),
Integer.parseInt(((PortfolioStructureRatingExpressionContext)_localctx).maximumInvestmentInCzk.getText()));
}
}
break;
}
setState(283);
match(T__24);
setState(284);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarketplaceFilterExpressionContext extends ParserRuleContext {
public Collection result;
public MarketplaceFilterContext f;
public List marketplaceFilter() {
return getRuleContexts(MarketplaceFilterContext.class);
}
public MarketplaceFilterContext marketplaceFilter(int i) {
return getRuleContext(MarketplaceFilterContext.class,i);
}
public MarketplaceFilterExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_marketplaceFilterExpression; }
}
public final MarketplaceFilterExpressionContext marketplaceFilterExpression() throws RecognitionException {
MarketplaceFilterExpressionContext _localctx = new MarketplaceFilterExpressionContext(_ctx, getState());
enterRule(_localctx, 38, RULE_marketplaceFilterExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
((MarketplaceFilterExpressionContext)_localctx).result = new ArrayList<>();
setState(290);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(287);
((MarketplaceFilterExpressionContext)_localctx).f = marketplaceFilter();
_localctx.result.add(((MarketplaceFilterExpressionContext)_localctx).f.result);
}
}
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__25 );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarketplaceFilterContext extends ParserRuleContext {
public MarketplaceFilter result;
public MarketplaceFilterConditionsContext r;
public MarketplaceFilterConditionsContext s;
public List marketplaceFilterConditions() {
return getRuleContexts(MarketplaceFilterConditionsContext.class);
}
public MarketplaceFilterConditionsContext marketplaceFilterConditions(int i) {
return getRuleContext(MarketplaceFilterConditionsContext.class,i);
}
public MarketplaceFilterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_marketplaceFilter; }
}
public final MarketplaceFilterContext marketplaceFilter() throws RecognitionException {
MarketplaceFilterContext _localctx = new MarketplaceFilterContext(_ctx, getState());
enterRule(_localctx, 40, RULE_marketplaceFilter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
((MarketplaceFilterContext)_localctx).result = new MarketplaceFilter();
setState(295);
match(T__25);
setState(296);
((MarketplaceFilterContext)_localctx).r = marketplaceFilterConditions();
_localctx.result.ignoreWhen(((MarketplaceFilterContext)_localctx).r.result);
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__26) {
{
setState(298);
match(T__26);
setState(299);
((MarketplaceFilterContext)_localctx).s = marketplaceFilterConditions();
_localctx.result.butNotWhen(((MarketplaceFilterContext)_localctx).s.result);
setState(301);
match(T__27);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarketplaceFilterConditionsContext extends ParserRuleContext {
public Collection result;
public MarketplaceFilterConditionContext c1;
public MarketplaceFilterConditionContext c2;
public TerminalNode DOT() { return getToken(NaturalLanguageStrategyParser.DOT, 0); }
public List marketplaceFilterCondition() {
return getRuleContexts(MarketplaceFilterConditionContext.class);
}
public MarketplaceFilterConditionContext marketplaceFilterCondition(int i) {
return getRuleContext(MarketplaceFilterConditionContext.class,i);
}
public MarketplaceFilterConditionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_marketplaceFilterConditions; }
}
public final MarketplaceFilterConditionsContext marketplaceFilterConditions() throws RecognitionException {
MarketplaceFilterConditionsContext _localctx = new MarketplaceFilterConditionsContext(_ctx, getState());
enterRule(_localctx, 42, RULE_marketplaceFilterConditions);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
Collection result = new LinkedHashSet<>();
setState(312);
_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(306);
((MarketplaceFilterConditionsContext)_localctx).c1 = marketplaceFilterCondition();
result.add(((MarketplaceFilterConditionsContext)_localctx).c1.result);
setState(308);
match(T__28);
}
}
}
setState(314);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
}
setState(315);
((MarketplaceFilterConditionsContext)_localctx).c2 = marketplaceFilterCondition();
result.add(((MarketplaceFilterConditionsContext)_localctx).c2.result);
setState(317);
match(DOT);
((MarketplaceFilterConditionsContext)_localctx).result = result;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarketplaceFilterConditionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public RegionConditionContext c1;
public RatingConditionContext c2;
public IncomeConditionContext c3;
public PurposeConditionContext c4;
public StoryConditionContext c5;
public TermConditionContext c6;
public AmountConditionContext c7;
public RegionConditionContext regionCondition() {
return getRuleContext(RegionConditionContext.class,0);
}
public RatingConditionContext ratingCondition() {
return getRuleContext(RatingConditionContext.class,0);
}
public IncomeConditionContext incomeCondition() {
return getRuleContext(IncomeConditionContext.class,0);
}
public PurposeConditionContext purposeCondition() {
return getRuleContext(PurposeConditionContext.class,0);
}
public StoryConditionContext storyCondition() {
return getRuleContext(StoryConditionContext.class,0);
}
public TermConditionContext termCondition() {
return getRuleContext(TermConditionContext.class,0);
}
public AmountConditionContext amountCondition() {
return getRuleContext(AmountConditionContext.class,0);
}
public MarketplaceFilterConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_marketplaceFilterCondition; }
}
public final MarketplaceFilterConditionContext marketplaceFilterCondition() throws RecognitionException {
MarketplaceFilterConditionContext _localctx = new MarketplaceFilterConditionContext(_ctx, getState());
enterRule(_localctx, 44, RULE_marketplaceFilterCondition);
try {
setState(341);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__29:
enterOuterAlt(_localctx, 1);
{
setState(320);
((MarketplaceFilterConditionContext)_localctx).c1 = regionCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c1.result;
}
break;
case T__17:
enterOuterAlt(_localctx, 2);
{
setState(323);
((MarketplaceFilterConditionContext)_localctx).c2 = ratingCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c2.result;
}
break;
case T__30:
enterOuterAlt(_localctx, 3);
{
setState(326);
((MarketplaceFilterConditionContext)_localctx).c3 = incomeCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c3.result;
}
break;
case T__31:
enterOuterAlt(_localctx, 4);
{
setState(329);
((MarketplaceFilterConditionContext)_localctx).c4 = purposeCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c4.result;
}
break;
case T__32:
enterOuterAlt(_localctx, 5);
{
setState(332);
((MarketplaceFilterConditionContext)_localctx).c5 = storyCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c5.result;
}
break;
case T__37:
enterOuterAlt(_localctx, 6);
{
setState(335);
((MarketplaceFilterConditionContext)_localctx).c6 = termCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c6.result;
}
break;
case T__42:
enterOuterAlt(_localctx, 7);
{
setState(338);
((MarketplaceFilterConditionContext)_localctx).c7 = amountCondition();
((MarketplaceFilterConditionContext)_localctx).result = ((MarketplaceFilterConditionContext)_localctx).c7.result;
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RegionConditionContext extends ParserRuleContext {
public BorrowerRegionCondition result;
public RegionExpressionContext r1;
public RegionExpressionContext r2;
public RegionExpressionContext r3;
public List regionExpression() {
return getRuleContexts(RegionExpressionContext.class);
}
public RegionExpressionContext regionExpression(int i) {
return getRuleContext(RegionExpressionContext.class,i);
}
public TerminalNode OR() { return getToken(NaturalLanguageStrategyParser.OR, 0); }
public List COMMA() { return getTokens(NaturalLanguageStrategyParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(NaturalLanguageStrategyParser.COMMA, i);
}
public RegionConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_regionCondition; }
}
public final RegionConditionContext regionCondition() throws RecognitionException {
RegionConditionContext _localctx = new RegionConditionContext(_ctx, getState());
enterRule(_localctx, 46, RULE_regionCondition);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
((RegionConditionContext)_localctx).result = new BorrowerRegionCondition();
setState(344);
match(T__29);
setState(358);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
setState(351);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(345);
((RegionConditionContext)_localctx).r1 = regionExpression();
setState(346);
match(COMMA);
_localctx.result.add(((RegionConditionContext)_localctx).r1.result);
}
}
}
setState(353);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
}
setState(354);
((RegionConditionContext)_localctx).r2 = regionExpression();
setState(355);
match(OR);
_localctx.result.add(((RegionConditionContext)_localctx).r2.result);
}
break;
}
setState(360);
((RegionConditionContext)_localctx).r3 = regionExpression();
_localctx.result.add(((RegionConditionContext)_localctx).r3.result);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IncomeConditionContext extends ParserRuleContext {
public BorrowerIncomeCondition result;
public IncomeExpressionContext i1;
public IncomeExpressionContext i2;
public IncomeExpressionContext i3;
public List incomeExpression() {
return getRuleContexts(IncomeExpressionContext.class);
}
public IncomeExpressionContext incomeExpression(int i) {
return getRuleContext(IncomeExpressionContext.class,i);
}
public TerminalNode OR() { return getToken(NaturalLanguageStrategyParser.OR, 0); }
public List COMMA() { return getTokens(NaturalLanguageStrategyParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(NaturalLanguageStrategyParser.COMMA, i);
}
public IncomeConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_incomeCondition; }
}
public final IncomeConditionContext incomeCondition() throws RecognitionException {
IncomeConditionContext _localctx = new IncomeConditionContext(_ctx, getState());
enterRule(_localctx, 48, RULE_incomeCondition);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
((IncomeConditionContext)_localctx).result = new BorrowerIncomeCondition();
setState(364);
match(T__30);
setState(378);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(371);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(365);
((IncomeConditionContext)_localctx).i1 = incomeExpression();
setState(366);
match(COMMA);
_localctx.result.add(((IncomeConditionContext)_localctx).i1.result);
}
}
}
setState(373);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
setState(374);
((IncomeConditionContext)_localctx).i2 = incomeExpression();
setState(375);
match(OR);
_localctx.result.add(((IncomeConditionContext)_localctx).i2.result);
}
break;
}
setState(380);
((IncomeConditionContext)_localctx).i3 = incomeExpression();
_localctx.result.add(((IncomeConditionContext)_localctx).i3.result);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PurposeConditionContext extends ParserRuleContext {
public LoanPurposeCondition result;
public PurposeExpressionContext p1;
public PurposeExpressionContext p2;
public PurposeExpressionContext p3;
public List purposeExpression() {
return getRuleContexts(PurposeExpressionContext.class);
}
public PurposeExpressionContext purposeExpression(int i) {
return getRuleContext(PurposeExpressionContext.class,i);
}
public TerminalNode OR() { return getToken(NaturalLanguageStrategyParser.OR, 0); }
public List COMMA() { return getTokens(NaturalLanguageStrategyParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(NaturalLanguageStrategyParser.COMMA, i);
}
public PurposeConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_purposeCondition; }
}
public final PurposeConditionContext purposeCondition() throws RecognitionException {
PurposeConditionContext _localctx = new PurposeConditionContext(_ctx, getState());
enterRule(_localctx, 50, RULE_purposeCondition);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
((PurposeConditionContext)_localctx).result = new LoanPurposeCondition();
setState(384);
match(T__31);
setState(398);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
setState(391);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(385);
((PurposeConditionContext)_localctx).p1 = purposeExpression();
setState(386);
match(COMMA);
_localctx.result.add(((PurposeConditionContext)_localctx).p1.result);
}
}
}
setState(393);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
}
setState(394);
((PurposeConditionContext)_localctx).p2 = purposeExpression();
setState(395);
match(OR);
_localctx.result.add(((PurposeConditionContext)_localctx).p2.result);
}
break;
}
setState(400);
((PurposeConditionContext)_localctx).p3 = purposeExpression();
_localctx.result.add(((PurposeConditionContext)_localctx).p3.result);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StoryConditionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public StoryConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_storyCondition; }
}
public final StoryConditionContext storyCondition() throws RecognitionException {
StoryConditionContext _localctx = new StoryConditionContext(_ctx, getState());
enterRule(_localctx, 52, RULE_storyCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(403);
match(T__32);
setState(412);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__33:
{
setState(404);
match(T__33);
((StoryConditionContext)_localctx).result = new VeryShortStoryCondition();
}
break;
case T__34:
{
setState(406);
match(T__34);
((StoryConditionContext)_localctx).result = new ShortStoryCondition();
}
break;
case T__35:
{
setState(408);
match(T__35);
((StoryConditionContext)_localctx).result = new AverageStoryCondition();
}
break;
case T__36:
{
setState(410);
match(T__36);
((StoryConditionContext)_localctx).result = new LongStoryCondition();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TermConditionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public TermConditionRangeOpenContext c1;
public TermConditionRangeClosedLeftContext c2;
public TermConditionRangeClosedRightContext c3;
public TermConditionRangeOpenContext termConditionRangeOpen() {
return getRuleContext(TermConditionRangeOpenContext.class,0);
}
public TermConditionRangeClosedLeftContext termConditionRangeClosedLeft() {
return getRuleContext(TermConditionRangeClosedLeftContext.class,0);
}
public TermConditionRangeClosedRightContext termConditionRangeClosedRight() {
return getRuleContext(TermConditionRangeClosedRightContext.class,0);
}
public TermConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_termCondition; }
}
public final TermConditionContext termCondition() throws RecognitionException {
TermConditionContext _localctx = new TermConditionContext(_ctx, getState());
enterRule(_localctx, 54, RULE_termCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(414);
match(T__37);
setState(424);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__39:
{
{
setState(415);
((TermConditionContext)_localctx).c1 = termConditionRangeOpen();
((TermConditionContext)_localctx).result = ((TermConditionContext)_localctx).c1.result;
}
}
break;
case T__40:
{
{
setState(418);
((TermConditionContext)_localctx).c2 = termConditionRangeClosedLeft();
((TermConditionContext)_localctx).result = ((TermConditionContext)_localctx).c2.result;
}
}
break;
case T__41:
{
{
setState(421);
((TermConditionContext)_localctx).c3 = termConditionRangeClosedRight();
((TermConditionContext)_localctx).result = ((TermConditionContext)_localctx).c3.result;
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(426);
match(T__38);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TermConditionRangeOpenContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token min;
public Token max;
public TerminalNode UP_TO() { return getToken(NaturalLanguageStrategyParser.UP_TO, 0); }
public List INTEGER() { return getTokens(NaturalLanguageStrategyParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(NaturalLanguageStrategyParser.INTEGER, i);
}
public TermConditionRangeOpenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_termConditionRangeOpen; }
}
public final TermConditionRangeOpenContext termConditionRangeOpen() throws RecognitionException {
TermConditionRangeOpenContext _localctx = new TermConditionRangeOpenContext(_ctx, getState());
enterRule(_localctx, 56, RULE_termConditionRangeOpen);
try {
enterOuterAlt(_localctx, 1);
{
setState(428);
match(T__39);
setState(429);
((TermConditionRangeOpenContext)_localctx).min = match(INTEGER);
setState(430);
match(UP_TO);
setState(431);
((TermConditionRangeOpenContext)_localctx).max = match(INTEGER);
((TermConditionRangeOpenContext)_localctx).result = new LoanTermCondition(Integer.parseInt(((TermConditionRangeOpenContext)_localctx).min.getText()), Integer.parseInt(((TermConditionRangeOpenContext)_localctx).max.getText()));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TermConditionRangeClosedLeftContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token min;
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public TermConditionRangeClosedLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_termConditionRangeClosedLeft; }
}
public final TermConditionRangeClosedLeftContext termConditionRangeClosedLeft() throws RecognitionException {
TermConditionRangeClosedLeftContext _localctx = new TermConditionRangeClosedLeftContext(_ctx, getState());
enterRule(_localctx, 58, RULE_termConditionRangeClosedLeft);
try {
enterOuterAlt(_localctx, 1);
{
setState(434);
match(T__40);
setState(435);
((TermConditionRangeClosedLeftContext)_localctx).min = match(INTEGER);
((TermConditionRangeClosedLeftContext)_localctx).result = new LoanTermCondition(Integer.parseInt(((TermConditionRangeClosedLeftContext)_localctx).min.getText()) + 1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TermConditionRangeClosedRightContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token max;
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public TermConditionRangeClosedRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_termConditionRangeClosedRight; }
}
public final TermConditionRangeClosedRightContext termConditionRangeClosedRight() throws RecognitionException {
TermConditionRangeClosedRightContext _localctx = new TermConditionRangeClosedRightContext(_ctx, getState());
enterRule(_localctx, 60, RULE_termConditionRangeClosedRight);
try {
enterOuterAlt(_localctx, 1);
{
setState(438);
match(T__41);
setState(439);
((TermConditionRangeClosedRightContext)_localctx).max = match(INTEGER);
((TermConditionRangeClosedRightContext)_localctx).result = new LoanTermCondition(0, Integer.parseInt(((TermConditionRangeClosedRightContext)_localctx).max.getText()) - 1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmountConditionContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public AmountConditionRangeOpenContext c1;
public AmountConditionRangeClosedLeftContext c2;
public AmountConditionRangeClosedRightContext c3;
public TerminalNode KC() { return getToken(NaturalLanguageStrategyParser.KC, 0); }
public AmountConditionRangeOpenContext amountConditionRangeOpen() {
return getRuleContext(AmountConditionRangeOpenContext.class,0);
}
public AmountConditionRangeClosedLeftContext amountConditionRangeClosedLeft() {
return getRuleContext(AmountConditionRangeClosedLeftContext.class,0);
}
public AmountConditionRangeClosedRightContext amountConditionRangeClosedRight() {
return getRuleContext(AmountConditionRangeClosedRightContext.class,0);
}
public AmountConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_amountCondition; }
}
public final AmountConditionContext amountCondition() throws RecognitionException {
AmountConditionContext _localctx = new AmountConditionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_amountCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(442);
match(T__42);
setState(452);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__39:
{
{
setState(443);
((AmountConditionContext)_localctx).c1 = amountConditionRangeOpen();
((AmountConditionContext)_localctx).result = ((AmountConditionContext)_localctx).c1.result;
}
}
break;
case T__40:
{
{
setState(446);
((AmountConditionContext)_localctx).c2 = amountConditionRangeClosedLeft();
((AmountConditionContext)_localctx).result = ((AmountConditionContext)_localctx).c2.result;
}
}
break;
case T__41:
{
{
setState(449);
((AmountConditionContext)_localctx).c3 = amountConditionRangeClosedRight();
((AmountConditionContext)_localctx).result = ((AmountConditionContext)_localctx).c3.result;
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(454);
match(T__5);
setState(455);
match(KC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmountConditionRangeOpenContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token min;
public Token max;
public TerminalNode UP_TO() { return getToken(NaturalLanguageStrategyParser.UP_TO, 0); }
public List INTEGER() { return getTokens(NaturalLanguageStrategyParser.INTEGER); }
public TerminalNode INTEGER(int i) {
return getToken(NaturalLanguageStrategyParser.INTEGER, i);
}
public AmountConditionRangeOpenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_amountConditionRangeOpen; }
}
public final AmountConditionRangeOpenContext amountConditionRangeOpen() throws RecognitionException {
AmountConditionRangeOpenContext _localctx = new AmountConditionRangeOpenContext(_ctx, getState());
enterRule(_localctx, 64, RULE_amountConditionRangeOpen);
try {
enterOuterAlt(_localctx, 1);
{
setState(457);
match(T__39);
setState(458);
((AmountConditionRangeOpenContext)_localctx).min = match(INTEGER);
setState(459);
match(UP_TO);
setState(460);
((AmountConditionRangeOpenContext)_localctx).max = match(INTEGER);
((AmountConditionRangeOpenContext)_localctx).result = new LoanAmountCondition(Integer.parseInt(((AmountConditionRangeOpenContext)_localctx).min.getText()), Integer.parseInt(((AmountConditionRangeOpenContext)_localctx).max.getText()));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmountConditionRangeClosedLeftContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token min;
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public AmountConditionRangeClosedLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_amountConditionRangeClosedLeft; }
}
public final AmountConditionRangeClosedLeftContext amountConditionRangeClosedLeft() throws RecognitionException {
AmountConditionRangeClosedLeftContext _localctx = new AmountConditionRangeClosedLeftContext(_ctx, getState());
enterRule(_localctx, 66, RULE_amountConditionRangeClosedLeft);
try {
enterOuterAlt(_localctx, 1);
{
setState(463);
match(T__40);
setState(464);
((AmountConditionRangeClosedLeftContext)_localctx).min = match(INTEGER);
((AmountConditionRangeClosedLeftContext)_localctx).result = new LoanAmountCondition(Integer.parseInt(((AmountConditionRangeClosedLeftContext)_localctx).min.getText()) + 1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmountConditionRangeClosedRightContext extends ParserRuleContext {
public MarketplaceFilterCondition result;
public Token max;
public TerminalNode INTEGER() { return getToken(NaturalLanguageStrategyParser.INTEGER, 0); }
public AmountConditionRangeClosedRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_amountConditionRangeClosedRight; }
}
public final AmountConditionRangeClosedRightContext amountConditionRangeClosedRight() throws RecognitionException {
AmountConditionRangeClosedRightContext _localctx = new AmountConditionRangeClosedRightContext(_ctx, getState());
enterRule(_localctx, 68, RULE_amountConditionRangeClosedRight);
try {
enterOuterAlt(_localctx, 1);
{
setState(467);
match(T__41);
setState(468);
((AmountConditionRangeClosedRightContext)_localctx).max = match(INTEGER);
((AmountConditionRangeClosedRightContext)_localctx).result = new LoanAmountCondition(0, Integer.parseInt(((AmountConditionRangeClosedRightContext)_localctx).max.getText()) - 1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3^\u01da\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\3\2\3\2\3\2\3\2\3\2\3\2\5\2O\n\2\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\5\3Z\n\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3b\n\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\5\3j\n\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\5\4t\n\4\3"+
"\4\3\4\3\4\5\4y\n\4\3\4\3\4\3\4\5\4~\n\4\3\4\3\4\3\4\5\4\u0083\n\4\3\4"+
"\3\4\3\4\5\4\u0088\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u0091\n\5\3\5\3"+
"\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b"+
"\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3"+
"\n\3\n\5\n\u00b9\n\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"+
"\13\3\13\3\13\3\13\3\13\5\13\u00ca\n\13\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3"+
"\r\7\r\u00d4\n\r\f\r\16\r\u00d7\13\r\3\r\3\r\3\r\3\r\5\r\u00dd\n\r\3\r"+
"\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3"+
"\21\6\21\u00ef\n\21\r\21\16\21\u00f0\3\21\3\21\3\22\3\22\3\22\3\22\3\22"+
"\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u0103\n\22\3\22\3\22"+
"\3\22\3\22\3\23\3\23\3\23\3\23\6\23\u010d\n\23\r\23\16\23\u010e\3\23\3"+
"\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u011c\n\24\3\24"+
"\3\24\3\24\3\25\3\25\3\25\3\25\6\25\u0125\n\25\r\25\16\25\u0126\3\26\3"+
"\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26\u0132\n\26\3\27\3\27\3\27"+
"\3\27\3\27\7\27\u0139\n\27\f\27\16\27\u013c\13\27\3\27\3\27\3\27\3\27"+
"\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30"+
"\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0158\n\30\3\31\3\31\3\31"+
"\3\31\3\31\3\31\7\31\u0160\n\31\f\31\16\31\u0163\13\31\3\31\3\31\3\31"+
"\3\31\5\31\u0169\n\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\7\32"+
"\u0174\n\32\f\32\16\32\u0177\13\32\3\32\3\32\3\32\3\32\5\32\u017d\n\32"+
"\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0188\n\33\f\33\16"+
"\33\u018b\13\33\3\33\3\33\3\33\3\33\5\33\u0191\n\33\3\33\3\33\3\33\3\34"+
"\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u019f\n\34\3\35\3\35\3\35"+
"\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u01ab\n\35\3\35\3\35\3\36\3\36"+
"\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\3!\3!\3"+
"!\3!\3!\3!\3!\5!\u01c7\n!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3"+
"#\3$\3$\3$\3$\3$\2\2%\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,."+
"\60\62\64\668:<>@BDF\2\6\3\2BI\3\2\64A\3\2JR\3\2S[\2\u01e2\2N\3\2\2\2"+
"\4P\3\2\2\2\6n\3\2\2\2\b\u0089\3\2\2\2\n\u0096\3\2\2\2\f\u009c\3\2\2\2"+
"\16\u00a3\3\2\2\2\20\u00aa\3\2\2\2\22\u00af\3\2\2\2\24\u00bd\3\2\2\2\26"+
"\u00cb\3\2\2\2\30\u00ce\3\2\2\2\32\u00e1\3\2\2\2\34\u00e4\3\2\2\2\36\u00e7"+
"\3\2\2\2 \u00ea\3\2\2\2\"\u00f4\3\2\2\2$\u0108\3\2\2\2&\u0112\3\2\2\2"+
"(\u0120\3\2\2\2*\u0128\3\2\2\2,\u0133\3\2\2\2.\u0157\3\2\2\2\60\u0159"+
"\3\2\2\2\62\u016d\3\2\2\2\64\u0181\3\2\2\2\66\u0195\3\2\2\28\u01a0\3\2"+
"\2\2:\u01ae\3\2\2\2<\u01b4\3\2\2\2>\u01b8\3\2\2\2@\u01bc\3\2\2\2B\u01cb"+
"\3\2\2\2D\u01d1\3\2\2\2F\u01d5\3\2\2\2HI\5\22\n\2IJ\b\2\1\2JO\3\2\2\2"+
"KL\5\4\3\2LM\b\2\1\2MO\3\2\2\2NH\3\2\2\2NK\3\2\2\2O\3\3\2\2\2PQ\7\60\2"+
"\2QR\7\3\2\2RS\5\6\4\2SY\b\3\1\2TU\7\60\2\2UV\7\4\2\2VW\5$\23\2WX\b\3"+
"\1\2XZ\3\2\2\2YT\3\2\2\2YZ\3\2\2\2Z[\3\2\2\2[a\b\3\1\2\\]\7\60\2\2]^\7"+
"\5\2\2^_\5 \21\2_`\b\3\1\2`b\3\2\2\2a\\\3\2\2\2ab\3\2\2\2bc\3\2\2\2ci"+
"\b\3\1\2de\7\60\2\2ef\7\6\2\2fg\5(\25\2gh\b\3\1\2hj\3\2\2\2id\3\2\2\2"+
"ij\3\2\2\2jk\3\2\2\2kl\7\2\2\3lm\b\3\1\2m\5\3\2\2\2no\5\22\n\2os\b\4\1"+
"\2pq\5\f\7\2qr\b\4\1\2rt\3\2\2\2sp\3\2\2\2st\3\2\2\2tx\3\2\2\2uv\5\b\5"+
"\2vw\b\4\1\2wy\3\2\2\2xu\3\2\2\2xy\3\2\2\2y}\3\2\2\2z{\5\n\6\2{|\b\4\1"+
"\2|~\3\2\2\2}z\3\2\2\2}~\3\2\2\2~\u0082\3\2\2\2\177\u0080\5\16\b\2\u0080"+
"\u0081\b\4\1\2\u0081\u0083\3\2\2\2\u0082\177\3\2\2\2\u0082\u0083\3\2\2"+
"\2\u0083\u0087\3\2\2\2\u0084\u0085\5\20\t\2\u0085\u0086\b\4\1\2\u0086"+
"\u0088\3\2\2\2\u0087\u0084\3\2\2\2\u0087\u0088\3\2\2\2\u0088\7\3\2\2\2"+
"\u0089\u0090\7\7\2\2\u008a\u008b\7\\\2\2\u008b\u0091\b\5\1\2\u008c\u008d"+
"\7\\\2\2\u008d\u008e\7\61\2\2\u008e\u008f\7\\\2\2\u008f\u0091\b\5\1\2"+
"\u0090\u008a\3\2\2\2\u0090\u008c\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093"+
"\7\b\2\2\u0093\u0094\7.\2\2\u0094\u0095\7/\2\2\u0095\t\3\2\2\2\u0096\u0097"+
"\7\t\2\2\u0097\u0098\7\\\2\2\u0098\u0099\b\6\1\2\u0099\u009a\7\n\2\2\u009a"+
"\u009b\7/\2\2\u009b\13\3\2\2\2\u009c\u009d\7\13\2\2\u009d\u009e\7\\\2"+
"\2\u009e\u009f\7\b\2\2\u009f\u00a0\7.\2\2\u00a0\u00a1\7/\2\2\u00a1\u00a2"+
"\b\7\1\2\u00a2\r\3\2\2\2\u00a3\u00a4\7\f\2\2\u00a4\u00a5\7\\\2\2\u00a5"+
"\u00a6\7\b\2\2\u00a6\u00a7\7.\2\2\u00a7\u00a8\7/\2\2\u00a8\u00a9\b\b\1"+
"\2\u00a9\17\3\2\2\2\u00aa\u00ab\7\r\2\2\u00ab\u00ac\5\24\13\2\u00ac\u00ad"+
"\7/\2\2\u00ad\u00ae\b\t\1\2\u00ae\21\3\2\2\2\u00af\u00b8\7\16\2\2\u00b0"+
"\u00b1\7\17\2\2\u00b1\u00b9\b\n\1\2\u00b2\u00b3\7\20\2\2\u00b3\u00b9\b"+
"\n\1\2\u00b4\u00b5\7\21\2\2\u00b5\u00b9\b\n\1\2\u00b6\u00b7\7\22\2\2\u00b7"+
"\u00b9\b\n\1\2\u00b8\u00b0\3\2\2\2\u00b8\u00b2\3\2\2\2\u00b8\u00b4\3\2"+
"\2\2\u00b8\u00b6\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\7\23\2\2\u00bb"+
"\u00bc\7/\2\2\u00bc\23\3\2\2\2\u00bd\u00c9\7\24\2\2\u00be\u00bf\5\30\r"+
"\2\u00bf\u00c0\b\13\1\2\u00c0\u00ca\3\2\2\2\u00c1\u00c2\7\25\2\2\u00c2"+
"\u00c3\5\26\f\2\u00c3\u00c4\b\13\1\2\u00c4\u00ca\3\2\2\2\u00c5\u00c6\7"+
"\26\2\2\u00c6\u00c7\5\26\f\2\u00c7\u00c8\b\13\1\2\u00c8\u00ca\3\2\2\2"+
"\u00c9\u00be\3\2\2\2\u00c9\u00c1\3\2\2\2\u00c9\u00c5\3\2\2\2\u00ca\25"+
"\3\2\2\2\u00cb\u00cc\t\2\2\2\u00cc\u00cd\b\f\1\2\u00cd\27\3\2\2\2\u00ce"+
"\u00dc\b\r\1\2\u00cf\u00d0\5\26\f\2\u00d0\u00d1\7\63\2\2\u00d1\u00d2\b"+
"\r\1\2\u00d2\u00d4\3\2\2\2\u00d3\u00cf\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5"+
"\u00d3\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d5\3\2"+
"\2\2\u00d8\u00d9\5\26\f\2\u00d9\u00da\7\62\2\2\u00da\u00db\b\r\1\2\u00db"+
"\u00dd\3\2\2\2\u00dc\u00d5\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00de\3\2"+
"\2\2\u00de\u00df\5\26\f\2\u00df\u00e0\b\r\1\2\u00e0\31\3\2\2\2\u00e1\u00e2"+
"\t\3\2\2\u00e2\u00e3\b\16\1\2\u00e3\33\3\2\2\2\u00e4\u00e5\t\4\2\2\u00e5"+
"\u00e6\b\17\1\2\u00e6\35\3\2\2\2\u00e7\u00e8\t\5\2\2\u00e8\u00e9\b\20"+
"\1\2\u00e9\37\3\2\2\2\u00ea\u00ee\b\21\1\2\u00eb\u00ec\5\"\22\2\u00ec"+
"\u00ed\b\21\1\2\u00ed\u00ef\3\2\2\2\u00ee\u00eb\3\2\2\2\u00ef\u00f0\3"+
"\2\2\2\u00f0\u00ee\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2"+
"\u00f3\b\21\1\2\u00f3!\3\2\2\2\u00f4\u00f5\7\27\2\2\u00f5\u00f6\5\26\f"+
"\2\u00f6\u0102\7\30\2\2\u00f7\u00f8\7\b\2\2\u00f8\u00f9\7\\\2\2\u00f9"+
"\u0103\b\22\1\2\u00fa\u00fb\7\61\2\2\u00fb\u00fc\7\\\2\2\u00fc\u0103\b"+
"\22\1\2\u00fd\u00fe\7\b\2\2\u00fe\u00ff\7\\\2\2\u00ff\u0100\7\61\2\2\u0100"+
"\u0101\7\\\2\2\u0101\u0103\b\22\1\2\u0102\u00f7\3\2\2\2\u0102\u00fa\3"+
"\2\2\2\u0102\u00fd\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0105\7\b\2\2\u0105"+
"\u0106\7.\2\2\u0106\u0107\7/\2\2\u0107#\3\2\2\2\u0108\u010c\b\23\1\2\u0109"+
"\u010a\5&\24\2\u010a\u010b\b\23\1\2\u010b\u010d\3\2\2\2\u010c\u0109\3"+
"\2\2\2\u010d\u010e\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010f\3\2\2\2\u010f"+
"\u0110\3\2\2\2\u0110\u0111\b\23\1\2\u0111%\3\2\2\2\u0112\u0113\7\31\2"+
"\2\u0113\u0114\5\26\f\2\u0114\u011b\7\32\2\2\u0115\u0116\7\\\2\2\u0116"+
"\u011c\b\24\1\2\u0117\u0118\7\\\2\2\u0118\u0119\7\61\2\2\u0119\u011a\7"+
"\\\2\2\u011a\u011c\b\24\1\2\u011b\u0115\3\2\2\2\u011b\u0117\3\2\2\2\u011c"+
"\u011d\3\2\2\2\u011d\u011e\7\33\2\2\u011e\u011f\7/\2\2\u011f\'\3\2\2\2"+
"\u0120\u0124\b\25\1\2\u0121\u0122\5*\26\2\u0122\u0123\b\25\1\2\u0123\u0125"+
"\3\2\2\2\u0124\u0121\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0124\3\2\2\2\u0126"+
"\u0127\3\2\2\2\u0127)\3\2\2\2\u0128\u0129\b\26\1\2\u0129\u012a\7\34\2"+
"\2\u012a\u012b\5,\27\2\u012b\u0131\b\26\1\2\u012c\u012d\7\35\2\2\u012d"+
"\u012e\5,\27\2\u012e\u012f\b\26\1\2\u012f\u0130\7\36\2\2\u0130\u0132\3"+
"\2\2\2\u0131\u012c\3\2\2\2\u0131\u0132\3\2\2\2\u0132+\3\2\2\2\u0133\u013a"+
"\b\27\1\2\u0134\u0135\5.\30\2\u0135\u0136\b\27\1\2\u0136\u0137\7\37\2"+
"\2\u0137\u0139\3\2\2\2\u0138\u0134\3\2\2\2\u0139\u013c\3\2\2\2\u013a\u0138"+
"\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u013d\3\2\2\2\u013c\u013a\3\2\2\2\u013d"+
"\u013e\5.\30\2\u013e\u013f\b\27\1\2\u013f\u0140\7/\2\2\u0140\u0141\b\27"+
"\1\2\u0141-\3\2\2\2\u0142\u0143\5\60\31\2\u0143\u0144\b\30\1\2\u0144\u0158"+
"\3\2\2\2\u0145\u0146\5\24\13\2\u0146\u0147\b\30\1\2\u0147\u0158\3\2\2"+
"\2\u0148\u0149\5\62\32\2\u0149\u014a\b\30\1\2\u014a\u0158\3\2\2\2\u014b"+
"\u014c\5\64\33\2\u014c\u014d\b\30\1\2\u014d\u0158\3\2\2\2\u014e\u014f"+
"\5\66\34\2\u014f\u0150\b\30\1\2\u0150\u0158\3\2\2\2\u0151\u0152\58\35"+
"\2\u0152\u0153\b\30\1\2\u0153\u0158\3\2\2\2\u0154\u0155\5@!\2\u0155\u0156"+
"\b\30\1\2\u0156\u0158\3\2\2\2\u0157\u0142\3\2\2\2\u0157\u0145\3\2\2\2"+
"\u0157\u0148\3\2\2\2\u0157\u014b\3\2\2\2\u0157\u014e\3\2\2\2\u0157\u0151"+
"\3\2\2\2\u0157\u0154\3\2\2\2\u0158/\3\2\2\2\u0159\u015a\b\31\1\2\u015a"+
"\u0168\7 \2\2\u015b\u015c\5\32\16\2\u015c\u015d\7\63\2\2\u015d\u015e\b"+
"\31\1\2\u015e\u0160\3\2\2\2\u015f\u015b\3\2\2\2\u0160\u0163\3\2\2\2\u0161"+
"\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0164\3\2\2\2\u0163\u0161\3\2"+
"\2\2\u0164\u0165\5\32\16\2\u0165\u0166\7\62\2\2\u0166\u0167\b\31\1\2\u0167"+
"\u0169\3\2\2\2\u0168\u0161\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a\3\2"+
"\2\2\u016a\u016b\5\32\16\2\u016b\u016c\b\31\1\2\u016c\61\3\2\2\2\u016d"+
"\u016e\b\32\1\2\u016e\u017c\7!\2\2\u016f\u0170\5\34\17\2\u0170\u0171\7"+
"\63\2\2\u0171\u0172\b\32\1\2\u0172\u0174\3\2\2\2\u0173\u016f\3\2\2\2\u0174"+
"\u0177\3\2\2\2\u0175\u0173\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0178\3\2"+
"\2\2\u0177\u0175\3\2\2\2\u0178\u0179\5\34\17\2\u0179\u017a\7\62\2\2\u017a"+
"\u017b\b\32\1\2\u017b\u017d\3\2\2\2\u017c\u0175\3\2\2\2\u017c\u017d\3"+
"\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f\5\34\17\2\u017f\u0180\b\32\1\2"+
"\u0180\63\3\2\2\2\u0181\u0182\b\33\1\2\u0182\u0190\7\"\2\2\u0183\u0184"+
"\5\36\20\2\u0184\u0185\7\63\2\2\u0185\u0186\b\33\1\2\u0186\u0188\3\2\2"+
"\2\u0187\u0183\3\2\2\2\u0188\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189\u018a"+
"\3\2\2\2\u018a\u018c\3\2\2\2\u018b\u0189\3\2\2\2\u018c\u018d\5\36\20\2"+
"\u018d\u018e\7\62\2\2\u018e\u018f\b\33\1\2\u018f\u0191\3\2\2\2\u0190\u0189"+
"\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193\5\36\20\2"+
"\u0193\u0194\b\33\1\2\u0194\65\3\2\2\2\u0195\u019e\7#\2\2\u0196\u0197"+
"\7$\2\2\u0197\u019f\b\34\1\2\u0198\u0199\7%\2\2\u0199\u019f\b\34\1\2\u019a"+
"\u019b\7&\2\2\u019b\u019f\b\34\1\2\u019c\u019d\7\'\2\2\u019d\u019f\b\34"+
"\1\2\u019e\u0196\3\2\2\2\u019e\u0198\3\2\2\2\u019e\u019a\3\2\2\2\u019e"+
"\u019c\3\2\2\2\u019f\67\3\2\2\2\u01a0\u01aa\7(\2\2\u01a1\u01a2\5:\36\2"+
"\u01a2\u01a3\b\35\1\2\u01a3\u01ab\3\2\2\2\u01a4\u01a5\5<\37\2\u01a5\u01a6"+
"\b\35\1\2\u01a6\u01ab\3\2\2\2\u01a7\u01a8\5> \2\u01a8\u01a9\b\35\1\2\u01a9"+
"\u01ab\3\2\2\2\u01aa\u01a1\3\2\2\2\u01aa\u01a4\3\2\2\2\u01aa\u01a7\3\2"+
"\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\7)\2\2\u01ad9\3\2\2\2\u01ae\u01af"+
"\7*\2\2\u01af\u01b0\7\\\2\2\u01b0\u01b1\7\61\2\2\u01b1\u01b2\7\\\2\2\u01b2"+
"\u01b3\b\36\1\2\u01b3;\3\2\2\2\u01b4\u01b5\7+\2\2\u01b5\u01b6\7\\\2\2"+
"\u01b6\u01b7\b\37\1\2\u01b7=\3\2\2\2\u01b8\u01b9\7,\2\2\u01b9\u01ba\7"+
"\\\2\2\u01ba\u01bb\b \1\2\u01bb?\3\2\2\2\u01bc\u01c6\7-\2\2\u01bd\u01be"+
"\5B\"\2\u01be\u01bf\b!\1\2\u01bf\u01c7\3\2\2\2\u01c0\u01c1\5D#\2\u01c1"+
"\u01c2\b!\1\2\u01c2\u01c7\3\2\2\2\u01c3\u01c4\5F$\2\u01c4\u01c5\b!\1\2"+
"\u01c5\u01c7\3\2\2\2\u01c6\u01bd\3\2\2\2\u01c6\u01c0\3\2\2\2\u01c6\u01c3"+
"\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\7\b\2\2\u01c9\u01ca\7.\2\2\u01ca"+
"A\3\2\2\2\u01cb\u01cc\7*\2\2\u01cc\u01cd\7\\\2\2\u01cd\u01ce\7\61\2\2"+
"\u01ce\u01cf\7\\\2\2\u01cf\u01d0\b\"\1\2\u01d0C\3\2\2\2\u01d1\u01d2\7"+
"+\2\2\u01d2\u01d3\7\\\2\2\u01d3\u01d4\b#\1\2\u01d4E\3\2\2\2\u01d5\u01d6"+
"\7,\2\2\u01d6\u01d7\7\\\2\2\u01d7\u01d8\b$\1\2\u01d8G\3\2\2\2!NYaisx}"+
"\u0082\u0087\u0090\u00b8\u00c9\u00d5\u00dc\u00f0\u0102\u010e\u011b\u0126"+
"\u0131\u013a\u0157\u0161\u0168\u0175\u017c\u0189\u0190\u019e\u01aa\u01c6";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy