ManifestParser.java

// Generated from io/earcam/instrumental/module/osgi/parser/Manifest.g4 by ANTLR 4.7.1
package io.earcam.instrumental.module.osgi.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"})
class ManifestParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, Alpha=24, 
		AlphaNum=25, Number=26, Digit=27, Path=28, Extended=29, QuotedString=30, 
		NL=31, WS=32, UniqueName=33, Identifier=34, ANYCHAR=35;
	public static final int
		RULE_manifest = 0, RULE_bundleManifestVersion = 1, RULE_bundleActivator = 2, 
		RULE_symbolicName = 3, RULE_fragmentHost = 4, RULE_manifestAttributes = 5, 
		RULE_manifestAttribute = 6, RULE_dynamicImports = 7, RULE_dynamicDescription = 8, 
		RULE_wildcardName = 9, RULE_imports = 10, RULE_exports = 11, RULE_port = 12, 
		RULE_paquet = 13, RULE_parameter = 14, RULE_directive = 15, RULE_attribute = 16, 
		RULE_argument = 17, RULE_anything = 18, RULE_genericManifestEntry = 19;
	public static final String[] ruleNames = {
		"manifest", "bundleManifestVersion", "bundleActivator", "symbolicName", 
		"fragmentHost", "manifestAttributes", "manifestAttribute", "dynamicImports", 
		"dynamicDescription", "wildcardName", "imports", "exports", "port", "paquet", 
		"parameter", "directive", "attribute", "argument", "anything", "genericManifestEntry"
	};

	private static final String[] _LITERAL_NAMES = {
		null, "'Manifest-Version'", "': '", "'Bundle-ManifestVersion'", "'Bundle-Activator'", 
		"'Bundle-SymbolicName'", "';'", "'Fragment-Host'", "'DynamicImport-Package'", 
		"','", "'*'", "'Import-Package: '", "'Export-Package: '", "':='", "'='", 
		"'@'", "':'", "'&'", "'('", "')'", "'!'", "'~'", "'+'", "'$'"
	};
	private static final String[] _SYMBOLIC_NAMES = {
		null, null, null, null, null, null, null, null, null, null, null, null, 
		null, null, null, null, null, null, null, null, null, null, null, null, 
		"Alpha", "AlphaNum", "Number", "Digit", "Path", "Extended", "QuotedString", 
		"NL", "WS", "UniqueName", "Identifier", "ANYCHAR"
	};
	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] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "Manifest.g4"; }

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

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

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

	public ManifestParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ManifestContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public List<TerminalNode> NL() { return getTokens(ManifestParser.NL); }
		public TerminalNode NL(int i) {
			return getToken(ManifestParser.NL, i);
		}
		public TerminalNode EOF() { return getToken(ManifestParser.EOF, 0); }
		public List<ImportsContext> imports() {
			return getRuleContexts(ImportsContext.class);
		}
		public ImportsContext imports(int i) {
			return getRuleContext(ImportsContext.class,i);
		}
		public List<ExportsContext> exports() {
			return getRuleContexts(ExportsContext.class);
		}
		public ExportsContext exports(int i) {
			return getRuleContext(ExportsContext.class,i);
		}
		public List<SymbolicNameContext> symbolicName() {
			return getRuleContexts(SymbolicNameContext.class);
		}
		public SymbolicNameContext symbolicName(int i) {
			return getRuleContext(SymbolicNameContext.class,i);
		}
		public List<BundleManifestVersionContext> bundleManifestVersion() {
			return getRuleContexts(BundleManifestVersionContext.class);
		}
		public BundleManifestVersionContext bundleManifestVersion(int i) {
			return getRuleContext(BundleManifestVersionContext.class,i);
		}
		public List<BundleActivatorContext> bundleActivator() {
			return getRuleContexts(BundleActivatorContext.class);
		}
		public BundleActivatorContext bundleActivator(int i) {
			return getRuleContext(BundleActivatorContext.class,i);
		}
		public List<FragmentHostContext> fragmentHost() {
			return getRuleContexts(FragmentHostContext.class);
		}
		public FragmentHostContext fragmentHost(int i) {
			return getRuleContext(FragmentHostContext.class,i);
		}
		public List<DynamicImportsContext> dynamicImports() {
			return getRuleContexts(DynamicImportsContext.class);
		}
		public DynamicImportsContext dynamicImports(int i) {
			return getRuleContext(DynamicImportsContext.class,i);
		}
		public List<GenericManifestEntryContext> genericManifestEntry() {
			return getRuleContexts(GenericManifestEntryContext.class);
		}
		public GenericManifestEntryContext genericManifestEntry(int i) {
			return getRuleContext(GenericManifestEntryContext.class,i);
		}
		public ManifestAttributesContext manifestAttributes() {
			return getRuleContext(ManifestAttributesContext.class,0);
		}
		public ManifestContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_manifest; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifest(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifest(this);
		}
	}

	public final ManifestContext manifest() throws RecognitionException {
		ManifestContext _localctx = new ManifestContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_manifest);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(40);
			match(T__0);
			setState(41);
			match(T__1);
			setState(42);
			match(Extended);
			setState(43);
			match(NL);
			setState(54);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__6) | (1L << T__7) | (1L << T__10) | (1L << T__11) | (1L << Extended))) != 0)) {
				{
				setState(52);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case T__10:
					{
					setState(44);
					imports();
					}
					break;
				case T__11:
					{
					setState(45);
					exports();
					}
					break;
				case T__4:
					{
					setState(46);
					symbolicName();
					}
					break;
				case T__2:
					{
					setState(47);
					bundleManifestVersion();
					}
					break;
				case T__3:
					{
					setState(48);
					bundleActivator();
					}
					break;
				case T__6:
					{
					setState(49);
					fragmentHost();
					}
					break;
				case T__7:
					{
					setState(50);
					dynamicImports();
					}
					break;
				case Extended:
					{
					setState(51);
					genericManifestEntry();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(56);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(57);
			match(NL);
			setState(59);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Extended) {
				{
				setState(58);
				manifestAttributes();
				}
			}

			setState(64);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==NL) {
				{
				{
				setState(61);
				match(NL);
				}
				}
				setState(66);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(67);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BundleManifestVersionContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public TerminalNode Number() { return getToken(ManifestParser.Number, 0); }
		public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
		public TerminalNode Digit() { return getToken(ManifestParser.Digit, 0); }
		public BundleManifestVersionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bundleManifestVersion; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleManifestVersion(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleManifestVersion(this);
		}
	}

	public final BundleManifestVersionContext bundleManifestVersion() throws RecognitionException {
		BundleManifestVersionContext _localctx = new BundleManifestVersionContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_bundleManifestVersion);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(69);
			match(T__2);
			setState(70);
			match(T__1);
			setState(71);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Number) | (1L << Digit))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(72);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BundleActivatorContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public BundleActivatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bundleActivator; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterBundleActivator(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitBundleActivator(this);
		}
	}

	public final BundleActivatorContext bundleActivator() throws RecognitionException {
		BundleActivatorContext _localctx = new BundleActivatorContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_bundleActivator);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(74);
			match(T__3);
			setState(75);
			match(T__1);
			setState(76);
			_la = _input.LA(1);
			if ( !(_la==Extended || _la==UniqueName) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(77);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SymbolicNameContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<ParameterContext> parameter() {
			return getRuleContexts(ParameterContext.class);
		}
		public ParameterContext parameter(int i) {
			return getRuleContext(ParameterContext.class,i);
		}
		public SymbolicNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_symbolicName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterSymbolicName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitSymbolicName(this);
		}
	}

	public final SymbolicNameContext symbolicName() throws RecognitionException {
		SymbolicNameContext _localctx = new SymbolicNameContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_symbolicName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(79);
			match(T__4);
			setState(80);
			match(T__1);
			setState(81);
			match(Extended);
			setState(86);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__5) {
				{
				{
				setState(82);
				match(T__5);
				setState(83);
				parameter();
				}
				}
				setState(88);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(89);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FragmentHostContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<ParameterContext> parameter() {
			return getRuleContexts(ParameterContext.class);
		}
		public ParameterContext parameter(int i) {
			return getRuleContext(ParameterContext.class,i);
		}
		public FragmentHostContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fragmentHost; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterFragmentHost(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitFragmentHost(this);
		}
	}

	public final FragmentHostContext fragmentHost() throws RecognitionException {
		FragmentHostContext _localctx = new FragmentHostContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_fragmentHost);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(91);
			match(T__6);
			setState(92);
			match(T__1);
			setState(93);
			match(Extended);
			setState(98);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__5) {
				{
				{
				setState(94);
				match(T__5);
				setState(95);
				parameter();
				}
				}
				setState(100);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(101);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ManifestAttributesContext extends ParserRuleContext {
		public List<ManifestAttributeContext> manifestAttribute() {
			return getRuleContexts(ManifestAttributeContext.class);
		}
		public ManifestAttributeContext manifestAttribute(int i) {
			return getRuleContext(ManifestAttributeContext.class,i);
		}
		public ManifestAttributesContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_manifestAttributes; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttributes(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttributes(this);
		}
	}

	public final ManifestAttributesContext manifestAttributes() throws RecognitionException {
		ManifestAttributesContext _localctx = new ManifestAttributesContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_manifestAttributes);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(104); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(103);
				manifestAttribute();
				}
				}
				setState(106); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==Extended );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ManifestAttributeContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<GenericManifestEntryContext> genericManifestEntry() {
			return getRuleContexts(GenericManifestEntryContext.class);
		}
		public GenericManifestEntryContext genericManifestEntry(int i) {
			return getRuleContext(GenericManifestEntryContext.class,i);
		}
		public ManifestAttributeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_manifestAttribute; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterManifestAttribute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitManifestAttribute(this);
		}
	}

	public final ManifestAttributeContext manifestAttribute() throws RecognitionException {
		ManifestAttributeContext _localctx = new ManifestAttributeContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_manifestAttribute);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(109); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(108);
				genericManifestEntry();
				}
				}
				setState(111); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==Extended );
			setState(113);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DynamicImportsContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<DynamicDescriptionContext> dynamicDescription() {
			return getRuleContexts(DynamicDescriptionContext.class);
		}
		public DynamicDescriptionContext dynamicDescription(int i) {
			return getRuleContext(DynamicDescriptionContext.class,i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public DynamicImportsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dynamicImports; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicImports(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicImports(this);
		}
	}

	public final DynamicImportsContext dynamicImports() throws RecognitionException {
		DynamicImportsContext _localctx = new DynamicImportsContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_dynamicImports);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(115);
			match(T__7);
			setState(116);
			match(T__1);
			setState(131);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
			case 1:
				{
				setState(117);
				dynamicDescription();
				}
				break;
			case 2:
				{
				setState(118);
				dynamicDescription();
				setState(127); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(119);
					match(T__8);
					setState(123);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==WS) {
						{
						{
						setState(120);
						match(WS);
						}
						}
						setState(125);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(126);
					dynamicDescription();
					}
					}
					setState(129); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==T__8 );
				}
				break;
			}
			setState(133);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DynamicDescriptionContext extends ParserRuleContext {
		public List<WildcardNameContext> wildcardName() {
			return getRuleContexts(WildcardNameContext.class);
		}
		public WildcardNameContext wildcardName(int i) {
			return getRuleContext(WildcardNameContext.class,i);
		}
		public List<ParameterContext> parameter() {
			return getRuleContexts(ParameterContext.class);
		}
		public ParameterContext parameter(int i) {
			return getRuleContext(ParameterContext.class,i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public DynamicDescriptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_dynamicDescription; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDynamicDescription(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDynamicDescription(this);
		}
	}

	public final DynamicDescriptionContext dynamicDescription() throws RecognitionException {
		DynamicDescriptionContext _localctx = new DynamicDescriptionContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_dynamicDescription);
		int _la;
		try {
			int _alt;
			setState(169);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(135);
				wildcardName();
				setState(146);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
				while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1+1 ) {
						{
						{
						setState(136);
						match(T__5);
						setState(140);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==WS) {
							{
							{
							setState(137);
							match(WS);
							}
							}
							setState(142);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						setState(143);
						parameter();
						}
						} 
					}
					setState(148);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(149);
				wildcardName();
				setState(158); 
				_errHandler.sync(this);
				_alt = 1+1;
				do {
					switch (_alt) {
					case 1+1:
						{
						{
						setState(150);
						match(T__5);
						setState(154);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==WS) {
							{
							{
							setState(151);
							match(WS);
							}
							}
							setState(156);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						setState(157);
						wildcardName();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(160); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
				} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				setState(166);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__5) {
					{
					{
					setState(162);
					match(T__5);
					setState(163);
					parameter();
					}
					}
					setState(168);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class WildcardNameContext extends ParserRuleContext {
		public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
		public TerminalNode UniqueName(int i) {
			return getToken(ManifestParser.UniqueName, i);
		}
		public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
		public TerminalNode Extended(int i) {
			return getToken(ManifestParser.Extended, i);
		}
		public PaquetContext paquet() {
			return getRuleContext(PaquetContext.class,0);
		}
		public WildcardNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_wildcardName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterWildcardName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitWildcardName(this);
		}
	}

	public final WildcardNameContext wildcardName() throws RecognitionException {
		WildcardNameContext _localctx = new WildcardNameContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_wildcardName);
		int _la;
		try {
			int _alt;
			setState(179);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(172); 
				_errHandler.sync(this);
				_alt = 1+1;
				do {
					switch (_alt) {
					case 1+1:
						{
						{
						setState(171);
						_la = _input.LA(1);
						if ( !(_la==Extended || _la==UniqueName) ) {
						_errHandler.recoverInline(this);
						}
						else {
							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
							_errHandler.reportMatch(this);
							consume();
						}
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(174); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
				} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				setState(176);
				match(T__9);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(177);
				paquet();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(178);
				match(T__9);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImportsContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<PortContext> port() {
			return getRuleContexts(PortContext.class);
		}
		public PortContext port(int i) {
			return getRuleContext(PortContext.class,i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public ImportsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_imports; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterImports(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitImports(this);
		}
	}

	public final ImportsContext imports() throws RecognitionException {
		ImportsContext _localctx = new ImportsContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_imports);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(181);
			match(T__10);
			setState(196);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(182);
				port();
				}
				break;
			case 2:
				{
				setState(183);
				port();
				setState(192); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(184);
					match(T__8);
					setState(188);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==WS) {
						{
						{
						setState(185);
						match(WS);
						}
						}
						setState(190);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(191);
					port();
					}
					}
					setState(194); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==T__8 );
				}
				break;
			}
			setState(198);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExportsContext extends ParserRuleContext {
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public List<PortContext> port() {
			return getRuleContexts(PortContext.class);
		}
		public PortContext port(int i) {
			return getRuleContext(PortContext.class,i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public ExportsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exports; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterExports(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitExports(this);
		}
	}

	public final ExportsContext exports() throws RecognitionException {
		ExportsContext _localctx = new ExportsContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_exports);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(200);
			match(T__11);
			setState(215);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
			case 1:
				{
				setState(201);
				port();
				}
				break;
			case 2:
				{
				setState(202);
				port();
				setState(211); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(203);
					match(T__8);
					setState(207);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==WS) {
						{
						{
						setState(204);
						match(WS);
						}
						}
						setState(209);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(210);
					port();
					}
					}
					setState(213); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==T__8 );
				}
				break;
			}
			setState(217);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PortContext extends ParserRuleContext {
		public List<PaquetContext> paquet() {
			return getRuleContexts(PaquetContext.class);
		}
		public PaquetContext paquet(int i) {
			return getRuleContext(PaquetContext.class,i);
		}
		public List<ParameterContext> parameter() {
			return getRuleContexts(ParameterContext.class);
		}
		public ParameterContext parameter(int i) {
			return getRuleContext(ParameterContext.class,i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public PortContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_port; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPort(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPort(this);
		}
	}

	public final PortContext port() throws RecognitionException {
		PortContext _localctx = new PortContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_port);
		int _la;
		try {
			int _alt;
			setState(253);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(219);
				paquet();
				setState(230);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
				while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1+1 ) {
						{
						{
						setState(220);
						match(T__5);
						setState(224);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==WS) {
							{
							{
							setState(221);
							match(WS);
							}
							}
							setState(226);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						setState(227);
						parameter();
						}
						} 
					}
					setState(232);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(233);
				paquet();
				setState(242); 
				_errHandler.sync(this);
				_alt = 1+1;
				do {
					switch (_alt) {
					case 1+1:
						{
						{
						setState(234);
						match(T__5);
						setState(238);
						_errHandler.sync(this);
						_la = _input.LA(1);
						while (_la==WS) {
							{
							{
							setState(235);
							match(WS);
							}
							}
							setState(240);
							_errHandler.sync(this);
							_la = _input.LA(1);
						}
						setState(241);
						paquet();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					setState(244); 
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
				} while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
				setState(250);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==T__5) {
					{
					{
					setState(246);
					match(T__5);
					setState(247);
					parameter();
					}
					}
					setState(252);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PaquetContext extends ParserRuleContext {
		public TerminalNode UniqueName() { return getToken(ManifestParser.UniqueName, 0); }
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public PaquetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paquet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterPaquet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitPaquet(this);
		}
	}

	public final PaquetContext paquet() throws RecognitionException {
		PaquetContext _localctx = new PaquetContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_paquet);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(255);
			_la = _input.LA(1);
			if ( !(_la==Extended || _la==UniqueName) ) {
			_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 ParameterContext extends ParserRuleContext {
		public DirectiveContext directive() {
			return getRuleContext(DirectiveContext.class,0);
		}
		public AttributeContext attribute() {
			return getRuleContext(AttributeContext.class,0);
		}
		public ParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameter; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterParameter(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitParameter(this);
		}
	}

	public final ParameterContext parameter() throws RecognitionException {
		ParameterContext _localctx = new ParameterContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_parameter);
		try {
			setState(259);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(257);
				directive();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(258);
				attribute();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DirectiveContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public ArgumentContext argument() {
			return getRuleContext(ArgumentContext.class,0);
		}
		public DirectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_directive; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterDirective(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitDirective(this);
		}
	}

	public final DirectiveContext directive() throws RecognitionException {
		DirectiveContext _localctx = new DirectiveContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_directive);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(261);
			match(Extended);
			setState(262);
			match(T__12);
			setState(263);
			argument();
			}
		}
		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 TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public ArgumentContext argument() {
			return getRuleContext(ArgumentContext.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 ManifestListener ) ((ManifestListener)listener).enterAttribute(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAttribute(this);
		}
	}

	public final AttributeContext attribute() throws RecognitionException {
		AttributeContext _localctx = new AttributeContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_attribute);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(265);
			match(Extended);
			setState(266);
			match(T__13);
			setState(267);
			argument();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ArgumentContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public TerminalNode QuotedString() { return getToken(ManifestParser.QuotedString, 0); }
		public TerminalNode AlphaNum() { return getToken(ManifestParser.AlphaNum, 0); }
		public ArgumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argument; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterArgument(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitArgument(this);
		}
	}

	public final ArgumentContext argument() throws RecognitionException {
		ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_argument);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(269);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AlphaNum) | (1L << Extended) | (1L << QuotedString))) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AnythingContext extends ParserRuleContext {
		public List<TerminalNode> Alpha() { return getTokens(ManifestParser.Alpha); }
		public TerminalNode Alpha(int i) {
			return getToken(ManifestParser.Alpha, i);
		}
		public List<TerminalNode> AlphaNum() { return getTokens(ManifestParser.AlphaNum); }
		public TerminalNode AlphaNum(int i) {
			return getToken(ManifestParser.AlphaNum, i);
		}
		public List<TerminalNode> Digit() { return getTokens(ManifestParser.Digit); }
		public TerminalNode Digit(int i) {
			return getToken(ManifestParser.Digit, i);
		}
		public List<TerminalNode> Number() { return getTokens(ManifestParser.Number); }
		public TerminalNode Number(int i) {
			return getToken(ManifestParser.Number, i);
		}
		public List<TerminalNode> Path() { return getTokens(ManifestParser.Path); }
		public TerminalNode Path(int i) {
			return getToken(ManifestParser.Path, i);
		}
		public List<TerminalNode> Extended() { return getTokens(ManifestParser.Extended); }
		public TerminalNode Extended(int i) {
			return getToken(ManifestParser.Extended, i);
		}
		public List<TerminalNode> QuotedString() { return getTokens(ManifestParser.QuotedString); }
		public TerminalNode QuotedString(int i) {
			return getToken(ManifestParser.QuotedString, i);
		}
		public List<TerminalNode> UniqueName() { return getTokens(ManifestParser.UniqueName); }
		public TerminalNode UniqueName(int i) {
			return getToken(ManifestParser.UniqueName, i);
		}
		public List<TerminalNode> Identifier() { return getTokens(ManifestParser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(ManifestParser.Identifier, i);
		}
		public List<TerminalNode> WS() { return getTokens(ManifestParser.WS); }
		public TerminalNode WS(int i) {
			return getToken(ManifestParser.WS, i);
		}
		public List<TerminalNode> ANYCHAR() { return getTokens(ManifestParser.ANYCHAR); }
		public TerminalNode ANYCHAR(int i) {
			return getToken(ManifestParser.ANYCHAR, i);
		}
		public AnythingContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_anything; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterAnything(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitAnything(this);
		}
	}

	public final AnythingContext anything() throws RecognitionException {
		AnythingContext _localctx = new AnythingContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_anything);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(272); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(271);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__8) | (1L << T__9) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << Alpha) | (1L << AlphaNum) | (1L << Number) | (1L << Digit) | (1L << Path) | (1L << Extended) | (1L << QuotedString) | (1L << WS) | (1L << UniqueName) | (1L << Identifier) | (1L << ANYCHAR))) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				}
				setState(274); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__5) | (1L << T__8) | (1L << T__9) | (1L << T__12) | (1L << T__13) | (1L << T__14) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << Alpha) | (1L << AlphaNum) | (1L << Number) | (1L << Digit) | (1L << Path) | (1L << Extended) | (1L << QuotedString) | (1L << WS) | (1L << UniqueName) | (1L << Identifier) | (1L << ANYCHAR))) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class GenericManifestEntryContext extends ParserRuleContext {
		public TerminalNode Extended() { return getToken(ManifestParser.Extended, 0); }
		public AnythingContext anything() {
			return getRuleContext(AnythingContext.class,0);
		}
		public TerminalNode NL() { return getToken(ManifestParser.NL, 0); }
		public GenericManifestEntryContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_genericManifestEntry; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).enterGenericManifestEntry(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ManifestListener ) ((ManifestListener)listener).exitGenericManifestEntry(this);
		}
	}

	public final GenericManifestEntryContext genericManifestEntry() throws RecognitionException {
		GenericManifestEntryContext _localctx = new GenericManifestEntryContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_genericManifestEntry);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(276);
			match(Extended);
			setState(277);
			match(T__1);
			setState(278);
			anything();
			setState(279);
			match(NL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3%\u011c\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"+
		"\3\2\3\2\7\2\67\n\2\f\2\16\2:\13\2\3\2\3\2\5\2>\n\2\3\2\7\2A\n\2\f\2\16"+
		"\2D\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3"+
		"\5\3\5\7\5W\n\5\f\5\16\5Z\13\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\7\6c\n\6\f"+
		"\6\16\6f\13\6\3\6\3\6\3\7\6\7k\n\7\r\7\16\7l\3\b\6\bp\n\b\r\b\16\bq\3"+
		"\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\7\t|\n\t\f\t\16\t\177\13\t\3\t\6\t\u0082"+
		"\n\t\r\t\16\t\u0083\5\t\u0086\n\t\3\t\3\t\3\n\3\n\3\n\7\n\u008d\n\n\f"+
		"\n\16\n\u0090\13\n\3\n\7\n\u0093\n\n\f\n\16\n\u0096\13\n\3\n\3\n\3\n\7"+
		"\n\u009b\n\n\f\n\16\n\u009e\13\n\3\n\6\n\u00a1\n\n\r\n\16\n\u00a2\3\n"+
		"\3\n\7\n\u00a7\n\n\f\n\16\n\u00aa\13\n\5\n\u00ac\n\n\3\13\6\13\u00af\n"+
		"\13\r\13\16\13\u00b0\3\13\3\13\3\13\5\13\u00b6\n\13\3\f\3\f\3\f\3\f\3"+
		"\f\7\f\u00bd\n\f\f\f\16\f\u00c0\13\f\3\f\6\f\u00c3\n\f\r\f\16\f\u00c4"+
		"\5\f\u00c7\n\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\7\r\u00d0\n\r\f\r\16\r\u00d3"+
		"\13\r\3\r\6\r\u00d6\n\r\r\r\16\r\u00d7\5\r\u00da\n\r\3\r\3\r\3\16\3\16"+
		"\3\16\7\16\u00e1\n\16\f\16\16\16\u00e4\13\16\3\16\7\16\u00e7\n\16\f\16"+
		"\16\16\u00ea\13\16\3\16\3\16\3\16\7\16\u00ef\n\16\f\16\16\16\u00f2\13"+
		"\16\3\16\6\16\u00f5\n\16\r\16\16\16\u00f6\3\16\3\16\7\16\u00fb\n\16\f"+
		"\16\16\16\u00fe\13\16\5\16\u0100\n\16\3\17\3\17\3\20\3\20\5\20\u0106\n"+
		"\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\24\6\24\u0113"+
		"\n\24\r\24\16\24\u0114\3\25\3\25\3\25\3\25\3\25\3\25\7\u0094\u00a2\u00b0"+
		"\u00e8\u00f6\2\26\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(\2\6\3\2"+
		"\33\35\4\2\37\37##\4\2\33\33\37 \6\2\b\b\13\f\17 \"%\2\u012f\2*\3\2\2"+
		"\2\4G\3\2\2\2\6L\3\2\2\2\bQ\3\2\2\2\n]\3\2\2\2\fj\3\2\2\2\16o\3\2\2\2"+
		"\20u\3\2\2\2\22\u00ab\3\2\2\2\24\u00b5\3\2\2\2\26\u00b7\3\2\2\2\30\u00ca"+
		"\3\2\2\2\32\u00ff\3\2\2\2\34\u0101\3\2\2\2\36\u0105\3\2\2\2 \u0107\3\2"+
		"\2\2\"\u010b\3\2\2\2$\u010f\3\2\2\2&\u0112\3\2\2\2(\u0116\3\2\2\2*+\7"+
		"\3\2\2+,\7\4\2\2,-\7\37\2\2-8\7!\2\2.\67\5\26\f\2/\67\5\30\r\2\60\67\5"+
		"\b\5\2\61\67\5\4\3\2\62\67\5\6\4\2\63\67\5\n\6\2\64\67\5\20\t\2\65\67"+
		"\5(\25\2\66.\3\2\2\2\66/\3\2\2\2\66\60\3\2\2\2\66\61\3\2\2\2\66\62\3\2"+
		"\2\2\66\63\3\2\2\2\66\64\3\2\2\2\66\65\3\2\2\2\67:\3\2\2\28\66\3\2\2\2"+
		"89\3\2\2\29;\3\2\2\2:8\3\2\2\2;=\7!\2\2<>\5\f\7\2=<\3\2\2\2=>\3\2\2\2"+
		">B\3\2\2\2?A\7!\2\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CE\3\2\2\2"+
		"DB\3\2\2\2EF\7\2\2\3F\3\3\2\2\2GH\7\5\2\2HI\7\4\2\2IJ\t\2\2\2JK\7!\2\2"+
		"K\5\3\2\2\2LM\7\6\2\2MN\7\4\2\2NO\t\3\2\2OP\7!\2\2P\7\3\2\2\2QR\7\7\2"+
		"\2RS\7\4\2\2SX\7\37\2\2TU\7\b\2\2UW\5\36\20\2VT\3\2\2\2WZ\3\2\2\2XV\3"+
		"\2\2\2XY\3\2\2\2Y[\3\2\2\2ZX\3\2\2\2[\\\7!\2\2\\\t\3\2\2\2]^\7\t\2\2^"+
		"_\7\4\2\2_d\7\37\2\2`a\7\b\2\2ac\5\36\20\2b`\3\2\2\2cf\3\2\2\2db\3\2\2"+
		"\2de\3\2\2\2eg\3\2\2\2fd\3\2\2\2gh\7!\2\2h\13\3\2\2\2ik\5\16\b\2ji\3\2"+
		"\2\2kl\3\2\2\2lj\3\2\2\2lm\3\2\2\2m\r\3\2\2\2np\5(\25\2on\3\2\2\2pq\3"+
		"\2\2\2qo\3\2\2\2qr\3\2\2\2rs\3\2\2\2st\7!\2\2t\17\3\2\2\2uv\7\n\2\2v\u0085"+
		"\7\4\2\2w\u0086\5\22\n\2x\u0081\5\22\n\2y}\7\13\2\2z|\7\"\2\2{z\3\2\2"+
		"\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080"+
		"\u0082\5\22\n\2\u0081y\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0081\3\2\2\2"+
		"\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085w\3\2\2\2\u0085x\3\2\2\2"+
		"\u0086\u0087\3\2\2\2\u0087\u0088\7!\2\2\u0088\21\3\2\2\2\u0089\u0094\5"+
		"\24\13\2\u008a\u008e\7\b\2\2\u008b\u008d\7\"\2\2\u008c\u008b\3\2\2\2\u008d"+
		"\u0090\3\2\2\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u0091\3\2"+
		"\2\2\u0090\u008e\3\2\2\2\u0091\u0093\5\36\20\2\u0092\u008a\3\2\2\2\u0093"+
		"\u0096\3\2\2\2\u0094\u0095\3\2\2\2\u0094\u0092\3\2\2\2\u0095\u00ac\3\2"+
		"\2\2\u0096\u0094\3\2\2\2\u0097\u00a0\5\24\13\2\u0098\u009c\7\b\2\2\u0099"+
		"\u009b\7\"\2\2\u009a\u0099\3\2\2\2\u009b\u009e\3\2\2\2\u009c\u009a\3\2"+
		"\2\2\u009c\u009d\3\2\2\2\u009d\u009f\3\2\2\2\u009e\u009c\3\2\2\2\u009f"+
		"\u00a1\5\24\13\2\u00a0\u0098\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\3"+
		"\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a8\3\2\2\2\u00a4\u00a5\7\b\2\2\u00a5"+
		"\u00a7\5\36\20\2\u00a6\u00a4\3\2\2\2\u00a7\u00aa\3\2\2\2\u00a8\u00a6\3"+
		"\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8\3\2\2\2\u00ab"+
		"\u0089\3\2\2\2\u00ab\u0097\3\2\2\2\u00ac\23\3\2\2\2\u00ad\u00af\t\3\2"+
		"\2\u00ae\u00ad\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b0\u00ae"+
		"\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b6\7\f\2\2\u00b3\u00b6\5\34\17\2"+
		"\u00b4\u00b6\7\f\2\2\u00b5\u00ae\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b4"+
		"\3\2\2\2\u00b6\25\3\2\2\2\u00b7\u00c6\7\r\2\2\u00b8\u00c7\5\32\16\2\u00b9"+
		"\u00c2\5\32\16\2\u00ba\u00be\7\13\2\2\u00bb\u00bd\7\"\2\2\u00bc\u00bb"+
		"\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf"+
		"\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c3\5\32\16\2\u00c2\u00ba\3"+
		"\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5"+
		"\u00c7\3\2\2\2\u00c6\u00b8\3\2\2\2\u00c6\u00b9\3\2\2\2\u00c7\u00c8\3\2"+
		"\2\2\u00c8\u00c9\7!\2\2\u00c9\27\3\2\2\2\u00ca\u00d9\7\16\2\2\u00cb\u00da"+
		"\5\32\16\2\u00cc\u00d5\5\32\16\2\u00cd\u00d1\7\13\2\2\u00ce\u00d0\7\""+
		"\2\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1"+
		"\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d6\5\32"+
		"\16\2\u00d5\u00cd\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7"+
		"\u00d8\3\2\2\2\u00d8\u00da\3\2\2\2\u00d9\u00cb\3\2\2\2\u00d9\u00cc\3\2"+
		"\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\7!\2\2\u00dc\31\3\2\2\2\u00dd\u00e8"+
		"\5\34\17\2\u00de\u00e2\7\b\2\2\u00df\u00e1\7\"\2\2\u00e0\u00df\3\2\2\2"+
		"\u00e1\u00e4\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\u00e5"+
		"\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e7\5\36\20\2\u00e6\u00de\3\2\2\2"+
		"\u00e7\u00ea\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u0100"+
		"\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00f4\5\34\17\2\u00ec\u00f0\7\b\2\2"+
		"\u00ed\u00ef\7\"\2\2\u00ee\u00ed\3\2\2\2\u00ef\u00f2\3\2\2\2\u00f0\u00ee"+
		"\3\2\2\2\u00f0\u00f1\3\2\2\2\u00f1\u00f3\3\2\2\2\u00f2\u00f0\3\2\2\2\u00f3"+
		"\u00f5\5\34\17\2\u00f4\u00ec\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7\3"+
		"\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fc\3\2\2\2\u00f8\u00f9\7\b\2\2\u00f9"+
		"\u00fb\5\36\20\2\u00fa\u00f8\3\2\2\2\u00fb\u00fe\3\2\2\2\u00fc\u00fa\3"+
		"\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe\u00fc\3\2\2\2\u00ff"+
		"\u00dd\3\2\2\2\u00ff\u00eb\3\2\2\2\u0100\33\3\2\2\2\u0101\u0102\t\3\2"+
		"\2\u0102\35\3\2\2\2\u0103\u0106\5 \21\2\u0104\u0106\5\"\22\2\u0105\u0103"+
		"\3\2\2\2\u0105\u0104\3\2\2\2\u0106\37\3\2\2\2\u0107\u0108\7\37\2\2\u0108"+
		"\u0109\7\17\2\2\u0109\u010a\5$\23\2\u010a!\3\2\2\2\u010b\u010c\7\37\2"+
		"\2\u010c\u010d\7\20\2\2\u010d\u010e\5$\23\2\u010e#\3\2\2\2\u010f\u0110"+
		"\t\4\2\2\u0110%\3\2\2\2\u0111\u0113\t\5\2\2\u0112\u0111\3\2\2\2\u0113"+
		"\u0114\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\'\3\2\2\2"+
		"\u0116\u0117\7\37\2\2\u0117\u0118\7\4\2\2\u0118\u0119\5&\24\2\u0119\u011a"+
		"\7!\2\2\u011a)\3\2\2\2#\668=BXdlq}\u0083\u0085\u008e\u0094\u009c\u00a2"+
		"\u00a8\u00ab\u00b0\u00b5\u00be\u00c4\u00c6\u00d1\u00d7\u00d9\u00e2\u00e8"+
		"\u00f0\u00f6\u00fc\u00ff\u0105\u0114";
	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);
		}
	}
}