COBOLTestParser.java

// Generated from org/egothor/methodatlas/discovery/cobol/parser/COBOLTest.g4 by ANTLR 4.13.2
package org.egothor.methodatlas.discovery.cobol.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 COBOLTestParser 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
		MFU_TC_ID=1, TESTSUITE=2, TESTCASE=3, SECTION=4, DIVISION=5, PROCEDURE=6, 
		PERIOD=7, COMMA=8, IDENTIFIER=9, QUOTED_STRING=10, INT_LIT=11, LINE_COMMENT=12, 
		WS=13, OTHER=14;
	public static final int
		RULE_sourceFile = 0, RULE_element = 1, RULE_mfunitParagraph = 2, RULE_paragraphContent = 3, 
		RULE_cobolCheckSuite = 4, RULE_cobolCheckCase = 5, RULE_caseContent = 6, 
		RULE_string_ = 7, RULE_otherElement = 8;
	private static String[] makeRuleNames() {
		return new String[] {
			"sourceFile", "element", "mfunitParagraph", "paragraphContent", "cobolCheckSuite", 
			"cobolCheckCase", "caseContent", "string_", "otherElement"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, "'TESTSUITE'", "'TESTCASE'", "'SECTION'", "'DIVISION'", "'PROCEDURE'", 
			"'.'", "','"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "MFU_TC_ID", "TESTSUITE", "TESTCASE", "SECTION", "DIVISION", "PROCEDURE", 
			"PERIOD", "COMMA", "IDENTIFIER", "QUOTED_STRING", "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 "COBOLTest.g4"; }

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

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

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

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

	@SuppressWarnings("CheckReturnValue")
	public static class SourceFileContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(COBOLTestParser.EOF, 0); }
		public List<ElementContext> element() {
			return getRuleContexts(ElementContext.class);
		}
		public ElementContext element(int i) {
			return getRuleContext(ElementContext.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 COBOLTestVisitor ) return ((COBOLTestVisitor<? 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(21);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 32766L) != 0)) {
				{
				{
				setState(18);
				element();
				}
				}
				setState(23);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(24);
			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 ElementContext extends ParserRuleContext {
		public MfunitParagraphContext mfunitParagraph() {
			return getRuleContext(MfunitParagraphContext.class,0);
		}
		public CobolCheckCaseContext cobolCheckCase() {
			return getRuleContext(CobolCheckCaseContext.class,0);
		}
		public CobolCheckSuiteContext cobolCheckSuite() {
			return getRuleContext(CobolCheckSuiteContext.class,0);
		}
		public OtherElementContext otherElement() {
			return getRuleContext(OtherElementContext.class,0);
		}
		public ElementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_element; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitElement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ElementContext element() throws RecognitionException {
		ElementContext _localctx = new ElementContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_element);
		try {
			setState(30);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case MFU_TC_ID:
				enterOuterAlt(_localctx, 1);
				{
				setState(26);
				mfunitParagraph();
				}
				break;
			case TESTCASE:
				enterOuterAlt(_localctx, 2);
				{
				setState(27);
				cobolCheckCase();
				}
				break;
			case TESTSUITE:
				enterOuterAlt(_localctx, 3);
				{
				setState(28);
				cobolCheckSuite();
				}
				break;
			case SECTION:
			case DIVISION:
			case PROCEDURE:
			case PERIOD:
			case COMMA:
			case IDENTIFIER:
			case QUOTED_STRING:
			case INT_LIT:
			case LINE_COMMENT:
			case WS:
			case OTHER:
				enterOuterAlt(_localctx, 4);
				{
				setState(29);
				otherElement();
				}
				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 MfunitParagraphContext extends ParserRuleContext {
		public TerminalNode MFU_TC_ID() { return getToken(COBOLTestParser.MFU_TC_ID, 0); }
		public TerminalNode PERIOD() { return getToken(COBOLTestParser.PERIOD, 0); }
		public List<ParagraphContentContext> paragraphContent() {
			return getRuleContexts(ParagraphContentContext.class);
		}
		public ParagraphContentContext paragraphContent(int i) {
			return getRuleContext(ParagraphContentContext.class,i);
		}
		public MfunitParagraphContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_mfunitParagraph; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitMfunitParagraph(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MfunitParagraphContext mfunitParagraph() throws RecognitionException {
		MfunitParagraphContext _localctx = new MfunitParagraphContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_mfunitParagraph);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(32);
			match(MFU_TC_ID);
			setState(33);
			match(PERIOD);
			setState(37);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(34);
					paragraphContent();
					}
					} 
				}
				setState(39);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParagraphContentContext extends ParserRuleContext {
		public TerminalNode MFU_TC_ID() { return getToken(COBOLTestParser.MFU_TC_ID, 0); }
		public TerminalNode TESTCASE() { return getToken(COBOLTestParser.TESTCASE, 0); }
		public TerminalNode TESTSUITE() { return getToken(COBOLTestParser.TESTSUITE, 0); }
		public TerminalNode EOF() { return getToken(COBOLTestParser.EOF, 0); }
		public ParagraphContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paragraphContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitParagraphContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParagraphContentContext paragraphContent() throws RecognitionException {
		ParagraphContentContext _localctx = new ParagraphContentContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_paragraphContent);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(40);
			_la = _input.LA(1);
			if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 29L) != 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 CobolCheckSuiteContext extends ParserRuleContext {
		public TerminalNode TESTSUITE() { return getToken(COBOLTestParser.TESTSUITE, 0); }
		public String_Context string_() {
			return getRuleContext(String_Context.class,0);
		}
		public CobolCheckSuiteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cobolCheckSuite; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitCobolCheckSuite(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CobolCheckSuiteContext cobolCheckSuite() throws RecognitionException {
		CobolCheckSuiteContext _localctx = new CobolCheckSuiteContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_cobolCheckSuite);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(42);
			match(TESTSUITE);
			setState(43);
			string_();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CobolCheckCaseContext extends ParserRuleContext {
		public TerminalNode TESTCASE() { return getToken(COBOLTestParser.TESTCASE, 0); }
		public String_Context string_() {
			return getRuleContext(String_Context.class,0);
		}
		public List<CaseContentContext> caseContent() {
			return getRuleContexts(CaseContentContext.class);
		}
		public CaseContentContext caseContent(int i) {
			return getRuleContext(CaseContentContext.class,i);
		}
		public CobolCheckCaseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_cobolCheckCase; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitCobolCheckCase(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CobolCheckCaseContext cobolCheckCase() throws RecognitionException {
		CobolCheckCaseContext _localctx = new CobolCheckCaseContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_cobolCheckCase);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(45);
			match(TESTCASE);
			setState(46);
			string_();
			setState(50);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(47);
					caseContent();
					}
					} 
				}
				setState(52);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CaseContentContext extends ParserRuleContext {
		public TerminalNode TESTCASE() { return getToken(COBOLTestParser.TESTCASE, 0); }
		public TerminalNode TESTSUITE() { return getToken(COBOLTestParser.TESTSUITE, 0); }
		public TerminalNode MFU_TC_ID() { return getToken(COBOLTestParser.MFU_TC_ID, 0); }
		public TerminalNode EOF() { return getToken(COBOLTestParser.EOF, 0); }
		public CaseContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_caseContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitCaseContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CaseContentContext caseContent() throws RecognitionException {
		CaseContentContext _localctx = new CaseContentContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_caseContent);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(53);
			_la = _input.LA(1);
			if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 29L) != 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 String_Context extends ParserRuleContext {
		public TerminalNode QUOTED_STRING() { return getToken(COBOLTestParser.QUOTED_STRING, 0); }
		public TerminalNode IDENTIFIER() { return getToken(COBOLTestParser.IDENTIFIER, 0); }
		public String_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_string_; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitString_(this);
			else return visitor.visitChildren(this);
		}
	}

	public final String_Context string_() throws RecognitionException {
		String_Context _localctx = new String_Context(_ctx, getState());
		enterRule(_localctx, 14, RULE_string_);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(55);
			_la = _input.LA(1);
			if ( !(_la==IDENTIFIER || _la==QUOTED_STRING) ) {
			_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 OtherElementContext extends ParserRuleContext {
		public List<TerminalNode> MFU_TC_ID() { return getTokens(COBOLTestParser.MFU_TC_ID); }
		public TerminalNode MFU_TC_ID(int i) {
			return getToken(COBOLTestParser.MFU_TC_ID, i);
		}
		public List<TerminalNode> TESTCASE() { return getTokens(COBOLTestParser.TESTCASE); }
		public TerminalNode TESTCASE(int i) {
			return getToken(COBOLTestParser.TESTCASE, i);
		}
		public List<TerminalNode> TESTSUITE() { return getTokens(COBOLTestParser.TESTSUITE); }
		public TerminalNode TESTSUITE(int i) {
			return getToken(COBOLTestParser.TESTSUITE, i);
		}
		public List<TerminalNode> EOF() { return getTokens(COBOLTestParser.EOF); }
		public TerminalNode EOF(int i) {
			return getToken(COBOLTestParser.EOF, i);
		}
		public OtherElementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_otherElement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof COBOLTestVisitor ) return ((COBOLTestVisitor<? extends T>)visitor).visitOtherElement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OtherElementContext otherElement() throws RecognitionException {
		OtherElementContext _localctx = new OtherElementContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_otherElement);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(58); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(57);
					_la = _input.LA(1);
					if ( _la <= 0 || (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & 29L) != 0)) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(60); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\u0004\u0001\u000e?\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\u0001\u0000\u0005\u0000\u0014\b\u0000\n\u0000\f\u0000\u0017"+
		"\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0003\u0001\u001f\b\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0005"+
		"\u0002$\b\u0002\n\u0002\f\u0002\'\t\u0002\u0001\u0003\u0001\u0003\u0001"+
		"\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0005"+
		"\u00051\b\u0005\n\u0005\f\u00054\t\u0005\u0001\u0006\u0001\u0006\u0001"+
		"\u0007\u0001\u0007\u0001\b\u0004\b;\b\b\u000b\b\f\b<\u0001\b\u0000\u0000"+
		"\t\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0000\u0002\u0001\u0001\u0001"+
		"\u0003\u0001\u0000\t\n<\u0000\u0015\u0001\u0000\u0000\u0000\u0002\u001e"+
		"\u0001\u0000\u0000\u0000\u0004 \u0001\u0000\u0000\u0000\u0006(\u0001\u0000"+
		"\u0000\u0000\b*\u0001\u0000\u0000\u0000\n-\u0001\u0000\u0000\u0000\f5"+
		"\u0001\u0000\u0000\u0000\u000e7\u0001\u0000\u0000\u0000\u0010:\u0001\u0000"+
		"\u0000\u0000\u0012\u0014\u0003\u0002\u0001\u0000\u0013\u0012\u0001\u0000"+
		"\u0000\u0000\u0014\u0017\u0001\u0000\u0000\u0000\u0015\u0013\u0001\u0000"+
		"\u0000\u0000\u0015\u0016\u0001\u0000\u0000\u0000\u0016\u0018\u0001\u0000"+
		"\u0000\u0000\u0017\u0015\u0001\u0000\u0000\u0000\u0018\u0019\u0005\u0000"+
		"\u0000\u0001\u0019\u0001\u0001\u0000\u0000\u0000\u001a\u001f\u0003\u0004"+
		"\u0002\u0000\u001b\u001f\u0003\n\u0005\u0000\u001c\u001f\u0003\b\u0004"+
		"\u0000\u001d\u001f\u0003\u0010\b\u0000\u001e\u001a\u0001\u0000\u0000\u0000"+
		"\u001e\u001b\u0001\u0000\u0000\u0000\u001e\u001c\u0001\u0000\u0000\u0000"+
		"\u001e\u001d\u0001\u0000\u0000\u0000\u001f\u0003\u0001\u0000\u0000\u0000"+
		" !\u0005\u0001\u0000\u0000!%\u0005\u0007\u0000\u0000\"$\u0003\u0006\u0003"+
		"\u0000#\"\u0001\u0000\u0000\u0000$\'\u0001\u0000\u0000\u0000%#\u0001\u0000"+
		"\u0000\u0000%&\u0001\u0000\u0000\u0000&\u0005\u0001\u0000\u0000\u0000"+
		"\'%\u0001\u0000\u0000\u0000()\b\u0000\u0000\u0000)\u0007\u0001\u0000\u0000"+
		"\u0000*+\u0005\u0002\u0000\u0000+,\u0003\u000e\u0007\u0000,\t\u0001\u0000"+
		"\u0000\u0000-.\u0005\u0003\u0000\u0000.2\u0003\u000e\u0007\u0000/1\u0003"+
		"\f\u0006\u00000/\u0001\u0000\u0000\u000014\u0001\u0000\u0000\u000020\u0001"+
		"\u0000\u0000\u000023\u0001\u0000\u0000\u00003\u000b\u0001\u0000\u0000"+
		"\u000042\u0001\u0000\u0000\u000056\b\u0000\u0000\u00006\r\u0001\u0000"+
		"\u0000\u000078\u0007\u0001\u0000\u00008\u000f\u0001\u0000\u0000\u0000"+
		"9;\b\u0000\u0000\u0000:9\u0001\u0000\u0000\u0000;<\u0001\u0000\u0000\u0000"+
		"<:\u0001\u0000\u0000\u0000<=\u0001\u0000\u0000\u0000=\u0011\u0001\u0000"+
		"\u0000\u0000\u0005\u0015\u001e%2<";
	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);
		}
	}
}