GoTestParser.java

// Generated from org/egothor/methodatlas/discovery/go/parser/GoTest.g4 by ANTLR 4.13.2
package org.egothor.methodatlas.discovery.go.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"})
public class GoTestParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		FUNC=1, PACKAGE=2, IMPORT=3, MAP=4, CHAN=5, STRUCT=6, INTERFACE=7, STAR=8, 
		LBRACE=9, RBRACE=10, LPAREN=11, RPAREN=12, LBRACKET=13, RBRACKET=14, COMMA=15, 
		DOT=16, TILDE=17, ARROW=18, ELLIPSIS=19, IDENTIFIER=20, STRING_LIT=21, 
		RUNE_LIT=22, INT_LIT=23, FLOAT_LIT=24, LINE_COMMENT=25, BLOCK_COMMENT=26, 
		WS=27;
	public static final int
		RULE_sourceFile = 0, RULE_topLevelDecl = 1, RULE_packageDecl = 2, RULE_importDecl = 3, 
		RULE_importSpec = 4, RULE_funcDecl = 5, RULE_methodDecl = 6, RULE_receiver = 7, 
		RULE_typeParams = 8, RULE_typeParamContent = 9, RULE_parameters = 10, 
		RULE_result = 11, RULE_paramList = 12, RULE_paramDecl = 13, RULE_identList = 14, 
		RULE_type_ = 15, RULE_typeName = 16, RULE_typeArgs = 17, RULE_funcBody = 18, 
		RULE_opaqueContent = 19, RULE_opaqueDecl = 20, RULE_opaqueTopContent = 21;
	private static String[] makeRuleNames() {
		return new String[] {
			"sourceFile", "topLevelDecl", "packageDecl", "importDecl", "importSpec", 
			"funcDecl", "methodDecl", "receiver", "typeParams", "typeParamContent", 
			"parameters", "result", "paramList", "paramDecl", "identList", "type_", 
			"typeName", "typeArgs", "funcBody", "opaqueContent", "opaqueDecl", "opaqueTopContent"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'func'", "'package'", "'import'", "'map'", "'chan'", "'struct'", 
			"'interface'", "'*'", "'{'", "'}'", "'('", "')'", "'['", "']'", "','", 
			"'.'", "'~'", "'<-'", "'...'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "FUNC", "PACKAGE", "IMPORT", "MAP", "CHAN", "STRUCT", "INTERFACE", 
			"STAR", "LBRACE", "RBRACE", "LPAREN", "RPAREN", "LBRACKET", "RBRACKET", 
			"COMMA", "DOT", "TILDE", "ARROW", "ELLIPSIS", "IDENTIFIER", "STRING_LIT", 
			"RUNE_LIT", "INT_LIT", "FLOAT_LIT", "LINE_COMMENT", "BLOCK_COMMENT", 
			"WS"
		};
	}
	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 "GoTest.g4"; }

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

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

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

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

	@SuppressWarnings("CheckReturnValue")
	public static class SourceFileContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(GoTestParser.EOF, 0); }
		public List<TopLevelDeclContext> topLevelDecl() {
			return getRuleContexts(TopLevelDeclContext.class);
		}
		public TopLevelDeclContext topLevelDecl(int i) {
			return getRuleContext(TopLevelDeclContext.class,i);
		}
		public SourceFileContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_sourceFile; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitSourceFile(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SourceFileContext sourceFile() throws RecognitionException {
		SourceFileContext _localctx = new SourceFileContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_sourceFile);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(47);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
				{
				{
				setState(44);
				topLevelDecl();
				}
				}
				setState(49);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(50);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TopLevelDeclContext extends ParserRuleContext {
		public PackageDeclContext packageDecl() {
			return getRuleContext(PackageDeclContext.class,0);
		}
		public ImportDeclContext importDecl() {
			return getRuleContext(ImportDeclContext.class,0);
		}
		public FuncDeclContext funcDecl() {
			return getRuleContext(FuncDeclContext.class,0);
		}
		public MethodDeclContext methodDecl() {
			return getRuleContext(MethodDeclContext.class,0);
		}
		public OpaqueDeclContext opaqueDecl() {
			return getRuleContext(OpaqueDeclContext.class,0);
		}
		public TopLevelDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_topLevelDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitTopLevelDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TopLevelDeclContext topLevelDecl() throws RecognitionException {
		TopLevelDeclContext _localctx = new TopLevelDeclContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_topLevelDecl);
		try {
			setState(57);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(52);
				packageDecl();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(53);
				importDecl();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(54);
				funcDecl();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(55);
				methodDecl();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(56);
				opaqueDecl();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PackageDeclContext extends ParserRuleContext {
		public TerminalNode PACKAGE() { return getToken(GoTestParser.PACKAGE, 0); }
		public TerminalNode IDENTIFIER() { return getToken(GoTestParser.IDENTIFIER, 0); }
		public PackageDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_packageDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitPackageDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PackageDeclContext packageDecl() throws RecognitionException {
		PackageDeclContext _localctx = new PackageDeclContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_packageDecl);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(59);
			match(PACKAGE);
			setState(60);
			match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ImportDeclContext extends ParserRuleContext {
		public TerminalNode IMPORT() { return getToken(GoTestParser.IMPORT, 0); }
		public List<ImportSpecContext> importSpec() {
			return getRuleContexts(ImportSpecContext.class);
		}
		public ImportSpecContext importSpec(int i) {
			return getRuleContext(ImportSpecContext.class,i);
		}
		public TerminalNode LPAREN() { return getToken(GoTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(GoTestParser.RPAREN, 0); }
		public ImportDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitImportDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportDeclContext importDecl() throws RecognitionException {
		ImportDeclContext _localctx = new ImportDeclContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_importDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(62);
			match(IMPORT);
			setState(72);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case DOT:
			case IDENTIFIER:
			case STRING_LIT:
				{
				setState(63);
				importSpec();
				}
				break;
			case LPAREN:
				{
				setState(64);
				match(LPAREN);
				setState(68);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 3211264L) != 0)) {
					{
					{
					setState(65);
					importSpec();
					}
					}
					setState(70);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(71);
				match(RPAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ImportSpecContext extends ParserRuleContext {
		public TerminalNode STRING_LIT() { return getToken(GoTestParser.STRING_LIT, 0); }
		public TerminalNode DOT() { return getToken(GoTestParser.DOT, 0); }
		public TerminalNode IDENTIFIER() { return getToken(GoTestParser.IDENTIFIER, 0); }
		public ImportSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_importSpec; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitImportSpec(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImportSpecContext importSpec() throws RecognitionException {
		ImportSpecContext _localctx = new ImportSpecContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_importSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(75);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOT || _la==IDENTIFIER) {
				{
				setState(74);
				_la = _input.LA(1);
				if ( !(_la==DOT || _la==IDENTIFIER) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class FuncDeclContext extends ParserRuleContext {
		public TerminalNode FUNC() { return getToken(GoTestParser.FUNC, 0); }
		public TerminalNode IDENTIFIER() { return getToken(GoTestParser.IDENTIFIER, 0); }
		public ParametersContext parameters() {
			return getRuleContext(ParametersContext.class,0);
		}
		public FuncBodyContext funcBody() {
			return getRuleContext(FuncBodyContext.class,0);
		}
		public TypeParamsContext typeParams() {
			return getRuleContext(TypeParamsContext.class,0);
		}
		public ResultContext result() {
			return getRuleContext(ResultContext.class,0);
		}
		public FuncDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funcDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitFuncDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncDeclContext funcDecl() throws RecognitionException {
		FuncDeclContext _localctx = new FuncDeclContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_funcDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(79);
			match(FUNC);
			setState(80);
			match(IDENTIFIER);
			setState(82);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LBRACKET) {
				{
				setState(81);
				typeParams();
				}
			}

			setState(84);
			parameters();
			setState(86);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1452530L) != 0)) {
				{
				setState(85);
				result();
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class MethodDeclContext extends ParserRuleContext {
		public TerminalNode FUNC() { return getToken(GoTestParser.FUNC, 0); }
		public ReceiverContext receiver() {
			return getRuleContext(ReceiverContext.class,0);
		}
		public TerminalNode IDENTIFIER() { return getToken(GoTestParser.IDENTIFIER, 0); }
		public ParametersContext parameters() {
			return getRuleContext(ParametersContext.class,0);
		}
		public FuncBodyContext funcBody() {
			return getRuleContext(FuncBodyContext.class,0);
		}
		public TypeParamsContext typeParams() {
			return getRuleContext(TypeParamsContext.class,0);
		}
		public ResultContext result() {
			return getRuleContext(ResultContext.class,0);
		}
		public MethodDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitMethodDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodDeclContext methodDecl() throws RecognitionException {
		MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_methodDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(90);
			match(FUNC);
			setState(91);
			receiver();
			setState(92);
			match(IDENTIFIER);
			setState(94);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LBRACKET) {
				{
				setState(93);
				typeParams();
				}
			}

			setState(96);
			parameters();
			setState(98);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1452530L) != 0)) {
				{
				setState(97);
				result();
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class ReceiverContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(GoTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(GoTestParser.RPAREN, 0); }
		public ParamDeclContext paramDecl() {
			return getRuleContext(ParamDeclContext.class,0);
		}
		public ReceiverContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_receiver; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitReceiver(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ReceiverContext receiver() throws RecognitionException {
		ReceiverContext _localctx = new ReceiverContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_receiver);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(102);
			match(LPAREN);
			setState(104);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1976818L) != 0)) {
				{
				setState(103);
				paramDecl();
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class TypeParamsContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(GoTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(GoTestParser.RBRACKET, 0); }
		public List<TypeParamContentContext> typeParamContent() {
			return getRuleContexts(TypeParamContentContext.class);
		}
		public TypeParamContentContext typeParamContent(int i) {
			return getRuleContext(TypeParamContentContext.class,i);
		}
		public TypeParamsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeParams; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitTypeParams(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeParamsContext typeParams() throws RecognitionException {
		TypeParamsContext _localctx = new TypeParamsContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_typeParams);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(108);
			match(LBRACKET);
			setState(112);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268419070L) != 0)) {
				{
				{
				setState(109);
				typeParamContent();
				}
				}
				setState(114);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(115);
			match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeParamContentContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(GoTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(GoTestParser.RBRACKET, 0); }
		public List<TypeParamContentContext> typeParamContent() {
			return getRuleContexts(TypeParamContentContext.class);
		}
		public TypeParamContentContext typeParamContent(int i) {
			return getRuleContext(TypeParamContentContext.class,i);
		}
		public TerminalNode EOF() { return getToken(GoTestParser.EOF, 0); }
		public TypeParamContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeParamContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitTypeParamContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeParamContentContext typeParamContent() throws RecognitionException {
		TypeParamContentContext _localctx = new TypeParamContentContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_typeParamContent);
		int _la;
		try {
			setState(126);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACKET:
				enterOuterAlt(_localctx, 1);
				{
				setState(117);
				match(LBRACKET);
				setState(121);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268419070L) != 0)) {
					{
					{
					setState(118);
					typeParamContent();
					}
					}
					setState(123);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(124);
				match(RBRACKET);
				}
				break;
			case FUNC:
			case PACKAGE:
			case IMPORT:
			case MAP:
			case CHAN:
			case STRUCT:
			case INTERFACE:
			case STAR:
			case LBRACE:
			case RBRACE:
			case LPAREN:
			case RPAREN:
			case COMMA:
			case DOT:
			case TILDE:
			case ARROW:
			case ELLIPSIS:
			case IDENTIFIER:
			case STRING_LIT:
			case RUNE_LIT:
			case INT_LIT:
			case FLOAT_LIT:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case WS:
				enterOuterAlt(_localctx, 2);
				{
				setState(125);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 49153L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParametersContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(GoTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(GoTestParser.RPAREN, 0); }
		public ParamListContext paramList() {
			return getRuleContext(ParamListContext.class,0);
		}
		public ParametersContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameters; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitParameters(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParametersContext parameters() throws RecognitionException {
		ParametersContext _localctx = new ParametersContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_parameters);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(128);
			match(LPAREN);
			setState(130);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1976818L) != 0)) {
				{
				setState(129);
				paramList();
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class ResultContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(GoTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(GoTestParser.RPAREN, 0); }
		public ParamListContext paramList() {
			return getRuleContext(ParamListContext.class,0);
		}
		public Type_Context type_() {
			return getRuleContext(Type_Context.class,0);
		}
		public ResultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_result; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitResult(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ResultContext result() throws RecognitionException {
		ResultContext _localctx = new ResultContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_result);
		int _la;
		try {
			setState(140);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(134);
				match(LPAREN);
				setState(136);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1976818L) != 0)) {
					{
					setState(135);
					paramList();
					}
				}

				setState(138);
				match(RPAREN);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(139);
				type_();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParamListContext extends ParserRuleContext {
		public List<ParamDeclContext> paramDecl() {
			return getRuleContexts(ParamDeclContext.class);
		}
		public ParamDeclContext paramDecl(int i) {
			return getRuleContext(ParamDeclContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(GoTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(GoTestParser.COMMA, i);
		}
		public ParamListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitParamList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamListContext paramList() throws RecognitionException {
		ParamListContext _localctx = new ParamListContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_paramList);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(142);
			paramDecl();
			setState(147);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(143);
					match(COMMA);
					setState(144);
					paramDecl();
					}
					} 
				}
				setState(149);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			}
			setState(151);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(150);
				match(COMMA);
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class ParamDeclContext extends ParserRuleContext {
		public Type_Context type_() {
			return getRuleContext(Type_Context.class,0);
		}
		public IdentListContext identList() {
			return getRuleContext(IdentListContext.class,0);
		}
		public TerminalNode ELLIPSIS() { return getToken(GoTestParser.ELLIPSIS, 0); }
		public ParamDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitParamDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamDeclContext paramDecl() throws RecognitionException {
		ParamDeclContext _localctx = new ParamDeclContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_paramDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(154);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				{
				setState(153);
				identList();
				}
				break;
			}
			setState(157);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ELLIPSIS) {
				{
				setState(156);
				match(ELLIPSIS);
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class IdentListContext extends ParserRuleContext {
		public List<TerminalNode> IDENTIFIER() { return getTokens(GoTestParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(GoTestParser.IDENTIFIER, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(GoTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(GoTestParser.COMMA, i);
		}
		public IdentListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitIdentList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdentListContext identList() throws RecognitionException {
		IdentListContext _localctx = new IdentListContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_identList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(161);
			match(IDENTIFIER);
			setState(166);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(162);
				match(COMMA);
				setState(163);
				match(IDENTIFIER);
				}
				}
				setState(168);
				_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;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Type_Context extends ParserRuleContext {
		public TerminalNode STAR() { return getToken(GoTestParser.STAR, 0); }
		public List<Type_Context> type_() {
			return getRuleContexts(Type_Context.class);
		}
		public Type_Context type_(int i) {
			return getRuleContext(Type_Context.class,i);
		}
		public TerminalNode LBRACKET() { return getToken(GoTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(GoTestParser.RBRACKET, 0); }
		public List<TypeParamContentContext> typeParamContent() {
			return getRuleContexts(TypeParamContentContext.class);
		}
		public TypeParamContentContext typeParamContent(int i) {
			return getRuleContext(TypeParamContentContext.class,i);
		}
		public TerminalNode MAP() { return getToken(GoTestParser.MAP, 0); }
		public TerminalNode CHAN() { return getToken(GoTestParser.CHAN, 0); }
		public TerminalNode ARROW() { return getToken(GoTestParser.ARROW, 0); }
		public TerminalNode FUNC() { return getToken(GoTestParser.FUNC, 0); }
		public ParametersContext parameters() {
			return getRuleContext(ParametersContext.class,0);
		}
		public TypeParamsContext typeParams() {
			return getRuleContext(TypeParamsContext.class,0);
		}
		public ResultContext result() {
			return getRuleContext(ResultContext.class,0);
		}
		public TerminalNode STRUCT() { return getToken(GoTestParser.STRUCT, 0); }
		public TerminalNode LBRACE() { return getToken(GoTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(GoTestParser.RBRACE, 0); }
		public List<OpaqueContentContext> opaqueContent() {
			return getRuleContexts(OpaqueContentContext.class);
		}
		public OpaqueContentContext opaqueContent(int i) {
			return getRuleContext(OpaqueContentContext.class,i);
		}
		public TerminalNode INTERFACE() { return getToken(GoTestParser.INTERFACE, 0); }
		public TerminalNode TILDE() { return getToken(GoTestParser.TILDE, 0); }
		public TypeNameContext typeName() {
			return getRuleContext(TypeNameContext.class,0);
		}
		public TypeArgsContext typeArgs() {
			return getRuleContext(TypeArgsContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(GoTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(GoTestParser.RPAREN, 0); }
		public Type_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type_; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitType_(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Type_Context type_() throws RecognitionException {
		Type_Context _localctx = new Type_Context(_ctx, getState());
		enterRule(_localctx, 30, RULE_type_);
		int _la;
		try {
			setState(233);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(169);
				match(STAR);
				setState(170);
				type_();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(171);
				match(LBRACKET);
				setState(172);
				match(RBRACKET);
				setState(173);
				type_();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(174);
				match(LBRACKET);
				setState(178);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268419070L) != 0)) {
					{
					{
					setState(175);
					typeParamContent();
					}
					}
					setState(180);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(181);
				match(RBRACKET);
				setState(182);
				type_();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(183);
				match(MAP);
				setState(184);
				match(LBRACKET);
				setState(185);
				type_();
				setState(186);
				match(RBRACKET);
				setState(187);
				type_();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(189);
				match(CHAN);
				setState(191);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
				case 1:
					{
					setState(190);
					match(ARROW);
					}
					break;
				}
				setState(193);
				type_();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(194);
				match(ARROW);
				setState(195);
				match(CHAN);
				setState(196);
				type_();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(197);
				match(FUNC);
				setState(199);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACKET) {
					{
					setState(198);
					typeParams();
					}
				}

				setState(201);
				parameters();
				setState(203);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1452530L) != 0)) {
					{
					setState(202);
					result();
					}
				}

				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(205);
				match(STRUCT);
				setState(206);
				match(LBRACE);
				setState(210);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
					{
					{
					setState(207);
					opaqueContent();
					}
					}
					setState(212);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(213);
				match(RBRACE);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(214);
				match(INTERFACE);
				setState(215);
				match(LBRACE);
				setState(219);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
					{
					{
					setState(216);
					opaqueContent();
					}
					}
					setState(221);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(222);
				match(RBRACE);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(223);
				match(TILDE);
				setState(224);
				type_();
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(225);
				typeName();
				setState(227);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACKET) {
					{
					setState(226);
					typeArgs();
					}
				}

				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(229);
				match(LPAREN);
				setState(230);
				type_();
				setState(231);
				match(RPAREN);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeNameContext extends ParserRuleContext {
		public List<TerminalNode> IDENTIFIER() { return getTokens(GoTestParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(GoTestParser.IDENTIFIER, i);
		}
		public TerminalNode DOT() { return getToken(GoTestParser.DOT, 0); }
		public TypeNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitTypeName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeNameContext typeName() throws RecognitionException {
		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_typeName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(235);
			match(IDENTIFIER);
			setState(238);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOT) {
				{
				setState(236);
				match(DOT);
				setState(237);
				match(IDENTIFIER);
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class TypeArgsContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(GoTestParser.LBRACKET, 0); }
		public List<Type_Context> type_() {
			return getRuleContexts(Type_Context.class);
		}
		public Type_Context type_(int i) {
			return getRuleContext(Type_Context.class,i);
		}
		public TerminalNode RBRACKET() { return getToken(GoTestParser.RBRACKET, 0); }
		public List<TerminalNode> COMMA() { return getTokens(GoTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(GoTestParser.COMMA, i);
		}
		public TypeArgsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArgs; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitTypeArgs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgsContext typeArgs() throws RecognitionException {
		TypeArgsContext _localctx = new TypeArgsContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_typeArgs);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(240);
			match(LBRACKET);
			setState(241);
			type_();
			setState(246);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(242);
					match(COMMA);
					setState(243);
					type_();
					}
					} 
				}
				setState(248);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
			}
			setState(250);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COMMA) {
				{
				setState(249);
				match(COMMA);
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class FuncBodyContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(GoTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(GoTestParser.RBRACE, 0); }
		public List<OpaqueContentContext> opaqueContent() {
			return getRuleContexts(OpaqueContentContext.class);
		}
		public OpaqueContentContext opaqueContent(int i) {
			return getRuleContext(OpaqueContentContext.class,i);
		}
		public FuncBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_funcBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitFuncBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FuncBodyContext funcBody() throws RecognitionException {
		FuncBodyContext _localctx = new FuncBodyContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_funcBody);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(254);
			match(LBRACE);
			setState(258);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
				{
				{
				setState(255);
				opaqueContent();
				}
				}
				setState(260);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(261);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpaqueContentContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(GoTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(GoTestParser.RBRACE, 0); }
		public List<OpaqueContentContext> opaqueContent() {
			return getRuleContexts(OpaqueContentContext.class);
		}
		public OpaqueContentContext opaqueContent(int i) {
			return getRuleContext(OpaqueContentContext.class,i);
		}
		public TerminalNode EOF() { return getToken(GoTestParser.EOF, 0); }
		public OpaqueContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opaqueContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitOpaqueContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpaqueContentContext opaqueContent() throws RecognitionException {
		OpaqueContentContext _localctx = new OpaqueContentContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_opaqueContent);
		int _la;
		try {
			setState(272);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(263);
				match(LBRACE);
				setState(267);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
					{
					{
					setState(264);
					opaqueContent();
					}
					}
					setState(269);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(270);
				match(RBRACE);
				}
				break;
			case FUNC:
			case PACKAGE:
			case IMPORT:
			case MAP:
			case CHAN:
			case STRUCT:
			case INTERFACE:
			case STAR:
			case LPAREN:
			case RPAREN:
			case LBRACKET:
			case RBRACKET:
			case COMMA:
			case DOT:
			case TILDE:
			case ARROW:
			case ELLIPSIS:
			case IDENTIFIER:
			case STRING_LIT:
			case RUNE_LIT:
			case INT_LIT:
			case FLOAT_LIT:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case WS:
				enterOuterAlt(_localctx, 2);
				{
				setState(271);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 3073L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpaqueDeclContext extends ParserRuleContext {
		public List<OpaqueTopContentContext> opaqueTopContent() {
			return getRuleContexts(OpaqueTopContentContext.class);
		}
		public OpaqueTopContentContext opaqueTopContent(int i) {
			return getRuleContext(OpaqueTopContentContext.class,i);
		}
		public OpaqueDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opaqueDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitOpaqueDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpaqueDeclContext opaqueDecl() throws RecognitionException {
		OpaqueDeclContext _localctx = new OpaqueDeclContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_opaqueDecl);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(275); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(274);
					opaqueTopContent();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(277); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpaqueTopContentContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(GoTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(GoTestParser.RBRACE, 0); }
		public List<OpaqueContentContext> opaqueContent() {
			return getRuleContexts(OpaqueContentContext.class);
		}
		public OpaqueContentContext opaqueContent(int i) {
			return getRuleContext(OpaqueContentContext.class,i);
		}
		public TerminalNode FUNC() { return getToken(GoTestParser.FUNC, 0); }
		public TerminalNode PACKAGE() { return getToken(GoTestParser.PACKAGE, 0); }
		public TerminalNode IMPORT() { return getToken(GoTestParser.IMPORT, 0); }
		public TerminalNode EOF() { return getToken(GoTestParser.EOF, 0); }
		public OpaqueTopContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opaqueTopContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof GoTestVisitor ) return ((GoTestVisitor<? extends T>)visitor).visitOpaqueTopContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpaqueTopContentContext opaqueTopContent() throws RecognitionException {
		OpaqueTopContentContext _localctx = new OpaqueTopContentContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_opaqueTopContent);
		int _la;
		try {
			setState(288);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(279);
				match(LBRACE);
				setState(283);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 268434430L) != 0)) {
					{
					{
					setState(280);
					opaqueContent();
					}
					}
					setState(285);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(286);
				match(RBRACE);
				}
				break;
			case MAP:
			case CHAN:
			case STRUCT:
			case INTERFACE:
			case STAR:
			case LPAREN:
			case RPAREN:
			case LBRACKET:
			case RBRACKET:
			case COMMA:
			case DOT:
			case TILDE:
			case ARROW:
			case ELLIPSIS:
			case IDENTIFIER:
			case STRING_LIT:
			case RUNE_LIT:
			case INT_LIT:
			case FLOAT_LIT:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case WS:
				enterOuterAlt(_localctx, 2);
				{
				setState(287);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 3101L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				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 final String _serializedATN =
		"\u0004\u0001\u001b\u0123\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
		"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
		"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
		"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
		"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
		"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
		"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
		"\u0015\u0001\u0000\u0005\u0000.\b\u0000\n\u0000\f\u00001\t\u0000\u0001"+
		"\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0003\u0001:\b\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+
		"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u0003C\b\u0003\n\u0003"+
		"\f\u0003F\t\u0003\u0001\u0003\u0003\u0003I\b\u0003\u0001\u0004\u0003\u0004"+
		"L\b\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005"+
		"\u0003\u0005S\b\u0005\u0001\u0005\u0001\u0005\u0003\u0005W\b\u0005\u0001"+
		"\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003"+
		"\u0006_\b\u0006\u0001\u0006\u0001\u0006\u0003\u0006c\b\u0006\u0001\u0006"+
		"\u0001\u0006\u0001\u0007\u0001\u0007\u0003\u0007i\b\u0007\u0001\u0007"+
		"\u0001\u0007\u0001\b\u0001\b\u0005\bo\b\b\n\b\f\br\t\b\u0001\b\u0001\b"+
		"\u0001\t\u0001\t\u0005\tx\b\t\n\t\f\t{\t\t\u0001\t\u0001\t\u0003\t\u007f"+
		"\b\t\u0001\n\u0001\n\u0003\n\u0083\b\n\u0001\n\u0001\n\u0001\u000b\u0001"+
		"\u000b\u0003\u000b\u0089\b\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u008d"+
		"\b\u000b\u0001\f\u0001\f\u0001\f\u0005\f\u0092\b\f\n\f\f\f\u0095\t\f\u0001"+
		"\f\u0003\f\u0098\b\f\u0001\r\u0003\r\u009b\b\r\u0001\r\u0003\r\u009e\b"+
		"\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u00a5"+
		"\b\u000e\n\u000e\f\u000e\u00a8\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u00b1\b\u000f"+
		"\n\u000f\f\u000f\u00b4\t\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+
		"\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+
		"\u000f\u0003\u000f\u00c0\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+
		"\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u00c8\b\u000f\u0001\u000f\u0001"+
		"\u000f\u0003\u000f\u00cc\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005"+
		"\u000f\u00d1\b\u000f\n\u000f\f\u000f\u00d4\t\u000f\u0001\u000f\u0001\u000f"+
		"\u0001\u000f\u0001\u000f\u0005\u000f\u00da\b\u000f\n\u000f\f\u000f\u00dd"+
		"\t\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003"+
		"\u000f\u00e4\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0003"+
		"\u000f\u00ea\b\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u00ef"+
		"\b\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u00f5"+
		"\b\u0011\n\u0011\f\u0011\u00f8\t\u0011\u0001\u0011\u0003\u0011\u00fb\b"+
		"\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0005\u0012\u0101"+
		"\b\u0012\n\u0012\f\u0012\u0104\t\u0012\u0001\u0012\u0001\u0012\u0001\u0013"+
		"\u0001\u0013\u0005\u0013\u010a\b\u0013\n\u0013\f\u0013\u010d\t\u0013\u0001"+
		"\u0013\u0001\u0013\u0003\u0013\u0111\b\u0013\u0001\u0014\u0004\u0014\u0114"+
		"\b\u0014\u000b\u0014\f\u0014\u0115\u0001\u0015\u0001\u0015\u0005\u0015"+
		"\u011a\b\u0015\n\u0015\f\u0015\u011d\t\u0015\u0001\u0015\u0001\u0015\u0003"+
		"\u0015\u0121\b\u0015\u0001\u0015\u0000\u0000\u0016\u0000\u0002\u0004\u0006"+
		"\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*\u0000"+
		"\u0004\u0002\u0000\u0010\u0010\u0014\u0014\u0001\u0001\r\u000e\u0001\u0001"+
		"\t\n\u0002\u0001\u0001\u0003\t\n\u013f\u0000/\u0001\u0000\u0000\u0000"+
		"\u00029\u0001\u0000\u0000\u0000\u0004;\u0001\u0000\u0000\u0000\u0006>"+
		"\u0001\u0000\u0000\u0000\bK\u0001\u0000\u0000\u0000\nO\u0001\u0000\u0000"+
		"\u0000\fZ\u0001\u0000\u0000\u0000\u000ef\u0001\u0000\u0000\u0000\u0010"+
		"l\u0001\u0000\u0000\u0000\u0012~\u0001\u0000\u0000\u0000\u0014\u0080\u0001"+
		"\u0000\u0000\u0000\u0016\u008c\u0001\u0000\u0000\u0000\u0018\u008e\u0001"+
		"\u0000\u0000\u0000\u001a\u009a\u0001\u0000\u0000\u0000\u001c\u00a1\u0001"+
		"\u0000\u0000\u0000\u001e\u00e9\u0001\u0000\u0000\u0000 \u00eb\u0001\u0000"+
		"\u0000\u0000\"\u00f0\u0001\u0000\u0000\u0000$\u00fe\u0001\u0000\u0000"+
		"\u0000&\u0110\u0001\u0000\u0000\u0000(\u0113\u0001\u0000\u0000\u0000*"+
		"\u0120\u0001\u0000\u0000\u0000,.\u0003\u0002\u0001\u0000-,\u0001\u0000"+
		"\u0000\u0000.1\u0001\u0000\u0000\u0000/-\u0001\u0000\u0000\u0000/0\u0001"+
		"\u0000\u0000\u000002\u0001\u0000\u0000\u00001/\u0001\u0000\u0000\u0000"+
		"23\u0005\u0000\u0000\u00013\u0001\u0001\u0000\u0000\u00004:\u0003\u0004"+
		"\u0002\u00005:\u0003\u0006\u0003\u00006:\u0003\n\u0005\u00007:\u0003\f"+
		"\u0006\u00008:\u0003(\u0014\u000094\u0001\u0000\u0000\u000095\u0001\u0000"+
		"\u0000\u000096\u0001\u0000\u0000\u000097\u0001\u0000\u0000\u000098\u0001"+
		"\u0000\u0000\u0000:\u0003\u0001\u0000\u0000\u0000;<\u0005\u0002\u0000"+
		"\u0000<=\u0005\u0014\u0000\u0000=\u0005\u0001\u0000\u0000\u0000>H\u0005"+
		"\u0003\u0000\u0000?I\u0003\b\u0004\u0000@D\u0005\u000b\u0000\u0000AC\u0003"+
		"\b\u0004\u0000BA\u0001\u0000\u0000\u0000CF\u0001\u0000\u0000\u0000DB\u0001"+
		"\u0000\u0000\u0000DE\u0001\u0000\u0000\u0000EG\u0001\u0000\u0000\u0000"+
		"FD\u0001\u0000\u0000\u0000GI\u0005\f\u0000\u0000H?\u0001\u0000\u0000\u0000"+
		"H@\u0001\u0000\u0000\u0000I\u0007\u0001\u0000\u0000\u0000JL\u0007\u0000"+
		"\u0000\u0000KJ\u0001\u0000\u0000\u0000KL\u0001\u0000\u0000\u0000LM\u0001"+
		"\u0000\u0000\u0000MN\u0005\u0015\u0000\u0000N\t\u0001\u0000\u0000\u0000"+
		"OP\u0005\u0001\u0000\u0000PR\u0005\u0014\u0000\u0000QS\u0003\u0010\b\u0000"+
		"RQ\u0001\u0000\u0000\u0000RS\u0001\u0000\u0000\u0000ST\u0001\u0000\u0000"+
		"\u0000TV\u0003\u0014\n\u0000UW\u0003\u0016\u000b\u0000VU\u0001\u0000\u0000"+
		"\u0000VW\u0001\u0000\u0000\u0000WX\u0001\u0000\u0000\u0000XY\u0003$\u0012"+
		"\u0000Y\u000b\u0001\u0000\u0000\u0000Z[\u0005\u0001\u0000\u0000[\\\u0003"+
		"\u000e\u0007\u0000\\^\u0005\u0014\u0000\u0000]_\u0003\u0010\b\u0000^]"+
		"\u0001\u0000\u0000\u0000^_\u0001\u0000\u0000\u0000_`\u0001\u0000\u0000"+
		"\u0000`b\u0003\u0014\n\u0000ac\u0003\u0016\u000b\u0000ba\u0001\u0000\u0000"+
		"\u0000bc\u0001\u0000\u0000\u0000cd\u0001\u0000\u0000\u0000de\u0003$\u0012"+
		"\u0000e\r\u0001\u0000\u0000\u0000fh\u0005\u000b\u0000\u0000gi\u0003\u001a"+
		"\r\u0000hg\u0001\u0000\u0000\u0000hi\u0001\u0000\u0000\u0000ij\u0001\u0000"+
		"\u0000\u0000jk\u0005\f\u0000\u0000k\u000f\u0001\u0000\u0000\u0000lp\u0005"+
		"\r\u0000\u0000mo\u0003\u0012\t\u0000nm\u0001\u0000\u0000\u0000or\u0001"+
		"\u0000\u0000\u0000pn\u0001\u0000\u0000\u0000pq\u0001\u0000\u0000\u0000"+
		"qs\u0001\u0000\u0000\u0000rp\u0001\u0000\u0000\u0000st\u0005\u000e\u0000"+
		"\u0000t\u0011\u0001\u0000\u0000\u0000uy\u0005\r\u0000\u0000vx\u0003\u0012"+
		"\t\u0000wv\u0001\u0000\u0000\u0000x{\u0001\u0000\u0000\u0000yw\u0001\u0000"+
		"\u0000\u0000yz\u0001\u0000\u0000\u0000z|\u0001\u0000\u0000\u0000{y\u0001"+
		"\u0000\u0000\u0000|\u007f\u0005\u000e\u0000\u0000}\u007f\b\u0001\u0000"+
		"\u0000~u\u0001\u0000\u0000\u0000~}\u0001\u0000\u0000\u0000\u007f\u0013"+
		"\u0001\u0000\u0000\u0000\u0080\u0082\u0005\u000b\u0000\u0000\u0081\u0083"+
		"\u0003\u0018\f\u0000\u0082\u0081\u0001\u0000\u0000\u0000\u0082\u0083\u0001"+
		"\u0000\u0000\u0000\u0083\u0084\u0001\u0000\u0000\u0000\u0084\u0085\u0005"+
		"\f\u0000\u0000\u0085\u0015\u0001\u0000\u0000\u0000\u0086\u0088\u0005\u000b"+
		"\u0000\u0000\u0087\u0089\u0003\u0018\f\u0000\u0088\u0087\u0001\u0000\u0000"+
		"\u0000\u0088\u0089\u0001\u0000\u0000\u0000\u0089\u008a\u0001\u0000\u0000"+
		"\u0000\u008a\u008d\u0005\f\u0000\u0000\u008b\u008d\u0003\u001e\u000f\u0000"+
		"\u008c\u0086\u0001\u0000\u0000\u0000\u008c\u008b\u0001\u0000\u0000\u0000"+
		"\u008d\u0017\u0001\u0000\u0000\u0000\u008e\u0093\u0003\u001a\r\u0000\u008f"+
		"\u0090\u0005\u000f\u0000\u0000\u0090\u0092\u0003\u001a\r\u0000\u0091\u008f"+
		"\u0001\u0000\u0000\u0000\u0092\u0095\u0001\u0000\u0000\u0000\u0093\u0091"+
		"\u0001\u0000\u0000\u0000\u0093\u0094\u0001\u0000\u0000\u0000\u0094\u0097"+
		"\u0001\u0000\u0000\u0000\u0095\u0093\u0001\u0000\u0000\u0000\u0096\u0098"+
		"\u0005\u000f\u0000\u0000\u0097\u0096\u0001\u0000\u0000\u0000\u0097\u0098"+
		"\u0001\u0000\u0000\u0000\u0098\u0019\u0001\u0000\u0000\u0000\u0099\u009b"+
		"\u0003\u001c\u000e\u0000\u009a\u0099\u0001\u0000\u0000\u0000\u009a\u009b"+
		"\u0001\u0000\u0000\u0000\u009b\u009d\u0001\u0000\u0000\u0000\u009c\u009e"+
		"\u0005\u0013\u0000\u0000\u009d\u009c\u0001\u0000\u0000\u0000\u009d\u009e"+
		"\u0001\u0000\u0000\u0000\u009e\u009f\u0001\u0000\u0000\u0000\u009f\u00a0"+
		"\u0003\u001e\u000f\u0000\u00a0\u001b\u0001\u0000\u0000\u0000\u00a1\u00a6"+
		"\u0005\u0014\u0000\u0000\u00a2\u00a3\u0005\u000f\u0000\u0000\u00a3\u00a5"+
		"\u0005\u0014\u0000\u0000\u00a4\u00a2\u0001\u0000\u0000\u0000\u00a5\u00a8"+
		"\u0001\u0000\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000\u0000\u00a6\u00a7"+
		"\u0001\u0000\u0000\u0000\u00a7\u001d\u0001\u0000\u0000\u0000\u00a8\u00a6"+
		"\u0001\u0000\u0000\u0000\u00a9\u00aa\u0005\b\u0000\u0000\u00aa\u00ea\u0003"+
		"\u001e\u000f\u0000\u00ab\u00ac\u0005\r\u0000\u0000\u00ac\u00ad\u0005\u000e"+
		"\u0000\u0000\u00ad\u00ea\u0003\u001e\u000f\u0000\u00ae\u00b2\u0005\r\u0000"+
		"\u0000\u00af\u00b1\u0003\u0012\t\u0000\u00b0\u00af\u0001\u0000\u0000\u0000"+
		"\u00b1\u00b4\u0001\u0000\u0000\u0000\u00b2\u00b0\u0001\u0000\u0000\u0000"+
		"\u00b2\u00b3\u0001\u0000\u0000\u0000\u00b3\u00b5\u0001\u0000\u0000\u0000"+
		"\u00b4\u00b2\u0001\u0000\u0000\u0000\u00b5\u00b6\u0005\u000e\u0000\u0000"+
		"\u00b6\u00ea\u0003\u001e\u000f\u0000\u00b7\u00b8\u0005\u0004\u0000\u0000"+
		"\u00b8\u00b9\u0005\r\u0000\u0000\u00b9\u00ba\u0003\u001e\u000f\u0000\u00ba"+
		"\u00bb\u0005\u000e\u0000\u0000\u00bb\u00bc\u0003\u001e\u000f\u0000\u00bc"+
		"\u00ea\u0001\u0000\u0000\u0000\u00bd\u00bf\u0005\u0005\u0000\u0000\u00be"+
		"\u00c0\u0005\u0012\u0000\u0000\u00bf\u00be\u0001\u0000\u0000\u0000\u00bf"+
		"\u00c0\u0001\u0000\u0000\u0000\u00c0\u00c1\u0001\u0000\u0000\u0000\u00c1"+
		"\u00ea\u0003\u001e\u000f\u0000\u00c2\u00c3\u0005\u0012\u0000\u0000\u00c3"+
		"\u00c4\u0005\u0005\u0000\u0000\u00c4\u00ea\u0003\u001e\u000f\u0000\u00c5"+
		"\u00c7\u0005\u0001\u0000\u0000\u00c6\u00c8\u0003\u0010\b\u0000\u00c7\u00c6"+
		"\u0001\u0000\u0000\u0000\u00c7\u00c8\u0001\u0000\u0000\u0000\u00c8\u00c9"+
		"\u0001\u0000\u0000\u0000\u00c9\u00cb\u0003\u0014\n\u0000\u00ca\u00cc\u0003"+
		"\u0016\u000b\u0000\u00cb\u00ca\u0001\u0000\u0000\u0000\u00cb\u00cc\u0001"+
		"\u0000\u0000\u0000\u00cc\u00ea\u0001\u0000\u0000\u0000\u00cd\u00ce\u0005"+
		"\u0006\u0000\u0000\u00ce\u00d2\u0005\t\u0000\u0000\u00cf\u00d1\u0003&"+
		"\u0013\u0000\u00d0\u00cf\u0001\u0000\u0000\u0000\u00d1\u00d4\u0001\u0000"+
		"\u0000\u0000\u00d2\u00d0\u0001\u0000\u0000\u0000\u00d2\u00d3\u0001\u0000"+
		"\u0000\u0000\u00d3\u00d5\u0001\u0000\u0000\u0000\u00d4\u00d2\u0001\u0000"+
		"\u0000\u0000\u00d5\u00ea\u0005\n\u0000\u0000\u00d6\u00d7\u0005\u0007\u0000"+
		"\u0000\u00d7\u00db\u0005\t\u0000\u0000\u00d8\u00da\u0003&\u0013\u0000"+
		"\u00d9\u00d8\u0001\u0000\u0000\u0000\u00da\u00dd\u0001\u0000\u0000\u0000"+
		"\u00db\u00d9\u0001\u0000\u0000\u0000\u00db\u00dc\u0001\u0000\u0000\u0000"+
		"\u00dc\u00de\u0001\u0000\u0000\u0000\u00dd\u00db\u0001\u0000\u0000\u0000"+
		"\u00de\u00ea\u0005\n\u0000\u0000\u00df\u00e0\u0005\u0011\u0000\u0000\u00e0"+
		"\u00ea\u0003\u001e\u000f\u0000\u00e1\u00e3\u0003 \u0010\u0000\u00e2\u00e4"+
		"\u0003\"\u0011\u0000\u00e3\u00e2\u0001\u0000\u0000\u0000\u00e3\u00e4\u0001"+
		"\u0000\u0000\u0000\u00e4\u00ea\u0001\u0000\u0000\u0000\u00e5\u00e6\u0005"+
		"\u000b\u0000\u0000\u00e6\u00e7\u0003\u001e\u000f\u0000\u00e7\u00e8\u0005"+
		"\f\u0000\u0000\u00e8\u00ea\u0001\u0000\u0000\u0000\u00e9\u00a9\u0001\u0000"+
		"\u0000\u0000\u00e9\u00ab\u0001\u0000\u0000\u0000\u00e9\u00ae\u0001\u0000"+
		"\u0000\u0000\u00e9\u00b7\u0001\u0000\u0000\u0000\u00e9\u00bd\u0001\u0000"+
		"\u0000\u0000\u00e9\u00c2\u0001\u0000\u0000\u0000\u00e9\u00c5\u0001\u0000"+
		"\u0000\u0000\u00e9\u00cd\u0001\u0000\u0000\u0000\u00e9\u00d6\u0001\u0000"+
		"\u0000\u0000\u00e9\u00df\u0001\u0000\u0000\u0000\u00e9\u00e1\u0001\u0000"+
		"\u0000\u0000\u00e9\u00e5\u0001\u0000\u0000\u0000\u00ea\u001f\u0001\u0000"+
		"\u0000\u0000\u00eb\u00ee\u0005\u0014\u0000\u0000\u00ec\u00ed\u0005\u0010"+
		"\u0000\u0000\u00ed\u00ef\u0005\u0014\u0000\u0000\u00ee\u00ec\u0001\u0000"+
		"\u0000\u0000\u00ee\u00ef\u0001\u0000\u0000\u0000\u00ef!\u0001\u0000\u0000"+
		"\u0000\u00f0\u00f1\u0005\r\u0000\u0000\u00f1\u00f6\u0003\u001e\u000f\u0000"+
		"\u00f2\u00f3\u0005\u000f\u0000\u0000\u00f3\u00f5\u0003\u001e\u000f\u0000"+
		"\u00f4\u00f2\u0001\u0000\u0000\u0000\u00f5\u00f8\u0001\u0000\u0000\u0000"+
		"\u00f6\u00f4\u0001\u0000\u0000\u0000\u00f6\u00f7\u0001\u0000\u0000\u0000"+
		"\u00f7\u00fa\u0001\u0000\u0000\u0000\u00f8\u00f6\u0001\u0000\u0000\u0000"+
		"\u00f9\u00fb\u0005\u000f\u0000\u0000\u00fa\u00f9\u0001\u0000\u0000\u0000"+
		"\u00fa\u00fb\u0001\u0000\u0000\u0000\u00fb\u00fc\u0001\u0000\u0000\u0000"+
		"\u00fc\u00fd\u0005\u000e\u0000\u0000\u00fd#\u0001\u0000\u0000\u0000\u00fe"+
		"\u0102\u0005\t\u0000\u0000\u00ff\u0101\u0003&\u0013\u0000\u0100\u00ff"+
		"\u0001\u0000\u0000\u0000\u0101\u0104\u0001\u0000\u0000\u0000\u0102\u0100"+
		"\u0001\u0000\u0000\u0000\u0102\u0103\u0001\u0000\u0000\u0000\u0103\u0105"+
		"\u0001\u0000\u0000\u0000\u0104\u0102\u0001\u0000\u0000\u0000\u0105\u0106"+
		"\u0005\n\u0000\u0000\u0106%\u0001\u0000\u0000\u0000\u0107\u010b\u0005"+
		"\t\u0000\u0000\u0108\u010a\u0003&\u0013\u0000\u0109\u0108\u0001\u0000"+
		"\u0000\u0000\u010a\u010d\u0001\u0000\u0000\u0000\u010b\u0109\u0001\u0000"+
		"\u0000\u0000\u010b\u010c\u0001\u0000\u0000\u0000\u010c\u010e\u0001\u0000"+
		"\u0000\u0000\u010d\u010b\u0001\u0000\u0000\u0000\u010e\u0111\u0005\n\u0000"+
		"\u0000\u010f\u0111\b\u0002\u0000\u0000\u0110\u0107\u0001\u0000\u0000\u0000"+
		"\u0110\u010f\u0001\u0000\u0000\u0000\u0111\'\u0001\u0000\u0000\u0000\u0112"+
		"\u0114\u0003*\u0015\u0000\u0113\u0112\u0001\u0000\u0000\u0000\u0114\u0115"+
		"\u0001\u0000\u0000\u0000\u0115\u0113\u0001\u0000\u0000\u0000\u0115\u0116"+
		"\u0001\u0000\u0000\u0000\u0116)\u0001\u0000\u0000\u0000\u0117\u011b\u0005"+
		"\t\u0000\u0000\u0118\u011a\u0003&\u0013\u0000\u0119\u0118\u0001\u0000"+
		"\u0000\u0000\u011a\u011d\u0001\u0000\u0000\u0000\u011b\u0119\u0001\u0000"+
		"\u0000\u0000\u011b\u011c\u0001\u0000\u0000\u0000\u011c\u011e\u0001\u0000"+
		"\u0000\u0000\u011d\u011b\u0001\u0000\u0000\u0000\u011e\u0121\u0005\n\u0000"+
		"\u0000\u011f\u0121\b\u0003\u0000\u0000\u0120\u0117\u0001\u0000\u0000\u0000"+
		"\u0120\u011f\u0001\u0000\u0000\u0000\u0121+\u0001\u0000\u0000\u0000&/"+
		"9DHKRV^bhpy~\u0082\u0088\u008c\u0093\u0097\u009a\u009d\u00a6\u00b2\u00bf"+
		"\u00c7\u00cb\u00d2\u00db\u00e3\u00e9\u00ee\u00f6\u00fa\u0102\u010b\u0110"+
		"\u0115\u011b\u0120";
	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);
		}
	}
}