• Home
• org.netbeans.modules
• org-netbeans-modules-languages-antlr
• RELEASE240
• source code
• ANTLRv3Parser.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.antlr.parser.antlr3.ANTLRv3Parser Maven / Gradle / Ivy

// Generated from ANTLRv3Parser.g4 by ANTLR 4.13.1


/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

// DO NOT EDIT THIS FILE MANUALLY!
// SEE build.xml FOR INSTRUCTIONS


package org.antlr.parser.antlr3;


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"})
public class ANTLRv3Parser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		DOC_COMMENT=1, PARSER=2, LEXER=3, RULE=4, BLOCK=5, OPTIONAL=6, CLOSURE=7, 
		POSITIVE_CLOSURE=8, SYNPRED=9, RANGE=10, CHAR_RANGE=11, EPSILON=12, ALT=13, 
		EOR=14, EOB=15, EOA=16, ID=17, ARG=18, ARGLIST=19, RET=20, LEXER_GRAMMAR=21, 
		PARSER_GRAMMAR=22, TREE_GRAMMAR=23, COMBINED_GRAMMAR=24, INITACTION=25, 
		LABEL=26, TEMPLATE=27, SCOPE=28, SEMPRED=29, GATED_SEMPRED=30, SYN_SEMPRED=31, 
		BACKTRACK_SEMPRED=32, FRAGMENT=33, TREE_BEGIN=34, ROOT=35, BANG=36, REWRITE=37, 
		ACTION_CONTENT=38, SL_COMMENT=39, ML_COMMENT=40, INT=41, CHAR_LITERAL=42, 
		STRING_LITERAL=43, DOUBLE_QUOTE_STRING_LITERAL=44, DOUBLE_ANGLE_STRING_LITERAL=45, 
		BEGIN_ARGUMENT=46, BEGIN_ACTION=47, OPTIONS=48, TOKENS=49, CATCH=50, FINALLY=51, 
		GRAMMAR=52, PRIVATE=53, PROTECTED=54, PUBLIC=55, RETURNS=56, THROWS=57, 
		TREE=58, AT=59, COLON=60, COLONCOLON=61, COMMA=62, DOT=63, EQUAL=64, LBRACE=65, 
		LBRACK=66, LPAREN=67, OR=68, PLUS=69, QM=70, RBRACE=71, RBRACK=72, RPAREN=73, 
		SEMI=74, SEMPREDOP=75, STAR=76, DOLLAR=77, PEQ=78, NOT=79, WS=80, TOKEN_REF=81, 
		RULE_REF=82, END_ARGUMENT=83, UNTERMINATED_ARGUMENT=84, ARGUMENT_CONTENT=85, 
		END_ACTION=86, UNTERMINATED_ACTION=87, OPT_LBRACE=88, LEXER_CHAR_SET=89, 
		UNTERMINATED_CHAR_SET=90;
	public static final int
		RULE_grammarDef = 0, RULE_tokensSpec = 1, RULE_tokenSpec = 2, RULE_attrScope = 3, 
		RULE_action = 4, RULE_actionScopeName = 5, RULE_optionsSpec = 6, RULE_option = 7, 
		RULE_optionValue = 8, RULE_rule_ = 9, RULE_ruleAction = 10, RULE_throwsSpec = 11, 
		RULE_ruleScopeSpec = 12, RULE_block = 13, RULE_altList = 14, RULE_alternative = 15, 
		RULE_exceptionGroup = 16, RULE_exceptionHandler = 17, RULE_finallyClause = 18, 
		RULE_element = 19, RULE_elementNoOptionSpec = 20, RULE_actionBlock = 21, 
		RULE_argActionBlock = 22, RULE_atom = 23, RULE_notSet = 24, RULE_treeSpec = 25, 
		RULE_ebnf = 26, RULE_range_ = 27, RULE_terminal_ = 28, RULE_notTerminal = 29, 
		RULE_ebnfSuffix = 30, RULE_rewrite = 31, RULE_rewrite_alternative = 32, 
		RULE_rewrite_tree_block = 33, RULE_rewrite_tree_alternative = 34, RULE_rewrite_tree_element = 35, 
		RULE_rewrite_tree_atom = 36, RULE_rewrite_tree_ebnf = 37, RULE_rewrite_tree = 38, 
		RULE_rewrite_template = 39, RULE_rewrite_template_ref = 40, RULE_rewrite_indirect_template_head = 41, 
		RULE_rewrite_template_args = 42, RULE_rewrite_template_arg = 43, RULE_id_ = 44;
	private static String[] makeRuleNames() {
		return new String[] {
			"grammarDef", "tokensSpec", "tokenSpec", "attrScope", "action", "actionScopeName", 
			"optionsSpec", "option", "optionValue", "rule_", "ruleAction", "throwsSpec", 
			"ruleScopeSpec", "block", "altList", "alternative", "exceptionGroup", 
			"exceptionHandler", "finallyClause", "element", "elementNoOptionSpec", 
			"actionBlock", "argActionBlock", "atom", "notSet", "treeSpec", "ebnf", 
			"range_", "terminal_", "notTerminal", "ebnfSuffix", "rewrite", "rewrite_alternative", 
			"rewrite_tree_block", "rewrite_tree_alternative", "rewrite_tree_element", 
			"rewrite_tree_atom", "rewrite_tree_ebnf", "rewrite_tree", "rewrite_template", 
			"rewrite_template_ref", "rewrite_indirect_template_head", "rewrite_template_args", 
			"rewrite_template_arg", "id_"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, null, "'parser'", "'lexer'", null, null, null, null, null, null, 
			"'..'", null, null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, "'scope'", null, null, null, null, 
			"'fragment'", "'^('", "'^'", "'!'", null, null, null, null, null, null, 
			null, null, null, null, null, "'options'", "'tokens'", "'catch'", "'finally'", 
			"'grammar'", "'private'", "'protected'", "'public'", "'returns'", "'throws'", 
			"'tree'", null, null, null, null, null, null, null, null, null, null, 
			null, null, null, null, null, null, "'=>'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "DOC_COMMENT", "PARSER", "LEXER", "RULE", "BLOCK", "OPTIONAL", 
			"CLOSURE", "POSITIVE_CLOSURE", "SYNPRED", "RANGE", "CHAR_RANGE", "EPSILON", 
			"ALT", "EOR", "EOB", "EOA", "ID", "ARG", "ARGLIST", "RET", "LEXER_GRAMMAR", 
			"PARSER_GRAMMAR", "TREE_GRAMMAR", "COMBINED_GRAMMAR", "INITACTION", "LABEL", 
			"TEMPLATE", "SCOPE", "SEMPRED", "GATED_SEMPRED", "SYN_SEMPRED", "BACKTRACK_SEMPRED", 
			"FRAGMENT", "TREE_BEGIN", "ROOT", "BANG", "REWRITE", "ACTION_CONTENT", 
			"SL_COMMENT", "ML_COMMENT", "INT", "CHAR_LITERAL", "STRING_LITERAL", 
			"DOUBLE_QUOTE_STRING_LITERAL", "DOUBLE_ANGLE_STRING_LITERAL", "BEGIN_ARGUMENT", 
			"BEGIN_ACTION", "OPTIONS", "TOKENS", "CATCH", "FINALLY", "GRAMMAR", "PRIVATE", 
			"PROTECTED", "PUBLIC", "RETURNS", "THROWS", "TREE", "AT", "COLON", "COLONCOLON", 
			"COMMA", "DOT", "EQUAL", "LBRACE", "LBRACK", "LPAREN", "OR", "PLUS", 
			"QM", "RBRACE", "RBRACK", "RPAREN", "SEMI", "SEMPREDOP", "STAR", "DOLLAR", 
			"PEQ", "NOT", "WS", "TOKEN_REF", "RULE_REF", "END_ARGUMENT", "UNTERMINATED_ARGUMENT", 
			"ARGUMENT_CONTENT", "END_ACTION", "UNTERMINATED_ACTION", "OPT_LBRACE", 
			"LEXER_CHAR_SET", "UNTERMINATED_CHAR_SET"
		};
	}
	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] = "";
			}
		}
	}

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

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

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

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

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

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

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

	@SuppressWarnings("CheckReturnValue")
	public static class GrammarDefContext extends ParserRuleContext {
		public TerminalNode GRAMMAR() { return getToken(ANTLRv3Parser.GRAMMAR, 0); }
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode SEMI() { return getToken(ANTLRv3Parser.SEMI, 0); }
		public TerminalNode EOF() { return getToken(ANTLRv3Parser.EOF, 0); }
		public TerminalNode LEXER() { return getToken(ANTLRv3Parser.LEXER, 0); }
		public TerminalNode PARSER() { return getToken(ANTLRv3Parser.PARSER, 0); }
		public TerminalNode TREE() { return getToken(ANTLRv3Parser.TREE, 0); }
		public TerminalNode DOC_COMMENT() { return getToken(ANTLRv3Parser.DOC_COMMENT, 0); }
		public OptionsSpecContext optionsSpec() {
			return getRuleContext(OptionsSpecContext.class,0);
		}
		public TokensSpecContext tokensSpec() {
			return getRuleContext(TokensSpecContext.class,0);
		}
		public List attrScope() {
			return getRuleContexts(AttrScopeContext.class);
		}
		public AttrScopeContext attrScope(int i) {
			return getRuleContext(AttrScopeContext.class,i);
		}
		public List action() {
			return getRuleContexts(ActionContext.class);
		}
		public ActionContext action(int i) {
			return getRuleContext(ActionContext.class,i);
		}
		public List rule_() {
			return getRuleContexts(Rule_Context.class);
		}
		public Rule_Context rule_(int i) {
			return getRuleContext(Rule_Context.class,i);
		}
		public GrammarDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_grammarDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterGrammarDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitGrammarDef(this);
		}
	}

	public final GrammarDefContext grammarDef() throws RecognitionException {
		GrammarDefContext _localctx = new GrammarDefContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_grammarDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(91);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOC_COMMENT) {
				{
				setState(90);
				match(DOC_COMMENT);
				}
			}

			setState(97);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LEXER:
				{
				setState(93);
				match(LEXER);
				}
				break;
			case PARSER:
				{
				setState(94);
				match(PARSER);
				}
				break;
			case TREE:
				{
				setState(95);
				match(TREE);
				}
				break;
			case GRAMMAR:
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(99);
			match(GRAMMAR);
			setState(100);
			id_();
			setState(101);
			match(SEMI);
			setState(103);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPTIONS) {
				{
				setState(102);
				optionsSpec();
				}
			}

			setState(106);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==TOKENS) {
				{
				setState(105);
				tokensSpec();
				}
			}

			setState(111);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SCOPE) {
				{
				{
				setState(108);
				attrScope();
				}
				}
				setState(113);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(117);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==AT) {
				{
				{
				setState(114);
				action();
				}
				}
				setState(119);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(121); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(120);
				rule_();
				}
				}
				setState(123); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 63050403373121538L) != 0) || _la==TOKEN_REF || _la==RULE_REF );
			setState(125);
			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 TokensSpecContext extends ParserRuleContext {
		public TerminalNode TOKENS() { return getToken(ANTLRv3Parser.TOKENS, 0); }
		public TerminalNode LBRACE() { return getToken(ANTLRv3Parser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(ANTLRv3Parser.RBRACE, 0); }
		public List tokenSpec() {
			return getRuleContexts(TokenSpecContext.class);
		}
		public TokenSpecContext tokenSpec(int i) {
			return getRuleContext(TokenSpecContext.class,i);
		}
		public TokensSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tokensSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterTokensSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitTokensSpec(this);
		}
	}

	public final TokensSpecContext tokensSpec() throws RecognitionException {
		TokensSpecContext _localctx = new TokensSpecContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_tokensSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(127);
			match(TOKENS);
			setState(128);
			match(LBRACE);
			setState(130); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(129);
				tokenSpec();
				}
				}
				setState(132); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==TOKEN_REF );
			setState(134);
			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 TokenSpecContext extends ParserRuleContext {
		public TerminalNode TOKEN_REF() { return getToken(ANTLRv3Parser.TOKEN_REF, 0); }
		public TerminalNode SEMI() { return getToken(ANTLRv3Parser.SEMI, 0); }
		public TerminalNode EQUAL() { return getToken(ANTLRv3Parser.EQUAL, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ANTLRv3Parser.STRING_LITERAL, 0); }
		public TerminalNode CHAR_LITERAL() { return getToken(ANTLRv3Parser.CHAR_LITERAL, 0); }
		public TokenSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tokenSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterTokenSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitTokenSpec(this);
		}
	}

	public final TokenSpecContext tokenSpec() throws RecognitionException {
		TokenSpecContext _localctx = new TokenSpecContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_tokenSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(136);
			match(TOKEN_REF);
			setState(140);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case EQUAL:
				{
				setState(137);
				match(EQUAL);
				setState(138);
				_la = _input.LA(1);
				if ( !(_la==CHAR_LITERAL || _la==STRING_LITERAL) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case SEMI:
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(142);
			match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttrScopeContext extends ParserRuleContext {
		public TerminalNode SCOPE() { return getToken(ANTLRv3Parser.SCOPE, 0); }
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public AttrScopeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attrScope; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterAttrScope(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitAttrScope(this);
		}
	}

	public final AttrScopeContext attrScope() throws RecognitionException {
		AttrScopeContext _localctx = new AttrScopeContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_attrScope);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(144);
			match(SCOPE);
			setState(145);
			id_();
			setState(146);
			actionBlock();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ActionContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(ANTLRv3Parser.AT, 0); }
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public ActionScopeNameContext actionScopeName() {
			return getRuleContext(ActionScopeNameContext.class,0);
		}
		public TerminalNode COLONCOLON() { return getToken(ANTLRv3Parser.COLONCOLON, 0); }
		public ActionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_action; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterAction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitAction(this);
		}
	}

	public final ActionContext action() throws RecognitionException {
		ActionContext _localctx = new ActionContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_action);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(148);
			match(AT);
			setState(152);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(149);
				actionScopeName();
				setState(150);
				match(COLONCOLON);
				}
				break;
			}
			setState(154);
			id_();
			setState(155);
			actionBlock();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ActionScopeNameContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode LEXER() { return getToken(ANTLRv3Parser.LEXER, 0); }
		public TerminalNode PARSER() { return getToken(ANTLRv3Parser.PARSER, 0); }
		public ActionScopeNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_actionScopeName; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterActionScopeName(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitActionScopeName(this);
		}
	}

	public final ActionScopeNameContext actionScopeName() throws RecognitionException {
		ActionScopeNameContext _localctx = new ActionScopeNameContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_actionScopeName);
		try {
			setState(160);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case TOKEN_REF:
			case RULE_REF:
				enterOuterAlt(_localctx, 1);
				{
				setState(157);
				id_();
				}
				break;
			case LEXER:
				enterOuterAlt(_localctx, 2);
				{
				setState(158);
				match(LEXER);
				}
				break;
			case PARSER:
				enterOuterAlt(_localctx, 3);
				{
				setState(159);
				match(PARSER);
				}
				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 OptionsSpecContext extends ParserRuleContext {
		public TerminalNode OPTIONS() { return getToken(ANTLRv3Parser.OPTIONS, 0); }
		public TerminalNode LBRACE() { return getToken(ANTLRv3Parser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(ANTLRv3Parser.RBRACE, 0); }
		public List option() {
			return getRuleContexts(OptionContext.class);
		}
		public OptionContext option(int i) {
			return getRuleContext(OptionContext.class,i);
		}
		public OptionsSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_optionsSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterOptionsSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitOptionsSpec(this);
		}
	}

	public final OptionsSpecContext optionsSpec() throws RecognitionException {
		OptionsSpecContext _localctx = new OptionsSpecContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_optionsSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(162);
			match(OPTIONS);
			setState(163);
			match(LBRACE);
			setState(167);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==TOKEN_REF || _la==RULE_REF) {
				{
				{
				setState(164);
				option();
				}
				}
				setState(169);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(170);
			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 OptionContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode EQUAL() { return getToken(ANTLRv3Parser.EQUAL, 0); }
		public OptionValueContext optionValue() {
			return getRuleContext(OptionValueContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(ANTLRv3Parser.SEMI, 0); }
		public OptionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_option; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterOption(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitOption(this);
		}
	}

	public final OptionContext option() throws RecognitionException {
		OptionContext _localctx = new OptionContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_option);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(172);
			id_();
			setState(173);
			match(EQUAL);
			setState(174);
			optionValue();
			setState(175);
			match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OptionValueContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode STRING_LITERAL() { return getToken(ANTLRv3Parser.STRING_LITERAL, 0); }
		public TerminalNode CHAR_LITERAL() { return getToken(ANTLRv3Parser.CHAR_LITERAL, 0); }
		public TerminalNode INT() { return getToken(ANTLRv3Parser.INT, 0); }
		public TerminalNode STAR() { return getToken(ANTLRv3Parser.STAR, 0); }
		public OptionValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_optionValue; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterOptionValue(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitOptionValue(this);
		}
	}

	public final OptionValueContext optionValue() throws RecognitionException {
		OptionValueContext _localctx = new OptionValueContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_optionValue);
		try {
			setState(182);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case TOKEN_REF:
			case RULE_REF:
				enterOuterAlt(_localctx, 1);
				{
				setState(177);
				id_();
				}
				break;
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 2);
				{
				setState(178);
				match(STRING_LITERAL);
				}
				break;
			case CHAR_LITERAL:
				enterOuterAlt(_localctx, 3);
				{
				setState(179);
				match(CHAR_LITERAL);
				}
				break;
			case INT:
				enterOuterAlt(_localctx, 4);
				{
				setState(180);
				match(INT);
				}
				break;
			case STAR:
				enterOuterAlt(_localctx, 5);
				{
				setState(181);
				match(STAR);
				}
				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 Rule_Context extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode COLON() { return getToken(ANTLRv3Parser.COLON, 0); }
		public AltListContext altList() {
			return getRuleContext(AltListContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(ANTLRv3Parser.SEMI, 0); }
		public TerminalNode DOC_COMMENT() { return getToken(ANTLRv3Parser.DOC_COMMENT, 0); }
		public TerminalNode BANG() { return getToken(ANTLRv3Parser.BANG, 0); }
		public List argActionBlock() {
			return getRuleContexts(ArgActionBlockContext.class);
		}
		public ArgActionBlockContext argActionBlock(int i) {
			return getRuleContext(ArgActionBlockContext.class,i);
		}
		public TerminalNode RETURNS() { return getToken(ANTLRv3Parser.RETURNS, 0); }
		public ThrowsSpecContext throwsSpec() {
			return getRuleContext(ThrowsSpecContext.class,0);
		}
		public OptionsSpecContext optionsSpec() {
			return getRuleContext(OptionsSpecContext.class,0);
		}
		public RuleScopeSpecContext ruleScopeSpec() {
			return getRuleContext(RuleScopeSpecContext.class,0);
		}
		public List ruleAction() {
			return getRuleContexts(RuleActionContext.class);
		}
		public RuleActionContext ruleAction(int i) {
			return getRuleContext(RuleActionContext.class,i);
		}
		public ExceptionGroupContext exceptionGroup() {
			return getRuleContext(ExceptionGroupContext.class,0);
		}
		public TerminalNode PROTECTED() { return getToken(ANTLRv3Parser.PROTECTED, 0); }
		public TerminalNode PUBLIC() { return getToken(ANTLRv3Parser.PUBLIC, 0); }
		public TerminalNode PRIVATE() { return getToken(ANTLRv3Parser.PRIVATE, 0); }
		public TerminalNode FRAGMENT() { return getToken(ANTLRv3Parser.FRAGMENT, 0); }
		public Rule_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rule_; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRule_(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRule_(this);
		}
	}

	public final Rule_Context rule_() throws RecognitionException {
		Rule_Context _localctx = new Rule_Context(_ctx, getState());
		enterRule(_localctx, 18, RULE_rule_);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(185);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==DOC_COMMENT) {
				{
				setState(184);
				match(DOC_COMMENT);
				}
			}

			setState(188);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 63050403373121536L) != 0)) {
				{
				setState(187);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 63050403373121536L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(190);
			id_();
			setState(192);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==BANG) {
				{
				setState(191);
				match(BANG);
				}
			}

			setState(195);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==BEGIN_ARGUMENT) {
				{
				setState(194);
				argActionBlock();
				}
			}

			setState(199);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==RETURNS) {
				{
				setState(197);
				match(RETURNS);
				setState(198);
				argActionBlock();
				}
			}

			setState(202);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==THROWS) {
				{
				setState(201);
				throwsSpec();
				}
			}

			setState(205);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPTIONS) {
				{
				setState(204);
				optionsSpec();
				}
			}

			setState(208);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==SCOPE) {
				{
				setState(207);
				ruleScopeSpec();
				}
			}

			setState(213);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==AT) {
				{
				{
				setState(210);
				ruleAction();
				}
				}
				setState(215);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(216);
			match(COLON);
			setState(217);
			altList();
			setState(218);
			match(SEMI);
			setState(220);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==CATCH || _la==FINALLY) {
				{
				setState(219);
				exceptionGroup();
				}
			}

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

	@SuppressWarnings("CheckReturnValue")
	public static class RuleActionContext extends ParserRuleContext {
		public TerminalNode AT() { return getToken(ANTLRv3Parser.AT, 0); }
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public RuleActionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ruleAction; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRuleAction(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRuleAction(this);
		}
	}

	public final RuleActionContext ruleAction() throws RecognitionException {
		RuleActionContext _localctx = new RuleActionContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_ruleAction);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(222);
			match(AT);
			setState(223);
			id_();
			setState(224);
			actionBlock();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ThrowsSpecContext extends ParserRuleContext {
		public TerminalNode THROWS() { return getToken(ANTLRv3Parser.THROWS, 0); }
		public List id_() {
			return getRuleContexts(Id_Context.class);
		}
		public Id_Context id_(int i) {
			return getRuleContext(Id_Context.class,i);
		}
		public List COMMA() { return getTokens(ANTLRv3Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ANTLRv3Parser.COMMA, i);
		}
		public ThrowsSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_throwsSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterThrowsSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitThrowsSpec(this);
		}
	}

	public final ThrowsSpecContext throwsSpec() throws RecognitionException {
		ThrowsSpecContext _localctx = new ThrowsSpecContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_throwsSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(226);
			match(THROWS);
			setState(227);
			id_();
			setState(232);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(228);
				match(COMMA);
				setState(229);
				id_();
				}
				}
				setState(234);
				_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 RuleScopeSpecContext extends ParserRuleContext {
		public List SCOPE() { return getTokens(ANTLRv3Parser.SCOPE); }
		public TerminalNode SCOPE(int i) {
			return getToken(ANTLRv3Parser.SCOPE, i);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public List id_() {
			return getRuleContexts(Id_Context.class);
		}
		public Id_Context id_(int i) {
			return getRuleContext(Id_Context.class,i);
		}
		public TerminalNode SEMI() { return getToken(ANTLRv3Parser.SEMI, 0); }
		public List COMMA() { return getTokens(ANTLRv3Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ANTLRv3Parser.COMMA, i);
		}
		public RuleScopeSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ruleScopeSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRuleScopeSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRuleScopeSpec(this);
		}
	}

	public final RuleScopeSpecContext ruleScopeSpec() throws RecognitionException {
		RuleScopeSpecContext _localctx = new RuleScopeSpecContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_ruleScopeSpec);
		int _la;
		try {
			setState(261);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(235);
				match(SCOPE);
				setState(236);
				actionBlock();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(237);
				match(SCOPE);
				setState(238);
				id_();
				setState(243);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(239);
					match(COMMA);
					setState(240);
					id_();
					}
					}
					setState(245);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(246);
				match(SEMI);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(248);
				match(SCOPE);
				setState(249);
				actionBlock();
				setState(250);
				match(SCOPE);
				setState(251);
				id_();
				setState(256);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(252);
					match(COMMA);
					setState(253);
					id_();
					}
					}
					setState(258);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(259);
				match(SEMI);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BlockContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(ANTLRv3Parser.LPAREN, 0); }
		public List alternative() {
			return getRuleContexts(AlternativeContext.class);
		}
		public AlternativeContext alternative(int i) {
			return getRuleContext(AlternativeContext.class,i);
		}
		public List rewrite() {
			return getRuleContexts(RewriteContext.class);
		}
		public RewriteContext rewrite(int i) {
			return getRuleContext(RewriteContext.class,i);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public TerminalNode COLON() { return getToken(ANTLRv3Parser.COLON, 0); }
		public List OR() { return getTokens(ANTLRv3Parser.OR); }
		public TerminalNode OR(int i) {
			return getToken(ANTLRv3Parser.OR, i);
		}
		public OptionsSpecContext optionsSpec() {
			return getRuleContext(OptionsSpecContext.class,0);
		}
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitBlock(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(263);
			match(LPAREN);
			setState(268);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==OPTIONS || _la==COLON) {
				{
				setState(265);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==OPTIONS) {
					{
					setState(264);
					optionsSpec();
					}
				}

				setState(267);
				match(COLON);
				}
			}

			setState(270);
			alternative();
			setState(271);
			rewrite();
			setState(278);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==OR) {
				{
				{
				setState(272);
				match(OR);
				setState(273);
				alternative();
				setState(274);
				rewrite();
				}
				}
				setState(280);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(281);
			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 AltListContext extends ParserRuleContext {
		public List alternative() {
			return getRuleContexts(AlternativeContext.class);
		}
		public AlternativeContext alternative(int i) {
			return getRuleContext(AlternativeContext.class,i);
		}
		public List rewrite() {
			return getRuleContexts(RewriteContext.class);
		}
		public RewriteContext rewrite(int i) {
			return getRuleContext(RewriteContext.class,i);
		}
		public List OR() { return getTokens(ANTLRv3Parser.OR); }
		public TerminalNode OR(int i) {
			return getToken(ANTLRv3Parser.OR, i);
		}
		public AltListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_altList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterAltList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitAltList(this);
		}
	}

	public final AltListContext altList() throws RecognitionException {
		AltListContext _localctx = new AltListContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_altList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(283);
			alternative();
			setState(284);
			rewrite();
			setState(291);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==OR) {
				{
				{
				setState(285);
				match(OR);
				setState(286);
				alternative();
				setState(287);
				rewrite();
				}
				}
				setState(293);
				_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 AlternativeContext extends ParserRuleContext {
		public List element() {
			return getRuleContexts(ElementContext.class);
		}
		public ElementContext element(int i) {
			return getRuleContext(ElementContext.class,i);
		}
		public AlternativeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_alternative; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterAlternative(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitAlternative(this);
		}
	}

	public final AlternativeContext alternative() throws RecognitionException {
		AlternativeContext _localctx = new AlternativeContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_alternative);
		int _la;
		try {
			setState(300);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case TREE_BEGIN:
			case CHAR_LITERAL:
			case STRING_LITERAL:
			case BEGIN_ACTION:
			case DOT:
			case LPAREN:
			case NOT:
			case TOKEN_REF:
			case RULE_REF:
				enterOuterAlt(_localctx, 1);
				{
				setState(295); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(294);
					element();
					}
					}
					setState(297); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( ((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 457405963969281L) != 0) );
				}
				break;
			case REWRITE:
			case OR:
			case RPAREN:
			case SEMI:
				enterOuterAlt(_localctx, 2);
				{
				}
				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 ExceptionGroupContext extends ParserRuleContext {
		public List exceptionHandler() {
			return getRuleContexts(ExceptionHandlerContext.class);
		}
		public ExceptionHandlerContext exceptionHandler(int i) {
			return getRuleContext(ExceptionHandlerContext.class,i);
		}
		public FinallyClauseContext finallyClause() {
			return getRuleContext(FinallyClauseContext.class,0);
		}
		public ExceptionGroupContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exceptionGroup; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterExceptionGroup(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitExceptionGroup(this);
		}
	}

	public final ExceptionGroupContext exceptionGroup() throws RecognitionException {
		ExceptionGroupContext _localctx = new ExceptionGroupContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_exceptionGroup);
		int _la;
		try {
			setState(311);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CATCH:
				enterOuterAlt(_localctx, 1);
				{
				setState(303); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(302);
					exceptionHandler();
					}
					}
					setState(305); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==CATCH );
				setState(308);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==FINALLY) {
					{
					setState(307);
					finallyClause();
					}
				}

				}
				break;
			case FINALLY:
				enterOuterAlt(_localctx, 2);
				{
				setState(310);
				finallyClause();
				}
				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 ExceptionHandlerContext extends ParserRuleContext {
		public TerminalNode CATCH() { return getToken(ANTLRv3Parser.CATCH, 0); }
		public ArgActionBlockContext argActionBlock() {
			return getRuleContext(ArgActionBlockContext.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public ExceptionHandlerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exceptionHandler; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterExceptionHandler(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitExceptionHandler(this);
		}
	}

	public final ExceptionHandlerContext exceptionHandler() throws RecognitionException {
		ExceptionHandlerContext _localctx = new ExceptionHandlerContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_exceptionHandler);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(313);
			match(CATCH);
			setState(314);
			argActionBlock();
			setState(315);
			actionBlock();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FinallyClauseContext extends ParserRuleContext {
		public TerminalNode FINALLY() { return getToken(ANTLRv3Parser.FINALLY, 0); }
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public FinallyClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_finallyClause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterFinallyClause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitFinallyClause(this);
		}
	}

	public final FinallyClauseContext finallyClause() throws RecognitionException {
		FinallyClauseContext _localctx = new FinallyClauseContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_finallyClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(317);
			match(FINALLY);
			setState(318);
			actionBlock();
			}
		}
		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 ElementNoOptionSpecContext elementNoOptionSpec() {
			return getRuleContext(ElementNoOptionSpecContext.class,0);
		}
		public ElementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_element; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterElement(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitElement(this);
		}
	}

	public final ElementContext element() throws RecognitionException {
		ElementContext _localctx = new ElementContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_element);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(320);
			elementNoOptionSpec();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ElementNoOptionSpecContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public AtomContext atom() {
			return getRuleContext(AtomContext.class,0);
		}
		public TerminalNode EQUAL() { return getToken(ANTLRv3Parser.EQUAL, 0); }
		public TerminalNode PEQ() { return getToken(ANTLRv3Parser.PEQ, 0); }
		public EbnfSuffixContext ebnfSuffix() {
			return getRuleContext(EbnfSuffixContext.class,0);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public EbnfContext ebnf() {
			return getRuleContext(EbnfContext.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public TerminalNode QM() { return getToken(ANTLRv3Parser.QM, 0); }
		public TerminalNode SEMPREDOP() { return getToken(ANTLRv3Parser.SEMPREDOP, 0); }
		public TreeSpecContext treeSpec() {
			return getRuleContext(TreeSpecContext.class,0);
		}
		public ElementNoOptionSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_elementNoOptionSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterElementNoOptionSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitElementNoOptionSpec(this);
		}
	}

	public final ElementNoOptionSpecContext elementNoOptionSpec() throws RecognitionException {
		ElementNoOptionSpecContext _localctx = new ElementNoOptionSpecContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_elementNoOptionSpec);
		int _la;
		try {
			setState(354);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(322);
				id_();
				setState(323);
				_la = _input.LA(1);
				if ( !(_la==EQUAL || _la==PEQ) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(324);
				atom();
				setState(327);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PLUS:
				case QM:
				case STAR:
					{
					setState(325);
					ebnfSuffix();
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(329);
				id_();
				setState(330);
				_la = _input.LA(1);
				if ( !(_la==EQUAL || _la==PEQ) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				setState(331);
				block();
				setState(334);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PLUS:
				case QM:
				case STAR:
					{
					setState(332);
					ebnfSuffix();
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(336);
				atom();
				setState(339);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PLUS:
				case QM:
				case STAR:
					{
					setState(337);
					ebnfSuffix();
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(341);
				ebnf();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(342);
				actionBlock();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(343);
				actionBlock();
				setState(344);
				match(QM);
				setState(347);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case SEMPREDOP:
					{
					setState(345);
					match(SEMPREDOP);
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(349);
				treeSpec();
				setState(352);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PLUS:
				case QM:
				case STAR:
					{
					setState(350);
					ebnfSuffix();
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ActionBlockContext extends ParserRuleContext {
		public TerminalNode BEGIN_ACTION() { return getToken(ANTLRv3Parser.BEGIN_ACTION, 0); }
		public TerminalNode END_ACTION() { return getToken(ANTLRv3Parser.END_ACTION, 0); }
		public List ACTION_CONTENT() { return getTokens(ANTLRv3Parser.ACTION_CONTENT); }
		public TerminalNode ACTION_CONTENT(int i) {
			return getToken(ANTLRv3Parser.ACTION_CONTENT, i);
		}
		public ActionBlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_actionBlock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterActionBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitActionBlock(this);
		}
	}

	public final ActionBlockContext actionBlock() throws RecognitionException {
		ActionBlockContext _localctx = new ActionBlockContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_actionBlock);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(356);
			match(BEGIN_ACTION);
			setState(360);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ACTION_CONTENT) {
				{
				{
				setState(357);
				match(ACTION_CONTENT);
				}
				}
				setState(362);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(363);
			match(END_ACTION);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArgActionBlockContext extends ParserRuleContext {
		public TerminalNode BEGIN_ARGUMENT() { return getToken(ANTLRv3Parser.BEGIN_ARGUMENT, 0); }
		public TerminalNode END_ARGUMENT() { return getToken(ANTLRv3Parser.END_ARGUMENT, 0); }
		public List ARGUMENT_CONTENT() { return getTokens(ANTLRv3Parser.ARGUMENT_CONTENT); }
		public TerminalNode ARGUMENT_CONTENT(int i) {
			return getToken(ANTLRv3Parser.ARGUMENT_CONTENT, i);
		}
		public ArgActionBlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argActionBlock; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterArgActionBlock(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitArgActionBlock(this);
		}
	}

	public final ArgActionBlockContext argActionBlock() throws RecognitionException {
		ArgActionBlockContext _localctx = new ArgActionBlockContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_argActionBlock);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(365);
			match(BEGIN_ARGUMENT);
			setState(369);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==ARGUMENT_CONTENT) {
				{
				{
				setState(366);
				match(ARGUMENT_CONTENT);
				}
				}
				setState(371);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(372);
			match(END_ARGUMENT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AtomContext extends ParserRuleContext {
		public Range_Context range_() {
			return getRuleContext(Range_Context.class,0);
		}
		public TerminalNode ROOT() { return getToken(ANTLRv3Parser.ROOT, 0); }
		public TerminalNode BANG() { return getToken(ANTLRv3Parser.BANG, 0); }
		public Terminal_Context terminal_() {
			return getRuleContext(Terminal_Context.class,0);
		}
		public NotSetContext notSet() {
			return getRuleContext(NotSetContext.class,0);
		}
		public TerminalNode RULE_REF() { return getToken(ANTLRv3Parser.RULE_REF, 0); }
		public ArgActionBlockContext argActionBlock() {
			return getRuleContext(ArgActionBlockContext.class,0);
		}
		public AtomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_atom; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterAtom(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitAtom(this);
		}
	}

	public final AtomContext atom() throws RecognitionException {
		AtomContext _localctx = new AtomContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_atom);
		int _la;
		try {
			setState(394);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(374);
				range_();
				setState(378);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case ROOT:
					{
					setState(375);
					match(ROOT);
					}
					break;
				case BANG:
					{
					setState(376);
					match(BANG);
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case PLUS:
				case QM:
				case RPAREN:
				case SEMI:
				case STAR:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(380);
				terminal_();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(381);
				notSet();
				setState(385);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case ROOT:
					{
					setState(382);
					match(ROOT);
					}
					break;
				case BANG:
					{
					setState(383);
					match(BANG);
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case PLUS:
				case QM:
				case RPAREN:
				case SEMI:
				case STAR:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(387);
				match(RULE_REF);
				setState(389);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==BEGIN_ARGUMENT) {
					{
					setState(388);
					argActionBlock();
					}
				}

				setState(392);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==ROOT || _la==BANG) {
					{
					setState(391);
					_la = _input.LA(1);
					if ( !(_la==ROOT || _la==BANG) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
				}

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

	@SuppressWarnings("CheckReturnValue")
	public static class NotSetContext extends ParserRuleContext {
		public TerminalNode NOT() { return getToken(ANTLRv3Parser.NOT, 0); }
		public NotTerminalContext notTerminal() {
			return getRuleContext(NotTerminalContext.class,0);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public NotSetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_notSet; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterNotSet(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitNotSet(this);
		}
	}

	public final NotSetContext notSet() throws RecognitionException {
		NotSetContext _localctx = new NotSetContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_notSet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(396);
			match(NOT);
			setState(399);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CHAR_LITERAL:
			case STRING_LITERAL:
			case TOKEN_REF:
				{
				setState(397);
				notTerminal();
				}
				break;
			case LPAREN:
				{
				setState(398);
				block();
				}
				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 TreeSpecContext extends ParserRuleContext {
		public TerminalNode TREE_BEGIN() { return getToken(ANTLRv3Parser.TREE_BEGIN, 0); }
		public List element() {
			return getRuleContexts(ElementContext.class);
		}
		public ElementContext element(int i) {
			return getRuleContext(ElementContext.class,i);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public TreeSpecContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_treeSpec; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterTreeSpec(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitTreeSpec(this);
		}
	}

	public final TreeSpecContext treeSpec() throws RecognitionException {
		TreeSpecContext _localctx = new TreeSpecContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_treeSpec);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(401);
			match(TREE_BEGIN);
			setState(402);
			element();
			setState(404); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(403);
				element();
				}
				}
				setState(406); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( ((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 457405963969281L) != 0) );
			setState(408);
			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 EbnfContext extends ParserRuleContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode QM() { return getToken(ANTLRv3Parser.QM, 0); }
		public TerminalNode STAR() { return getToken(ANTLRv3Parser.STAR, 0); }
		public TerminalNode PLUS() { return getToken(ANTLRv3Parser.PLUS, 0); }
		public TerminalNode SEMPREDOP() { return getToken(ANTLRv3Parser.SEMPREDOP, 0); }
		public EbnfContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ebnf; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterEbnf(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitEbnf(this);
		}
	}

	public final EbnfContext ebnf() throws RecognitionException {
		EbnfContext _localctx = new EbnfContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_ebnf);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(410);
			block();
			setState(416);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case QM:
				{
				setState(411);
				match(QM);
				}
				break;
			case STAR:
				{
				setState(412);
				match(STAR);
				}
				break;
			case PLUS:
				{
				setState(413);
				match(PLUS);
				}
				break;
			case SEMPREDOP:
				{
				setState(414);
				match(SEMPREDOP);
				}
				break;
			case TREE_BEGIN:
			case REWRITE:
			case CHAR_LITERAL:
			case STRING_LITERAL:
			case BEGIN_ACTION:
			case DOT:
			case LPAREN:
			case OR:
			case RPAREN:
			case SEMI:
			case NOT:
			case TOKEN_REF:
			case RULE_REF:
				{
				}
				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 Range_Context extends ParserRuleContext {
		public List CHAR_LITERAL() { return getTokens(ANTLRv3Parser.CHAR_LITERAL); }
		public TerminalNode CHAR_LITERAL(int i) {
			return getToken(ANTLRv3Parser.CHAR_LITERAL, i);
		}
		public TerminalNode RANGE() { return getToken(ANTLRv3Parser.RANGE, 0); }
		public Range_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_range_; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRange_(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRange_(this);
		}
	}

	public final Range_Context range_() throws RecognitionException {
		Range_Context _localctx = new Range_Context(_ctx, getState());
		enterRule(_localctx, 54, RULE_range_);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(418);
			match(CHAR_LITERAL);
			setState(419);
			match(RANGE);
			setState(420);
			match(CHAR_LITERAL);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Terminal_Context extends ParserRuleContext {
		public TerminalNode CHAR_LITERAL() { return getToken(ANTLRv3Parser.CHAR_LITERAL, 0); }
		public TerminalNode TOKEN_REF() { return getToken(ANTLRv3Parser.TOKEN_REF, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ANTLRv3Parser.STRING_LITERAL, 0); }
		public TerminalNode DOT() { return getToken(ANTLRv3Parser.DOT, 0); }
		public ArgActionBlockContext argActionBlock() {
			return getRuleContext(ArgActionBlockContext.class,0);
		}
		public TerminalNode ROOT() { return getToken(ANTLRv3Parser.ROOT, 0); }
		public TerminalNode BANG() { return getToken(ANTLRv3Parser.BANG, 0); }
		public Terminal_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_terminal_; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterTerminal_(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitTerminal_(this);
		}
	}

	public final Terminal_Context terminal_() throws RecognitionException {
		Terminal_Context _localctx = new Terminal_Context(_ctx, getState());
		enterRule(_localctx, 56, RULE_terminal_);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(430);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CHAR_LITERAL:
				{
				setState(422);
				match(CHAR_LITERAL);
				}
				break;
			case TOKEN_REF:
				{
				setState(423);
				match(TOKEN_REF);
				setState(426);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case BEGIN_ARGUMENT:
					{
					setState(424);
					argActionBlock();
					}
					break;
				case TREE_BEGIN:
				case ROOT:
				case BANG:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case DOT:
				case LPAREN:
				case OR:
				case PLUS:
				case QM:
				case RPAREN:
				case SEMI:
				case STAR:
				case NOT:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case STRING_LITERAL:
				{
				setState(428);
				match(STRING_LITERAL);
				}
				break;
			case DOT:
				{
				setState(429);
				match(DOT);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(433);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==ROOT || _la==BANG) {
				{
				setState(432);
				_la = _input.LA(1);
				if ( !(_la==ROOT || _la==BANG) ) {
				_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 NotTerminalContext extends ParserRuleContext {
		public TerminalNode CHAR_LITERAL() { return getToken(ANTLRv3Parser.CHAR_LITERAL, 0); }
		public TerminalNode TOKEN_REF() { return getToken(ANTLRv3Parser.TOKEN_REF, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ANTLRv3Parser.STRING_LITERAL, 0); }
		public NotTerminalContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_notTerminal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterNotTerminal(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitNotTerminal(this);
		}
	}

	public final NotTerminalContext notTerminal() throws RecognitionException {
		NotTerminalContext _localctx = new NotTerminalContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_notTerminal);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(435);
			_la = _input.LA(1);
			if ( !(((((_la - 42)) & ~0x3f) == 0 && ((1L << (_la - 42)) & 549755813891L) != 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 EbnfSuffixContext extends ParserRuleContext {
		public TerminalNode QM() { return getToken(ANTLRv3Parser.QM, 0); }
		public TerminalNode STAR() { return getToken(ANTLRv3Parser.STAR, 0); }
		public TerminalNode PLUS() { return getToken(ANTLRv3Parser.PLUS, 0); }
		public EbnfSuffixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ebnfSuffix; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterEbnfSuffix(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitEbnfSuffix(this);
		}
	}

	public final EbnfSuffixContext ebnfSuffix() throws RecognitionException {
		EbnfSuffixContext _localctx = new EbnfSuffixContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_ebnfSuffix);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(437);
			_la = _input.LA(1);
			if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 131L) != 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 RewriteContext extends ParserRuleContext {
		public List REWRITE() { return getTokens(ANTLRv3Parser.REWRITE); }
		public TerminalNode REWRITE(int i) {
			return getToken(ANTLRv3Parser.REWRITE, i);
		}
		public List rewrite_alternative() {
			return getRuleContexts(Rewrite_alternativeContext.class);
		}
		public Rewrite_alternativeContext rewrite_alternative(int i) {
			return getRuleContext(Rewrite_alternativeContext.class,i);
		}
		public List actionBlock() {
			return getRuleContexts(ActionBlockContext.class);
		}
		public ActionBlockContext actionBlock(int i) {
			return getRuleContext(ActionBlockContext.class,i);
		}
		public List QM() { return getTokens(ANTLRv3Parser.QM); }
		public TerminalNode QM(int i) {
			return getToken(ANTLRv3Parser.QM, i);
		}
		public RewriteContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite(this);
		}
	}

	public final RewriteContext rewrite() throws RecognitionException {
		RewriteContext _localctx = new RewriteContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_rewrite);
		try {
			int _alt;
			setState(452);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case REWRITE:
				enterOuterAlt(_localctx, 1);
				{
				setState(446);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(439);
						match(REWRITE);
						setState(440);
						actionBlock();
						setState(441);
						match(QM);
						setState(442);
						rewrite_alternative();
						}
						} 
					}
					setState(448);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
				}
				setState(449);
				match(REWRITE);
				setState(450);
				rewrite_alternative();
				}
				break;
			case OR:
			case RPAREN:
			case SEMI:
				enterOuterAlt(_localctx, 2);
				{
				}
				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 Rewrite_alternativeContext extends ParserRuleContext {
		public Rewrite_templateContext rewrite_template() {
			return getRuleContext(Rewrite_templateContext.class,0);
		}
		public Rewrite_tree_alternativeContext rewrite_tree_alternative() {
			return getRuleContext(Rewrite_tree_alternativeContext.class,0);
		}
		public Rewrite_alternativeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_alternative; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_alternative(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_alternative(this);
		}
	}

	public final Rewrite_alternativeContext rewrite_alternative() throws RecognitionException {
		Rewrite_alternativeContext _localctx = new Rewrite_alternativeContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_rewrite_alternative);
		try {
			setState(457);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(454);
				rewrite_template();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(455);
				rewrite_tree_alternative();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rewrite_tree_blockContext extends ParserRuleContext {
		public TerminalNode LPAREN() { return getToken(ANTLRv3Parser.LPAREN, 0); }
		public Rewrite_tree_alternativeContext rewrite_tree_alternative() {
			return getRuleContext(Rewrite_tree_alternativeContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public Rewrite_tree_blockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree_block; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree_block(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree_block(this);
		}
	}

	public final Rewrite_tree_blockContext rewrite_tree_block() throws RecognitionException {
		Rewrite_tree_blockContext _localctx = new Rewrite_tree_blockContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_rewrite_tree_block);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(459);
			match(LPAREN);
			setState(460);
			rewrite_tree_alternative();
			setState(461);
			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 Rewrite_tree_alternativeContext extends ParserRuleContext {
		public List rewrite_tree_element() {
			return getRuleContexts(Rewrite_tree_elementContext.class);
		}
		public Rewrite_tree_elementContext rewrite_tree_element(int i) {
			return getRuleContext(Rewrite_tree_elementContext.class,i);
		}
		public Rewrite_tree_alternativeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree_alternative; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree_alternative(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree_alternative(this);
		}
	}

	public final Rewrite_tree_alternativeContext rewrite_tree_alternative() throws RecognitionException {
		Rewrite_tree_alternativeContext _localctx = new Rewrite_tree_alternativeContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_rewrite_tree_alternative);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(464); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(463);
				rewrite_tree_element();
				}
				}
				setState(466); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( ((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 431017148031745L) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rewrite_tree_elementContext extends ParserRuleContext {
		public Rewrite_tree_atomContext rewrite_tree_atom() {
			return getRuleContext(Rewrite_tree_atomContext.class,0);
		}
		public EbnfSuffixContext ebnfSuffix() {
			return getRuleContext(EbnfSuffixContext.class,0);
		}
		public Rewrite_treeContext rewrite_tree() {
			return getRuleContext(Rewrite_treeContext.class,0);
		}
		public Rewrite_tree_ebnfContext rewrite_tree_ebnf() {
			return getRuleContext(Rewrite_tree_ebnfContext.class,0);
		}
		public Rewrite_tree_elementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree_element; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree_element(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree_element(this);
		}
	}

	public final Rewrite_tree_elementContext rewrite_tree_element() throws RecognitionException {
		Rewrite_tree_elementContext _localctx = new Rewrite_tree_elementContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_rewrite_tree_element);
		try {
			setState(478);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(468);
				rewrite_tree_atom();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(469);
				rewrite_tree_atom();
				setState(470);
				ebnfSuffix();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(472);
				rewrite_tree();
				setState(475);
				_errHandler.sync(this);
				switch (_input.LA(1)) {
				case PLUS:
				case QM:
				case STAR:
					{
					setState(473);
					ebnfSuffix();
					}
					break;
				case TREE_BEGIN:
				case REWRITE:
				case CHAR_LITERAL:
				case STRING_LITERAL:
				case BEGIN_ACTION:
				case LPAREN:
				case OR:
				case RPAREN:
				case SEMI:
				case DOLLAR:
				case TOKEN_REF:
				case RULE_REF:
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(477);
				rewrite_tree_ebnf();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rewrite_tree_atomContext extends ParserRuleContext {
		public TerminalNode CHAR_LITERAL() { return getToken(ANTLRv3Parser.CHAR_LITERAL, 0); }
		public TerminalNode TOKEN_REF() { return getToken(ANTLRv3Parser.TOKEN_REF, 0); }
		public ArgActionBlockContext argActionBlock() {
			return getRuleContext(ArgActionBlockContext.class,0);
		}
		public TerminalNode RULE_REF() { return getToken(ANTLRv3Parser.RULE_REF, 0); }
		public TerminalNode STRING_LITERAL() { return getToken(ANTLRv3Parser.STRING_LITERAL, 0); }
		public TerminalNode DOLLAR() { return getToken(ANTLRv3Parser.DOLLAR, 0); }
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public Rewrite_tree_atomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree_atom; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree_atom(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree_atom(this);
		}
	}

	public final Rewrite_tree_atomContext rewrite_tree_atom() throws RecognitionException {
		Rewrite_tree_atomContext _localctx = new Rewrite_tree_atomContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_rewrite_tree_atom);
		int _la;
		try {
			setState(490);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CHAR_LITERAL:
				enterOuterAlt(_localctx, 1);
				{
				setState(480);
				match(CHAR_LITERAL);
				}
				break;
			case TOKEN_REF:
				enterOuterAlt(_localctx, 2);
				{
				setState(481);
				match(TOKEN_REF);
				setState(483);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==BEGIN_ARGUMENT) {
					{
					setState(482);
					argActionBlock();
					}
				}

				}
				break;
			case RULE_REF:
				enterOuterAlt(_localctx, 3);
				{
				setState(485);
				match(RULE_REF);
				}
				break;
			case STRING_LITERAL:
				enterOuterAlt(_localctx, 4);
				{
				setState(486);
				match(STRING_LITERAL);
				}
				break;
			case DOLLAR:
				enterOuterAlt(_localctx, 5);
				{
				setState(487);
				match(DOLLAR);
				setState(488);
				id_();
				}
				break;
			case BEGIN_ACTION:
				enterOuterAlt(_localctx, 6);
				{
				setState(489);
				actionBlock();
				}
				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 Rewrite_tree_ebnfContext extends ParserRuleContext {
		public Rewrite_tree_blockContext rewrite_tree_block() {
			return getRuleContext(Rewrite_tree_blockContext.class,0);
		}
		public EbnfSuffixContext ebnfSuffix() {
			return getRuleContext(EbnfSuffixContext.class,0);
		}
		public Rewrite_tree_ebnfContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree_ebnf; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree_ebnf(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree_ebnf(this);
		}
	}

	public final Rewrite_tree_ebnfContext rewrite_tree_ebnf() throws RecognitionException {
		Rewrite_tree_ebnfContext _localctx = new Rewrite_tree_ebnfContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_rewrite_tree_ebnf);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(492);
			rewrite_tree_block();
			setState(493);
			ebnfSuffix();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rewrite_treeContext extends ParserRuleContext {
		public TerminalNode TREE_BEGIN() { return getToken(ANTLRv3Parser.TREE_BEGIN, 0); }
		public Rewrite_tree_atomContext rewrite_tree_atom() {
			return getRuleContext(Rewrite_tree_atomContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public List rewrite_tree_element() {
			return getRuleContexts(Rewrite_tree_elementContext.class);
		}
		public Rewrite_tree_elementContext rewrite_tree_element(int i) {
			return getRuleContext(Rewrite_tree_elementContext.class,i);
		}
		public Rewrite_treeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_tree; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_tree(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_tree(this);
		}
	}

	public final Rewrite_treeContext rewrite_tree() throws RecognitionException {
		Rewrite_treeContext _localctx = new Rewrite_treeContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_rewrite_tree);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(495);
			match(TREE_BEGIN);
			setState(496);
			rewrite_tree_atom();
			setState(500);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & 431017148031745L) != 0)) {
				{
				{
				setState(497);
				rewrite_tree_element();
				}
				}
				setState(502);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(503);
			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 Rewrite_templateContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode LPAREN() { return getToken(ANTLRv3Parser.LPAREN, 0); }
		public Rewrite_template_argsContext rewrite_template_args() {
			return getRuleContext(Rewrite_template_argsContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public TerminalNode DOUBLE_QUOTE_STRING_LITERAL() { return getToken(ANTLRv3Parser.DOUBLE_QUOTE_STRING_LITERAL, 0); }
		public TerminalNode DOUBLE_ANGLE_STRING_LITERAL() { return getToken(ANTLRv3Parser.DOUBLE_ANGLE_STRING_LITERAL, 0); }
		public Rewrite_template_refContext rewrite_template_ref() {
			return getRuleContext(Rewrite_template_refContext.class,0);
		}
		public Rewrite_indirect_template_headContext rewrite_indirect_template_head() {
			return getRuleContext(Rewrite_indirect_template_headContext.class,0);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public Rewrite_templateContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_template; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_template(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_template(this);
		}
	}

	public final Rewrite_templateContext rewrite_template() throws RecognitionException {
		Rewrite_templateContext _localctx = new Rewrite_templateContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_rewrite_template);
		int _la;
		try {
			setState(514);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(505);
				id_();
				setState(506);
				match(LPAREN);
				setState(507);
				rewrite_template_args();
				setState(508);
				match(RPAREN);
				setState(509);
				_la = _input.LA(1);
				if ( !(_la==DOUBLE_QUOTE_STRING_LITERAL || _la==DOUBLE_ANGLE_STRING_LITERAL) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(511);
				rewrite_template_ref();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(512);
				rewrite_indirect_template_head();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(513);
				actionBlock();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Rewrite_template_refContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode LPAREN() { return getToken(ANTLRv3Parser.LPAREN, 0); }
		public Rewrite_template_argsContext rewrite_template_args() {
			return getRuleContext(Rewrite_template_argsContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(ANTLRv3Parser.RPAREN, 0); }
		public Rewrite_template_refContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_template_ref; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_template_ref(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_template_ref(this);
		}
	}

	public final Rewrite_template_refContext rewrite_template_ref() throws RecognitionException {
		Rewrite_template_refContext _localctx = new Rewrite_template_refContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_rewrite_template_ref);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(516);
			id_();
			setState(517);
			match(LPAREN);
			setState(518);
			rewrite_template_args();
			setState(519);
			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 Rewrite_indirect_template_headContext extends ParserRuleContext {
		public List LPAREN() { return getTokens(ANTLRv3Parser.LPAREN); }
		public TerminalNode LPAREN(int i) {
			return getToken(ANTLRv3Parser.LPAREN, i);
		}
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public List RPAREN() { return getTokens(ANTLRv3Parser.RPAREN); }
		public TerminalNode RPAREN(int i) {
			return getToken(ANTLRv3Parser.RPAREN, i);
		}
		public Rewrite_template_argsContext rewrite_template_args() {
			return getRuleContext(Rewrite_template_argsContext.class,0);
		}
		public Rewrite_indirect_template_headContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_indirect_template_head; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_indirect_template_head(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_indirect_template_head(this);
		}
	}

	public final Rewrite_indirect_template_headContext rewrite_indirect_template_head() throws RecognitionException {
		Rewrite_indirect_template_headContext _localctx = new Rewrite_indirect_template_headContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_rewrite_indirect_template_head);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(521);
			match(LPAREN);
			setState(522);
			actionBlock();
			setState(523);
			match(RPAREN);
			setState(524);
			match(LPAREN);
			setState(525);
			rewrite_template_args();
			setState(526);
			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 Rewrite_template_argsContext extends ParserRuleContext {
		public List rewrite_template_arg() {
			return getRuleContexts(Rewrite_template_argContext.class);
		}
		public Rewrite_template_argContext rewrite_template_arg(int i) {
			return getRuleContext(Rewrite_template_argContext.class,i);
		}
		public List COMMA() { return getTokens(ANTLRv3Parser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(ANTLRv3Parser.COMMA, i);
		}
		public Rewrite_template_argsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_template_args; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_template_args(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_template_args(this);
		}
	}

	public final Rewrite_template_argsContext rewrite_template_args() throws RecognitionException {
		Rewrite_template_argsContext _localctx = new Rewrite_template_argsContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_rewrite_template_args);
		int _la;
		try {
			setState(537);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case TOKEN_REF:
			case RULE_REF:
				enterOuterAlt(_localctx, 1);
				{
				setState(528);
				rewrite_template_arg();
				setState(533);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(529);
					match(COMMA);
					setState(530);
					rewrite_template_arg();
					}
					}
					setState(535);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			case RPAREN:
				enterOuterAlt(_localctx, 2);
				{
				}
				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 Rewrite_template_argContext extends ParserRuleContext {
		public Id_Context id_() {
			return getRuleContext(Id_Context.class,0);
		}
		public TerminalNode EQUAL() { return getToken(ANTLRv3Parser.EQUAL, 0); }
		public ActionBlockContext actionBlock() {
			return getRuleContext(ActionBlockContext.class,0);
		}
		public Rewrite_template_argContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_rewrite_template_arg; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterRewrite_template_arg(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitRewrite_template_arg(this);
		}
	}

	public final Rewrite_template_argContext rewrite_template_arg() throws RecognitionException {
		Rewrite_template_argContext _localctx = new Rewrite_template_argContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_rewrite_template_arg);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(539);
			id_();
			setState(540);
			match(EQUAL);
			setState(541);
			actionBlock();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class Id_Context extends ParserRuleContext {
		public TerminalNode TOKEN_REF() { return getToken(ANTLRv3Parser.TOKEN_REF, 0); }
		public TerminalNode RULE_REF() { return getToken(ANTLRv3Parser.RULE_REF, 0); }
		public Id_Context(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_id_; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).enterId_(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof ANTLRv3ParserListener ) ((ANTLRv3ParserListener)listener).exitId_(this);
		}
	}

	public final Id_Context id_() throws RecognitionException {
		Id_Context _localctx = new Id_Context(_ctx, getState());
		enterRule(_localctx, 88, RULE_id_);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(543);
			_la = _input.LA(1);
			if ( !(_la==TOKEN_REF || _la==RULE_REF) ) {
			_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\u0001Z\u0222\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"+
		"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
		"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
		"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
		"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
		"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
		"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0001"+
		"\u0000\u0003\u0000\\\b\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001"+
		"\u0000\u0003\u0000b\b\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001"+
		"\u0000\u0003\u0000h\b\u0000\u0001\u0000\u0003\u0000k\b\u0000\u0001\u0000"+
		"\u0005\u0000n\b\u0000\n\u0000\f\u0000q\t\u0000\u0001\u0000\u0005\u0000"+
		"t\b\u0000\n\u0000\f\u0000w\t\u0000\u0001\u0000\u0004\u0000z\b\u0000\u000b"+
		"\u0000\f\u0000{\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0004\u0001\u0083\b\u0001\u000b\u0001\f\u0001\u0084\u0001\u0001"+
		"\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0003\u0002"+
		"\u008d\b\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003"+
		"\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004"+
		"\u0099\b\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005"+
		"\u0001\u0005\u0003\u0005\u00a1\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+
		"\u0005\u0006\u00a6\b\u0006\n\u0006\f\u0006\u00a9\t\u0006\u0001\u0006\u0001"+
		"\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
		"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u00b7\b\b\u0001\t\u0003\t\u00ba"+
		"\b\t\u0001\t\u0003\t\u00bd\b\t\u0001\t\u0001\t\u0003\t\u00c1\b\t\u0001"+
		"\t\u0003\t\u00c4\b\t\u0001\t\u0001\t\u0003\t\u00c8\b\t\u0001\t\u0003\t"+
		"\u00cb\b\t\u0001\t\u0003\t\u00ce\b\t\u0001\t\u0003\t\u00d1\b\t\u0001\t"+
		"\u0005\t\u00d4\b\t\n\t\f\t\u00d7\t\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+
		"\t\u00dd\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001"+
		"\u000b\u0001\u000b\u0005\u000b\u00e7\b\u000b\n\u000b\f\u000b\u00ea\t\u000b"+
		"\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0005\f\u00f2\b\f\n\f"+
		"\f\f\u00f5\t\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f"+
		"\u0001\f\u0005\f\u00ff\b\f\n\f\f\f\u0102\t\f\u0001\f\u0001\f\u0003\f\u0106"+
		"\b\f\u0001\r\u0001\r\u0003\r\u010a\b\r\u0001\r\u0003\r\u010d\b\r\u0001"+
		"\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0005\r\u0115\b\r\n\r\f\r\u0118"+
		"\t\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
		"\u000e\u0001\u000e\u0005\u000e\u0122\b\u000e\n\u000e\f\u000e\u0125\t\u000e"+
		"\u0001\u000f\u0004\u000f\u0128\b\u000f\u000b\u000f\f\u000f\u0129\u0001"+
		"\u000f\u0003\u000f\u012d\b\u000f\u0001\u0010\u0004\u0010\u0130\b\u0010"+
		"\u000b\u0010\f\u0010\u0131\u0001\u0010\u0003\u0010\u0135\b\u0010\u0001"+
		"\u0010\u0003\u0010\u0138\b\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+
		"\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0148"+
		"\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003"+
		"\u0014\u014f\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u0154"+
		"\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0003\u0014\u015c\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0003"+
		"\u0014\u0161\b\u0014\u0003\u0014\u0163\b\u0014\u0001\u0015\u0001\u0015"+
		"\u0005\u0015\u0167\b\u0015\n\u0015\f\u0015\u016a\t\u0015\u0001\u0015\u0001"+
		"\u0015\u0001\u0016\u0001\u0016\u0005\u0016\u0170\b\u0016\n\u0016\f\u0016"+
		"\u0173\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017"+
		"\u0001\u0017\u0003\u0017\u017b\b\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+
		"\u0001\u0017\u0001\u0017\u0003\u0017\u0182\b\u0017\u0001\u0017\u0001\u0017"+
		"\u0003\u0017\u0186\b\u0017\u0001\u0017\u0003\u0017\u0189\b\u0017\u0003"+
		"\u0017\u018b\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u0190"+
		"\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0004\u0019\u0195\b\u0019"+
		"\u000b\u0019\f\u0019\u0196\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a"+
		"\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u01a1\b\u001a"+
		"\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c"+
		"\u0001\u001c\u0001\u001c\u0003\u001c\u01ab\b\u001c\u0001\u001c\u0001\u001c"+
		"\u0003\u001c\u01af\b\u001c\u0001\u001c\u0003\u001c\u01b2\b\u001c\u0001"+
		"\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001"+
		"\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u01bd\b\u001f\n\u001f\f\u001f"+
		"\u01c0\t\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u01c5\b"+
		"\u001f\u0001 \u0001 \u0001 \u0003 \u01ca\b \u0001!\u0001!\u0001!\u0001"+
		"!\u0001\"\u0004\"\u01d1\b\"\u000b\"\f\"\u01d2\u0001#\u0001#\u0001#\u0001"+
		"#\u0001#\u0001#\u0001#\u0003#\u01dc\b#\u0001#\u0003#\u01df\b#\u0001$\u0001"+
		"$\u0001$\u0003$\u01e4\b$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u01eb"+
		"\b$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0005&\u01f3\b&\n&\f&\u01f6"+
		"\t&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+
		"\'\u0001\'\u0001\'\u0003\'\u0203\b\'\u0001(\u0001(\u0001(\u0001(\u0001"+
		"(\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001*\u0001"+
		"*\u0005*\u0214\b*\n*\f*\u0217\t*\u0001*\u0003*\u021a\b*\u0001+\u0001+"+
		"\u0001+\u0001+\u0001,\u0001,\u0001,\u0000\u0000-\u0000\u0002\u0004\u0006"+
		"\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,."+
		"02468:<>@BDFHJLNPRTVX\u0000\b\u0001\u0000*+\u0002\u0000!!57\u0002\u0000"+
		"@@NN\u0001\u0000#$\u0002\u0000*+QQ\u0002\u0000EFLL\u0001\u0000,-\u0001"+
		"\u0000QR\u0255\u0000[\u0001\u0000\u0000\u0000\u0002\u007f\u0001\u0000"+
		"\u0000\u0000\u0004\u0088\u0001\u0000\u0000\u0000\u0006\u0090\u0001\u0000"+
		"\u0000\u0000\b\u0094\u0001\u0000\u0000\u0000\n\u00a0\u0001\u0000\u0000"+
		"\u0000\f\u00a2\u0001\u0000\u0000\u0000\u000e\u00ac\u0001\u0000\u0000\u0000"+
		"\u0010\u00b6\u0001\u0000\u0000\u0000\u0012\u00b9\u0001\u0000\u0000\u0000"+
		"\u0014\u00de\u0001\u0000\u0000\u0000\u0016\u00e2\u0001\u0000\u0000\u0000"+
		"\u0018\u0105\u0001\u0000\u0000\u0000\u001a\u0107\u0001\u0000\u0000\u0000"+
		"\u001c\u011b\u0001\u0000\u0000\u0000\u001e\u012c\u0001\u0000\u0000\u0000"+
		" \u0137\u0001\u0000\u0000\u0000\"\u0139\u0001\u0000\u0000\u0000$\u013d"+
		"\u0001\u0000\u0000\u0000&\u0140\u0001\u0000\u0000\u0000(\u0162\u0001\u0000"+
		"\u0000\u0000*\u0164\u0001\u0000\u0000\u0000,\u016d\u0001\u0000\u0000\u0000"+
		".\u018a\u0001\u0000\u0000\u00000\u018c\u0001\u0000\u0000\u00002\u0191"+
		"\u0001\u0000\u0000\u00004\u019a\u0001\u0000\u0000\u00006\u01a2\u0001\u0000"+
		"\u0000\u00008\u01ae\u0001\u0000\u0000\u0000:\u01b3\u0001\u0000\u0000\u0000"+
		"<\u01b5\u0001\u0000\u0000\u0000>\u01c4\u0001\u0000\u0000\u0000@\u01c9"+
		"\u0001\u0000\u0000\u0000B\u01cb\u0001\u0000\u0000\u0000D\u01d0\u0001\u0000"+
		"\u0000\u0000F\u01de\u0001\u0000\u0000\u0000H\u01ea\u0001\u0000\u0000\u0000"+
		"J\u01ec\u0001\u0000\u0000\u0000L\u01ef\u0001\u0000\u0000\u0000N\u0202"+
		"\u0001\u0000\u0000\u0000P\u0204\u0001\u0000\u0000\u0000R\u0209\u0001\u0000"+
		"\u0000\u0000T\u0219\u0001\u0000\u0000\u0000V\u021b\u0001\u0000\u0000\u0000"+
		"X\u021f\u0001\u0000\u0000\u0000Z\\\u0005\u0001\u0000\u0000[Z\u0001\u0000"+
		"\u0000\u0000[\\\u0001\u0000\u0000\u0000\\a\u0001\u0000\u0000\u0000]b\u0005"+
		"\u0003\u0000\u0000^b\u0005\u0002\u0000\u0000_b\u0005:\u0000\u0000`b\u0001"+
		"\u0000\u0000\u0000a]\u0001\u0000\u0000\u0000a^\u0001\u0000\u0000\u0000"+
		"a_\u0001\u0000\u0000\u0000a`\u0001\u0000\u0000\u0000bc\u0001\u0000\u0000"+
		"\u0000cd\u00054\u0000\u0000de\u0003X,\u0000eg\u0005J\u0000\u0000fh\u0003"+
		"\f\u0006\u0000gf\u0001\u0000\u0000\u0000gh\u0001\u0000\u0000\u0000hj\u0001"+
		"\u0000\u0000\u0000ik\u0003\u0002\u0001\u0000ji\u0001\u0000\u0000\u0000"+
		"jk\u0001\u0000\u0000\u0000ko\u0001\u0000\u0000\u0000ln\u0003\u0006\u0003"+
		"\u0000ml\u0001\u0000\u0000\u0000nq\u0001\u0000\u0000\u0000om\u0001\u0000"+
		"\u0000\u0000op\u0001\u0000\u0000\u0000pu\u0001\u0000\u0000\u0000qo\u0001"+
		"\u0000\u0000\u0000rt\u0003\b\u0004\u0000sr\u0001\u0000\u0000\u0000tw\u0001"+
		"\u0000\u0000\u0000us\u0001\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000"+
		"vy\u0001\u0000\u0000\u0000wu\u0001\u0000\u0000\u0000xz\u0003\u0012\t\u0000"+
		"yx\u0001\u0000\u0000\u0000z{\u0001\u0000\u0000\u0000{y\u0001\u0000\u0000"+
		"\u0000{|\u0001\u0000\u0000\u0000|}\u0001\u0000\u0000\u0000}~\u0005\u0000"+
		"\u0000\u0001~\u0001\u0001\u0000\u0000\u0000\u007f\u0080\u00051\u0000\u0000"+
		"\u0080\u0082\u0005A\u0000\u0000\u0081\u0083\u0003\u0004\u0002\u0000\u0082"+
		"\u0081\u0001\u0000\u0000\u0000\u0083\u0084\u0001\u0000\u0000\u0000\u0084"+
		"\u0082\u0001\u0000\u0000\u0000\u0084\u0085\u0001\u0000\u0000\u0000\u0085"+
		"\u0086\u0001\u0000\u0000\u0000\u0086\u0087\u0005G\u0000\u0000\u0087\u0003"+
		"\u0001\u0000\u0000\u0000\u0088\u008c\u0005Q\u0000\u0000\u0089\u008a\u0005"+
		"@\u0000\u0000\u008a\u008d\u0007\u0000\u0000\u0000\u008b\u008d\u0001\u0000"+
		"\u0000\u0000\u008c\u0089\u0001\u0000\u0000\u0000\u008c\u008b\u0001\u0000"+
		"\u0000\u0000\u008d\u008e\u0001\u0000\u0000\u0000\u008e\u008f\u0005J\u0000"+
		"\u0000\u008f\u0005\u0001\u0000\u0000\u0000\u0090\u0091\u0005\u001c\u0000"+
		"\u0000\u0091\u0092\u0003X,\u0000\u0092\u0093\u0003*\u0015\u0000\u0093"+
		"\u0007\u0001\u0000\u0000\u0000\u0094\u0098\u0005;\u0000\u0000\u0095\u0096"+
		"\u0003\n\u0005\u0000\u0096\u0097\u0005=\u0000\u0000\u0097\u0099\u0001"+
		"\u0000\u0000\u0000\u0098\u0095\u0001\u0000\u0000\u0000\u0098\u0099\u0001"+
		"\u0000\u0000\u0000\u0099\u009a\u0001\u0000\u0000\u0000\u009a\u009b\u0003"+
		"X,\u0000\u009b\u009c\u0003*\u0015\u0000\u009c\t\u0001\u0000\u0000\u0000"+
		"\u009d\u00a1\u0003X,\u0000\u009e\u00a1\u0005\u0003\u0000\u0000\u009f\u00a1"+
		"\u0005\u0002\u0000\u0000\u00a0\u009d\u0001\u0000\u0000\u0000\u00a0\u009e"+
		"\u0001\u0000\u0000\u0000\u00a0\u009f\u0001\u0000\u0000\u0000\u00a1\u000b"+
		"\u0001\u0000\u0000\u0000\u00a2\u00a3\u00050\u0000\u0000\u00a3\u00a7\u0005"+
		"A\u0000\u0000\u00a4\u00a6\u0003\u000e\u0007\u0000\u00a5\u00a4\u0001\u0000"+
		"\u0000\u0000\u00a6\u00a9\u0001\u0000\u0000\u0000\u00a7\u00a5\u0001\u0000"+
		"\u0000\u0000\u00a7\u00a8\u0001\u0000\u0000\u0000\u00a8\u00aa\u0001\u0000"+
		"\u0000\u0000\u00a9\u00a7\u0001\u0000\u0000\u0000\u00aa\u00ab\u0005G\u0000"+
		"\u0000\u00ab\r\u0001\u0000\u0000\u0000\u00ac\u00ad\u0003X,\u0000\u00ad"+
		"\u00ae\u0005@\u0000\u0000\u00ae\u00af\u0003\u0010\b\u0000\u00af\u00b0"+
		"\u0005J\u0000\u0000\u00b0\u000f\u0001\u0000\u0000\u0000\u00b1\u00b7\u0003"+
		"X,\u0000\u00b2\u00b7\u0005+\u0000\u0000\u00b3\u00b7\u0005*\u0000\u0000"+
		"\u00b4\u00b7\u0005)\u0000\u0000\u00b5\u00b7\u0005L\u0000\u0000\u00b6\u00b1"+
		"\u0001\u0000\u0000\u0000\u00b6\u00b2\u0001\u0000\u0000\u0000\u00b6\u00b3"+
		"\u0001\u0000\u0000\u0000\u00b6\u00b4\u0001\u0000\u0000\u0000\u00b6\u00b5"+
		"\u0001\u0000\u0000\u0000\u00b7\u0011\u0001\u0000\u0000\u0000\u00b8\u00ba"+
		"\u0005\u0001\u0000\u0000\u00b9\u00b8\u0001\u0000\u0000\u0000\u00b9\u00ba"+
		"\u0001\u0000\u0000\u0000\u00ba\u00bc\u0001\u0000\u0000\u0000\u00bb\u00bd"+
		"\u0007\u0001\u0000\u0000\u00bc\u00bb\u0001\u0000\u0000\u0000\u00bc\u00bd"+
		"\u0001\u0000\u0000\u0000\u00bd\u00be\u0001\u0000\u0000\u0000\u00be\u00c0"+
		"\u0003X,\u0000\u00bf\u00c1\u0005$\u0000\u0000\u00c0\u00bf\u0001\u0000"+
		"\u0000\u0000\u00c0\u00c1\u0001\u0000\u0000\u0000\u00c1\u00c3\u0001\u0000"+
		"\u0000\u0000\u00c2\u00c4\u0003,\u0016\u0000\u00c3\u00c2\u0001\u0000\u0000"+
		"\u0000\u00c3\u00c4\u0001\u0000\u0000\u0000\u00c4\u00c7\u0001\u0000\u0000"+
		"\u0000\u00c5\u00c6\u00058\u0000\u0000\u00c6\u00c8\u0003,\u0016\u0000\u00c7"+
		"\u00c5\u0001\u0000\u0000\u0000\u00c7\u00c8\u0001\u0000\u0000\u0000\u00c8"+
		"\u00ca\u0001\u0000\u0000\u0000\u00c9\u00cb\u0003\u0016\u000b\u0000\u00ca"+
		"\u00c9\u0001\u0000\u0000\u0000\u00ca\u00cb\u0001\u0000\u0000\u0000\u00cb"+
		"\u00cd\u0001\u0000\u0000\u0000\u00cc\u00ce\u0003\f\u0006\u0000\u00cd\u00cc"+
		"\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000\u0000\u0000\u00ce\u00d0"+
		"\u0001\u0000\u0000\u0000\u00cf\u00d1\u0003\u0018\f\u0000\u00d0\u00cf\u0001"+
		"\u0000\u0000\u0000\u00d0\u00d1\u0001\u0000\u0000\u0000\u00d1\u00d5\u0001"+
		"\u0000\u0000\u0000\u00d2\u00d4\u0003\u0014\n\u0000\u00d3\u00d2\u0001\u0000"+
		"\u0000\u0000\u00d4\u00d7\u0001\u0000\u0000\u0000\u00d5\u00d3\u0001\u0000"+
		"\u0000\u0000\u00d5\u00d6\u0001\u0000\u0000\u0000\u00d6\u00d8\u0001\u0000"+
		"\u0000\u0000\u00d7\u00d5\u0001\u0000\u0000\u0000\u00d8\u00d9\u0005<\u0000"+
		"\u0000\u00d9\u00da\u0003\u001c\u000e\u0000\u00da\u00dc\u0005J\u0000\u0000"+
		"\u00db\u00dd\u0003 \u0010\u0000\u00dc\u00db\u0001\u0000\u0000\u0000\u00dc"+
		"\u00dd\u0001\u0000\u0000\u0000\u00dd\u0013\u0001\u0000\u0000\u0000\u00de"+
		"\u00df\u0005;\u0000\u0000\u00df\u00e0\u0003X,\u0000\u00e0\u00e1\u0003"+
		"*\u0015\u0000\u00e1\u0015\u0001\u0000\u0000\u0000\u00e2\u00e3\u00059\u0000"+
		"\u0000\u00e3\u00e8\u0003X,\u0000\u00e4\u00e5\u0005>\u0000\u0000\u00e5"+
		"\u00e7\u0003X,\u0000\u00e6\u00e4\u0001\u0000\u0000\u0000\u00e7\u00ea\u0001"+
		"\u0000\u0000\u0000\u00e8\u00e6\u0001\u0000\u0000\u0000\u00e8\u00e9\u0001"+
		"\u0000\u0000\u0000\u00e9\u0017\u0001\u0000\u0000\u0000\u00ea\u00e8\u0001"+
		"\u0000\u0000\u0000\u00eb\u00ec\u0005\u001c\u0000\u0000\u00ec\u0106\u0003"+
		"*\u0015\u0000\u00ed\u00ee\u0005\u001c\u0000\u0000\u00ee\u00f3\u0003X,"+
		"\u0000\u00ef\u00f0\u0005>\u0000\u0000\u00f0\u00f2\u0003X,\u0000\u00f1"+
		"\u00ef\u0001\u0000\u0000\u0000\u00f2\u00f5\u0001\u0000\u0000\u0000\u00f3"+
		"\u00f1\u0001\u0000\u0000\u0000\u00f3\u00f4\u0001\u0000\u0000\u0000\u00f4"+
		"\u00f6\u0001\u0000\u0000\u0000\u00f5\u00f3\u0001\u0000\u0000\u0000\u00f6"+
		"\u00f7\u0005J\u0000\u0000\u00f7\u0106\u0001\u0000\u0000\u0000\u00f8\u00f9"+
		"\u0005\u001c\u0000\u0000\u00f9\u00fa\u0003*\u0015\u0000\u00fa\u00fb\u0005"+
		"\u001c\u0000\u0000\u00fb\u0100\u0003X,\u0000\u00fc\u00fd\u0005>\u0000"+
		"\u0000\u00fd\u00ff\u0003X,\u0000\u00fe\u00fc\u0001\u0000\u0000\u0000\u00ff"+
		"\u0102\u0001\u0000\u0000\u0000\u0100\u00fe\u0001\u0000\u0000\u0000\u0100"+
		"\u0101\u0001\u0000\u0000\u0000\u0101\u0103\u0001\u0000\u0000\u0000\u0102"+
		"\u0100\u0001\u0000\u0000\u0000\u0103\u0104\u0005J\u0000\u0000\u0104\u0106"+
		"\u0001\u0000\u0000\u0000\u0105\u00eb\u0001\u0000\u0000\u0000\u0105\u00ed"+
		"\u0001\u0000\u0000\u0000\u0105\u00f8\u0001\u0000\u0000\u0000\u0106\u0019"+
		"\u0001\u0000\u0000\u0000\u0107\u010c\u0005C\u0000\u0000\u0108\u010a\u0003"+
		"\f\u0006\u0000\u0109\u0108\u0001\u0000\u0000\u0000\u0109\u010a\u0001\u0000"+
		"\u0000\u0000\u010a\u010b\u0001\u0000\u0000\u0000\u010b\u010d\u0005<\u0000"+
		"\u0000\u010c\u0109\u0001\u0000\u0000\u0000\u010c\u010d\u0001\u0000\u0000"+
		"\u0000\u010d\u010e\u0001\u0000\u0000\u0000\u010e\u010f\u0003\u001e\u000f"+
		"\u0000\u010f\u0116\u0003>\u001f\u0000\u0110\u0111\u0005D\u0000\u0000\u0111"+
		"\u0112\u0003\u001e\u000f\u0000\u0112\u0113\u0003>\u001f\u0000\u0113\u0115"+
		"\u0001\u0000\u0000\u0000\u0114\u0110\u0001\u0000\u0000\u0000\u0115\u0118"+
		"\u0001\u0000\u0000\u0000\u0116\u0114\u0001\u0000\u0000\u0000\u0116\u0117"+
		"\u0001\u0000\u0000\u0000\u0117\u0119\u0001\u0000\u0000\u0000\u0118\u0116"+
		"\u0001\u0000\u0000\u0000\u0119\u011a\u0005I\u0000\u0000\u011a\u001b\u0001"+
		"\u0000\u0000\u0000\u011b\u011c\u0003\u001e\u000f\u0000\u011c\u0123\u0003"+
		">\u001f\u0000\u011d\u011e\u0005D\u0000\u0000\u011e\u011f\u0003\u001e\u000f"+
		"\u0000\u011f\u0120\u0003>\u001f\u0000\u0120\u0122\u0001\u0000\u0000\u0000"+
		"\u0121\u011d\u0001\u0000\u0000\u0000\u0122\u0125\u0001\u0000\u0000\u0000"+
		"\u0123\u0121\u0001\u0000\u0000\u0000\u0123\u0124\u0001\u0000\u0000\u0000"+
		"\u0124\u001d\u0001\u0000\u0000\u0000\u0125\u0123\u0001\u0000\u0000\u0000"+
		"\u0126\u0128\u0003&\u0013\u0000\u0127\u0126\u0001\u0000\u0000\u0000\u0128"+
		"\u0129\u0001\u0000\u0000\u0000\u0129\u0127\u0001\u0000\u0000\u0000\u0129"+
		"\u012a\u0001\u0000\u0000\u0000\u012a\u012d\u0001\u0000\u0000\u0000\u012b"+
		"\u012d\u0001\u0000\u0000\u0000\u012c\u0127\u0001\u0000\u0000\u0000\u012c"+
		"\u012b\u0001\u0000\u0000\u0000\u012d\u001f\u0001\u0000\u0000\u0000\u012e"+
		"\u0130\u0003\"\u0011\u0000\u012f\u012e\u0001\u0000\u0000\u0000\u0130\u0131"+
		"\u0001\u0000\u0000\u0000\u0131\u012f\u0001\u0000\u0000\u0000\u0131\u0132"+
		"\u0001\u0000\u0000\u0000\u0132\u0134\u0001\u0000\u0000\u0000\u0133\u0135"+
		"\u0003$\u0012\u0000\u0134\u0133\u0001\u0000\u0000\u0000\u0134\u0135\u0001"+
		"\u0000\u0000\u0000\u0135\u0138\u0001\u0000\u0000\u0000\u0136\u0138\u0003"+
		"$\u0012\u0000\u0137\u012f\u0001\u0000\u0000\u0000\u0137\u0136\u0001\u0000"+
		"\u0000\u0000\u0138!\u0001\u0000\u0000\u0000\u0139\u013a\u00052\u0000\u0000"+
		"\u013a\u013b\u0003,\u0016\u0000\u013b\u013c\u0003*\u0015\u0000\u013c#"+
		"\u0001\u0000\u0000\u0000\u013d\u013e\u00053\u0000\u0000\u013e\u013f\u0003"+
		"*\u0015\u0000\u013f%\u0001\u0000\u0000\u0000\u0140\u0141\u0003(\u0014"+
		"\u0000\u0141\'\u0001\u0000\u0000\u0000\u0142\u0143\u0003X,\u0000\u0143"+
		"\u0144\u0007\u0002\u0000\u0000\u0144\u0147\u0003.\u0017\u0000\u0145\u0148"+
		"\u0003<\u001e\u0000\u0146\u0148\u0001\u0000\u0000\u0000\u0147\u0145\u0001"+
		"\u0000\u0000\u0000\u0147\u0146\u0001\u0000\u0000\u0000\u0148\u0163\u0001"+
		"\u0000\u0000\u0000\u0149\u014a\u0003X,\u0000\u014a\u014b\u0007\u0002\u0000"+
		"\u0000\u014b\u014e\u0003\u001a\r\u0000\u014c\u014f\u0003<\u001e\u0000"+
		"\u014d\u014f\u0001\u0000\u0000\u0000\u014e\u014c\u0001\u0000\u0000\u0000"+
		"\u014e\u014d\u0001\u0000\u0000\u0000\u014f\u0163\u0001\u0000\u0000\u0000"+
		"\u0150\u0153\u0003.\u0017\u0000\u0151\u0154\u0003<\u001e\u0000\u0152\u0154"+
		"\u0001\u0000\u0000\u0000\u0153\u0151\u0001\u0000\u0000\u0000\u0153\u0152"+
		"\u0001\u0000\u0000\u0000\u0154\u0163\u0001\u0000\u0000\u0000\u0155\u0163"+
		"\u00034\u001a\u0000\u0156\u0163\u0003*\u0015\u0000\u0157\u0158\u0003*"+
		"\u0015\u0000\u0158\u015b\u0005F\u0000\u0000\u0159\u015c\u0005K\u0000\u0000"+
		"\u015a\u015c\u0001\u0000\u0000\u0000\u015b\u0159\u0001\u0000\u0000\u0000"+
		"\u015b\u015a\u0001\u0000\u0000\u0000\u015c\u0163\u0001\u0000\u0000\u0000"+
		"\u015d\u0160\u00032\u0019\u0000\u015e\u0161\u0003<\u001e\u0000\u015f\u0161"+
		"\u0001\u0000\u0000\u0000\u0160\u015e\u0001\u0000\u0000\u0000\u0160\u015f"+
		"\u0001\u0000\u0000\u0000\u0161\u0163\u0001\u0000\u0000\u0000\u0162\u0142"+
		"\u0001\u0000\u0000\u0000\u0162\u0149\u0001\u0000\u0000\u0000\u0162\u0150"+
		"\u0001\u0000\u0000\u0000\u0162\u0155\u0001\u0000\u0000\u0000\u0162\u0156"+
		"\u0001\u0000\u0000\u0000\u0162\u0157\u0001\u0000\u0000\u0000\u0162\u015d"+
		"\u0001\u0000\u0000\u0000\u0163)\u0001\u0000\u0000\u0000\u0164\u0168\u0005"+
		"/\u0000\u0000\u0165\u0167\u0005&\u0000\u0000\u0166\u0165\u0001\u0000\u0000"+
		"\u0000\u0167\u016a\u0001\u0000\u0000\u0000\u0168\u0166\u0001\u0000\u0000"+
		"\u0000\u0168\u0169\u0001\u0000\u0000\u0000\u0169\u016b\u0001\u0000\u0000"+
		"\u0000\u016a\u0168\u0001\u0000\u0000\u0000\u016b\u016c\u0005V\u0000\u0000"+
		"\u016c+\u0001\u0000\u0000\u0000\u016d\u0171\u0005.\u0000\u0000\u016e\u0170"+
		"\u0005U\u0000\u0000\u016f\u016e\u0001\u0000\u0000\u0000\u0170\u0173\u0001"+
		"\u0000\u0000\u0000\u0171\u016f\u0001\u0000\u0000\u0000\u0171\u0172\u0001"+
		"\u0000\u0000\u0000\u0172\u0174\u0001\u0000\u0000\u0000\u0173\u0171\u0001"+
		"\u0000\u0000\u0000\u0174\u0175\u0005S\u0000\u0000\u0175-\u0001\u0000\u0000"+
		"\u0000\u0176\u017a\u00036\u001b\u0000\u0177\u017b\u0005#\u0000\u0000\u0178"+
		"\u017b\u0005$\u0000\u0000\u0179\u017b\u0001\u0000\u0000\u0000\u017a\u0177"+
		"\u0001\u0000\u0000\u0000\u017a\u0178\u0001\u0000\u0000\u0000\u017a\u0179"+
		"\u0001\u0000\u0000\u0000\u017b\u018b\u0001\u0000\u0000\u0000\u017c\u018b"+
		"\u00038\u001c\u0000\u017d\u0181\u00030\u0018\u0000\u017e\u0182\u0005#"+
		"\u0000\u0000\u017f\u0182\u0005$\u0000\u0000\u0180\u0182\u0001\u0000\u0000"+
		"\u0000\u0181\u017e\u0001\u0000\u0000\u0000\u0181\u017f\u0001\u0000\u0000"+
		"\u0000\u0181\u0180\u0001\u0000\u0000\u0000\u0182\u018b\u0001\u0000\u0000"+
		"\u0000\u0183\u0185\u0005R\u0000\u0000\u0184\u0186\u0003,\u0016\u0000\u0185"+
		"\u0184\u0001\u0000\u0000\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186"+
		"\u0188\u0001\u0000\u0000\u0000\u0187\u0189\u0007\u0003\u0000\u0000\u0188"+
		"\u0187\u0001\u0000\u0000\u0000\u0188\u0189\u0001\u0000\u0000\u0000\u0189"+
		"\u018b\u0001\u0000\u0000\u0000\u018a\u0176\u0001\u0000\u0000\u0000\u018a"+
		"\u017c\u0001\u0000\u0000\u0000\u018a\u017d\u0001\u0000\u0000\u0000\u018a"+
		"\u0183\u0001\u0000\u0000\u0000\u018b/\u0001\u0000\u0000\u0000\u018c\u018f"+
		"\u0005O\u0000\u0000\u018d\u0190\u0003:\u001d\u0000\u018e\u0190\u0003\u001a"+
		"\r\u0000\u018f\u018d\u0001\u0000\u0000\u0000\u018f\u018e\u0001\u0000\u0000"+
		"\u0000\u01901\u0001\u0000\u0000\u0000\u0191\u0192\u0005\"\u0000\u0000"+
		"\u0192\u0194\u0003&\u0013\u0000\u0193\u0195\u0003&\u0013\u0000\u0194\u0193"+
		"\u0001\u0000\u0000\u0000\u0195\u0196\u0001\u0000\u0000\u0000\u0196\u0194"+
		"\u0001\u0000\u0000\u0000\u0196\u0197\u0001\u0000\u0000\u0000\u0197\u0198"+
		"\u0001\u0000\u0000\u0000\u0198\u0199\u0005I\u0000\u0000\u01993\u0001\u0000"+
		"\u0000\u0000\u019a\u01a0\u0003\u001a\r\u0000\u019b\u01a1\u0005F\u0000"+
		"\u0000\u019c\u01a1\u0005L\u0000\u0000\u019d\u01a1\u0005E\u0000\u0000\u019e"+
		"\u01a1\u0005K\u0000\u0000\u019f\u01a1\u0001\u0000\u0000\u0000\u01a0\u019b"+
		"\u0001\u0000\u0000\u0000\u01a0\u019c\u0001\u0000\u0000\u0000\u01a0\u019d"+
		"\u0001\u0000\u0000\u0000\u01a0\u019e\u0001\u0000\u0000\u0000\u01a0\u019f"+
		"\u0001\u0000\u0000\u0000\u01a15\u0001\u0000\u0000\u0000\u01a2\u01a3\u0005"+
		"*\u0000\u0000\u01a3\u01a4\u0005\n\u0000\u0000\u01a4\u01a5\u0005*\u0000"+
		"\u0000\u01a57\u0001\u0000\u0000\u0000\u01a6\u01af\u0005*\u0000\u0000\u01a7"+
		"\u01aa\u0005Q\u0000\u0000\u01a8\u01ab\u0003,\u0016\u0000\u01a9\u01ab\u0001"+
		"\u0000\u0000\u0000\u01aa\u01a8\u0001\u0000\u0000\u0000\u01aa\u01a9\u0001"+
		"\u0000\u0000\u0000\u01ab\u01af\u0001\u0000\u0000\u0000\u01ac\u01af\u0005"+
		"+\u0000\u0000\u01ad\u01af\u0005?\u0000\u0000\u01ae\u01a6\u0001\u0000\u0000"+
		"\u0000\u01ae\u01a7\u0001\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000"+
		"\u0000\u01ae\u01ad\u0001\u0000\u0000\u0000\u01af\u01b1\u0001\u0000\u0000"+
		"\u0000\u01b0\u01b2\u0007\u0003\u0000\u0000\u01b1\u01b0\u0001\u0000\u0000"+
		"\u0000\u01b1\u01b2\u0001\u0000\u0000\u0000\u01b29\u0001\u0000\u0000\u0000"+
		"\u01b3\u01b4\u0007\u0004\u0000\u0000\u01b4;\u0001\u0000\u0000\u0000\u01b5"+
		"\u01b6\u0007\u0005\u0000\u0000\u01b6=\u0001\u0000\u0000\u0000\u01b7\u01b8"+
		"\u0005%\u0000\u0000\u01b8\u01b9\u0003*\u0015\u0000\u01b9\u01ba\u0005F"+
		"\u0000\u0000\u01ba\u01bb\u0003@ \u0000\u01bb\u01bd\u0001\u0000\u0000\u0000"+
		"\u01bc\u01b7\u0001\u0000\u0000\u0000\u01bd\u01c0\u0001\u0000\u0000\u0000"+
		"\u01be\u01bc\u0001\u0000\u0000\u0000\u01be\u01bf\u0001\u0000\u0000\u0000"+
		"\u01bf\u01c1\u0001\u0000\u0000\u0000\u01c0\u01be\u0001\u0000\u0000\u0000"+
		"\u01c1\u01c2\u0005%\u0000\u0000\u01c2\u01c5\u0003@ \u0000\u01c3\u01c5"+
		"\u0001\u0000\u0000\u0000\u01c4\u01be\u0001\u0000\u0000\u0000\u01c4\u01c3"+
		"\u0001\u0000\u0000\u0000\u01c5?\u0001\u0000\u0000\u0000\u01c6\u01ca\u0003"+
		"N\'\u0000\u01c7\u01ca\u0003D\"\u0000\u01c8\u01ca\u0001\u0000\u0000\u0000"+
		"\u01c9\u01c6\u0001\u0000\u0000\u0000\u01c9\u01c7\u0001\u0000\u0000\u0000"+
		"\u01c9\u01c8\u0001\u0000\u0000\u0000\u01caA\u0001\u0000\u0000\u0000\u01cb"+
		"\u01cc\u0005C\u0000\u0000\u01cc\u01cd\u0003D\"\u0000\u01cd\u01ce\u0005"+
		"I\u0000\u0000\u01ceC\u0001\u0000\u0000\u0000\u01cf\u01d1\u0003F#\u0000"+
		"\u01d0\u01cf\u0001\u0000\u0000\u0000\u01d1\u01d2\u0001\u0000\u0000\u0000"+
		"\u01d2\u01d0\u0001\u0000\u0000\u0000\u01d2\u01d3\u0001\u0000\u0000\u0000"+
		"\u01d3E\u0001\u0000\u0000\u0000\u01d4\u01df\u0003H$\u0000\u01d5\u01d6"+
		"\u0003H$\u0000\u01d6\u01d7\u0003<\u001e\u0000\u01d7\u01df\u0001\u0000"+
		"\u0000\u0000\u01d8\u01db\u0003L&\u0000\u01d9\u01dc\u0003<\u001e\u0000"+
		"\u01da\u01dc\u0001\u0000\u0000\u0000\u01db\u01d9\u0001\u0000\u0000\u0000"+
		"\u01db\u01da\u0001\u0000\u0000\u0000\u01dc\u01df\u0001\u0000\u0000\u0000"+
		"\u01dd\u01df\u0003J%\u0000\u01de\u01d4\u0001\u0000\u0000\u0000\u01de\u01d5"+
		"\u0001\u0000\u0000\u0000\u01de\u01d8\u0001\u0000\u0000\u0000\u01de\u01dd"+
		"\u0001\u0000\u0000\u0000\u01dfG\u0001\u0000\u0000\u0000\u01e0\u01eb\u0005"+
		"*\u0000\u0000\u01e1\u01e3\u0005Q\u0000\u0000\u01e2\u01e4\u0003,\u0016"+
		"\u0000\u01e3\u01e2\u0001\u0000\u0000\u0000\u01e3\u01e4\u0001\u0000\u0000"+
		"\u0000\u01e4\u01eb\u0001\u0000\u0000\u0000\u01e5\u01eb\u0005R\u0000\u0000"+
		"\u01e6\u01eb\u0005+\u0000\u0000\u01e7\u01e8\u0005M\u0000\u0000\u01e8\u01eb"+
		"\u0003X,\u0000\u01e9\u01eb\u0003*\u0015\u0000\u01ea\u01e0\u0001\u0000"+
		"\u0000\u0000\u01ea\u01e1\u0001\u0000\u0000\u0000\u01ea\u01e5\u0001\u0000"+
		"\u0000\u0000\u01ea\u01e6\u0001\u0000\u0000\u0000\u01ea\u01e7\u0001\u0000"+
		"\u0000\u0000\u01ea\u01e9\u0001\u0000\u0000\u0000\u01ebI\u0001\u0000\u0000"+
		"\u0000\u01ec\u01ed\u0003B!\u0000\u01ed\u01ee\u0003<\u001e\u0000\u01ee"+
		"K\u0001\u0000\u0000\u0000\u01ef\u01f0\u0005\"\u0000\u0000\u01f0\u01f4"+
		"\u0003H$\u0000\u01f1\u01f3\u0003F#\u0000\u01f2\u01f1\u0001\u0000\u0000"+
		"\u0000\u01f3\u01f6\u0001\u0000\u0000\u0000\u01f4\u01f2\u0001\u0000\u0000"+
		"\u0000\u01f4\u01f5\u0001\u0000\u0000\u0000\u01f5\u01f7\u0001\u0000\u0000"+
		"\u0000\u01f6\u01f4\u0001\u0000\u0000\u0000\u01f7\u01f8\u0005I\u0000\u0000"+
		"\u01f8M\u0001\u0000\u0000\u0000\u01f9\u01fa\u0003X,\u0000\u01fa\u01fb"+
		"\u0005C\u0000\u0000\u01fb\u01fc\u0003T*\u0000\u01fc\u01fd\u0005I\u0000"+
		"\u0000\u01fd\u01fe\u0007\u0006\u0000\u0000\u01fe\u0203\u0001\u0000\u0000"+
		"\u0000\u01ff\u0203\u0003P(\u0000\u0200\u0203\u0003R)\u0000\u0201\u0203"+
		"\u0003*\u0015\u0000\u0202\u01f9\u0001\u0000\u0000\u0000\u0202\u01ff\u0001"+
		"\u0000\u0000\u0000\u0202\u0200\u0001\u0000\u0000\u0000\u0202\u0201\u0001"+
		"\u0000\u0000\u0000\u0203O\u0001\u0000\u0000\u0000\u0204\u0205\u0003X,"+
		"\u0000\u0205\u0206\u0005C\u0000\u0000\u0206\u0207\u0003T*\u0000\u0207"+
		"\u0208\u0005I\u0000\u0000\u0208Q\u0001\u0000\u0000\u0000\u0209\u020a\u0005"+
		"C\u0000\u0000\u020a\u020b\u0003*\u0015\u0000\u020b\u020c\u0005I\u0000"+
		"\u0000\u020c\u020d\u0005C\u0000\u0000\u020d\u020e\u0003T*\u0000\u020e"+
		"\u020f\u0005I\u0000\u0000\u020fS\u0001\u0000\u0000\u0000\u0210\u0215\u0003"+
		"V+\u0000\u0211\u0212\u0005>\u0000\u0000\u0212\u0214\u0003V+\u0000\u0213"+
		"\u0211\u0001\u0000\u0000\u0000\u0214\u0217\u0001\u0000\u0000\u0000\u0215"+
		"\u0213\u0001\u0000\u0000\u0000\u0215\u0216\u0001\u0000\u0000\u0000\u0216"+
		"\u021a\u0001\u0000\u0000\u0000\u0217\u0215\u0001\u0000\u0000\u0000\u0218"+
		"\u021a\u0001\u0000\u0000\u0000\u0219\u0210\u0001\u0000\u0000\u0000\u0219"+
		"\u0218\u0001\u0000\u0000\u0000\u021aU\u0001\u0000\u0000\u0000\u021b\u021c"+
		"\u0003X,\u0000\u021c\u021d\u0005@\u0000\u0000\u021d\u021e\u0003*\u0015"+
		"\u0000\u021eW\u0001\u0000\u0000\u0000\u021f\u0220\u0007\u0007\u0000\u0000"+
		"\u0220Y\u0001\u0000\u0000\u0000C[agjou{\u0084\u008c\u0098\u00a0\u00a7"+
		"\u00b6\u00b9\u00bc\u00c0\u00c3\u00c7\u00ca\u00cd\u00d0\u00d5\u00dc\u00e8"+
		"\u00f3\u0100\u0105\u0109\u010c\u0116\u0123\u0129\u012c\u0131\u0134\u0137"+
		"\u0147\u014e\u0153\u015b\u0160\u0162\u0168\u0171\u017a\u0181\u0185\u0188"+
		"\u018a\u018f\u0196\u01a0\u01aa\u01ae\u01b1\u01be\u01c4\u01c9\u01d2\u01db"+
		"\u01de\u01e3\u01ea\u01f4\u0202\u0215\u0219";
	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);
		}
	}
}