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.eolang.parser.EoParser Maven / Gradle / Ivy
// Generated from org/eolang/parser/Eo.g4 by ANTLR 4.13.1
package org.eolang.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", "CheckReturnValue"})
public class EoParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
COMMENTARY=1, META=2, ROOT=3, HOME=4, STAR=5, CONST=6, SLASH=7, COLON=8,
ARROW=9, XI=10, PLUS=11, MINUS=12, QUESTION=13, SPACE=14, DOT=15, LSQ=16,
RSQ=17, LB=18, RB=19, PHI=20, RHO=21, HASH=22, BAR=23, EOL=24, BYTES=25,
STRING=26, INT=27, FLOAT=28, HEX=29, NAME=30, VER=31, TEXT=32, TAB=33,
UNTAB=34;
public static final int
RULE_program = 0, RULE_eop = 1, RULE_license = 2, RULE_metas = 3, RULE_objects = 4,
RULE_comment = 5, RULE_commentOptional = 6, RULE_commentMandatory = 7,
RULE_object = 8, RULE_slave = 9, RULE_master = 10, RULE_subMaster = 11,
RULE_masterBody = 12, RULE_just = 13, RULE_justNamed = 14, RULE_atom = 15,
RULE_formation = 16, RULE_innersOrEol = 17, RULE_inners = 18, RULE_attributes = 19,
RULE_attribute = 20, RULE_type = 21, RULE_application = 22, RULE_happlication = 23,
RULE_happlicationExtended = 24, RULE_happlicationReversed = 25, RULE_happlicationHead = 26,
RULE_happlicationHeadExtended = 27, RULE_applicable = 28, RULE_happlicationTail = 29,
RULE_happlicationTailReversed = 30, RULE_happlicationTailReversedFirst = 31,
RULE_happlicationArg = 32, RULE_vapplication = 33, RULE_vapplicationHead = 34,
RULE_vapplicationHeadNamed = 35, RULE_vapplicationHeadAs = 36, RULE_vapplicationArgs = 37,
RULE_vapplicationArgsReversed = 38, RULE_vapplicationArgsSpecific = 39,
RULE_vapplicationArgBound = 40, RULE_vapplicationArgBoundCurrent = 41,
RULE_vapplicationArgBoundNext = 42, RULE_vapplicationArgUnbound = 43,
RULE_vapplicationArgUnboundCurrent = 44, RULE_vapplicationArgUnboundNext = 45,
RULE_vapplicationArgHapplicationBound = 46, RULE_vapplicationArgHapplicationUnbound = 47,
RULE_formationNameless = 48, RULE_formationNamedOrNameless = 49, RULE_vapplicationArgVanonymBound = 50,
RULE_attributesAs = 51, RULE_vapplicationArgHanonymBoundBody = 52, RULE_vapplicationArgHanonymBound = 53,
RULE_vapplicationArgHanonymUnbound = 54, RULE_hformation = 55, RULE_hanonym = 56,
RULE_onlyphi = 57, RULE_onlyphiTail = 58, RULE_hanonymInner = 59, RULE_method = 60,
RULE_methodNamed = 61, RULE_hmethod = 62, RULE_hmethodOptional = 63, RULE_hmethodExtended = 64,
RULE_hmethodVersioned = 65, RULE_hmethodExtendedVersioned = 66, RULE_hmethodHead = 67,
RULE_hmethodHeadExtended = 68, RULE_vmethod = 69, RULE_vmethodVersioned = 70,
RULE_vmethodOptional = 71, RULE_vmethodHead = 72, RULE_methodTailOptional = 73,
RULE_vmethodHeadApplicationTail = 74, RULE_vmethodHeadVapplication = 75,
RULE_methodTail = 76, RULE_methodTailVersioned = 77, RULE_beginner = 78,
RULE_finisher = 79, RULE_beginnerOrFinisher = 80, RULE_versioned = 81,
RULE_reversed = 82, RULE_oname = 83, RULE_aname = 84, RULE_suffix = 85,
RULE_spacedArrow = 86, RULE_scope = 87, RULE_version = 88, RULE_as = 89,
RULE_data = 90;
private static String[] makeRuleNames() {
return new String[] {
"program", "eop", "license", "metas", "objects", "comment", "commentOptional",
"commentMandatory", "object", "slave", "master", "subMaster", "masterBody",
"just", "justNamed", "atom", "formation", "innersOrEol", "inners", "attributes",
"attribute", "type", "application", "happlication", "happlicationExtended",
"happlicationReversed", "happlicationHead", "happlicationHeadExtended",
"applicable", "happlicationTail", "happlicationTailReversed", "happlicationTailReversedFirst",
"happlicationArg", "vapplication", "vapplicationHead", "vapplicationHeadNamed",
"vapplicationHeadAs", "vapplicationArgs", "vapplicationArgsReversed",
"vapplicationArgsSpecific", "vapplicationArgBound", "vapplicationArgBoundCurrent",
"vapplicationArgBoundNext", "vapplicationArgUnbound", "vapplicationArgUnboundCurrent",
"vapplicationArgUnboundNext", "vapplicationArgHapplicationBound", "vapplicationArgHapplicationUnbound",
"formationNameless", "formationNamedOrNameless", "vapplicationArgVanonymBound",
"attributesAs", "vapplicationArgHanonymBoundBody", "vapplicationArgHanonymBound",
"vapplicationArgHanonymUnbound", "hformation", "hanonym", "onlyphi",
"onlyphiTail", "hanonymInner", "method", "methodNamed", "hmethod", "hmethodOptional",
"hmethodExtended", "hmethodVersioned", "hmethodExtendedVersioned", "hmethodHead",
"hmethodHeadExtended", "vmethod", "vmethodVersioned", "vmethodOptional",
"vmethodHead", "methodTailOptional", "vmethodHeadApplicationTail", "vmethodHeadVapplication",
"methodTail", "methodTailVersioned", "beginner", "finisher", "beginnerOrFinisher",
"versioned", "reversed", "oname", "aname", "suffix", "spacedArrow", "scope",
"version", "as", "data"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, "'Q'", "'QQ'", "'*'", "'!'", "'/'", "':'", "'>'", "'$'",
"'+'", "'-'", "'?'", "' '", "'.'", "'['", "']'", "'('", "')'", "'@'",
"'^'", "'#'", "'|'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "COMMENTARY", "META", "ROOT", "HOME", "STAR", "CONST", "SLASH",
"COLON", "ARROW", "XI", "PLUS", "MINUS", "QUESTION", "SPACE", "DOT",
"LSQ", "RSQ", "LB", "RB", "PHI", "RHO", "HASH", "BAR", "EOL", "BYTES",
"STRING", "INT", "FLOAT", "HEX", "NAME", "VER", "TEXT", "TAB", "UNTAB"
};
}
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 "Eo.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public EoParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class ProgramContext extends ParserRuleContext {
public ObjectsContext objects() {
return getRuleContext(ObjectsContext.class,0);
}
public TerminalNode EOF() { return getToken(EoParser.EOF, 0); }
public LicenseContext license() {
return getRuleContext(LicenseContext.class,0);
}
public MetasContext metas() {
return getRuleContext(MetasContext.class,0);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitProgram(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(182);
license();
}
break;
}
setState(186);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==META) {
{
setState(185);
metas();
}
}
setState(188);
objects();
setState(189);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EopContext extends ParserRuleContext {
public List EOL() { return getTokens(EoParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(EoParser.EOL, i);
}
public EopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterEop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitEop(this);
}
}
public final EopContext eop() throws RecognitionException {
EopContext _localctx = new EopContext(_ctx, getState());
enterRule(_localctx, 2, RULE_eop);
try {
enterOuterAlt(_localctx, 1);
{
setState(191);
match(EOL);
setState(192);
match(EOL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LicenseContext extends ParserRuleContext {
public List COMMENTARY() { return getTokens(EoParser.COMMENTARY); }
public TerminalNode COMMENTARY(int i) {
return getToken(EoParser.COMMENTARY, i);
}
public EopContext eop() {
return getRuleContext(EopContext.class,0);
}
public List EOL() { return getTokens(EoParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(EoParser.EOL, i);
}
public LicenseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_license; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterLicense(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitLicense(this);
}
}
public final LicenseContext license() throws RecognitionException {
LicenseContext _localctx = new LicenseContext(_ctx, getState());
enterRule(_localctx, 4, RULE_license);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(198);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(194);
match(COMMENTARY);
setState(195);
match(EOL);
}
}
}
setState(200);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
}
setState(201);
match(COMMENTARY);
setState(202);
eop();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MetasContext extends ParserRuleContext {
public List META() { return getTokens(EoParser.META); }
public TerminalNode META(int i) {
return getToken(EoParser.META, i);
}
public EopContext eop() {
return getRuleContext(EopContext.class,0);
}
public List EOL() { return getTokens(EoParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(EoParser.EOL, i);
}
public MetasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_metas; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMetas(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMetas(this);
}
}
public final MetasContext metas() throws RecognitionException {
MetasContext _localctx = new MetasContext(_ctx, getState());
enterRule(_localctx, 6, RULE_metas);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(208);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(204);
match(META);
setState(205);
match(EOL);
}
}
}
setState(210);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
setState(211);
match(META);
setState(212);
eop();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ObjectsContext extends ParserRuleContext {
public List object() {
return getRuleContexts(ObjectContext.class);
}
public ObjectContext object(int i) {
return getRuleContext(ObjectContext.class,i);
}
public List EOL() { return getTokens(EoParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(EoParser.EOL, i);
}
public ObjectsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objects; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterObjects(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitObjects(this);
}
}
public final ObjectsContext objects() throws RecognitionException {
ObjectsContext _localctx = new ObjectsContext(_ctx, getState());
enterRule(_localctx, 8, RULE_objects);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(220);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(214);
object();
setState(216);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EOL) {
{
setState(215);
match(EOL);
}
}
}
}
}
setState(222);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
setState(223);
object();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommentContext extends ParserRuleContext {
public TerminalNode COMMENTARY() { return getToken(EoParser.COMMENTARY, 0); }
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public CommentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterComment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitComment(this);
}
}
public final CommentContext comment() throws RecognitionException {
CommentContext _localctx = new CommentContext(_ctx, getState());
enterRule(_localctx, 10, RULE_comment);
try {
enterOuterAlt(_localctx, 1);
{
setState(225);
match(COMMENTARY);
setState(226);
match(EOL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommentOptionalContext extends ParserRuleContext {
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public CommentOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterCommentOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitCommentOptional(this);
}
}
public final CommentOptionalContext commentOptional() throws RecognitionException {
CommentOptionalContext _localctx = new CommentOptionalContext(_ctx, getState());
enterRule(_localctx, 12, RULE_commentOptional);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(231);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(228);
comment();
}
}
}
setState(233);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommentMandatoryContext extends ParserRuleContext {
public List comment() {
return getRuleContexts(CommentContext.class);
}
public CommentContext comment(int i) {
return getRuleContext(CommentContext.class,i);
}
public CommentMandatoryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commentMandatory; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterCommentMandatory(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitCommentMandatory(this);
}
}
public final CommentMandatoryContext commentMandatory() throws RecognitionException {
CommentMandatoryContext _localctx = new CommentMandatoryContext(_ctx, getState());
enterRule(_localctx, 14, RULE_commentMandatory);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(235);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(234);
comment();
}
}
setState(237);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==COMMENTARY );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ObjectContext extends ParserRuleContext {
public MasterContext master() {
return getRuleContext(MasterContext.class,0);
}
public SlaveContext slave() {
return getRuleContext(SlaveContext.class,0);
}
public ObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_object; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitObject(this);
}
}
public final ObjectContext object() throws RecognitionException {
ObjectContext _localctx = new ObjectContext(_ctx, getState());
enterRule(_localctx, 16, RULE_object);
try {
setState(241);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(239);
master();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(240);
slave();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SlaveContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public ApplicationContext application() {
return getRuleContext(ApplicationContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public MethodNamedContext methodNamed() {
return getRuleContext(MethodNamedContext.class,0);
}
public JustNamedContext justNamed() {
return getRuleContext(JustNamedContext.class,0);
}
public SlaveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_slave; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterSlave(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitSlave(this);
}
}
public final SlaveContext slave() throws RecognitionException {
SlaveContext _localctx = new SlaveContext(_ctx, getState());
enterRule(_localctx, 18, RULE_slave);
try {
enterOuterAlt(_localctx, 1);
{
setState(243);
commentOptional();
setState(251);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(244);
application();
}
break;
case 2:
{
setState(247);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(245);
methodNamed();
}
break;
case 2:
{
setState(246);
justNamed();
}
break;
}
setState(249);
match(EOL);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MasterContext extends ParserRuleContext {
public CommentMandatoryContext commentMandatory() {
return getRuleContext(CommentMandatoryContext.class,0);
}
public MasterBodyContext masterBody() {
return getRuleContext(MasterBodyContext.class,0);
}
public MasterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_master; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMaster(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMaster(this);
}
}
public final MasterContext master() throws RecognitionException {
MasterContext _localctx = new MasterContext(_ctx, getState());
enterRule(_localctx, 20, RULE_master);
try {
enterOuterAlt(_localctx, 1);
{
setState(253);
commentMandatory();
setState(254);
masterBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubMasterContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public MasterBodyContext masterBody() {
return getRuleContext(MasterBodyContext.class,0);
}
public SubMasterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subMaster; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterSubMaster(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitSubMaster(this);
}
}
public final SubMasterContext subMaster() throws RecognitionException {
SubMasterContext _localctx = new SubMasterContext(_ctx, getState());
enterRule(_localctx, 22, RULE_subMaster);
try {
enterOuterAlt(_localctx, 1);
{
setState(256);
commentOptional();
setState(257);
masterBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MasterBodyContext extends ParserRuleContext {
public FormationContext formation() {
return getRuleContext(FormationContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public MasterBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_masterBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMasterBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMasterBody(this);
}
}
public final MasterBodyContext masterBody() throws RecognitionException {
MasterBodyContext _localctx = new MasterBodyContext(_ctx, getState());
enterRule(_localctx, 24, RULE_masterBody);
try {
setState(268);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(259);
formation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(260);
atom();
}
break;
case 2:
{
setState(261);
hanonym();
setState(262);
oname();
}
break;
}
setState(266);
match(EOL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JustContext extends ParserRuleContext {
public BeginnerOrFinisherContext beginnerOrFinisher() {
return getRuleContext(BeginnerOrFinisherContext.class,0);
}
public VersionedContext versioned() {
return getRuleContext(VersionedContext.class,0);
}
public JustContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_just; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterJust(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitJust(this);
}
}
public final JustContext just() throws RecognitionException {
JustContext _localctx = new JustContext(_ctx, getState());
enterRule(_localctx, 26, RULE_just);
try {
setState(272);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(270);
beginnerOrFinisher();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(271);
versioned();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JustNamedContext extends ParserRuleContext {
public JustContext just() {
return getRuleContext(JustContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public JustNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_justNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterJustNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitJustNamed(this);
}
}
public final JustNamedContext justNamed() throws RecognitionException {
JustNamedContext _localctx = new JustNamedContext(_ctx, getState());
enterRule(_localctx, 28, RULE_justNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(274);
just();
setState(276);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(275);
oname();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AtomContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public SuffixContext suffix() {
return getRuleContext(SuffixContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAtom(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 30, RULE_atom);
try {
enterOuterAlt(_localctx, 1);
{
setState(278);
attributes();
setState(279);
suffix();
setState(280);
type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FormationContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public InnersOrEolContext innersOrEol() {
return getRuleContext(InnersOrEolContext.class,0);
}
public FormationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterFormation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitFormation(this);
}
}
public final FormationContext formation() throws RecognitionException {
FormationContext _localctx = new FormationContext(_ctx, getState());
enterRule(_localctx, 32, RULE_formation);
try {
enterOuterAlt(_localctx, 1);
{
setState(282);
attributes();
setState(283);
oname();
setState(284);
innersOrEol();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InnersOrEolContext extends ParserRuleContext {
public InnersContext inners() {
return getRuleContext(InnersContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public InnersOrEolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_innersOrEol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterInnersOrEol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitInnersOrEol(this);
}
}
public final InnersOrEolContext innersOrEol() throws RecognitionException {
InnersOrEolContext _localctx = new InnersOrEolContext(_ctx, getState());
enterRule(_localctx, 34, RULE_innersOrEol);
try {
setState(288);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(286);
inners();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(287);
match(EOL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InnersContext extends ParserRuleContext {
public List EOL() { return getTokens(EoParser.EOL); }
public TerminalNode EOL(int i) {
return getToken(EoParser.EOL, i);
}
public TerminalNode TAB() { return getToken(EoParser.TAB, 0); }
public TerminalNode UNTAB() { return getToken(EoParser.UNTAB, 0); }
public List slave() {
return getRuleContexts(SlaveContext.class);
}
public SlaveContext slave(int i) {
return getRuleContext(SlaveContext.class,i);
}
public List subMaster() {
return getRuleContexts(SubMasterContext.class);
}
public SubMasterContext subMaster(int i) {
return getRuleContext(SubMasterContext.class,i);
}
public InnersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inners; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterInners(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitInners(this);
}
}
public final InnersContext inners() throws RecognitionException {
InnersContext _localctx = new InnersContext(_ctx, getState());
enterRule(_localctx, 36, RULE_inners);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(290);
match(EOL);
setState(291);
match(TAB);
setState(294);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(292);
slave();
}
break;
case 2:
{
setState(293);
subMaster();
}
break;
}
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 6429148218L) != 0)) {
{
setState(301);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(296);
slave();
}
break;
case 2:
{
setState(298);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EOL) {
{
setState(297);
match(EOL);
}
}
setState(300);
subMaster();
}
break;
}
}
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(306);
match(UNTAB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttributesContext extends ParserRuleContext {
public TerminalNode LSQ() { return getToken(EoParser.LSQ, 0); }
public TerminalNode RSQ() { return getToken(EoParser.RSQ, 0); }
public List attribute() {
return getRuleContexts(AttributeContext.class);
}
public AttributeContext attribute(int i) {
return getRuleContext(AttributeContext.class,i);
}
public List SPACE() { return getTokens(EoParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(EoParser.SPACE, i);
}
public AttributesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAttributes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAttributes(this);
}
}
public final AttributesContext attributes() throws RecognitionException {
AttributesContext _localctx = new AttributesContext(_ctx, getState());
enterRule(_localctx, 38, RULE_attributes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(308);
match(LSQ);
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(309);
attribute();
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==SPACE) {
{
{
setState(310);
match(SPACE);
setState(311);
attribute();
}
}
setState(316);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(319);
match(RSQ);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttributeContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public AttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAttribute(this);
}
}
public final AttributeContext attribute() throws RecognitionException {
AttributeContext _localctx = new AttributeContext(_ctx, getState());
enterRule(_localctx, 40, RULE_attribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(321);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeContext extends ParserRuleContext {
public TerminalNode SPACE() { return getToken(EoParser.SPACE, 0); }
public TerminalNode SLASH() { return getToken(EoParser.SLASH, 0); }
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public TerminalNode QUESTION() { return getToken(EoParser.QUESTION, 0); }
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitType(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 42, RULE_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(323);
match(SPACE);
setState(324);
match(SLASH);
setState(325);
_la = _input.LA(1);
if ( !(_la==QUESTION || _la==NAME) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ApplicationContext extends ParserRuleContext {
public HapplicationExtendedContext happlicationExtended() {
return getRuleContext(HapplicationExtendedContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationContext vapplication() {
return getRuleContext(VapplicationContext.class,0);
}
public ApplicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_application; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterApplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitApplication(this);
}
}
public final ApplicationContext application() throws RecognitionException {
ApplicationContext _localctx = new ApplicationContext(_ctx, getState());
enterRule(_localctx, 44, RULE_application);
int _la;
try {
setState(334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(327);
happlicationExtended();
setState(329);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(328);
oname();
}
}
setState(331);
match(EOL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(333);
vapplication();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationContext extends ParserRuleContext {
public HapplicationHeadContext happlicationHead() {
return getRuleContext(HapplicationHeadContext.class,0);
}
public HapplicationTailContext happlicationTail() {
return getRuleContext(HapplicationTailContext.class,0);
}
public HapplicationReversedContext happlicationReversed() {
return getRuleContext(HapplicationReversedContext.class,0);
}
public HapplicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlication; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplication(this);
}
}
public final HapplicationContext happlication() throws RecognitionException {
HapplicationContext _localctx = new HapplicationContext(_ctx, getState());
enterRule(_localctx, 46, RULE_happlication);
try {
setState(340);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(336);
happlicationHead();
setState(337);
happlicationTail();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(339);
happlicationReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationExtendedContext extends ParserRuleContext {
public HapplicationHeadExtendedContext happlicationHeadExtended() {
return getRuleContext(HapplicationHeadExtendedContext.class,0);
}
public HapplicationTailContext happlicationTail() {
return getRuleContext(HapplicationTailContext.class,0);
}
public HapplicationReversedContext happlicationReversed() {
return getRuleContext(HapplicationReversedContext.class,0);
}
public HapplicationExtendedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationExtended; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationExtended(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationExtended(this);
}
}
public final HapplicationExtendedContext happlicationExtended() throws RecognitionException {
HapplicationExtendedContext _localctx = new HapplicationExtendedContext(_ctx, getState());
enterRule(_localctx, 48, RULE_happlicationExtended);
try {
setState(346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(342);
happlicationHeadExtended();
setState(343);
happlicationTail();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(345);
happlicationReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationReversedContext extends ParserRuleContext {
public ReversedContext reversed() {
return getRuleContext(ReversedContext.class,0);
}
public HapplicationTailReversedContext happlicationTailReversed() {
return getRuleContext(HapplicationTailReversedContext.class,0);
}
public HapplicationReversedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationReversed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationReversed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationReversed(this);
}
}
public final HapplicationReversedContext happlicationReversed() throws RecognitionException {
HapplicationReversedContext _localctx = new HapplicationReversedContext(_ctx, getState());
enterRule(_localctx, 50, RULE_happlicationReversed);
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
reversed();
setState(349);
happlicationTailReversed();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationHeadContext extends ParserRuleContext {
public HmethodContext hmethod() {
return getRuleContext(HmethodContext.class,0);
}
public ApplicableContext applicable() {
return getRuleContext(ApplicableContext.class,0);
}
public HapplicationHeadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationHead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationHead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationHead(this);
}
}
public final HapplicationHeadContext happlicationHead() throws RecognitionException {
HapplicationHeadContext _localctx = new HapplicationHeadContext(_ctx, getState());
enterRule(_localctx, 52, RULE_happlicationHead);
try {
setState(353);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(351);
hmethod();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(352);
applicable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationHeadExtendedContext extends ParserRuleContext {
public VmethodContext vmethod() {
return getRuleContext(VmethodContext.class,0);
}
public HmethodExtendedContext hmethodExtended() {
return getRuleContext(HmethodExtendedContext.class,0);
}
public ApplicableContext applicable() {
return getRuleContext(ApplicableContext.class,0);
}
public HapplicationHeadExtendedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationHeadExtended; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationHeadExtended(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationHeadExtended(this);
}
}
public final HapplicationHeadExtendedContext happlicationHeadExtended() throws RecognitionException {
HapplicationHeadExtendedContext _localctx = new HapplicationHeadExtendedContext(_ctx, getState());
enterRule(_localctx, 54, RULE_happlicationHeadExtended);
try {
setState(358);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(355);
vmethod();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(356);
hmethodExtended();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(357);
applicable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ApplicableContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(EoParser.STAR, 0); }
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public TerminalNode PHI() { return getToken(EoParser.PHI, 0); }
public ApplicableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_applicable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterApplicable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitApplicable(this);
}
}
public final ApplicableContext applicable() throws RecognitionException {
ApplicableContext _localctx = new ApplicableContext(_ctx, getState());
enterRule(_localctx, 56, RULE_applicable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1074790432L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationTailContext extends ParserRuleContext {
public List SPACE() { return getTokens(EoParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(EoParser.SPACE, i);
}
public List happlicationArg() {
return getRuleContexts(HapplicationArgContext.class);
}
public HapplicationArgContext happlicationArg(int i) {
return getRuleContext(HapplicationArgContext.class,i);
}
public List as() {
return getRuleContexts(AsContext.class);
}
public AsContext as(int i) {
return getRuleContext(AsContext.class,i);
}
public HapplicationTailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationTail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationTail(this);
}
}
public final HapplicationTailContext happlicationTail() throws RecognitionException {
HapplicationTailContext _localctx = new HapplicationTailContext(_ctx, getState());
enterRule(_localctx, 58, RULE_happlicationTail);
try {
int _alt;
setState(376);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(366);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(362);
match(SPACE);
setState(363);
happlicationArg();
setState(364);
as();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(368);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(372);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(370);
match(SPACE);
setState(371);
happlicationArg();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(374);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationTailReversedContext extends ParserRuleContext {
public TerminalNode SPACE() { return getToken(EoParser.SPACE, 0); }
public HapplicationTailReversedFirstContext happlicationTailReversedFirst() {
return getRuleContext(HapplicationTailReversedFirstContext.class,0);
}
public HapplicationTailContext happlicationTail() {
return getRuleContext(HapplicationTailContext.class,0);
}
public HapplicationTailReversedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationTailReversed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationTailReversed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationTailReversed(this);
}
}
public final HapplicationTailReversedContext happlicationTailReversed() throws RecognitionException {
HapplicationTailReversedContext _localctx = new HapplicationTailReversedContext(_ctx, getState());
enterRule(_localctx, 60, RULE_happlicationTailReversed);
try {
enterOuterAlt(_localctx, 1);
{
setState(378);
match(SPACE);
setState(379);
happlicationTailReversedFirst();
setState(381);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(380);
happlicationTail();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationTailReversedFirstContext extends ParserRuleContext {
public HapplicationArgContext happlicationArg() {
return getRuleContext(HapplicationArgContext.class,0);
}
public HapplicationTailReversedFirstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationTailReversedFirst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationTailReversedFirst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationTailReversedFirst(this);
}
}
public final HapplicationTailReversedFirstContext happlicationTailReversedFirst() throws RecognitionException {
HapplicationTailReversedFirstContext _localctx = new HapplicationTailReversedFirstContext(_ctx, getState());
enterRule(_localctx, 62, RULE_happlicationTailReversedFirst);
try {
enterOuterAlt(_localctx, 1);
{
setState(383);
happlicationArg();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HapplicationArgContext extends ParserRuleContext {
public BeginnerOrFinisherContext beginnerOrFinisher() {
return getRuleContext(BeginnerOrFinisherContext.class,0);
}
public HmethodContext hmethod() {
return getRuleContext(HmethodContext.class,0);
}
public ScopeContext scope() {
return getRuleContext(ScopeContext.class,0);
}
public HapplicationArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_happlicationArg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHapplicationArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHapplicationArg(this);
}
}
public final HapplicationArgContext happlicationArg() throws RecognitionException {
HapplicationArgContext _localctx = new HapplicationArgContext(_ctx, getState());
enterRule(_localctx, 64, RULE_happlicationArg);
try {
setState(388);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(385);
beginnerOrFinisher();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(386);
hmethod();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(387);
scope();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationContext extends ParserRuleContext {
public VapplicationHeadNamedContext vapplicationHeadNamed() {
return getRuleContext(VapplicationHeadNamedContext.class,0);
}
public VapplicationArgsContext vapplicationArgs() {
return getRuleContext(VapplicationArgsContext.class,0);
}
public ReversedContext reversed() {
return getRuleContext(ReversedContext.class,0);
}
public VapplicationArgsReversedContext vapplicationArgsReversed() {
return getRuleContext(VapplicationArgsReversedContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplication; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplication(this);
}
}
public final VapplicationContext vapplication() throws RecognitionException {
VapplicationContext _localctx = new VapplicationContext(_ctx, getState());
enterRule(_localctx, 66, RULE_vapplication);
int _la;
try {
setState(399);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(390);
vapplicationHeadNamed();
setState(391);
vapplicationArgs();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(393);
reversed();
setState(395);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(394);
oname();
}
}
setState(397);
vapplicationArgsReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationHeadContext extends ParserRuleContext {
public ApplicableContext applicable() {
return getRuleContext(ApplicableContext.class,0);
}
public HmethodOptionalContext hmethodOptional() {
return getRuleContext(HmethodOptionalContext.class,0);
}
public VmethodOptionalContext vmethodOptional() {
return getRuleContext(VmethodOptionalContext.class,0);
}
public VersionedContext versioned() {
return getRuleContext(VersionedContext.class,0);
}
public VapplicationHeadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationHead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationHead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationHead(this);
}
}
public final VapplicationHeadContext vapplicationHead() throws RecognitionException {
VapplicationHeadContext _localctx = new VapplicationHeadContext(_ctx, getState());
enterRule(_localctx, 68, RULE_vapplicationHead);
try {
setState(405);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(401);
applicable();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(402);
hmethodOptional();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(403);
vmethodOptional();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(404);
versioned();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationHeadNamedContext extends ParserRuleContext {
public VapplicationHeadContext vapplicationHead() {
return getRuleContext(VapplicationHeadContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationHeadNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationHeadNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationHeadNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationHeadNamed(this);
}
}
public final VapplicationHeadNamedContext vapplicationHeadNamed() throws RecognitionException {
VapplicationHeadNamedContext _localctx = new VapplicationHeadNamedContext(_ctx, getState());
enterRule(_localctx, 70, RULE_vapplicationHeadNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(407);
vapplicationHead();
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(408);
oname();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationHeadAsContext extends ParserRuleContext {
public VapplicationHeadContext vapplicationHead() {
return getRuleContext(VapplicationHeadContext.class,0);
}
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public VapplicationHeadAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationHeadAs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationHeadAs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationHeadAs(this);
}
}
public final VapplicationHeadAsContext vapplicationHeadAs() throws RecognitionException {
VapplicationHeadAsContext _localctx = new VapplicationHeadAsContext(_ctx, getState());
enterRule(_localctx, 72, RULE_vapplicationHeadAs);
try {
enterOuterAlt(_localctx, 1);
{
setState(411);
vapplicationHead();
setState(412);
as();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgsContext extends ParserRuleContext {
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public TerminalNode TAB() { return getToken(EoParser.TAB, 0); }
public VapplicationArgsSpecificContext vapplicationArgsSpecific() {
return getRuleContext(VapplicationArgsSpecificContext.class,0);
}
public TerminalNode UNTAB() { return getToken(EoParser.UNTAB, 0); }
public VapplicationArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgs(this);
}
}
public final VapplicationArgsContext vapplicationArgs() throws RecognitionException {
VapplicationArgsContext _localctx = new VapplicationArgsContext(_ctx, getState());
enterRule(_localctx, 74, RULE_vapplicationArgs);
try {
enterOuterAlt(_localctx, 1);
{
setState(414);
match(EOL);
setState(415);
match(TAB);
setState(416);
vapplicationArgsSpecific();
setState(417);
match(UNTAB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgsReversedContext extends ParserRuleContext {
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public TerminalNode TAB() { return getToken(EoParser.TAB, 0); }
public VapplicationArgUnboundContext vapplicationArgUnbound() {
return getRuleContext(VapplicationArgUnboundContext.class,0);
}
public TerminalNode UNTAB() { return getToken(EoParser.UNTAB, 0); }
public VapplicationArgsSpecificContext vapplicationArgsSpecific() {
return getRuleContext(VapplicationArgsSpecificContext.class,0);
}
public VapplicationArgsReversedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgsReversed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgsReversed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgsReversed(this);
}
}
public final VapplicationArgsReversedContext vapplicationArgsReversed() throws RecognitionException {
VapplicationArgsReversedContext _localctx = new VapplicationArgsReversedContext(_ctx, getState());
enterRule(_localctx, 76, RULE_vapplicationArgsReversed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
match(EOL);
setState(420);
match(TAB);
setState(421);
vapplicationArgUnbound();
setState(423);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 6412371002L) != 0)) {
{
setState(422);
vapplicationArgsSpecific();
}
}
setState(425);
match(UNTAB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgsSpecificContext extends ParserRuleContext {
public List vapplicationArgBound() {
return getRuleContexts(VapplicationArgBoundContext.class);
}
public VapplicationArgBoundContext vapplicationArgBound(int i) {
return getRuleContext(VapplicationArgBoundContext.class,i);
}
public List vapplicationArgUnbound() {
return getRuleContexts(VapplicationArgUnboundContext.class);
}
public VapplicationArgUnboundContext vapplicationArgUnbound(int i) {
return getRuleContext(VapplicationArgUnboundContext.class,i);
}
public VapplicationArgsSpecificContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgsSpecific; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgsSpecific(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgsSpecific(this);
}
}
public final VapplicationArgsSpecificContext vapplicationArgsSpecific() throws RecognitionException {
VapplicationArgsSpecificContext _localctx = new VapplicationArgsSpecificContext(_ctx, getState());
enterRule(_localctx, 78, RULE_vapplicationArgsSpecific);
int _la;
try {
setState(437);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(428);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(427);
vapplicationArgBound();
}
}
setState(430);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 6412371002L) != 0) );
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(433);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(432);
vapplicationArgUnbound();
}
}
setState(435);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 6412371002L) != 0) );
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgBoundContext extends ParserRuleContext {
public VapplicationArgBoundCurrentContext vapplicationArgBoundCurrent() {
return getRuleContext(VapplicationArgBoundCurrentContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public VapplicationArgBoundNextContext vapplicationArgBoundNext() {
return getRuleContext(VapplicationArgBoundNextContext.class,0);
}
public VapplicationArgBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgBound(this);
}
}
public final VapplicationArgBoundContext vapplicationArgBound() throws RecognitionException {
VapplicationArgBoundContext _localctx = new VapplicationArgBoundContext(_ctx, getState());
enterRule(_localctx, 80, RULE_vapplicationArgBound);
try {
setState(443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(439);
vapplicationArgBoundCurrent();
setState(440);
match(EOL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(442);
vapplicationArgBoundNext();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgBoundCurrentContext extends ParserRuleContext {
public VapplicationArgHapplicationBoundContext vapplicationArgHapplicationBound() {
return getRuleContext(VapplicationArgHapplicationBoundContext.class,0);
}
public VapplicationArgHanonymBoundContext vapplicationArgHanonymBound() {
return getRuleContext(VapplicationArgHanonymBoundContext.class,0);
}
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public JustContext just() {
return getRuleContext(JustContext.class,0);
}
public MethodContext method() {
return getRuleContext(MethodContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationArgBoundCurrentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgBoundCurrent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgBoundCurrent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgBoundCurrent(this);
}
}
public final VapplicationArgBoundCurrentContext vapplicationArgBoundCurrent() throws RecognitionException {
VapplicationArgBoundCurrentContext _localctx = new VapplicationArgBoundCurrentContext(_ctx, getState());
enterRule(_localctx, 82, RULE_vapplicationArgBoundCurrent);
int _la;
try {
setState(455);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(445);
vapplicationArgHapplicationBound();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(446);
vapplicationArgHanonymBound();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(447);
just();
}
break;
case 2:
{
setState(448);
method();
}
break;
}
setState(451);
as();
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(452);
oname();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgBoundNextContext extends ParserRuleContext {
public VapplicationArgVanonymBoundContext vapplicationArgVanonymBound() {
return getRuleContext(VapplicationArgVanonymBoundContext.class,0);
}
public VapplicationHeadAsContext vapplicationHeadAs() {
return getRuleContext(VapplicationHeadAsContext.class,0);
}
public VapplicationArgsContext vapplicationArgs() {
return getRuleContext(VapplicationArgsContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public ReversedContext reversed() {
return getRuleContext(ReversedContext.class,0);
}
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public VapplicationArgsReversedContext vapplicationArgsReversed() {
return getRuleContext(VapplicationArgsReversedContext.class,0);
}
public VapplicationArgBoundNextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgBoundNext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgBoundNext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgBoundNext(this);
}
}
public final VapplicationArgBoundNextContext vapplicationArgBoundNext() throws RecognitionException {
VapplicationArgBoundNextContext _localctx = new VapplicationArgBoundNextContext(_ctx, getState());
enterRule(_localctx, 84, RULE_vapplicationArgBoundNext);
int _la;
try {
setState(471);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(457);
vapplicationArgVanonymBound();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(458);
vapplicationHeadAs();
setState(460);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(459);
oname();
}
}
setState(462);
vapplicationArgs();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(464);
reversed();
setState(465);
as();
setState(467);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(466);
oname();
}
}
setState(469);
vapplicationArgsReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgUnboundContext extends ParserRuleContext {
public VapplicationArgUnboundCurrentContext vapplicationArgUnboundCurrent() {
return getRuleContext(VapplicationArgUnboundCurrentContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public VapplicationArgUnboundNextContext vapplicationArgUnboundNext() {
return getRuleContext(VapplicationArgUnboundNextContext.class,0);
}
public VapplicationArgUnboundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgUnbound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgUnbound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgUnbound(this);
}
}
public final VapplicationArgUnboundContext vapplicationArgUnbound() throws RecognitionException {
VapplicationArgUnboundContext _localctx = new VapplicationArgUnboundContext(_ctx, getState());
enterRule(_localctx, 86, RULE_vapplicationArgUnbound);
try {
setState(477);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(473);
vapplicationArgUnboundCurrent();
setState(474);
match(EOL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(476);
vapplicationArgUnboundNext();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgUnboundCurrentContext extends ParserRuleContext {
public VapplicationArgHapplicationUnboundContext vapplicationArgHapplicationUnbound() {
return getRuleContext(VapplicationArgHapplicationUnboundContext.class,0);
}
public VapplicationArgHanonymUnboundContext vapplicationArgHanonymUnbound() {
return getRuleContext(VapplicationArgHanonymUnboundContext.class,0);
}
public JustNamedContext justNamed() {
return getRuleContext(JustNamedContext.class,0);
}
public MethodNamedContext methodNamed() {
return getRuleContext(MethodNamedContext.class,0);
}
public VapplicationArgUnboundCurrentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgUnboundCurrent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgUnboundCurrent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgUnboundCurrent(this);
}
}
public final VapplicationArgUnboundCurrentContext vapplicationArgUnboundCurrent() throws RecognitionException {
VapplicationArgUnboundCurrentContext _localctx = new VapplicationArgUnboundCurrentContext(_ctx, getState());
enterRule(_localctx, 88, RULE_vapplicationArgUnboundCurrent);
try {
setState(483);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(479);
vapplicationArgHapplicationUnbound();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(480);
vapplicationArgHanonymUnbound();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(481);
justNamed();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(482);
methodNamed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgUnboundNextContext extends ParserRuleContext {
public FormationNamedOrNamelessContext formationNamedOrNameless() {
return getRuleContext(FormationNamedOrNamelessContext.class,0);
}
public VapplicationHeadNamedContext vapplicationHeadNamed() {
return getRuleContext(VapplicationHeadNamedContext.class,0);
}
public VapplicationArgsContext vapplicationArgs() {
return getRuleContext(VapplicationArgsContext.class,0);
}
public ReversedContext reversed() {
return getRuleContext(ReversedContext.class,0);
}
public VapplicationArgsReversedContext vapplicationArgsReversed() {
return getRuleContext(VapplicationArgsReversedContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationArgUnboundNextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgUnboundNext; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgUnboundNext(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgUnboundNext(this);
}
}
public final VapplicationArgUnboundNextContext vapplicationArgUnboundNext() throws RecognitionException {
VapplicationArgUnboundNextContext _localctx = new VapplicationArgUnboundNextContext(_ctx, getState());
enterRule(_localctx, 90, RULE_vapplicationArgUnboundNext);
int _la;
try {
setState(495);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(485);
formationNamedOrNameless();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(486);
vapplicationHeadNamed();
setState(487);
vapplicationArgs();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(489);
reversed();
setState(491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(490);
oname();
}
}
setState(493);
vapplicationArgsReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgHapplicationBoundContext extends ParserRuleContext {
public TerminalNode LB() { return getToken(EoParser.LB, 0); }
public HapplicationExtendedContext happlicationExtended() {
return getRuleContext(HapplicationExtendedContext.class,0);
}
public TerminalNode RB() { return getToken(EoParser.RB, 0); }
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationArgHapplicationBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgHapplicationBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgHapplicationBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgHapplicationBound(this);
}
}
public final VapplicationArgHapplicationBoundContext vapplicationArgHapplicationBound() throws RecognitionException {
VapplicationArgHapplicationBoundContext _localctx = new VapplicationArgHapplicationBoundContext(_ctx, getState());
enterRule(_localctx, 92, RULE_vapplicationArgHapplicationBound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(497);
match(LB);
setState(498);
happlicationExtended();
setState(499);
match(RB);
setState(500);
as();
setState(502);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(501);
oname();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgHapplicationUnboundContext extends ParserRuleContext {
public HapplicationExtendedContext happlicationExtended() {
return getRuleContext(HapplicationExtendedContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public VapplicationArgHapplicationUnboundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgHapplicationUnbound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgHapplicationUnbound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgHapplicationUnbound(this);
}
}
public final VapplicationArgHapplicationUnboundContext vapplicationArgHapplicationUnbound() throws RecognitionException {
VapplicationArgHapplicationUnboundContext _localctx = new VapplicationArgHapplicationUnboundContext(_ctx, getState());
enterRule(_localctx, 94, RULE_vapplicationArgHapplicationUnbound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(504);
happlicationExtended();
setState(506);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(505);
oname();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FormationNamelessContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public InnersOrEolContext innersOrEol() {
return getRuleContext(InnersOrEolContext.class,0);
}
public AnameContext aname() {
return getRuleContext(AnameContext.class,0);
}
public FormationNamelessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formationNameless; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterFormationNameless(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitFormationNameless(this);
}
}
public final FormationNamelessContext formationNameless() throws RecognitionException {
FormationNamelessContext _localctx = new FormationNamelessContext(_ctx, getState());
enterRule(_localctx, 96, RULE_formationNameless);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(508);
attributes();
setState(510);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(509);
aname();
}
}
setState(512);
innersOrEol();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FormationNamedOrNamelessContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public FormationContext formation() {
return getRuleContext(FormationContext.class,0);
}
public FormationNamelessContext formationNameless() {
return getRuleContext(FormationNamelessContext.class,0);
}
public FormationNamedOrNamelessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formationNamedOrNameless; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterFormationNamedOrNameless(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitFormationNamedOrNameless(this);
}
}
public final FormationNamedOrNamelessContext formationNamedOrNameless() throws RecognitionException {
FormationNamedOrNamelessContext _localctx = new FormationNamedOrNamelessContext(_ctx, getState());
enterRule(_localctx, 98, RULE_formationNamedOrNameless);
try {
setState(518);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(514);
commentOptional();
setState(515);
formation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(517);
formationNameless();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgVanonymBoundContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public AttributesAsContext attributesAs() {
return getRuleContext(AttributesAsContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public InnersOrEolContext innersOrEol() {
return getRuleContext(InnersOrEolContext.class,0);
}
public AnameContext aname() {
return getRuleContext(AnameContext.class,0);
}
public VapplicationArgVanonymBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgVanonymBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgVanonymBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgVanonymBound(this);
}
}
public final VapplicationArgVanonymBoundContext vapplicationArgVanonymBound() throws RecognitionException {
VapplicationArgVanonymBoundContext _localctx = new VapplicationArgVanonymBoundContext(_ctx, getState());
enterRule(_localctx, 100, RULE_vapplicationArgVanonymBound);
int _la;
try {
setState(531);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(520);
commentOptional();
setState(521);
attributesAs();
setState(522);
oname();
setState(523);
innersOrEol();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(525);
attributesAs();
setState(527);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(526);
aname();
}
}
setState(529);
innersOrEol();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttributesAsContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public AttributesAsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributesAs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAttributesAs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAttributesAs(this);
}
}
public final AttributesAsContext attributesAs() throws RecognitionException {
AttributesAsContext _localctx = new AttributesAsContext(_ctx, getState());
enterRule(_localctx, 102, RULE_attributesAs);
try {
enterOuterAlt(_localctx, 1);
{
setState(533);
attributes();
setState(534);
as();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgHanonymBoundBodyContext extends ParserRuleContext {
public TerminalNode LB() { return getToken(EoParser.LB, 0); }
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public TerminalNode RB() { return getToken(EoParser.RB, 0); }
public AsContext as() {
return getRuleContext(AsContext.class,0);
}
public VapplicationArgHanonymBoundBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgHanonymBoundBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgHanonymBoundBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgHanonymBoundBody(this);
}
}
public final VapplicationArgHanonymBoundBodyContext vapplicationArgHanonymBoundBody() throws RecognitionException {
VapplicationArgHanonymBoundBodyContext _localctx = new VapplicationArgHanonymBoundBodyContext(_ctx, getState());
enterRule(_localctx, 104, RULE_vapplicationArgHanonymBoundBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(536);
match(LB);
setState(537);
hanonym();
setState(538);
match(RB);
setState(539);
as();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgHanonymBoundContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public VapplicationArgHanonymBoundBodyContext vapplicationArgHanonymBoundBody() {
return getRuleContext(VapplicationArgHanonymBoundBodyContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public AnameContext aname() {
return getRuleContext(AnameContext.class,0);
}
public VapplicationArgHanonymBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgHanonymBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgHanonymBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgHanonymBound(this);
}
}
public final VapplicationArgHanonymBoundContext vapplicationArgHanonymBound() throws RecognitionException {
VapplicationArgHanonymBoundContext _localctx = new VapplicationArgHanonymBoundContext(_ctx, getState());
enterRule(_localctx, 106, RULE_vapplicationArgHanonymBound);
int _la;
try {
setState(549);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(541);
commentOptional();
setState(542);
vapplicationArgHanonymBoundBody();
setState(543);
oname();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(545);
vapplicationArgHanonymBoundBody();
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(546);
aname();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VapplicationArgHanonymUnboundContext extends ParserRuleContext {
public CommentOptionalContext commentOptional() {
return getRuleContext(CommentOptionalContext.class,0);
}
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public AnameContext aname() {
return getRuleContext(AnameContext.class,0);
}
public VapplicationArgHanonymUnboundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vapplicationArgHanonymUnbound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVapplicationArgHanonymUnbound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVapplicationArgHanonymUnbound(this);
}
}
public final VapplicationArgHanonymUnboundContext vapplicationArgHanonymUnbound() throws RecognitionException {
VapplicationArgHanonymUnboundContext _localctx = new VapplicationArgHanonymUnboundContext(_ctx, getState());
enterRule(_localctx, 108, RULE_vapplicationArgHanonymUnbound);
int _la;
try {
setState(559);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(551);
commentOptional();
setState(552);
hanonym();
setState(553);
oname();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(555);
hanonym();
setState(557);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(556);
aname();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HformationContext extends ParserRuleContext {
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public List hanonymInner() {
return getRuleContexts(HanonymInnerContext.class);
}
public HanonymInnerContext hanonymInner(int i) {
return getRuleContext(HanonymInnerContext.class,i);
}
public HformationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hformation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHformation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHformation(this);
}
}
public final HformationContext hformation() throws RecognitionException {
HformationContext _localctx = new HformationContext(_ctx, getState());
enterRule(_localctx, 110, RULE_hformation);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(561);
attributes();
setState(563);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(562);
hanonymInner();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(565);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HanonymContext extends ParserRuleContext {
public HformationContext hformation() {
return getRuleContext(HformationContext.class,0);
}
public OnlyphiContext onlyphi() {
return getRuleContext(OnlyphiContext.class,0);
}
public HanonymContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hanonym; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHanonym(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHanonym(this);
}
}
public final HanonymContext hanonym() throws RecognitionException {
HanonymContext _localctx = new HanonymContext(_ctx, getState());
enterRule(_localctx, 112, RULE_hanonym);
try {
setState(569);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(567);
hformation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(568);
onlyphi(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OnlyphiContext extends ParserRuleContext {
public OnlyphiTailContext onlyphiTail() {
return getRuleContext(OnlyphiTailContext.class,0);
}
public HmethodContext hmethod() {
return getRuleContext(HmethodContext.class,0);
}
public HapplicationContext happlication() {
return getRuleContext(HapplicationContext.class,0);
}
public HformationContext hformation() {
return getRuleContext(HformationContext.class,0);
}
public JustContext just() {
return getRuleContext(JustContext.class,0);
}
public OnlyphiContext onlyphi() {
return getRuleContext(OnlyphiContext.class,0);
}
public OnlyphiContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onlyphi; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterOnlyphi(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitOnlyphi(this);
}
}
public final OnlyphiContext onlyphi() throws RecognitionException {
return onlyphi(0);
}
private OnlyphiContext onlyphi(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
OnlyphiContext _localctx = new OnlyphiContext(_ctx, _parentState);
OnlyphiContext _prevctx = _localctx;
int _startState = 114;
enterRecursionRule(_localctx, 114, RULE_onlyphi, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(576);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(572);
hmethod();
}
break;
case 2:
{
setState(573);
happlication();
}
break;
case 3:
{
setState(574);
hformation();
}
break;
case 4:
{
setState(575);
just();
}
break;
}
setState(578);
onlyphiTail();
}
_ctx.stop = _input.LT(-1);
setState(584);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new OnlyphiContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_onlyphi);
setState(580);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(581);
onlyphiTail();
}
}
}
setState(586);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OnlyphiTailContext extends ParserRuleContext {
public SpacedArrowContext spacedArrow() {
return getRuleContext(SpacedArrowContext.class,0);
}
public AttributesContext attributes() {
return getRuleContext(AttributesContext.class,0);
}
public OnlyphiTailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_onlyphiTail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterOnlyphiTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitOnlyphiTail(this);
}
}
public final OnlyphiTailContext onlyphiTail() throws RecognitionException {
OnlyphiTailContext _localctx = new OnlyphiTailContext(_ctx, getState());
enterRule(_localctx, 116, RULE_onlyphiTail);
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
spacedArrow();
setState(588);
attributes();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HanonymInnerContext extends ParserRuleContext {
public TerminalNode SPACE() { return getToken(EoParser.SPACE, 0); }
public TerminalNode LB() { return getToken(EoParser.LB, 0); }
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public TerminalNode RB() { return getToken(EoParser.RB, 0); }
public HmethodContext hmethod() {
return getRuleContext(HmethodContext.class,0);
}
public HmethodVersionedContext hmethodVersioned() {
return getRuleContext(HmethodVersionedContext.class,0);
}
public HapplicationContext happlication() {
return getRuleContext(HapplicationContext.class,0);
}
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public JustContext just() {
return getRuleContext(JustContext.class,0);
}
public HanonymInnerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hanonymInner; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHanonymInner(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHanonymInner(this);
}
}
public final HanonymInnerContext hanonymInner() throws RecognitionException {
HanonymInnerContext _localctx = new HanonymInnerContext(_ctx, getState());
enterRule(_localctx, 118, RULE_hanonymInner);
try {
enterOuterAlt(_localctx, 1);
{
setState(590);
match(SPACE);
setState(591);
match(LB);
setState(597);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) {
case 1:
{
setState(592);
hmethod();
}
break;
case 2:
{
setState(593);
hmethodVersioned();
}
break;
case 3:
{
setState(594);
happlication();
}
break;
case 4:
{
setState(595);
hanonym();
}
break;
case 5:
{
setState(596);
just();
}
break;
}
setState(599);
oname();
setState(600);
match(RB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodContext extends ParserRuleContext {
public HmethodOptionalContext hmethodOptional() {
return getRuleContext(HmethodOptionalContext.class,0);
}
public VmethodOptionalContext vmethodOptional() {
return getRuleContext(VmethodOptionalContext.class,0);
}
public MethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_method; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMethod(this);
}
}
public final MethodContext method() throws RecognitionException {
MethodContext _localctx = new MethodContext(_ctx, getState());
enterRule(_localctx, 120, RULE_method);
try {
setState(604);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(602);
hmethodOptional();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(603);
vmethodOptional();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodNamedContext extends ParserRuleContext {
public MethodContext method() {
return getRuleContext(MethodContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public MethodNamedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodNamed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMethodNamed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMethodNamed(this);
}
}
public final MethodNamedContext methodNamed() throws RecognitionException {
MethodNamedContext _localctx = new MethodNamedContext(_ctx, getState());
enterRule(_localctx, 122, RULE_methodNamed);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(606);
method();
setState(608);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(607);
oname();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodContext extends ParserRuleContext {
public HmethodHeadContext hmethodHead() {
return getRuleContext(HmethodHeadContext.class,0);
}
public List methodTail() {
return getRuleContexts(MethodTailContext.class);
}
public MethodTailContext methodTail(int i) {
return getRuleContext(MethodTailContext.class,i);
}
public HmethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethod(this);
}
}
public final HmethodContext hmethod() throws RecognitionException {
HmethodContext _localctx = new HmethodContext(_ctx, getState());
enterRule(_localctx, 124, RULE_hmethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(610);
hmethodHead();
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(611);
methodTail();
}
}
setState(614);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DOT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodOptionalContext extends ParserRuleContext {
public HmethodExtendedContext hmethodExtended() {
return getRuleContext(HmethodExtendedContext.class,0);
}
public HmethodExtendedVersionedContext hmethodExtendedVersioned() {
return getRuleContext(HmethodExtendedVersionedContext.class,0);
}
public HmethodOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodOptional(this);
}
}
public final HmethodOptionalContext hmethodOptional() throws RecognitionException {
HmethodOptionalContext _localctx = new HmethodOptionalContext(_ctx, getState());
enterRule(_localctx, 126, RULE_hmethodOptional);
try {
setState(618);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(616);
hmethodExtended();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(617);
hmethodExtendedVersioned();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodExtendedContext extends ParserRuleContext {
public HmethodHeadExtendedContext hmethodHeadExtended() {
return getRuleContext(HmethodHeadExtendedContext.class,0);
}
public List methodTail() {
return getRuleContexts(MethodTailContext.class);
}
public MethodTailContext methodTail(int i) {
return getRuleContext(MethodTailContext.class,i);
}
public HmethodExtendedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodExtended; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodExtended(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodExtended(this);
}
}
public final HmethodExtendedContext hmethodExtended() throws RecognitionException {
HmethodExtendedContext _localctx = new HmethodExtendedContext(_ctx, getState());
enterRule(_localctx, 128, RULE_hmethodExtended);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(620);
hmethodHeadExtended();
setState(622);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(621);
methodTail();
}
}
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DOT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodVersionedContext extends ParserRuleContext {
public HmethodHeadContext hmethodHead() {
return getRuleContext(HmethodHeadContext.class,0);
}
public MethodTailVersionedContext methodTailVersioned() {
return getRuleContext(MethodTailVersionedContext.class,0);
}
public List methodTail() {
return getRuleContexts(MethodTailContext.class);
}
public MethodTailContext methodTail(int i) {
return getRuleContext(MethodTailContext.class,i);
}
public HmethodVersionedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodVersioned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodVersioned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodVersioned(this);
}
}
public final HmethodVersionedContext hmethodVersioned() throws RecognitionException {
HmethodVersionedContext _localctx = new HmethodVersionedContext(_ctx, getState());
enterRule(_localctx, 130, RULE_hmethodVersioned);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(626);
hmethodHead();
setState(630);
_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 ) {
{
{
setState(627);
methodTail();
}
}
}
setState(632);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
}
setState(633);
methodTailVersioned();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodExtendedVersionedContext extends ParserRuleContext {
public HmethodHeadExtendedContext hmethodHeadExtended() {
return getRuleContext(HmethodHeadExtendedContext.class,0);
}
public MethodTailVersionedContext methodTailVersioned() {
return getRuleContext(MethodTailVersionedContext.class,0);
}
public List methodTail() {
return getRuleContexts(MethodTailContext.class);
}
public MethodTailContext methodTail(int i) {
return getRuleContext(MethodTailContext.class,i);
}
public HmethodExtendedVersionedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodExtendedVersioned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodExtendedVersioned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodExtendedVersioned(this);
}
}
public final HmethodExtendedVersionedContext hmethodExtendedVersioned() throws RecognitionException {
HmethodExtendedVersionedContext _localctx = new HmethodExtendedVersionedContext(_ctx, getState());
enterRule(_localctx, 132, RULE_hmethodExtendedVersioned);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(635);
hmethodHeadExtended();
setState(639);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(636);
methodTail();
}
}
}
setState(641);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
}
setState(642);
methodTailVersioned();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodHeadContext extends ParserRuleContext {
public BeginnerOrFinisherContext beginnerOrFinisher() {
return getRuleContext(BeginnerOrFinisherContext.class,0);
}
public ScopeContext scope() {
return getRuleContext(ScopeContext.class,0);
}
public HmethodHeadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodHead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodHead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodHead(this);
}
}
public final HmethodHeadContext hmethodHead() throws RecognitionException {
HmethodHeadContext _localctx = new HmethodHeadContext(_ctx, getState());
enterRule(_localctx, 134, RULE_hmethodHead);
try {
setState(646);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROOT:
case HOME:
case STAR:
case XI:
case PHI:
case RHO:
case BYTES:
case STRING:
case INT:
case FLOAT:
case HEX:
case NAME:
case TEXT:
enterOuterAlt(_localctx, 1);
{
setState(644);
beginnerOrFinisher();
}
break;
case LB:
enterOuterAlt(_localctx, 2);
{
setState(645);
scope();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class HmethodHeadExtendedContext extends ParserRuleContext {
public BeginnerOrFinisherContext beginnerOrFinisher() {
return getRuleContext(BeginnerOrFinisherContext.class,0);
}
public ScopeContext scope() {
return getRuleContext(ScopeContext.class,0);
}
public HmethodHeadExtendedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hmethodHeadExtended; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterHmethodHeadExtended(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitHmethodHeadExtended(this);
}
}
public final HmethodHeadExtendedContext hmethodHeadExtended() throws RecognitionException {
HmethodHeadExtendedContext _localctx = new HmethodHeadExtendedContext(_ctx, getState());
enterRule(_localctx, 136, RULE_hmethodHeadExtended);
try {
setState(650);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROOT:
case HOME:
case STAR:
case XI:
case PHI:
case RHO:
case BYTES:
case STRING:
case INT:
case FLOAT:
case HEX:
case NAME:
case TEXT:
enterOuterAlt(_localctx, 1);
{
setState(648);
beginnerOrFinisher();
}
break;
case LB:
enterOuterAlt(_localctx, 2);
{
setState(649);
scope();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodContext extends ParserRuleContext {
public VmethodHeadContext vmethodHead() {
return getRuleContext(VmethodHeadContext.class,0);
}
public MethodTailContext methodTail() {
return getRuleContext(MethodTailContext.class,0);
}
public VmethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethod(this);
}
}
public final VmethodContext vmethod() throws RecognitionException {
VmethodContext _localctx = new VmethodContext(_ctx, getState());
enterRule(_localctx, 138, RULE_vmethod);
try {
enterOuterAlt(_localctx, 1);
{
setState(652);
vmethodHead(0);
setState(653);
methodTail();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodVersionedContext extends ParserRuleContext {
public VmethodHeadContext vmethodHead() {
return getRuleContext(VmethodHeadContext.class,0);
}
public MethodTailVersionedContext methodTailVersioned() {
return getRuleContext(MethodTailVersionedContext.class,0);
}
public VmethodVersionedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethodVersioned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethodVersioned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethodVersioned(this);
}
}
public final VmethodVersionedContext vmethodVersioned() throws RecognitionException {
VmethodVersionedContext _localctx = new VmethodVersionedContext(_ctx, getState());
enterRule(_localctx, 140, RULE_vmethodVersioned);
try {
enterOuterAlt(_localctx, 1);
{
setState(655);
vmethodHead(0);
setState(656);
methodTailVersioned();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodOptionalContext extends ParserRuleContext {
public VmethodContext vmethod() {
return getRuleContext(VmethodContext.class,0);
}
public VmethodVersionedContext vmethodVersioned() {
return getRuleContext(VmethodVersionedContext.class,0);
}
public VmethodOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethodOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethodOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethodOptional(this);
}
}
public final VmethodOptionalContext vmethodOptional() throws RecognitionException {
VmethodOptionalContext _localctx = new VmethodOptionalContext(_ctx, getState());
enterRule(_localctx, 142, RULE_vmethodOptional);
try {
setState(660);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(658);
vmethod();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(659);
vmethodVersioned();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodHeadContext extends ParserRuleContext {
public VmethodHeadVapplicationContext vmethodHeadVapplication() {
return getRuleContext(VmethodHeadVapplicationContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public JustNamedContext justNamed() {
return getRuleContext(JustNamedContext.class,0);
}
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public FormationNamedOrNamelessContext formationNamedOrNameless() {
return getRuleContext(FormationNamedOrNamelessContext.class,0);
}
public VmethodHeadContext vmethodHead() {
return getRuleContext(VmethodHeadContext.class,0);
}
public MethodTailOptionalContext methodTailOptional() {
return getRuleContext(MethodTailOptionalContext.class,0);
}
public VmethodHeadApplicationTailContext vmethodHeadApplicationTail() {
return getRuleContext(VmethodHeadApplicationTailContext.class,0);
}
public VmethodHeadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethodHead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethodHead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethodHead(this);
}
}
public final VmethodHeadContext vmethodHead() throws RecognitionException {
return vmethodHead(0);
}
private VmethodHeadContext vmethodHead(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
VmethodHeadContext _localctx = new VmethodHeadContext(_ctx, _parentState);
VmethodHeadContext _prevctx = _localctx;
int _startState = 144;
enterRecursionRule(_localctx, 144, RULE_vmethodHead, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(674);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
{
setState(663);
vmethodHeadVapplication();
}
break;
case 2:
{
setState(669);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
case 1:
{
setState(664);
justNamed();
}
break;
case 2:
{
setState(665);
hanonym();
setState(667);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(666);
oname();
}
}
}
break;
}
setState(671);
match(EOL);
}
break;
case 3:
{
setState(673);
formationNamedOrNameless();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(682);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new VmethodHeadContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_vmethodHead);
setState(676);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(677);
methodTailOptional();
setState(678);
vmethodHeadApplicationTail();
}
}
}
setState(684);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodTailOptionalContext extends ParserRuleContext {
public MethodTailContext methodTail() {
return getRuleContext(MethodTailContext.class,0);
}
public MethodTailVersionedContext methodTailVersioned() {
return getRuleContext(MethodTailVersionedContext.class,0);
}
public MethodTailOptionalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodTailOptional; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMethodTailOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMethodTailOptional(this);
}
}
public final MethodTailOptionalContext methodTailOptional() throws RecognitionException {
MethodTailOptionalContext _localctx = new MethodTailOptionalContext(_ctx, getState());
enterRule(_localctx, 146, RULE_methodTailOptional);
try {
setState(687);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(685);
methodTail();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(686);
methodTailVersioned();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodHeadApplicationTailContext extends ParserRuleContext {
public VapplicationArgsContext vapplicationArgs() {
return getRuleContext(VapplicationArgsContext.class,0);
}
public TerminalNode EOL() { return getToken(EoParser.EOL, 0); }
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public HapplicationTailContext happlicationTail() {
return getRuleContext(HapplicationTailContext.class,0);
}
public VmethodHeadApplicationTailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethodHeadApplicationTail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethodHeadApplicationTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethodHeadApplicationTail(this);
}
}
public final VmethodHeadApplicationTailContext vmethodHeadApplicationTail() throws RecognitionException {
VmethodHeadApplicationTailContext _localctx = new VmethodHeadApplicationTailContext(_ctx, getState());
enterRule(_localctx, 148, RULE_vmethodHeadApplicationTail);
int _la;
try {
setState(702);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(690);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(689);
oname();
}
}
setState(694);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
{
setState(692);
vapplicationArgs();
}
break;
case 2:
{
setState(693);
match(EOL);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(696);
happlicationTail();
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(697);
oname();
}
}
setState(700);
match(EOL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VmethodHeadVapplicationContext extends ParserRuleContext {
public VapplicationArgsContext vapplicationArgs() {
return getRuleContext(VapplicationArgsContext.class,0);
}
public ApplicableContext applicable() {
return getRuleContext(ApplicableContext.class,0);
}
public HmethodOptionalContext hmethodOptional() {
return getRuleContext(HmethodOptionalContext.class,0);
}
public VersionedContext versioned() {
return getRuleContext(VersionedContext.class,0);
}
public OnameContext oname() {
return getRuleContext(OnameContext.class,0);
}
public ReversedContext reversed() {
return getRuleContext(ReversedContext.class,0);
}
public VapplicationArgsReversedContext vapplicationArgsReversed() {
return getRuleContext(VapplicationArgsReversedContext.class,0);
}
public VmethodHeadVapplicationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vmethodHeadVapplication; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVmethodHeadVapplication(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVmethodHeadVapplication(this);
}
}
public final VmethodHeadVapplicationContext vmethodHeadVapplication() throws RecognitionException {
VmethodHeadVapplicationContext _localctx = new VmethodHeadVapplicationContext(_ctx, getState());
enterRule(_localctx, 150, RULE_vmethodHeadVapplication);
int _la;
try {
setState(720);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(707);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
case 1:
{
setState(704);
applicable();
}
break;
case 2:
{
setState(705);
hmethodOptional();
}
break;
case 3:
{
setState(706);
versioned();
}
break;
}
setState(710);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(709);
oname();
}
}
setState(712);
vapplicationArgs();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(714);
reversed();
setState(716);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SPACE) {
{
setState(715);
oname();
}
}
setState(718);
vapplicationArgsReversed();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodTailContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(EoParser.DOT, 0); }
public FinisherContext finisher() {
return getRuleContext(FinisherContext.class,0);
}
public MethodTailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodTail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMethodTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMethodTail(this);
}
}
public final MethodTailContext methodTail() throws RecognitionException {
MethodTailContext _localctx = new MethodTailContext(_ctx, getState());
enterRule(_localctx, 152, RULE_methodTail);
try {
enterOuterAlt(_localctx, 1);
{
setState(722);
match(DOT);
setState(723);
finisher();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodTailVersionedContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(EoParser.DOT, 0); }
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public MethodTailVersionedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodTailVersioned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterMethodTailVersioned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitMethodTailVersioned(this);
}
}
public final MethodTailVersionedContext methodTailVersioned() throws RecognitionException {
MethodTailVersionedContext _localctx = new MethodTailVersionedContext(_ctx, getState());
enterRule(_localctx, 154, RULE_methodTailVersioned);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(725);
match(DOT);
setState(726);
match(NAME);
setState(728);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BAR) {
{
setState(727);
version();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BeginnerContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(EoParser.STAR, 0); }
public TerminalNode ROOT() { return getToken(EoParser.ROOT, 0); }
public TerminalNode HOME() { return getToken(EoParser.HOME, 0); }
public TerminalNode XI() { return getToken(EoParser.XI, 0); }
public DataContext data() {
return getRuleContext(DataContext.class,0);
}
public BeginnerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_beginner; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterBeginner(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitBeginner(this);
}
}
public final BeginnerContext beginner() throws RecognitionException {
BeginnerContext _localctx = new BeginnerContext(_ctx, getState());
enterRule(_localctx, 156, RULE_beginner);
try {
setState(735);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
enterOuterAlt(_localctx, 1);
{
setState(730);
match(STAR);
}
break;
case ROOT:
enterOuterAlt(_localctx, 2);
{
setState(731);
match(ROOT);
}
break;
case HOME:
enterOuterAlt(_localctx, 3);
{
setState(732);
match(HOME);
}
break;
case XI:
enterOuterAlt(_localctx, 4);
{
setState(733);
match(XI);
}
break;
case BYTES:
case STRING:
case INT:
case FLOAT:
case HEX:
case TEXT:
enterOuterAlt(_localctx, 5);
{
setState(734);
data();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FinisherContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public TerminalNode PHI() { return getToken(EoParser.PHI, 0); }
public TerminalNode RHO() { return getToken(EoParser.RHO, 0); }
public FinisherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finisher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterFinisher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitFinisher(this);
}
}
public final FinisherContext finisher() throws RecognitionException {
FinisherContext _localctx = new FinisherContext(_ctx, getState());
enterRule(_localctx, 158, RULE_finisher);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(737);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1076887552L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BeginnerOrFinisherContext extends ParserRuleContext {
public BeginnerContext beginner() {
return getRuleContext(BeginnerContext.class,0);
}
public FinisherContext finisher() {
return getRuleContext(FinisherContext.class,0);
}
public BeginnerOrFinisherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_beginnerOrFinisher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterBeginnerOrFinisher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitBeginnerOrFinisher(this);
}
}
public final BeginnerOrFinisherContext beginnerOrFinisher() throws RecognitionException {
BeginnerOrFinisherContext _localctx = new BeginnerOrFinisherContext(_ctx, getState());
enterRule(_localctx, 160, RULE_beginnerOrFinisher);
try {
setState(741);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ROOT:
case HOME:
case STAR:
case XI:
case BYTES:
case STRING:
case INT:
case FLOAT:
case HEX:
case TEXT:
enterOuterAlt(_localctx, 1);
{
setState(739);
beginner();
}
break;
case PHI:
case RHO:
case NAME:
enterOuterAlt(_localctx, 2);
{
setState(740);
finisher();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VersionedContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public VersionContext version() {
return getRuleContext(VersionContext.class,0);
}
public VersionedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_versioned; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVersioned(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVersioned(this);
}
}
public final VersionedContext versioned() throws RecognitionException {
VersionedContext _localctx = new VersionedContext(_ctx, getState());
enterRule(_localctx, 162, RULE_versioned);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(743);
match(NAME);
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BAR) {
{
setState(744);
version();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReversedContext extends ParserRuleContext {
public FinisherContext finisher() {
return getRuleContext(FinisherContext.class,0);
}
public TerminalNode DOT() { return getToken(EoParser.DOT, 0); }
public ReversedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reversed; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterReversed(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitReversed(this);
}
}
public final ReversedContext reversed() throws RecognitionException {
ReversedContext _localctx = new ReversedContext(_ctx, getState());
enterRule(_localctx, 164, RULE_reversed);
try {
enterOuterAlt(_localctx, 1);
{
setState(747);
finisher();
setState(748);
match(DOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OnameContext extends ParserRuleContext {
public SuffixContext suffix() {
return getRuleContext(SuffixContext.class,0);
}
public TerminalNode CONST() { return getToken(EoParser.CONST, 0); }
public OnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_oname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterOname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitOname(this);
}
}
public final OnameContext oname() throws RecognitionException {
OnameContext _localctx = new OnameContext(_ctx, getState());
enterRule(_localctx, 166, RULE_oname);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(750);
suffix();
setState(752);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONST) {
{
setState(751);
match(CONST);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnameContext extends ParserRuleContext {
public TerminalNode SPACE() { return getToken(EoParser.SPACE, 0); }
public List ARROW() { return getTokens(EoParser.ARROW); }
public TerminalNode ARROW(int i) {
return getToken(EoParser.ARROW, i);
}
public AnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAname(this);
}
}
public final AnameContext aname() throws RecognitionException {
AnameContext _localctx = new AnameContext(_ctx, getState());
enterRule(_localctx, 168, RULE_aname);
try {
enterOuterAlt(_localctx, 1);
{
setState(754);
match(SPACE);
setState(755);
match(ARROW);
setState(756);
match(ARROW);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SuffixContext extends ParserRuleContext {
public SpacedArrowContext spacedArrow() {
return getRuleContext(SpacedArrowContext.class,0);
}
public TerminalNode PHI() { return getToken(EoParser.PHI, 0); }
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public SuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_suffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitSuffix(this);
}
}
public final SuffixContext suffix() throws RecognitionException {
SuffixContext _localctx = new SuffixContext(_ctx, getState());
enterRule(_localctx, 170, RULE_suffix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(758);
spacedArrow();
setState(759);
_la = _input.LA(1);
if ( !(_la==PHI || _la==NAME) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SpacedArrowContext extends ParserRuleContext {
public List SPACE() { return getTokens(EoParser.SPACE); }
public TerminalNode SPACE(int i) {
return getToken(EoParser.SPACE, i);
}
public TerminalNode ARROW() { return getToken(EoParser.ARROW, 0); }
public SpacedArrowContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_spacedArrow; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterSpacedArrow(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitSpacedArrow(this);
}
}
public final SpacedArrowContext spacedArrow() throws RecognitionException {
SpacedArrowContext _localctx = new SpacedArrowContext(_ctx, getState());
enterRule(_localctx, 172, RULE_spacedArrow);
try {
enterOuterAlt(_localctx, 1);
{
setState(761);
match(SPACE);
setState(762);
match(ARROW);
setState(763);
match(SPACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ScopeContext extends ParserRuleContext {
public TerminalNode LB() { return getToken(EoParser.LB, 0); }
public TerminalNode RB() { return getToken(EoParser.RB, 0); }
public HapplicationContext happlication() {
return getRuleContext(HapplicationContext.class,0);
}
public HanonymContext hanonym() {
return getRuleContext(HanonymContext.class,0);
}
public ScopeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scope; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterScope(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitScope(this);
}
}
public final ScopeContext scope() throws RecognitionException {
ScopeContext _localctx = new ScopeContext(_ctx, getState());
enterRule(_localctx, 174, RULE_scope);
try {
enterOuterAlt(_localctx, 1);
{
setState(765);
match(LB);
setState(768);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(766);
happlication();
}
break;
case 2:
{
setState(767);
hanonym();
}
break;
}
setState(770);
match(RB);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VersionContext extends ParserRuleContext {
public TerminalNode BAR() { return getToken(EoParser.BAR, 0); }
public TerminalNode VER() { return getToken(EoParser.VER, 0); }
public VersionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_version; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterVersion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitVersion(this);
}
}
public final VersionContext version() throws RecognitionException {
VersionContext _localctx = new VersionContext(_ctx, getState());
enterRule(_localctx, 176, RULE_version);
try {
enterOuterAlt(_localctx, 1);
{
setState(772);
match(BAR);
setState(773);
match(VER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AsContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(EoParser.COLON, 0); }
public TerminalNode NAME() { return getToken(EoParser.NAME, 0); }
public TerminalNode INT() { return getToken(EoParser.INT, 0); }
public AsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_as; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterAs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitAs(this);
}
}
public final AsContext as() throws RecognitionException {
AsContext _localctx = new AsContext(_ctx, getState());
enterRule(_localctx, 178, RULE_as);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(775);
match(COLON);
setState(776);
_la = _input.LA(1);
if ( !(_la==INT || _la==NAME) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DataContext extends ParserRuleContext {
public TerminalNode BYTES() { return getToken(EoParser.BYTES, 0); }
public TerminalNode TEXT() { return getToken(EoParser.TEXT, 0); }
public TerminalNode STRING() { return getToken(EoParser.STRING, 0); }
public TerminalNode INT() { return getToken(EoParser.INT, 0); }
public TerminalNode FLOAT() { return getToken(EoParser.FLOAT, 0); }
public TerminalNode HEX() { return getToken(EoParser.HEX, 0); }
public DataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_data; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).enterData(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof EoListener ) ((EoListener)listener).exitData(this);
}
}
public final DataContext data() throws RecognitionException {
DataContext _localctx = new DataContext(_ctx, getState());
enterRule(_localctx, 180, RULE_data);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(778);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 5335154688L) != 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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 57:
return onlyphi_sempred((OnlyphiContext)_localctx, predIndex);
case 72:
return vmethodHead_sempred((VmethodHeadContext)_localctx, predIndex);
}
return true;
}
private boolean onlyphi_sempred(OnlyphiContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 1);
}
return true;
}
private boolean vmethodHead_sempred(VmethodHeadContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\"\u030d\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
"2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+
"7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+
"<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+
"A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+
"F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+
"K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+
"P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+
"U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+
"Z\u0007Z\u0001\u0000\u0003\u0000\u00b8\b\u0000\u0001\u0000\u0003\u0000"+
"\u00bb\b\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+
"\u0001\u0001\u0001\u0002\u0001\u0002\u0005\u0002\u00c5\b\u0002\n\u0002"+
"\f\u0002\u00c8\t\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003"+
"\u0001\u0003\u0005\u0003\u00cf\b\u0003\n\u0003\f\u0003\u00d2\t\u0003\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0003\u0004\u00d9"+
"\b\u0004\u0005\u0004\u00db\b\u0004\n\u0004\f\u0004\u00de\t\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0005"+
"\u0006\u00e6\b\u0006\n\u0006\f\u0006\u00e9\t\u0006\u0001\u0007\u0004\u0007"+
"\u00ec\b\u0007\u000b\u0007\f\u0007\u00ed\u0001\b\u0001\b\u0003\b\u00f2"+
"\b\b\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u00f8\b\t\u0001\t\u0001\t"+
"\u0003\t\u00fc\b\t\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001"+
"\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0003\f\u0109\b\f\u0001"+
"\f\u0001\f\u0003\f\u010d\b\f\u0001\r\u0001\r\u0003\r\u0111\b\r\u0001\u000e"+
"\u0001\u000e\u0003\u000e\u0115\b\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011"+
"\u0001\u0011\u0003\u0011\u0121\b\u0011\u0001\u0012\u0001\u0012\u0001\u0012"+
"\u0001\u0012\u0003\u0012\u0127\b\u0012\u0001\u0012\u0001\u0012\u0003\u0012"+
"\u012b\b\u0012\u0001\u0012\u0005\u0012\u012e\b\u0012\n\u0012\f\u0012\u0131"+
"\t\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
"\u0013\u0005\u0013\u0139\b\u0013\n\u0013\f\u0013\u013c\t\u0013\u0003\u0013"+
"\u013e\b\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0015"+
"\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0003\u0016"+
"\u014a\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u014f\b"+
"\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0003\u0017\u0155"+
"\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u015b"+
"\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0003"+
"\u001a\u0162\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u0167"+
"\b\u001b\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+
"\u001d\u0004\u001d\u016f\b\u001d\u000b\u001d\f\u001d\u0170\u0001\u001d"+
"\u0001\u001d\u0004\u001d\u0175\b\u001d\u000b\u001d\f\u001d\u0176\u0003"+
"\u001d\u0179\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u017e"+
"\b\u001e\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0003 \u0185\b "+
"\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u018c\b!\u0001!\u0001!\u0003"+
"!\u0190\b!\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u0196\b\"\u0001#\u0001"+
"#\u0003#\u019a\b#\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001"+
"%\u0001&\u0001&\u0001&\u0001&\u0003&\u01a8\b&\u0001&\u0001&\u0001\'\u0004"+
"\'\u01ad\b\'\u000b\'\f\'\u01ae\u0001\'\u0004\'\u01b2\b\'\u000b\'\f\'\u01b3"+
"\u0003\'\u01b6\b\'\u0001(\u0001(\u0001(\u0001(\u0003(\u01bc\b(\u0001)"+
"\u0001)\u0001)\u0001)\u0003)\u01c2\b)\u0001)\u0001)\u0003)\u01c6\b)\u0003"+
")\u01c8\b)\u0001*\u0001*\u0001*\u0003*\u01cd\b*\u0001*\u0001*\u0001*\u0001"+
"*\u0001*\u0003*\u01d4\b*\u0001*\u0001*\u0003*\u01d8\b*\u0001+\u0001+\u0001"+
"+\u0001+\u0003+\u01de\b+\u0001,\u0001,\u0001,\u0001,\u0003,\u01e4\b,\u0001"+
"-\u0001-\u0001-\u0001-\u0001-\u0001-\u0003-\u01ec\b-\u0001-\u0001-\u0003"+
"-\u01f0\b-\u0001.\u0001.\u0001.\u0001.\u0001.\u0003.\u01f7\b.\u0001/\u0001"+
"/\u0003/\u01fb\b/\u00010\u00010\u00030\u01ff\b0\u00010\u00010\u00011\u0001"+
"1\u00011\u00011\u00031\u0207\b1\u00012\u00012\u00012\u00012\u00012\u0001"+
"2\u00012\u00032\u0210\b2\u00012\u00012\u00032\u0214\b2\u00013\u00013\u0001"+
"3\u00014\u00014\u00014\u00014\u00014\u00015\u00015\u00015\u00015\u0001"+
"5\u00015\u00035\u0224\b5\u00035\u0226\b5\u00016\u00016\u00016\u00016\u0001"+
"6\u00016\u00036\u022e\b6\u00036\u0230\b6\u00017\u00017\u00047\u0234\b"+
"7\u000b7\f7\u0235\u00018\u00018\u00038\u023a\b8\u00019\u00019\u00019\u0001"+
"9\u00019\u00039\u0241\b9\u00019\u00019\u00019\u00019\u00059\u0247\b9\n"+
"9\f9\u024a\t9\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0001;\u0001;"+
"\u0001;\u0001;\u0003;\u0256\b;\u0001;\u0001;\u0001;\u0001<\u0001<\u0003"+
"<\u025d\b<\u0001=\u0001=\u0003=\u0261\b=\u0001>\u0001>\u0004>\u0265\b"+
">\u000b>\f>\u0266\u0001?\u0001?\u0003?\u026b\b?\u0001@\u0001@\u0004@\u026f"+
"\b@\u000b@\f@\u0270\u0001A\u0001A\u0005A\u0275\bA\nA\fA\u0278\tA\u0001"+
"A\u0001A\u0001B\u0001B\u0005B\u027e\bB\nB\fB\u0281\tB\u0001B\u0001B\u0001"+
"C\u0001C\u0003C\u0287\bC\u0001D\u0001D\u0003D\u028b\bD\u0001E\u0001E\u0001"+
"E\u0001F\u0001F\u0001F\u0001G\u0001G\u0003G\u0295\bG\u0001H\u0001H\u0001"+
"H\u0001H\u0001H\u0003H\u029c\bH\u0003H\u029e\bH\u0001H\u0001H\u0001H\u0003"+
"H\u02a3\bH\u0001H\u0001H\u0001H\u0001H\u0005H\u02a9\bH\nH\fH\u02ac\tH"+
"\u0001I\u0001I\u0003I\u02b0\bI\u0001J\u0003J\u02b3\bJ\u0001J\u0001J\u0003"+
"J\u02b7\bJ\u0001J\u0001J\u0003J\u02bb\bJ\u0001J\u0001J\u0003J\u02bf\b"+
"J\u0001K\u0001K\u0001K\u0003K\u02c4\bK\u0001K\u0003K\u02c7\bK\u0001K\u0001"+
"K\u0001K\u0001K\u0003K\u02cd\bK\u0001K\u0001K\u0003K\u02d1\bK\u0001L\u0001"+
"L\u0001L\u0001M\u0001M\u0001M\u0003M\u02d9\bM\u0001N\u0001N\u0001N\u0001"+
"N\u0001N\u0003N\u02e0\bN\u0001O\u0001O\u0001P\u0001P\u0003P\u02e6\bP\u0001"+
"Q\u0001Q\u0003Q\u02ea\bQ\u0001R\u0001R\u0001R\u0001S\u0001S\u0003S\u02f1"+
"\bS\u0001T\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0001V\u0001V\u0001"+
"V\u0001V\u0001W\u0001W\u0001W\u0003W\u0301\bW\u0001W\u0001W\u0001X\u0001"+
"X\u0001X\u0001Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0000\u0002r\u0090"+
"[\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a"+
"\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082"+
"\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a"+
"\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2"+
"\u00b4\u0000\u0006\u0002\u0000\r\r\u001e\u001e\u0003\u0000\u0005\u0005"+
"\u0014\u0014\u001e\u001e\u0002\u0000\u0014\u0015\u001e\u001e\u0002\u0000"+
"\u0014\u0014\u001e\u001e\u0002\u0000\u001b\u001b\u001e\u001e\u0002\u0000"+
"\u0019\u001d \u0324\u0000\u00b7\u0001\u0000\u0000\u0000\u0002\u00bf\u0001"+
"\u0000\u0000\u0000\u0004\u00c6\u0001\u0000\u0000\u0000\u0006\u00d0\u0001"+
"\u0000\u0000\u0000\b\u00dc\u0001\u0000\u0000\u0000\n\u00e1\u0001\u0000"+
"\u0000\u0000\f\u00e7\u0001\u0000\u0000\u0000\u000e\u00eb\u0001\u0000\u0000"+
"\u0000\u0010\u00f1\u0001\u0000\u0000\u0000\u0012\u00f3\u0001\u0000\u0000"+
"\u0000\u0014\u00fd\u0001\u0000\u0000\u0000\u0016\u0100\u0001\u0000\u0000"+
"\u0000\u0018\u010c\u0001\u0000\u0000\u0000\u001a\u0110\u0001\u0000\u0000"+
"\u0000\u001c\u0112\u0001\u0000\u0000\u0000\u001e\u0116\u0001\u0000\u0000"+
"\u0000 \u011a\u0001\u0000\u0000\u0000\"\u0120\u0001\u0000\u0000\u0000"+
"$\u0122\u0001\u0000\u0000\u0000&\u0134\u0001\u0000\u0000\u0000(\u0141"+
"\u0001\u0000\u0000\u0000*\u0143\u0001\u0000\u0000\u0000,\u014e\u0001\u0000"+
"\u0000\u0000.\u0154\u0001\u0000\u0000\u00000\u015a\u0001\u0000\u0000\u0000"+
"2\u015c\u0001\u0000\u0000\u00004\u0161\u0001\u0000\u0000\u00006\u0166"+
"\u0001\u0000\u0000\u00008\u0168\u0001\u0000\u0000\u0000:\u0178\u0001\u0000"+
"\u0000\u0000<\u017a\u0001\u0000\u0000\u0000>\u017f\u0001\u0000\u0000\u0000"+
"@\u0184\u0001\u0000\u0000\u0000B\u018f\u0001\u0000\u0000\u0000D\u0195"+
"\u0001\u0000\u0000\u0000F\u0197\u0001\u0000\u0000\u0000H\u019b\u0001\u0000"+
"\u0000\u0000J\u019e\u0001\u0000\u0000\u0000L\u01a3\u0001\u0000\u0000\u0000"+
"N\u01b5\u0001\u0000\u0000\u0000P\u01bb\u0001\u0000\u0000\u0000R\u01c7"+
"\u0001\u0000\u0000\u0000T\u01d7\u0001\u0000\u0000\u0000V\u01dd\u0001\u0000"+
"\u0000\u0000X\u01e3\u0001\u0000\u0000\u0000Z\u01ef\u0001\u0000\u0000\u0000"+
"\\\u01f1\u0001\u0000\u0000\u0000^\u01f8\u0001\u0000\u0000\u0000`\u01fc"+
"\u0001\u0000\u0000\u0000b\u0206\u0001\u0000\u0000\u0000d\u0213\u0001\u0000"+
"\u0000\u0000f\u0215\u0001\u0000\u0000\u0000h\u0218\u0001\u0000\u0000\u0000"+
"j\u0225\u0001\u0000\u0000\u0000l\u022f\u0001\u0000\u0000\u0000n\u0231"+
"\u0001\u0000\u0000\u0000p\u0239\u0001\u0000\u0000\u0000r\u023b\u0001\u0000"+
"\u0000\u0000t\u024b\u0001\u0000\u0000\u0000v\u024e\u0001\u0000\u0000\u0000"+
"x\u025c\u0001\u0000\u0000\u0000z\u025e\u0001\u0000\u0000\u0000|\u0262"+
"\u0001\u0000\u0000\u0000~\u026a\u0001\u0000\u0000\u0000\u0080\u026c\u0001"+
"\u0000\u0000\u0000\u0082\u0272\u0001\u0000\u0000\u0000\u0084\u027b\u0001"+
"\u0000\u0000\u0000\u0086\u0286\u0001\u0000\u0000\u0000\u0088\u028a\u0001"+
"\u0000\u0000\u0000\u008a\u028c\u0001\u0000\u0000\u0000\u008c\u028f\u0001"+
"\u0000\u0000\u0000\u008e\u0294\u0001\u0000\u0000\u0000\u0090\u02a2\u0001"+
"\u0000\u0000\u0000\u0092\u02af\u0001\u0000\u0000\u0000\u0094\u02be\u0001"+
"\u0000\u0000\u0000\u0096\u02d0\u0001\u0000\u0000\u0000\u0098\u02d2\u0001"+
"\u0000\u0000\u0000\u009a\u02d5\u0001\u0000\u0000\u0000\u009c\u02df\u0001"+
"\u0000\u0000\u0000\u009e\u02e1\u0001\u0000\u0000\u0000\u00a0\u02e5\u0001"+
"\u0000\u0000\u0000\u00a2\u02e7\u0001\u0000\u0000\u0000\u00a4\u02eb\u0001"+
"\u0000\u0000\u0000\u00a6\u02ee\u0001\u0000\u0000\u0000\u00a8\u02f2\u0001"+
"\u0000\u0000\u0000\u00aa\u02f6\u0001\u0000\u0000\u0000\u00ac\u02f9\u0001"+
"\u0000\u0000\u0000\u00ae\u02fd\u0001\u0000\u0000\u0000\u00b0\u0304\u0001"+
"\u0000\u0000\u0000\u00b2\u0307\u0001\u0000\u0000\u0000\u00b4\u030a\u0001"+
"\u0000\u0000\u0000\u00b6\u00b8\u0003\u0004\u0002\u0000\u00b7\u00b6\u0001"+
"\u0000\u0000\u0000\u00b7\u00b8\u0001\u0000\u0000\u0000\u00b8\u00ba\u0001"+
"\u0000\u0000\u0000\u00b9\u00bb\u0003\u0006\u0003\u0000\u00ba\u00b9\u0001"+
"\u0000\u0000\u0000\u00ba\u00bb\u0001\u0000\u0000\u0000\u00bb\u00bc\u0001"+
"\u0000\u0000\u0000\u00bc\u00bd\u0003\b\u0004\u0000\u00bd\u00be\u0005\u0000"+
"\u0000\u0001\u00be\u0001\u0001\u0000\u0000\u0000\u00bf\u00c0\u0005\u0018"+
"\u0000\u0000\u00c0\u00c1\u0005\u0018\u0000\u0000\u00c1\u0003\u0001\u0000"+
"\u0000\u0000\u00c2\u00c3\u0005\u0001\u0000\u0000\u00c3\u00c5\u0005\u0018"+
"\u0000\u0000\u00c4\u00c2\u0001\u0000\u0000\u0000\u00c5\u00c8\u0001\u0000"+
"\u0000\u0000\u00c6\u00c4\u0001\u0000\u0000\u0000\u00c6\u00c7\u0001\u0000"+
"\u0000\u0000\u00c7\u00c9\u0001\u0000\u0000\u0000\u00c8\u00c6\u0001\u0000"+
"\u0000\u0000\u00c9\u00ca\u0005\u0001\u0000\u0000\u00ca\u00cb\u0003\u0002"+
"\u0001\u0000\u00cb\u0005\u0001\u0000\u0000\u0000\u00cc\u00cd\u0005\u0002"+
"\u0000\u0000\u00cd\u00cf\u0005\u0018\u0000\u0000\u00ce\u00cc\u0001\u0000"+
"\u0000\u0000\u00cf\u00d2\u0001\u0000\u0000\u0000\u00d0\u00ce\u0001\u0000"+
"\u0000\u0000\u00d0\u00d1\u0001\u0000\u0000\u0000\u00d1\u00d3\u0001\u0000"+
"\u0000\u0000\u00d2\u00d0\u0001\u0000\u0000\u0000\u00d3\u00d4\u0005\u0002"+
"\u0000\u0000\u00d4\u00d5\u0003\u0002\u0001\u0000\u00d5\u0007\u0001\u0000"+
"\u0000\u0000\u00d6\u00d8\u0003\u0010\b\u0000\u00d7\u00d9\u0005\u0018\u0000"+
"\u0000\u00d8\u00d7\u0001\u0000\u0000\u0000\u00d8\u00d9\u0001\u0000\u0000"+
"\u0000\u00d9\u00db\u0001\u0000\u0000\u0000\u00da\u00d6\u0001\u0000\u0000"+
"\u0000\u00db\u00de\u0001\u0000\u0000\u0000\u00dc\u00da\u0001\u0000\u0000"+
"\u0000\u00dc\u00dd\u0001\u0000\u0000\u0000\u00dd\u00df\u0001\u0000\u0000"+
"\u0000\u00de\u00dc\u0001\u0000\u0000\u0000\u00df\u00e0\u0003\u0010\b\u0000"+
"\u00e0\t\u0001\u0000\u0000\u0000\u00e1\u00e2\u0005\u0001\u0000\u0000\u00e2"+
"\u00e3\u0005\u0018\u0000\u0000\u00e3\u000b\u0001\u0000\u0000\u0000\u00e4"+
"\u00e6\u0003\n\u0005\u0000\u00e5\u00e4\u0001\u0000\u0000\u0000\u00e6\u00e9"+
"\u0001\u0000\u0000\u0000\u00e7\u00e5\u0001\u0000\u0000\u0000\u00e7\u00e8"+
"\u0001\u0000\u0000\u0000\u00e8\r\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001"+
"\u0000\u0000\u0000\u00ea\u00ec\u0003\n\u0005\u0000\u00eb\u00ea\u0001\u0000"+
"\u0000\u0000\u00ec\u00ed\u0001\u0000\u0000\u0000\u00ed\u00eb\u0001\u0000"+
"\u0000\u0000\u00ed\u00ee\u0001\u0000\u0000\u0000\u00ee\u000f\u0001\u0000"+
"\u0000\u0000\u00ef\u00f2\u0003\u0014\n\u0000\u00f0\u00f2\u0003\u0012\t"+
"\u0000\u00f1\u00ef\u0001\u0000\u0000\u0000\u00f1\u00f0\u0001\u0000\u0000"+
"\u0000\u00f2\u0011\u0001\u0000\u0000\u0000\u00f3\u00fb\u0003\f\u0006\u0000"+
"\u00f4\u00fc\u0003,\u0016\u0000\u00f5\u00f8\u0003z=\u0000\u00f6\u00f8"+
"\u0003\u001c\u000e\u0000\u00f7\u00f5\u0001\u0000\u0000\u0000\u00f7\u00f6"+
"\u0001\u0000\u0000\u0000\u00f8\u00f9\u0001\u0000\u0000\u0000\u00f9\u00fa"+
"\u0005\u0018\u0000\u0000\u00fa\u00fc\u0001\u0000\u0000\u0000\u00fb\u00f4"+
"\u0001\u0000\u0000\u0000\u00fb\u00f7\u0001\u0000\u0000\u0000\u00fc\u0013"+
"\u0001\u0000\u0000\u0000\u00fd\u00fe\u0003\u000e\u0007\u0000\u00fe\u00ff"+
"\u0003\u0018\f\u0000\u00ff\u0015\u0001\u0000\u0000\u0000\u0100\u0101\u0003"+
"\f\u0006\u0000\u0101\u0102\u0003\u0018\f\u0000\u0102\u0017\u0001\u0000"+
"\u0000\u0000\u0103\u010d\u0003 \u0010\u0000\u0104\u0109\u0003\u001e\u000f"+
"\u0000\u0105\u0106\u0003p8\u0000\u0106\u0107\u0003\u00a6S\u0000\u0107"+
"\u0109\u0001\u0000\u0000\u0000\u0108\u0104\u0001\u0000\u0000\u0000\u0108"+
"\u0105\u0001\u0000\u0000\u0000\u0109\u010a\u0001\u0000\u0000\u0000\u010a"+
"\u010b\u0005\u0018\u0000\u0000\u010b\u010d\u0001\u0000\u0000\u0000\u010c"+
"\u0103\u0001\u0000\u0000\u0000\u010c\u0108\u0001\u0000\u0000\u0000\u010d"+
"\u0019\u0001\u0000\u0000\u0000\u010e\u0111\u0003\u00a0P\u0000\u010f\u0111"+
"\u0003\u00a2Q\u0000\u0110\u010e\u0001\u0000\u0000\u0000\u0110\u010f\u0001"+
"\u0000\u0000\u0000\u0111\u001b\u0001\u0000\u0000\u0000\u0112\u0114\u0003"+
"\u001a\r\u0000\u0113\u0115\u0003\u00a6S\u0000\u0114\u0113\u0001\u0000"+
"\u0000\u0000\u0114\u0115\u0001\u0000\u0000\u0000\u0115\u001d\u0001\u0000"+
"\u0000\u0000\u0116\u0117\u0003&\u0013\u0000\u0117\u0118\u0003\u00aaU\u0000"+
"\u0118\u0119\u0003*\u0015\u0000\u0119\u001f\u0001\u0000\u0000\u0000\u011a"+
"\u011b\u0003&\u0013\u0000\u011b\u011c\u0003\u00a6S\u0000\u011c\u011d\u0003"+
"\"\u0011\u0000\u011d!\u0001\u0000\u0000\u0000\u011e\u0121\u0003$\u0012"+
"\u0000\u011f\u0121\u0005\u0018\u0000\u0000\u0120\u011e\u0001\u0000\u0000"+
"\u0000\u0120\u011f\u0001\u0000\u0000\u0000\u0121#\u0001\u0000\u0000\u0000"+
"\u0122\u0123\u0005\u0018\u0000\u0000\u0123\u0126\u0005!\u0000\u0000\u0124"+
"\u0127\u0003\u0012\t\u0000\u0125\u0127\u0003\u0016\u000b\u0000\u0126\u0124"+
"\u0001\u0000\u0000\u0000\u0126\u0125\u0001\u0000\u0000\u0000\u0127\u012f"+
"\u0001\u0000\u0000\u0000\u0128\u012e\u0003\u0012\t\u0000\u0129\u012b\u0005"+
"\u0018\u0000\u0000\u012a\u0129\u0001\u0000\u0000\u0000\u012a\u012b\u0001"+
"\u0000\u0000\u0000\u012b\u012c\u0001\u0000\u0000\u0000\u012c\u012e\u0003"+
"\u0016\u000b\u0000\u012d\u0128\u0001\u0000\u0000\u0000\u012d\u012a\u0001"+
"\u0000\u0000\u0000\u012e\u0131\u0001\u0000\u0000\u0000\u012f\u012d\u0001"+
"\u0000\u0000\u0000\u012f\u0130\u0001\u0000\u0000\u0000\u0130\u0132\u0001"+
"\u0000\u0000\u0000\u0131\u012f\u0001\u0000\u0000\u0000\u0132\u0133\u0005"+
"\"\u0000\u0000\u0133%\u0001\u0000\u0000\u0000\u0134\u013d\u0005\u0010"+
"\u0000\u0000\u0135\u013a\u0003(\u0014\u0000\u0136\u0137\u0005\u000e\u0000"+
"\u0000\u0137\u0139\u0003(\u0014\u0000\u0138\u0136\u0001\u0000\u0000\u0000"+
"\u0139\u013c\u0001\u0000\u0000\u0000\u013a\u0138\u0001\u0000\u0000\u0000"+
"\u013a\u013b\u0001\u0000\u0000\u0000\u013b\u013e\u0001\u0000\u0000\u0000"+
"\u013c\u013a\u0001\u0000\u0000\u0000\u013d\u0135\u0001\u0000\u0000\u0000"+
"\u013d\u013e\u0001\u0000\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000"+
"\u013f\u0140\u0005\u0011\u0000\u0000\u0140\'\u0001\u0000\u0000\u0000\u0141"+
"\u0142\u0005\u001e\u0000\u0000\u0142)\u0001\u0000\u0000\u0000\u0143\u0144"+
"\u0005\u000e\u0000\u0000\u0144\u0145\u0005\u0007\u0000\u0000\u0145\u0146"+
"\u0007\u0000\u0000\u0000\u0146+\u0001\u0000\u0000\u0000\u0147\u0149\u0003"+
"0\u0018\u0000\u0148\u014a\u0003\u00a6S\u0000\u0149\u0148\u0001\u0000\u0000"+
"\u0000\u0149\u014a\u0001\u0000\u0000\u0000\u014a\u014b\u0001\u0000\u0000"+
"\u0000\u014b\u014c\u0005\u0018\u0000\u0000\u014c\u014f\u0001\u0000\u0000"+
"\u0000\u014d\u014f\u0003B!\u0000\u014e\u0147\u0001\u0000\u0000\u0000\u014e"+
"\u014d\u0001\u0000\u0000\u0000\u014f-\u0001\u0000\u0000\u0000\u0150\u0151"+
"\u00034\u001a\u0000\u0151\u0152\u0003:\u001d\u0000\u0152\u0155\u0001\u0000"+
"\u0000\u0000\u0153\u0155\u00032\u0019\u0000\u0154\u0150\u0001\u0000\u0000"+
"\u0000\u0154\u0153\u0001\u0000\u0000\u0000\u0155/\u0001\u0000\u0000\u0000"+
"\u0156\u0157\u00036\u001b\u0000\u0157\u0158\u0003:\u001d\u0000\u0158\u015b"+
"\u0001\u0000\u0000\u0000\u0159\u015b\u00032\u0019\u0000\u015a\u0156\u0001"+
"\u0000\u0000\u0000\u015a\u0159\u0001\u0000\u0000\u0000\u015b1\u0001\u0000"+
"\u0000\u0000\u015c\u015d\u0003\u00a4R\u0000\u015d\u015e\u0003<\u001e\u0000"+
"\u015e3\u0001\u0000\u0000\u0000\u015f\u0162\u0003|>\u0000\u0160\u0162"+
"\u00038\u001c\u0000\u0161\u015f\u0001\u0000\u0000\u0000\u0161\u0160\u0001"+
"\u0000\u0000\u0000\u01625\u0001\u0000\u0000\u0000\u0163\u0167\u0003\u008a"+
"E\u0000\u0164\u0167\u0003\u0080@\u0000\u0165\u0167\u00038\u001c\u0000"+
"\u0166\u0163\u0001\u0000\u0000\u0000\u0166\u0164\u0001\u0000\u0000\u0000"+
"\u0166\u0165\u0001\u0000\u0000\u0000\u01677\u0001\u0000\u0000\u0000\u0168"+
"\u0169\u0007\u0001\u0000\u0000\u01699\u0001\u0000\u0000\u0000\u016a\u016b"+
"\u0005\u000e\u0000\u0000\u016b\u016c\u0003@ \u0000\u016c\u016d\u0003\u00b2"+
"Y\u0000\u016d\u016f\u0001\u0000\u0000\u0000\u016e\u016a\u0001\u0000\u0000"+
"\u0000\u016f\u0170\u0001\u0000\u0000\u0000\u0170\u016e\u0001\u0000\u0000"+
"\u0000\u0170\u0171\u0001\u0000\u0000\u0000\u0171\u0179\u0001\u0000\u0000"+
"\u0000\u0172\u0173\u0005\u000e\u0000\u0000\u0173\u0175\u0003@ \u0000\u0174"+
"\u0172\u0001\u0000\u0000\u0000\u0175\u0176\u0001\u0000\u0000\u0000\u0176"+
"\u0174\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000\u0177"+
"\u0179\u0001\u0000\u0000\u0000\u0178\u016e\u0001\u0000\u0000\u0000\u0178"+
"\u0174\u0001\u0000\u0000\u0000\u0179;\u0001\u0000\u0000\u0000\u017a\u017b"+
"\u0005\u000e\u0000\u0000\u017b\u017d\u0003>\u001f\u0000\u017c\u017e\u0003"+
":\u001d\u0000\u017d\u017c\u0001\u0000\u0000\u0000\u017d\u017e\u0001\u0000"+
"\u0000\u0000\u017e=\u0001\u0000\u0000\u0000\u017f\u0180\u0003@ \u0000"+
"\u0180?\u0001\u0000\u0000\u0000\u0181\u0185\u0003\u00a0P\u0000\u0182\u0185"+
"\u0003|>\u0000\u0183\u0185\u0003\u00aeW\u0000\u0184\u0181\u0001\u0000"+
"\u0000\u0000\u0184\u0182\u0001\u0000\u0000\u0000\u0184\u0183\u0001\u0000"+
"\u0000\u0000\u0185A\u0001\u0000\u0000\u0000\u0186\u0187\u0003F#\u0000"+
"\u0187\u0188\u0003J%\u0000\u0188\u0190\u0001\u0000\u0000\u0000\u0189\u018b"+
"\u0003\u00a4R\u0000\u018a\u018c\u0003\u00a6S\u0000\u018b\u018a\u0001\u0000"+
"\u0000\u0000\u018b\u018c\u0001\u0000\u0000\u0000\u018c\u018d\u0001\u0000"+
"\u0000\u0000\u018d\u018e\u0003L&\u0000\u018e\u0190\u0001\u0000\u0000\u0000"+
"\u018f\u0186\u0001\u0000\u0000\u0000\u018f\u0189\u0001\u0000\u0000\u0000"+
"\u0190C\u0001\u0000\u0000\u0000\u0191\u0196\u00038\u001c\u0000\u0192\u0196"+
"\u0003~?\u0000\u0193\u0196\u0003\u008eG\u0000\u0194\u0196\u0003\u00a2"+
"Q\u0000\u0195\u0191\u0001\u0000\u0000\u0000\u0195\u0192\u0001\u0000\u0000"+
"\u0000\u0195\u0193\u0001\u0000\u0000\u0000\u0195\u0194\u0001\u0000\u0000"+
"\u0000\u0196E\u0001\u0000\u0000\u0000\u0197\u0199\u0003D\"\u0000\u0198"+
"\u019a\u0003\u00a6S\u0000\u0199\u0198\u0001\u0000\u0000\u0000\u0199\u019a"+
"\u0001\u0000\u0000\u0000\u019aG\u0001\u0000\u0000\u0000\u019b\u019c\u0003"+
"D\"\u0000\u019c\u019d\u0003\u00b2Y\u0000\u019dI\u0001\u0000\u0000\u0000"+
"\u019e\u019f\u0005\u0018\u0000\u0000\u019f\u01a0\u0005!\u0000\u0000\u01a0"+
"\u01a1\u0003N\'\u0000\u01a1\u01a2\u0005\"\u0000\u0000\u01a2K\u0001\u0000"+
"\u0000\u0000\u01a3\u01a4\u0005\u0018\u0000\u0000\u01a4\u01a5\u0005!\u0000"+
"\u0000\u01a5\u01a7\u0003V+\u0000\u01a6\u01a8\u0003N\'\u0000\u01a7\u01a6"+
"\u0001\u0000\u0000\u0000\u01a7\u01a8\u0001\u0000\u0000\u0000\u01a8\u01a9"+
"\u0001\u0000\u0000\u0000\u01a9\u01aa\u0005\"\u0000\u0000\u01aaM\u0001"+
"\u0000\u0000\u0000\u01ab\u01ad\u0003P(\u0000\u01ac\u01ab\u0001\u0000\u0000"+
"\u0000\u01ad\u01ae\u0001\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000"+
"\u0000\u01ae\u01af\u0001\u0000\u0000\u0000\u01af\u01b6\u0001\u0000\u0000"+
"\u0000\u01b0\u01b2\u0003V+\u0000\u01b1\u01b0\u0001\u0000\u0000\u0000\u01b2"+
"\u01b3\u0001\u0000\u0000\u0000\u01b3\u01b1\u0001\u0000\u0000\u0000\u01b3"+
"\u01b4\u0001\u0000\u0000\u0000\u01b4\u01b6\u0001\u0000\u0000\u0000\u01b5"+
"\u01ac\u0001\u0000\u0000\u0000\u01b5\u01b1\u0001\u0000\u0000\u0000\u01b6"+
"O\u0001\u0000\u0000\u0000\u01b7\u01b8\u0003R)\u0000\u01b8\u01b9\u0005"+
"\u0018\u0000\u0000\u01b9\u01bc\u0001\u0000\u0000\u0000\u01ba\u01bc\u0003"+
"T*\u0000\u01bb\u01b7\u0001\u0000\u0000\u0000\u01bb\u01ba\u0001\u0000\u0000"+
"\u0000\u01bcQ\u0001\u0000\u0000\u0000\u01bd\u01c8\u0003\\.\u0000\u01be"+
"\u01c8\u0003j5\u0000\u01bf\u01c2\u0003\u001a\r\u0000\u01c0\u01c2\u0003"+
"x<\u0000\u01c1\u01bf\u0001\u0000\u0000\u0000\u01c1\u01c0\u0001\u0000\u0000"+
"\u0000\u01c2\u01c3\u0001\u0000\u0000\u0000\u01c3\u01c5\u0003\u00b2Y\u0000"+
"\u01c4\u01c6\u0003\u00a6S\u0000\u01c5\u01c4\u0001\u0000\u0000\u0000\u01c5"+
"\u01c6\u0001\u0000\u0000\u0000\u01c6\u01c8\u0001\u0000\u0000\u0000\u01c7"+
"\u01bd\u0001\u0000\u0000\u0000\u01c7\u01be\u0001\u0000\u0000\u0000\u01c7"+
"\u01c1\u0001\u0000\u0000\u0000\u01c8S\u0001\u0000\u0000\u0000\u01c9\u01d8"+
"\u0003d2\u0000\u01ca\u01cc\u0003H$\u0000\u01cb\u01cd\u0003\u00a6S\u0000"+
"\u01cc\u01cb\u0001\u0000\u0000\u0000\u01cc\u01cd\u0001\u0000\u0000\u0000"+
"\u01cd\u01ce\u0001\u0000\u0000\u0000\u01ce\u01cf\u0003J%\u0000\u01cf\u01d8"+
"\u0001\u0000\u0000\u0000\u01d0\u01d1\u0003\u00a4R\u0000\u01d1\u01d3\u0003"+
"\u00b2Y\u0000\u01d2\u01d4\u0003\u00a6S\u0000\u01d3\u01d2\u0001\u0000\u0000"+
"\u0000\u01d3\u01d4\u0001\u0000\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000"+
"\u0000\u01d5\u01d6\u0003L&\u0000\u01d6\u01d8\u0001\u0000\u0000\u0000\u01d7"+
"\u01c9\u0001\u0000\u0000\u0000\u01d7\u01ca\u0001\u0000\u0000\u0000\u01d7"+
"\u01d0\u0001\u0000\u0000\u0000\u01d8U\u0001\u0000\u0000\u0000\u01d9\u01da"+
"\u0003X,\u0000\u01da\u01db\u0005\u0018\u0000\u0000\u01db\u01de\u0001\u0000"+
"\u0000\u0000\u01dc\u01de\u0003Z-\u0000\u01dd\u01d9\u0001\u0000\u0000\u0000"+
"\u01dd\u01dc\u0001\u0000\u0000\u0000\u01deW\u0001\u0000\u0000\u0000\u01df"+
"\u01e4\u0003^/\u0000\u01e0\u01e4\u0003l6\u0000\u01e1\u01e4\u0003\u001c"+
"\u000e\u0000\u01e2\u01e4\u0003z=\u0000\u01e3\u01df\u0001\u0000\u0000\u0000"+
"\u01e3\u01e0\u0001\u0000\u0000\u0000\u01e3\u01e1\u0001\u0000\u0000\u0000"+
"\u01e3\u01e2\u0001\u0000\u0000\u0000\u01e4Y\u0001\u0000\u0000\u0000\u01e5"+
"\u01f0\u0003b1\u0000\u01e6\u01e7\u0003F#\u0000\u01e7\u01e8\u0003J%\u0000"+
"\u01e8\u01f0\u0001\u0000\u0000\u0000\u01e9\u01eb\u0003\u00a4R\u0000\u01ea"+
"\u01ec\u0003\u00a6S\u0000\u01eb\u01ea\u0001\u0000\u0000\u0000\u01eb\u01ec"+
"\u0001\u0000\u0000\u0000\u01ec\u01ed\u0001\u0000\u0000\u0000\u01ed\u01ee"+
"\u0003L&\u0000\u01ee\u01f0\u0001\u0000\u0000\u0000\u01ef\u01e5\u0001\u0000"+
"\u0000\u0000\u01ef\u01e6\u0001\u0000\u0000\u0000\u01ef\u01e9\u0001\u0000"+
"\u0000\u0000\u01f0[\u0001\u0000\u0000\u0000\u01f1\u01f2\u0005\u0012\u0000"+
"\u0000\u01f2\u01f3\u00030\u0018\u0000\u01f3\u01f4\u0005\u0013\u0000\u0000"+
"\u01f4\u01f6\u0003\u00b2Y\u0000\u01f5\u01f7\u0003\u00a6S\u0000\u01f6\u01f5"+
"\u0001\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7]\u0001"+
"\u0000\u0000\u0000\u01f8\u01fa\u00030\u0018\u0000\u01f9\u01fb\u0003\u00a6"+
"S\u0000\u01fa\u01f9\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000"+
"\u0000\u01fb_\u0001\u0000\u0000\u0000\u01fc\u01fe\u0003&\u0013\u0000\u01fd"+
"\u01ff\u0003\u00a8T\u0000\u01fe\u01fd\u0001\u0000\u0000\u0000\u01fe\u01ff"+
"\u0001\u0000\u0000\u0000\u01ff\u0200\u0001\u0000\u0000\u0000\u0200\u0201"+
"\u0003\"\u0011\u0000\u0201a\u0001\u0000\u0000\u0000\u0202\u0203\u0003"+
"\f\u0006\u0000\u0203\u0204\u0003 \u0010\u0000\u0204\u0207\u0001\u0000"+
"\u0000\u0000\u0205\u0207\u0003`0\u0000\u0206\u0202\u0001\u0000\u0000\u0000"+
"\u0206\u0205\u0001\u0000\u0000\u0000\u0207c\u0001\u0000\u0000\u0000\u0208"+
"\u0209\u0003\f\u0006\u0000\u0209\u020a\u0003f3\u0000\u020a\u020b\u0003"+
"\u00a6S\u0000\u020b\u020c\u0003\"\u0011\u0000\u020c\u0214\u0001\u0000"+
"\u0000\u0000\u020d\u020f\u0003f3\u0000\u020e\u0210\u0003\u00a8T\u0000"+
"\u020f\u020e\u0001\u0000\u0000\u0000\u020f\u0210\u0001\u0000\u0000\u0000"+
"\u0210\u0211\u0001\u0000\u0000\u0000\u0211\u0212\u0003\"\u0011\u0000\u0212"+
"\u0214\u0001\u0000\u0000\u0000\u0213\u0208\u0001\u0000\u0000\u0000\u0213"+
"\u020d\u0001\u0000\u0000\u0000\u0214e\u0001\u0000\u0000\u0000\u0215\u0216"+
"\u0003&\u0013\u0000\u0216\u0217\u0003\u00b2Y\u0000\u0217g\u0001\u0000"+
"\u0000\u0000\u0218\u0219\u0005\u0012\u0000\u0000\u0219\u021a\u0003p8\u0000"+
"\u021a\u021b\u0005\u0013\u0000\u0000\u021b\u021c\u0003\u00b2Y\u0000\u021c"+
"i\u0001\u0000\u0000\u0000\u021d\u021e\u0003\f\u0006\u0000\u021e\u021f"+
"\u0003h4\u0000\u021f\u0220\u0003\u00a6S\u0000\u0220\u0226\u0001\u0000"+
"\u0000\u0000\u0221\u0223\u0003h4\u0000\u0222\u0224\u0003\u00a8T\u0000"+
"\u0223\u0222\u0001\u0000\u0000\u0000\u0223\u0224\u0001\u0000\u0000\u0000"+
"\u0224\u0226\u0001\u0000\u0000\u0000\u0225\u021d\u0001\u0000\u0000\u0000"+
"\u0225\u0221\u0001\u0000\u0000\u0000\u0226k\u0001\u0000\u0000\u0000\u0227"+
"\u0228\u0003\f\u0006\u0000\u0228\u0229\u0003p8\u0000\u0229\u022a\u0003"+
"\u00a6S\u0000\u022a\u0230\u0001\u0000\u0000\u0000\u022b\u022d\u0003p8"+
"\u0000\u022c\u022e\u0003\u00a8T\u0000\u022d\u022c\u0001\u0000\u0000\u0000"+
"\u022d\u022e\u0001\u0000\u0000\u0000\u022e\u0230\u0001\u0000\u0000\u0000"+
"\u022f\u0227\u0001\u0000\u0000\u0000\u022f\u022b\u0001\u0000\u0000\u0000"+
"\u0230m\u0001\u0000\u0000\u0000\u0231\u0233\u0003&\u0013\u0000\u0232\u0234"+
"\u0003v;\u0000\u0233\u0232\u0001\u0000\u0000\u0000\u0234\u0235\u0001\u0000"+
"\u0000\u0000\u0235\u0233\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000"+
"\u0000\u0000\u0236o\u0001\u0000\u0000\u0000\u0237\u023a\u0003n7\u0000"+
"\u0238\u023a\u0003r9\u0000\u0239\u0237\u0001\u0000\u0000\u0000\u0239\u0238"+
"\u0001\u0000\u0000\u0000\u023aq\u0001\u0000\u0000\u0000\u023b\u0240\u0006"+
"9\uffff\uffff\u0000\u023c\u0241\u0003|>\u0000\u023d\u0241\u0003.\u0017"+
"\u0000\u023e\u0241\u0003n7\u0000\u023f\u0241\u0003\u001a\r\u0000\u0240"+
"\u023c\u0001\u0000\u0000\u0000\u0240\u023d\u0001\u0000\u0000\u0000\u0240"+
"\u023e\u0001\u0000\u0000\u0000\u0240\u023f\u0001\u0000\u0000\u0000\u0241"+
"\u0242\u0001\u0000\u0000\u0000\u0242\u0243\u0003t:\u0000\u0243\u0248\u0001"+
"\u0000\u0000\u0000\u0244\u0245\n\u0001\u0000\u0000\u0245\u0247\u0003t"+
":\u0000\u0246\u0244\u0001\u0000\u0000\u0000\u0247\u024a\u0001\u0000\u0000"+
"\u0000\u0248\u0246\u0001\u0000\u0000\u0000\u0248\u0249\u0001\u0000\u0000"+
"\u0000\u0249s\u0001\u0000\u0000\u0000\u024a\u0248\u0001\u0000\u0000\u0000"+
"\u024b\u024c\u0003\u00acV\u0000\u024c\u024d\u0003&\u0013\u0000\u024du"+
"\u0001\u0000\u0000\u0000\u024e\u024f\u0005\u000e\u0000\u0000\u024f\u0255"+
"\u0005\u0012\u0000\u0000\u0250\u0256\u0003|>\u0000\u0251\u0256\u0003\u0082"+
"A\u0000\u0252\u0256\u0003.\u0017\u0000\u0253\u0256\u0003p8\u0000\u0254"+
"\u0256\u0003\u001a\r\u0000\u0255\u0250\u0001\u0000\u0000\u0000\u0255\u0251"+
"\u0001\u0000\u0000\u0000\u0255\u0252\u0001\u0000\u0000\u0000\u0255\u0253"+
"\u0001\u0000\u0000\u0000\u0255\u0254\u0001\u0000\u0000\u0000\u0256\u0257"+
"\u0001\u0000\u0000\u0000\u0257\u0258\u0003\u00a6S\u0000\u0258\u0259\u0005"+
"\u0013\u0000\u0000\u0259w\u0001\u0000\u0000\u0000\u025a\u025d\u0003~?"+
"\u0000\u025b\u025d\u0003\u008eG\u0000\u025c\u025a\u0001\u0000\u0000\u0000"+
"\u025c\u025b\u0001\u0000\u0000\u0000\u025dy\u0001\u0000\u0000\u0000\u025e"+
"\u0260\u0003x<\u0000\u025f\u0261\u0003\u00a6S\u0000\u0260\u025f\u0001"+
"\u0000\u0000\u0000\u0260\u0261\u0001\u0000\u0000\u0000\u0261{\u0001\u0000"+
"\u0000\u0000\u0262\u0264\u0003\u0086C\u0000\u0263\u0265\u0003\u0098L\u0000"+
"\u0264\u0263\u0001\u0000\u0000\u0000\u0265\u0266\u0001\u0000\u0000\u0000"+
"\u0266\u0264\u0001\u0000\u0000\u0000\u0266\u0267\u0001\u0000\u0000\u0000"+
"\u0267}\u0001\u0000\u0000\u0000\u0268\u026b\u0003\u0080@\u0000\u0269\u026b"+
"\u0003\u0084B\u0000\u026a\u0268\u0001\u0000\u0000\u0000\u026a\u0269\u0001"+
"\u0000\u0000\u0000\u026b\u007f\u0001\u0000\u0000\u0000\u026c\u026e\u0003"+
"\u0088D\u0000\u026d\u026f\u0003\u0098L\u0000\u026e\u026d\u0001\u0000\u0000"+
"\u0000\u026f\u0270\u0001\u0000\u0000\u0000\u0270\u026e\u0001\u0000\u0000"+
"\u0000\u0270\u0271\u0001\u0000\u0000\u0000\u0271\u0081\u0001\u0000\u0000"+
"\u0000\u0272\u0276\u0003\u0086C\u0000\u0273\u0275\u0003\u0098L\u0000\u0274"+
"\u0273\u0001\u0000\u0000\u0000\u0275\u0278\u0001\u0000\u0000\u0000\u0276"+
"\u0274\u0001\u0000\u0000\u0000\u0276\u0277\u0001\u0000\u0000\u0000\u0277"+
"\u0279\u0001\u0000\u0000\u0000\u0278\u0276\u0001\u0000\u0000\u0000\u0279"+
"\u027a\u0003\u009aM\u0000\u027a\u0083\u0001\u0000\u0000\u0000\u027b\u027f"+
"\u0003\u0088D\u0000\u027c\u027e\u0003\u0098L\u0000\u027d\u027c\u0001\u0000"+
"\u0000\u0000\u027e\u0281\u0001\u0000\u0000\u0000\u027f\u027d\u0001\u0000"+
"\u0000\u0000\u027f\u0280\u0001\u0000\u0000\u0000\u0280\u0282\u0001\u0000"+
"\u0000\u0000\u0281\u027f\u0001\u0000\u0000\u0000\u0282\u0283\u0003\u009a"+
"M\u0000\u0283\u0085\u0001\u0000\u0000\u0000\u0284\u0287\u0003\u00a0P\u0000"+
"\u0285\u0287\u0003\u00aeW\u0000\u0286\u0284\u0001\u0000\u0000\u0000\u0286"+
"\u0285\u0001\u0000\u0000\u0000\u0287\u0087\u0001\u0000\u0000\u0000\u0288"+
"\u028b\u0003\u00a0P\u0000\u0289\u028b\u0003\u00aeW\u0000\u028a\u0288\u0001"+
"\u0000\u0000\u0000\u028a\u0289\u0001\u0000\u0000\u0000\u028b\u0089\u0001"+
"\u0000\u0000\u0000\u028c\u028d\u0003\u0090H\u0000\u028d\u028e\u0003\u0098"+
"L\u0000\u028e\u008b\u0001\u0000\u0000\u0000\u028f\u0290\u0003\u0090H\u0000"+
"\u0290\u0291\u0003\u009aM\u0000\u0291\u008d\u0001\u0000\u0000\u0000\u0292"+
"\u0295\u0003\u008aE\u0000\u0293\u0295\u0003\u008cF\u0000\u0294\u0292\u0001"+
"\u0000\u0000\u0000\u0294\u0293\u0001\u0000\u0000\u0000\u0295\u008f\u0001"+
"\u0000\u0000\u0000\u0296\u0297\u0006H\uffff\uffff\u0000\u0297\u02a3\u0003"+
"\u0096K\u0000\u0298\u029e\u0003\u001c\u000e\u0000\u0299\u029b\u0003p8"+
"\u0000\u029a\u029c\u0003\u00a6S\u0000\u029b\u029a\u0001\u0000\u0000\u0000"+
"\u029b\u029c\u0001\u0000\u0000\u0000\u029c\u029e\u0001\u0000\u0000\u0000"+
"\u029d\u0298\u0001\u0000\u0000\u0000\u029d\u0299\u0001\u0000\u0000\u0000"+
"\u029e\u029f\u0001\u0000\u0000\u0000\u029f\u02a0\u0005\u0018\u0000\u0000"+
"\u02a0\u02a3\u0001\u0000\u0000\u0000\u02a1\u02a3\u0003b1\u0000\u02a2\u0296"+
"\u0001\u0000\u0000\u0000\u02a2\u029d\u0001\u0000\u0000\u0000\u02a2\u02a1"+
"\u0001\u0000\u0000\u0000\u02a3\u02aa\u0001\u0000\u0000\u0000\u02a4\u02a5"+
"\n\u0004\u0000\u0000\u02a5\u02a6\u0003\u0092I\u0000\u02a6\u02a7\u0003"+
"\u0094J\u0000\u02a7\u02a9\u0001\u0000\u0000\u0000\u02a8\u02a4\u0001\u0000"+
"\u0000\u0000\u02a9\u02ac\u0001\u0000\u0000\u0000\u02aa\u02a8\u0001\u0000"+
"\u0000\u0000\u02aa\u02ab\u0001\u0000\u0000\u0000\u02ab\u0091\u0001\u0000"+
"\u0000\u0000\u02ac\u02aa\u0001\u0000\u0000\u0000\u02ad\u02b0\u0003\u0098"+
"L\u0000\u02ae\u02b0\u0003\u009aM\u0000\u02af\u02ad\u0001\u0000\u0000\u0000"+
"\u02af\u02ae\u0001\u0000\u0000\u0000\u02b0\u0093\u0001\u0000\u0000\u0000"+
"\u02b1\u02b3\u0003\u00a6S\u0000\u02b2\u02b1\u0001\u0000\u0000\u0000\u02b2"+
"\u02b3\u0001\u0000\u0000\u0000\u02b3\u02b6\u0001\u0000\u0000\u0000\u02b4"+
"\u02b7\u0003J%\u0000\u02b5\u02b7\u0005\u0018\u0000\u0000\u02b6\u02b4\u0001"+
"\u0000\u0000\u0000\u02b6\u02b5\u0001\u0000\u0000\u0000\u02b7\u02bf\u0001"+
"\u0000\u0000\u0000\u02b8\u02ba\u0003:\u001d\u0000\u02b9\u02bb\u0003\u00a6"+
"S\u0000\u02ba\u02b9\u0001\u0000\u0000\u0000\u02ba\u02bb\u0001\u0000\u0000"+
"\u0000\u02bb\u02bc\u0001\u0000\u0000\u0000\u02bc\u02bd\u0005\u0018\u0000"+
"\u0000\u02bd\u02bf\u0001\u0000\u0000\u0000\u02be\u02b2\u0001\u0000\u0000"+
"\u0000\u02be\u02b8\u0001\u0000\u0000\u0000\u02bf\u0095\u0001\u0000\u0000"+
"\u0000\u02c0\u02c4\u00038\u001c\u0000\u02c1\u02c4\u0003~?\u0000\u02c2"+
"\u02c4\u0003\u00a2Q\u0000\u02c3\u02c0\u0001\u0000\u0000\u0000\u02c3\u02c1"+
"\u0001\u0000\u0000\u0000\u02c3\u02c2\u0001\u0000\u0000\u0000\u02c4\u02c6"+
"\u0001\u0000\u0000\u0000\u02c5\u02c7\u0003\u00a6S\u0000\u02c6\u02c5\u0001"+
"\u0000\u0000\u0000\u02c6\u02c7\u0001\u0000\u0000\u0000\u02c7\u02c8\u0001"+
"\u0000\u0000\u0000\u02c8\u02c9\u0003J%\u0000\u02c9\u02d1\u0001\u0000\u0000"+
"\u0000\u02ca\u02cc\u0003\u00a4R\u0000\u02cb\u02cd\u0003\u00a6S\u0000\u02cc"+
"\u02cb\u0001\u0000\u0000\u0000\u02cc\u02cd\u0001\u0000\u0000\u0000\u02cd"+
"\u02ce\u0001\u0000\u0000\u0000\u02ce\u02cf\u0003L&\u0000\u02cf\u02d1\u0001"+
"\u0000\u0000\u0000\u02d0\u02c3\u0001\u0000\u0000\u0000\u02d0\u02ca\u0001"+
"\u0000\u0000\u0000\u02d1\u0097\u0001\u0000\u0000\u0000\u02d2\u02d3\u0005"+
"\u000f\u0000\u0000\u02d3\u02d4\u0003\u009eO\u0000\u02d4\u0099\u0001\u0000"+
"\u0000\u0000\u02d5\u02d6\u0005\u000f\u0000\u0000\u02d6\u02d8\u0005\u001e"+
"\u0000\u0000\u02d7\u02d9\u0003\u00b0X\u0000\u02d8\u02d7\u0001\u0000\u0000"+
"\u0000\u02d8\u02d9\u0001\u0000\u0000\u0000\u02d9\u009b\u0001\u0000\u0000"+
"\u0000\u02da\u02e0\u0005\u0005\u0000\u0000\u02db\u02e0\u0005\u0003\u0000"+
"\u0000\u02dc\u02e0\u0005\u0004\u0000\u0000\u02dd\u02e0\u0005\n\u0000\u0000"+
"\u02de\u02e0\u0003\u00b4Z\u0000\u02df\u02da\u0001\u0000\u0000\u0000\u02df"+
"\u02db\u0001\u0000\u0000\u0000\u02df\u02dc\u0001\u0000\u0000\u0000\u02df"+
"\u02dd\u0001\u0000\u0000\u0000\u02df\u02de\u0001\u0000\u0000\u0000\u02e0"+
"\u009d\u0001\u0000\u0000\u0000\u02e1\u02e2\u0007\u0002\u0000\u0000\u02e2"+
"\u009f\u0001\u0000\u0000\u0000\u02e3\u02e6\u0003\u009cN\u0000\u02e4\u02e6"+
"\u0003\u009eO\u0000\u02e5\u02e3\u0001\u0000\u0000\u0000\u02e5\u02e4\u0001"+
"\u0000\u0000\u0000\u02e6\u00a1\u0001\u0000\u0000\u0000\u02e7\u02e9\u0005"+
"\u001e\u0000\u0000\u02e8\u02ea\u0003\u00b0X\u0000\u02e9\u02e8\u0001\u0000"+
"\u0000\u0000\u02e9\u02ea\u0001\u0000\u0000\u0000\u02ea\u00a3\u0001\u0000"+
"\u0000\u0000\u02eb\u02ec\u0003\u009eO\u0000\u02ec\u02ed\u0005\u000f\u0000"+
"\u0000\u02ed\u00a5\u0001\u0000\u0000\u0000\u02ee\u02f0\u0003\u00aaU\u0000"+
"\u02ef\u02f1\u0005\u0006\u0000\u0000\u02f0\u02ef\u0001\u0000\u0000\u0000"+
"\u02f0\u02f1\u0001\u0000\u0000\u0000\u02f1\u00a7\u0001\u0000\u0000\u0000"+
"\u02f2\u02f3\u0005\u000e\u0000\u0000\u02f3\u02f4\u0005\t\u0000\u0000\u02f4"+
"\u02f5\u0005\t\u0000\u0000\u02f5\u00a9\u0001\u0000\u0000\u0000\u02f6\u02f7"+
"\u0003\u00acV\u0000\u02f7\u02f8\u0007\u0003\u0000\u0000\u02f8\u00ab\u0001"+
"\u0000\u0000\u0000\u02f9\u02fa\u0005\u000e\u0000\u0000\u02fa\u02fb\u0005"+
"\t\u0000\u0000\u02fb\u02fc\u0005\u000e\u0000\u0000\u02fc\u00ad\u0001\u0000"+
"\u0000\u0000\u02fd\u0300\u0005\u0012\u0000\u0000\u02fe\u0301\u0003.\u0017"+
"\u0000\u02ff\u0301\u0003p8\u0000\u0300\u02fe\u0001\u0000\u0000\u0000\u0300"+
"\u02ff\u0001\u0000\u0000\u0000\u0301\u0302\u0001\u0000\u0000\u0000\u0302"+
"\u0303\u0005\u0013\u0000\u0000\u0303\u00af\u0001\u0000\u0000\u0000\u0304"+
"\u0305\u0005\u0017\u0000\u0000\u0305\u0306\u0005\u001f\u0000\u0000\u0306"+
"\u00b1\u0001\u0000\u0000\u0000\u0307\u0308\u0005\b\u0000\u0000\u0308\u0309"+
"\u0007\u0004\u0000\u0000\u0309\u00b3\u0001\u0000\u0000\u0000\u030a\u030b"+
"\u0007\u0005\u0000\u0000\u030b\u00b5\u0001\u0000\u0000\u0000`\u00b7\u00ba"+
"\u00c6\u00d0\u00d8\u00dc\u00e7\u00ed\u00f1\u00f7\u00fb\u0108\u010c\u0110"+
"\u0114\u0120\u0126\u012a\u012d\u012f\u013a\u013d\u0149\u014e\u0154\u015a"+
"\u0161\u0166\u0170\u0176\u0178\u017d\u0184\u018b\u018f\u0195\u0199\u01a7"+
"\u01ae\u01b3\u01b5\u01bb\u01c1\u01c5\u01c7\u01cc\u01d3\u01d7\u01dd\u01e3"+
"\u01eb\u01ef\u01f6\u01fa\u01fe\u0206\u020f\u0213\u0223\u0225\u022d\u022f"+
"\u0235\u0239\u0240\u0248\u0255\u025c\u0260\u0266\u026a\u0270\u0276\u027f"+
"\u0286\u028a\u0294\u029b\u029d\u02a2\u02aa\u02af\u02b2\u02b6\u02ba\u02be"+
"\u02c3\u02c6\u02cc\u02d0\u02d8\u02df\u02e5\u02e9\u02f0\u0300";
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);
}
}
}
