ABAPTestParser.java

// Generated from org/egothor/methodatlas/discovery/abap/parser/ABAPTest.g4 by ANTLR 4.13.2
package org.egothor.methodatlas.discovery.abap.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 ABAPTestParser 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
		CLASS=1, ENDCLASS=2, DEFINITION=3, IMPLEMENTATION=4, FOR=5, TESTING=6, 
		RISK=7, LEVEL=8, DURATION=9, INHERITING=10, FROM=11, CREATE=12, PUBLIC=13, 
		PROTECTED=14, PRIVATE=15, FINAL=16, ABSTRACT=17, SECTION=18, METHODS=19, 
		METHOD=20, ENDMETHOD=21, IMPORTING=22, EXPORTING=23, CHANGING=24, RETURNING=25, 
		RAISING=26, EXCEPTIONS=27, STATIC=28, REDEFINITION=29, DEFAULT=30, IGNORE=31, 
		FAIL=32, EVENT=33, OF=34, TYPE=35, VALUE=36, OPTIONAL=37, PERIOD=38, COMMA=39, 
		COLON=40, DASH=41, LPAREN=42, RPAREN=43, IDENTIFIER=44, STRING_LIT=45, 
		INT_LIT=46, LINE_COMMENT=47, WS=48, OTHER=49;
	public static final int
		RULE_sourceFile = 0, RULE_topDecl = 1, RULE_classDef = 2, RULE_classDefAttr = 3, 
		RULE_classSec = 4, RULE_classMember = 5, RULE_classMemberToken = 6, RULE_methodDecl = 7, 
		RULE_methodDeclAttr = 8, RULE_typeName = 9, RULE_classImpl = 10, RULE_methodImpl = 11, 
		RULE_implContent = 12, RULE_opaqueDecl = 13, RULE_opaqueTop = 14;
	private static String[] makeRuleNames() {
		return new String[] {
			"sourceFile", "topDecl", "classDef", "classDefAttr", "classSec", "classMember", 
			"classMemberToken", "methodDecl", "methodDeclAttr", "typeName", "classImpl", 
			"methodImpl", "implContent", "opaqueDecl", "opaqueTop"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'CLASS'", "'ENDCLASS'", "'DEFINITION'", "'IMPLEMENTATION'", "'FOR'", 
			"'TESTING'", "'RISK'", "'LEVEL'", "'DURATION'", "'INHERITING'", "'FROM'", 
			"'CREATE'", "'PUBLIC'", "'PROTECTED'", "'PRIVATE'", "'FINAL'", "'ABSTRACT'", 
			"'SECTION'", "'METHODS'", "'METHOD'", "'ENDMETHOD'", "'IMPORTING'", "'EXPORTING'", 
			"'CHANGING'", "'RETURNING'", "'RAISING'", "'EXCEPTIONS'", "'STATIC'", 
			"'REDEFINITION'", "'DEFAULT'", "'IGNORE'", "'FAIL'", "'EVENT'", "'OF'", 
			"'TYPE'", "'VALUE'", "'OPTIONAL'", "'.'", "','", "':'", "'-'", "'('", 
			"')'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "CLASS", "ENDCLASS", "DEFINITION", "IMPLEMENTATION", "FOR", "TESTING", 
			"RISK", "LEVEL", "DURATION", "INHERITING", "FROM", "CREATE", "PUBLIC", 
			"PROTECTED", "PRIVATE", "FINAL", "ABSTRACT", "SECTION", "METHODS", "METHOD", 
			"ENDMETHOD", "IMPORTING", "EXPORTING", "CHANGING", "RETURNING", "RAISING", 
			"EXCEPTIONS", "STATIC", "REDEFINITION", "DEFAULT", "IGNORE", "FAIL", 
			"EVENT", "OF", "TYPE", "VALUE", "OPTIONAL", "PERIOD", "COMMA", "COLON", 
			"DASH", "LPAREN", "RPAREN", "IDENTIFIER", "STRING_LIT", "INT_LIT", "LINE_COMMENT", 
			"WS", "OTHER"
		};
	}
	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 "ABAPTest.g4"; }

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

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

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

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

	@SuppressWarnings("CheckReturnValue")
	public static class SourceFileContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(ABAPTestParser.EOF, 0); }
		public List<TopDeclContext> topDecl() {
			return getRuleContexts(TopDeclContext.class);
		}
		public TopDeclContext topDecl(int i) {
			return getRuleContext(TopDeclContext.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 ABAPTestVisitor ) return ((ABAPTestVisitor<? 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(33);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125899906842618L) != 0)) {
				{
				{
				setState(30);
				topDecl();
				}
				}
				setState(35);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(36);
			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 TopDeclContext extends ParserRuleContext {
		public ClassDefContext classDef() {
			return getRuleContext(ClassDefContext.class,0);
		}
		public ClassImplContext classImpl() {
			return getRuleContext(ClassImplContext.class,0);
		}
		public OpaqueDeclContext opaqueDecl() {
			return getRuleContext(OpaqueDeclContext.class,0);
		}
		public TopDeclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_topDecl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitTopDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TopDeclContext topDecl() throws RecognitionException {
		TopDeclContext _localctx = new TopDeclContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_topDecl);
		try {
			setState(41);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(38);
				classDef();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(39);
				classImpl();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(40);
				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 ClassDefContext extends ParserRuleContext {
		public TerminalNode CLASS() { return getToken(ABAPTestParser.CLASS, 0); }
		public TerminalNode IDENTIFIER() { return getToken(ABAPTestParser.IDENTIFIER, 0); }
		public TerminalNode DEFINITION() { return getToken(ABAPTestParser.DEFINITION, 0); }
		public List<TerminalNode> PERIOD() { return getTokens(ABAPTestParser.PERIOD); }
		public TerminalNode PERIOD(int i) {
			return getToken(ABAPTestParser.PERIOD, i);
		}
		public TerminalNode ENDCLASS() { return getToken(ABAPTestParser.ENDCLASS, 0); }
		public List<ClassDefAttrContext> classDefAttr() {
			return getRuleContexts(ClassDefAttrContext.class);
		}
		public ClassDefAttrContext classDefAttr(int i) {
			return getRuleContext(ClassDefAttrContext.class,i);
		}
		public List<ClassSecContext> classSec() {
			return getRuleContexts(ClassSecContext.class);
		}
		public ClassSecContext classSec(int i) {
			return getRuleContext(ClassSecContext.class,i);
		}
		public ClassDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classDef; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassDef(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassDefContext classDef() throws RecognitionException {
		ClassDefContext _localctx = new ClassDefContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_classDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(43);
			match(CLASS);
			setState(44);
			match(IDENTIFIER);
			setState(45);
			match(DEFINITION);
			setState(49);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 210592L) != 0)) {
				{
				{
				setState(46);
				classDefAttr();
				}
				}
				setState(51);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(52);
			match(PERIOD);
			setState(56);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 57344L) != 0)) {
				{
				{
				setState(53);
				classSec();
				}
				}
				setState(58);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(59);
			match(ENDCLASS);
			setState(60);
			match(PERIOD);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ClassDefAttrContext extends ParserRuleContext {
		public TerminalNode FOR() { return getToken(ABAPTestParser.FOR, 0); }
		public TerminalNode TESTING() { return getToken(ABAPTestParser.TESTING, 0); }
		public TerminalNode RISK() { return getToken(ABAPTestParser.RISK, 0); }
		public TerminalNode IDENTIFIER() { return getToken(ABAPTestParser.IDENTIFIER, 0); }
		public TerminalNode LEVEL() { return getToken(ABAPTestParser.LEVEL, 0); }
		public TerminalNode DURATION() { return getToken(ABAPTestParser.DURATION, 0); }
		public TerminalNode INHERITING() { return getToken(ABAPTestParser.INHERITING, 0); }
		public TerminalNode FROM() { return getToken(ABAPTestParser.FROM, 0); }
		public TerminalNode CREATE() { return getToken(ABAPTestParser.CREATE, 0); }
		public TerminalNode PUBLIC() { return getToken(ABAPTestParser.PUBLIC, 0); }
		public TerminalNode PROTECTED() { return getToken(ABAPTestParser.PROTECTED, 0); }
		public TerminalNode PRIVATE() { return getToken(ABAPTestParser.PRIVATE, 0); }
		public TerminalNode FINAL() { return getToken(ABAPTestParser.FINAL, 0); }
		public TerminalNode ABSTRACT() { return getToken(ABAPTestParser.ABSTRACT, 0); }
		public ClassDefAttrContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classDefAttr; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassDefAttr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassDefAttrContext classDefAttr() throws RecognitionException {
		ClassDefAttrContext _localctx = new ClassDefAttrContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_classDefAttr);
		int _la;
		try {
			setState(79);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case FOR:
				enterOuterAlt(_localctx, 1);
				{
				setState(62);
				match(FOR);
				setState(63);
				match(TESTING);
				}
				break;
			case RISK:
				enterOuterAlt(_localctx, 2);
				{
				setState(64);
				match(RISK);
				setState(66);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LEVEL) {
					{
					setState(65);
					match(LEVEL);
					}
				}

				setState(68);
				match(IDENTIFIER);
				}
				break;
			case DURATION:
				enterOuterAlt(_localctx, 3);
				{
				setState(69);
				match(DURATION);
				setState(70);
				match(IDENTIFIER);
				}
				break;
			case INHERITING:
				enterOuterAlt(_localctx, 4);
				{
				setState(71);
				match(INHERITING);
				setState(72);
				match(FROM);
				setState(73);
				match(IDENTIFIER);
				}
				break;
			case CREATE:
				enterOuterAlt(_localctx, 5);
				{
				setState(74);
				match(CREATE);
				setState(75);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 57344L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case PUBLIC:
				enterOuterAlt(_localctx, 6);
				{
				setState(76);
				match(PUBLIC);
				}
				break;
			case FINAL:
				enterOuterAlt(_localctx, 7);
				{
				setState(77);
				match(FINAL);
				}
				break;
			case ABSTRACT:
				enterOuterAlt(_localctx, 8);
				{
				setState(78);
				match(ABSTRACT);
				}
				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 ClassSecContext extends ParserRuleContext {
		public TerminalNode SECTION() { return getToken(ABAPTestParser.SECTION, 0); }
		public TerminalNode PERIOD() { return getToken(ABAPTestParser.PERIOD, 0); }
		public TerminalNode PUBLIC() { return getToken(ABAPTestParser.PUBLIC, 0); }
		public TerminalNode PROTECTED() { return getToken(ABAPTestParser.PROTECTED, 0); }
		public TerminalNode PRIVATE() { return getToken(ABAPTestParser.PRIVATE, 0); }
		public List<ClassMemberContext> classMember() {
			return getRuleContexts(ClassMemberContext.class);
		}
		public ClassMemberContext classMember(int i) {
			return getRuleContext(ClassMemberContext.class,i);
		}
		public ClassSecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classSec; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassSec(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassSecContext classSec() throws RecognitionException {
		ClassSecContext _localctx = new ClassSecContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_classSec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(81);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 57344L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(82);
			match(SECTION);
			setState(83);
			match(PERIOD);
			setState(87);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125625028878330L) != 0)) {
				{
				{
				setState(84);
				classMember();
				}
				}
				setState(89);
				_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 ClassMemberContext extends ParserRuleContext {
		public TerminalNode METHODS() { return getToken(ABAPTestParser.METHODS, 0); }
		public List<MethodDeclContext> methodDecl() {
			return getRuleContexts(MethodDeclContext.class);
		}
		public MethodDeclContext methodDecl(int i) {
			return getRuleContext(MethodDeclContext.class,i);
		}
		public TerminalNode PERIOD() { return getToken(ABAPTestParser.PERIOD, 0); }
		public TerminalNode COLON() { return getToken(ABAPTestParser.COLON, 0); }
		public List<TerminalNode> COMMA() { return getTokens(ABAPTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ABAPTestParser.COMMA, i);
		}
		public List<ClassMemberTokenContext> classMemberToken() {
			return getRuleContexts(ClassMemberTokenContext.class);
		}
		public ClassMemberTokenContext classMemberToken(int i) {
			return getRuleContext(ClassMemberTokenContext.class,i);
		}
		public ClassMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classMember; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassMemberContext classMember() throws RecognitionException {
		ClassMemberContext _localctx = new ClassMemberContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_classMember);
		int _la;
		try {
			setState(111);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case METHODS:
				enterOuterAlt(_localctx, 1);
				{
				setState(90);
				match(METHODS);
				setState(92);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==COLON) {
					{
					setState(91);
					match(COLON);
					}
				}

				setState(94);
				methodDecl();
				setState(99);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(95);
					match(COMMA);
					setState(96);
					methodDecl();
					}
					}
					setState(101);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(102);
				match(PERIOD);
				}
				break;
			case CLASS:
			case DEFINITION:
			case IMPLEMENTATION:
			case FOR:
			case TESTING:
			case RISK:
			case LEVEL:
			case DURATION:
			case INHERITING:
			case FROM:
			case CREATE:
			case FINAL:
			case ABSTRACT:
			case SECTION:
			case METHOD:
			case ENDMETHOD:
			case IMPORTING:
			case EXPORTING:
			case CHANGING:
			case RETURNING:
			case RAISING:
			case EXCEPTIONS:
			case STATIC:
			case REDEFINITION:
			case DEFAULT:
			case IGNORE:
			case FAIL:
			case EVENT:
			case OF:
			case TYPE:
			case VALUE:
			case OPTIONAL:
			case COMMA:
			case COLON:
			case DASH:
			case LPAREN:
			case RPAREN:
			case IDENTIFIER:
			case STRING_LIT:
			case INT_LIT:
			case LINE_COMMENT:
			case WS:
			case OTHER:
				enterOuterAlt(_localctx, 2);
				{
				setState(105); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(104);
					classMemberToken();
					}
					}
					setState(107); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 1125625028354042L) != 0) );
				setState(109);
				match(PERIOD);
				}
				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 ClassMemberTokenContext extends ParserRuleContext {
		public TerminalNode METHODS() { return getToken(ABAPTestParser.METHODS, 0); }
		public TerminalNode PUBLIC() { return getToken(ABAPTestParser.PUBLIC, 0); }
		public TerminalNode PROTECTED() { return getToken(ABAPTestParser.PROTECTED, 0); }
		public TerminalNode PRIVATE() { return getToken(ABAPTestParser.PRIVATE, 0); }
		public TerminalNode ENDCLASS() { return getToken(ABAPTestParser.ENDCLASS, 0); }
		public TerminalNode PERIOD() { return getToken(ABAPTestParser.PERIOD, 0); }
		public TerminalNode EOF() { return getToken(ABAPTestParser.EOF, 0); }
		public ClassMemberTokenContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classMemberToken; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassMemberToken(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassMemberTokenContext classMemberToken() throws RecognitionException {
		ClassMemberTokenContext _localctx = new ClassMemberTokenContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_classMemberToken);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(113);
			_la = _input.LA(1);
			if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 549756977161L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MethodDeclContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(ABAPTestParser.IDENTIFIER, 0); }
		public List<MethodDeclAttrContext> methodDeclAttr() {
			return getRuleContexts(MethodDeclAttrContext.class);
		}
		public MethodDeclAttrContext methodDeclAttr(int i) {
			return getRuleContext(MethodDeclAttrContext.class,i);
		}
		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 ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitMethodDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodDeclContext methodDecl() throws RecognitionException {
		MethodDeclContext _localctx = new MethodDeclContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_methodDecl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(115);
			match(IDENTIFIER);
			setState(119);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 17834847698976L) != 0)) {
				{
				{
				setState(116);
				methodDeclAttr();
				}
				}
				setState(121);
				_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 MethodDeclAttrContext extends ParserRuleContext {
		public TerminalNode FOR() { return getToken(ABAPTestParser.FOR, 0); }
		public TerminalNode TESTING() { return getToken(ABAPTestParser.TESTING, 0); }
		public TerminalNode EVENT() { return getToken(ABAPTestParser.EVENT, 0); }
		public List<TerminalNode> IDENTIFIER() { return getTokens(ABAPTestParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ABAPTestParser.IDENTIFIER, i);
		}
		public TerminalNode OF() { return getToken(ABAPTestParser.OF, 0); }
		public TerminalNode IMPORTING() { return getToken(ABAPTestParser.IMPORTING, 0); }
		public TerminalNode EXPORTING() { return getToken(ABAPTestParser.EXPORTING, 0); }
		public TerminalNode CHANGING() { return getToken(ABAPTestParser.CHANGING, 0); }
		public TerminalNode RETURNING() { return getToken(ABAPTestParser.RETURNING, 0); }
		public TerminalNode RAISING() { return getToken(ABAPTestParser.RAISING, 0); }
		public TerminalNode EXCEPTIONS() { return getToken(ABAPTestParser.EXCEPTIONS, 0); }
		public TerminalNode ABSTRACT() { return getToken(ABAPTestParser.ABSTRACT, 0); }
		public TerminalNode FINAL() { return getToken(ABAPTestParser.FINAL, 0); }
		public TerminalNode STATIC() { return getToken(ABAPTestParser.STATIC, 0); }
		public TerminalNode REDEFINITION() { return getToken(ABAPTestParser.REDEFINITION, 0); }
		public TerminalNode DEFAULT() { return getToken(ABAPTestParser.DEFAULT, 0); }
		public TerminalNode IGNORE() { return getToken(ABAPTestParser.IGNORE, 0); }
		public TerminalNode FAIL() { return getToken(ABAPTestParser.FAIL, 0); }
		public TerminalNode TYPE() { return getToken(ABAPTestParser.TYPE, 0); }
		public TypeNameContext typeName() {
			return getRuleContext(TypeNameContext.class,0);
		}
		public TerminalNode VALUE() { return getToken(ABAPTestParser.VALUE, 0); }
		public TerminalNode LPAREN() { return getToken(ABAPTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(ABAPTestParser.RPAREN, 0); }
		public TerminalNode OPTIONAL() { return getToken(ABAPTestParser.OPTIONAL, 0); }
		public MethodDeclAttrContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodDeclAttr; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitMethodDeclAttr(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodDeclAttrContext methodDeclAttr() throws RecognitionException {
		MethodDeclAttrContext _localctx = new MethodDeclAttrContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_methodDeclAttr);
		int _la;
		try {
			setState(149);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(122);
				match(FOR);
				setState(123);
				match(TESTING);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(124);
				match(FOR);
				setState(125);
				match(EVENT);
				setState(126);
				match(IDENTIFIER);
				setState(127);
				match(OF);
				setState(128);
				match(IDENTIFIER);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(129);
				match(IMPORTING);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(130);
				match(EXPORTING);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(131);
				match(CHANGING);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(132);
				match(RETURNING);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(133);
				match(RAISING);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(134);
				match(EXCEPTIONS);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(135);
				match(ABSTRACT);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(136);
				match(FINAL);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(137);
				match(STATIC);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(138);
				match(REDEFINITION);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(139);
				match(DEFAULT);
				setState(140);
				_la = _input.LA(1);
				if ( !(_la==IGNORE || _la==FAIL) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(141);
				match(TYPE);
				setState(142);
				typeName();
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(143);
				match(VALUE);
				setState(144);
				match(LPAREN);
				setState(145);
				match(IDENTIFIER);
				setState(146);
				match(RPAREN);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(147);
				match(OPTIONAL);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(148);
				match(IDENTIFIER);
				}
				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(ABAPTestParser.IDENTIFIER); }
		public TerminalNode IDENTIFIER(int i) {
			return getToken(ABAPTestParser.IDENTIFIER, i);
		}
		public List<TerminalNode> DASH() { return getTokens(ABAPTestParser.DASH); }
		public TerminalNode DASH(int i) {
			return getToken(ABAPTestParser.DASH, i);
		}
		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 ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitTypeName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeNameContext typeName() throws RecognitionException {
		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_typeName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(151);
			match(IDENTIFIER);
			setState(156);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DASH) {
				{
				{
				setState(152);
				match(DASH);
				setState(153);
				match(IDENTIFIER);
				}
				}
				setState(158);
				_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 ClassImplContext extends ParserRuleContext {
		public TerminalNode CLASS() { return getToken(ABAPTestParser.CLASS, 0); }
		public TerminalNode IDENTIFIER() { return getToken(ABAPTestParser.IDENTIFIER, 0); }
		public TerminalNode IMPLEMENTATION() { return getToken(ABAPTestParser.IMPLEMENTATION, 0); }
		public List<TerminalNode> PERIOD() { return getTokens(ABAPTestParser.PERIOD); }
		public TerminalNode PERIOD(int i) {
			return getToken(ABAPTestParser.PERIOD, i);
		}
		public TerminalNode ENDCLASS() { return getToken(ABAPTestParser.ENDCLASS, 0); }
		public List<MethodImplContext> methodImpl() {
			return getRuleContexts(MethodImplContext.class);
		}
		public MethodImplContext methodImpl(int i) {
			return getRuleContext(MethodImplContext.class,i);
		}
		public ClassImplContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classImpl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitClassImpl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassImplContext classImpl() throws RecognitionException {
		ClassImplContext _localctx = new ClassImplContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_classImpl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(159);
			match(CLASS);
			setState(160);
			match(IDENTIFIER);
			setState(161);
			match(IMPLEMENTATION);
			setState(162);
			match(PERIOD);
			setState(166);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==METHOD) {
				{
				{
				setState(163);
				methodImpl();
				}
				}
				setState(168);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(169);
			match(ENDCLASS);
			setState(170);
			match(PERIOD);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MethodImplContext extends ParserRuleContext {
		public TerminalNode METHOD() { return getToken(ABAPTestParser.METHOD, 0); }
		public TerminalNode IDENTIFIER() { return getToken(ABAPTestParser.IDENTIFIER, 0); }
		public List<TerminalNode> PERIOD() { return getTokens(ABAPTestParser.PERIOD); }
		public TerminalNode PERIOD(int i) {
			return getToken(ABAPTestParser.PERIOD, i);
		}
		public TerminalNode ENDMETHOD() { return getToken(ABAPTestParser.ENDMETHOD, 0); }
		public List<ImplContentContext> implContent() {
			return getRuleContexts(ImplContentContext.class);
		}
		public ImplContentContext implContent(int i) {
			return getRuleContext(ImplContentContext.class,i);
		}
		public MethodImplContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodImpl; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitMethodImpl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodImplContext methodImpl() throws RecognitionException {
		MethodImplContext _localctx = new MethodImplContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_methodImpl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(172);
			match(METHOD);
			setState(173);
			match(IDENTIFIER);
			setState(174);
			match(PERIOD);
			setState(178);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1125899903696890L) != 0)) {
				{
				{
				setState(175);
				implContent();
				}
				}
				setState(180);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(181);
			match(ENDMETHOD);
			setState(182);
			match(PERIOD);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ImplContentContext extends ParserRuleContext {
		public TerminalNode METHOD() { return getToken(ABAPTestParser.METHOD, 0); }
		public TerminalNode ENDMETHOD() { return getToken(ABAPTestParser.ENDMETHOD, 0); }
		public TerminalNode ENDCLASS() { return getToken(ABAPTestParser.ENDCLASS, 0); }
		public TerminalNode EOF() { return getToken(ABAPTestParser.EOF, 0); }
		public ImplContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_implContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitImplContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ImplContentContext implContent() throws RecognitionException {
		ImplContentContext _localctx = new ImplContentContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_implContent);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(184);
			_la = _input.LA(1);
			if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 6291465L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OpaqueDeclContext extends ParserRuleContext {
		public List<OpaqueTopContext> opaqueTop() {
			return getRuleContexts(OpaqueTopContext.class);
		}
		public OpaqueTopContext opaqueTop(int i) {
			return getRuleContext(OpaqueTopContext.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 ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitOpaqueDecl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpaqueDeclContext opaqueDecl() throws RecognitionException {
		OpaqueDeclContext _localctx = new OpaqueDeclContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_opaqueDecl);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(187); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(186);
					opaqueTop();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(189); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,16,_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 OpaqueTopContext extends ParserRuleContext {
		public TerminalNode CLASS() { return getToken(ABAPTestParser.CLASS, 0); }
		public TerminalNode ENDCLASS() { return getToken(ABAPTestParser.ENDCLASS, 0); }
		public TerminalNode EOF() { return getToken(ABAPTestParser.EOF, 0); }
		public OpaqueTopContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_opaqueTop; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof ABAPTestVisitor ) return ((ABAPTestVisitor<? extends T>)visitor).visitOpaqueTop(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OpaqueTopContext opaqueTop() throws RecognitionException {
		OpaqueTopContext _localctx = new OpaqueTopContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_opaqueTop);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(191);
			_la = _input.LA(1);
			if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 13L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u00011\u00c2\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\u0001\u0000\u0005\u0000"+
		" \b\u0000\n\u0000\f\u0000#\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0003\u0001*\b\u0001\u0001\u0002\u0001\u0002"+
		"\u0001\u0002\u0001\u0002\u0005\u00020\b\u0002\n\u0002\f\u00023\t\u0002"+
		"\u0001\u0002\u0001\u0002\u0005\u00027\b\u0002\n\u0002\f\u0002:\t\u0002"+
		"\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0003\u0003C\b\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0003\u0003\u0003P\b\u0003\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0005\u0004V\b\u0004\n\u0004\f\u0004Y\t\u0004"+
		"\u0001\u0005\u0001\u0005\u0003\u0005]\b\u0005\u0001\u0005\u0001\u0005"+
		"\u0001\u0005\u0005\u0005b\b\u0005\n\u0005\f\u0005e\t\u0005\u0001\u0005"+
		"\u0001\u0005\u0001\u0005\u0004\u0005j\b\u0005\u000b\u0005\f\u0005k\u0001"+
		"\u0005\u0001\u0005\u0003\u0005p\b\u0005\u0001\u0006\u0001\u0006\u0001"+
		"\u0007\u0001\u0007\u0005\u0007v\b\u0007\n\u0007\f\u0007y\t\u0007\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003"+
		"\b\u0096\b\b\u0001\t\u0001\t\u0001\t\u0005\t\u009b\b\t\n\t\f\t\u009e\t"+
		"\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u00a5\b\n\n\n\f\n\u00a8"+
		"\t\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+
		"\u000b\u0005\u000b\u00b1\b\u000b\n\u000b\f\u000b\u00b4\t\u000b\u0001\u000b"+
		"\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0004\r\u00bc\b\r\u000b"+
		"\r\f\r\u00bd\u0001\u000e\u0001\u000e\u0001\u000e\u0000\u0000\u000f\u0000"+
		"\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c"+
		"\u0000\u0005\u0001\u0000\r\u000f\u0004\u0001\u0002\u0002\r\u000f\u0013"+
		"\u0013&&\u0001\u0000\u001f \u0002\u0001\u0002\u0002\u0014\u0015\u0001"+
		"\u0001\u0001\u0002\u00d9\u0000!\u0001\u0000\u0000\u0000\u0002)\u0001\u0000"+
		"\u0000\u0000\u0004+\u0001\u0000\u0000\u0000\u0006O\u0001\u0000\u0000\u0000"+
		"\bQ\u0001\u0000\u0000\u0000\no\u0001\u0000\u0000\u0000\fq\u0001\u0000"+
		"\u0000\u0000\u000es\u0001\u0000\u0000\u0000\u0010\u0095\u0001\u0000\u0000"+
		"\u0000\u0012\u0097\u0001\u0000\u0000\u0000\u0014\u009f\u0001\u0000\u0000"+
		"\u0000\u0016\u00ac\u0001\u0000\u0000\u0000\u0018\u00b8\u0001\u0000\u0000"+
		"\u0000\u001a\u00bb\u0001\u0000\u0000\u0000\u001c\u00bf\u0001\u0000\u0000"+
		"\u0000\u001e \u0003\u0002\u0001\u0000\u001f\u001e\u0001\u0000\u0000\u0000"+
		" #\u0001\u0000\u0000\u0000!\u001f\u0001\u0000\u0000\u0000!\"\u0001\u0000"+
		"\u0000\u0000\"$\u0001\u0000\u0000\u0000#!\u0001\u0000\u0000\u0000$%\u0005"+
		"\u0000\u0000\u0001%\u0001\u0001\u0000\u0000\u0000&*\u0003\u0004\u0002"+
		"\u0000\'*\u0003\u0014\n\u0000(*\u0003\u001a\r\u0000)&\u0001\u0000\u0000"+
		"\u0000)\'\u0001\u0000\u0000\u0000)(\u0001\u0000\u0000\u0000*\u0003\u0001"+
		"\u0000\u0000\u0000+,\u0005\u0001\u0000\u0000,-\u0005,\u0000\u0000-1\u0005"+
		"\u0003\u0000\u0000.0\u0003\u0006\u0003\u0000/.\u0001\u0000\u0000\u0000"+
		"03\u0001\u0000\u0000\u00001/\u0001\u0000\u0000\u000012\u0001\u0000\u0000"+
		"\u000024\u0001\u0000\u0000\u000031\u0001\u0000\u0000\u000048\u0005&\u0000"+
		"\u000057\u0003\b\u0004\u000065\u0001\u0000\u0000\u00007:\u0001\u0000\u0000"+
		"\u000086\u0001\u0000\u0000\u000089\u0001\u0000\u0000\u00009;\u0001\u0000"+
		"\u0000\u0000:8\u0001\u0000\u0000\u0000;<\u0005\u0002\u0000\u0000<=\u0005"+
		"&\u0000\u0000=\u0005\u0001\u0000\u0000\u0000>?\u0005\u0005\u0000\u0000"+
		"?P\u0005\u0006\u0000\u0000@B\u0005\u0007\u0000\u0000AC\u0005\b\u0000\u0000"+
		"BA\u0001\u0000\u0000\u0000BC\u0001\u0000\u0000\u0000CD\u0001\u0000\u0000"+
		"\u0000DP\u0005,\u0000\u0000EF\u0005\t\u0000\u0000FP\u0005,\u0000\u0000"+
		"GH\u0005\n\u0000\u0000HI\u0005\u000b\u0000\u0000IP\u0005,\u0000\u0000"+
		"JK\u0005\f\u0000\u0000KP\u0007\u0000\u0000\u0000LP\u0005\r\u0000\u0000"+
		"MP\u0005\u0010\u0000\u0000NP\u0005\u0011\u0000\u0000O>\u0001\u0000\u0000"+
		"\u0000O@\u0001\u0000\u0000\u0000OE\u0001\u0000\u0000\u0000OG\u0001\u0000"+
		"\u0000\u0000OJ\u0001\u0000\u0000\u0000OL\u0001\u0000\u0000\u0000OM\u0001"+
		"\u0000\u0000\u0000ON\u0001\u0000\u0000\u0000P\u0007\u0001\u0000\u0000"+
		"\u0000QR\u0007\u0000\u0000\u0000RS\u0005\u0012\u0000\u0000SW\u0005&\u0000"+
		"\u0000TV\u0003\n\u0005\u0000UT\u0001\u0000\u0000\u0000VY\u0001\u0000\u0000"+
		"\u0000WU\u0001\u0000\u0000\u0000WX\u0001\u0000\u0000\u0000X\t\u0001\u0000"+
		"\u0000\u0000YW\u0001\u0000\u0000\u0000Z\\\u0005\u0013\u0000\u0000[]\u0005"+
		"(\u0000\u0000\\[\u0001\u0000\u0000\u0000\\]\u0001\u0000\u0000\u0000]^"+
		"\u0001\u0000\u0000\u0000^c\u0003\u000e\u0007\u0000_`\u0005\'\u0000\u0000"+
		"`b\u0003\u000e\u0007\u0000a_\u0001\u0000\u0000\u0000be\u0001\u0000\u0000"+
		"\u0000ca\u0001\u0000\u0000\u0000cd\u0001\u0000\u0000\u0000df\u0001\u0000"+
		"\u0000\u0000ec\u0001\u0000\u0000\u0000fg\u0005&\u0000\u0000gp\u0001\u0000"+
		"\u0000\u0000hj\u0003\f\u0006\u0000ih\u0001\u0000\u0000\u0000jk\u0001\u0000"+
		"\u0000\u0000ki\u0001\u0000\u0000\u0000kl\u0001\u0000\u0000\u0000lm\u0001"+
		"\u0000\u0000\u0000mn\u0005&\u0000\u0000np\u0001\u0000\u0000\u0000oZ\u0001"+
		"\u0000\u0000\u0000oi\u0001\u0000\u0000\u0000p\u000b\u0001\u0000\u0000"+
		"\u0000qr\b\u0001\u0000\u0000r\r\u0001\u0000\u0000\u0000sw\u0005,\u0000"+
		"\u0000tv\u0003\u0010\b\u0000ut\u0001\u0000\u0000\u0000vy\u0001\u0000\u0000"+
		"\u0000wu\u0001\u0000\u0000\u0000wx\u0001\u0000\u0000\u0000x\u000f\u0001"+
		"\u0000\u0000\u0000yw\u0001\u0000\u0000\u0000z{\u0005\u0005\u0000\u0000"+
		"{\u0096\u0005\u0006\u0000\u0000|}\u0005\u0005\u0000\u0000}~\u0005!\u0000"+
		"\u0000~\u007f\u0005,\u0000\u0000\u007f\u0080\u0005\"\u0000\u0000\u0080"+
		"\u0096\u0005,\u0000\u0000\u0081\u0096\u0005\u0016\u0000\u0000\u0082\u0096"+
		"\u0005\u0017\u0000\u0000\u0083\u0096\u0005\u0018\u0000\u0000\u0084\u0096"+
		"\u0005\u0019\u0000\u0000\u0085\u0096\u0005\u001a\u0000\u0000\u0086\u0096"+
		"\u0005\u001b\u0000\u0000\u0087\u0096\u0005\u0011\u0000\u0000\u0088\u0096"+
		"\u0005\u0010\u0000\u0000\u0089\u0096\u0005\u001c\u0000\u0000\u008a\u0096"+
		"\u0005\u001d\u0000\u0000\u008b\u008c\u0005\u001e\u0000\u0000\u008c\u0096"+
		"\u0007\u0002\u0000\u0000\u008d\u008e\u0005#\u0000\u0000\u008e\u0096\u0003"+
		"\u0012\t\u0000\u008f\u0090\u0005$\u0000\u0000\u0090\u0091\u0005*\u0000"+
		"\u0000\u0091\u0092\u0005,\u0000\u0000\u0092\u0096\u0005+\u0000\u0000\u0093"+
		"\u0096\u0005%\u0000\u0000\u0094\u0096\u0005,\u0000\u0000\u0095z\u0001"+
		"\u0000\u0000\u0000\u0095|\u0001\u0000\u0000\u0000\u0095\u0081\u0001\u0000"+
		"\u0000\u0000\u0095\u0082\u0001\u0000\u0000\u0000\u0095\u0083\u0001\u0000"+
		"\u0000\u0000\u0095\u0084\u0001\u0000\u0000\u0000\u0095\u0085\u0001\u0000"+
		"\u0000\u0000\u0095\u0086\u0001\u0000\u0000\u0000\u0095\u0087\u0001\u0000"+
		"\u0000\u0000\u0095\u0088\u0001\u0000\u0000\u0000\u0095\u0089\u0001\u0000"+
		"\u0000\u0000\u0095\u008a\u0001\u0000\u0000\u0000\u0095\u008b\u0001\u0000"+
		"\u0000\u0000\u0095\u008d\u0001\u0000\u0000\u0000\u0095\u008f\u0001\u0000"+
		"\u0000\u0000\u0095\u0093\u0001\u0000\u0000\u0000\u0095\u0094\u0001\u0000"+
		"\u0000\u0000\u0096\u0011\u0001\u0000\u0000\u0000\u0097\u009c\u0005,\u0000"+
		"\u0000\u0098\u0099\u0005)\u0000\u0000\u0099\u009b\u0005,\u0000\u0000\u009a"+
		"\u0098\u0001\u0000\u0000\u0000\u009b\u009e\u0001\u0000\u0000\u0000\u009c"+
		"\u009a\u0001\u0000\u0000\u0000\u009c\u009d\u0001\u0000\u0000\u0000\u009d"+
		"\u0013\u0001\u0000\u0000\u0000\u009e\u009c\u0001\u0000\u0000\u0000\u009f"+
		"\u00a0\u0005\u0001\u0000\u0000\u00a0\u00a1\u0005,\u0000\u0000\u00a1\u00a2"+
		"\u0005\u0004\u0000\u0000\u00a2\u00a6\u0005&\u0000\u0000\u00a3\u00a5\u0003"+
		"\u0016\u000b\u0000\u00a4\u00a3\u0001\u0000\u0000\u0000\u00a5\u00a8\u0001"+
		"\u0000\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000\u0000\u00a6\u00a7\u0001"+
		"\u0000\u0000\u0000\u00a7\u00a9\u0001\u0000\u0000\u0000\u00a8\u00a6\u0001"+
		"\u0000\u0000\u0000\u00a9\u00aa\u0005\u0002\u0000\u0000\u00aa\u00ab\u0005"+
		"&\u0000\u0000\u00ab\u0015\u0001\u0000\u0000\u0000\u00ac\u00ad\u0005\u0014"+
		"\u0000\u0000\u00ad\u00ae\u0005,\u0000\u0000\u00ae\u00b2\u0005&\u0000\u0000"+
		"\u00af\u00b1\u0003\u0018\f\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\u0015\u0000\u0000\u00b6"+
		"\u00b7\u0005&\u0000\u0000\u00b7\u0017\u0001\u0000\u0000\u0000\u00b8\u00b9"+
		"\b\u0003\u0000\u0000\u00b9\u0019\u0001\u0000\u0000\u0000\u00ba\u00bc\u0003"+
		"\u001c\u000e\u0000\u00bb\u00ba\u0001\u0000\u0000\u0000\u00bc\u00bd\u0001"+
		"\u0000\u0000\u0000\u00bd\u00bb\u0001\u0000\u0000\u0000\u00bd\u00be\u0001"+
		"\u0000\u0000\u0000\u00be\u001b\u0001\u0000\u0000\u0000\u00bf\u00c0\b\u0004"+
		"\u0000\u0000\u00c0\u001d\u0001\u0000\u0000\u0000\u0011!)18BOW\\ckow\u0095"+
		"\u009c\u00a6\u00b2\u00bd";
	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);
		}
	}
}