org.antlr.v4.parse.GrammarTreeVisitor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr4 Show documentation
The ANTLR 4 grammar compiler.
There is a newer version: 4.13.2
// $ANTLR 3.5 org\\antlr\\v4\\parse\\GrammarTreeVisitor.g 2013-01-21 13:51:55

/*
 [The "BSD license"]
 Copyright (c) 2011 Terence Parr
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:

 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. The name of the author may not be used to endorse or promote products
    derived from this software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.antlr.v4.parse;
import org.antlr.v4.tool.*;
import org.antlr.v4.tool.ast.*;
import java.lang.reflect.Method;


import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

/** The definitive ANTLR v3 tree grammar to walk/visit ANTLR v4 grammars.
 *  Parses trees created by ANTLRParser.g.
 *
 *  Rather than have multiple tree grammars, one for each visit, I'm
 *  creating this generic visitor that knows about context. All of the
 *  boilerplate pattern recognition is done here. Then, subclasses can
 *  override the methods they care about. This prevents a lot of the same
 *  context tracking stuff like "set current alternative for current
 *  rule node" that is repeated in lots of tree filters.
 */
@SuppressWarnings("all")
public class GrammarTreeVisitor extends TreeParser {
	public static final String[] tokenNames = new String[] {
		"", "", "", "", "ACTION", "ACTION_CHAR_LITERAL", 
		"ACTION_ESC", "ACTION_STRING_LITERAL", "ARG_ACTION", "ARG_OR_CHARSET", 
		"ASSIGN", "AT", "CATCH", "COLON", "COLONCOLON", "COMMA", "COMMENT", "DOC_COMMENT", 
		"DOLLAR", "DOT", "ERRCHAR", "ESC_SEQ", "FINALLY", "FRAGMENT", "GRAMMAR", 
		"GT", "HEX_DIGIT", "ID", "IMPORT", "INT", "LEXER", "LEXER_CHAR_SET", "LOCALS", 
		"LPAREN", "LT", "MODE", "NESTED_ACTION", "NLCHARS", "NOT", "NameChar", 
		"NameStartChar", "OPTIONS", "OR", "PARSER", "PLUS", "PLUS_ASSIGN", "POUND", 
		"PRIVATE", "PROTECTED", "PUBLIC", "QUESTION", "RANGE", "RARROW", "RBRACE", 
		"RETURNS", "RPAREN", "RULE_REF", "SEMI", "SEMPRED", "SRC", "STAR", "STRING_LITERAL", 
		"SYNPRED", "THROWS", "TOKENS_SPEC", "TOKEN_REF", "TREE_GRAMMAR", "UNICODE_ESC", 
		"WS", "WSCHARS", "WSNLCHARS", "ALT", "ALTLIST", "ARG", "ARGLIST", "BLOCK", 
		"CHAR_RANGE", "CLOSURE", "COMBINED", "ELEMENT_OPTIONS", "EPSILON", "INITACTION", 
		"LABEL", "LEXER_ACTION_CALL", "LEXER_ALT_ACTION", "LIST", "OPTIONAL", 
		"POSITIVE_CLOSURE", "PREC_RULE", "RESULT", "RET", "RULE", "RULEACTIONS", 
		"RULEMODIFIERS", "RULES", "SET", "TEMPLATE", "WILDCARD"
	};
	public static final int EOF=-1;
	public static final int ACTION=4;
	public static final int ACTION_CHAR_LITERAL=5;
	public static final int ACTION_ESC=6;
	public static final int ACTION_STRING_LITERAL=7;
	public static final int ARG_ACTION=8;
	public static final int ARG_OR_CHARSET=9;
	public static final int ASSIGN=10;
	public static final int AT=11;
	public static final int CATCH=12;
	public static final int COLON=13;
	public static final int COLONCOLON=14;
	public static final int COMMA=15;
	public static final int COMMENT=16;
	public static final int DOC_COMMENT=17;
	public static final int DOLLAR=18;
	public static final int DOT=19;
	public static final int ERRCHAR=20;
	public static final int ESC_SEQ=21;
	public static final int FINALLY=22;
	public static final int FRAGMENT=23;
	public static final int GRAMMAR=24;
	public static final int GT=25;
	public static final int HEX_DIGIT=26;
	public static final int ID=27;
	public static final int IMPORT=28;
	public static final int INT=29;
	public static final int LEXER=30;
	public static final int LEXER_CHAR_SET=31;
	public static final int LOCALS=32;
	public static final int LPAREN=33;
	public static final int LT=34;
	public static final int MODE=35;
	public static final int NESTED_ACTION=36;
	public static final int NLCHARS=37;
	public static final int NOT=38;
	public static final int NameChar=39;
	public static final int NameStartChar=40;
	public static final int OPTIONS=41;
	public static final int OR=42;
	public static final int PARSER=43;
	public static final int PLUS=44;
	public static final int PLUS_ASSIGN=45;
	public static final int POUND=46;
	public static final int PRIVATE=47;
	public static final int PROTECTED=48;
	public static final int PUBLIC=49;
	public static final int QUESTION=50;
	public static final int RANGE=51;
	public static final int RARROW=52;
	public static final int RBRACE=53;
	public static final int RETURNS=54;
	public static final int RPAREN=55;
	public static final int RULE_REF=56;
	public static final int SEMI=57;
	public static final int SEMPRED=58;
	public static final int SRC=59;
	public static final int STAR=60;
	public static final int STRING_LITERAL=61;
	public static final int SYNPRED=62;
	public static final int THROWS=63;
	public static final int TOKENS_SPEC=64;
	public static final int TOKEN_REF=65;
	public static final int TREE_GRAMMAR=66;
	public static final int UNICODE_ESC=67;
	public static final int WS=68;
	public static final int WSCHARS=69;
	public static final int WSNLCHARS=70;
	public static final int ALT=71;
	public static final int ALTLIST=72;
	public static final int ARG=73;
	public static final int ARGLIST=74;
	public static final int BLOCK=75;
	public static final int CHAR_RANGE=76;
	public static final int CLOSURE=77;
	public static final int COMBINED=78;
	public static final int ELEMENT_OPTIONS=79;
	public static final int EPSILON=80;
	public static final int INITACTION=81;
	public static final int LABEL=82;
	public static final int LEXER_ACTION_CALL=83;
	public static final int LEXER_ALT_ACTION=84;
	public static final int LIST=85;
	public static final int OPTIONAL=86;
	public static final int POSITIVE_CLOSURE=87;
	public static final int PREC_RULE=88;
	public static final int RESULT=89;
	public static final int RET=90;
	public static final int RULE=91;
	public static final int RULEACTIONS=92;
	public static final int RULEMODIFIERS=93;
	public static final int RULES=94;
	public static final int SET=95;
	public static final int TEMPLATE=96;
	public static final int WILDCARD=97;

	// delegates
	public TreeParser[] getDelegates() {
		return new TreeParser[] {};
	}

	// delegators


	public GrammarTreeVisitor(TreeNodeStream input) {
		this(input, new RecognizerSharedState());
	}
	public GrammarTreeVisitor(TreeNodeStream input, RecognizerSharedState state) {
		super(input, state);
	}

	@Override public String[] getTokenNames() { return GrammarTreeVisitor.tokenNames; }
	@Override public String getGrammarFileName() { return "org\\antlr\\v4\\parse\\GrammarTreeVisitor.g"; }


	public String grammarName;
	public GrammarAST currentRuleAST;
	public String currentModeName = LexerGrammar.DEFAULT_MODE_NAME;
	public String currentRuleName;
	//public GrammarAST currentRuleBlock;
	public GrammarAST currentOuterAltRoot;
	public int currentOuterAltNumber = 1; // 1..n
	public int rewriteEBNFLevel = 0;

	public GrammarTreeVisitor() { this(null); }

	public ErrorManager getErrorManager() { return null; }

	public void visitGrammar(GrammarAST t) { visit(t, "grammarSpec"); }
	public void visit(GrammarAST t, String ruleName) {
		CommonTreeNodeStream nodes = new CommonTreeNodeStream(new GrammarASTAdaptor(), t);
		setTreeNodeStream(nodes);
		try {
			Method m = getClass().getMethod(ruleName);
			m.invoke(this);
		}
		catch (Exception e) {
			ErrorManager errMgr = getErrorManager();
			if ( errMgr==null ) {
				System.err.println("can't find rule "+ruleName+
								   " or tree structure error: "+t.toStringTree()
								   );
				e.printStackTrace(System.err);
			}
			else errMgr.toolError(ErrorType.INTERNAL_ERROR, e);
		}
	}

	public void discoverGrammar(GrammarRootAST root, GrammarAST ID) { }
	public void finishPrequels(GrammarAST firstPrequel) { }
	public void finishGrammar(GrammarRootAST root, GrammarAST ID) { }

	public void grammarOption(GrammarAST ID, GrammarAST valueAST) { }
	public void ruleOption(GrammarAST ID, GrammarAST valueAST) { }
	public void blockOption(GrammarAST ID, GrammarAST valueAST) { }
	public void defineToken(GrammarAST ID) { }
	public void globalNamedAction(GrammarAST scope, GrammarAST ID, ActionAST action) { }
	public void importGrammar(GrammarAST label, GrammarAST ID) { }

	public void modeDef(GrammarAST m, GrammarAST ID) { }

	public void discoverRules(GrammarAST rules) { }
	public void finishRules(GrammarAST rule) { }
	public void discoverRule(RuleAST rule, GrammarAST ID, List modifiers,
							 ActionAST arg, ActionAST returns, GrammarAST thrws,
							 GrammarAST options, ActionAST locals,
							 List actions,
							 GrammarAST block) { }
	public void finishRule(RuleAST rule, GrammarAST ID, GrammarAST block) { }
	public void discoverLexerRule(RuleAST rule, GrammarAST ID, List modifiers,
	                              GrammarAST block) { }
	public void finishLexerRule(RuleAST rule, GrammarAST ID, GrammarAST block) { }
	public void ruleCatch(GrammarAST arg, ActionAST action) { }
	public void finallyAction(ActionAST action) { }
	public void discoverOuterAlt(AltAST alt) { }
	public void finishOuterAlt(AltAST alt) { }
	public void discoverAlt(AltAST alt) { }
	public void finishAlt(AltAST alt) { }

	public void ruleRef(GrammarAST ref, ActionAST arg) { }
	public void tokenRef(TerminalAST ref) { }
	public void elementOption(GrammarASTWithOptions t, GrammarAST ID, GrammarAST valueAST) { }
	public void stringRef(TerminalAST ref) { }
	public void wildcardRef(GrammarAST ref) { }
	public void actionInAlt(ActionAST action) { }
	public void sempredInAlt(PredAST pred) { }
	public void label(GrammarAST op, GrammarAST ID, GrammarAST element) { }
	public void lexerCallCommand(int outerAltNumber, GrammarAST ID, GrammarAST arg) { }
	public void lexerCommand(int outerAltNumber, GrammarAST ID) { }

	protected void enterGrammarSpec(GrammarAST tree) { }
	protected void exitGrammarSpec(GrammarAST tree) { }

	protected void enterPrequelConstructs(GrammarAST tree) { }
	protected void exitPrequelConstructs(GrammarAST tree) { }

	protected void enterPrequelConstruct(GrammarAST tree) { }
	protected void exitPrequelConstruct(GrammarAST tree) { }

	protected void enterOptionsSpec(GrammarAST tree) { }
	protected void exitOptionsSpec(GrammarAST tree) { }

	protected void enterOption(GrammarAST tree) { }
	protected void exitOption(GrammarAST tree) { }

	protected void enterOptionValue(GrammarAST tree) { }
	protected void exitOptionValue(GrammarAST tree) { }

	protected void enterDelegateGrammars(GrammarAST tree) { }
	protected void exitDelegateGrammars(GrammarAST tree) { }

	protected void enterDelegateGrammar(GrammarAST tree) { }
	protected void exitDelegateGrammar(GrammarAST tree) { }

	protected void enterTokensSpec(GrammarAST tree) { }
	protected void exitTokensSpec(GrammarAST tree) { }

	protected void enterTokenSpec(GrammarAST tree) { }
	protected void exitTokenSpec(GrammarAST tree) { }

	protected void enterAction(GrammarAST tree) { }
	protected void exitAction(GrammarAST tree) { }

	protected void enterRules(GrammarAST tree) { }
	protected void exitRules(GrammarAST tree) { }

	protected void enterMode(GrammarAST tree) { }
	protected void exitMode(GrammarAST tree) { }

	protected void enterLexerRule(GrammarAST tree) { }
	protected void exitLexerRule(GrammarAST tree) { }

	protected void enterRule(GrammarAST tree) { }
	protected void exitRule(GrammarAST tree) { }

	protected void enterExceptionGroup(GrammarAST tree) { }
	protected void exitExceptionGroup(GrammarAST tree) { }

	protected void enterExceptionHandler(GrammarAST tree) { }
	protected void exitExceptionHandler(GrammarAST tree) { }

	protected void enterFinallyClause(GrammarAST tree) { }
	protected void exitFinallyClause(GrammarAST tree) { }

	protected void enterLocals(GrammarAST tree) { }
	protected void exitLocals(GrammarAST tree) { }

	protected void enterRuleReturns(GrammarAST tree) { }
	protected void exitRuleReturns(GrammarAST tree) { }

	protected void enterThrowsSpec(GrammarAST tree) { }
	protected void exitThrowsSpec(GrammarAST tree) { }

	protected void enterRuleAction(GrammarAST tree) { }
	protected void exitRuleAction(GrammarAST tree) { }

	protected void enterRuleModifier(GrammarAST tree) { }
	protected void exitRuleModifier(GrammarAST tree) { }

	protected void enterLexerRuleBlock(GrammarAST tree) { }
	protected void exitLexerRuleBlock(GrammarAST tree) { }

	protected void enterRuleBlock(GrammarAST tree) { }
	protected void exitRuleBlock(GrammarAST tree) { }

	protected void enterLexerOuterAlternative(AltAST tree) { }
	protected void exitLexerOuterAlternative(AltAST tree) { }

	protected void enterOuterAlternative(AltAST tree) { }
	protected void exitOuterAlternative(AltAST tree) { }

	protected void enterLexerAlternative(GrammarAST tree) { }
	protected void exitLexerAlternative(GrammarAST tree) { }

	protected void enterLexerElements(GrammarAST tree) { }
	protected void exitLexerElements(GrammarAST tree) { }

	protected void enterLexerElement(GrammarAST tree) { }
	protected void exitLexerElement(GrammarAST tree) { }

	protected void enterLabeledLexerElement(GrammarAST tree) { }
	protected void exitLabeledLexerElement(GrammarAST tree) { }

	protected void enterLexerBlock(GrammarAST tree) { }
	protected void exitLexerBlock(GrammarAST tree) { }

	protected void enterLexerAtom(GrammarAST tree) { }
	protected void exitLexerAtom(GrammarAST tree) { }

	protected void enterActionElement(GrammarAST tree) { }
	protected void exitActionElement(GrammarAST tree) { }

	protected void enterAlternative(AltAST tree) { }
	protected void exitAlternative(AltAST tree) { }

	protected void enterLexerCommand(GrammarAST tree) { }
	protected void exitLexerCommand(GrammarAST tree) { }

	protected void enterLexerCommandExpr(GrammarAST tree) { }
	protected void exitLexerCommandExpr(GrammarAST tree) { }

	protected void enterElement(GrammarAST tree) { }
	protected void exitElement(GrammarAST tree) { }

	protected void enterAstOperand(GrammarAST tree) { }
	protected void exitAstOperand(GrammarAST tree) { }

	protected void enterLabeledElement(GrammarAST tree) { }
	protected void exitLabeledElement(GrammarAST tree) { }

	protected void enterSubrule(GrammarAST tree) { }
	protected void exitSubrule(GrammarAST tree) { }

	protected void enterLexerSubrule(GrammarAST tree) { }
	protected void exitLexerSubrule(GrammarAST tree) { }

	protected void enterBlockSuffix(GrammarAST tree) { }
	protected void exitBlockSuffix(GrammarAST tree) { }

	protected void enterEbnfSuffix(GrammarAST tree) { }
	protected void exitEbnfSuffix(GrammarAST tree) { }

	protected void enterAtom(GrammarAST tree) { }
	protected void exitAtom(GrammarAST tree) { }

	protected void enterBlockSet(GrammarAST tree) { }
	protected void exitBlockSet(GrammarAST tree) { }

	protected void enterSetElement(GrammarAST tree) { }
	protected void exitSetElement(GrammarAST tree) { }

	protected void enterBlock(GrammarAST tree) { }
	protected void exitBlock(GrammarAST tree) { }

	protected void enterRuleref(GrammarAST tree) { }
	protected void exitRuleref(GrammarAST tree) { }

	protected void enterRange(GrammarAST tree) { }
	protected void exitRange(GrammarAST tree) { }

	protected void enterTerminal(GrammarAST tree) { }
	protected void exitTerminal(GrammarAST tree) { }

	protected void enterElementOptions(GrammarAST tree) { }
	protected void exitElementOptions(GrammarAST tree) { }

	protected void enterElementOption(GrammarAST tree) { }
	protected void exitElementOption(GrammarAST tree) { }

		@Override
		public void traceIn(String ruleName, int ruleIndex)  {
			System.err.println("enter "+ruleName+": "+input.LT(1));
		}

		@Override
		public void traceOut(String ruleName, int ruleIndex)  {
			System.err.println("exit "+ruleName+": "+input.LT(1));
		}


	public static class grammarSpec_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "grammarSpec"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:330:1: grammarSpec : ^( GRAMMAR ID ( DOC_COMMENT )? prequelConstructs rules ( mode )* ) ;
	public final GrammarTreeVisitor.grammarSpec_return grammarSpec() throws RecognitionException {
		GrammarTreeVisitor.grammarSpec_return retval = new GrammarTreeVisitor.grammarSpec_return();
		retval.start = input.LT(1);

		GrammarAST ID1=null;
		GrammarAST GRAMMAR2=null;
		TreeRuleReturnScope prequelConstructs3 =null;


			enterGrammarSpec(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:337:5: ( ^( GRAMMAR ID ( DOC_COMMENT )? prequelConstructs rules ( mode )* ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:337:9: ^( GRAMMAR ID ( DOC_COMMENT )? prequelConstructs rules ( mode )* )
			{
			GRAMMAR2=(GrammarAST)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarSpec85); 
			match(input, Token.DOWN, null); 
			ID1=(GrammarAST)match(input,ID,FOLLOW_ID_in_grammarSpec87); 
			grammarName=(ID1!=null?ID1.getText():null);
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:337:47: ( DOC_COMMENT )?
			int alt1=2;
			int LA1_0 = input.LA(1);
			if ( (LA1_0==DOC_COMMENT) ) {
				alt1=1;
			}
			switch (alt1) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:337:47: DOC_COMMENT
					{
					match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_grammarSpec91); 
					}
					break;

			}

			discoverGrammar((GrammarRootAST)GRAMMAR2, ID1);
			pushFollow(FOLLOW_prequelConstructs_in_grammarSpec109);
			prequelConstructs3=prequelConstructs();
			state._fsp--;

			finishPrequels((prequelConstructs3!=null?((GrammarTreeVisitor.prequelConstructs_return)prequelConstructs3).firstOne:null));
			pushFollow(FOLLOW_rules_in_grammarSpec126);
			rules();
			state._fsp--;

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:341:14: ( mode )*
			loop2:
			while (true) {
				int alt2=2;
				int LA2_0 = input.LA(1);
				if ( (LA2_0==MODE) ) {
					alt2=1;
				}

				switch (alt2) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:341:14: mode
					{
					pushFollow(FOLLOW_mode_in_grammarSpec128);
					mode();
					state._fsp--;

					}
					break;

				default :
					break loop2;
				}
			}

			finishGrammar((GrammarRootAST)GRAMMAR2, ID1);
			match(input, Token.UP, null); 

			}


				exitGrammarSpec(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "grammarSpec"


	public static class prequelConstructs_return extends TreeRuleReturnScope {
		public GrammarAST firstOne=null;
	};


	// $ANTLR start "prequelConstructs"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:346:1: prequelConstructs returns [GrammarAST firstOne=null] : ( ( prequelConstruct )+ |);
	public final GrammarTreeVisitor.prequelConstructs_return prequelConstructs() throws RecognitionException {
		GrammarTreeVisitor.prequelConstructs_return retval = new GrammarTreeVisitor.prequelConstructs_return();
		retval.start = input.LT(1);


			enterPrequelConstructs(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:353:2: ( ( prequelConstruct )+ |)
			int alt4=2;
			int LA4_0 = input.LA(1);
			if ( (LA4_0==AT||LA4_0==IMPORT||LA4_0==OPTIONS||LA4_0==TOKENS_SPEC) ) {
				alt4=1;
			}
			else if ( (LA4_0==RULES) ) {
				alt4=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 4, 0, input);
				throw nvae;
			}

			switch (alt4) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:353:4: ( prequelConstruct )+
					{
					retval.firstOne =((GrammarAST)retval.start);
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:353:24: ( prequelConstruct )+
					int cnt3=0;
					loop3:
					while (true) {
						int alt3=2;
						int LA3_0 = input.LA(1);
						if ( (LA3_0==AT||LA3_0==IMPORT||LA3_0==OPTIONS||LA3_0==TOKENS_SPEC) ) {
							alt3=1;
						}

						switch (alt3) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:353:24: prequelConstruct
							{
							pushFollow(FOLLOW_prequelConstruct_in_prequelConstructs170);
							prequelConstruct();
							state._fsp--;

							}
							break;

						default :
							if ( cnt3 >= 1 ) break loop3;
							EarlyExitException eee = new EarlyExitException(3, input);
							throw eee;
						}
						cnt3++;
					}

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:355:2: 
					{
					}
					break;

			}

				exitPrequelConstructs(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "prequelConstructs"


	public static class prequelConstruct_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "prequelConstruct"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:357:1: prequelConstruct : ( optionsSpec | delegateGrammars | tokensSpec | action );
	public final GrammarTreeVisitor.prequelConstruct_return prequelConstruct() throws RecognitionException {
		GrammarTreeVisitor.prequelConstruct_return retval = new GrammarTreeVisitor.prequelConstruct_return();
		retval.start = input.LT(1);


			enterPrequelConstructs(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:364:2: ( optionsSpec | delegateGrammars | tokensSpec | action )
			int alt5=4;
			switch ( input.LA(1) ) {
			case OPTIONS:
				{
				alt5=1;
				}
				break;
			case IMPORT:
				{
				alt5=2;
				}
				break;
			case TOKENS_SPEC:
				{
				alt5=3;
				}
				break;
			case AT:
				{
				alt5=4;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 5, 0, input);
				throw nvae;
			}
			switch (alt5) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:364:6: optionsSpec
					{
					pushFollow(FOLLOW_optionsSpec_in_prequelConstruct197);
					optionsSpec();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:365:9: delegateGrammars
					{
					pushFollow(FOLLOW_delegateGrammars_in_prequelConstruct207);
					delegateGrammars();
					state._fsp--;

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:366:9: tokensSpec
					{
					pushFollow(FOLLOW_tokensSpec_in_prequelConstruct217);
					tokensSpec();
					state._fsp--;

					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:367:9: action
					{
					pushFollow(FOLLOW_action_in_prequelConstruct227);
					action();
					state._fsp--;

					}
					break;

			}

				exitPrequelConstructs(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "prequelConstruct"


	public static class optionsSpec_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "optionsSpec"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:370:1: optionsSpec : ^( OPTIONS ( option )* ) ;
	public final GrammarTreeVisitor.optionsSpec_return optionsSpec() throws RecognitionException {
		GrammarTreeVisitor.optionsSpec_return retval = new GrammarTreeVisitor.optionsSpec_return();
		retval.start = input.LT(1);


			enterOptionsSpec(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:377:2: ( ^( OPTIONS ( option )* ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:377:4: ^( OPTIONS ( option )* )
			{
			match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec252); 
			if ( input.LA(1)==Token.DOWN ) {
				match(input, Token.DOWN, null); 
				// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:377:14: ( option )*
				loop6:
				while (true) {
					int alt6=2;
					int LA6_0 = input.LA(1);
					if ( (LA6_0==ASSIGN) ) {
						alt6=1;
					}

					switch (alt6) {
					case 1 :
						// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:377:14: option
						{
						pushFollow(FOLLOW_option_in_optionsSpec254);
						option();
						state._fsp--;

						}
						break;

					default :
						break loop6;
					}
				}

				match(input, Token.UP, null); 
			}

			}


				exitOptionsSpec(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "optionsSpec"


	public static class option_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "option"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:380:1: option : ^(a= ASSIGN ID v= optionValue ) ;
	public final GrammarTreeVisitor.option_return option() throws RecognitionException {
		GrammarTreeVisitor.option_return retval = new GrammarTreeVisitor.option_return();
		retval.start = input.LT(1);

		GrammarAST a=null;
		GrammarAST ID4=null;
		TreeRuleReturnScope v =null;


			enterOption(((GrammarAST)retval.start));
			boolean rule = inContext("RULE ...");
			boolean block = inContext("BLOCK ...");

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:389:5: ( ^(a= ASSIGN ID v= optionValue ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:389:9: ^(a= ASSIGN ID v= optionValue )
			{
			a=(GrammarAST)match(input,ASSIGN,FOLLOW_ASSIGN_in_option288); 
			match(input, Token.DOWN, null); 
			ID4=(GrammarAST)match(input,ID,FOLLOW_ID_in_option290); 
			pushFollow(FOLLOW_optionValue_in_option294);
			v=optionValue();
			state._fsp--;

			match(input, Token.UP, null); 


			    	if ( block ) blockOption(ID4, (v!=null?((GrammarAST)v.start):null)); // most specific first
			    	else if ( rule ) ruleOption(ID4, (v!=null?((GrammarAST)v.start):null));
			    	else grammarOption(ID4, (v!=null?((GrammarAST)v.start):null));
			    	
			}


				exitOption(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "option"


	public static class optionValue_return extends TreeRuleReturnScope {
		public String v;
	};


	// $ANTLR start "optionValue"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:397:1: optionValue returns [String v] : ( ID | STRING_LITERAL | INT );
	public final GrammarTreeVisitor.optionValue_return optionValue() throws RecognitionException {
		GrammarTreeVisitor.optionValue_return retval = new GrammarTreeVisitor.optionValue_return();
		retval.start = input.LT(1);


			enterOptionValue(((GrammarAST)retval.start));
			retval.v = ((GrammarAST)retval.start).token.getText();

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:405:5: ( ID | STRING_LITERAL | INT )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:
			{
			if ( input.LA(1)==ID||input.LA(1)==INT||input.LA(1)==STRING_LITERAL ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}


				exitOptionValue(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "optionValue"


	public static class delegateGrammars_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "delegateGrammars"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:410:1: delegateGrammars : ^( IMPORT ( delegateGrammar )+ ) ;
	public final GrammarTreeVisitor.delegateGrammars_return delegateGrammars() throws RecognitionException {
		GrammarTreeVisitor.delegateGrammars_return retval = new GrammarTreeVisitor.delegateGrammars_return();
		retval.start = input.LT(1);


			enterDelegateGrammars(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:417:2: ( ^( IMPORT ( delegateGrammar )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:417:6: ^( IMPORT ( delegateGrammar )+ )
			{
			match(input,IMPORT,FOLLOW_IMPORT_in_delegateGrammars382); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:417:15: ( delegateGrammar )+
			int cnt7=0;
			loop7:
			while (true) {
				int alt7=2;
				int LA7_0 = input.LA(1);
				if ( (LA7_0==ASSIGN||LA7_0==ID) ) {
					alt7=1;
				}

				switch (alt7) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:417:15: delegateGrammar
					{
					pushFollow(FOLLOW_delegateGrammar_in_delegateGrammars384);
					delegateGrammar();
					state._fsp--;

					}
					break;

				default :
					if ( cnt7 >= 1 ) break loop7;
					EarlyExitException eee = new EarlyExitException(7, input);
					throw eee;
				}
				cnt7++;
			}

			match(input, Token.UP, null); 

			}


				exitDelegateGrammars(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "delegateGrammars"


	public static class delegateGrammar_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "delegateGrammar"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:420:1: delegateGrammar : ( ^( ASSIGN label= ID id= ID ) |id= ID );
	public final GrammarTreeVisitor.delegateGrammar_return delegateGrammar() throws RecognitionException {
		GrammarTreeVisitor.delegateGrammar_return retval = new GrammarTreeVisitor.delegateGrammar_return();
		retval.start = input.LT(1);

		GrammarAST label=null;
		GrammarAST id=null;


			enterDelegateGrammar(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:427:5: ( ^( ASSIGN label= ID id= ID ) |id= ID )
			int alt8=2;
			int LA8_0 = input.LA(1);
			if ( (LA8_0==ASSIGN) ) {
				alt8=1;
			}
			else if ( (LA8_0==ID) ) {
				alt8=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 8, 0, input);
				throw nvae;
			}

			switch (alt8) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:427:9: ^( ASSIGN label= ID id= ID )
					{
					match(input,ASSIGN,FOLLOW_ASSIGN_in_delegateGrammar413); 
					match(input, Token.DOWN, null); 
					label=(GrammarAST)match(input,ID,FOLLOW_ID_in_delegateGrammar417); 
					id=(GrammarAST)match(input,ID,FOLLOW_ID_in_delegateGrammar421); 
					match(input, Token.UP, null); 

					importGrammar(label, id);
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:428:9: id= ID
					{
					id=(GrammarAST)match(input,ID,FOLLOW_ID_in_delegateGrammar436); 
					importGrammar(null, id);
					}
					break;

			}

				exitDelegateGrammar(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "delegateGrammar"


	public static class tokensSpec_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "tokensSpec"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:431:1: tokensSpec : ^( TOKENS_SPEC ( tokenSpec )+ ) ;
	public final GrammarTreeVisitor.tokensSpec_return tokensSpec() throws RecognitionException {
		GrammarTreeVisitor.tokensSpec_return retval = new GrammarTreeVisitor.tokensSpec_return();
		retval.start = input.LT(1);


			enterTokensSpec(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:438:2: ( ^( TOKENS_SPEC ( tokenSpec )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:438:6: ^( TOKENS_SPEC ( tokenSpec )+ )
			{
			match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec470); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:438:20: ( tokenSpec )+
			int cnt9=0;
			loop9:
			while (true) {
				int alt9=2;
				int LA9_0 = input.LA(1);
				if ( (LA9_0==ID) ) {
					alt9=1;
				}

				switch (alt9) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:438:20: tokenSpec
					{
					pushFollow(FOLLOW_tokenSpec_in_tokensSpec472);
					tokenSpec();
					state._fsp--;

					}
					break;

				default :
					if ( cnt9 >= 1 ) break loop9;
					EarlyExitException eee = new EarlyExitException(9, input);
					throw eee;
				}
				cnt9++;
			}

			match(input, Token.UP, null); 

			}


				exitTokensSpec(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "tokensSpec"


	public static class tokenSpec_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "tokenSpec"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:441:1: tokenSpec : ID ;
	public final GrammarTreeVisitor.tokenSpec_return tokenSpec() throws RecognitionException {
		GrammarTreeVisitor.tokenSpec_return retval = new GrammarTreeVisitor.tokenSpec_return();
		retval.start = input.LT(1);

		GrammarAST ID5=null;


			enterTokenSpec(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:448:2: ( ID )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:448:4: ID
			{
			ID5=(GrammarAST)match(input,ID,FOLLOW_ID_in_tokenSpec495); 
			defineToken(ID5);
			}


				exitTokenSpec(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "tokenSpec"


	public static class action_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "action"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:451:1: action : ^( AT (sc= ID )? name= ID ACTION ) ;
	public final GrammarTreeVisitor.action_return action() throws RecognitionException {
		GrammarTreeVisitor.action_return retval = new GrammarTreeVisitor.action_return();
		retval.start = input.LT(1);

		GrammarAST sc=null;
		GrammarAST name=null;
		GrammarAST ACTION6=null;


			enterAction(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:458:2: ( ^( AT (sc= ID )? name= ID ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:458:4: ^( AT (sc= ID )? name= ID ACTION )
			{
			match(input,AT,FOLLOW_AT_in_action523); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:458:11: (sc= ID )?
			int alt10=2;
			int LA10_0 = input.LA(1);
			if ( (LA10_0==ID) ) {
				int LA10_1 = input.LA(2);
				if ( (LA10_1==ID) ) {
					alt10=1;
				}
			}
			switch (alt10) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:458:11: sc= ID
					{
					sc=(GrammarAST)match(input,ID,FOLLOW_ID_in_action527); 
					}
					break;

			}

			name=(GrammarAST)match(input,ID,FOLLOW_ID_in_action532); 
			ACTION6=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_action534); 
			match(input, Token.UP, null); 

			globalNamedAction(sc, name, (ActionAST)ACTION6);
			}


				exitAction(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "action"


	public static class rules_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "rules"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:461:1: rules : ^( RULES ( rule | lexerRule )* ) ;
	public final GrammarTreeVisitor.rules_return rules() throws RecognitionException {
		GrammarTreeVisitor.rules_return retval = new GrammarTreeVisitor.rules_return();
		retval.start = input.LT(1);

		GrammarAST RULES7=null;


			enterRules(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:468:5: ( ^( RULES ( rule | lexerRule )* ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:468:7: ^( RULES ( rule | lexerRule )* )
			{
			RULES7=(GrammarAST)match(input,RULES,FOLLOW_RULES_in_rules562); 
			discoverRules(RULES7);
			if ( input.LA(1)==Token.DOWN ) {
				match(input, Token.DOWN, null); 
				// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:468:40: ( rule | lexerRule )*
				loop11:
				while (true) {
					int alt11=3;
					int LA11_0 = input.LA(1);
					if ( (LA11_0==RULE) ) {
						int LA11_2 = input.LA(2);
						if ( (LA11_2==DOWN) ) {
							int LA11_3 = input.LA(3);
							if ( (LA11_3==RULE_REF) ) {
								alt11=1;
							}
							else if ( (LA11_3==TOKEN_REF) ) {
								alt11=2;
							}

						}

					}

					switch (alt11) {
					case 1 :
						// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:468:41: rule
						{
						pushFollow(FOLLOW_rule_in_rules567);
						rule();
						state._fsp--;

						}
						break;
					case 2 :
						// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:468:46: lexerRule
						{
						pushFollow(FOLLOW_lexerRule_in_rules569);
						lexerRule();
						state._fsp--;

						}
						break;

					default :
						break loop11;
					}
				}

				finishRules(RULES7);
				match(input, Token.UP, null); 
			}

			}


				exitRules(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "rules"


	public static class mode_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "mode"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:471:1: mode : ^( MODE ID ( lexerRule )* ) ;
	public final GrammarTreeVisitor.mode_return mode() throws RecognitionException {
		GrammarTreeVisitor.mode_return retval = new GrammarTreeVisitor.mode_return();
		retval.start = input.LT(1);

		GrammarAST ID8=null;
		GrammarAST MODE9=null;


			enterMode(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:478:2: ( ^( MODE ID ( lexerRule )* ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:478:4: ^( MODE ID ( lexerRule )* )
			{
			MODE9=(GrammarAST)match(input,MODE,FOLLOW_MODE_in_mode600); 
			match(input, Token.DOWN, null); 
			ID8=(GrammarAST)match(input,ID,FOLLOW_ID_in_mode602); 
			currentModeName=(ID8!=null?ID8.getText():null); modeDef(MODE9, ID8);
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:478:64: ( lexerRule )*
			loop12:
			while (true) {
				int alt12=2;
				int LA12_0 = input.LA(1);
				if ( (LA12_0==RULE) ) {
					alt12=1;
				}

				switch (alt12) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:478:64: lexerRule
					{
					pushFollow(FOLLOW_lexerRule_in_mode606);
					lexerRule();
					state._fsp--;

					}
					break;

				default :
					break loop12;
				}
			}

			match(input, Token.UP, null); 

			}


				exitMode(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "mode"


	public static class lexerRule_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerRule"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:481:1: lexerRule : ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS m= FRAGMENT ) )? lexerRuleBlock ) ;
	public final GrammarTreeVisitor.lexerRule_return lexerRule() throws RecognitionException {
		GrammarTreeVisitor.lexerRule_return retval = new GrammarTreeVisitor.lexerRule_return();
		retval.start = input.LT(1);

		GrammarAST m=null;
		GrammarAST TOKEN_REF10=null;
		GrammarAST RULE11=null;
		TreeRuleReturnScope lexerRuleBlock12 =null;


			enterLexerRule(((GrammarAST)retval.start));
			List mods = new ArrayList();
			currentOuterAltNumber=0;

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:490:2: ( ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS m= FRAGMENT ) )? lexerRuleBlock ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:490:4: ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS m= FRAGMENT ) )? lexerRuleBlock )
			{
			RULE11=(GrammarAST)match(input,RULE,FOLLOW_RULE_in_lexerRule632); 
			match(input, Token.DOWN, null); 
			TOKEN_REF10=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule634); 
			currentRuleName=(TOKEN_REF10!=null?TOKEN_REF10.getText():null); currentRuleAST=RULE11;
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:492:4: ( DOC_COMMENT )?
			int alt13=2;
			int LA13_0 = input.LA(1);
			if ( (LA13_0==DOC_COMMENT) ) {
				alt13=1;
			}
			switch (alt13) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:492:4: DOC_COMMENT
					{
					match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_lexerRule644); 
					}
					break;

			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:492:17: ( ^( RULEMODIFIERS m= FRAGMENT ) )?
			int alt14=2;
			int LA14_0 = input.LA(1);
			if ( (LA14_0==RULEMODIFIERS) ) {
				alt14=1;
			}
			switch (alt14) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:492:18: ^( RULEMODIFIERS m= FRAGMENT )
					{
					match(input,RULEMODIFIERS,FOLLOW_RULEMODIFIERS_in_lexerRule649); 
					match(input, Token.DOWN, null); 
					m=(GrammarAST)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule653); 
					mods.add(m);
					match(input, Token.UP, null); 

					}
					break;

			}

			discoverLexerRule((RuleAST)RULE11, TOKEN_REF10, mods, (GrammarAST)input.LT(1));
			pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule678);
			lexerRuleBlock12=lexerRuleBlock();
			state._fsp--;


			      		finishLexerRule((RuleAST)RULE11, TOKEN_REF10, (lexerRuleBlock12!=null?((GrammarAST)lexerRuleBlock12.start):null));
			      		currentRuleName=null; currentRuleAST=null;
			      		
			match(input, Token.UP, null); 

			}


				exitLexerRule(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerRule"


	public static class rule_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "rule"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:502:1: rule : ({...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup ) |{...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup ) );
	public final GrammarTreeVisitor.rule_return rule() throws RecognitionException {
		GrammarTreeVisitor.rule_return retval = new GrammarTreeVisitor.rule_return();
		retval.start = input.LT(1);

		GrammarAST RULE_REF13=null;
		GrammarAST RULE14=null;
		GrammarAST ARG_ACTION15=null;
		TreeRuleReturnScope m =null;
		TreeRuleReturnScope ret =null;
		TreeRuleReturnScope thr =null;
		TreeRuleReturnScope loc =null;
		TreeRuleReturnScope opts =null;
		TreeRuleReturnScope a =null;
		TreeRuleReturnScope ruleBlock16 =null;


			enterRule(((GrammarAST)retval.start));
			List mods = new ArrayList();
			List actions = new ArrayList(); // track roots
			currentOuterAltNumber=0;

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:512:2: ({...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup ) |{...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup ) )
			int alt31=2;
			int LA31_0 = input.LA(1);
			if ( (LA31_0==RULE) ) {
				int LA31_1 = input.LA(2);
				if ( ((!((RuleAST)((GrammarAST)retval.start)).dead)) ) {
					alt31=1;
				}
				else if ( ((((RuleAST)((GrammarAST)retval.start)).dead)) ) {
					alt31=2;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 31, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 31, 0, input);
				throw nvae;
			}

			switch (alt31) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:512:6: {...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup )
					{
					if ( !((!((RuleAST)((GrammarAST)retval.start)).dead)) ) {
						throw new FailedPredicateException(input, "rule", "!((RuleAST)$start).dead");
					}
					RULE14=(GrammarAST)match(input,RULE,FOLLOW_RULE_in_rule733); 
					match(input, Token.DOWN, null); 
					RULE_REF13=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_rule735); 
					currentRuleName=(RULE_REF13!=null?RULE_REF13.getText():null); currentRuleAST=RULE14;
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:4: ( DOC_COMMENT )?
					int alt15=2;
					int LA15_0 = input.LA(1);
					if ( (LA15_0==DOC_COMMENT) ) {
						alt15=1;
					}
					switch (alt15) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:4: DOC_COMMENT
							{
							match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_rule742); 
							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:17: ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )?
					int alt17=2;
					int LA17_0 = input.LA(1);
					if ( (LA17_0==RULEMODIFIERS) ) {
						alt17=1;
					}
					switch (alt17) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:18: ^( RULEMODIFIERS (m= ruleModifier )+ )
							{
							match(input,RULEMODIFIERS,FOLLOW_RULEMODIFIERS_in_rule747); 
							match(input, Token.DOWN, null); 
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:34: (m= ruleModifier )+
							int cnt16=0;
							loop16:
							while (true) {
								int alt16=2;
								int LA16_0 = input.LA(1);
								if ( (LA16_0==FRAGMENT||(LA16_0 >= PRIVATE && LA16_0 <= PUBLIC)) ) {
									alt16=1;
								}

								switch (alt16) {
								case 1 :
									// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:514:35: m= ruleModifier
									{
									pushFollow(FOLLOW_ruleModifier_in_rule752);
									m=ruleModifier();
									state._fsp--;

									mods.add((m!=null?((GrammarAST)m.start):null));
									}
									break;

								default :
									if ( cnt16 >= 1 ) break loop16;
									EarlyExitException eee = new EarlyExitException(16, input);
									throw eee;
								}
								cnt16++;
							}

							match(input, Token.UP, null); 

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:515:4: ( ARG_ACTION )?
					int alt18=2;
					int LA18_0 = input.LA(1);
					if ( (LA18_0==ARG_ACTION) ) {
						alt18=1;
					}
					switch (alt18) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:515:4: ARG_ACTION
							{
							ARG_ACTION15=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule763); 
							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:516:12: (ret= ruleReturns )?
					int alt19=2;
					int LA19_0 = input.LA(1);
					if ( (LA19_0==RETURNS) ) {
						alt19=1;
					}
					switch (alt19) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:516:12: ret= ruleReturns
							{
							pushFollow(FOLLOW_ruleReturns_in_rule776);
							ret=ruleReturns();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:517:12: (thr= throwsSpec )?
					int alt20=2;
					int LA20_0 = input.LA(1);
					if ( (LA20_0==THROWS) ) {
						alt20=1;
					}
					switch (alt20) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:517:12: thr= throwsSpec
							{
							pushFollow(FOLLOW_throwsSpec_in_rule789);
							thr=throwsSpec();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:518:12: (loc= locals )?
					int alt21=2;
					int LA21_0 = input.LA(1);
					if ( (LA21_0==LOCALS) ) {
						alt21=1;
					}
					switch (alt21) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:518:12: loc= locals
							{
							pushFollow(FOLLOW_locals_in_rule802);
							loc=locals();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:519:9: (opts= optionsSpec |a= ruleAction )*
					loop22:
					while (true) {
						int alt22=3;
						int LA22_0 = input.LA(1);
						if ( (LA22_0==OPTIONS) ) {
							alt22=1;
						}
						else if ( (LA22_0==AT) ) {
							alt22=2;
						}

						switch (alt22) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:519:11: opts= optionsSpec
							{
							pushFollow(FOLLOW_optionsSpec_in_rule817);
							opts=optionsSpec();
							state._fsp--;

							}
							break;
						case 2 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:520:11: a= ruleAction
							{
							pushFollow(FOLLOW_ruleAction_in_rule831);
							a=ruleAction();
							state._fsp--;

							actions.add((a!=null?((GrammarAST)a.start):null));
							}
							break;

						default :
							break loop22;
						}
					}

					discoverRule((RuleAST)RULE14, RULE_REF13, mods, (ActionAST)ARG_ACTION15,
					      					  (ret!=null?((GrammarAST)ret.start):null)!=null?(ActionAST)(ret!=null?((GrammarAST)ret.start):null).getChild(0):null,
					      					  (thr!=null?((GrammarAST)thr.start):null), (opts!=null?((GrammarAST)opts.start):null),
					      					  (loc!=null?((GrammarAST)loc.start):null)!=null?(ActionAST)(loc!=null?((GrammarAST)loc.start):null).getChild(0):null,
					      					  actions, (GrammarAST)input.LT(1));
					pushFollow(FOLLOW_ruleBlock_in_rule862);
					ruleBlock16=ruleBlock();
					state._fsp--;

					pushFollow(FOLLOW_exceptionGroup_in_rule864);
					exceptionGroup();
					state._fsp--;

					finishRule((RuleAST)RULE14, RULE_REF13, (ruleBlock16!=null?((GrammarAST)ruleBlock16.start):null)); currentRuleName=null; currentRuleAST=null;
					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:532:6: {...}? ^( RULE RULE_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )? ( ARG_ACTION )? (ret= ruleReturns )? (thr= throwsSpec )? (loc= locals )? (opts= optionsSpec |a= ruleAction )* ruleBlock exceptionGroup )
					{
					if ( !((((RuleAST)((GrammarAST)retval.start)).dead)) ) {
						throw new FailedPredicateException(input, "rule", "((RuleAST)$start).dead");
					}
					match(input,RULE,FOLLOW_RULE_in_rule918); 
					match(input, Token.DOWN, null); 
					match(input,RULE_REF,FOLLOW_RULE_REF_in_rule920); 
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:4: ( DOC_COMMENT )?
					int alt23=2;
					int LA23_0 = input.LA(1);
					if ( (LA23_0==DOC_COMMENT) ) {
						alt23=1;
					}
					switch (alt23) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:4: DOC_COMMENT
							{
							match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_rule925); 
							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:17: ( ^( RULEMODIFIERS (m= ruleModifier )+ ) )?
					int alt25=2;
					int LA25_0 = input.LA(1);
					if ( (LA25_0==RULEMODIFIERS) ) {
						alt25=1;
					}
					switch (alt25) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:18: ^( RULEMODIFIERS (m= ruleModifier )+ )
							{
							match(input,RULEMODIFIERS,FOLLOW_RULEMODIFIERS_in_rule930); 
							match(input, Token.DOWN, null); 
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:34: (m= ruleModifier )+
							int cnt24=0;
							loop24:
							while (true) {
								int alt24=2;
								int LA24_0 = input.LA(1);
								if ( (LA24_0==FRAGMENT||(LA24_0 >= PRIVATE && LA24_0 <= PUBLIC)) ) {
									alt24=1;
								}

								switch (alt24) {
								case 1 :
									// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:534:35: m= ruleModifier
									{
									pushFollow(FOLLOW_ruleModifier_in_rule935);
									m=ruleModifier();
									state._fsp--;

									}
									break;

								default :
									if ( cnt24 >= 1 ) break loop24;
									EarlyExitException eee = new EarlyExitException(24, input);
									throw eee;
								}
								cnt24++;
							}

							match(input, Token.UP, null); 

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:535:4: ( ARG_ACTION )?
					int alt26=2;
					int LA26_0 = input.LA(1);
					if ( (LA26_0==ARG_ACTION) ) {
						alt26=1;
					}
					switch (alt26) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:535:4: ARG_ACTION
							{
							match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rule945); 
							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:536:12: (ret= ruleReturns )?
					int alt27=2;
					int LA27_0 = input.LA(1);
					if ( (LA27_0==RETURNS) ) {
						alt27=1;
					}
					switch (alt27) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:536:12: ret= ruleReturns
							{
							pushFollow(FOLLOW_ruleReturns_in_rule958);
							ret=ruleReturns();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:537:12: (thr= throwsSpec )?
					int alt28=2;
					int LA28_0 = input.LA(1);
					if ( (LA28_0==THROWS) ) {
						alt28=1;
					}
					switch (alt28) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:537:12: thr= throwsSpec
							{
							pushFollow(FOLLOW_throwsSpec_in_rule971);
							thr=throwsSpec();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:538:12: (loc= locals )?
					int alt29=2;
					int LA29_0 = input.LA(1);
					if ( (LA29_0==LOCALS) ) {
						alt29=1;
					}
					switch (alt29) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:538:12: loc= locals
							{
							pushFollow(FOLLOW_locals_in_rule984);
							loc=locals();
							state._fsp--;

							}
							break;

					}

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:539:9: (opts= optionsSpec |a= ruleAction )*
					loop30:
					while (true) {
						int alt30=3;
						int LA30_0 = input.LA(1);
						if ( (LA30_0==OPTIONS) ) {
							alt30=1;
						}
						else if ( (LA30_0==AT) ) {
							alt30=2;
						}

						switch (alt30) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:539:11: opts= optionsSpec
							{
							pushFollow(FOLLOW_optionsSpec_in_rule999);
							opts=optionsSpec();
							state._fsp--;

							}
							break;
						case 2 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:540:11: a= ruleAction
							{
							pushFollow(FOLLOW_ruleAction_in_rule1013);
							a=ruleAction();
							state._fsp--;

							}
							break;

						default :
							break loop30;
						}
					}

					pushFollow(FOLLOW_ruleBlock_in_rule1032);
					ruleBlock();
					state._fsp--;

					pushFollow(FOLLOW_exceptionGroup_in_rule1034);
					exceptionGroup();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;

			}

				exitRule(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "rule"


	public static class exceptionGroup_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "exceptionGroup"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:546:1: exceptionGroup : ( exceptionHandler )* ( finallyClause )? ;
	public final GrammarTreeVisitor.exceptionGroup_return exceptionGroup() throws RecognitionException {
		GrammarTreeVisitor.exceptionGroup_return retval = new GrammarTreeVisitor.exceptionGroup_return();
		retval.start = input.LT(1);


			enterExceptionGroup(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:5: ( ( exceptionHandler )* ( finallyClause )? )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:7: ( exceptionHandler )* ( finallyClause )?
			{
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:7: ( exceptionHandler )*
			loop32:
			while (true) {
				int alt32=2;
				int LA32_0 = input.LA(1);
				if ( (LA32_0==CATCH) ) {
					alt32=1;
				}

				switch (alt32) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:7: exceptionHandler
					{
					pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1072);
					exceptionHandler();
					state._fsp--;

					}
					break;

				default :
					break loop32;
				}
			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:25: ( finallyClause )?
			int alt33=2;
			int LA33_0 = input.LA(1);
			if ( (LA33_0==FINALLY) ) {
				alt33=1;
			}
			switch (alt33) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:553:25: finallyClause
					{
					pushFollow(FOLLOW_finallyClause_in_exceptionGroup1075);
					finallyClause();
					state._fsp--;

					}
					break;

			}

			}


				exitExceptionGroup(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "exceptionGroup"


	public static class exceptionHandler_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "exceptionHandler"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:556:1: exceptionHandler : ^( CATCH ARG_ACTION ACTION ) ;
	public final GrammarTreeVisitor.exceptionHandler_return exceptionHandler() throws RecognitionException {
		GrammarTreeVisitor.exceptionHandler_return retval = new GrammarTreeVisitor.exceptionHandler_return();
		retval.start = input.LT(1);

		GrammarAST ARG_ACTION17=null;
		GrammarAST ACTION18=null;


			enterExceptionHandler(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:563:2: ( ^( CATCH ARG_ACTION ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:563:4: ^( CATCH ARG_ACTION ACTION )
			{
			match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1101); 
			match(input, Token.DOWN, null); 
			ARG_ACTION17=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1103); 
			ACTION18=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1105); 
			match(input, Token.UP, null); 

			ruleCatch(ARG_ACTION17, (ActionAST)ACTION18);
			}


				exitExceptionHandler(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "exceptionHandler"


	public static class finallyClause_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "finallyClause"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:566:1: finallyClause : ^( FINALLY ACTION ) ;
	public final GrammarTreeVisitor.finallyClause_return finallyClause() throws RecognitionException {
		GrammarTreeVisitor.finallyClause_return retval = new GrammarTreeVisitor.finallyClause_return();
		retval.start = input.LT(1);

		GrammarAST ACTION19=null;


			enterFinallyClause(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:573:2: ( ^( FINALLY ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:573:4: ^( FINALLY ACTION )
			{
			match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1130); 
			match(input, Token.DOWN, null); 
			ACTION19=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1132); 
			match(input, Token.UP, null); 

			finallyAction((ActionAST)ACTION19);
			}


				exitFinallyClause(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "finallyClause"


	public static class locals_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "locals"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:576:1: locals : ^( LOCALS ARG_ACTION ) ;
	public final GrammarTreeVisitor.locals_return locals() throws RecognitionException {
		GrammarTreeVisitor.locals_return retval = new GrammarTreeVisitor.locals_return();
		retval.start = input.LT(1);


			enterLocals(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:583:2: ( ^( LOCALS ARG_ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:583:4: ^( LOCALS ARG_ACTION )
			{
			match(input,LOCALS,FOLLOW_LOCALS_in_locals1160); 
			match(input, Token.DOWN, null); 
			match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_locals1162); 
			match(input, Token.UP, null); 

			}


				exitLocals(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "locals"


	public static class ruleReturns_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ruleReturns"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:586:1: ruleReturns : ^( RETURNS ARG_ACTION ) ;
	public final GrammarTreeVisitor.ruleReturns_return ruleReturns() throws RecognitionException {
		GrammarTreeVisitor.ruleReturns_return retval = new GrammarTreeVisitor.ruleReturns_return();
		retval.start = input.LT(1);


			enterRuleReturns(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:593:2: ( ^( RETURNS ARG_ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:593:4: ^( RETURNS ARG_ACTION )
			{
			match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1185); 
			match(input, Token.DOWN, null); 
			match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1187); 
			match(input, Token.UP, null); 

			}


				exitRuleReturns(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleReturns"


	public static class throwsSpec_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "throwsSpec"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:596:1: throwsSpec : ^( THROWS ( ID )+ ) ;
	public final GrammarTreeVisitor.throwsSpec_return throwsSpec() throws RecognitionException {
		GrammarTreeVisitor.throwsSpec_return retval = new GrammarTreeVisitor.throwsSpec_return();
		retval.start = input.LT(1);


			enterThrowsSpec(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:603:5: ( ^( THROWS ( ID )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:603:7: ^( THROWS ( ID )+ )
			{
			match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1213); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:603:16: ( ID )+
			int cnt34=0;
			loop34:
			while (true) {
				int alt34=2;
				int LA34_0 = input.LA(1);
				if ( (LA34_0==ID) ) {
					alt34=1;
				}

				switch (alt34) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:603:16: ID
					{
					match(input,ID,FOLLOW_ID_in_throwsSpec1215); 
					}
					break;

				default :
					if ( cnt34 >= 1 ) break loop34;
					EarlyExitException eee = new EarlyExitException(34, input);
					throw eee;
				}
				cnt34++;
			}

			match(input, Token.UP, null); 

			}


				exitThrowsSpec(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "throwsSpec"


	public static class ruleAction_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ruleAction"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:606:1: ruleAction : ^( AT ID ACTION ) ;
	public final GrammarTreeVisitor.ruleAction_return ruleAction() throws RecognitionException {
		GrammarTreeVisitor.ruleAction_return retval = new GrammarTreeVisitor.ruleAction_return();
		retval.start = input.LT(1);


			enterRuleAction(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:613:2: ( ^( AT ID ACTION ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:613:4: ^( AT ID ACTION )
			{
			match(input,AT,FOLLOW_AT_in_ruleAction1242); 
			match(input, Token.DOWN, null); 
			match(input,ID,FOLLOW_ID_in_ruleAction1244); 
			match(input,ACTION,FOLLOW_ACTION_in_ruleAction1246); 
			match(input, Token.UP, null); 

			}


				exitRuleAction(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleAction"


	public static class ruleModifier_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ruleModifier"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:616:1: ruleModifier : ( PUBLIC | PRIVATE | PROTECTED | FRAGMENT );
	public final GrammarTreeVisitor.ruleModifier_return ruleModifier() throws RecognitionException {
		GrammarTreeVisitor.ruleModifier_return retval = new GrammarTreeVisitor.ruleModifier_return();
		retval.start = input.LT(1);


			enterRuleModifier(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:623:5: ( PUBLIC | PRIVATE | PROTECTED | FRAGMENT )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:
			{
			if ( input.LA(1)==FRAGMENT||(input.LA(1) >= PRIVATE && input.LA(1) <= PUBLIC) ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}


				exitRuleModifier(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleModifier"


	public static class lexerRuleBlock_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerRuleBlock"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:629:1: lexerRuleBlock : ^( BLOCK ( lexerOuterAlternative )+ ) ;
	public final GrammarTreeVisitor.lexerRuleBlock_return lexerRuleBlock() throws RecognitionException {
		GrammarTreeVisitor.lexerRuleBlock_return retval = new GrammarTreeVisitor.lexerRuleBlock_return();
		retval.start = input.LT(1);


			enterLexerRuleBlock(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:636:5: ( ^( BLOCK ( lexerOuterAlternative )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:636:7: ^( BLOCK ( lexerOuterAlternative )+ )
			{
			match(input,BLOCK,FOLLOW_BLOCK_in_lexerRuleBlock1324); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:637:7: ( lexerOuterAlternative )+
			int cnt35=0;
			loop35:
			while (true) {
				int alt35=2;
				int LA35_0 = input.LA(1);
				if ( (LA35_0==ALT||LA35_0==LEXER_ALT_ACTION) ) {
					alt35=1;
				}

				switch (alt35) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:637:9: lexerOuterAlternative
					{

					    			currentOuterAltRoot = (GrammarAST)input.LT(1);
									currentOuterAltNumber++;
									
					pushFollow(FOLLOW_lexerOuterAlternative_in_lexerRuleBlock1343);
					lexerOuterAlternative();
					state._fsp--;

					}
					break;

				default :
					if ( cnt35 >= 1 ) break loop35;
					EarlyExitException eee = new EarlyExitException(35, input);
					throw eee;
				}
				cnt35++;
			}

			match(input, Token.UP, null); 

			}


				exitLexerRuleBlock(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerRuleBlock"


	public static class ruleBlock_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ruleBlock"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:646:1: ruleBlock : ^( BLOCK ( outerAlternative )+ ) ;
	public final GrammarTreeVisitor.ruleBlock_return ruleBlock() throws RecognitionException {
		GrammarTreeVisitor.ruleBlock_return retval = new GrammarTreeVisitor.ruleBlock_return();
		retval.start = input.LT(1);


			enterRuleBlock(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:653:5: ( ^( BLOCK ( outerAlternative )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:653:7: ^( BLOCK ( outerAlternative )+ )
			{
			match(input,BLOCK,FOLLOW_BLOCK_in_ruleBlock1388); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:654:7: ( outerAlternative )+
			int cnt36=0;
			loop36:
			while (true) {
				int alt36=2;
				int LA36_0 = input.LA(1);
				if ( (LA36_0==ALT) ) {
					alt36=1;
				}

				switch (alt36) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:654:9: outerAlternative
					{

					    			currentOuterAltRoot = (GrammarAST)input.LT(1);
									currentOuterAltNumber++;
									
					pushFollow(FOLLOW_outerAlternative_in_ruleBlock1407);
					outerAlternative();
					state._fsp--;

					}
					break;

				default :
					if ( cnt36 >= 1 ) break loop36;
					EarlyExitException eee = new EarlyExitException(36, input);
					throw eee;
				}
				cnt36++;
			}

			match(input, Token.UP, null); 

			}


				exitRuleBlock(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleBlock"


	public static class lexerOuterAlternative_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerOuterAlternative"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:663:1: lexerOuterAlternative : lexerAlternative ;
	public final GrammarTreeVisitor.lexerOuterAlternative_return lexerOuterAlternative() throws RecognitionException {
		GrammarTreeVisitor.lexerOuterAlternative_return retval = new GrammarTreeVisitor.lexerOuterAlternative_return();
		retval.start = input.LT(1);


			enterLexerOuterAlternative((AltAST)((GrammarAST)retval.start));
			discoverOuterAlt((AltAST)((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:672:2: ( lexerAlternative )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:672:4: lexerAlternative
			{
			pushFollow(FOLLOW_lexerAlternative_in_lexerOuterAlternative1447);
			lexerAlternative();
			state._fsp--;

			}


				finishOuterAlt((AltAST)((GrammarAST)retval.start));
				exitLexerOuterAlternative((AltAST)((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerOuterAlternative"


	public static class outerAlternative_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "outerAlternative"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:676:1: outerAlternative : alternative ;
	public final GrammarTreeVisitor.outerAlternative_return outerAlternative() throws RecognitionException {
		GrammarTreeVisitor.outerAlternative_return retval = new GrammarTreeVisitor.outerAlternative_return();
		retval.start = input.LT(1);


			enterOuterAlternative((AltAST)((GrammarAST)retval.start));
			discoverOuterAlt((AltAST)((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:685:2: ( alternative )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:685:4: alternative
			{
			pushFollow(FOLLOW_alternative_in_outerAlternative1469);
			alternative();
			state._fsp--;

			}


				finishOuterAlt((AltAST)((GrammarAST)retval.start));
				exitOuterAlternative((AltAST)((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "outerAlternative"


	public static class lexerAlternative_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerAlternative"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:688:1: lexerAlternative : ( ^( LEXER_ALT_ACTION lexerElements ( lexerCommand )+ ) | lexerElements );
	public final GrammarTreeVisitor.lexerAlternative_return lexerAlternative() throws RecognitionException {
		GrammarTreeVisitor.lexerAlternative_return retval = new GrammarTreeVisitor.lexerAlternative_return();
		retval.start = input.LT(1);


			enterLexerAlternative(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:695:2: ( ^( LEXER_ALT_ACTION lexerElements ( lexerCommand )+ ) | lexerElements )
			int alt38=2;
			int LA38_0 = input.LA(1);
			if ( (LA38_0==LEXER_ALT_ACTION) ) {
				alt38=1;
			}
			else if ( (LA38_0==ALT) ) {
				alt38=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 38, 0, input);
				throw nvae;
			}

			switch (alt38) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:695:4: ^( LEXER_ALT_ACTION lexerElements ( lexerCommand )+ )
					{
					match(input,LEXER_ALT_ACTION,FOLLOW_LEXER_ALT_ACTION_in_lexerAlternative1491); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_lexerElements_in_lexerAlternative1493);
					lexerElements();
					state._fsp--;

					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:695:37: ( lexerCommand )+
					int cnt37=0;
					loop37:
					while (true) {
						int alt37=2;
						int LA37_0 = input.LA(1);
						if ( (LA37_0==ID||LA37_0==LEXER_ACTION_CALL) ) {
							alt37=1;
						}

						switch (alt37) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:695:37: lexerCommand
							{
							pushFollow(FOLLOW_lexerCommand_in_lexerAlternative1495);
							lexerCommand();
							state._fsp--;

							}
							break;

						default :
							if ( cnt37 >= 1 ) break loop37;
							EarlyExitException eee = new EarlyExitException(37, input);
							throw eee;
						}
						cnt37++;
					}

					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:696:9: lexerElements
					{
					pushFollow(FOLLOW_lexerElements_in_lexerAlternative1507);
					lexerElements();
					state._fsp--;

					}
					break;

			}

				exitLexerAlternative(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerAlternative"


	public static class lexerElements_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerElements"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:699:1: lexerElements : ^( ALT ( lexerElement )+ ) ;
	public final GrammarTreeVisitor.lexerElements_return lexerElements() throws RecognitionException {
		GrammarTreeVisitor.lexerElements_return retval = new GrammarTreeVisitor.lexerElements_return();
		retval.start = input.LT(1);


			enterLexerElements(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:706:5: ( ^( ALT ( lexerElement )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:706:7: ^( ALT ( lexerElement )+ )
			{
			match(input,ALT,FOLLOW_ALT_in_lexerElements1535); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:706:13: ( lexerElement )+
			int cnt39=0;
			loop39:
			while (true) {
				int alt39=2;
				int LA39_0 = input.LA(1);
				if ( (LA39_0==ACTION||LA39_0==ASSIGN||LA39_0==LEXER_CHAR_SET||LA39_0==NOT||LA39_0==PLUS_ASSIGN||LA39_0==RANGE||LA39_0==SEMPRED||LA39_0==STRING_LITERAL||LA39_0==TOKEN_REF||LA39_0==BLOCK||LA39_0==CLOSURE||LA39_0==EPSILON||(LA39_0 >= OPTIONAL && LA39_0 <= POSITIVE_CLOSURE)||LA39_0==SET||LA39_0==WILDCARD) ) {
					alt39=1;
				}

				switch (alt39) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:706:13: lexerElement
					{
					pushFollow(FOLLOW_lexerElement_in_lexerElements1537);
					lexerElement();
					state._fsp--;

					}
					break;

				default :
					if ( cnt39 >= 1 ) break loop39;
					EarlyExitException eee = new EarlyExitException(39, input);
					throw eee;
				}
				cnt39++;
			}

			match(input, Token.UP, null); 

			}


				exitLexerElements(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerElements"


	public static class lexerElement_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerElement"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:709:1: lexerElement : ( labeledLexerElement | lexerAtom | lexerSubrule | ACTION | SEMPRED | ^( ACTION elementOptions ) | ^( SEMPRED elementOptions ) | EPSILON );
	public final GrammarTreeVisitor.lexerElement_return lexerElement() throws RecognitionException {
		GrammarTreeVisitor.lexerElement_return retval = new GrammarTreeVisitor.lexerElement_return();
		retval.start = input.LT(1);

		GrammarAST ACTION20=null;
		GrammarAST SEMPRED21=null;
		GrammarAST ACTION22=null;
		GrammarAST SEMPRED23=null;


			enterLexerElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:716:2: ( labeledLexerElement | lexerAtom | lexerSubrule | ACTION | SEMPRED | ^( ACTION elementOptions ) | ^( SEMPRED elementOptions ) | EPSILON )
			int alt40=8;
			switch ( input.LA(1) ) {
			case ASSIGN:
			case PLUS_ASSIGN:
				{
				alt40=1;
				}
				break;
			case LEXER_CHAR_SET:
			case NOT:
			case RANGE:
			case STRING_LITERAL:
			case TOKEN_REF:
			case SET:
			case WILDCARD:
				{
				alt40=2;
				}
				break;
			case BLOCK:
			case CLOSURE:
			case OPTIONAL:
			case POSITIVE_CLOSURE:
				{
				alt40=3;
				}
				break;
			case ACTION:
				{
				int LA40_4 = input.LA(2);
				if ( (LA40_4==DOWN) ) {
					alt40=6;
				}
				else if ( ((LA40_4 >= UP && LA40_4 <= ACTION)||LA40_4==ASSIGN||LA40_4==LEXER_CHAR_SET||LA40_4==NOT||LA40_4==PLUS_ASSIGN||LA40_4==RANGE||LA40_4==SEMPRED||LA40_4==STRING_LITERAL||LA40_4==TOKEN_REF||LA40_4==BLOCK||LA40_4==CLOSURE||LA40_4==EPSILON||(LA40_4 >= OPTIONAL && LA40_4 <= POSITIVE_CLOSURE)||LA40_4==SET||LA40_4==WILDCARD) ) {
					alt40=4;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 40, 4, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case SEMPRED:
				{
				int LA40_5 = input.LA(2);
				if ( (LA40_5==DOWN) ) {
					alt40=7;
				}
				else if ( ((LA40_5 >= UP && LA40_5 <= ACTION)||LA40_5==ASSIGN||LA40_5==LEXER_CHAR_SET||LA40_5==NOT||LA40_5==PLUS_ASSIGN||LA40_5==RANGE||LA40_5==SEMPRED||LA40_5==STRING_LITERAL||LA40_5==TOKEN_REF||LA40_5==BLOCK||LA40_5==CLOSURE||LA40_5==EPSILON||(LA40_5 >= OPTIONAL && LA40_5 <= POSITIVE_CLOSURE)||LA40_5==SET||LA40_5==WILDCARD) ) {
					alt40=5;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 40, 5, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case EPSILON:
				{
				alt40=8;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 40, 0, input);
				throw nvae;
			}
			switch (alt40) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:716:4: labeledLexerElement
					{
					pushFollow(FOLLOW_labeledLexerElement_in_lexerElement1563);
					labeledLexerElement();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:717:4: lexerAtom
					{
					pushFollow(FOLLOW_lexerAtom_in_lexerElement1568);
					lexerAtom();
					state._fsp--;

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:718:4: lexerSubrule
					{
					pushFollow(FOLLOW_lexerSubrule_in_lexerElement1573);
					lexerSubrule();
					state._fsp--;

					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:719:6: ACTION
					{
					ACTION20=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_lexerElement1580); 
					actionInAlt((ActionAST)ACTION20);
					}
					break;
				case 5 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:720:6: SEMPRED
					{
					SEMPRED21=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_lexerElement1594); 
					sempredInAlt((PredAST)SEMPRED21);
					}
					break;
				case 6 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:721:6: ^( ACTION elementOptions )
					{
					ACTION22=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_lexerElement1609); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_lexerElement1611);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					actionInAlt((ActionAST)ACTION22);
					}
					break;
				case 7 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:722:6: ^( SEMPRED elementOptions )
					{
					SEMPRED23=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_lexerElement1622); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_lexerElement1624);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					sempredInAlt((PredAST)SEMPRED23);
					}
					break;
				case 8 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:723:4: EPSILON
					{
					match(input,EPSILON,FOLLOW_EPSILON_in_lexerElement1632); 
					}
					break;

			}

				exitLexerElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerElement"


	public static class labeledLexerElement_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "labeledLexerElement"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:726:1: labeledLexerElement : ^( ( ASSIGN | PLUS_ASSIGN ) ID ( lexerAtom | block ) ) ;
	public final GrammarTreeVisitor.labeledLexerElement_return labeledLexerElement() throws RecognitionException {
		GrammarTreeVisitor.labeledLexerElement_return retval = new GrammarTreeVisitor.labeledLexerElement_return();
		retval.start = input.LT(1);


			enterLabeledLexerElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:733:5: ( ^( ( ASSIGN | PLUS_ASSIGN ) ID ( lexerAtom | block ) ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:733:9: ^( ( ASSIGN | PLUS_ASSIGN ) ID ( lexerAtom | block ) )
			{
			if ( input.LA(1)==ASSIGN||input.LA(1)==PLUS_ASSIGN ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			match(input, Token.DOWN, null); 
			match(input,ID,FOLLOW_ID_in_labeledLexerElement1665); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:733:35: ( lexerAtom | block )
			int alt41=2;
			int LA41_0 = input.LA(1);
			if ( (LA41_0==LEXER_CHAR_SET||LA41_0==NOT||LA41_0==RANGE||LA41_0==STRING_LITERAL||LA41_0==TOKEN_REF||LA41_0==SET||LA41_0==WILDCARD) ) {
				alt41=1;
			}
			else if ( (LA41_0==BLOCK) ) {
				alt41=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 41, 0, input);
				throw nvae;
			}

			switch (alt41) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:733:36: lexerAtom
					{
					pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement1668);
					lexerAtom();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:733:46: block
					{
					pushFollow(FOLLOW_block_in_labeledLexerElement1670);
					block();
					state._fsp--;

					}
					break;

			}

			match(input, Token.UP, null); 

			}


				exitLabeledLexerElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "labeledLexerElement"


	public static class lexerBlock_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerBlock"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:736:1: lexerBlock : ^( BLOCK ( optionsSpec )? ( lexerAlternative )+ ) ;
	public final GrammarTreeVisitor.lexerBlock_return lexerBlock() throws RecognitionException {
		GrammarTreeVisitor.lexerBlock_return retval = new GrammarTreeVisitor.lexerBlock_return();
		retval.start = input.LT(1);


			enterLexerBlock(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:3: ( ^( BLOCK ( optionsSpec )? ( lexerAlternative )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:5: ^( BLOCK ( optionsSpec )? ( lexerAlternative )+ )
			{
			match(input,BLOCK,FOLLOW_BLOCK_in_lexerBlock1695); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:13: ( optionsSpec )?
			int alt42=2;
			int LA42_0 = input.LA(1);
			if ( (LA42_0==OPTIONS) ) {
				alt42=1;
			}
			switch (alt42) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:13: optionsSpec
					{
					pushFollow(FOLLOW_optionsSpec_in_lexerBlock1697);
					optionsSpec();
					state._fsp--;

					}
					break;

			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:26: ( lexerAlternative )+
			int cnt43=0;
			loop43:
			while (true) {
				int alt43=2;
				int LA43_0 = input.LA(1);
				if ( (LA43_0==ALT||LA43_0==LEXER_ALT_ACTION) ) {
					alt43=1;
				}

				switch (alt43) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:743:26: lexerAlternative
					{
					pushFollow(FOLLOW_lexerAlternative_in_lexerBlock1700);
					lexerAlternative();
					state._fsp--;

					}
					break;

				default :
					if ( cnt43 >= 1 ) break loop43;
					EarlyExitException eee = new EarlyExitException(43, input);
					throw eee;
				}
				cnt43++;
			}

			match(input, Token.UP, null); 

			}


				exitLexerBlock(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerBlock"


	public static class lexerAtom_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerAtom"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:746:1: lexerAtom : ( terminal | ^( NOT blockSet ) | blockSet | ^( WILDCARD elementOptions ) | WILDCARD | LEXER_CHAR_SET | range );
	public final GrammarTreeVisitor.lexerAtom_return lexerAtom() throws RecognitionException {
		GrammarTreeVisitor.lexerAtom_return retval = new GrammarTreeVisitor.lexerAtom_return();
		retval.start = input.LT(1);


			enterLexerAtom(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:753:5: ( terminal | ^( NOT blockSet ) | blockSet | ^( WILDCARD elementOptions ) | WILDCARD | LEXER_CHAR_SET | range )
			int alt44=7;
			switch ( input.LA(1) ) {
			case STRING_LITERAL:
			case TOKEN_REF:
				{
				alt44=1;
				}
				break;
			case NOT:
				{
				alt44=2;
				}
				break;
			case SET:
				{
				alt44=3;
				}
				break;
			case WILDCARD:
				{
				int LA44_4 = input.LA(2);
				if ( (LA44_4==DOWN) ) {
					alt44=4;
				}
				else if ( ((LA44_4 >= UP && LA44_4 <= ACTION)||LA44_4==ASSIGN||LA44_4==LEXER_CHAR_SET||LA44_4==NOT||LA44_4==PLUS_ASSIGN||LA44_4==RANGE||LA44_4==SEMPRED||LA44_4==STRING_LITERAL||LA44_4==TOKEN_REF||LA44_4==BLOCK||LA44_4==CLOSURE||LA44_4==EPSILON||(LA44_4 >= OPTIONAL && LA44_4 <= POSITIVE_CLOSURE)||LA44_4==SET||LA44_4==WILDCARD) ) {
					alt44=5;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 44, 4, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case LEXER_CHAR_SET:
				{
				alt44=6;
				}
				break;
			case RANGE:
				{
				alt44=7;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 44, 0, input);
				throw nvae;
			}
			switch (alt44) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:753:9: terminal
					{
					pushFollow(FOLLOW_terminal_in_lexerAtom1731);
					terminal();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:754:9: ^( NOT blockSet )
					{
					match(input,NOT,FOLLOW_NOT_in_lexerAtom1742); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_blockSet_in_lexerAtom1744);
					blockSet();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:755:9: blockSet
					{
					pushFollow(FOLLOW_blockSet_in_lexerAtom1755);
					blockSet();
					state._fsp--;

					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:756:9: ^( WILDCARD elementOptions )
					{
					match(input,WILDCARD,FOLLOW_WILDCARD_in_lexerAtom1766); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_lexerAtom1768);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 5 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:757:9: WILDCARD
					{
					match(input,WILDCARD,FOLLOW_WILDCARD_in_lexerAtom1779); 
					}
					break;
				case 6 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:758:7: LEXER_CHAR_SET
					{
					match(input,LEXER_CHAR_SET,FOLLOW_LEXER_CHAR_SET_in_lexerAtom1787); 
					}
					break;
				case 7 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:759:9: range
					{
					pushFollow(FOLLOW_range_in_lexerAtom1797);
					range();
					state._fsp--;

					}
					break;

			}

				exitLexerAtom(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerAtom"


	public static class actionElement_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "actionElement"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:762:1: actionElement : ( ACTION | ^( ACTION elementOptions ) | SEMPRED | ^( SEMPRED elementOptions ) );
	public final GrammarTreeVisitor.actionElement_return actionElement() throws RecognitionException {
		GrammarTreeVisitor.actionElement_return retval = new GrammarTreeVisitor.actionElement_return();
		retval.start = input.LT(1);


			enterActionElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:769:2: ( ACTION | ^( ACTION elementOptions ) | SEMPRED | ^( SEMPRED elementOptions ) )
			int alt45=4;
			int LA45_0 = input.LA(1);
			if ( (LA45_0==ACTION) ) {
				int LA45_1 = input.LA(2);
				if ( (LA45_1==DOWN) ) {
					alt45=2;
				}
				else if ( (LA45_1==EOF) ) {
					alt45=1;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 45, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}
			else if ( (LA45_0==SEMPRED) ) {
				int LA45_2 = input.LA(2);
				if ( (LA45_2==DOWN) ) {
					alt45=4;
				}
				else if ( (LA45_2==EOF) ) {
					alt45=3;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 45, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 45, 0, input);
				throw nvae;
			}

			switch (alt45) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:769:4: ACTION
					{
					match(input,ACTION,FOLLOW_ACTION_in_actionElement1821); 
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:770:6: ^( ACTION elementOptions )
					{
					match(input,ACTION,FOLLOW_ACTION_in_actionElement1829); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_actionElement1831);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:771:6: SEMPRED
					{
					match(input,SEMPRED,FOLLOW_SEMPRED_in_actionElement1839); 
					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:772:6: ^( SEMPRED elementOptions )
					{
					match(input,SEMPRED,FOLLOW_SEMPRED_in_actionElement1847); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_actionElement1849);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;

			}

				exitActionElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "actionElement"


	public static class alternative_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "alternative"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:775:1: alternative : ( ^( ALT ( element )+ ) | ^( ALT EPSILON ) );
	public final GrammarTreeVisitor.alternative_return alternative() throws RecognitionException {
		GrammarTreeVisitor.alternative_return retval = new GrammarTreeVisitor.alternative_return();
		retval.start = input.LT(1);


			enterAlternative((AltAST)((GrammarAST)retval.start));
			discoverAlt((AltAST)((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:784:2: ( ^( ALT ( element )+ ) | ^( ALT EPSILON ) )
			int alt47=2;
			int LA47_0 = input.LA(1);
			if ( (LA47_0==ALT) ) {
				int LA47_1 = input.LA(2);
				if ( (LA47_1==DOWN) ) {
					int LA47_2 = input.LA(3);
					if ( (LA47_2==EPSILON) ) {
						alt47=2;
					}
					else if ( (LA47_2==ACTION||LA47_2==ASSIGN||LA47_2==DOT||LA47_2==NOT||LA47_2==PLUS_ASSIGN||LA47_2==RULE_REF||LA47_2==SEMPRED||LA47_2==STRING_LITERAL||LA47_2==TOKEN_REF||LA47_2==BLOCK||LA47_2==CLOSURE||(LA47_2 >= OPTIONAL && LA47_2 <= POSITIVE_CLOSURE)||LA47_2==SET||LA47_2==WILDCARD) ) {
						alt47=1;
					}

					else {
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 47, 2, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 47, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 47, 0, input);
				throw nvae;
			}

			switch (alt47) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:784:4: ^( ALT ( element )+ )
					{
					match(input,ALT,FOLLOW_ALT_in_alternative1872); 
					match(input, Token.DOWN, null); 
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:784:10: ( element )+
					int cnt46=0;
					loop46:
					while (true) {
						int alt46=2;
						int LA46_0 = input.LA(1);
						if ( (LA46_0==ACTION||LA46_0==ASSIGN||LA46_0==DOT||LA46_0==NOT||LA46_0==PLUS_ASSIGN||LA46_0==RULE_REF||LA46_0==SEMPRED||LA46_0==STRING_LITERAL||LA46_0==TOKEN_REF||LA46_0==BLOCK||LA46_0==CLOSURE||(LA46_0 >= OPTIONAL && LA46_0 <= POSITIVE_CLOSURE)||LA46_0==SET||LA46_0==WILDCARD) ) {
							alt46=1;
						}

						switch (alt46) {
						case 1 :
							// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:784:10: element
							{
							pushFollow(FOLLOW_element_in_alternative1874);
							element();
							state._fsp--;

							}
							break;

						default :
							if ( cnt46 >= 1 ) break loop46;
							EarlyExitException eee = new EarlyExitException(46, input);
							throw eee;
						}
						cnt46++;
					}

					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:785:4: ^( ALT EPSILON )
					{
					match(input,ALT,FOLLOW_ALT_in_alternative1882); 
					match(input, Token.DOWN, null); 
					match(input,EPSILON,FOLLOW_EPSILON_in_alternative1884); 
					match(input, Token.UP, null); 

					}
					break;

			}

				finishAlt((AltAST)((GrammarAST)retval.start));
				exitAlternative((AltAST)((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "alternative"


	public static class lexerCommand_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerCommand"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:788:1: lexerCommand : ( ^( LEXER_ACTION_CALL ID lexerCommandExpr ) | ID );
	public final GrammarTreeVisitor.lexerCommand_return lexerCommand() throws RecognitionException {
		GrammarTreeVisitor.lexerCommand_return retval = new GrammarTreeVisitor.lexerCommand_return();
		retval.start = input.LT(1);

		GrammarAST ID24=null;
		GrammarAST ID26=null;
		TreeRuleReturnScope lexerCommandExpr25 =null;


			enterLexerCommand(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:795:2: ( ^( LEXER_ACTION_CALL ID lexerCommandExpr ) | ID )
			int alt48=2;
			int LA48_0 = input.LA(1);
			if ( (LA48_0==LEXER_ACTION_CALL) ) {
				alt48=1;
			}
			else if ( (LA48_0==ID) ) {
				alt48=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 48, 0, input);
				throw nvae;
			}

			switch (alt48) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:795:4: ^( LEXER_ACTION_CALL ID lexerCommandExpr )
					{
					match(input,LEXER_ACTION_CALL,FOLLOW_LEXER_ACTION_CALL_in_lexerCommand1910); 
					match(input, Token.DOWN, null); 
					ID24=(GrammarAST)match(input,ID,FOLLOW_ID_in_lexerCommand1912); 
					pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand1914);
					lexerCommandExpr25=lexerCommandExpr();
					state._fsp--;

					match(input, Token.UP, null); 

					lexerCallCommand(currentOuterAltNumber, ID24, (lexerCommandExpr25!=null?((GrammarAST)lexerCommandExpr25.start):null));
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:797:4: ID
					{
					ID26=(GrammarAST)match(input,ID,FOLLOW_ID_in_lexerCommand1930); 
					lexerCommand(currentOuterAltNumber, ID26);
					}
					break;

			}

				exitLexerCommand(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerCommand"


	public static class lexerCommandExpr_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerCommandExpr"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:801:1: lexerCommandExpr : ( ID | INT );
	public final GrammarTreeVisitor.lexerCommandExpr_return lexerCommandExpr() throws RecognitionException {
		GrammarTreeVisitor.lexerCommandExpr_return retval = new GrammarTreeVisitor.lexerCommandExpr_return();
		retval.start = input.LT(1);


			enterLexerCommandExpr(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:808:2: ( ID | INT )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:
			{
			if ( input.LA(1)==ID||input.LA(1)==INT ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}


				exitLexerCommandExpr(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerCommandExpr"


	public static class element_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "element"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:812:1: element : ( labeledElement | atom | subrule | ACTION | SEMPRED | ^( ACTION elementOptions ) | ^( SEMPRED elementOptions ) | ^( NOT blockSet ) | ^( NOT block ) );
	public final GrammarTreeVisitor.element_return element() throws RecognitionException {
		GrammarTreeVisitor.element_return retval = new GrammarTreeVisitor.element_return();
		retval.start = input.LT(1);

		GrammarAST ACTION27=null;
		GrammarAST SEMPRED28=null;
		GrammarAST ACTION29=null;
		GrammarAST SEMPRED30=null;


			enterElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:819:2: ( labeledElement | atom | subrule | ACTION | SEMPRED | ^( ACTION elementOptions ) | ^( SEMPRED elementOptions ) | ^( NOT blockSet ) | ^( NOT block ) )
			int alt49=9;
			switch ( input.LA(1) ) {
			case ASSIGN:
			case PLUS_ASSIGN:
				{
				alt49=1;
				}
				break;
			case DOT:
			case RULE_REF:
			case STRING_LITERAL:
			case TOKEN_REF:
			case SET:
			case WILDCARD:
				{
				alt49=2;
				}
				break;
			case BLOCK:
			case CLOSURE:
			case OPTIONAL:
			case POSITIVE_CLOSURE:
				{
				alt49=3;
				}
				break;
			case ACTION:
				{
				int LA49_4 = input.LA(2);
				if ( (LA49_4==DOWN) ) {
					alt49=6;
				}
				else if ( ((LA49_4 >= UP && LA49_4 <= ACTION)||LA49_4==ASSIGN||LA49_4==DOT||LA49_4==NOT||LA49_4==PLUS_ASSIGN||LA49_4==RULE_REF||LA49_4==SEMPRED||LA49_4==STRING_LITERAL||LA49_4==TOKEN_REF||LA49_4==BLOCK||LA49_4==CLOSURE||(LA49_4 >= OPTIONAL && LA49_4 <= POSITIVE_CLOSURE)||LA49_4==SET||LA49_4==WILDCARD) ) {
					alt49=4;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 49, 4, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case SEMPRED:
				{
				int LA49_5 = input.LA(2);
				if ( (LA49_5==DOWN) ) {
					alt49=7;
				}
				else if ( ((LA49_5 >= UP && LA49_5 <= ACTION)||LA49_5==ASSIGN||LA49_5==DOT||LA49_5==NOT||LA49_5==PLUS_ASSIGN||LA49_5==RULE_REF||LA49_5==SEMPRED||LA49_5==STRING_LITERAL||LA49_5==TOKEN_REF||LA49_5==BLOCK||LA49_5==CLOSURE||(LA49_5 >= OPTIONAL && LA49_5 <= POSITIVE_CLOSURE)||LA49_5==SET||LA49_5==WILDCARD) ) {
					alt49=5;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 49, 5, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case NOT:
				{
				int LA49_6 = input.LA(2);
				if ( (LA49_6==DOWN) ) {
					int LA49_11 = input.LA(3);
					if ( (LA49_11==SET) ) {
						alt49=8;
					}
					else if ( (LA49_11==BLOCK) ) {
						alt49=9;
					}

					else {
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 49, 11, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 49, 6, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 49, 0, input);
				throw nvae;
			}
			switch (alt49) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:819:4: labeledElement
					{
					pushFollow(FOLLOW_labeledElement_in_element1987);
					labeledElement();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:820:4: atom
					{
					pushFollow(FOLLOW_atom_in_element1992);
					atom();
					state._fsp--;

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:821:4: subrule
					{
					pushFollow(FOLLOW_subrule_in_element1997);
					subrule();
					state._fsp--;

					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:822:6: ACTION
					{
					ACTION27=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_element2004); 
					actionInAlt((ActionAST)ACTION27);
					}
					break;
				case 5 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:823:6: SEMPRED
					{
					SEMPRED28=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_element2018); 
					sempredInAlt((PredAST)SEMPRED28);
					}
					break;
				case 6 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:824:6: ^( ACTION elementOptions )
					{
					ACTION29=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_element2033); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_element2035);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					actionInAlt((ActionAST)ACTION29);
					}
					break;
				case 7 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:825:6: ^( SEMPRED elementOptions )
					{
					SEMPRED30=(GrammarAST)match(input,SEMPRED,FOLLOW_SEMPRED_in_element2046); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_element2048);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					sempredInAlt((PredAST)SEMPRED30);
					}
					break;
				case 8 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:827:4: ^( NOT blockSet )
					{
					match(input,NOT,FOLLOW_NOT_in_element2058); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_blockSet_in_element2060);
					blockSet();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 9 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:828:4: ^( NOT block )
					{
					match(input,NOT,FOLLOW_NOT_in_element2067); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_block_in_element2069);
					block();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;

			}

				exitElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "element"


	public static class astOperand_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "astOperand"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:831:1: astOperand : ( atom | ^( NOT blockSet ) | ^( NOT block ) );
	public final GrammarTreeVisitor.astOperand_return astOperand() throws RecognitionException {
		GrammarTreeVisitor.astOperand_return retval = new GrammarTreeVisitor.astOperand_return();
		retval.start = input.LT(1);


			enterAstOperand(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:838:2: ( atom | ^( NOT blockSet ) | ^( NOT block ) )
			int alt50=3;
			int LA50_0 = input.LA(1);
			if ( (LA50_0==DOT||LA50_0==RULE_REF||LA50_0==STRING_LITERAL||LA50_0==TOKEN_REF||LA50_0==SET||LA50_0==WILDCARD) ) {
				alt50=1;
			}
			else if ( (LA50_0==NOT) ) {
				int LA50_2 = input.LA(2);
				if ( (LA50_2==DOWN) ) {
					int LA50_3 = input.LA(3);
					if ( (LA50_3==SET) ) {
						alt50=2;
					}
					else if ( (LA50_3==BLOCK) ) {
						alt50=3;
					}

					else {
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 50, 3, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 50, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 50, 0, input);
				throw nvae;
			}

			switch (alt50) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:838:4: atom
					{
					pushFollow(FOLLOW_atom_in_astOperand2091);
					atom();
					state._fsp--;

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:839:4: ^( NOT blockSet )
					{
					match(input,NOT,FOLLOW_NOT_in_astOperand2097); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_blockSet_in_astOperand2099);
					blockSet();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:840:4: ^( NOT block )
					{
					match(input,NOT,FOLLOW_NOT_in_astOperand2106); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_block_in_astOperand2108);
					block();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;

			}

				exitAstOperand(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "astOperand"


	public static class labeledElement_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "labeledElement"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:843:1: labeledElement : ^( ( ASSIGN | PLUS_ASSIGN ) ID element ) ;
	public final GrammarTreeVisitor.labeledElement_return labeledElement() throws RecognitionException {
		GrammarTreeVisitor.labeledElement_return retval = new GrammarTreeVisitor.labeledElement_return();
		retval.start = input.LT(1);

		GrammarAST ID31=null;
		TreeRuleReturnScope element32 =null;


			enterLabeledElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:850:2: ( ^( ( ASSIGN | PLUS_ASSIGN ) ID element ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:850:4: ^( ( ASSIGN | PLUS_ASSIGN ) ID element )
			{
			if ( input.LA(1)==ASSIGN||input.LA(1)==PLUS_ASSIGN ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			match(input, Token.DOWN, null); 
			ID31=(GrammarAST)match(input,ID,FOLLOW_ID_in_labeledElement2137); 
			pushFollow(FOLLOW_element_in_labeledElement2139);
			element32=element();
			state._fsp--;

			match(input, Token.UP, null); 

			label(((GrammarAST)retval.start), ID31, (element32!=null?((GrammarAST)element32.start):null));
			}


				exitLabeledElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "labeledElement"


	public static class subrule_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "subrule"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:853:1: subrule : ( ^( blockSuffix block ) | block );
	public final GrammarTreeVisitor.subrule_return subrule() throws RecognitionException {
		GrammarTreeVisitor.subrule_return retval = new GrammarTreeVisitor.subrule_return();
		retval.start = input.LT(1);


			enterSubrule(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:860:2: ( ^( blockSuffix block ) | block )
			int alt51=2;
			int LA51_0 = input.LA(1);
			if ( (LA51_0==CLOSURE||(LA51_0 >= OPTIONAL && LA51_0 <= POSITIVE_CLOSURE)) ) {
				alt51=1;
			}
			else if ( (LA51_0==BLOCK) ) {
				alt51=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 51, 0, input);
				throw nvae;
			}

			switch (alt51) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:860:4: ^( blockSuffix block )
					{
					pushFollow(FOLLOW_blockSuffix_in_subrule2164);
					blockSuffix();
					state._fsp--;

					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_block_in_subrule2166);
					block();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:861:5: block
					{
					pushFollow(FOLLOW_block_in_subrule2173);
					block();
					state._fsp--;

					}
					break;

			}

				exitSubrule(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "subrule"


	public static class lexerSubrule_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "lexerSubrule"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:864:1: lexerSubrule : ( ^( blockSuffix lexerBlock ) | lexerBlock );
	public final GrammarTreeVisitor.lexerSubrule_return lexerSubrule() throws RecognitionException {
		GrammarTreeVisitor.lexerSubrule_return retval = new GrammarTreeVisitor.lexerSubrule_return();
		retval.start = input.LT(1);


			enterLexerSubrule(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:871:2: ( ^( blockSuffix lexerBlock ) | lexerBlock )
			int alt52=2;
			int LA52_0 = input.LA(1);
			if ( (LA52_0==CLOSURE||(LA52_0 >= OPTIONAL && LA52_0 <= POSITIVE_CLOSURE)) ) {
				alt52=1;
			}
			else if ( (LA52_0==BLOCK) ) {
				alt52=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 52, 0, input);
				throw nvae;
			}

			switch (alt52) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:871:4: ^( blockSuffix lexerBlock )
					{
					pushFollow(FOLLOW_blockSuffix_in_lexerSubrule2198);
					blockSuffix();
					state._fsp--;

					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_lexerBlock_in_lexerSubrule2200);
					lexerBlock();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:872:5: lexerBlock
					{
					pushFollow(FOLLOW_lexerBlock_in_lexerSubrule2207);
					lexerBlock();
					state._fsp--;

					}
					break;

			}

				exitLexerSubrule(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lexerSubrule"


	public static class blockSuffix_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "blockSuffix"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:875:1: blockSuffix : ebnfSuffix ;
	public final GrammarTreeVisitor.blockSuffix_return blockSuffix() throws RecognitionException {
		GrammarTreeVisitor.blockSuffix_return retval = new GrammarTreeVisitor.blockSuffix_return();
		retval.start = input.LT(1);


			enterBlockSuffix(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:882:5: ( ebnfSuffix )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:882:7: ebnfSuffix
			{
			pushFollow(FOLLOW_ebnfSuffix_in_blockSuffix2234);
			ebnfSuffix();
			state._fsp--;

			}


				exitBlockSuffix(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "blockSuffix"


	public static class ebnfSuffix_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ebnfSuffix"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:885:1: ebnfSuffix : ( OPTIONAL | CLOSURE | POSITIVE_CLOSURE );
	public final GrammarTreeVisitor.ebnfSuffix_return ebnfSuffix() throws RecognitionException {
		GrammarTreeVisitor.ebnfSuffix_return retval = new GrammarTreeVisitor.ebnfSuffix_return();
		retval.start = input.LT(1);


			enterEbnfSuffix(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:892:2: ( OPTIONAL | CLOSURE | POSITIVE_CLOSURE )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:
			{
			if ( input.LA(1)==CLOSURE||(input.LA(1) >= OPTIONAL && input.LA(1) <= POSITIVE_CLOSURE) ) {
				input.consume();
				state.errorRecovery=false;
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}


				exitEbnfSuffix(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ebnfSuffix"


	public static class atom_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "atom"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:897:1: atom : ( ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD elementOptions ) | WILDCARD | terminal | blockSet | ruleref );
	public final GrammarTreeVisitor.atom_return atom() throws RecognitionException {
		GrammarTreeVisitor.atom_return retval = new GrammarTreeVisitor.atom_return();
		retval.start = input.LT(1);

		GrammarAST WILDCARD33=null;
		GrammarAST WILDCARD34=null;


			enterAtom(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:904:2: ( ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD elementOptions ) | WILDCARD | terminal | blockSet | ruleref )
			int alt53=7;
			switch ( input.LA(1) ) {
			case DOT:
				{
				int LA53_1 = input.LA(2);
				if ( (LA53_1==DOWN) ) {
					int LA53_6 = input.LA(3);
					if ( (LA53_6==ID) ) {
						int LA53_9 = input.LA(4);
						if ( (LA53_9==STRING_LITERAL||LA53_9==TOKEN_REF) ) {
							alt53=1;
						}
						else if ( (LA53_9==RULE_REF) ) {
							alt53=2;
						}

						else {
							int nvaeMark = input.mark();
							try {
								for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
									input.consume();
								}
								NoViableAltException nvae =
									new NoViableAltException("", 53, 9, input);
								throw nvae;
							} finally {
								input.rewind(nvaeMark);
							}
						}

					}

					else {
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 53, 6, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 53, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case WILDCARD:
				{
				int LA53_2 = input.LA(2);
				if ( (LA53_2==DOWN) ) {
					alt53=3;
				}
				else if ( (LA53_2==EOF||(LA53_2 >= UP && LA53_2 <= ACTION)||LA53_2==ASSIGN||LA53_2==DOT||LA53_2==NOT||LA53_2==PLUS_ASSIGN||LA53_2==RULE_REF||LA53_2==SEMPRED||LA53_2==STRING_LITERAL||LA53_2==TOKEN_REF||LA53_2==BLOCK||LA53_2==CLOSURE||(LA53_2 >= OPTIONAL && LA53_2 <= POSITIVE_CLOSURE)||LA53_2==SET||LA53_2==WILDCARD) ) {
					alt53=4;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 53, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

				}
				break;
			case STRING_LITERAL:
			case TOKEN_REF:
				{
				alt53=5;
				}
				break;
			case SET:
				{
				alt53=6;
				}
				break;
			case RULE_REF:
				{
				alt53=7;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 53, 0, input);
				throw nvae;
			}
			switch (alt53) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:904:4: ^( DOT ID terminal )
					{
					match(input,DOT,FOLLOW_DOT_in_atom2295); 
					match(input, Token.DOWN, null); 
					match(input,ID,FOLLOW_ID_in_atom2297); 
					pushFollow(FOLLOW_terminal_in_atom2299);
					terminal();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:905:4: ^( DOT ID ruleref )
					{
					match(input,DOT,FOLLOW_DOT_in_atom2306); 
					match(input, Token.DOWN, null); 
					match(input,ID,FOLLOW_ID_in_atom2308); 
					pushFollow(FOLLOW_ruleref_in_atom2310);
					ruleref();
					state._fsp--;

					match(input, Token.UP, null); 

					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:906:7: ^( WILDCARD elementOptions )
					{
					WILDCARD33=(GrammarAST)match(input,WILDCARD,FOLLOW_WILDCARD_in_atom2320); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_atom2322);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					wildcardRef(WILDCARD33);
					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:907:7: WILDCARD
					{
					WILDCARD34=(GrammarAST)match(input,WILDCARD,FOLLOW_WILDCARD_in_atom2333); 
					wildcardRef(WILDCARD34);
					}
					break;
				case 5 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:908:9: terminal
					{
					pushFollow(FOLLOW_terminal_in_atom2349);
					terminal();
					state._fsp--;

					}
					break;
				case 6 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:909:7: blockSet
					{
					pushFollow(FOLLOW_blockSet_in_atom2357);
					blockSet();
					state._fsp--;

					}
					break;
				case 7 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:910:9: ruleref
					{
					pushFollow(FOLLOW_ruleref_in_atom2367);
					ruleref();
					state._fsp--;

					}
					break;

			}

				exitAtom(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "atom"


	public static class blockSet_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "blockSet"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:913:1: blockSet : ^( SET ( setElement )+ ) ;
	public final GrammarTreeVisitor.blockSet_return blockSet() throws RecognitionException {
		GrammarTreeVisitor.blockSet_return retval = new GrammarTreeVisitor.blockSet_return();
		retval.start = input.LT(1);


			enterBlockSet(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:920:2: ( ^( SET ( setElement )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:920:4: ^( SET ( setElement )+ )
			{
			match(input,SET,FOLLOW_SET_in_blockSet2392); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:920:10: ( setElement )+
			int cnt54=0;
			loop54:
			while (true) {
				int alt54=2;
				int LA54_0 = input.LA(1);
				if ( (LA54_0==LEXER_CHAR_SET||LA54_0==RANGE||LA54_0==STRING_LITERAL||LA54_0==TOKEN_REF) ) {
					alt54=1;
				}

				switch (alt54) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:920:10: setElement
					{
					pushFollow(FOLLOW_setElement_in_blockSet2394);
					setElement();
					state._fsp--;

					}
					break;

				default :
					if ( cnt54 >= 1 ) break loop54;
					EarlyExitException eee = new EarlyExitException(54, input);
					throw eee;
				}
				cnt54++;
			}

			match(input, Token.UP, null); 

			}


				exitBlockSet(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "blockSet"


	public static class setElement_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "setElement"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:923:1: setElement : ( STRING_LITERAL | TOKEN_REF | ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) | LEXER_CHAR_SET );
	public final GrammarTreeVisitor.setElement_return setElement() throws RecognitionException {
		GrammarTreeVisitor.setElement_return retval = new GrammarTreeVisitor.setElement_return();
		retval.start = input.LT(1);

		GrammarAST a=null;
		GrammarAST b=null;
		GrammarAST STRING_LITERAL35=null;
		GrammarAST TOKEN_REF36=null;


			enterSetElement(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:930:2: ( STRING_LITERAL | TOKEN_REF | ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) | LEXER_CHAR_SET )
			int alt55=4;
			switch ( input.LA(1) ) {
			case STRING_LITERAL:
				{
				alt55=1;
				}
				break;
			case TOKEN_REF:
				{
				alt55=2;
				}
				break;
			case RANGE:
				{
				alt55=3;
				}
				break;
			case LEXER_CHAR_SET:
				{
				alt55=4;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 55, 0, input);
				throw nvae;
			}
			switch (alt55) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:930:4: STRING_LITERAL
					{
					STRING_LITERAL35=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement2417); 
					stringRef((TerminalAST)STRING_LITERAL35);
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:931:4: TOKEN_REF
					{
					TOKEN_REF36=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_setElement2424); 
					tokenRef((TerminalAST)TOKEN_REF36);
					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:932:4: ^( RANGE a= STRING_LITERAL b= STRING_LITERAL )
					{
					match(input,RANGE,FOLLOW_RANGE_in_setElement2433); 
					match(input, Token.DOWN, null); 
					a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement2437); 
					b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement2441); 
					match(input, Token.UP, null); 


							stringRef((TerminalAST)a);
							stringRef((TerminalAST)b);
							
					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:937:17: LEXER_CHAR_SET
					{
					match(input,LEXER_CHAR_SET,FOLLOW_LEXER_CHAR_SET_in_setElement2464); 
					}
					break;

			}

				exitSetElement(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "setElement"


	public static class block_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "block"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:940:1: block : ^( BLOCK ( optionsSpec )? ( ruleAction )* ( ACTION )? ( alternative )+ ) ;
	public final GrammarTreeVisitor.block_return block() throws RecognitionException {
		GrammarTreeVisitor.block_return retval = new GrammarTreeVisitor.block_return();
		retval.start = input.LT(1);


			enterBlock(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:5: ( ^( BLOCK ( optionsSpec )? ( ruleAction )* ( ACTION )? ( alternative )+ ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:7: ^( BLOCK ( optionsSpec )? ( ruleAction )* ( ACTION )? ( alternative )+ )
			{
			match(input,BLOCK,FOLLOW_BLOCK_in_block2489); 
			match(input, Token.DOWN, null); 
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:15: ( optionsSpec )?
			int alt56=2;
			int LA56_0 = input.LA(1);
			if ( (LA56_0==OPTIONS) ) {
				alt56=1;
			}
			switch (alt56) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:15: optionsSpec
					{
					pushFollow(FOLLOW_optionsSpec_in_block2491);
					optionsSpec();
					state._fsp--;

					}
					break;

			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:28: ( ruleAction )*
			loop57:
			while (true) {
				int alt57=2;
				int LA57_0 = input.LA(1);
				if ( (LA57_0==AT) ) {
					alt57=1;
				}

				switch (alt57) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:28: ruleAction
					{
					pushFollow(FOLLOW_ruleAction_in_block2494);
					ruleAction();
					state._fsp--;

					}
					break;

				default :
					break loop57;
				}
			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:40: ( ACTION )?
			int alt58=2;
			int LA58_0 = input.LA(1);
			if ( (LA58_0==ACTION) ) {
				alt58=1;
			}
			switch (alt58) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:40: ACTION
					{
					match(input,ACTION,FOLLOW_ACTION_in_block2497); 
					}
					break;

			}

			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:48: ( alternative )+
			int cnt59=0;
			loop59:
			while (true) {
				int alt59=2;
				int LA59_0 = input.LA(1);
				if ( (LA59_0==ALT) ) {
					alt59=1;
				}

				switch (alt59) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:947:48: alternative
					{
					pushFollow(FOLLOW_alternative_in_block2500);
					alternative();
					state._fsp--;

					}
					break;

				default :
					if ( cnt59 >= 1 ) break loop59;
					EarlyExitException eee = new EarlyExitException(59, input);
					throw eee;
				}
				cnt59++;
			}

			match(input, Token.UP, null); 

			}


				exitBlock(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "block"


	public static class ruleref_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "ruleref"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:950:1: ruleref : ^( RULE_REF (arg= ARG_ACTION )? ) ;
	public final GrammarTreeVisitor.ruleref_return ruleref() throws RecognitionException {
		GrammarTreeVisitor.ruleref_return retval = new GrammarTreeVisitor.ruleref_return();
		retval.start = input.LT(1);

		GrammarAST arg=null;
		GrammarAST RULE_REF37=null;


			enterRuleref(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:957:5: ( ^( RULE_REF (arg= ARG_ACTION )? ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:957:7: ^( RULE_REF (arg= ARG_ACTION )? )
			{
			RULE_REF37=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref2530); 
			if ( input.LA(1)==Token.DOWN ) {
				match(input, Token.DOWN, null); 
				// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:957:21: (arg= ARG_ACTION )?
				int alt60=2;
				int LA60_0 = input.LA(1);
				if ( (LA60_0==ARG_ACTION) ) {
					alt60=1;
				}
				switch (alt60) {
					case 1 :
						// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:957:21: arg= ARG_ACTION
						{
						arg=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref2534); 
						}
						break;

				}

				match(input, Token.UP, null); 
			}


			    	ruleRef(RULE_REF37, (ActionAST)arg);
			    	if ( arg!=null ) actionInAlt((ActionAST)arg);
			    	
			}


				exitRuleref(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ruleref"


	public static class range_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "range"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:964:1: range : ^( RANGE STRING_LITERAL STRING_LITERAL ) ;
	public final GrammarTreeVisitor.range_return range() throws RecognitionException {
		GrammarTreeVisitor.range_return retval = new GrammarTreeVisitor.range_return();
		retval.start = input.LT(1);


			enterRange(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:971:5: ( ^( RANGE STRING_LITERAL STRING_LITERAL ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:971:7: ^( RANGE STRING_LITERAL STRING_LITERAL )
			{
			match(input,RANGE,FOLLOW_RANGE_in_range2571); 
			match(input, Token.DOWN, null); 
			match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range2573); 
			match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range2575); 
			match(input, Token.UP, null); 

			}


				exitRange(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "range"


	public static class terminal_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "terminal"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:974:1: terminal : ( ^( STRING_LITERAL elementOptions ) | STRING_LITERAL | ^( TOKEN_REF elementOptions ) | TOKEN_REF );
	public final GrammarTreeVisitor.terminal_return terminal() throws RecognitionException {
		GrammarTreeVisitor.terminal_return retval = new GrammarTreeVisitor.terminal_return();
		retval.start = input.LT(1);

		GrammarAST STRING_LITERAL38=null;
		GrammarAST STRING_LITERAL39=null;
		GrammarAST TOKEN_REF40=null;
		GrammarAST TOKEN_REF41=null;


			enterTerminal(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:981:5: ( ^( STRING_LITERAL elementOptions ) | STRING_LITERAL | ^( TOKEN_REF elementOptions ) | TOKEN_REF )
			int alt61=4;
			int LA61_0 = input.LA(1);
			if ( (LA61_0==STRING_LITERAL) ) {
				int LA61_1 = input.LA(2);
				if ( (LA61_1==DOWN) ) {
					alt61=1;
				}
				else if ( (LA61_1==EOF||(LA61_1 >= UP && LA61_1 <= ACTION)||LA61_1==ASSIGN||LA61_1==DOT||LA61_1==LEXER_CHAR_SET||LA61_1==NOT||LA61_1==PLUS_ASSIGN||LA61_1==RANGE||LA61_1==RULE_REF||LA61_1==SEMPRED||LA61_1==STRING_LITERAL||LA61_1==TOKEN_REF||LA61_1==BLOCK||LA61_1==CLOSURE||LA61_1==EPSILON||(LA61_1 >= OPTIONAL && LA61_1 <= POSITIVE_CLOSURE)||LA61_1==SET||LA61_1==WILDCARD) ) {
					alt61=2;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 61, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}
			else if ( (LA61_0==TOKEN_REF) ) {
				int LA61_2 = input.LA(2);
				if ( (LA61_2==DOWN) ) {
					alt61=3;
				}
				else if ( (LA61_2==EOF||(LA61_2 >= UP && LA61_2 <= ACTION)||LA61_2==ASSIGN||LA61_2==DOT||LA61_2==LEXER_CHAR_SET||LA61_2==NOT||LA61_2==PLUS_ASSIGN||LA61_2==RANGE||LA61_2==RULE_REF||LA61_2==SEMPRED||LA61_2==STRING_LITERAL||LA61_2==TOKEN_REF||LA61_2==BLOCK||LA61_2==CLOSURE||LA61_2==EPSILON||(LA61_2 >= OPTIONAL && LA61_2 <= POSITIVE_CLOSURE)||LA61_2==SET||LA61_2==WILDCARD) ) {
					alt61=4;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 61, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 61, 0, input);
				throw nvae;
			}

			switch (alt61) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:981:8: ^( STRING_LITERAL elementOptions )
					{
					STRING_LITERAL38=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal2605); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_terminal2607);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					stringRef((TerminalAST)STRING_LITERAL38);
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:983:7: STRING_LITERAL
					{
					STRING_LITERAL39=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal2630); 
					stringRef((TerminalAST)STRING_LITERAL39);
					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:984:7: ^( TOKEN_REF elementOptions )
					{
					TOKEN_REF40=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal2644); 
					match(input, Token.DOWN, null); 
					pushFollow(FOLLOW_elementOptions_in_terminal2646);
					elementOptions();
					state._fsp--;

					match(input, Token.UP, null); 

					tokenRef((TerminalAST)TOKEN_REF40);
					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:985:7: TOKEN_REF
					{
					TOKEN_REF41=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal2657); 
					tokenRef((TerminalAST)TOKEN_REF41);
					}
					break;

			}

				exitTerminal(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "terminal"


	public static class elementOptions_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "elementOptions"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:988:1: elementOptions : ^( ELEMENT_OPTIONS ( elementOption[(GrammarASTWithOptions)$start.getParent()] )* ) ;
	public final GrammarTreeVisitor.elementOptions_return elementOptions() throws RecognitionException {
		GrammarTreeVisitor.elementOptions_return retval = new GrammarTreeVisitor.elementOptions_return();
		retval.start = input.LT(1);


			enterElementOptions(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:995:5: ( ^( ELEMENT_OPTIONS ( elementOption[(GrammarASTWithOptions)$start.getParent()] )* ) )
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:995:7: ^( ELEMENT_OPTIONS ( elementOption[(GrammarASTWithOptions)$start.getParent()] )* )
			{
			match(input,ELEMENT_OPTIONS,FOLLOW_ELEMENT_OPTIONS_in_elementOptions2694); 
			if ( input.LA(1)==Token.DOWN ) {
				match(input, Token.DOWN, null); 
				// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:995:25: ( elementOption[(GrammarASTWithOptions)$start.getParent()] )*
				loop62:
				while (true) {
					int alt62=2;
					int LA62_0 = input.LA(1);
					if ( (LA62_0==ASSIGN||LA62_0==ID) ) {
						alt62=1;
					}

					switch (alt62) {
					case 1 :
						// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:995:25: elementOption[(GrammarASTWithOptions)$start.getParent()]
						{
						pushFollow(FOLLOW_elementOption_in_elementOptions2696);
						elementOption((GrammarASTWithOptions)((GrammarAST)retval.start).getParent());
						state._fsp--;

						}
						break;

					default :
						break loop62;
					}
				}

				match(input, Token.UP, null); 
			}

			}


				exitElementOptions(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "elementOptions"


	public static class elementOption_return extends TreeRuleReturnScope {
	};


	// $ANTLR start "elementOption"
	// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:998:1: elementOption[GrammarASTWithOptions t] : ( ID | ^( ASSIGN id= ID v= ID ) | ^( ASSIGN ID v= STRING_LITERAL ) | ^( ASSIGN ID v= ACTION ) | ^( ASSIGN ID v= INT ) );
	public final GrammarTreeVisitor.elementOption_return elementOption(GrammarASTWithOptions t) throws RecognitionException {
		GrammarTreeVisitor.elementOption_return retval = new GrammarTreeVisitor.elementOption_return();
		retval.start = input.LT(1);

		GrammarAST id=null;
		GrammarAST v=null;
		GrammarAST ID42=null;
		GrammarAST ID43=null;
		GrammarAST ID44=null;
		GrammarAST ID45=null;


			enterElementOption(((GrammarAST)retval.start));

		try {
			// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1005:5: ( ID | ^( ASSIGN id= ID v= ID ) | ^( ASSIGN ID v= STRING_LITERAL ) | ^( ASSIGN ID v= ACTION ) | ^( ASSIGN ID v= INT ) )
			int alt63=5;
			int LA63_0 = input.LA(1);
			if ( (LA63_0==ID) ) {
				alt63=1;
			}
			else if ( (LA63_0==ASSIGN) ) {
				int LA63_2 = input.LA(2);
				if ( (LA63_2==DOWN) ) {
					int LA63_3 = input.LA(3);
					if ( (LA63_3==ID) ) {
						switch ( input.LA(4) ) {
						case ID:
							{
							alt63=2;
							}
							break;
						case STRING_LITERAL:
							{
							alt63=3;
							}
							break;
						case ACTION:
							{
							alt63=4;
							}
							break;
						case INT:
							{
							alt63=5;
							}
							break;
						default:
							int nvaeMark = input.mark();
							try {
								for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
									input.consume();
								}
								NoViableAltException nvae =
									new NoViableAltException("", 63, 4, input);
								throw nvae;
							} finally {
								input.rewind(nvaeMark);
							}
						}
					}

					else {
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 63, 3, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 63, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 63, 0, input);
				throw nvae;
			}

			switch (alt63) {
				case 1 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1005:7: ID
					{
					ID42=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2727); 
					elementOption(t, ID42, null);
					}
					break;
				case 2 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1006:9: ^( ASSIGN id= ID v= ID )
					{
					match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption2747); 
					match(input, Token.DOWN, null); 
					id=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2751); 
					v=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2755); 
					match(input, Token.UP, null); 

					elementOption(t, id, v);
					}
					break;
				case 3 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1007:9: ^( ASSIGN ID v= STRING_LITERAL )
					{
					match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption2771); 
					match(input, Token.DOWN, null); 
					ID43=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2773); 
					v=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_elementOption2777); 
					match(input, Token.UP, null); 

					elementOption(t, ID43, v);
					}
					break;
				case 4 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1008:9: ^( ASSIGN ID v= ACTION )
					{
					match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption2791); 
					match(input, Token.DOWN, null); 
					ID44=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2793); 
					v=(GrammarAST)match(input,ACTION,FOLLOW_ACTION_in_elementOption2797); 
					match(input, Token.UP, null); 

					elementOption(t, ID44, v);
					}
					break;
				case 5 :
					// org\\antlr\\v4\\parse\\GrammarTreeVisitor.g:1009:9: ^( ASSIGN ID v= INT )
					{
					match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption2813); 
					match(input, Token.DOWN, null); 
					ID45=(GrammarAST)match(input,ID,FOLLOW_ID_in_elementOption2815); 
					v=(GrammarAST)match(input,INT,FOLLOW_INT_in_elementOption2819); 
					match(input, Token.UP, null); 

					elementOption(t, ID45, v);
					}
					break;

			}

				exitElementOption(((GrammarAST)retval.start));

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "elementOption"

	// Delegated rules



	public static final BitSet FOLLOW_GRAMMAR_in_grammarSpec85 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_grammarSpec87 = new BitSet(new long[]{0x0000020010020800L,0x0000000040000001L});
	public static final BitSet FOLLOW_DOC_COMMENT_in_grammarSpec91 = new BitSet(new long[]{0x0000020010000800L,0x0000000040000001L});
	public static final BitSet FOLLOW_prequelConstructs_in_grammarSpec109 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
	public static final BitSet FOLLOW_rules_in_grammarSpec126 = new BitSet(new long[]{0x0000000800000008L});
	public static final BitSet FOLLOW_mode_in_grammarSpec128 = new BitSet(new long[]{0x0000000800000008L});
	public static final BitSet FOLLOW_prequelConstruct_in_prequelConstructs170 = new BitSet(new long[]{0x0000020010000802L,0x0000000000000001L});
	public static final BitSet FOLLOW_optionsSpec_in_prequelConstruct197 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_delegateGrammars_in_prequelConstruct207 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_tokensSpec_in_prequelConstruct217 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_action_in_prequelConstruct227 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_OPTIONS_in_optionsSpec252 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_option_in_optionsSpec254 = new BitSet(new long[]{0x0000000000000408L});
	public static final BitSet FOLLOW_ASSIGN_in_option288 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_option290 = new BitSet(new long[]{0x2000000028000000L});
	public static final BitSet FOLLOW_optionValue_in_option294 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_IMPORT_in_delegateGrammars382 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_delegateGrammar_in_delegateGrammars384 = new BitSet(new long[]{0x0000000008000408L});
	public static final BitSet FOLLOW_ASSIGN_in_delegateGrammar413 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_delegateGrammar417 = new BitSet(new long[]{0x0000000008000000L});
	public static final BitSet FOLLOW_ID_in_delegateGrammar421 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ID_in_delegateGrammar436 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_TOKENS_SPEC_in_tokensSpec470 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_tokenSpec_in_tokensSpec472 = new BitSet(new long[]{0x0000000008000008L});
	public static final BitSet FOLLOW_ID_in_tokenSpec495 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_AT_in_action523 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_action527 = new BitSet(new long[]{0x0000000008000000L});
	public static final BitSet FOLLOW_ID_in_action532 = new BitSet(new long[]{0x0000000000000010L});
	public static final BitSet FOLLOW_ACTION_in_action534 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_RULES_in_rules562 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_rule_in_rules567 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L});
	public static final BitSet FOLLOW_lexerRule_in_rules569 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L});
	public static final BitSet FOLLOW_MODE_in_mode600 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_mode602 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L});
	public static final BitSet FOLLOW_lexerRule_in_mode606 = new BitSet(new long[]{0x0000000000000008L,0x0000000008000000L});
	public static final BitSet FOLLOW_RULE_in_lexerRule632 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_TOKEN_REF_in_lexerRule634 = new BitSet(new long[]{0x0000000000020000L,0x0000000020000800L});
	public static final BitSet FOLLOW_DOC_COMMENT_in_lexerRule644 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000800L});
	public static final BitSet FOLLOW_RULEMODIFIERS_in_lexerRule649 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_FRAGMENT_in_lexerRule653 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_lexerRuleBlock_in_lexerRule678 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_RULE_in_rule733 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_RULE_REF_in_rule735 = new BitSet(new long[]{0x8040020100020900L,0x0000000020000800L});
	public static final BitSet FOLLOW_DOC_COMMENT_in_rule742 = new BitSet(new long[]{0x8040020100000900L,0x0000000020000800L});
	public static final BitSet FOLLOW_RULEMODIFIERS_in_rule747 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ruleModifier_in_rule752 = new BitSet(new long[]{0x0003800000800008L});
	public static final BitSet FOLLOW_ARG_ACTION_in_rule763 = new BitSet(new long[]{0x8040020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleReturns_in_rule776 = new BitSet(new long[]{0x8000020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_throwsSpec_in_rule789 = new BitSet(new long[]{0x0000020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_locals_in_rule802 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_optionsSpec_in_rule817 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleAction_in_rule831 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleBlock_in_rule862 = new BitSet(new long[]{0x0000000000401008L});
	public static final BitSet FOLLOW_exceptionGroup_in_rule864 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_RULE_in_rule918 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_RULE_REF_in_rule920 = new BitSet(new long[]{0x8040020100020900L,0x0000000020000800L});
	public static final BitSet FOLLOW_DOC_COMMENT_in_rule925 = new BitSet(new long[]{0x8040020100000900L,0x0000000020000800L});
	public static final BitSet FOLLOW_RULEMODIFIERS_in_rule930 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ruleModifier_in_rule935 = new BitSet(new long[]{0x0003800000800008L});
	public static final BitSet FOLLOW_ARG_ACTION_in_rule945 = new BitSet(new long[]{0x8040020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleReturns_in_rule958 = new BitSet(new long[]{0x8000020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_throwsSpec_in_rule971 = new BitSet(new long[]{0x0000020100000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_locals_in_rule984 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_optionsSpec_in_rule999 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleAction_in_rule1013 = new BitSet(new long[]{0x0000020000000800L,0x0000000000000800L});
	public static final BitSet FOLLOW_ruleBlock_in_rule1032 = new BitSet(new long[]{0x0000000000401008L});
	public static final BitSet FOLLOW_exceptionGroup_in_rule1034 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_exceptionHandler_in_exceptionGroup1072 = new BitSet(new long[]{0x0000000000401002L});
	public static final BitSet FOLLOW_finallyClause_in_exceptionGroup1075 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_CATCH_in_exceptionHandler1101 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ARG_ACTION_in_exceptionHandler1103 = new BitSet(new long[]{0x0000000000000010L});
	public static final BitSet FOLLOW_ACTION_in_exceptionHandler1105 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_FINALLY_in_finallyClause1130 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ACTION_in_finallyClause1132 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_LOCALS_in_locals1160 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ARG_ACTION_in_locals1162 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_RETURNS_in_ruleReturns1185 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ARG_ACTION_in_ruleReturns1187 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_THROWS_in_throwsSpec1213 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_throwsSpec1215 = new BitSet(new long[]{0x0000000008000008L});
	public static final BitSet FOLLOW_AT_in_ruleAction1242 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_ruleAction1244 = new BitSet(new long[]{0x0000000000000010L});
	public static final BitSet FOLLOW_ACTION_in_ruleAction1246 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_BLOCK_in_lexerRuleBlock1324 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_lexerOuterAlternative_in_lexerRuleBlock1343 = new BitSet(new long[]{0x0000000000000008L,0x0000000000100080L});
	public static final BitSet FOLLOW_BLOCK_in_ruleBlock1388 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_outerAlternative_in_ruleBlock1407 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000080L});
	public static final BitSet FOLLOW_lexerAlternative_in_lexerOuterAlternative1447 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_alternative_in_outerAlternative1469 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LEXER_ALT_ACTION_in_lexerAlternative1491 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_lexerElements_in_lexerAlternative1493 = new BitSet(new long[]{0x0000000008000000L,0x0000000000080000L});
	public static final BitSet FOLLOW_lexerCommand_in_lexerAlternative1495 = new BitSet(new long[]{0x0000000008000008L,0x0000000000080000L});
	public static final BitSet FOLLOW_lexerElements_in_lexerAlternative1507 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ALT_in_lexerElements1535 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_lexerElement_in_lexerElements1537 = new BitSet(new long[]{0x2408204080000418L,0x0000000280C12802L});
	public static final BitSet FOLLOW_labeledLexerElement_in_lexerElement1563 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_lexerAtom_in_lexerElement1568 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_lexerSubrule_in_lexerElement1573 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_lexerElement1580 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_SEMPRED_in_lexerElement1594 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_lexerElement1609 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_lexerElement1611 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_SEMPRED_in_lexerElement1622 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_lexerElement1624 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_EPSILON_in_lexerElement1632 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_set_in_labeledLexerElement1659 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_labeledLexerElement1665 = new BitSet(new long[]{0x2008004080000000L,0x0000000280000802L});
	public static final BitSet FOLLOW_lexerAtom_in_labeledLexerElement1668 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_block_in_labeledLexerElement1670 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_BLOCK_in_lexerBlock1695 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_optionsSpec_in_lexerBlock1697 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100080L});
	public static final BitSet FOLLOW_lexerAlternative_in_lexerBlock1700 = new BitSet(new long[]{0x0000000000000008L,0x0000000000100080L});
	public static final BitSet FOLLOW_terminal_in_lexerAtom1731 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NOT_in_lexerAtom1742 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_blockSet_in_lexerAtom1744 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_blockSet_in_lexerAtom1755 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_WILDCARD_in_lexerAtom1766 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_lexerAtom1768 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_WILDCARD_in_lexerAtom1779 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LEXER_CHAR_SET_in_lexerAtom1787 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_range_in_lexerAtom1797 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_actionElement1821 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_actionElement1829 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_actionElement1831 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_SEMPRED_in_actionElement1839 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_SEMPRED_in_actionElement1847 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_actionElement1849 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ALT_in_alternative1872 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_element_in_alternative1874 = new BitSet(new long[]{0x2500204000080418L,0x0000000280C02802L});
	public static final BitSet FOLLOW_ALT_in_alternative1882 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_EPSILON_in_alternative1884 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_LEXER_ACTION_CALL_in_lexerCommand1910 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_lexerCommand1912 = new BitSet(new long[]{0x0000000028000000L});
	public static final BitSet FOLLOW_lexerCommandExpr_in_lexerCommand1914 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ID_in_lexerCommand1930 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_labeledElement_in_element1987 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_atom_in_element1992 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_subrule_in_element1997 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_element2004 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_SEMPRED_in_element2018 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ACTION_in_element2033 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_element2035 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_SEMPRED_in_element2046 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_element2048 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_NOT_in_element2058 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_blockSet_in_element2060 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_NOT_in_element2067 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_block_in_element2069 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_atom_in_astOperand2091 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NOT_in_astOperand2097 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_blockSet_in_astOperand2099 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_NOT_in_astOperand2106 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_block_in_astOperand2108 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_set_in_labeledElement2131 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_labeledElement2137 = new BitSet(new long[]{0x2500204000080410L,0x0000000280C02802L});
	public static final BitSet FOLLOW_element_in_labeledElement2139 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_blockSuffix_in_subrule2164 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_block_in_subrule2166 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_block_in_subrule2173 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_blockSuffix_in_lexerSubrule2198 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_lexerBlock_in_lexerSubrule2200 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_lexerBlock_in_lexerSubrule2207 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ebnfSuffix_in_blockSuffix2234 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_DOT_in_atom2295 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_atom2297 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000002L});
	public static final BitSet FOLLOW_terminal_in_atom2299 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_DOT_in_atom2306 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_atom2308 = new BitSet(new long[]{0x0100000000000000L});
	public static final BitSet FOLLOW_ruleref_in_atom2310 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_WILDCARD_in_atom2320 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_atom2322 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_WILDCARD_in_atom2333 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_terminal_in_atom2349 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_blockSet_in_atom2357 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ruleref_in_atom2367 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_SET_in_blockSet2392 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_setElement_in_blockSet2394 = new BitSet(new long[]{0x2008000080000008L,0x0000000000000002L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_setElement2417 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_TOKEN_REF_in_setElement2424 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_RANGE_in_setElement2433 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_setElement2437 = new BitSet(new long[]{0x2000000000000000L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_setElement2441 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_LEXER_CHAR_SET_in_setElement2464 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_BLOCK_in_block2489 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_optionsSpec_in_block2491 = new BitSet(new long[]{0x0000000000000810L,0x0000000000000080L});
	public static final BitSet FOLLOW_ruleAction_in_block2494 = new BitSet(new long[]{0x0000000000000810L,0x0000000000000080L});
	public static final BitSet FOLLOW_ACTION_in_block2497 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
	public static final BitSet FOLLOW_alternative_in_block2500 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000080L});
	public static final BitSet FOLLOW_RULE_REF_in_ruleref2530 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ARG_ACTION_in_ruleref2534 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_RANGE_in_range2571 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_range2573 = new BitSet(new long[]{0x2000000000000000L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_range2575 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_terminal2605 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_terminal2607 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_terminal2630 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_TOKEN_REF_in_terminal2644 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOptions_in_terminal2646 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_TOKEN_REF_in_terminal2657 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ELEMENT_OPTIONS_in_elementOptions2694 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_elementOption_in_elementOptions2696 = new BitSet(new long[]{0x0000000008000408L});
	public static final BitSet FOLLOW_ID_in_elementOption2727 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ASSIGN_in_elementOption2747 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_elementOption2751 = new BitSet(new long[]{0x0000000008000000L});
	public static final BitSet FOLLOW_ID_in_elementOption2755 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ASSIGN_in_elementOption2771 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_elementOption2773 = new BitSet(new long[]{0x2000000000000000L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_elementOption2777 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ASSIGN_in_elementOption2791 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_elementOption2793 = new BitSet(new long[]{0x0000000000000010L});
	public static final BitSet FOLLOW_ACTION_in_elementOption2797 = new BitSet(new long[]{0x0000000000000008L});
	public static final BitSet FOLLOW_ASSIGN_in_elementOption2813 = new BitSet(new long[]{0x0000000000000004L});
	public static final BitSet FOLLOW_ID_in_elementOption2815 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_INT_in_elementOption2819 = new BitSet(new long[]{0x0000000000000008L});
}