Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.aya.parser.AyaParser Maven / Gradle / Ivy
// Generated from org\aya\parser\AyaParser.g4 by ANTLR 4.9.3
package org.aya.parser;
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 AyaParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
INFIX=1, INFIXL=2, INFIXR=3, TIGHTER=4, LOOSER=5, EXAMPLE=6, COUNTEREXAMPLE=7,
ULIFT=8, TYPE=9, AS=10, OPEN=11, IMPORT=12, PUBLIC=13, PRIVATE=14, USING=15,
HIDING=16, COERCE=17, OPAQUE=18, INLINE=19, OVERLAP=20, MODULE_KW=21,
BIND_KW=22, MATCH=23, VARIABLE=24, DEF=25, STRUCT=26, DATA=27, PRIM=28,
EXTENDS=29, NEW_KW=30, PATTERN_KW=31, DO_KW=32, CODATA_KW=33, LET_KW=34,
IN_KW=35, COMPLETED=36, SIGMA=37, LAMBDA=38, PI=39, FORALL=40, TO=41,
IMPLIES=42, SUCHTHAT=43, DOT=44, BAR=45, COMMA=46, COLON=47, COLON2=48,
LBRACE=49, RBRACE=50, LPAREN=51, RPAREN=52, LGOAL=53, RGOAL=54, NUMBER=55,
CALM_FACE=56, STRING=57, INCOMPLETE_STRING=58, ID=59, WS=60, DOC_COMMENT=61,
LINE_COMMENT=62, COMMENT=63, ERROR_CHAR=64;
public static final int
RULE_program = 0, RULE_repl = 1, RULE_stmt = 2, RULE_remark = 3, RULE_importCmd = 4,
RULE_openCmd = 5, RULE_module = 6, RULE_useHide = 7, RULE_hideList = 8,
RULE_useList = 9, RULE_useIdsComma = 10, RULE_useId = 11, RULE_useAs = 12,
RULE_generalize = 13, RULE_sampleModifiers = 14, RULE_decl = 15, RULE_assoc = 16,
RULE_declNameOrInfix = 17, RULE_bindBlock = 18, RULE_tighters = 19, RULE_loosers = 20,
RULE_fnDecl = 21, RULE_fnBody = 22, RULE_fnModifiers = 23, RULE_structDecl = 24,
RULE_primDecl = 25, RULE_field = 26, RULE_dataDecl = 27, RULE_dataBody = 28,
RULE_dataCtor = 29, RULE_dataCtorClause = 30, RULE_expr = 31, RULE_newArg = 32,
RULE_atom = 33, RULE_argument = 34, RULE_projFix = 35, RULE_clauses = 36,
RULE_clause = 37, RULE_patterns = 38, RULE_pattern = 39, RULE_atomPatterns = 40,
RULE_atomPattern = 41, RULE_literal = 42, RULE_tele = 43, RULE_teleBinder = 44,
RULE_teleMaybeTypedExpr = 45, RULE_exprList = 46, RULE_idsComma = 47,
RULE_qIdsComma = 48, RULE_ids = 49, RULE_type = 50, RULE_qualifiedId = 51;
private static String[] makeRuleNames() {
return new String[] {
"program", "repl", "stmt", "remark", "importCmd", "openCmd", "module",
"useHide", "hideList", "useList", "useIdsComma", "useId", "useAs", "generalize",
"sampleModifiers", "decl", "assoc", "declNameOrInfix", "bindBlock", "tighters",
"loosers", "fnDecl", "fnBody", "fnModifiers", "structDecl", "primDecl",
"field", "dataDecl", "dataBody", "dataCtor", "dataCtorClause", "expr",
"newArg", "atom", "argument", "projFix", "clauses", "clause", "patterns",
"pattern", "atomPatterns", "atomPattern", "literal", "tele", "teleBinder",
"teleMaybeTypedExpr", "exprList", "idsComma", "qIdsComma", "ids", "type",
"qualifiedId"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'infix'", "'infixl'", "'infixr'", "'tighter'", "'looser'", "'example'",
"'counterexample'", null, "'Type'", "'as'", "'open'", "'import'", "'public'",
"'private'", "'using'", "'hiding'", "'coerce'", "'opaque'", "'inline'",
"'overlap'", "'module'", "'bind'", "'match'", "'variable'", "'def'",
"'struct'", "'data'", "'prim'", "'extends'", "'new'", "'pattern'", "'do'",
"'codata'", "'let'", "'in'", "'completed'", null, null, null, null, null,
null, "'**'", "'.'", "'|'", "','", "':'", "'::'", "'{'", "'}'", "'('",
"')'", "'{?'", "'?}'", null, "'_'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "INFIX", "INFIXL", "INFIXR", "TIGHTER", "LOOSER", "EXAMPLE", "COUNTEREXAMPLE",
"ULIFT", "TYPE", "AS", "OPEN", "IMPORT", "PUBLIC", "PRIVATE", "USING",
"HIDING", "COERCE", "OPAQUE", "INLINE", "OVERLAP", "MODULE_KW", "BIND_KW",
"MATCH", "VARIABLE", "DEF", "STRUCT", "DATA", "PRIM", "EXTENDS", "NEW_KW",
"PATTERN_KW", "DO_KW", "CODATA_KW", "LET_KW", "IN_KW", "COMPLETED", "SIGMA",
"LAMBDA", "PI", "FORALL", "TO", "IMPLIES", "SUCHTHAT", "DOT", "BAR",
"COMMA", "COLON", "COLON2", "LBRACE", "RBRACE", "LPAREN", "RPAREN", "LGOAL",
"RGOAL", "NUMBER", "CALM_FACE", "STRING", "INCOMPLETE_STRING", "ID",
"WS", "DOC_COMMENT", "LINE_COMMENT", "COMMENT", "ERROR_CHAR"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "AyaParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public AyaParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProgramContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(AyaParser.EOF, 0); }
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXAMPLE) | (1L << COUNTEREXAMPLE) | (1L << OPEN) | (1L << IMPORT) | (1L << PUBLIC) | (1L << PRIVATE) | (1L << MODULE_KW) | (1L << VARIABLE) | (1L << DEF) | (1L << STRUCT) | (1L << DATA) | (1L << PRIM) | (1L << DOC_COMMENT))) != 0)) {
{
{
setState(104);
stmt();
}
}
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(110);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReplContext extends ParserRuleContext {
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public ReplContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_repl; }
}
public final ReplContext repl() throws RecognitionException {
ReplContext _localctx = new ReplContext(_ctx, getState());
enterRule(_localctx, 2, RULE_repl);
int _la;
try {
setState(121);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EXAMPLE:
case COUNTEREXAMPLE:
case OPEN:
case IMPORT:
case PUBLIC:
case PRIVATE:
case MODULE_KW:
case VARIABLE:
case DEF:
case STRUCT:
case DATA:
case PRIM:
case DOC_COMMENT:
enterOuterAlt(_localctx, 1);
{
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(112);
stmt();
}
}
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXAMPLE) | (1L << COUNTEREXAMPLE) | (1L << OPEN) | (1L << IMPORT) | (1L << PUBLIC) | (1L << PRIVATE) | (1L << MODULE_KW) | (1L << VARIABLE) | (1L << DEF) | (1L << STRUCT) | (1L << DATA) | (1L << PRIM) | (1L << DOC_COMMENT))) != 0) );
}
break;
case ULIFT:
case TYPE:
case MATCH:
case NEW_KW:
case SIGMA:
case LAMBDA:
case PI:
case FORALL:
case LPAREN:
case LGOAL:
case NUMBER:
case CALM_FACE:
case STRING:
case ID:
enterOuterAlt(_localctx, 2);
{
setState(118);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
setState(117);
match(ID);
}
break;
}
setState(120);
expr(0);
}
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 StmtContext extends ParserRuleContext {
public DeclContext decl() {
return getRuleContext(DeclContext.class,0);
}
public ImportCmdContext importCmd() {
return getRuleContext(ImportCmdContext.class,0);
}
public OpenCmdContext openCmd() {
return getRuleContext(OpenCmdContext.class,0);
}
public ModuleContext module() {
return getRuleContext(ModuleContext.class,0);
}
public RemarkContext remark() {
return getRuleContext(RemarkContext.class,0);
}
public GeneralizeContext generalize() {
return getRuleContext(GeneralizeContext.class,0);
}
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 4, RULE_stmt);
try {
setState(129);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(123);
decl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(124);
importCmd();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(125);
openCmd();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(126);
module();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(127);
remark();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(128);
generalize();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RemarkContext extends ParserRuleContext {
public List DOC_COMMENT() { return getTokens(AyaParser.DOC_COMMENT); }
public TerminalNode DOC_COMMENT(int i) {
return getToken(AyaParser.DOC_COMMENT, i);
}
public RemarkContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_remark; }
}
public final RemarkContext remark() throws RecognitionException {
RemarkContext _localctx = new RemarkContext(_ctx, getState());
enterRule(_localctx, 6, RULE_remark);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(132);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(131);
match(DOC_COMMENT);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(134);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportCmdContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(AyaParser.IMPORT, 0); }
public QualifiedIdContext qualifiedId() {
return getRuleContext(QualifiedIdContext.class,0);
}
public TerminalNode AS() { return getToken(AyaParser.AS, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public ImportCmdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importCmd; }
}
public final ImportCmdContext importCmd() throws RecognitionException {
ImportCmdContext _localctx = new ImportCmdContext(_ctx, getState());
enterRule(_localctx, 8, RULE_importCmd);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(136);
match(IMPORT);
setState(137);
qualifiedId();
setState(140);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(138);
match(AS);
setState(139);
match(ID);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpenCmdContext extends ParserRuleContext {
public TerminalNode OPEN() { return getToken(AyaParser.OPEN, 0); }
public QualifiedIdContext qualifiedId() {
return getRuleContext(QualifiedIdContext.class,0);
}
public TerminalNode PUBLIC() { return getToken(AyaParser.PUBLIC, 0); }
public TerminalNode IMPORT() { return getToken(AyaParser.IMPORT, 0); }
public UseHideContext useHide() {
return getRuleContext(UseHideContext.class,0);
}
public OpenCmdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_openCmd; }
}
public final OpenCmdContext openCmd() throws RecognitionException {
OpenCmdContext _localctx = new OpenCmdContext(_ctx, getState());
enterRule(_localctx, 10, RULE_openCmd);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(143);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PUBLIC) {
{
setState(142);
match(PUBLIC);
}
}
setState(145);
match(OPEN);
setState(147);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPORT) {
{
setState(146);
match(IMPORT);
}
}
setState(149);
qualifiedId();
setState(151);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==USING || _la==HIDING) {
{
setState(150);
useHide();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleContext extends ParserRuleContext {
public TerminalNode MODULE_KW() { return getToken(AyaParser.MODULE_KW, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public ModuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_module; }
}
public final ModuleContext module() throws RecognitionException {
ModuleContext _localctx = new ModuleContext(_ctx, getState());
enterRule(_localctx, 12, RULE_module);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(153);
match(MODULE_KW);
setState(154);
match(ID);
setState(155);
match(LBRACE);
setState(159);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXAMPLE) | (1L << COUNTEREXAMPLE) | (1L << OPEN) | (1L << IMPORT) | (1L << PUBLIC) | (1L << PRIVATE) | (1L << MODULE_KW) | (1L << VARIABLE) | (1L << DEF) | (1L << STRUCT) | (1L << DATA) | (1L << PRIM) | (1L << DOC_COMMENT))) != 0)) {
{
{
setState(156);
stmt();
}
}
setState(161);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(162);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UseHideContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(AyaParser.USING, 0); }
public List useList() {
return getRuleContexts(UseListContext.class);
}
public UseListContext useList(int i) {
return getRuleContext(UseListContext.class,i);
}
public TerminalNode HIDING() { return getToken(AyaParser.HIDING, 0); }
public List hideList() {
return getRuleContexts(HideListContext.class);
}
public HideListContext hideList(int i) {
return getRuleContext(HideListContext.class,i);
}
public UseHideContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useHide; }
}
public final UseHideContext useHide() throws RecognitionException {
UseHideContext _localctx = new UseHideContext(_ctx, getState());
enterRule(_localctx, 14, RULE_useHide);
int _la;
try {
setState(176);
_errHandler.sync(this);
switch (_input.LA(1)) {
case USING:
enterOuterAlt(_localctx, 1);
{
setState(164);
match(USING);
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(165);
useList();
}
}
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LPAREN );
}
break;
case HIDING:
enterOuterAlt(_localctx, 2);
{
setState(170);
match(HIDING);
setState(172);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(171);
hideList();
}
}
setState(174);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LPAREN );
}
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 HideListContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(AyaParser.LPAREN, 0); }
public IdsCommaContext idsComma() {
return getRuleContext(IdsCommaContext.class,0);
}
public TerminalNode RPAREN() { return getToken(AyaParser.RPAREN, 0); }
public HideListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hideList; }
}
public final HideListContext hideList() throws RecognitionException {
HideListContext _localctx = new HideListContext(_ctx, getState());
enterRule(_localctx, 16, RULE_hideList);
try {
enterOuterAlt(_localctx, 1);
{
setState(178);
match(LPAREN);
setState(179);
idsComma();
setState(180);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UseListContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(AyaParser.LPAREN, 0); }
public UseIdsCommaContext useIdsComma() {
return getRuleContext(UseIdsCommaContext.class,0);
}
public TerminalNode RPAREN() { return getToken(AyaParser.RPAREN, 0); }
public UseListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useList; }
}
public final UseListContext useList() throws RecognitionException {
UseListContext _localctx = new UseListContext(_ctx, getState());
enterRule(_localctx, 18, RULE_useList);
try {
enterOuterAlt(_localctx, 1);
{
setState(182);
match(LPAREN);
setState(183);
useIdsComma();
setState(184);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UseIdsCommaContext extends ParserRuleContext {
public List useId() {
return getRuleContexts(UseIdContext.class);
}
public UseIdContext useId(int i) {
return getRuleContext(UseIdContext.class,i);
}
public List COMMA() { return getTokens(AyaParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(AyaParser.COMMA, i);
}
public UseIdsCommaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useIdsComma; }
}
public final UseIdsCommaContext useIdsComma() throws RecognitionException {
UseIdsCommaContext _localctx = new UseIdsCommaContext(_ctx, getState());
enterRule(_localctx, 20, RULE_useIdsComma);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(191);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(186);
useId();
setState(187);
match(COMMA);
}
}
}
setState(193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(195);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(194);
useId();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UseIdContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public UseAsContext useAs() {
return getRuleContext(UseAsContext.class,0);
}
public UseIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useId; }
}
public final UseIdContext useId() throws RecognitionException {
UseIdContext _localctx = new UseIdContext(_ctx, getState());
enterRule(_localctx, 22, RULE_useId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(197);
match(ID);
setState(199);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(198);
useAs();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UseAsContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(AyaParser.AS, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public AssocContext assoc() {
return getRuleContext(AssocContext.class,0);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public UseAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useAs; }
}
public final UseAsContext useAs() throws RecognitionException {
UseAsContext _localctx = new UseAsContext(_ctx, getState());
enterRule(_localctx, 24, RULE_useAs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(201);
match(AS);
setState(203);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INFIX) | (1L << INFIXL) | (1L << INFIXR))) != 0)) {
{
setState(202);
assoc();
}
}
setState(205);
match(ID);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BIND_KW) {
{
setState(206);
bindBlock();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneralizeContext extends ParserRuleContext {
public TerminalNode VARIABLE() { return getToken(AyaParser.VARIABLE, 0); }
public IdsContext ids() {
return getRuleContext(IdsContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public GeneralizeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generalize; }
}
public final GeneralizeContext generalize() throws RecognitionException {
GeneralizeContext _localctx = new GeneralizeContext(_ctx, getState());
enterRule(_localctx, 26, RULE_generalize);
try {
enterOuterAlt(_localctx, 1);
{
setState(209);
match(VARIABLE);
setState(210);
ids();
setState(211);
type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SampleModifiersContext extends ParserRuleContext {
public TerminalNode EXAMPLE() { return getToken(AyaParser.EXAMPLE, 0); }
public TerminalNode COUNTEREXAMPLE() { return getToken(AyaParser.COUNTEREXAMPLE, 0); }
public SampleModifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampleModifiers; }
}
public final SampleModifiersContext sampleModifiers() throws RecognitionException {
SampleModifiersContext _localctx = new SampleModifiersContext(_ctx, getState());
enterRule(_localctx, 28, RULE_sampleModifiers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(213);
_la = _input.LA(1);
if ( !(_la==EXAMPLE || _la==COUNTEREXAMPLE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclContext extends ParserRuleContext {
public FnDeclContext fnDecl() {
return getRuleContext(FnDeclContext.class,0);
}
public StructDeclContext structDecl() {
return getRuleContext(StructDeclContext.class,0);
}
public DataDeclContext dataDecl() {
return getRuleContext(DataDeclContext.class,0);
}
public PrimDeclContext primDecl() {
return getRuleContext(PrimDeclContext.class,0);
}
public TerminalNode PRIVATE() { return getToken(AyaParser.PRIVATE, 0); }
public DeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decl; }
}
public final DeclContext decl() throws RecognitionException {
DeclContext _localctx = new DeclContext(_ctx, getState());
enterRule(_localctx, 30, RULE_decl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(216);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PRIVATE) {
{
setState(215);
match(PRIVATE);
}
}
setState(222);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(218);
fnDecl();
}
break;
case 2:
{
setState(219);
structDecl();
}
break;
case 3:
{
setState(220);
dataDecl();
}
break;
case 4:
{
setState(221);
primDecl();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssocContext extends ParserRuleContext {
public TerminalNode INFIX() { return getToken(AyaParser.INFIX, 0); }
public TerminalNode INFIXL() { return getToken(AyaParser.INFIXL, 0); }
public TerminalNode INFIXR() { return getToken(AyaParser.INFIXR, 0); }
public AssocContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assoc; }
}
public final AssocContext assoc() throws RecognitionException {
AssocContext _localctx = new AssocContext(_ctx, getState());
enterRule(_localctx, 32, RULE_assoc);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(224);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INFIX) | (1L << INFIXL) | (1L << INFIXR))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclNameOrInfixContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public AssocContext assoc() {
return getRuleContext(AssocContext.class,0);
}
public DeclNameOrInfixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declNameOrInfix; }
}
public final DeclNameOrInfixContext declNameOrInfix() throws RecognitionException {
DeclNameOrInfixContext _localctx = new DeclNameOrInfixContext(_ctx, getState());
enterRule(_localctx, 34, RULE_declNameOrInfix);
try {
setState(230);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ID:
enterOuterAlt(_localctx, 1);
{
setState(226);
match(ID);
}
break;
case INFIX:
case INFIXL:
case INFIXR:
enterOuterAlt(_localctx, 2);
{
setState(227);
assoc();
setState(228);
match(ID);
}
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 BindBlockContext extends ParserRuleContext {
public TerminalNode BIND_KW() { return getToken(AyaParser.BIND_KW, 0); }
public QIdsCommaContext qIdsComma() {
return getRuleContext(QIdsCommaContext.class,0);
}
public TerminalNode TIGHTER() { return getToken(AyaParser.TIGHTER, 0); }
public TerminalNode LOOSER() { return getToken(AyaParser.LOOSER, 0); }
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public List tighters() {
return getRuleContexts(TightersContext.class);
}
public TightersContext tighters(int i) {
return getRuleContext(TightersContext.class,i);
}
public List loosers() {
return getRuleContexts(LoosersContext.class);
}
public LoosersContext loosers(int i) {
return getRuleContext(LoosersContext.class,i);
}
public BindBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bindBlock; }
}
public final BindBlockContext bindBlock() throws RecognitionException {
BindBlockContext _localctx = new BindBlockContext(_ctx, getState());
enterRule(_localctx, 36, RULE_bindBlock);
int _la;
try {
setState(245);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(232);
match(BIND_KW);
setState(233);
_la = _input.LA(1);
if ( !(_la==TIGHTER || _la==LOOSER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(234);
qIdsComma();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(235);
match(BIND_KW);
setState(236);
match(LBRACE);
setState(241);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==TIGHTER || _la==LOOSER) {
{
setState(239);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TIGHTER:
{
setState(237);
tighters();
}
break;
case LOOSER:
{
setState(238);
loosers();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(243);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(244);
match(RBRACE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TightersContext extends ParserRuleContext {
public TerminalNode TIGHTER() { return getToken(AyaParser.TIGHTER, 0); }
public QIdsCommaContext qIdsComma() {
return getRuleContext(QIdsCommaContext.class,0);
}
public TightersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tighters; }
}
public final TightersContext tighters() throws RecognitionException {
TightersContext _localctx = new TightersContext(_ctx, getState());
enterRule(_localctx, 38, RULE_tighters);
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
match(TIGHTER);
setState(248);
qIdsComma();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LoosersContext extends ParserRuleContext {
public TerminalNode LOOSER() { return getToken(AyaParser.LOOSER, 0); }
public QIdsCommaContext qIdsComma() {
return getRuleContext(QIdsCommaContext.class,0);
}
public LoosersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loosers; }
}
public final LoosersContext loosers() throws RecognitionException {
LoosersContext _localctx = new LoosersContext(_ctx, getState());
enterRule(_localctx, 40, RULE_loosers);
try {
enterOuterAlt(_localctx, 1);
{
setState(250);
match(LOOSER);
setState(251);
qIdsComma();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FnDeclContext extends ParserRuleContext {
public TerminalNode DEF() { return getToken(AyaParser.DEF, 0); }
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public FnBodyContext fnBody() {
return getRuleContext(FnBodyContext.class,0);
}
public SampleModifiersContext sampleModifiers() {
return getRuleContext(SampleModifiersContext.class,0);
}
public List fnModifiers() {
return getRuleContexts(FnModifiersContext.class);
}
public FnModifiersContext fnModifiers(int i) {
return getRuleContext(FnModifiersContext.class,i);
}
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public FnDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fnDecl; }
}
public final FnDeclContext fnDecl() throws RecognitionException {
FnDeclContext _localctx = new FnDeclContext(_ctx, getState());
enterRule(_localctx, 42, RULE_fnDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXAMPLE || _la==COUNTEREXAMPLE) {
{
setState(253);
sampleModifiers();
}
}
setState(256);
match(DEF);
setState(260);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPAQUE) | (1L << INLINE) | (1L << OVERLAP) | (1L << PATTERN_KW))) != 0)) {
{
{
setState(257);
fnModifiers();
}
}
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(263);
declNameOrInfix();
setState(267);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(264);
tele();
}
}
setState(269);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(271);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(270);
type();
}
}
setState(273);
fnBody();
setState(275);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BIND_KW) {
{
setState(274);
bindBlock();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FnBodyContext extends ParserRuleContext {
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List BAR() { return getTokens(AyaParser.BAR); }
public TerminalNode BAR(int i) {
return getToken(AyaParser.BAR, i);
}
public List clause() {
return getRuleContexts(ClauseContext.class);
}
public ClauseContext clause(int i) {
return getRuleContext(ClauseContext.class,i);
}
public FnBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fnBody; }
}
public final FnBodyContext fnBody() throws RecognitionException {
FnBodyContext _localctx = new FnBodyContext(_ctx, getState());
enterRule(_localctx, 44, RULE_fnBody);
int _la;
try {
setState(286);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IMPLIES:
enterOuterAlt(_localctx, 1);
{
setState(277);
match(IMPLIES);
setState(278);
expr(0);
}
break;
case EOF:
case EXAMPLE:
case COUNTEREXAMPLE:
case OPEN:
case IMPORT:
case PUBLIC:
case PRIVATE:
case MODULE_KW:
case BIND_KW:
case VARIABLE:
case DEF:
case STRUCT:
case DATA:
case PRIM:
case BAR:
case RBRACE:
case DOC_COMMENT:
enterOuterAlt(_localctx, 2);
{
setState(283);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(279);
match(BAR);
setState(280);
clause();
}
}
setState(285);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
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 FnModifiersContext extends ParserRuleContext {
public TerminalNode OPAQUE() { return getToken(AyaParser.OPAQUE, 0); }
public TerminalNode INLINE() { return getToken(AyaParser.INLINE, 0); }
public TerminalNode OVERLAP() { return getToken(AyaParser.OVERLAP, 0); }
public TerminalNode PATTERN_KW() { return getToken(AyaParser.PATTERN_KW, 0); }
public FnModifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fnModifiers; }
}
public final FnModifiersContext fnModifiers() throws RecognitionException {
FnModifiersContext _localctx = new FnModifiersContext(_ctx, getState());
enterRule(_localctx, 46, RULE_fnModifiers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(288);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OPAQUE) | (1L << INLINE) | (1L << OVERLAP) | (1L << PATTERN_KW))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructDeclContext extends ParserRuleContext {
public TerminalNode STRUCT() { return getToken(AyaParser.STRUCT, 0); }
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public SampleModifiersContext sampleModifiers() {
return getRuleContext(SampleModifiersContext.class,0);
}
public TerminalNode OPEN() { return getToken(AyaParser.OPEN, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode EXTENDS() { return getToken(AyaParser.EXTENDS, 0); }
public IdsCommaContext idsComma() {
return getRuleContext(IdsCommaContext.class,0);
}
public List BAR() { return getTokens(AyaParser.BAR); }
public TerminalNode BAR(int i) {
return getToken(AyaParser.BAR, i);
}
public List field() {
return getRuleContexts(FieldContext.class);
}
public FieldContext field(int i) {
return getRuleContext(FieldContext.class,i);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public TerminalNode PUBLIC() { return getToken(AyaParser.PUBLIC, 0); }
public StructDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structDecl; }
}
public final StructDeclContext structDecl() throws RecognitionException {
StructDeclContext _localctx = new StructDeclContext(_ctx, getState());
enterRule(_localctx, 48, RULE_structDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXAMPLE || _la==COUNTEREXAMPLE) {
{
setState(290);
sampleModifiers();
}
}
setState(297);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN || _la==PUBLIC) {
{
setState(294);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PUBLIC) {
{
setState(293);
match(PUBLIC);
}
}
setState(296);
match(OPEN);
}
}
setState(299);
match(STRUCT);
setState(300);
declNameOrInfix();
setState(304);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(301);
tele();
}
}
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(307);
type();
}
}
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(310);
match(EXTENDS);
setState(311);
idsComma();
}
}
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(314);
match(BAR);
setState(315);
field();
}
}
setState(320);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BIND_KW) {
{
setState(321);
bindBlock();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimDeclContext extends ParserRuleContext {
public TerminalNode PRIM() { return getToken(AyaParser.PRIM, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public PrimDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primDecl; }
}
public final PrimDeclContext primDecl() throws RecognitionException {
PrimDeclContext _localctx = new PrimDeclContext(_ctx, getState());
enterRule(_localctx, 50, RULE_primDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(324);
match(PRIM);
setState(325);
match(ID);
setState(329);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(326);
tele();
}
}
setState(331);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(332);
type();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldContext extends ParserRuleContext {
public FieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_field; }
public FieldContext() { }
public void copyFrom(FieldContext ctx) {
super.copyFrom(ctx);
}
}
public static class FieldDeclContext extends FieldContext {
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode COERCE() { return getToken(AyaParser.COERCE, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public ClausesContext clauses() {
return getRuleContext(ClausesContext.class,0);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public FieldDeclContext(FieldContext ctx) { copyFrom(ctx); }
}
public static class FieldImplContext extends FieldContext {
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public FieldImplContext(FieldContext ctx) { copyFrom(ctx); }
}
public final FieldContext field() throws RecognitionException {
FieldContext _localctx = new FieldContext(_ctx, getState());
enterRule(_localctx, 52, RULE_field);
int _la;
try {
setState(367);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
_localctx = new FieldDeclContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COERCE) {
{
setState(335);
match(COERCE);
}
}
setState(338);
declNameOrInfix();
setState(342);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(339);
tele();
}
}
setState(344);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(345);
type();
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(346);
clauses();
}
}
setState(350);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(349);
bindBlock();
}
break;
}
}
break;
case 2:
_localctx = new FieldImplContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(352);
declNameOrInfix();
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(353);
tele();
}
}
setState(358);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(359);
type();
}
}
setState(362);
match(IMPLIES);
setState(363);
expr(0);
setState(365);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(364);
bindBlock();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataDeclContext extends ParserRuleContext {
public TerminalNode DATA() { return getToken(AyaParser.DATA, 0); }
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public SampleModifiersContext sampleModifiers() {
return getRuleContext(SampleModifiersContext.class,0);
}
public TerminalNode OPEN() { return getToken(AyaParser.OPEN, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public List dataBody() {
return getRuleContexts(DataBodyContext.class);
}
public DataBodyContext dataBody(int i) {
return getRuleContext(DataBodyContext.class,i);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public TerminalNode PUBLIC() { return getToken(AyaParser.PUBLIC, 0); }
public DataDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataDecl; }
}
public final DataDeclContext dataDecl() throws RecognitionException {
DataDeclContext _localctx = new DataDeclContext(_ctx, getState());
enterRule(_localctx, 54, RULE_dataDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXAMPLE || _la==COUNTEREXAMPLE) {
{
setState(369);
sampleModifiers();
}
}
setState(376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN || _la==PUBLIC) {
{
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PUBLIC) {
{
setState(372);
match(PUBLIC);
}
}
setState(375);
match(OPEN);
}
}
setState(378);
match(DATA);
setState(379);
declNameOrInfix();
setState(383);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
{
setState(380);
tele();
}
}
setState(385);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(386);
type();
}
}
setState(392);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(389);
dataBody();
}
}
setState(394);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BIND_KW) {
{
setState(395);
bindBlock();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataBodyContext extends ParserRuleContext {
public DataBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataBody; }
public DataBodyContext() { }
public void copyFrom(DataBodyContext ctx) {
super.copyFrom(ctx);
}
}
public static class DataClausesContext extends DataBodyContext {
public DataCtorClauseContext dataCtorClause() {
return getRuleContext(DataCtorClauseContext.class,0);
}
public DataClausesContext(DataBodyContext ctx) { copyFrom(ctx); }
}
public static class DataCtorsContext extends DataBodyContext {
public TerminalNode BAR() { return getToken(AyaParser.BAR, 0); }
public DataCtorContext dataCtor() {
return getRuleContext(DataCtorContext.class,0);
}
public DataCtorsContext(DataBodyContext ctx) { copyFrom(ctx); }
}
public final DataBodyContext dataBody() throws RecognitionException {
DataBodyContext _localctx = new DataBodyContext(_ctx, getState());
enterRule(_localctx, 56, RULE_dataBody);
try {
setState(401);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
_localctx = new DataCtorsContext(_localctx);
enterOuterAlt(_localctx, 1);
{
{
setState(398);
match(BAR);
setState(399);
dataCtor();
}
}
break;
case 2:
_localctx = new DataClausesContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(400);
dataCtorClause();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataCtorContext extends ParserRuleContext {
public DeclNameOrInfixContext declNameOrInfix() {
return getRuleContext(DeclNameOrInfixContext.class,0);
}
public TerminalNode COERCE() { return getToken(AyaParser.COERCE, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public ClausesContext clauses() {
return getRuleContext(ClausesContext.class,0);
}
public BindBlockContext bindBlock() {
return getRuleContext(BindBlockContext.class,0);
}
public DataCtorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataCtor; }
}
public final DataCtorContext dataCtor() throws RecognitionException {
DataCtorContext _localctx = new DataCtorContext(_ctx, getState());
enterRule(_localctx, 58, RULE_dataCtor);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COERCE) {
{
setState(403);
match(COERCE);
}
}
setState(406);
declNameOrInfix();
setState(410);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(407);
tele();
}
}
}
setState(412);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,59,_ctx);
}
setState(414);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(413);
clauses();
}
}
setState(417);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
setState(416);
bindBlock();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DataCtorClauseContext extends ParserRuleContext {
public TerminalNode BAR() { return getToken(AyaParser.BAR, 0); }
public PatternsContext patterns() {
return getRuleContext(PatternsContext.class,0);
}
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public DataCtorContext dataCtor() {
return getRuleContext(DataCtorContext.class,0);
}
public DataCtorClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dataCtorClause; }
}
public final DataCtorClauseContext dataCtorClause() throws RecognitionException {
DataCtorClauseContext _localctx = new DataCtorClauseContext(_ctx, getState());
enterRule(_localctx, 60, RULE_dataCtorClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
match(BAR);
setState(420);
patterns();
setState(421);
match(IMPLIES);
setState(422);
dataCtor();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
}
}
public static class SingleContext extends ExprContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public SingleContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class SigmaContext extends ExprContext {
public TerminalNode SIGMA() { return getToken(AyaParser.SIGMA, 0); }
public TerminalNode SUCHTHAT() { return getToken(AyaParser.SUCHTHAT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public SigmaContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class ArrContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode TO() { return getToken(AyaParser.TO, 0); }
public ArrContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class AppContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public AppContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class NewContext extends ExprContext {
public TerminalNode NEW_KW() { return getToken(AyaParser.NEW_KW, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public List newArg() {
return getRuleContexts(NewArgContext.class);
}
public NewArgContext newArg(int i) {
return getRuleContext(NewArgContext.class,i);
}
public NewContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class ForallContext extends ExprContext {
public TerminalNode FORALL() { return getToken(AyaParser.FORALL, 0); }
public TerminalNode TO() { return getToken(AyaParser.TO, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public ForallContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class MatchContext extends ExprContext {
public TerminalNode MATCH() { return getToken(AyaParser.MATCH, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public ClausesContext clauses() {
return getRuleContext(ClausesContext.class,0);
}
public MatchContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class PiContext extends ExprContext {
public TerminalNode PI() { return getToken(AyaParser.PI, 0); }
public TerminalNode TO() { return getToken(AyaParser.TO, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public PiContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class LamContext extends ExprContext {
public TerminalNode LAMBDA() { return getToken(AyaParser.LAMBDA, 0); }
public List tele() {
return getRuleContexts(TeleContext.class);
}
public TeleContext tele(int i) {
return getRuleContext(TeleContext.class,i);
}
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public LamContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class ProjContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ProjFixContext projFix() {
return getRuleContext(ProjFixContext.class,0);
}
public ProjContext(ExprContext ctx) { copyFrom(ctx); }
}
public static class NewEmptyContext extends ExprContext {
public TerminalNode NEW_KW() { return getToken(AyaParser.NEW_KW, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NewEmptyContext(ExprContext ctx) { copyFrom(ctx); }
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 62;
enterRecursionRule(_localctx, 62, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(482);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
_localctx = new SingleContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(425);
atom();
}
break;
case 2:
{
_localctx = new NewContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(426);
match(NEW_KW);
setState(427);
expr(0);
setState(428);
match(LBRACE);
setState(432);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(429);
newArg();
}
}
setState(434);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(435);
match(RBRACE);
}
break;
case 3:
{
_localctx = new NewEmptyContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(437);
match(NEW_KW);
setState(438);
expr(8);
}
break;
case 4:
{
_localctx = new PiContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(439);
match(PI);
setState(441);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(440);
tele();
}
}
setState(443);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0) );
setState(445);
match(TO);
setState(446);
expr(5);
}
break;
case 5:
{
_localctx = new ForallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(448);
match(FORALL);
setState(450);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(449);
tele();
}
}
setState(452);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0) );
setState(454);
match(TO);
setState(455);
expr(4);
}
break;
case 6:
{
_localctx = new SigmaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(457);
match(SIGMA);
setState(459);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(458);
tele();
}
}
setState(461);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TYPE) | (1L << LBRACE) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0) );
setState(463);
match(SUCHTHAT);
setState(464);
expr(3);
}
break;
case 7:
{
_localctx = new LamContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(466);
match(LAMBDA);
setState(468);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(467);
tele();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(470);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(476);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(472);
match(IMPLIES);
setState(474);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(473);
expr(0);
}
break;
}
}
break;
}
}
break;
case 8:
{
_localctx = new MatchContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(478);
match(MATCH);
setState(479);
exprList();
setState(480);
clauses();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(497);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(495);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
_localctx = new ArrContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(484);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(485);
match(TO);
setState(486);
expr(7);
}
break;
case 2:
{
_localctx = new AppContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(487);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(489);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(488);
argument();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(491);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case 3:
{
_localctx = new ProjContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(493);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(494);
projFix();
}
break;
}
}
}
setState(499);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class NewArgContext extends ParserRuleContext {
public TerminalNode BAR() { return getToken(AyaParser.BAR, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public IdsContext ids() {
return getRuleContext(IdsContext.class,0);
}
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NewArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newArg; }
}
public final NewArgContext newArg() throws RecognitionException {
NewArgContext _localctx = new NewArgContext(_ctx, getState());
enterRule(_localctx, 64, RULE_newArg);
try {
enterOuterAlt(_localctx, 1);
{
setState(500);
match(BAR);
setState(501);
match(ID);
setState(502);
ids();
setState(503);
match(IMPLIES);
setState(504);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public List ULIFT() { return getTokens(AyaParser.ULIFT); }
public TerminalNode ULIFT(int i) {
return getToken(AyaParser.ULIFT, i);
}
public TerminalNode LPAREN() { return getToken(AyaParser.LPAREN, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RPAREN() { return getToken(AyaParser.RPAREN, 0); }
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 66, RULE_atom);
int _la;
try {
setState(517);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ULIFT:
case TYPE:
case LGOAL:
case NUMBER:
case CALM_FACE:
case STRING:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(509);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ULIFT) {
{
{
setState(506);
match(ULIFT);
}
}
setState(511);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(512);
literal();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(513);
match(LPAREN);
setState(514);
exprList();
setState(515);
match(RPAREN);
}
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 ArgumentContext extends ParserRuleContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public List projFix() {
return getRuleContexts(ProjFixContext.class);
}
public ProjFixContext projFix(int i) {
return getRuleContext(ProjFixContext.class,i);
}
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 68, RULE_argument);
int _la;
try {
int _alt;
setState(537);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(519);
atom();
setState(523);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(520);
projFix();
}
}
}
setState(525);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(526);
match(LBRACE);
setState(527);
exprList();
setState(528);
match(RBRACE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(530);
match(LBRACE);
setState(531);
match(ID);
setState(532);
match(IMPLIES);
setState(534);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ULIFT) | (1L << TYPE) | (1L << MATCH) | (1L << NEW_KW) | (1L << SIGMA) | (1L << LAMBDA) | (1L << PI) | (1L << FORALL) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
setState(533);
expr(0);
}
}
setState(536);
match(RBRACE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProjFixContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(AyaParser.DOT, 0); }
public TerminalNode NUMBER() { return getToken(AyaParser.NUMBER, 0); }
public QualifiedIdContext qualifiedId() {
return getRuleContext(QualifiedIdContext.class,0);
}
public ProjFixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_projFix; }
}
public final ProjFixContext projFix() throws RecognitionException {
ProjFixContext _localctx = new ProjFixContext(_ctx, getState());
enterRule(_localctx, 70, RULE_projFix);
try {
enterOuterAlt(_localctx, 1);
{
setState(539);
match(DOT);
setState(542);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NUMBER:
{
setState(540);
match(NUMBER);
}
break;
case ID:
{
setState(541);
qualifiedId();
}
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 ClausesContext extends ParserRuleContext {
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public List clause() {
return getRuleContexts(ClauseContext.class);
}
public ClauseContext clause(int i) {
return getRuleContext(ClauseContext.class,i);
}
public List BAR() { return getTokens(AyaParser.BAR); }
public TerminalNode BAR(int i) {
return getToken(AyaParser.BAR, i);
}
public ClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_clauses; }
}
public final ClausesContext clauses() throws RecognitionException {
ClausesContext _localctx = new ClausesContext(_ctx, getState());
enterRule(_localctx, 72, RULE_clauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(544);
match(LBRACE);
setState(546);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LBRACE) | (1L << LPAREN) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << ID))) != 0)) {
{
setState(545);
clause();
}
}
setState(552);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BAR) {
{
{
setState(548);
match(BAR);
setState(549);
clause();
}
}
setState(554);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(555);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClauseContext extends ParserRuleContext {
public PatternsContext patterns() {
return getRuleContext(PatternsContext.class,0);
}
public TerminalNode IMPLIES() { return getToken(AyaParser.IMPLIES, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_clause; }
}
public final ClauseContext clause() throws RecognitionException {
ClauseContext _localctx = new ClauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(557);
patterns();
setState(560);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLIES) {
{
setState(558);
match(IMPLIES);
setState(559);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternsContext extends ParserRuleContext {
public List pattern() {
return getRuleContexts(PatternContext.class);
}
public PatternContext pattern(int i) {
return getRuleContext(PatternContext.class,i);
}
public List COMMA() { return getTokens(AyaParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(AyaParser.COMMA, i);
}
public PatternsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patterns; }
}
public final PatternsContext patterns() throws RecognitionException {
PatternsContext _localctx = new PatternsContext(_ctx, getState());
enterRule(_localctx, 76, RULE_patterns);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(562);
pattern();
setState(567);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(563);
match(COMMA);
setState(564);
pattern();
}
}
setState(569);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternContext extends ParserRuleContext {
public AtomPatternsContext atomPatterns() {
return getRuleContext(AtomPatternsContext.class,0);
}
public PatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern; }
}
public final PatternContext pattern() throws RecognitionException {
PatternContext _localctx = new PatternContext(_ctx, getState());
enterRule(_localctx, 78, RULE_pattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(570);
atomPatterns();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomPatternsContext extends ParserRuleContext {
public List atomPattern() {
return getRuleContexts(AtomPatternContext.class);
}
public AtomPatternContext atomPattern(int i) {
return getRuleContext(AtomPatternContext.class,i);
}
public AtomPatternsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomPatterns; }
}
public final AtomPatternsContext atomPatterns() throws RecognitionException {
AtomPatternsContext _localctx = new AtomPatternsContext(_ctx, getState());
enterRule(_localctx, 80, RULE_atomPatterns);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(573);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(572);
atomPattern();
}
}
setState(575);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LBRACE) | (1L << LPAREN) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << ID))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomPatternContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(AyaParser.LPAREN, 0); }
public PatternsContext patterns() {
return getRuleContext(PatternsContext.class,0);
}
public TerminalNode RPAREN() { return getToken(AyaParser.RPAREN, 0); }
public TerminalNode AS() { return getToken(AyaParser.AS, 0); }
public TerminalNode ID() { return getToken(AyaParser.ID, 0); }
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public TerminalNode NUMBER() { return getToken(AyaParser.NUMBER, 0); }
public TerminalNode CALM_FACE() { return getToken(AyaParser.CALM_FACE, 0); }
public AtomPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomPattern; }
}
public final AtomPatternContext atomPattern() throws RecognitionException {
AtomPatternContext _localctx = new AtomPatternContext(_ctx, getState());
enterRule(_localctx, 82, RULE_atomPattern);
int _la;
try {
setState(596);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(577);
match(LPAREN);
setState(578);
patterns();
setState(579);
match(RPAREN);
setState(582);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(580);
match(AS);
setState(581);
match(ID);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(584);
match(LBRACE);
setState(585);
patterns();
setState(586);
match(RBRACE);
setState(589);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(587);
match(AS);
setState(588);
match(ID);
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(591);
match(NUMBER);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(592);
match(LPAREN);
setState(593);
match(RPAREN);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(594);
match(ID);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(595);
match(CALM_FACE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public QualifiedIdContext qualifiedId() {
return getRuleContext(QualifiedIdContext.class,0);
}
public TerminalNode CALM_FACE() { return getToken(AyaParser.CALM_FACE, 0); }
public TerminalNode LGOAL() { return getToken(AyaParser.LGOAL, 0); }
public TerminalNode RGOAL() { return getToken(AyaParser.RGOAL, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode NUMBER() { return getToken(AyaParser.NUMBER, 0); }
public TerminalNode STRING() { return getToken(AyaParser.STRING, 0); }
public TerminalNode TYPE() { return getToken(AyaParser.TYPE, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 84, RULE_literal);
int _la;
try {
setState(608);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ID:
enterOuterAlt(_localctx, 1);
{
setState(598);
qualifiedId();
}
break;
case CALM_FACE:
enterOuterAlt(_localctx, 2);
{
setState(599);
match(CALM_FACE);
}
break;
case LGOAL:
enterOuterAlt(_localctx, 3);
{
setState(600);
match(LGOAL);
setState(602);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ULIFT) | (1L << TYPE) | (1L << MATCH) | (1L << NEW_KW) | (1L << SIGMA) | (1L << LAMBDA) | (1L << PI) | (1L << FORALL) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
setState(601);
expr(0);
}
}
setState(604);
match(RGOAL);
}
break;
case NUMBER:
enterOuterAlt(_localctx, 4);
{
setState(605);
match(NUMBER);
}
break;
case STRING:
enterOuterAlt(_localctx, 5);
{
setState(606);
match(STRING);
}
break;
case TYPE:
enterOuterAlt(_localctx, 6);
{
setState(607);
match(TYPE);
}
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 TeleContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TerminalNode LPAREN() { return getToken(AyaParser.LPAREN, 0); }
public TeleBinderContext teleBinder() {
return getRuleContext(TeleBinderContext.class,0);
}
public TerminalNode RPAREN() { return getToken(AyaParser.RPAREN, 0); }
public TerminalNode LBRACE() { return getToken(AyaParser.LBRACE, 0); }
public TeleMaybeTypedExprContext teleMaybeTypedExpr() {
return getRuleContext(TeleMaybeTypedExprContext.class,0);
}
public TerminalNode RBRACE() { return getToken(AyaParser.RBRACE, 0); }
public TeleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tele; }
}
public final TeleContext tele() throws RecognitionException {
TeleContext _localctx = new TeleContext(_ctx, getState());
enterRule(_localctx, 86, RULE_tele);
try {
setState(619);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TYPE:
case LGOAL:
case NUMBER:
case CALM_FACE:
case STRING:
case ID:
enterOuterAlt(_localctx, 1);
{
setState(610);
literal();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(611);
match(LPAREN);
setState(612);
teleBinder();
setState(613);
match(RPAREN);
}
break;
case LBRACE:
enterOuterAlt(_localctx, 3);
{
setState(615);
match(LBRACE);
setState(616);
teleMaybeTypedExpr();
setState(617);
match(RBRACE);
}
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 TeleBinderContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TeleMaybeTypedExprContext teleMaybeTypedExpr() {
return getRuleContext(TeleMaybeTypedExprContext.class,0);
}
public TeleBinderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_teleBinder; }
}
public final TeleBinderContext teleBinder() throws RecognitionException {
TeleBinderContext _localctx = new TeleBinderContext(_ctx, getState());
enterRule(_localctx, 88, RULE_teleBinder);
try {
setState(623);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(621);
expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(622);
teleMaybeTypedExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TeleMaybeTypedExprContext extends ParserRuleContext {
public IdsContext ids() {
return getRuleContext(IdsContext.class,0);
}
public TerminalNode PATTERN_KW() { return getToken(AyaParser.PATTERN_KW, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TeleMaybeTypedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_teleMaybeTypedExpr; }
}
public final TeleMaybeTypedExprContext teleMaybeTypedExpr() throws RecognitionException {
TeleMaybeTypedExprContext _localctx = new TeleMaybeTypedExprContext(_ctx, getState());
enterRule(_localctx, 90, RULE_teleMaybeTypedExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(626);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PATTERN_KW) {
{
setState(625);
match(PATTERN_KW);
}
}
setState(628);
ids();
setState(630);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(629);
type();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprListContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(AyaParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(AyaParser.COMMA, i);
}
public ExprListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprList; }
}
public final ExprListContext exprList() throws RecognitionException {
ExprListContext _localctx = new ExprListContext(_ctx, getState());
enterRule(_localctx, 92, RULE_exprList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(637);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(632);
expr(0);
setState(633);
match(COMMA);
}
}
}
setState(639);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
}
setState(641);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ULIFT) | (1L << TYPE) | (1L << MATCH) | (1L << NEW_KW) | (1L << SIGMA) | (1L << LAMBDA) | (1L << PI) | (1L << FORALL) | (1L << LPAREN) | (1L << LGOAL) | (1L << NUMBER) | (1L << CALM_FACE) | (1L << STRING) | (1L << ID))) != 0)) {
{
setState(640);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdsCommaContext extends ParserRuleContext {
public List ID() { return getTokens(AyaParser.ID); }
public TerminalNode ID(int i) {
return getToken(AyaParser.ID, i);
}
public List COMMA() { return getTokens(AyaParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(AyaParser.COMMA, i);
}
public IdsCommaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_idsComma; }
}
public final IdsCommaContext idsComma() throws RecognitionException {
IdsCommaContext _localctx = new IdsCommaContext(_ctx, getState());
enterRule(_localctx, 94, RULE_idsComma);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(647);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(643);
match(ID);
setState(644);
match(COMMA);
}
}
}
setState(649);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
}
setState(651);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(650);
match(ID);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QIdsCommaContext extends ParserRuleContext {
public List qualifiedId() {
return getRuleContexts(QualifiedIdContext.class);
}
public QualifiedIdContext qualifiedId(int i) {
return getRuleContext(QualifiedIdContext.class,i);
}
public List COMMA() { return getTokens(AyaParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(AyaParser.COMMA, i);
}
public QIdsCommaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qIdsComma; }
}
public final QIdsCommaContext qIdsComma() throws RecognitionException {
QIdsCommaContext _localctx = new QIdsCommaContext(_ctx, getState());
enterRule(_localctx, 96, RULE_qIdsComma);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(658);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(653);
qualifiedId();
setState(654);
match(COMMA);
}
}
}
setState(660);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
}
setState(662);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(661);
qualifiedId();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdsContext extends ParserRuleContext {
public List ID() { return getTokens(AyaParser.ID); }
public TerminalNode ID(int i) {
return getToken(AyaParser.ID, i);
}
public IdsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ids; }
}
public final IdsContext ids() throws RecognitionException {
IdsContext _localctx = new IdsContext(_ctx, getState());
enterRule(_localctx, 98, RULE_ids);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(667);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ID) {
{
{
setState(664);
match(ID);
}
}
setState(669);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(AyaParser.COLON, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 100, RULE_type);
try {
enterOuterAlt(_localctx, 1);
{
setState(670);
match(COLON);
setState(671);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedIdContext extends ParserRuleContext {
public List ID() { return getTokens(AyaParser.ID); }
public TerminalNode ID(int i) {
return getToken(AyaParser.ID, i);
}
public List COLON2() { return getTokens(AyaParser.COLON2); }
public TerminalNode COLON2(int i) {
return getToken(AyaParser.COLON2, i);
}
public QualifiedIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedId; }
}
public final QualifiedIdContext qualifiedId() throws RecognitionException {
QualifiedIdContext _localctx = new QualifiedIdContext(_ctx, getState());
enterRule(_localctx, 102, RULE_qualifiedId);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(673);
match(ID);
setState(678);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(674);
match(COLON2);
setState(675);
match(ID);
}
}
}
setState(680);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 31:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 7);
case 1:
return precpred(_ctx, 10);
case 2:
return precpred(_ctx, 6);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3B\u02ac\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\3\2\7\2l\n\2\f\2\16\2o\13\2\3\2\3\2\3\3\6\3t\n\3\r\3\16"+
"\3u\3\3\5\3y\n\3\3\3\5\3|\n\3\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u0084\n\4\3"+
"\5\6\5\u0087\n\5\r\5\16\5\u0088\3\6\3\6\3\6\3\6\5\6\u008f\n\6\3\7\5\7"+
"\u0092\n\7\3\7\3\7\5\7\u0096\n\7\3\7\3\7\5\7\u009a\n\7\3\b\3\b\3\b\3\b"+
"\7\b\u00a0\n\b\f\b\16\b\u00a3\13\b\3\b\3\b\3\t\3\t\6\t\u00a9\n\t\r\t\16"+
"\t\u00aa\3\t\3\t\6\t\u00af\n\t\r\t\16\t\u00b0\5\t\u00b3\n\t\3\n\3\n\3"+
"\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\7\f\u00c0\n\f\f\f\16\f\u00c3\13"+
"\f\3\f\5\f\u00c6\n\f\3\r\3\r\5\r\u00ca\n\r\3\16\3\16\5\16\u00ce\n\16\3"+
"\16\3\16\5\16\u00d2\n\16\3\17\3\17\3\17\3\17\3\20\3\20\3\21\5\21\u00db"+
"\n\21\3\21\3\21\3\21\3\21\5\21\u00e1\n\21\3\22\3\22\3\23\3\23\3\23\3\23"+
"\5\23\u00e9\n\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\7\24\u00f2\n\24\f"+
"\24\16\24\u00f5\13\24\3\24\5\24\u00f8\n\24\3\25\3\25\3\25\3\26\3\26\3"+
"\26\3\27\5\27\u0101\n\27\3\27\3\27\7\27\u0105\n\27\f\27\16\27\u0108\13"+
"\27\3\27\3\27\7\27\u010c\n\27\f\27\16\27\u010f\13\27\3\27\5\27\u0112\n"+
"\27\3\27\3\27\5\27\u0116\n\27\3\30\3\30\3\30\3\30\7\30\u011c\n\30\f\30"+
"\16\30\u011f\13\30\5\30\u0121\n\30\3\31\3\31\3\32\5\32\u0126\n\32\3\32"+
"\5\32\u0129\n\32\3\32\5\32\u012c\n\32\3\32\3\32\3\32\7\32\u0131\n\32\f"+
"\32\16\32\u0134\13\32\3\32\5\32\u0137\n\32\3\32\3\32\5\32\u013b\n\32\3"+
"\32\3\32\7\32\u013f\n\32\f\32\16\32\u0142\13\32\3\32\5\32\u0145\n\32\3"+
"\33\3\33\3\33\7\33\u014a\n\33\f\33\16\33\u014d\13\33\3\33\5\33\u0150\n"+
"\33\3\34\5\34\u0153\n\34\3\34\3\34\7\34\u0157\n\34\f\34\16\34\u015a\13"+
"\34\3\34\3\34\5\34\u015e\n\34\3\34\5\34\u0161\n\34\3\34\3\34\7\34\u0165"+
"\n\34\f\34\16\34\u0168\13\34\3\34\5\34\u016b\n\34\3\34\3\34\3\34\5\34"+
"\u0170\n\34\5\34\u0172\n\34\3\35\5\35\u0175\n\35\3\35\5\35\u0178\n\35"+
"\3\35\5\35\u017b\n\35\3\35\3\35\3\35\7\35\u0180\n\35\f\35\16\35\u0183"+
"\13\35\3\35\5\35\u0186\n\35\3\35\7\35\u0189\n\35\f\35\16\35\u018c\13\35"+
"\3\35\5\35\u018f\n\35\3\36\3\36\3\36\5\36\u0194\n\36\3\37\5\37\u0197\n"+
"\37\3\37\3\37\7\37\u019b\n\37\f\37\16\37\u019e\13\37\3\37\5\37\u01a1\n"+
"\37\3\37\5\37\u01a4\n\37\3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\7!\u01b1\n!"+
"\f!\16!\u01b4\13!\3!\3!\3!\3!\3!\3!\6!\u01bc\n!\r!\16!\u01bd\3!\3!\3!"+
"\3!\3!\6!\u01c5\n!\r!\16!\u01c6\3!\3!\3!\3!\3!\6!\u01ce\n!\r!\16!\u01cf"+
"\3!\3!\3!\3!\3!\6!\u01d7\n!\r!\16!\u01d8\3!\3!\5!\u01dd\n!\5!\u01df\n"+
"!\3!\3!\3!\3!\5!\u01e5\n!\3!\3!\3!\3!\3!\6!\u01ec\n!\r!\16!\u01ed\3!\3"+
"!\7!\u01f2\n!\f!\16!\u01f5\13!\3\"\3\"\3\"\3\"\3\"\3\"\3#\7#\u01fe\n#"+
"\f#\16#\u0201\13#\3#\3#\3#\3#\3#\5#\u0208\n#\3$\3$\7$\u020c\n$\f$\16$"+
"\u020f\13$\3$\3$\3$\3$\3$\3$\3$\3$\5$\u0219\n$\3$\5$\u021c\n$\3%\3%\3"+
"%\5%\u0221\n%\3&\3&\5&\u0225\n&\3&\3&\7&\u0229\n&\f&\16&\u022c\13&\3&"+
"\3&\3\'\3\'\3\'\5\'\u0233\n\'\3(\3(\3(\7(\u0238\n(\f(\16(\u023b\13(\3"+
")\3)\3*\6*\u0240\n*\r*\16*\u0241\3+\3+\3+\3+\3+\5+\u0249\n+\3+\3+\3+\3"+
"+\3+\5+\u0250\n+\3+\3+\3+\3+\3+\5+\u0257\n+\3,\3,\3,\3,\5,\u025d\n,\3"+
",\3,\3,\3,\5,\u0263\n,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5-\u026e\n-\3.\3.\5"+
".\u0272\n.\3/\5/\u0275\n/\3/\3/\5/\u0279\n/\3\60\3\60\3\60\7\60\u027e"+
"\n\60\f\60\16\60\u0281\13\60\3\60\5\60\u0284\n\60\3\61\3\61\7\61\u0288"+
"\n\61\f\61\16\61\u028b\13\61\3\61\5\61\u028e\n\61\3\62\3\62\3\62\7\62"+
"\u0293\n\62\f\62\16\62\u0296\13\62\3\62\5\62\u0299\n\62\3\63\7\63\u029c"+
"\n\63\f\63\16\63\u029f\13\63\3\64\3\64\3\64\3\65\3\65\3\65\7\65\u02a7"+
"\n\65\f\65\16\65\u02aa\13\65\3\65\2\3@\66\2\4\6\b\n\f\16\20\22\24\26\30"+
"\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfh\2\6\3\2\b\t\3"+
"\2\3\5\3\2\6\7\4\2\24\26!!\2\u02f3\2m\3\2\2\2\4{\3\2\2\2\6\u0083\3\2\2"+
"\2\b\u0086\3\2\2\2\n\u008a\3\2\2\2\f\u0091\3\2\2\2\16\u009b\3\2\2\2\20"+
"\u00b2\3\2\2\2\22\u00b4\3\2\2\2\24\u00b8\3\2\2\2\26\u00c1\3\2\2\2\30\u00c7"+
"\3\2\2\2\32\u00cb\3\2\2\2\34\u00d3\3\2\2\2\36\u00d7\3\2\2\2 \u00da\3\2"+
"\2\2\"\u00e2\3\2\2\2$\u00e8\3\2\2\2&\u00f7\3\2\2\2(\u00f9\3\2\2\2*\u00fc"+
"\3\2\2\2,\u0100\3\2\2\2.\u0120\3\2\2\2\60\u0122\3\2\2\2\62\u0125\3\2\2"+
"\2\64\u0146\3\2\2\2\66\u0171\3\2\2\28\u0174\3\2\2\2:\u0193\3\2\2\2<\u0196"+
"\3\2\2\2>\u01a5\3\2\2\2@\u01e4\3\2\2\2B\u01f6\3\2\2\2D\u0207\3\2\2\2F"+
"\u021b\3\2\2\2H\u021d\3\2\2\2J\u0222\3\2\2\2L\u022f\3\2\2\2N\u0234\3\2"+
"\2\2P\u023c\3\2\2\2R\u023f\3\2\2\2T\u0256\3\2\2\2V\u0262\3\2\2\2X\u026d"+
"\3\2\2\2Z\u0271\3\2\2\2\\\u0274\3\2\2\2^\u027f\3\2\2\2`\u0289\3\2\2\2"+
"b\u0294\3\2\2\2d\u029d\3\2\2\2f\u02a0\3\2\2\2h\u02a3\3\2\2\2jl\5\6\4\2"+
"kj\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3\2\2\2np\3\2\2\2om\3\2\2\2pq\7\2\2\3"+
"q\3\3\2\2\2rt\5\6\4\2sr\3\2\2\2tu\3\2\2\2us\3\2\2\2uv\3\2\2\2v|\3\2\2"+
"\2wy\7=\2\2xw\3\2\2\2xy\3\2\2\2yz\3\2\2\2z|\5@!\2{s\3\2\2\2{x\3\2\2\2"+
"|\5\3\2\2\2}\u0084\5 \21\2~\u0084\5\n\6\2\177\u0084\5\f\7\2\u0080\u0084"+
"\5\16\b\2\u0081\u0084\5\b\5\2\u0082\u0084\5\34\17\2\u0083}\3\2\2\2\u0083"+
"~\3\2\2\2\u0083\177\3\2\2\2\u0083\u0080\3\2\2\2\u0083\u0081\3\2\2\2\u0083"+
"\u0082\3\2\2\2\u0084\7\3\2\2\2\u0085\u0087\7?\2\2\u0086\u0085\3\2\2\2"+
"\u0087\u0088\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\t\3"+
"\2\2\2\u008a\u008b\7\16\2\2\u008b\u008e\5h\65\2\u008c\u008d\7\f\2\2\u008d"+
"\u008f\7=\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2\2\u008f\13\3\2\2\2"+
"\u0090\u0092\7\17\2\2\u0091\u0090\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093"+
"\3\2\2\2\u0093\u0095\7\r\2\2\u0094\u0096\7\16\2\2\u0095\u0094\3\2\2\2"+
"\u0095\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097\u0099\5h\65\2\u0098\u009a"+
"\5\20\t\2\u0099\u0098\3\2\2\2\u0099\u009a\3\2\2\2\u009a\r\3\2\2\2\u009b"+
"\u009c\7\27\2\2\u009c\u009d\7=\2\2\u009d\u00a1\7\63\2\2\u009e\u00a0\5"+
"\6\4\2\u009f\u009e\3\2\2\2\u00a0\u00a3\3\2\2\2\u00a1\u009f\3\2\2\2\u00a1"+
"\u00a2\3\2\2\2\u00a2\u00a4\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a4\u00a5\7\64"+
"\2\2\u00a5\17\3\2\2\2\u00a6\u00a8\7\21\2\2\u00a7\u00a9\5\24\13\2\u00a8"+
"\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2"+
"\2\2\u00ab\u00b3\3\2\2\2\u00ac\u00ae\7\22\2\2\u00ad\u00af\5\22\n\2\u00ae"+
"\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00b1\3\2"+
"\2\2\u00b1\u00b3\3\2\2\2\u00b2\u00a6\3\2\2\2\u00b2\u00ac\3\2\2\2\u00b3"+
"\21\3\2\2\2\u00b4\u00b5\7\65\2\2\u00b5\u00b6\5`\61\2\u00b6\u00b7\7\66"+
"\2\2\u00b7\23\3\2\2\2\u00b8\u00b9\7\65\2\2\u00b9\u00ba\5\26\f\2\u00ba"+
"\u00bb\7\66\2\2\u00bb\25\3\2\2\2\u00bc\u00bd\5\30\r\2\u00bd\u00be\7\60"+
"\2\2\u00be\u00c0\3\2\2\2\u00bf\u00bc\3\2\2\2\u00c0\u00c3\3\2\2\2\u00c1"+
"\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3\u00c1\3\2"+
"\2\2\u00c4\u00c6\5\30\r\2\u00c5\u00c4\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6"+
"\27\3\2\2\2\u00c7\u00c9\7=\2\2\u00c8\u00ca\5\32\16\2\u00c9\u00c8\3\2\2"+
"\2\u00c9\u00ca\3\2\2\2\u00ca\31\3\2\2\2\u00cb\u00cd\7\f\2\2\u00cc\u00ce"+
"\5\"\22\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2"+
"\u00cf\u00d1\7=\2\2\u00d0\u00d2\5&\24\2\u00d1\u00d0\3\2\2\2\u00d1\u00d2"+
"\3\2\2\2\u00d2\33\3\2\2\2\u00d3\u00d4\7\32\2\2\u00d4\u00d5\5d\63\2\u00d5"+
"\u00d6\5f\64\2\u00d6\35\3\2\2\2\u00d7\u00d8\t\2\2\2\u00d8\37\3\2\2\2\u00d9"+
"\u00db\7\20\2\2\u00da\u00d9\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00e0\3"+
"\2\2\2\u00dc\u00e1\5,\27\2\u00dd\u00e1\5\62\32\2\u00de\u00e1\58\35\2\u00df"+
"\u00e1\5\64\33\2\u00e0\u00dc\3\2\2\2\u00e0\u00dd\3\2\2\2\u00e0\u00de\3"+
"\2\2\2\u00e0\u00df\3\2\2\2\u00e1!\3\2\2\2\u00e2\u00e3\t\3\2\2\u00e3#\3"+
"\2\2\2\u00e4\u00e9\7=\2\2\u00e5\u00e6\5\"\22\2\u00e6\u00e7\7=\2\2\u00e7"+
"\u00e9\3\2\2\2\u00e8\u00e4\3\2\2\2\u00e8\u00e5\3\2\2\2\u00e9%\3\2\2\2"+
"\u00ea\u00eb\7\30\2\2\u00eb\u00ec\t\4\2\2\u00ec\u00f8\5b\62\2\u00ed\u00ee"+
"\7\30\2\2\u00ee\u00f3\7\63\2\2\u00ef\u00f2\5(\25\2\u00f0\u00f2\5*\26\2"+
"\u00f1\u00ef\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3\u00f1"+
"\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f6\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6"+
"\u00f8\7\64\2\2\u00f7\u00ea\3\2\2\2\u00f7\u00ed\3\2\2\2\u00f8\'\3\2\2"+
"\2\u00f9\u00fa\7\6\2\2\u00fa\u00fb\5b\62\2\u00fb)\3\2\2\2\u00fc\u00fd"+
"\7\7\2\2\u00fd\u00fe\5b\62\2\u00fe+\3\2\2\2\u00ff\u0101\5\36\20\2\u0100"+
"\u00ff\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0106\7\33"+
"\2\2\u0103\u0105\5\60\31\2\u0104\u0103\3\2\2\2\u0105\u0108\3\2\2\2\u0106"+
"\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0109\3\2\2\2\u0108\u0106\3\2"+
"\2\2\u0109\u010d\5$\23\2\u010a\u010c\5X-\2\u010b\u010a\3\2\2\2\u010c\u010f"+
"\3\2\2\2\u010d\u010b\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0111\3\2\2\2\u010f"+
"\u010d\3\2\2\2\u0110\u0112\5f\64\2\u0111\u0110\3\2\2\2\u0111\u0112\3\2"+
"\2\2\u0112\u0113\3\2\2\2\u0113\u0115\5.\30\2\u0114\u0116\5&\24\2\u0115"+
"\u0114\3\2\2\2\u0115\u0116\3\2\2\2\u0116-\3\2\2\2\u0117\u0118\7,\2\2\u0118"+
"\u0121\5@!\2\u0119\u011a\7/\2\2\u011a\u011c\5L\'\2\u011b\u0119\3\2\2\2"+
"\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u0121"+
"\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0117\3\2\2\2\u0120\u011d\3\2\2\2\u0121"+
"/\3\2\2\2\u0122\u0123\t\5\2\2\u0123\61\3\2\2\2\u0124\u0126\5\36\20\2\u0125"+
"\u0124\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u012b\3\2\2\2\u0127\u0129\7\17"+
"\2\2\u0128\u0127\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012a\3\2\2\2\u012a"+
"\u012c\7\r\2\2\u012b\u0128\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012d\3\2"+
"\2\2\u012d\u012e\7\34\2\2\u012e\u0132\5$\23\2\u012f\u0131\5X-\2\u0130"+
"\u012f\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2"+
"\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u0137\5f\64\2\u0136"+
"\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u013a\3\2\2\2\u0138\u0139\7\37"+
"\2\2\u0139\u013b\5`\61\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b"+
"\u0140\3\2\2\2\u013c\u013d\7/\2\2\u013d\u013f\5\66\34\2\u013e\u013c\3"+
"\2\2\2\u013f\u0142\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2\u0141"+
"\u0144\3\2\2\2\u0142\u0140\3\2\2\2\u0143\u0145\5&\24\2\u0144\u0143\3\2"+
"\2\2\u0144\u0145\3\2\2\2\u0145\63\3\2\2\2\u0146\u0147\7\36\2\2\u0147\u014b"+
"\7=\2\2\u0148\u014a\5X-\2\u0149\u0148\3\2\2\2\u014a\u014d\3\2\2\2\u014b"+
"\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u014f\3\2\2\2\u014d\u014b\3\2"+
"\2\2\u014e\u0150\5f\64\2\u014f\u014e\3\2\2\2\u014f\u0150\3\2\2\2\u0150"+
"\65\3\2\2\2\u0151\u0153\7\23\2\2\u0152\u0151\3\2\2\2\u0152\u0153\3\2\2"+
"\2\u0153\u0154\3\2\2\2\u0154\u0158\5$\23\2\u0155\u0157\5X-\2\u0156\u0155"+
"\3\2\2\2\u0157\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0159\3\2\2\2\u0159"+
"\u015b\3\2\2\2\u015a\u0158\3\2\2\2\u015b\u015d\5f\64\2\u015c\u015e\5J"+
"&\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0160\3\2\2\2\u015f"+
"\u0161\5&\24\2\u0160\u015f\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0172\3\2"+
"\2\2\u0162\u0166\5$\23\2\u0163\u0165\5X-\2\u0164\u0163\3\2\2\2\u0165\u0168"+
"\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u016a\3\2\2\2\u0168"+
"\u0166\3\2\2\2\u0169\u016b\5f\64\2\u016a\u0169\3\2\2\2\u016a\u016b\3\2"+
"\2\2\u016b\u016c\3\2\2\2\u016c\u016d\7,\2\2\u016d\u016f\5@!\2\u016e\u0170"+
"\5&\24\2\u016f\u016e\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0172\3\2\2\2\u0171"+
"\u0152\3\2\2\2\u0171\u0162\3\2\2\2\u0172\67\3\2\2\2\u0173\u0175\5\36\20"+
"\2\u0174\u0173\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u017a\3\2\2\2\u0176\u0178"+
"\7\17\2\2\u0177\u0176\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u0179\3\2\2\2"+
"\u0179\u017b\7\r\2\2\u017a\u0177\3\2\2\2\u017a\u017b\3\2\2\2\u017b\u017c"+
"\3\2\2\2\u017c\u017d\7\35\2\2\u017d\u0181\5$\23\2\u017e\u0180\5X-\2\u017f"+
"\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+
"\2\2\u0182\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0186\5f\64\2\u0185"+
"\u0184\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u018a\3\2\2\2\u0187\u0189\5:"+
"\36\2\u0188\u0187\3\2\2\2\u0189\u018c\3\2\2\2\u018a\u0188\3\2\2\2\u018a"+
"\u018b\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018d\u018f\5&"+
"\24\2\u018e\u018d\3\2\2\2\u018e\u018f\3\2\2\2\u018f9\3\2\2\2\u0190\u0191"+
"\7/\2\2\u0191\u0194\5<\37\2\u0192\u0194\5> \2\u0193\u0190\3\2\2\2\u0193"+
"\u0192\3\2\2\2\u0194;\3\2\2\2\u0195\u0197\7\23\2\2\u0196\u0195\3\2\2\2"+
"\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u019c\5$\23\2\u0199\u019b"+
"\5X-\2\u019a\u0199\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019a\3\2\2\2\u019c"+
"\u019d\3\2\2\2\u019d\u01a0\3\2\2\2\u019e\u019c\3\2\2\2\u019f\u01a1\5J"+
"&\2\u01a0\u019f\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1\u01a3\3\2\2\2\u01a2"+
"\u01a4\5&\24\2\u01a3\u01a2\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4=\3\2\2\2"+
"\u01a5\u01a6\7/\2\2\u01a6\u01a7\5N(\2\u01a7\u01a8\7,\2\2\u01a8\u01a9\5"+
"<\37\2\u01a9?\3\2\2\2\u01aa\u01ab\b!\1\2\u01ab\u01e5\5D#\2\u01ac\u01ad"+
"\7 \2\2\u01ad\u01ae\5@!\2\u01ae\u01b2\7\63\2\2\u01af\u01b1\5B\"\2\u01b0"+
"\u01af\3\2\2\2\u01b1\u01b4\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b3\3\2"+
"\2\2\u01b3\u01b5\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b5\u01b6\7\64\2\2\u01b6"+
"\u01e5\3\2\2\2\u01b7\u01b8\7 \2\2\u01b8\u01e5\5@!\n\u01b9\u01bb\7)\2\2"+
"\u01ba\u01bc\5X-\2\u01bb\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd\u01bb"+
"\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\7+\2\2\u01c0"+
"\u01c1\5@!\7\u01c1\u01e5\3\2\2\2\u01c2\u01c4\7*\2\2\u01c3\u01c5\5X-\2"+
"\u01c4\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7"+
"\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\7+\2\2\u01c9\u01ca\5@!\6\u01ca"+
"\u01e5\3\2\2\2\u01cb\u01cd\7\'\2\2\u01cc\u01ce\5X-\2\u01cd\u01cc\3\2\2"+
"\2\u01ce\u01cf\3\2\2\2\u01cf\u01cd\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d1"+
"\3\2\2\2\u01d1\u01d2\7-\2\2\u01d2\u01d3\5@!\5\u01d3\u01e5\3\2\2\2\u01d4"+
"\u01d6\7(\2\2\u01d5\u01d7\5X-\2\u01d6\u01d5\3\2\2\2\u01d7\u01d8\3\2\2"+
"\2\u01d8\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01de\3\2\2\2\u01da\u01dc"+
"\7,\2\2\u01db\u01dd\5@!\2\u01dc\u01db\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd"+
"\u01df\3\2\2\2\u01de\u01da\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01e5\3\2"+
"\2\2\u01e0\u01e1\7\31\2\2\u01e1\u01e2\5^\60\2\u01e2\u01e3\5J&\2\u01e3"+
"\u01e5\3\2\2\2\u01e4\u01aa\3\2\2\2\u01e4\u01ac\3\2\2\2\u01e4\u01b7\3\2"+
"\2\2\u01e4\u01b9\3\2\2\2\u01e4\u01c2\3\2\2\2\u01e4\u01cb\3\2\2\2\u01e4"+
"\u01d4\3\2\2\2\u01e4\u01e0\3\2\2\2\u01e5\u01f3\3\2\2\2\u01e6\u01e7\f\t"+
"\2\2\u01e7\u01e8\7+\2\2\u01e8\u01f2\5@!\t\u01e9\u01eb\f\f\2\2\u01ea\u01ec"+
"\5F$\2\u01eb\u01ea\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed"+
"\u01ee\3\2\2\2\u01ee\u01f2\3\2\2\2\u01ef\u01f0\f\b\2\2\u01f0\u01f2\5H"+
"%\2\u01f1\u01e6\3\2\2\2\u01f1\u01e9\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f2"+
"\u01f5\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4A\3\2\2\2"+
"\u01f5\u01f3\3\2\2\2\u01f6\u01f7\7/\2\2\u01f7\u01f8\7=\2\2\u01f8\u01f9"+
"\5d\63\2\u01f9\u01fa\7,\2\2\u01fa\u01fb\5@!\2\u01fbC\3\2\2\2\u01fc\u01fe"+
"\7\n\2\2\u01fd\u01fc\3\2\2\2\u01fe\u0201\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff"+
"\u0200\3\2\2\2\u0200\u0202\3\2\2\2\u0201\u01ff\3\2\2\2\u0202\u0208\5V"+
",\2\u0203\u0204\7\65\2\2\u0204\u0205\5^\60\2\u0205\u0206\7\66\2\2\u0206"+
"\u0208\3\2\2\2\u0207\u01ff\3\2\2\2\u0207\u0203\3\2\2\2\u0208E\3\2\2\2"+
"\u0209\u020d\5D#\2\u020a\u020c\5H%\2\u020b\u020a\3\2\2\2\u020c\u020f\3"+
"\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u021c\3\2\2\2\u020f"+
"\u020d\3\2\2\2\u0210\u0211\7\63\2\2\u0211\u0212\5^\60\2\u0212\u0213\7"+
"\64\2\2\u0213\u021c\3\2\2\2\u0214\u0215\7\63\2\2\u0215\u0216\7=\2\2\u0216"+
"\u0218\7,\2\2\u0217\u0219\5@!\2\u0218\u0217\3\2\2\2\u0218\u0219\3\2\2"+
"\2\u0219\u021a\3\2\2\2\u021a\u021c\7\64\2\2\u021b\u0209\3\2\2\2\u021b"+
"\u0210\3\2\2\2\u021b\u0214\3\2\2\2\u021cG\3\2\2\2\u021d\u0220\7.\2\2\u021e"+
"\u0221\79\2\2\u021f\u0221\5h\65\2\u0220\u021e\3\2\2\2\u0220\u021f\3\2"+
"\2\2\u0221I\3\2\2\2\u0222\u0224\7\63\2\2\u0223\u0225\5L\'\2\u0224\u0223"+
"\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u022a\3\2\2\2\u0226\u0227\7/\2\2\u0227"+
"\u0229\5L\'\2\u0228\u0226\3\2\2\2\u0229\u022c\3\2\2\2\u022a\u0228\3\2"+
"\2\2\u022a\u022b\3\2\2\2\u022b\u022d\3\2\2\2\u022c\u022a\3\2\2\2\u022d"+
"\u022e\7\64\2\2\u022eK\3\2\2\2\u022f\u0232\5N(\2\u0230\u0231\7,\2\2\u0231"+
"\u0233\5@!\2\u0232\u0230\3\2\2\2\u0232\u0233\3\2\2\2\u0233M\3\2\2\2\u0234"+
"\u0239\5P)\2\u0235\u0236\7\60\2\2\u0236\u0238\5P)\2\u0237\u0235\3\2\2"+
"\2\u0238\u023b\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u023a\3\2\2\2\u023aO"+
"\3\2\2\2\u023b\u0239\3\2\2\2\u023c\u023d\5R*\2\u023dQ\3\2\2\2\u023e\u0240"+
"\5T+\2\u023f\u023e\3\2\2\2\u0240\u0241\3\2\2\2\u0241\u023f\3\2\2\2\u0241"+
"\u0242\3\2\2\2\u0242S\3\2\2\2\u0243\u0244\7\65\2\2\u0244\u0245\5N(\2\u0245"+
"\u0248\7\66\2\2\u0246\u0247\7\f\2\2\u0247\u0249\7=\2\2\u0248\u0246\3\2"+
"\2\2\u0248\u0249\3\2\2\2\u0249\u0257\3\2\2\2\u024a\u024b\7\63\2\2\u024b"+
"\u024c\5N(\2\u024c\u024f\7\64\2\2\u024d\u024e\7\f\2\2\u024e\u0250\7=\2"+
"\2\u024f\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0257\3\2\2\2\u0251\u0257"+
"\79\2\2\u0252\u0253\7\65\2\2\u0253\u0257\7\66\2\2\u0254\u0257\7=\2\2\u0255"+
"\u0257\7:\2\2\u0256\u0243\3\2\2\2\u0256\u024a\3\2\2\2\u0256\u0251\3\2"+
"\2\2\u0256\u0252\3\2\2\2\u0256\u0254\3\2\2\2\u0256\u0255\3\2\2\2\u0257"+
"U\3\2\2\2\u0258\u0263\5h\65\2\u0259\u0263\7:\2\2\u025a\u025c\7\67\2\2"+
"\u025b\u025d\5@!\2\u025c\u025b\3\2\2\2\u025c\u025d\3\2\2\2\u025d\u025e"+
"\3\2\2\2\u025e\u0263\78\2\2\u025f\u0263\79\2\2\u0260\u0263\7;\2\2\u0261"+
"\u0263\7\13\2\2\u0262\u0258\3\2\2\2\u0262\u0259\3\2\2\2\u0262\u025a\3"+
"\2\2\2\u0262\u025f\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0261\3\2\2\2\u0263"+
"W\3\2\2\2\u0264\u026e\5V,\2\u0265\u0266\7\65\2\2\u0266\u0267\5Z.\2\u0267"+
"\u0268\7\66\2\2\u0268\u026e\3\2\2\2\u0269\u026a\7\63\2\2\u026a\u026b\5"+
"\\/\2\u026b\u026c\7\64\2\2\u026c\u026e\3\2\2\2\u026d\u0264\3\2\2\2\u026d"+
"\u0265\3\2\2\2\u026d\u0269\3\2\2\2\u026eY\3\2\2\2\u026f\u0272\5@!\2\u0270"+
"\u0272\5\\/\2\u0271\u026f\3\2\2\2\u0271\u0270\3\2\2\2\u0272[\3\2\2\2\u0273"+
"\u0275\7!\2\2\u0274\u0273\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0276\3\2"+
"\2\2\u0276\u0278\5d\63\2\u0277\u0279\5f\64\2\u0278\u0277\3\2\2\2\u0278"+
"\u0279\3\2\2\2\u0279]\3\2\2\2\u027a\u027b\5@!\2\u027b\u027c\7\60\2\2\u027c"+
"\u027e\3\2\2\2\u027d\u027a\3\2\2\2\u027e\u0281\3\2\2\2\u027f\u027d\3\2"+
"\2\2\u027f\u0280\3\2\2\2\u0280\u0283\3\2\2\2\u0281\u027f\3\2\2\2\u0282"+
"\u0284\5@!\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2\u0284_\3\2\2\2\u0285"+
"\u0286\7=\2\2\u0286\u0288\7\60\2\2\u0287\u0285\3\2\2\2\u0288\u028b\3\2"+
"\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a\u028d\3\2\2\2\u028b"+
"\u0289\3\2\2\2\u028c\u028e\7=\2\2\u028d\u028c\3\2\2\2\u028d\u028e\3\2"+
"\2\2\u028ea\3\2\2\2\u028f\u0290\5h\65\2\u0290\u0291\7\60\2\2\u0291\u0293"+
"\3\2\2\2\u0292\u028f\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0292\3\2\2\2\u0294"+
"\u0295\3\2\2\2\u0295\u0298\3\2\2\2\u0296\u0294\3\2\2\2\u0297\u0299\5h"+
"\65\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299c\3\2\2\2\u029a\u029c"+
"\7=\2\2\u029b\u029a\3\2\2\2\u029c\u029f\3\2\2\2\u029d\u029b\3\2\2\2\u029d"+
"\u029e\3\2\2\2\u029ee\3\2\2\2\u029f\u029d\3\2\2\2\u02a0\u02a1\7\61\2\2"+
"\u02a1\u02a2\5@!\2\u02a2g\3\2\2\2\u02a3\u02a8\7=\2\2\u02a4\u02a5\7\62"+
"\2\2\u02a5\u02a7\7=\2\2\u02a6\u02a4\3\2\2\2\u02a7\u02aa\3\2\2\2\u02a8"+
"\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9i\3\2\2\2\u02aa\u02a8\3\2\2\2"+
"gmux{\u0083\u0088\u008e\u0091\u0095\u0099\u00a1\u00aa\u00b0\u00b2\u00c1"+
"\u00c5\u00c9\u00cd\u00d1\u00da\u00e0\u00e8\u00f1\u00f3\u00f7\u0100\u0106"+
"\u010d\u0111\u0115\u011d\u0120\u0125\u0128\u012b\u0132\u0136\u013a\u0140"+
"\u0144\u014b\u014f\u0152\u0158\u015d\u0160\u0166\u016a\u016f\u0171\u0174"+
"\u0177\u017a\u0181\u0185\u018a\u018e\u0193\u0196\u019c\u01a0\u01a3\u01b2"+
"\u01bd\u01c6\u01cf\u01d8\u01dc\u01de\u01e4\u01ed\u01f1\u01f3\u01ff\u0207"+
"\u020d\u0218\u021b\u0220\u0224\u022a\u0232\u0239\u0241\u0248\u024f\u0256"+
"\u025c\u0262\u026d\u0271\u0274\u0278\u027f\u0283\u0289\u028d\u0294\u0298"+
"\u029d\u02a8";
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);
}
}
}
