All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.eolang.parser.ProgramParser Maven / Gradle / Ivy

The newest version!
// Generated from org/eolang/parser/Program.g4 by ANTLR 4.8
package org.eolang.parser;

  import java.util.LinkedList;

import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class ProgramParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		COMMENT=1, META=2, REGEX=3, STAR=4, DOTS=5, CONST=6, SLASH=7, COLON=8, 
		ARROW=9, SELF=10, PLUS=11, MINUS=12, SPACE=13, DOT=14, LSQ=15, RSQ=16, 
		LB=17, RB=18, AT=19, PARENT=20, HASH=21, EOL=22, BYTES=23, BOOL=24, CHAR=25, 
		STRING=26, INT=27, FLOAT=28, HEX=29, NAME=30, TAB=31, UNTAB=32;
	public static final int
		RULE_program = 0, RULE_license = 1, RULE_metas = 2, RULE_objects = 3, 
		RULE_object = 4, RULE_anonymous = 5, RULE_abstraction = 6, RULE_attributes = 7, 
		RULE_attribute = 8, RULE_label = 9, RULE_tail = 10, RULE_suffix = 11, 
		RULE_method = 12, RULE_application = 13, RULE_htail = 14, RULE_head = 15, 
		RULE_has = 16, RULE_data = 17;
	private static String[] makeRuleNames() {
		return new String[] {
			"program", "license", "metas", "objects", "object", "anonymous", "abstraction", 
			"attributes", "attribute", "label", "tail", "suffix", "method", "application", 
			"htail", "head", "has", "data"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, null, null, "'*'", "'...'", "'!'", "'/'", "':'", "'>'", "'$'", 
			"'+'", "'-'", "' '", "'.'", "'['", "']'", "'('", "')'", "'@'", "'^'", 
			"'#'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "COMMENT", "META", "REGEX", "STAR", "DOTS", "CONST", "SLASH", "COLON", 
			"ARROW", "SELF", "PLUS", "MINUS", "SPACE", "DOT", "LSQ", "RSQ", "LB", 
			"RB", "AT", "PARENT", "HASH", "EOL", "BYTES", "BOOL", "CHAR", "STRING", 
			"INT", "FLOAT", "HEX", "NAME", "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 "Program.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public ProgramParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class ProgramContext extends ParserRuleContext {
		public ObjectsContext objects() {
			return getRuleContext(ObjectsContext.class,0);
		}
		public TerminalNode EOF() { return getToken(ProgramParser.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 ProgramListener ) ((ProgramListener)listener).enterProgram(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)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(37);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
			case 1:
				{
				setState(36);
				license();
				}
				break;
			}
			setState(40);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==META) {
				{
				setState(39);
				metas();
				}
			}

			setState(42);
			objects();
			setState(43);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LicenseContext extends ParserRuleContext {
		public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
		public TerminalNode COMMENT(int i) {
			return getToken(ProgramParser.COMMENT, i);
		}
		public List EOL() { return getTokens(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.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 ProgramListener ) ((ProgramListener)listener).enterLicense(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitLicense(this);
		}
	}

	public final LicenseContext license() throws RecognitionException {
		LicenseContext _localctx = new LicenseContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_license);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(47); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(45);
					match(COMMENT);
					setState(46);
					match(EOL);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(49); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MetasContext extends ParserRuleContext {
		public List META() { return getTokens(ProgramParser.META); }
		public TerminalNode META(int i) {
			return getToken(ProgramParser.META, i);
		}
		public List EOL() { return getTokens(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.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 ProgramListener ) ((ProgramListener)listener).enterMetas(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitMetas(this);
		}
	}

	public final MetasContext metas() throws RecognitionException {
		MetasContext _localctx = new MetasContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_metas);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(53); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(51);
				match(META);
				setState(52);
				match(EOL);
				}
				}
				setState(55); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==META );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	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(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.EOL, i);
		}
		public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
		public TerminalNode COMMENT(int i) {
			return getToken(ProgramParser.COMMENT, 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 ProgramListener ) ((ProgramListener)listener).enterObjects(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitObjects(this);
		}
	}

	public final ObjectsContext objects() throws RecognitionException {
		ObjectsContext _localctx = new ObjectsContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_objects);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(67); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(61);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(57);
						match(COMMENT);
						setState(58);
						match(EOL);
						}
						} 
					}
					setState(63);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
				}
				setState(64);
				object();
				setState(65);
				match(EOL);
				}
				}
				setState(69); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << REGEX) | (1L << STAR) | (1L << SELF) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << PARENT) | (1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME))) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectContext extends ParserRuleContext {
		public AnonymousContext anonymous() {
			return getRuleContext(AnonymousContext.class,0);
		}
		public AbstractionContext abstraction() {
			return getRuleContext(AbstractionContext.class,0);
		}
		public ApplicationContext application() {
			return getRuleContext(ApplicationContext.class,0);
		}
		public List tail() {
			return getRuleContexts(TailContext.class);
		}
		public TailContext tail(int i) {
			return getRuleContext(TailContext.class,i);
		}
		public List EOL() { return getTokens(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.EOL, i);
		}
		public List method() {
			return getRuleContexts(MethodContext.class);
		}
		public MethodContext method(int i) {
			return getRuleContext(MethodContext.class,i);
		}
		public List htail() {
			return getRuleContexts(HtailContext.class);
		}
		public HtailContext htail(int i) {
			return getRuleContext(HtailContext.class,i);
		}
		public List suffix() {
			return getRuleContexts(SuffixContext.class);
		}
		public SuffixContext suffix(int i) {
			return getRuleContext(SuffixContext.class,i);
		}
		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 ProgramListener ) ((ProgramListener)listener).enterObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitObject(this);
		}
	}

	public final ObjectContext object() throws RecognitionException {
		ObjectContext _localctx = new ObjectContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_object);
		int _la;
		try {
			int _alt;
			setState(95);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(71);
				anonymous();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(74);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case COMMENT:
				case LSQ:
					{
					setState(72);
					abstraction();
					}
					break;
				case REGEX:
				case STAR:
				case SELF:
				case LB:
				case AT:
				case PARENT:
				case BYTES:
				case BOOL:
				case CHAR:
				case STRING:
				case INT:
				case FLOAT:
				case HEX:
				case NAME:
					{
					setState(73);
					application(0);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(77);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
				case 1:
					{
					setState(76);
					tail();
					}
					break;
				}
				setState(92);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(79);
						match(EOL);
						setState(80);
						method();
						setState(82);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
						case 1:
							{
							setState(81);
							htail();
							}
							break;
						}
						setState(85);
						_errHandler.sync(this);
						_la = _input.LA(1);
						if (_la==SPACE) {
							{
							setState(84);
							suffix();
							}
						}

						setState(88);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
						case 1:
							{
							setState(87);
							tail();
							}
							break;
						}
						}
						} 
					}
					setState(94);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AnonymousContext extends ParserRuleContext {
		public AttributesContext attributes() {
			return getRuleContext(AttributesContext.class,0);
		}
		public HtailContext htail() {
			return getRuleContext(HtailContext.class,0);
		}
		public AnonymousContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anonymous; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterAnonymous(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAnonymous(this);
		}
	}

	public final AnonymousContext anonymous() throws RecognitionException {
		AnonymousContext _localctx = new AnonymousContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_anonymous);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(97);
			attributes();
			setState(98);
			htail();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AbstractionContext extends ParserRuleContext {
		public AttributesContext attributes() {
			return getRuleContext(AttributesContext.class,0);
		}
		public List COMMENT() { return getTokens(ProgramParser.COMMENT); }
		public TerminalNode COMMENT(int i) {
			return getToken(ProgramParser.COMMENT, i);
		}
		public List EOL() { return getTokens(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.EOL, i);
		}
		public SuffixContext suffix() {
			return getRuleContext(SuffixContext.class,0);
		}
		public TerminalNode SPACE() { return getToken(ProgramParser.SPACE, 0); }
		public TerminalNode SLASH() { return getToken(ProgramParser.SLASH, 0); }
		public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
		public AbstractionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_abstraction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterAbstraction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAbstraction(this);
		}
	}

	public final AbstractionContext abstraction() throws RecognitionException {
		AbstractionContext _localctx = new AbstractionContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_abstraction);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(104);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMENT) {
				{
				{
				setState(100);
				match(COMMENT);
				setState(101);
				match(EOL);
				}
				}
				setState(106);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(107);
			attributes();
			setState(114);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SPACE) {
				{
				setState(108);
				suffix();
				setState(112);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==SPACE) {
					{
					setState(109);
					match(SPACE);
					setState(110);
					match(SLASH);
					setState(111);
					match(NAME);
					}
				}

				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AttributesContext extends ParserRuleContext {
		public TerminalNode LSQ() { return getToken(ProgramParser.LSQ, 0); }
		public TerminalNode RSQ() { return getToken(ProgramParser.RSQ, 0); }
		public List attribute() {
			return getRuleContexts(AttributeContext.class);
		}
		public AttributeContext attribute(int i) {
			return getRuleContext(AttributeContext.class,i);
		}
		public List SPACE() { return getTokens(ProgramParser.SPACE); }
		public TerminalNode SPACE(int i) {
			return getToken(ProgramParser.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 ProgramListener ) ((ProgramListener)listener).enterAttributes(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAttributes(this);
		}
	}

	public final AttributesContext attributes() throws RecognitionException {
		AttributesContext _localctx = new AttributesContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_attributes);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(116);
			match(LSQ);
			setState(125);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==AT || _la==NAME) {
				{
				setState(117);
				attribute();
				setState(122);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==SPACE) {
					{
					{
					setState(118);
					match(SPACE);
					setState(119);
					attribute();
					}
					}
					setState(124);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
			}

			setState(127);
			match(RSQ);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AttributeContext extends ParserRuleContext {
		public LabelContext label() {
			return getRuleContext(LabelContext.class,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 ProgramListener ) ((ProgramListener)listener).enterAttribute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitAttribute(this);
		}
	}

	public final AttributeContext attribute() throws RecognitionException {
		AttributeContext _localctx = new AttributeContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_attribute);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(129);
			label();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LabelContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(ProgramParser.AT, 0); }
		public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
		public TerminalNode DOTS() { return getToken(ProgramParser.DOTS, 0); }
		public LabelContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_label; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterLabel(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitLabel(this);
		}
	}

	public final LabelContext label() throws RecognitionException {
		LabelContext _localctx = new LabelContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_label);
		try {
			setState(136);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case AT:
				enterOuterAlt(_localctx, 1);
				{
				setState(131);
				match(AT);
				}
				break;
			case NAME:
				enterOuterAlt(_localctx, 2);
				{
				setState(132);
				match(NAME);
				setState(134);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
				case 1:
					{
					setState(133);
					match(DOTS);
					}
					break;
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TailContext extends ParserRuleContext {
		public List EOL() { return getTokens(ProgramParser.EOL); }
		public TerminalNode EOL(int i) {
			return getToken(ProgramParser.EOL, i);
		}
		public TerminalNode TAB() { return getToken(ProgramParser.TAB, 0); }
		public TerminalNode UNTAB() { return getToken(ProgramParser.UNTAB, 0); }
		public List object() {
			return getRuleContexts(ObjectContext.class);
		}
		public ObjectContext object(int i) {
			return getRuleContext(ObjectContext.class,i);
		}
		public TailContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tail; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterTail(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitTail(this);
		}
	}

	public final TailContext tail() throws RecognitionException {
		TailContext _localctx = new TailContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_tail);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(138);
			match(EOL);
			setState(139);
			match(TAB);
			setState(143); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(140);
				object();
				setState(141);
				match(EOL);
				}
				}
				setState(145); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << COMMENT) | (1L << REGEX) | (1L << STAR) | (1L << SELF) | (1L << LSQ) | (1L << LB) | (1L << AT) | (1L << PARENT) | (1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX) | (1L << NAME))) != 0) );
			setState(147);
			match(UNTAB);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SuffixContext extends ParserRuleContext {
		public List SPACE() { return getTokens(ProgramParser.SPACE); }
		public TerminalNode SPACE(int i) {
			return getToken(ProgramParser.SPACE, i);
		}
		public TerminalNode ARROW() { return getToken(ProgramParser.ARROW, 0); }
		public LabelContext label() {
			return getRuleContext(LabelContext.class,0);
		}
		public TerminalNode CONST() { return getToken(ProgramParser.CONST, 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 ProgramListener ) ((ProgramListener)listener).enterSuffix(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitSuffix(this);
		}
	}

	public final SuffixContext suffix() throws RecognitionException {
		SuffixContext _localctx = new SuffixContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_suffix);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(149);
			match(SPACE);
			setState(150);
			match(ARROW);
			setState(151);
			match(SPACE);
			setState(152);
			label();
			setState(154);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(153);
				match(CONST);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MethodContext extends ParserRuleContext {
		public TerminalNode DOT() { return getToken(ProgramParser.DOT, 0); }
		public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
		public TerminalNode PARENT() { return getToken(ProgramParser.PARENT, 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 ProgramListener ) ((ProgramListener)listener).enterMethod(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitMethod(this);
		}
	}

	public final MethodContext method() throws RecognitionException {
		MethodContext _localctx = new MethodContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_method);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(156);
			match(DOT);
			setState(157);
			_la = _input.LA(1);
			if ( !(_la==PARENT || _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;
	}

	public static class ApplicationContext extends ParserRuleContext {
		public HeadContext head() {
			return getRuleContext(HeadContext.class,0);
		}
		public HtailContext htail() {
			return getRuleContext(HtailContext.class,0);
		}
		public TerminalNode LB() { return getToken(ProgramParser.LB, 0); }
		public ApplicationContext application() {
			return getRuleContext(ApplicationContext.class,0);
		}
		public TerminalNode RB() { return getToken(ProgramParser.RB, 0); }
		public MethodContext method() {
			return getRuleContext(MethodContext.class,0);
		}
		public HasContext has() {
			return getRuleContext(HasContext.class,0);
		}
		public SuffixContext suffix() {
			return getRuleContext(SuffixContext.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 ProgramListener ) ((ProgramListener)listener).enterApplication(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitApplication(this);
		}
	}

	public final ApplicationContext application() throws RecognitionException {
		return application(0);
	}

	private ApplicationContext application(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		ApplicationContext _localctx = new ApplicationContext(_ctx, _parentState);
		ApplicationContext _prevctx = _localctx;
		int _startState = 26;
		enterRecursionRule(_localctx, 26, RULE_application, _p);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(170);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case REGEX:
			case STAR:
			case SELF:
			case AT:
			case PARENT:
			case BYTES:
			case BOOL:
			case CHAR:
			case STRING:
			case INT:
			case FLOAT:
			case HEX:
			case NAME:
				{
				setState(160);
				head();
				setState(162);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
				case 1:
					{
					setState(161);
					htail();
					}
					break;
				}
				}
				break;
			case LB:
				{
				setState(164);
				match(LB);
				setState(165);
				application(0);
				setState(166);
				match(RB);
				setState(168);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
				case 1:
					{
					setState(167);
					htail();
					}
					break;
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			_ctx.stop = _input.LT(-1);
			setState(189);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(187);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
					case 1:
						{
						_localctx = new ApplicationContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_application);
						setState(172);
						if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
						setState(173);
						method();
						setState(175);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
						case 1:
							{
							setState(174);
							htail();
							}
							break;
						}
						}
						break;
					case 2:
						{
						_localctx = new ApplicationContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_application);
						setState(177);
						if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
						setState(178);
						has();
						setState(180);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
						case 1:
							{
							setState(179);
							htail();
							}
							break;
						}
						}
						break;
					case 3:
						{
						_localctx = new ApplicationContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_application);
						setState(182);
						if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
						setState(183);
						suffix();
						setState(185);
						_errHandler.sync(this);
						switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
						case 1:
							{
							setState(184);
							htail();
							}
							break;
						}
						}
						break;
					}
					} 
				}
				setState(191);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public static class HtailContext extends ParserRuleContext {
		public List SPACE() { return getTokens(ProgramParser.SPACE); }
		public TerminalNode SPACE(int i) {
			return getToken(ProgramParser.SPACE, i);
		}
		public List head() {
			return getRuleContexts(HeadContext.class);
		}
		public HeadContext head(int i) {
			return getRuleContext(HeadContext.class,i);
		}
		public List application() {
			return getRuleContexts(ApplicationContext.class);
		}
		public ApplicationContext application(int i) {
			return getRuleContext(ApplicationContext.class,i);
		}
		public List method() {
			return getRuleContexts(MethodContext.class);
		}
		public MethodContext method(int i) {
			return getRuleContext(MethodContext.class,i);
		}
		public List LB() { return getTokens(ProgramParser.LB); }
		public TerminalNode LB(int i) {
			return getToken(ProgramParser.LB, i);
		}
		public List RB() { return getTokens(ProgramParser.RB); }
		public TerminalNode RB(int i) {
			return getToken(ProgramParser.RB, i);
		}
		public List has() {
			return getRuleContexts(HasContext.class);
		}
		public HasContext has(int i) {
			return getRuleContext(HasContext.class,i);
		}
		public List suffix() {
			return getRuleContexts(SuffixContext.class);
		}
		public SuffixContext suffix(int i) {
			return getRuleContext(SuffixContext.class,i);
		}
		public List anonymous() {
			return getRuleContexts(AnonymousContext.class);
		}
		public AnonymousContext anonymous(int i) {
			return getRuleContext(AnonymousContext.class,i);
		}
		public HtailContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_htail; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHtail(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHtail(this);
		}
	}

	public final HtailContext htail() throws RecognitionException {
		HtailContext _localctx = new HtailContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_htail);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(213); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					setState(213);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
					case 1:
						{
						setState(192);
						match(SPACE);
						setState(193);
						head();
						}
						break;
					case 2:
						{
						setState(194);
						match(SPACE);
						setState(195);
						application(0);
						setState(196);
						method();
						}
						break;
					case 3:
						{
						setState(198);
						match(SPACE);
						setState(199);
						match(LB);
						setState(200);
						application(0);
						setState(201);
						match(RB);
						}
						break;
					case 4:
						{
						setState(203);
						match(SPACE);
						setState(204);
						application(0);
						setState(205);
						has();
						}
						break;
					case 5:
						{
						setState(207);
						match(SPACE);
						setState(208);
						application(0);
						setState(209);
						suffix();
						}
						break;
					case 6:
						{
						setState(211);
						match(SPACE);
						setState(212);
						anonymous();
						}
						break;
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(215); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HeadContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(ProgramParser.AT, 0); }
		public TerminalNode PARENT() { return getToken(ProgramParser.PARENT, 0); }
		public TerminalNode SELF() { return getToken(ProgramParser.SELF, 0); }
		public TerminalNode STAR() { return getToken(ProgramParser.STAR, 0); }
		public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
		public TerminalNode DOT() { return getToken(ProgramParser.DOT, 0); }
		public DataContext data() {
			return getRuleContext(DataContext.class,0);
		}
		public HeadContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_head; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHead(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHead(this);
		}
	}

	public final HeadContext head() throws RecognitionException {
		HeadContext _localctx = new HeadContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_head);
		try {
			setState(225);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(217);
				match(AT);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(218);
				match(PARENT);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(219);
				match(SELF);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(220);
				match(STAR);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(221);
				match(NAME);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(222);
				match(NAME);
				setState(223);
				match(DOT);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(224);
				data();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HasContext extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(ProgramParser.COLON, 0); }
		public TerminalNode NAME() { return getToken(ProgramParser.NAME, 0); }
		public HasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_has; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).enterHas(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitHas(this);
		}
	}

	public final HasContext has() throws RecognitionException {
		HasContext _localctx = new HasContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_has);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(227);
			match(COLON);
			setState(228);
			match(NAME);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DataContext extends ParserRuleContext {
		public TerminalNode BYTES() { return getToken(ProgramParser.BYTES, 0); }
		public TerminalNode BOOL() { return getToken(ProgramParser.BOOL, 0); }
		public TerminalNode STRING() { return getToken(ProgramParser.STRING, 0); }
		public TerminalNode INT() { return getToken(ProgramParser.INT, 0); }
		public TerminalNode FLOAT() { return getToken(ProgramParser.FLOAT, 0); }
		public TerminalNode HEX() { return getToken(ProgramParser.HEX, 0); }
		public TerminalNode CHAR() { return getToken(ProgramParser.CHAR, 0); }
		public TerminalNode REGEX() { return getToken(ProgramParser.REGEX, 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 ProgramListener ) ((ProgramListener)listener).enterData(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ProgramListener ) ((ProgramListener)listener).exitData(this);
		}
	}

	public final DataContext data() throws RecognitionException {
		DataContext _localctx = new DataContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_data);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(230);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REGEX) | (1L << BYTES) | (1L << BOOL) | (1L << CHAR) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << HEX))) != 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 13:
			return application_sempred((ApplicationContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean application_sempred(ApplicationContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 4);
		case 1:
			return precpred(_ctx, 2);
		case 2:
			return precpred(_ctx, 1);
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\"\u00eb\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\3\2\5\2(\n\2\3\2\5\2+\n\2\3\2\3\2\3\2\3\3\3\3\6\3\62\n\3\r"+
		"\3\16\3\63\3\4\3\4\6\48\n\4\r\4\16\49\3\5\3\5\7\5>\n\5\f\5\16\5A\13\5"+
		"\3\5\3\5\3\5\6\5F\n\5\r\5\16\5G\3\6\3\6\3\6\5\6M\n\6\3\6\5\6P\n\6\3\6"+
		"\3\6\3\6\5\6U\n\6\3\6\5\6X\n\6\3\6\5\6[\n\6\7\6]\n\6\f\6\16\6`\13\6\5"+
		"\6b\n\6\3\7\3\7\3\7\3\b\3\b\7\bi\n\b\f\b\16\bl\13\b\3\b\3\b\3\b\3\b\3"+
		"\b\5\bs\n\b\5\bu\n\b\3\t\3\t\3\t\3\t\7\t{\n\t\f\t\16\t~\13\t\5\t\u0080"+
		"\n\t\3\t\3\t\3\n\3\n\3\13\3\13\3\13\5\13\u0089\n\13\5\13\u008b\n\13\3"+
		"\f\3\f\3\f\3\f\3\f\6\f\u0092\n\f\r\f\16\f\u0093\3\f\3\f\3\r\3\r\3\r\3"+
		"\r\3\r\5\r\u009d\n\r\3\16\3\16\3\16\3\17\3\17\3\17\5\17\u00a5\n\17\3\17"+
		"\3\17\3\17\3\17\5\17\u00ab\n\17\5\17\u00ad\n\17\3\17\3\17\3\17\5\17\u00b2"+
		"\n\17\3\17\3\17\3\17\5\17\u00b7\n\17\3\17\3\17\3\17\5\17\u00bc\n\17\7"+
		"\17\u00be\n\17\f\17\16\17\u00c1\13\17\3\20\3\20\3\20\3\20\3\20\3\20\3"+
		"\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3"+
		"\20\6\20\u00d8\n\20\r\20\16\20\u00d9\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
		"\3\21\5\21\u00e4\n\21\3\22\3\22\3\22\3\23\3\23\3\23\2\3\34\24\2\4\6\b"+
		"\n\f\16\20\22\24\26\30\32\34\36 \"$\2\4\4\2\26\26  \4\2\5\5\31\37\2\u0103"+
		"\2\'\3\2\2\2\4\61\3\2\2\2\6\67\3\2\2\2\bE\3\2\2\2\na\3\2\2\2\fc\3\2\2"+
		"\2\16j\3\2\2\2\20v\3\2\2\2\22\u0083\3\2\2\2\24\u008a\3\2\2\2\26\u008c"+
		"\3\2\2\2\30\u0097\3\2\2\2\32\u009e\3\2\2\2\34\u00ac\3\2\2\2\36\u00d7\3"+
		"\2\2\2 \u00e3\3\2\2\2\"\u00e5\3\2\2\2$\u00e8\3\2\2\2&(\5\4\3\2\'&\3\2"+
		"\2\2\'(\3\2\2\2(*\3\2\2\2)+\5\6\4\2*)\3\2\2\2*+\3\2\2\2+,\3\2\2\2,-\5"+
		"\b\5\2-.\7\2\2\3.\3\3\2\2\2/\60\7\3\2\2\60\62\7\30\2\2\61/\3\2\2\2\62"+
		"\63\3\2\2\2\63\61\3\2\2\2\63\64\3\2\2\2\64\5\3\2\2\2\65\66\7\4\2\2\66"+
		"8\7\30\2\2\67\65\3\2\2\289\3\2\2\29\67\3\2\2\29:\3\2\2\2:\7\3\2\2\2;<"+
		"\7\3\2\2<>\7\30\2\2=;\3\2\2\2>A\3\2\2\2?=\3\2\2\2?@\3\2\2\2@B\3\2\2\2"+
		"A?\3\2\2\2BC\5\n\6\2CD\7\30\2\2DF\3\2\2\2E?\3\2\2\2FG\3\2\2\2GE\3\2\2"+
		"\2GH\3\2\2\2H\t\3\2\2\2Ib\5\f\7\2JM\5\16\b\2KM\5\34\17\2LJ\3\2\2\2LK\3"+
		"\2\2\2MO\3\2\2\2NP\5\26\f\2ON\3\2\2\2OP\3\2\2\2P^\3\2\2\2QR\7\30\2\2R"+
		"T\5\32\16\2SU\5\36\20\2TS\3\2\2\2TU\3\2\2\2UW\3\2\2\2VX\5\30\r\2WV\3\2"+
		"\2\2WX\3\2\2\2XZ\3\2\2\2Y[\5\26\f\2ZY\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\Q\3"+
		"\2\2\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_b\3\2\2\2`^\3\2\2\2aI\3\2\2\2aL"+
		"\3\2\2\2b\13\3\2\2\2cd\5\20\t\2de\5\36\20\2e\r\3\2\2\2fg\7\3\2\2gi\7\30"+
		"\2\2hf\3\2\2\2il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2\2mt\5\20"+
		"\t\2nr\5\30\r\2op\7\17\2\2pq\7\t\2\2qs\7 \2\2ro\3\2\2\2rs\3\2\2\2su\3"+
		"\2\2\2tn\3\2\2\2tu\3\2\2\2u\17\3\2\2\2v\177\7\21\2\2w|\5\22\n\2xy\7\17"+
		"\2\2y{\5\22\n\2zx\3\2\2\2{~\3\2\2\2|z\3\2\2\2|}\3\2\2\2}\u0080\3\2\2\2"+
		"~|\3\2\2\2\177w\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u0082"+
		"\7\22\2\2\u0082\21\3\2\2\2\u0083\u0084\5\24\13\2\u0084\23\3\2\2\2\u0085"+
		"\u008b\7\25\2\2\u0086\u0088\7 \2\2\u0087\u0089\7\7\2\2\u0088\u0087\3\2"+
		"\2\2\u0088\u0089\3\2\2\2\u0089\u008b\3\2\2\2\u008a\u0085\3\2\2\2\u008a"+
		"\u0086\3\2\2\2\u008b\25\3\2\2\2\u008c\u008d\7\30\2\2\u008d\u0091\7!\2"+
		"\2\u008e\u008f\5\n\6\2\u008f\u0090\7\30\2\2\u0090\u0092\3\2\2\2\u0091"+
		"\u008e\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2"+
		"\2\2\u0094\u0095\3\2\2\2\u0095\u0096\7\"\2\2\u0096\27\3\2\2\2\u0097\u0098"+
		"\7\17\2\2\u0098\u0099\7\13\2\2\u0099\u009a\7\17\2\2\u009a\u009c\5\24\13"+
		"\2\u009b\u009d\7\b\2\2\u009c\u009b\3\2\2\2\u009c\u009d\3\2\2\2\u009d\31"+
		"\3\2\2\2\u009e\u009f\7\20\2\2\u009f\u00a0\t\2\2\2\u00a0\33\3\2\2\2\u00a1"+
		"\u00a2\b\17\1\2\u00a2\u00a4\5 \21\2\u00a3\u00a5\5\36\20\2\u00a4\u00a3"+
		"\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00ad\3\2\2\2\u00a6\u00a7\7\23\2\2"+
		"\u00a7\u00a8\5\34\17\2\u00a8\u00aa\7\24\2\2\u00a9\u00ab\5\36\20\2\u00aa"+
		"\u00a9\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ad\3\2\2\2\u00ac\u00a1\3\2"+
		"\2\2\u00ac\u00a6\3\2\2\2\u00ad\u00bf\3\2\2\2\u00ae\u00af\f\6\2\2\u00af"+
		"\u00b1\5\32\16\2\u00b0\u00b2\5\36\20\2\u00b1\u00b0\3\2\2\2\u00b1\u00b2"+
		"\3\2\2\2\u00b2\u00be\3\2\2\2\u00b3\u00b4\f\4\2\2\u00b4\u00b6\5\"\22\2"+
		"\u00b5\u00b7\5\36\20\2\u00b6\u00b5\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00be"+
		"\3\2\2\2\u00b8\u00b9\f\3\2\2\u00b9\u00bb\5\30\r\2\u00ba\u00bc\5\36\20"+
		"\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00be\3\2\2\2\u00bd\u00ae"+
		"\3\2\2\2\u00bd\u00b3\3\2\2\2\u00bd\u00b8\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf"+
		"\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\35\3\2\2\2\u00c1\u00bf\3\2\2"+
		"\2\u00c2\u00c3\7\17\2\2\u00c3\u00d8\5 \21\2\u00c4\u00c5\7\17\2\2\u00c5"+
		"\u00c6\5\34\17\2\u00c6\u00c7\5\32\16\2\u00c7\u00d8\3\2\2\2\u00c8\u00c9"+
		"\7\17\2\2\u00c9\u00ca\7\23\2\2\u00ca\u00cb\5\34\17\2\u00cb\u00cc\7\24"+
		"\2\2\u00cc\u00d8\3\2\2\2\u00cd\u00ce\7\17\2\2\u00ce\u00cf\5\34\17\2\u00cf"+
		"\u00d0\5\"\22\2\u00d0\u00d8\3\2\2\2\u00d1\u00d2\7\17\2\2\u00d2\u00d3\5"+
		"\34\17\2\u00d3\u00d4\5\30\r\2\u00d4\u00d8\3\2\2\2\u00d5\u00d6\7\17\2\2"+
		"\u00d6\u00d8\5\f\7\2\u00d7\u00c2\3\2\2\2\u00d7\u00c4\3\2\2\2\u00d7\u00c8"+
		"\3\2\2\2\u00d7\u00cd\3\2\2\2\u00d7\u00d1\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8"+
		"\u00d9\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\37\3\2\2"+
		"\2\u00db\u00e4\7\25\2\2\u00dc\u00e4\7\26\2\2\u00dd\u00e4\7\f\2\2\u00de"+
		"\u00e4\7\6\2\2\u00df\u00e4\7 \2\2\u00e0\u00e1\7 \2\2\u00e1\u00e4\7\20"+
		"\2\2\u00e2\u00e4\5$\23\2\u00e3\u00db\3\2\2\2\u00e3\u00dc\3\2\2\2\u00e3"+
		"\u00dd\3\2\2\2\u00e3\u00de\3\2\2\2\u00e3\u00df\3\2\2\2\u00e3\u00e0\3\2"+
		"\2\2\u00e3\u00e2\3\2\2\2\u00e4!\3\2\2\2\u00e5\u00e6\7\n\2\2\u00e6\u00e7"+
		"\7 \2\2\u00e7#\3\2\2\2\u00e8\u00e9\t\3\2\2\u00e9%\3\2\2\2#\'*\639?GLO"+
		"TWZ^ajrt|\177\u0088\u008a\u0093\u009c\u00a4\u00aa\u00ac\u00b1\u00b6\u00bb"+
		"\u00bd\u00bf\u00d7\u00d9\u00e3";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy