// Generated from E:/subjects/Compilers Principle/exp/antlr/aidl-to-json/src/main/resources/grammar\Aidl.g4 by ANTLR 4.9.1
package xyz.ignatz.antlr.aidl.recognizer;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;

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

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		PRIMITIVE=1, BYTE=2, SHORT=3, INT=4, LONG=5, FLOAT=6, DOUBLE=7, BOOLEAN=8, 
		CHAR=9, PACKAGE=10, PARCELABLE=11, IMPORT=12, INTERFACE=13, ONEWAY=14, 
		VOID=15, CONST=16, NULLABLE=17, INOUT=18, IN=19, OUT=20, STRING=21, CHARSEQUENCE=22, 
		MAP=23, LIST=24, IBINDER=25, LP=26, RP=27, LC=28, RC=29, LB=30, RB=31, 
		LA=32, RA=33, DOT=34, CO=35, SE=36, EQ=37, PATH=38, ID=39, INTEGER=40, 
		LITERALSTRING=41, WS=42, COMMENT_BLOCK=43, COMMENT_LINE=44;
	public static final int
		RULE_aidl = 0, RULE_packageStatement = 1, RULE_parcelableStatement = 2, 
		RULE_importStatement = 3, RULE_interfaceStatement = 4, RULE_interfaceSubStatement = 5, 
		RULE_methodStatement = 6, RULE_constStatement = 7, RULE_methodReturnType = 8, 
		RULE_paramList = 9, RULE_param = 10, RULE_paramTag = 11, RULE_paramType = 12, 
		RULE_type = 13, RULE_list = 14, RULE_interfaceName = 15, RULE_className = 16, 
		RULE_name = 17, RULE_path = 18, RULE_id = 19;
	private static String[] makeRuleNames() {
		return new String[] {
			"aidl", "packageStatement", "parcelableStatement", "importStatement", 
			"interfaceStatement", "interfaceSubStatement", "methodStatement", "constStatement", 
			"methodReturnType", "paramList", "param", "paramTag", "paramType", "type", 
			"list", "interfaceName", "className", "name", "path", "id"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, "'byte'", "'short'", "'int'", "'long'", "'float'", "'double'", 
			"'boolean'", "'char'", "'package'", "'parcelable'", "'import'", "'interface'", 
			"'oneway'", "'void'", "'const'", "'@nullable'", "'inout'", "'in'", "'out'", 
			"'String'", "'CharSequence'", "'Map'", "'List'", "'IBinder'", "'('", 
			"')'", "'{'", "'}'", "'['", "']'", "'<'", "'>'", "'.'", "','", "';'", 
			"'='"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "PRIMITIVE", "BYTE", "SHORT", "INT", "LONG", "FLOAT", "DOUBLE", 
			"BOOLEAN", "CHAR", "PACKAGE", "PARCELABLE", "IMPORT", "INTERFACE", "ONEWAY", 
			"VOID", "CONST", "NULLABLE", "INOUT", "IN", "OUT", "STRING", "CHARSEQUENCE", 
			"MAP", "LIST", "IBINDER", "LP", "RP", "LC", "RC", "LB", "RB", "LA", "RA", 
			"DOT", "CO", "SE", "EQ", "PATH", "ID", "INTEGER", "LITERALSTRING", "WS", 
			"COMMENT_BLOCK", "COMMENT_LINE"
		};
	}
	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] = "<INVALID>";
			}
		}
	}

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

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

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

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

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

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


	    int oneway = 0;

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

	public static class AidlContext extends ParserRuleContext {
		public PackageStatementContext packageStatement() {
			return getRuleContext(PackageStatementContext.class,0);
		}
		public ParcelableStatementContext parcelableStatement() {
			return getRuleContext(ParcelableStatementContext.class,0);
		}
		public InterfaceStatementContext interfaceStatement() {
			return getRuleContext(InterfaceStatementContext.class,0);
		}
		public List<ImportStatementContext> importStatement() {
			return getRuleContexts(ImportStatementContext.class);
		}
		public ImportStatementContext importStatement(int i) {
			return getRuleContext(ImportStatementContext.class,i);
		}
		public AidlContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_aidl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterAidl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitAidl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitAidl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AidlContext aidl() throws RecognitionException {
		AidlContext _localctx = new AidlContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_aidl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(41);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==PACKAGE) {
				{
				setState(40);
				packageStatement();
				}
			}

			setState(51);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case PARCELABLE:
				{
				setState(43);
				parcelableStatement();
				}
				break;
			case IMPORT:
			case INTERFACE:
			case ONEWAY:
				{
				setState(47);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==IMPORT) {
					{
					{
					setState(44);
					importStatement();
					}
					}
					setState(49);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(50);
				interfaceStatement();
				}
				break;
			case EOF:
				break;
			default:
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PackageStatementContext extends ParserRuleContext {
		public TerminalNode PACKAGE() { return getToken(AidlParser.PACKAGE, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public TerminalNode SE() { return getToken(AidlParser.SE, 0); }
		public PackageStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_packageStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterPackageStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitPackageStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitPackageStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PackageStatementContext packageStatement() throws RecognitionException {
		PackageStatementContext _localctx = new PackageStatementContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_packageStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(53);
			match(PACKAGE);
			setState(54);
			name();
			setState(55);
			match(SE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParcelableStatementContext extends ParserRuleContext {
		public TerminalNode PARCELABLE() { return getToken(AidlParser.PARCELABLE, 0); }
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode SE() { return getToken(AidlParser.SE, 0); }
		public ParcelableStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parcelableStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterParcelableStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitParcelableStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitParcelableStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParcelableStatementContext parcelableStatement() throws RecognitionException {
		ParcelableStatementContext _localctx = new ParcelableStatementContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_parcelableStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(57);
			match(PARCELABLE);
			setState(58);
			id();
			setState(59);
			match(SE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ImportStatementContext extends ParserRuleContext {
		public TerminalNode IMPORT() { return getToken(AidlParser.IMPORT, 0); }
		public PathContext path() {
			return getRuleContext(PathContext.class,0);
		}
		public TerminalNode SE() { return getToken(AidlParser.SE, 0); }
		public ImportStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterImportStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitImportStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitImportStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportStatementContext importStatement() throws RecognitionException {
		ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_importStatement);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(61);
			match(IMPORT);
			setState(62);
			path();
			setState(63);
			match(SE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InterfaceStatementContext extends ParserRuleContext {
		public TerminalNode INTERFACE() { return getToken(AidlParser.INTERFACE, 0); }
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode LC() { return getToken(AidlParser.LC, 0); }
		public TerminalNode RC() { return getToken(AidlParser.RC, 0); }
		public TerminalNode ONEWAY() { return getToken(AidlParser.ONEWAY, 0); }
		public List<InterfaceSubStatementContext> interfaceSubStatement() {
			return getRuleContexts(InterfaceSubStatementContext.class);
		}
		public InterfaceSubStatementContext interfaceSubStatement(int i) {
			return getRuleContext(InterfaceSubStatementContext.class,i);
		}
		public InterfaceStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_interfaceStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterInterfaceStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitInterfaceStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitInterfaceStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InterfaceStatementContext interfaceStatement() throws RecognitionException {
		InterfaceStatementContext _localctx = new InterfaceStatementContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_interfaceStatement);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			oneway = 0;
			setState(68);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ONEWAY) {
				{
				setState(66);
				match(ONEWAY);
				oneway = 1;
				}
			}

			setState(70);
			match(INTERFACE);
			setState(71);
			id();
			setState(72);
			match(LC);
			setState(76);
			_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(73);
					interfaceSubStatement();
					}
					} 
				}
				setState(78);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
			}
			setState(79);
			match(RC);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InterfaceSubStatementContext extends ParserRuleContext {
		public MethodStatementContext methodStatement() {
			return getRuleContext(MethodStatementContext.class,0);
		}
		public ConstStatementContext constStatement() {
			return getRuleContext(ConstStatementContext.class,0);
		}
		public InterfaceSubStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_interfaceSubStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterInterfaceSubStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitInterfaceSubStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitInterfaceSubStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InterfaceSubStatementContext interfaceSubStatement() throws RecognitionException {
		InterfaceSubStatementContext _localctx = new InterfaceSubStatementContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_interfaceSubStatement);
		try {
			setState(83);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(81);
				methodStatement();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(82);
				constStatement();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MethodStatementContext extends ParserRuleContext {
		public MethodReturnTypeContext methodReturnType() {
			return getRuleContext(MethodReturnTypeContext.class,0);
		}
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode LP() { return getToken(AidlParser.LP, 0); }
		public TerminalNode RP() { return getToken(AidlParser.RP, 0); }
		public TerminalNode SE() { return getToken(AidlParser.SE, 0); }
		public TerminalNode ONEWAY() { return getToken(AidlParser.ONEWAY, 0); }
		public ParamListContext paramList() {
			return getRuleContext(ParamListContext.class,0);
		}
		public TerminalNode EQ() { return getToken(AidlParser.EQ, 0); }
		public TerminalNode INT() { return getToken(AidlParser.INT, 0); }
		public MethodStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterMethodStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitMethodStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitMethodStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodStatementContext methodStatement() throws RecognitionException {
		MethodStatementContext _localctx = new MethodStatementContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_methodStatement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			oneway &= 1;
			setState(88);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				{
				setState(86);
				match(ONEWAY);
				oneway |= 2;
				}
				break;
			}
			setState(90);
			methodReturnType();
			setState(91);
			id();
			setState(92);
			match(LP);
			setState(94);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				{
				setState(93);
				paramList();
				}
				break;
			}
			setState(96);
			match(RP);
			setState(99);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EQ) {
				{
				setState(97);
				match(EQ);
				setState(98);
				match(INT);
				}
			}

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

	public static class ConstStatementContext extends ParserRuleContext {
		public TerminalNode CONST() { return getToken(AidlParser.CONST, 0); }
		public TerminalNode INT() { return getToken(AidlParser.INT, 0); }
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode EQ() { return getToken(AidlParser.EQ, 0); }
		public TerminalNode INTEGER() { return getToken(AidlParser.INTEGER, 0); }
		public TerminalNode SE() { return getToken(AidlParser.SE, 0); }
		public TerminalNode STRING() { return getToken(AidlParser.STRING, 0); }
		public TerminalNode LITERALSTRING() { return getToken(AidlParser.LITERALSTRING, 0); }
		public ConstStatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constStatement; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterConstStatement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitConstStatement(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitConstStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstStatementContext constStatement() throws RecognitionException {
		ConstStatementContext _localctx = new ConstStatementContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_constStatement);
		try {
			setState(117);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(103);
				match(CONST);
				setState(104);
				match(INT);
				setState(105);
				id();
				setState(106);
				match(EQ);
				setState(107);
				match(INTEGER);
				setState(108);
				match(SE);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(110);
				match(CONST);
				setState(111);
				match(STRING);
				setState(112);
				id();
				setState(113);
				match(EQ);
				setState(114);
				match(LITERALSTRING);
				setState(115);
				match(SE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MethodReturnTypeContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode NULLABLE() { return getToken(AidlParser.NULLABLE, 0); }
		public TerminalNode VOID() { return getToken(AidlParser.VOID, 0); }
		public MethodReturnTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodReturnType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterMethodReturnType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitMethodReturnType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitMethodReturnType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodReturnTypeContext methodReturnType() throws RecognitionException {
		MethodReturnTypeContext _localctx = new MethodReturnTypeContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_methodReturnType);
		int _la;
		try {
			setState(125);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(119);
				if (!(oneway==0)) throw new FailedPredicateException(this, "oneway==0");
				{
				setState(121);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==NULLABLE) {
					{
					setState(120);
					match(NULLABLE);
					}
				}

				setState(123);
				type();
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(124);
				match(VOID);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamListContext extends ParserRuleContext {
		public List<ParamContext> param() {
			return getRuleContexts(ParamContext.class);
		}
		public ParamContext param(int i) {
			return getRuleContext(ParamContext.class,i);
		}
		public List<TerminalNode> CO() { return getTokens(AidlParser.CO); }
		public TerminalNode CO(int i) {
			return getToken(AidlParser.CO, i);
		}
		public ParamListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterParamList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitParamList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitParamList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamListContext paramList() throws RecognitionException {
		ParamListContext _localctx = new ParamListContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_paramList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(127);
			param();
			setState(132);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==CO) {
				{
				{
				setState(128);
				match(CO);
				setState(129);
				param();
				}
				}
				setState(134);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamContext extends ParserRuleContext {
		public ParamTagContext paramTag;
		public ParamTypeContext paramType() {
			return getRuleContext(ParamTypeContext.class,0);
		}
		public IdContext id() {
			return getRuleContext(IdContext.class,0);
		}
		public TerminalNode NULLABLE() { return getToken(AidlParser.NULLABLE, 0); }
		public ParamTagContext paramTag() {
			return getRuleContext(ParamTagContext.class,0);
		}
		public ParamContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_param; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterParam(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitParam(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitParam(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamContext param() throws RecognitionException {
		ParamContext _localctx = new ParamContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_param);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(136);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				{
				setState(135);
				match(NULLABLE);
				}
				break;
			}
			setState(139);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
			case 1:
				{
				setState(138);
				((ParamContext)_localctx).paramTag = paramTag();
				}
				break;
			}
			setState(141);
			paramType((((ParamContext)_localctx).paramTag!=null?_input.getText(((ParamContext)_localctx).paramTag.start,((ParamContext)_localctx).paramTag.stop):null));
			setState(142);
			id();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamTagContext extends ParserRuleContext {
		public TerminalNode IN() { return getToken(AidlParser.IN, 0); }
		public TerminalNode OUT() { return getToken(AidlParser.OUT, 0); }
		public TerminalNode INOUT() { return getToken(AidlParser.INOUT, 0); }
		public ParamTagContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramTag; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterParamTag(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitParamTag(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitParamTag(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamTagContext paramTag() throws RecognitionException {
		ParamTagContext _localctx = new ParamTagContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_paramTag);
		int _la;
		try {
			setState(147);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(144);
				match(IN);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(145);
				if (!(oneway==0)) throw new FailedPredicateException(this, "oneway==0");
				setState(146);
				_la = _input.LA(1);
				if ( !(_la==INOUT || _la==OUT) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamTypeContext extends ParserRuleContext {
		public String tag;
		public int tid = 0;
		public TypeContext type;
		public TerminalNode PRIMITIVE() { return getToken(AidlParser.PRIMITIVE, 0); }
		public TerminalNode STRING() { return getToken(AidlParser.STRING, 0); }
		public InterfaceNameContext interfaceName() {
			return getRuleContext(InterfaceNameContext.class,0);
		}
		public TerminalNode MAP() { return getToken(AidlParser.MAP, 0); }
		public TerminalNode CHARSEQUENCE() { return getToken(AidlParser.CHARSEQUENCE, 0); }
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public ClassNameContext className() {
			return getRuleContext(ClassNameContext.class,0);
		}
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode LB() { return getToken(AidlParser.LB, 0); }
		public TerminalNode RB() { return getToken(AidlParser.RB, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public ParamTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
		public ParamTypeContext(ParserRuleContext parent, int invokingState, String tag) {
			super(parent, invokingState);
			this.tag = tag;
		}
		@Override public int getRuleIndex() { return RULE_paramType; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterParamType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitParamType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitParamType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamTypeContext paramType(String tag) throws RecognitionException {
		ParamTypeContext _localctx = new ParamTypeContext(_ctx, getState(), tag);
		enterRule(_localctx, 24, RULE_paramType);
		try {
			setState(180);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(149);
				if (!(_localctx.tag==null)) throw new FailedPredicateException(this, "$tag==null");
				{
				setState(155);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PRIMITIVE:
					{
					setState(150);
					match(PRIMITIVE);
					}
					break;
				case STRING:
					{
					setState(151);
					match(STRING);
					}
					break;
				case IBINDER:
				case PATH:
				case ID:
					{
					setState(152);
					interfaceName();
					((ParamTypeContext)_localctx).tid =  1;
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(157);
				if (!(_localctx.tag!=null)) throw new FailedPredicateException(this, "$tag!=null");
				setState(178);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
				case 1:
					{
					setState(158);
					match(MAP);
					}
					break;
				case 2:
					{
					setState(159);
					match(CHARSEQUENCE);
					}
					break;
				case 3:
					{
					setState(160);
					list();
					}
					break;
				case 4:
					{
					setState(167);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
					case 1:
						{
						setState(161);
						name();
						((ParamTypeContext)_localctx).tid =  -1;
						}
						break;
					case 2:
						{
						setState(164);
						((ParamTypeContext)_localctx).type = type();
						((ParamTypeContext)_localctx).tid =  ((ParamTypeContext)_localctx).type.tid;
						}
						break;
					}
					setState(169);
					if (!(_localctx.tag.equals("in"))) throw new FailedPredicateException(this, "$tag.equals(\"in\")");
					}
					break;
				case 5:
					{
					setState(171);
					className();
					((ParamTypeContext)_localctx).tid =  2;
					}
					break;
				case 6:
					{
					setState(174);
					((ParamTypeContext)_localctx).type = type();
					setState(175);
					match(LB);
					setState(176);
					match(RB);
					}
					break;
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TypeContext extends ParserRuleContext {
		public int tid = 0;
		public TerminalNode PRIMITIVE() { return getToken(AidlParser.PRIMITIVE, 0); }
		public TerminalNode STRING() { return getToken(AidlParser.STRING, 0); }
		public TerminalNode CHARSEQUENCE() { return getToken(AidlParser.CHARSEQUENCE, 0); }
		public TerminalNode MAP() { return getToken(AidlParser.MAP, 0); }
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public ClassNameContext className() {
			return getRuleContext(ClassNameContext.class,0);
		}
		public List<TerminalNode> LB() { return getTokens(AidlParser.LB); }
		public TerminalNode LB(int i) {
			return getToken(AidlParser.LB, i);
		}
		public List<TerminalNode> RB() { return getTokens(AidlParser.RB); }
		public TerminalNode RB(int i) {
			return getToken(AidlParser.RB, i);
		}
		public TypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterType(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitType(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeContext type() throws RecognitionException {
		TypeContext _localctx = new TypeContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_type);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(190);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case PRIMITIVE:
				{
				setState(182);
				match(PRIMITIVE);
				}
				break;
			case STRING:
				{
				setState(183);
				match(STRING);
				}
				break;
			case CHARSEQUENCE:
				{
				setState(184);
				match(CHARSEQUENCE);
				}
				break;
			case MAP:
				{
				setState(185);
				match(MAP);
				}
				break;
			case LIST:
				{
				setState(186);
				list();
				}
				break;
			case PATH:
			case ID:
				{
				setState(187);
				className();
				((TypeContext)_localctx).tid =  2;
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(196);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(192);
					match(LB);
					setState(193);
					match(RB);
					}
					} 
				}
				setState(198);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListContext extends ParserRuleContext {
		public TerminalNode LIST() { return getToken(AidlParser.LIST, 0); }
		public TerminalNode LA() { return getToken(AidlParser.LA, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode RA() { return getToken(AidlParser.RA, 0); }
		public ListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListContext list() throws RecognitionException {
		ListContext _localctx = new ListContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_list);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(199);
			match(LIST);
			setState(204);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
			case 1:
				{
				setState(200);
				match(LA);
				setState(201);
				type();
				setState(202);
				match(RA);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class InterfaceNameContext extends ParserRuleContext {
		public TerminalNode IBINDER() { return getToken(AidlParser.IBINDER, 0); }
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public InterfaceNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_interfaceName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterInterfaceName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitInterfaceName(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitInterfaceName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final InterfaceNameContext interfaceName() throws RecognitionException {
		InterfaceNameContext _localctx = new InterfaceNameContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_interfaceName);
		try {
			setState(208);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case IBINDER:
				enterOuterAlt(_localctx, 1);
				{
				setState(206);
				match(IBINDER);
				}
				break;
			case PATH:
			case ID:
				enterOuterAlt(_localctx, 2);
				{
				setState(207);
				name();
				}
				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 ClassNameContext extends ParserRuleContext {
		public NameContext name() {
			return getRuleContext(NameContext.class,0);
		}
		public ClassNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_className; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterClassName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitClassName(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitClassName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassNameContext className() throws RecognitionException {
		ClassNameContext _localctx = new ClassNameContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_className);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(210);
			name();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NameContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(AidlParser.ID, 0); }
		public TerminalNode PATH() { return getToken(AidlParser.PATH, 0); }
		public NameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_name; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitName(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NameContext name() throws RecognitionException {
		NameContext _localctx = new NameContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_name);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(212);
			_la = _input.LA(1);
			if ( !(_la==PATH || _la==ID) ) {
			_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 PathContext extends ParserRuleContext {
		public TerminalNode PATH() { return getToken(AidlParser.PATH, 0); }
		public PathContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_path; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterPath(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitPath(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitPath(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PathContext path() throws RecognitionException {
		PathContext _localctx = new PathContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_path);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(214);
			match(PATH);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IdContext extends ParserRuleContext {
		public TerminalNode ID() { return getToken(AidlParser.ID, 0); }
		public IdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_id; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).enterId(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof AidlListener ) ((AidlListener)listener).exitId(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof AidlVisitor ) return ((AidlVisitor<? extends T>)visitor).visitId(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdContext id() throws RecognitionException {
		IdContext _localctx = new IdContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_id);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(216);
			match(ID);
			}
		}
		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 8:
			return methodReturnType_sempred((MethodReturnTypeContext)_localctx, predIndex);
		case 11:
			return paramTag_sempred((ParamTagContext)_localctx, predIndex);
		case 12:
			return paramType_sempred((ParamTypeContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean methodReturnType_sempred(MethodReturnTypeContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return oneway==0;
		}
		return true;
	}
	private boolean paramTag_sempred(ParamTagContext _localctx, int predIndex) {
		switch (predIndex) {
		case 1:
			return oneway==0;
		}
		return true;
	}
	private boolean paramType_sempred(ParamTypeContext _localctx, int predIndex) {
		switch (predIndex) {
		case 2:
			return _localctx.tag==null;
		case 3:
			return _localctx.tag!=null;
		case 4:
			return _localctx.tag.equals("in");
		}
		return true;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3.\u00dd\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\5\2,\n\2\3\2\3\2\7\2\60\n\2\f\2\16"+
		"\2\63\13\2\3\2\5\2\66\n\2\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5"+
		"\3\5\3\6\3\6\3\6\5\6G\n\6\3\6\3\6\3\6\3\6\7\6M\n\6\f\6\16\6P\13\6\3\6"+
		"\3\6\3\7\3\7\5\7V\n\7\3\b\3\b\3\b\5\b[\n\b\3\b\3\b\3\b\3\b\5\ba\n\b\3"+
		"\b\3\b\3\b\5\bf\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+
		"\t\3\t\3\t\3\t\5\tx\n\t\3\n\3\n\5\n|\n\n\3\n\3\n\5\n\u0080\n\n\3\13\3"+
		"\13\3\13\7\13\u0085\n\13\f\13\16\13\u0088\13\13\3\f\5\f\u008b\n\f\3\f"+
		"\5\f\u008e\n\f\3\f\3\f\3\f\3\r\3\r\3\r\5\r\u0096\n\r\3\16\3\16\3\16\3"+
		"\16\3\16\3\16\5\16\u009e\n\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16"+
		"\3\16\3\16\5\16\u00aa\n\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16"+
		"\5\16\u00b5\n\16\5\16\u00b7\n\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3"+
		"\17\5\17\u00c1\n\17\3\17\3\17\7\17\u00c5\n\17\f\17\16\17\u00c8\13\17\3"+
		"\20\3\20\3\20\3\20\3\20\5\20\u00cf\n\20\3\21\3\21\5\21\u00d3\n\21\3\22"+
		"\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\25\2\2\26\2\4\6\b\n\f\16\20\22\24"+
		"\26\30\32\34\36 \"$&(\2\4\4\2\24\24\26\26\3\2()\2\u00ea\2+\3\2\2\2\4\67"+
		"\3\2\2\2\6;\3\2\2\2\b?\3\2\2\2\nC\3\2\2\2\fU\3\2\2\2\16W\3\2\2\2\20w\3"+
		"\2\2\2\22\177\3\2\2\2\24\u0081\3\2\2\2\26\u008a\3\2\2\2\30\u0095\3\2\2"+
		"\2\32\u00b6\3\2\2\2\34\u00c0\3\2\2\2\36\u00c9\3\2\2\2 \u00d2\3\2\2\2\""+
		"\u00d4\3\2\2\2$\u00d6\3\2\2\2&\u00d8\3\2\2\2(\u00da\3\2\2\2*,\5\4\3\2"+
		"+*\3\2\2\2+,\3\2\2\2,\65\3\2\2\2-\66\5\6\4\2.\60\5\b\5\2/.\3\2\2\2\60"+
		"\63\3\2\2\2\61/\3\2\2\2\61\62\3\2\2\2\62\64\3\2\2\2\63\61\3\2\2\2\64\66"+
		"\5\n\6\2\65-\3\2\2\2\65\61\3\2\2\2\65\66\3\2\2\2\66\3\3\2\2\2\678\7\f"+
		"\2\289\5$\23\29:\7&\2\2:\5\3\2\2\2;<\7\r\2\2<=\5(\25\2=>\7&\2\2>\7\3\2"+
		"\2\2?@\7\16\2\2@A\5&\24\2AB\7&\2\2B\t\3\2\2\2CF\b\6\1\2DE\7\20\2\2EG\b"+
		"\6\1\2FD\3\2\2\2FG\3\2\2\2GH\3\2\2\2HI\7\17\2\2IJ\5(\25\2JN\7\36\2\2K"+
		"M\5\f\7\2LK\3\2\2\2MP\3\2\2\2NL\3\2\2\2NO\3\2\2\2OQ\3\2\2\2PN\3\2\2\2"+
		"QR\7\37\2\2R\13\3\2\2\2SV\5\16\b\2TV\5\20\t\2US\3\2\2\2UT\3\2\2\2V\r\3"+
		"\2\2\2WZ\b\b\1\2XY\7\20\2\2Y[\b\b\1\2ZX\3\2\2\2Z[\3\2\2\2[\\\3\2\2\2\\"+
		"]\5\22\n\2]^\5(\25\2^`\7\34\2\2_a\5\24\13\2`_\3\2\2\2`a\3\2\2\2ab\3\2"+
		"\2\2be\7\35\2\2cd\7\'\2\2df\7\6\2\2ec\3\2\2\2ef\3\2\2\2fg\3\2\2\2gh\7"+
		"&\2\2h\17\3\2\2\2ij\7\22\2\2jk\7\6\2\2kl\5(\25\2lm\7\'\2\2mn\7*\2\2no"+
		"\7&\2\2ox\3\2\2\2pq\7\22\2\2qr\7\27\2\2rs\5(\25\2st\7\'\2\2tu\7+\2\2u"+
		"v\7&\2\2vx\3\2\2\2wi\3\2\2\2wp\3\2\2\2x\21\3\2\2\2y{\6\n\2\2z|\7\23\2"+
		"\2{z\3\2\2\2{|\3\2\2\2|}\3\2\2\2}\u0080\5\34\17\2~\u0080\7\21\2\2\177"+
		"y\3\2\2\2\177~\3\2\2\2\u0080\23\3\2\2\2\u0081\u0086\5\26\f\2\u0082\u0083"+
		"\7%\2\2\u0083\u0085\5\26\f\2\u0084\u0082\3\2\2\2\u0085\u0088\3\2\2\2\u0086"+
		"\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087\25\3\2\2\2\u0088\u0086\3\2\2"+
		"\2\u0089\u008b\7\23\2\2\u008a\u0089\3\2\2\2\u008a\u008b\3\2\2\2\u008b"+
		"\u008d\3\2\2\2\u008c\u008e\5\30\r\2\u008d\u008c\3\2\2\2\u008d\u008e\3"+
		"\2\2\2\u008e\u008f\3\2\2\2\u008f\u0090\5\32\16\2\u0090\u0091\5(\25\2\u0091"+
		"\27\3\2\2\2\u0092\u0096\7\25\2\2\u0093\u0094\6\r\3\2\u0094\u0096\t\2\2"+
		"\2\u0095\u0092\3\2\2\2\u0095\u0093\3\2\2\2\u0096\31\3\2\2\2\u0097\u009d"+
		"\6\16\4\3\u0098\u009e\7\3\2\2\u0099\u009e\7\27\2\2\u009a\u009b\5 \21\2"+
		"\u009b\u009c\b\16\1\2\u009c\u009e\3\2\2\2\u009d\u0098\3\2\2\2\u009d\u0099"+
		"\3\2\2\2\u009d\u009a\3\2\2\2\u009e\u00b7\3\2\2\2\u009f\u00b4\6\16\5\3"+
		"\u00a0\u00b5\7\31\2\2\u00a1\u00b5\7\30\2\2\u00a2\u00b5\5\36\20\2\u00a3"+
		"\u00a4\5$\23\2\u00a4\u00a5\b\16\1\2\u00a5\u00aa\3\2\2\2\u00a6\u00a7\5"+
		"\34\17\2\u00a7\u00a8\b\16\1\2\u00a8\u00aa\3\2\2\2\u00a9\u00a3\3\2\2\2"+
		"\u00a9\u00a6\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ac\6\16\6\3\u00ac\u00b5"+
		"\3\2\2\2\u00ad\u00ae\5\"\22\2\u00ae\u00af\b\16\1\2\u00af\u00b5\3\2\2\2"+
		"\u00b0\u00b1\5\34\17\2\u00b1\u00b2\7 \2\2\u00b2\u00b3\7!\2\2\u00b3\u00b5"+
		"\3\2\2\2\u00b4\u00a0\3\2\2\2\u00b4\u00a1\3\2\2\2\u00b4\u00a2\3\2\2\2\u00b4"+
		"\u00a9\3\2\2\2\u00b4\u00ad\3\2\2\2\u00b4\u00b0\3\2\2\2\u00b5\u00b7\3\2"+
		"\2\2\u00b6\u0097\3\2\2\2\u00b6\u009f\3\2\2\2\u00b7\33\3\2\2\2\u00b8\u00c1"+
		"\7\3\2\2\u00b9\u00c1\7\27\2\2\u00ba\u00c1\7\30\2\2\u00bb\u00c1\7\31\2"+
		"\2\u00bc\u00c1\5\36\20\2\u00bd\u00be\5\"\22\2\u00be\u00bf\b\17\1\2\u00bf"+
		"\u00c1\3\2\2\2\u00c0\u00b8\3\2\2\2\u00c0\u00b9\3\2\2\2\u00c0\u00ba\3\2"+
		"\2\2\u00c0\u00bb\3\2\2\2\u00c0\u00bc\3\2\2\2\u00c0\u00bd\3\2\2\2\u00c1"+
		"\u00c6\3\2\2\2\u00c2\u00c3\7 \2\2\u00c3\u00c5\7!\2\2\u00c4\u00c2\3\2\2"+
		"\2\u00c5\u00c8\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c7\3\2\2\2\u00c7\35"+
		"\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c9\u00ce\7\32\2\2\u00ca\u00cb\7\"\2\2"+
		"\u00cb\u00cc\5\34\17\2\u00cc\u00cd\7#\2\2\u00cd\u00cf\3\2\2\2\u00ce\u00ca"+
		"\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\37\3\2\2\2\u00d0\u00d3\7\33\2\2\u00d1"+
		"\u00d3\5$\23\2\u00d2\u00d0\3\2\2\2\u00d2\u00d1\3\2\2\2\u00d3!\3\2\2\2"+
		"\u00d4\u00d5\5$\23\2\u00d5#\3\2\2\2\u00d6\u00d7\t\3\2\2\u00d7%\3\2\2\2"+
		"\u00d8\u00d9\7(\2\2\u00d9\'\3\2\2\2\u00da\u00db\7)\2\2\u00db)\3\2\2\2"+
		"\32+\61\65FNUZ`ew{\177\u0086\u008a\u008d\u0095\u009d\u00a9\u00b4\u00b6"+
		"\u00c0\u00c6\u00ce\u00d2";
	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);
		}
	}
}