Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 12283 insertions, 0 deletions

diff --git a/languages/ada/AdaParser.cpp b/languages/ada/AdaParser.cpp
new file mode 100644
index 00000000..e783595e
--- /dev/null
+++ b/languages/ada/AdaParser.cpp
@@ -0,0 +1,12283 @@
+/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaParser.cpp"$ */
+#include "AdaParser.hpp"
+#include <antlr/NoViableAltException.hpp>
+#include <antlr/SemanticException.hpp>
+#include <antlr/ASTFactory.hpp>
+#line 1 "ada.g"
+#line 8 "AdaParser.cpp"
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
+{
+}
+
+AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
+{
+}
+
+AdaParser::AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
+{
+}
+
+void AdaParser::compilation_unit() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST compilation_unit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	context_items_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case PRIVATE:
+	case PACKAGE:
+	case PROCEDURE:
+	case FUNCTION:
+	case GENERIC:
+	{
+		library_item();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEPARATE:
+	{
+		subunit();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PRAGMA)) {
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop4;
+		}
+		
+	}
+	_loop4:;
+	} // ( ... )*
+	compilation_unit_AST = RefAdaAST(currentAST.root);
+	returnAST = compilation_unit_AST;
+}
+
+void AdaParser::context_items_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST context_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case WITH:
+		{
+			with_clause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case USE:
+		{
+			use_clause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop14;
+		}
+		}
+	}
+	_loop14:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		context_items_opt_AST = RefAdaAST(currentAST.root);
+#line 86 "ada.g"
+		context_items_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CONTEXT_CLAUSE,"CONTEXT_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(context_items_opt_AST))));
+#line 135 "AdaParser.cpp"
+		currentAST.root = context_items_opt_AST;
+		if ( context_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			context_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = context_items_opt_AST->getFirstChild();
+		else
+			currentAST.child = context_items_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	context_items_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = context_items_opt_AST;
+}
+
+void AdaParser::library_item() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST library_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	private_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case PACKAGE:
+	{
+		lib_pkg_spec_or_body();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case PROCEDURE:
+	case FUNCTION:
+	{
+		subprog_decl_or_rename_or_inst_or_body(true);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case GENERIC:
+	{
+		generic_decl(true);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		library_item_AST = RefAdaAST(currentAST.root);
+#line 133 "ada.g"
+		library_item_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LIBRARY_ITEM,"LIBRARY_ITEM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(library_item_AST))));
+#line 194 "AdaParser.cpp"
+		currentAST.root = library_item_AST;
+		if ( library_item_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			library_item_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = library_item_AST->getFirstChild();
+		else
+			currentAST.child = library_item_AST;
+		currentAST.advanceChildToEnd();
+	}
+	library_item_AST = RefAdaAST(currentAST.root);
+	returnAST = library_item_AST;
+}
+
+void AdaParser::subunit() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subunit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  sep = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST sep_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	sep = LT(1);
+	if ( inputState->guessing == 0 ) {
+		sep_AST = astFactory->create(sep);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sep_AST));
+	}
+	match(SEPARATE);
+	match(LPAREN);
+	compound_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+#line 1497 "ada.g"
+		Set(sep_AST, SUBUNIT);
+#line 229 "AdaParser.cpp"
+	}
+	{
+	switch ( LA(1)) {
+	case PROCEDURE:
+	case FUNCTION:
+	{
+		subprogram_body();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case PACKAGE:
+	{
+		package_body();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case TASK:
+	{
+		task_body();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case PROTECTED:
+	{
+		protected_body();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	subunit_AST = RefAdaAST(currentAST.root);
+	returnAST = subunit_AST;
+}
+
+void AdaParser::pragma() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST pragma_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp3_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp3_AST = astFactory->create(LT(1));
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST));
+	}
+	match(PRAGMA);
+	RefAdaAST tmp4_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp4_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST));
+	}
+	match(IDENTIFIER);
+	pragma_args_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	pragma_AST = RefAdaAST(currentAST.root);
+	returnAST = pragma_AST;
+}
+
+void AdaParser::pragma_args_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST pragma_args_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		pragma_arg();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == COMMA)) {
+				match(COMMA);
+				pragma_arg();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop9;
+			}
+			
+		}
+		_loop9:;
+		} // ( ... )*
+		match(RPAREN);
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	pragma_args_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = pragma_args_opt_AST;
+}
+
+void AdaParser::pragma_arg() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST pragma_arg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) {
+		RefAdaAST tmp9_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp9_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST));
+		}
+		match(IDENTIFIER);
+		RefAdaAST tmp10_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp10_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST));
+		}
+		match(RIGHT_SHAFT);
+	}
+	else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	pragma_arg_AST = RefAdaAST(currentAST.root);
+	returnAST = pragma_arg_AST;
+}
+
+void AdaParser::expression() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  o = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST o_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	relation();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case AND:
+		{
+			a = LT(1);
+			if ( inputState->guessing == 0 ) {
+				a_AST = astFactory->create(a);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+			}
+			match(AND);
+			{
+			switch ( LA(1)) {
+			case THEN:
+			{
+				match(THEN);
+				if ( inputState->guessing==0 ) {
+#line 1417 "ada.g"
+					Set (a_AST, AND_THEN);
+#line 416 "AdaParser.cpp"
+				}
+				break;
+			}
+			case IDENTIFIER:
+			case LPAREN:
+			case NEW:
+			case CHARACTER_LITERAL:
+			case CHAR_STRING:
+			case NuLL:
+			case NOT:
+			case PLUS:
+			case MINUS:
+			case ABS:
+			case NUMERIC_LIT:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			relation();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case OR:
+		{
+			o = LT(1);
+			if ( inputState->guessing == 0 ) {
+				o_AST = astFactory->create(o);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST));
+			}
+			match(OR);
+			{
+			switch ( LA(1)) {
+			case ELSE:
+			{
+				match(ELSE);
+				if ( inputState->guessing==0 ) {
+#line 1418 "ada.g"
+					Set (o_AST, OR_ELSE);
+#line 462 "AdaParser.cpp"
+				}
+				break;
+			}
+			case IDENTIFIER:
+			case LPAREN:
+			case NEW:
+			case CHARACTER_LITERAL:
+			case CHAR_STRING:
+			case NuLL:
+			case NOT:
+			case PLUS:
+			case MINUS:
+			case ABS:
+			case NUMERIC_LIT:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			relation();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case XOR:
+		{
+			RefAdaAST tmp13_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp13_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST));
+			}
+			match(XOR);
+			relation();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop450;
+		}
+		}
+	}
+	_loop450:;
+	} // ( ... )*
+	expression_AST = RefAdaAST(currentAST.root);
+	returnAST = expression_AST;
+}
+
+void AdaParser::with_clause() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST with_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	w = LT(1);
+	if ( inputState->guessing == 0 ) {
+		w_AST = astFactory->create(w);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+	}
+	match(WITH);
+	c_name_list();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 94 "ada.g"
+		Set(w_AST, WITH_CLAUSE);
+#line 539 "AdaParser.cpp"
+	}
+	with_clause_AST = RefAdaAST(currentAST.root);
+	returnAST = with_clause_AST;
+}
+
+void AdaParser::use_clause() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST use_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  u = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST u_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	u = LT(1);
+	if ( inputState->guessing == 0 ) {
+		u_AST = astFactory->create(u);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(u_AST));
+	}
+	match(USE);
+	{
+	switch ( LA(1)) {
+	case TYPE:
+	{
+		match(TYPE);
+		subtype_mark();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == COMMA)) {
+				match(COMMA);
+				subtype_mark();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop25;
+			}
+			
+		}
+		_loop25:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+#line 108 "ada.g"
+			Set(u_AST, USE_TYPE_CLAUSE);
+#line 586 "AdaParser.cpp"
+		}
+		break;
+	}
+	case IDENTIFIER:
+	{
+		c_name_list();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 109 "ada.g"
+			Set(u_AST, USE_CLAUSE);
+#line 599 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	use_clause_AST = RefAdaAST(currentAST.root);
+	returnAST = use_clause_AST;
+}
+
+void AdaParser::c_name_list() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST c_name_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	compound_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			compound_name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop18;
+		}
+		
+	}
+	_loop18:;
+	} // ( ... )*
+	c_name_list_AST = RefAdaAST(currentAST.root);
+	returnAST = c_name_list_AST;
+}
+
+void AdaParser::compound_name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST compound_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp19_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp19_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST));
+	}
+	match(IDENTIFIER);
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == DOT)) {
+			RefAdaAST tmp20_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp20_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST));
+			}
+			match(DOT);
+			RefAdaAST tmp21_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp21_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST));
+			}
+			match(IDENTIFIER);
+		}
+		else {
+			goto _loop21;
+		}
+		
+	}
+	_loop21:;
+	} // ( ... )*
+	compound_name_AST = RefAdaAST(currentAST.root);
+	returnAST = compound_name_AST;
+}
+
+void AdaParser::subtype_mark() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subtype_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	compound_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case TIC:
+	{
+		RefAdaAST tmp22_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp22_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
+		}
+		match(TIC);
+		attribute_id();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case LPAREN:
+	case COMMA:
+	case RPAREN:
+	case RIGHT_SHAFT:
+	case WITH:
+	case USE:
+	case RANGE:
+	case DIGITS:
+	case DELTA:
+	case IS:
+	case PIPE:
+	case DOT_DOT:
+	case RENAMES:
+	case ASSIGN:
+	case AT:
+	case THEN:
+	case LOOP:
+	case OR:
+	case AND:
+	case XOR:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	subtype_mark_AST = RefAdaAST(currentAST.root);
+	returnAST = subtype_mark_AST;
+}
+
+void AdaParser::attribute_id() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST attribute_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case RANGE:
+	{
+		RefAdaAST tmp23_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp23_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST));
+		}
+		match(RANGE);
+		attribute_id_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case DIGITS:
+	{
+		RefAdaAST tmp24_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp24_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
+		}
+		match(DIGITS);
+		attribute_id_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case DELTA:
+	{
+		RefAdaAST tmp25_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp25_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST));
+		}
+		match(DELTA);
+		attribute_id_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case ACCESS:
+	{
+		RefAdaAST tmp26_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp26_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST));
+		}
+		match(ACCESS);
+		attribute_id_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		RefAdaAST tmp27_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp27_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST));
+		}
+		match(IDENTIFIER);
+		attribute_id_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = attribute_id_AST;
+}
+
+void AdaParser::private_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PRIVATE:
+	{
+		RefAdaAST tmp28_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp28_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST));
+		}
+		match(PRIVATE);
+		break;
+	}
+	case PACKAGE:
+	case PROCEDURE:
+	case FUNCTION:
+	case GENERIC:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		private_opt_AST = RefAdaAST(currentAST.root);
+#line 137 "ada.g"
+		private_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_opt_AST))));
+#line 843 "AdaParser.cpp"
+		currentAST.root = private_opt_AST;
+		if ( private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = private_opt_AST->getFirstChild();
+		else
+			currentAST.child = private_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	private_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = private_opt_AST;
+}
+
+void AdaParser::lib_pkg_spec_or_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST lib_pkg_spec_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	pkg = LT(1);
+	if ( inputState->guessing == 0 ) {
+		pkg_AST = astFactory->create(pkg);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+	}
+	match(PACKAGE);
+	{
+	switch ( LA(1)) {
+	case BODY:
+	{
+		match(BODY);
+		def_id(true);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(IS);
+		pkg_body_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 143 "ada.g"
+			Set(pkg_AST, PACKAGE_BODY);
+#line 887 "AdaParser.cpp"
+		}
+		break;
+	}
+	case IDENTIFIER:
+	{
+		def_id(true);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		spec_decl_part(pkg_AST);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	lib_pkg_spec_or_body_AST = RefAdaAST(currentAST.root);
+	returnAST = lib_pkg_spec_or_body_AST;
+}
+
+void AdaParser::subprog_decl_or_rename_or_inst_or_body(
+	boolean lib_level
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 944 "ada.g"
+	RefAdaAST t;
+#line 925 "AdaParser.cpp"
+	
+	switch ( LA(1)) {
+	case PROCEDURE:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PROCEDURE);
+		def_id(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		if ((LA(1) == IS) && (LA(2) == NEW)) {
+			generic_subp_inst();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 948 "ada.g"
+				Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
+#line 949 "AdaParser.cpp"
+			}
+		}
+		else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) {
+			formal_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case RENAMES:
+			{
+				renames();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 950 "ada.g"
+					Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
+#line 968 "AdaParser.cpp"
+				}
+				break;
+			}
+			case IS:
+			{
+				match(IS);
+				{
+				switch ( LA(1)) {
+				case SEPARATE:
+				case ABSTRACT:
+				{
+					separate_or_abstract(p_AST);
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				case PRAGMA:
+				case IDENTIFIER:
+				case USE:
+				case TYPE:
+				case PACKAGE:
+				case PROCEDURE:
+				case FUNCTION:
+				case TASK:
+				case PROTECTED:
+				case FOR:
+				case SUBTYPE:
+				case GENERIC:
+				case BEGIN:
+				{
+					body_part();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					if ( inputState->guessing==0 ) {
+#line 952 "ada.g"
+						Set(p_AST, PROCEDURE_BODY);
+#line 1007 "AdaParser.cpp"
+					}
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				break;
+			}
+			case SEMI:
+			{
+				if ( inputState->guessing==0 ) {
+#line 954 "ada.g"
+					pop_def_id();
+								    Set(p_AST, PROCEDURE_DECLARATION);
+#line 1025 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FUNCTION:
+	{
+		f = LT(1);
+		if ( inputState->guessing == 0 ) {
+			f_AST = astFactory->create(f);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+		}
+		match(FUNCTION);
+		def_designator(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			generic_subp_inst();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 961 "ada.g"
+				Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
+#line 1068 "AdaParser.cpp"
+			}
+			break;
+		}
+		case LPAREN:
+		case RETURN:
+		{
+			function_tail();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case RENAMES:
+			{
+				renames();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 963 "ada.g"
+					Set(f_AST, FUNCTION_RENAMING_DECLARATION);
+#line 1090 "AdaParser.cpp"
+				}
+				break;
+			}
+			case IS:
+			{
+				match(IS);
+				{
+				switch ( LA(1)) {
+				case SEPARATE:
+				case ABSTRACT:
+				{
+					separate_or_abstract(f_AST);
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				case PRAGMA:
+				case IDENTIFIER:
+				case USE:
+				case TYPE:
+				case PACKAGE:
+				case PROCEDURE:
+				case FUNCTION:
+				case TASK:
+				case PROTECTED:
+				case FOR:
+				case SUBTYPE:
+				case GENERIC:
+				case BEGIN:
+				{
+					body_part();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					if ( inputState->guessing==0 ) {
+#line 965 "ada.g"
+						Set(f_AST, FUNCTION_BODY);
+#line 1129 "AdaParser.cpp"
+					}
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				break;
+			}
+			case SEMI:
+			{
+				if ( inputState->guessing==0 ) {
+#line 967 "ada.g"
+					pop_def_id();
+								    Set(f_AST, FUNCTION_DECLARATION);
+#line 1147 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = subprog_decl_or_rename_or_inst_or_body_AST;
+}
+
+void AdaParser::generic_decl(
+	boolean lib_level
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST generic_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  g = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST g_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	g = LT(1);
+	if ( inputState->guessing == 0 ) {
+		g_AST = astFactory->create(g);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(g_AST));
+	}
+	match(GENERIC);
+	generic_formal_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case PACKAGE:
+	{
+		match(PACKAGE);
+		def_id(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case RENAMES:
+		{
+			renames();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 865 "ada.g"
+				Set(g_AST, GENERIC_PACKAGE_RENAMING);
+#line 1216 "AdaParser.cpp"
+			}
+			break;
+		}
+		case IS:
+		{
+			match(IS);
+			pkg_spec_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 866 "ada.g"
+				Set(g_AST, GENERIC_PACKAGE_DECLARATION);
+#line 1230 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case PROCEDURE:
+	{
+		match(PROCEDURE);
+		def_id(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		formal_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case RENAMES:
+		{
+			renames();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 869 "ada.g"
+				Set(g_AST, GENERIC_PROCEDURE_RENAMING);
+#line 1264 "AdaParser.cpp"
+			}
+			break;
+		}
+		case SEMI:
+		{
+			if ( inputState->guessing==0 ) {
+#line 872 "ada.g"
+				Set(g_AST, GENERIC_PROCEDURE_DECLARATION); pop_def_id();
+#line 1273 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case FUNCTION:
+	{
+		match(FUNCTION);
+		def_designator(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		function_tail();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case RENAMES:
+		{
+			renames();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 875 "ada.g"
+				Set(g_AST, GENERIC_FUNCTION_RENAMING);
+#line 1307 "AdaParser.cpp"
+			}
+			break;
+		}
+		case SEMI:
+		{
+			if ( inputState->guessing==0 ) {
+#line 878 "ada.g"
+				Set(g_AST, GENERIC_FUNCTION_DECLARATION); pop_def_id();
+#line 1316 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	generic_decl_AST = RefAdaAST(currentAST.root);
+	returnAST = generic_decl_AST;
+}
+
+void AdaParser::def_id(
+	boolean lib_level
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST def_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefAdaAST cn_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if (((LA(1) == IDENTIFIER) && (_tokenSet_4.member(LA(2))))&&( lib_level )) {
+		compound_name();
+		if (inputState->guessing==0) {
+			cn_AST = returnAST;
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 171 "ada.g"
+			push_def_id(cn_AST);
+#line 1358 "AdaParser.cpp"
+		}
+		def_id_AST = RefAdaAST(currentAST.root);
+	}
+	else if (((LA(1) == IDENTIFIER) && (_tokenSet_5.member(LA(2))))&&( !lib_level )) {
+		n = LT(1);
+		if ( inputState->guessing == 0 ) {
+			n_AST = astFactory->create(n);
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+		}
+		match(IDENTIFIER);
+		if ( inputState->guessing==0 ) {
+#line 172 "ada.g"
+			push_def_id(n_AST);
+#line 1372 "AdaParser.cpp"
+		}
+		def_id_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = def_id_AST;
+}
+
+void AdaParser::pkg_body_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST pkg_body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	declarative_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	block_body_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	end_id_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	pkg_body_part_AST = RefAdaAST(currentAST.root);
+	returnAST = pkg_body_part_AST;
+}
+
+void AdaParser::spec_decl_part(
+	RefAdaAST pkg
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST spec_decl_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case IS:
+	{
+		match(IS);
+		{
+		switch ( LA(1)) {
+		case NEW:
+		{
+			generic_inst();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 364 "ada.g"
+				Set(pkg, GENERIC_PACKAGE_INSTANTIATION);
+#line 1427 "AdaParser.cpp"
+			}
+			break;
+		}
+		case PRAGMA:
+		case IDENTIFIER:
+		case USE:
+		case TYPE:
+		case PRIVATE:
+		case PACKAGE:
+		case PROCEDURE:
+		case FUNCTION:
+		case TASK:
+		case PROTECTED:
+		case FOR:
+		case END:
+		case SUBTYPE:
+		case GENERIC:
+		{
+			pkg_spec_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 365 "ada.g"
+				Set(pkg, PACKAGE_SPECIFICATION);
+#line 1453 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case RENAMES:
+	{
+		renames();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 367 "ada.g"
+			Set(pkg, PACKAGE_RENAMING_DECLARATION);
+#line 1474 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	spec_decl_part_AST = RefAdaAST(currentAST.root);
+	returnAST = spec_decl_part_AST;
+}
+
+void AdaParser::subprog_decl(
+	boolean lib_level
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subprog_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 148 "ada.g"
+	RefAdaAST t;
+#line 1501 "AdaParser.cpp"
+	
+	switch ( LA(1)) {
+	case PROCEDURE:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PROCEDURE);
+		def_id(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		if ((LA(1) == IS) && (LA(2) == NEW)) {
+			generic_subp_inst();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 152 "ada.g"
+				Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
+#line 1525 "AdaParser.cpp"
+			}
+		}
+		else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
+			formal_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case RENAMES:
+			{
+				renames();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 154 "ada.g"
+					Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
+#line 1544 "AdaParser.cpp"
+				}
+				break;
+			}
+			case SEMI:
+			case IS:
+			{
+				is_separate_or_abstract_or_decl(p_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		subprog_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FUNCTION:
+	{
+		f = LT(1);
+		if ( inputState->guessing == 0 ) {
+			f_AST = astFactory->create(f);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+		}
+		match(FUNCTION);
+		def_designator(lib_level);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			generic_subp_inst();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 161 "ada.g"
+				Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
+#line 1596 "AdaParser.cpp"
+			}
+			break;
+		}
+		case LPAREN:
+		case RETURN:
+		{
+			function_tail();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case RENAMES:
+			{
+				renames();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 163 "ada.g"
+					Set(f_AST, FUNCTION_RENAMING_DECLARATION);
+#line 1618 "AdaParser.cpp"
+				}
+				break;
+			}
+			case SEMI:
+			case IS:
+			{
+				is_separate_or_abstract_or_decl(f_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		subprog_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = subprog_decl_AST;
+}
+
+void AdaParser::generic_subp_inst() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST generic_subp_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(IS);
+	generic_inst();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	generic_subp_inst_AST = RefAdaAST(currentAST.root);
+	returnAST = generic_subp_inst_AST;
+}
+
+void AdaParser::formal_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		parameter_specification();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == SEMI)) {
+				match(SEMI);
+				parameter_specification();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop70;
+			}
+			
+		}
+		_loop70:;
+		} // ( ... )*
+		match(RPAREN);
+		break;
+	}
+	case SEMI:
+	case IS:
+	case RENAMES:
+	case WHEN:
+	case DO:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 235 "ada.g"
+		formal_part_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(formal_part_opt_AST))));
+#line 1723 "AdaParser.cpp"
+		currentAST.root = formal_part_opt_AST;
+		if ( formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = formal_part_opt_AST->getFirstChild();
+		else
+			currentAST.child = formal_part_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	formal_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = formal_part_opt_AST;
+}
+
+void AdaParser::renames() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST renames_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 258 "ada.g"
+	RefAdaAST dummy;
+#line 1742 "AdaParser.cpp"
+	
+	match(RENAMES);
+	{
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		name();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case CHAR_STRING:
+	{
+		dummy=definable_operator_symbol();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+#line 262 "ada.g"
+		pop_def_id();
+#line 1772 "AdaParser.cpp"
+	}
+	renames_AST = RefAdaAST(currentAST.root);
+	returnAST = renames_AST;
+}
+
+void AdaParser::is_separate_or_abstract_or_decl(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST is_separate_or_abstract_or_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case IS:
+	{
+		match(IS);
+		separate_or_abstract(t);
+		break;
+	}
+	case SEMI:
+	{
+		if ( inputState->guessing==0 ) {
+#line 305 "ada.g"
+			pop_def_id();
+				    if (t->getType() == AdaTokenTypes::PROCEDURE)
+				      Set(t, PROCEDURE_DECLARATION);
+				    else
+				      Set(t, FUNCTION_DECLARATION);
+				
+#line 1802 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = is_separate_or_abstract_or_decl_AST;
+}
+
+void AdaParser::def_designator(
+	boolean lib_level
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST def_designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 330 "ada.g"
+	RefAdaAST d;
+#line 1823 "AdaParser.cpp"
+	
+	if (((LA(1) == IDENTIFIER) && (_tokenSet_7.member(LA(2))))&&( lib_level )) {
+		compound_name();
+		if (inputState->guessing==0) {
+			n_AST = returnAST;
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 332 "ada.g"
+			push_def_id(n_AST);
+#line 1834 "AdaParser.cpp"
+		}
+		def_designator_AST = RefAdaAST(currentAST.root);
+	}
+	else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) {
+		d=designator();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 333 "ada.g"
+			push_def_id(d);
+#line 1846 "AdaParser.cpp"
+		}
+		def_designator_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = def_designator_AST;
+}
+
+void AdaParser::function_tail() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST function_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	func_formal_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RETURN);
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	function_tail_AST = RefAdaAST(currentAST.root);
+	returnAST = function_tail_AST;
+}
+
+void AdaParser::generic_inst() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST generic_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(NEW);
+	compound_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		value_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+#line 179 "ada.g"
+		pop_def_id();
+#line 1910 "AdaParser.cpp"
+	}
+	generic_inst_AST = RefAdaAST(currentAST.root);
+	returnAST = generic_inst_AST;
+}
+
+void AdaParser::value_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST value_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	value();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			value();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop445;
+		}
+		
+	}
+	_loop445:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		value_s_AST = RefAdaAST(currentAST.root);
+#line 1405 "ada.g"
+		value_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VALUES,"VALUES")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(value_s_AST))));
+#line 1945 "AdaParser.cpp"
+		currentAST.root = value_s_AST;
+		if ( value_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			value_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = value_s_AST->getFirstChild();
+		else
+			currentAST.child = value_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	value_s_AST = RefAdaAST(currentAST.root);
+	returnAST = value_s_AST;
+}
+
+void AdaParser::parenth_values() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST parenth_values_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(LPAREN);
+	value();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			value();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop46;
+		}
+		
+	}
+	_loop46:;
+	} // ( ... )*
+	match(RPAREN);
+	parenth_values_AST = RefAdaAST(currentAST.root);
+	returnAST = parenth_values_AST;
+}
+
+void AdaParser::value() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST value_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case OTHERS:
+	{
+		RefAdaAST tmp60_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp60_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp60_AST));
+		}
+		match(OTHERS);
+		match(RIGHT_SHAFT);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case PLUS:
+	case MINUS:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		ranged_expr_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case RIGHT_SHAFT:
+		{
+			RefAdaAST tmp62_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp62_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp62_AST));
+			}
+			match(RIGHT_SHAFT);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case COMMA:
+		case RPAREN:
+		case WITH:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	value_AST = RefAdaAST(currentAST.root);
+	returnAST = value_AST;
+}
+
+void AdaParser::ranged_expr_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST ranged_expr_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	ranged_expr();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PIPE)) {
+			RefAdaAST tmp63_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp63_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp63_AST));
+			}
+			match(PIPE);
+			ranged_expr();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop52;
+		}
+		
+	}
+	_loop52:;
+	} // ( ... )*
+	ranged_expr_s_AST = RefAdaAST(currentAST.root);
+	returnAST = ranged_expr_s_AST;
+}
+
+void AdaParser::ranged_expr() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST ranged_expr_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case DOT_DOT:
+	{
+		RefAdaAST tmp64_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp64_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp64_AST));
+		}
+		match(DOT_DOT);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case RANGE:
+	{
+		RefAdaAST tmp65_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp65_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp65_AST));
+		}
+		match(RANGE);
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case COMMA:
+	case RPAREN:
+	case RIGHT_SHAFT:
+	case WITH:
+	case PIPE:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	ranged_expr_AST = RefAdaAST(currentAST.root);
+	returnAST = ranged_expr_AST;
+}
+
+void AdaParser::simple_expression() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST simple_expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	signed_term();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PLUS:
+		{
+			RefAdaAST tmp66_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp66_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp66_AST));
+			}
+			match(PLUS);
+			signed_term();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case MINUS:
+		{
+			RefAdaAST tmp67_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp67_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST));
+			}
+			match(MINUS);
+			signed_term();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case CONCAT:
+		{
+			RefAdaAST tmp68_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp68_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp68_AST));
+			}
+			match(CONCAT);
+			signed_term();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop458;
+		}
+		}
+	}
+	_loop458:;
+	} // ( ... )*
+	simple_expression_AST = RefAdaAST(currentAST.root);
+	returnAST = simple_expression_AST;
+}
+
+void AdaParser::range() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched59 = false;
+	if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+		int _m59 = mark();
+		synPredMatched59 = true;
+		inputState->guessing++;
+		try {
+			{
+			range_dots();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched59 = false;
+		}
+		rewind(_m59);
+		inputState->guessing--;
+	}
+	if ( synPredMatched59 ) {
+		range_dots();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) {
+		range_attrib_ref();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	range_AST = RefAdaAST(currentAST.root);
+	returnAST = range_AST;
+}
+
+void AdaParser::range_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	r = LT(1);
+	if ( inputState->guessing == 0 ) {
+		r_AST = astFactory->create(r);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+	}
+	match(RANGE);
+	range();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 203 "ada.g"
+		Set(r_AST, RANGE_CONSTRAINT);
+#line 2287 "AdaParser.cpp"
+	}
+	range_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = range_constraint_AST;
+}
+
+void AdaParser::range_dots() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_dots_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	simple_expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	RefAdaAST tmp69_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp69_AST = astFactory->create(LT(1));
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp69_AST));
+	}
+	match(DOT_DOT);
+	simple_expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	range_dots_AST = RefAdaAST(currentAST.root);
+	returnAST = range_dots_AST;
+}
+
+void AdaParser::range_attrib_ref() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_attrib_ref_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	prefix();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(TIC);
+	r = LT(1);
+	if ( inputState->guessing == 0 ) {
+		r_AST = astFactory->create(r);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+	}
+	match(RANGE);
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+		break;
+	}
+	case SEMI:
+	case COMMA:
+	case RPAREN:
+	case RIGHT_SHAFT:
+	case WITH:
+	case RANGE:
+	case DIGITS:
+	case IS:
+	case PIPE:
+	case DOT_DOT:
+	case ASSIGN:
+	case THEN:
+	case LOOP:
+	case OR:
+	case AND:
+	case XOR:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+#line 219 "ada.g"
+		Set(r_AST, RANGE_ATTRIBUTE_REFERENCE);
+#line 2374 "AdaParser.cpp"
+	}
+	range_attrib_ref_AST = RefAdaAST(currentAST.root);
+	returnAST = range_attrib_ref_AST;
+}
+
+void AdaParser::prefix() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prefix_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp73_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp73_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST));
+	}
+	match(IDENTIFIER);
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case DOT:
+		{
+			RefAdaAST tmp74_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp74_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp74_AST));
+			}
+			match(DOT);
+			{
+			switch ( LA(1)) {
+			case ALL:
+			{
+				RefAdaAST tmp75_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp75_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp75_AST));
+				}
+				match(ALL);
+				break;
+			}
+			case IDENTIFIER:
+			{
+				RefAdaAST tmp76_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp76_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp76_AST));
+				}
+				match(IDENTIFIER);
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case LPAREN:
+		{
+			p = LT(1);
+			if ( inputState->guessing == 0 ) {
+				p_AST = astFactory->create(p);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+			}
+			match(LPAREN);
+			value_s();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			if ( inputState->guessing==0 ) {
+#line 228 "ada.g"
+				Set(p_AST, INDEXED_COMPONENT);
+#line 2450 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop66;
+		}
+		}
+	}
+	_loop66:;
+	} // ( ... )*
+	prefix_AST = RefAdaAST(currentAST.root);
+	returnAST = prefix_AST;
+}
+
+void AdaParser::parameter_specification() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST parameter_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	def_ids_colon();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	mode_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	init_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		parameter_specification_AST = RefAdaAST(currentAST.root);
+#line 240 "ada.g"
+		parameter_specification_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(parameter_specification_AST))));
+#line 2492 "AdaParser.cpp"
+		currentAST.root = parameter_specification_AST;
+		if ( parameter_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			parameter_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = parameter_specification_AST->getFirstChild();
+		else
+			currentAST.child = parameter_specification_AST;
+		currentAST.advanceChildToEnd();
+	}
+	parameter_specification_AST = RefAdaAST(currentAST.root);
+	returnAST = parameter_specification_AST;
+}
+
+void AdaParser::def_ids_colon() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST def_ids_colon_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	defining_identifier_list();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(COLON);
+	def_ids_colon_AST = RefAdaAST(currentAST.root);
+	returnAST = def_ids_colon_AST;
+}
+
+void AdaParser::mode_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST mode_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case IN:
+	{
+		RefAdaAST tmp79_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp79_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp79_AST));
+		}
+		match(IN);
+		{
+		switch ( LA(1)) {
+		case OUT:
+		{
+			RefAdaAST tmp80_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp80_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST));
+			}
+			match(OUT);
+			break;
+		}
+		case IDENTIFIER:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case OUT:
+	{
+		RefAdaAST tmp81_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp81_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp81_AST));
+		}
+		match(OUT);
+		break;
+	}
+	case ACCESS:
+	{
+		RefAdaAST tmp82_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp82_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp82_AST));
+		}
+		match(ACCESS);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		mode_opt_AST = RefAdaAST(currentAST.root);
+#line 255 "ada.g"
+		mode_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mode_opt_AST))));
+#line 2592 "AdaParser.cpp"
+		currentAST.root = mode_opt_AST;
+		if ( mode_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			mode_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = mode_opt_AST->getFirstChild();
+		else
+			currentAST.child = mode_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	mode_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = mode_opt_AST;
+}
+
+void AdaParser::init_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST init_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ASSIGN:
+	{
+		match(ASSIGN);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case RPAREN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		init_opt_AST = RefAdaAST(currentAST.root);
+#line 468 "ada.g"
+		init_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INIT_OPT,"INIT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(init_opt_AST))));
+#line 2636 "AdaParser.cpp"
+		currentAST.root = init_opt_AST;
+		if ( init_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			init_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = init_opt_AST->getFirstChild();
+		else
+			currentAST.child = init_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	init_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = init_opt_AST;
+}
+
+void AdaParser::defining_identifier_list() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST defining_identifier_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp84_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp84_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp84_AST));
+	}
+	match(IDENTIFIER);
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			RefAdaAST tmp86_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp86_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp86_AST));
+			}
+			match(IDENTIFIER);
+		}
+		else {
+			goto _loop75;
+		}
+		
+	}
+	_loop75:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		defining_identifier_list_AST = RefAdaAST(currentAST.root);
+#line 249 "ada.g"
+		defining_identifier_list_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFINING_IDENTIFIER_LIST,"DEFINING_IDENTIFIER_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(defining_identifier_list_AST))));
+#line 2683 "AdaParser.cpp"
+		currentAST.root = defining_identifier_list_AST;
+		if ( defining_identifier_list_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			defining_identifier_list_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = defining_identifier_list_AST->getFirstChild();
+		else
+			currentAST.child = defining_identifier_list_AST;
+		currentAST.advanceChildToEnd();
+	}
+	defining_identifier_list_AST = RefAdaAST(currentAST.root);
+	returnAST = defining_identifier_list_AST;
+}
+
+void AdaParser::name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 265 "ada.g"
+	RefAdaAST dummy;
+#line 2704 "AdaParser.cpp"
+	
+	RefAdaAST tmp87_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp87_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp87_AST));
+	}
+	match(IDENTIFIER);
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case DOT:
+		{
+			RefAdaAST tmp88_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp88_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp88_AST));
+			}
+			match(DOT);
+			{
+			switch ( LA(1)) {
+			case ALL:
+			{
+				RefAdaAST tmp89_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp89_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp89_AST));
+				}
+				match(ALL);
+				break;
+			}
+			case IDENTIFIER:
+			{
+				RefAdaAST tmp90_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp90_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp90_AST));
+				}
+				match(IDENTIFIER);
+				break;
+			}
+			case CHARACTER_LITERAL:
+			{
+				RefAdaAST tmp91_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp91_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp91_AST));
+				}
+				match(CHARACTER_LITERAL);
+				break;
+			}
+			case CHAR_STRING:
+			{
+				dummy=is_operator();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case LPAREN:
+		{
+			p = LT(1);
+			if ( inputState->guessing == 0 ) {
+				p_AST = astFactory->create(p);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+			}
+			match(LPAREN);
+			value_s();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			if ( inputState->guessing==0 ) {
+#line 273 "ada.g"
+				Set(p_AST, INDEXED_COMPONENT);
+#line 2787 "AdaParser.cpp"
+			}
+			break;
+		}
+		case TIC:
+		{
+			RefAdaAST tmp93_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp93_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp93_AST));
+			}
+			match(TIC);
+			attribute_id();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop84;
+		}
+		}
+	}
+	_loop84:;
+	} // ( ... )*
+	name_AST = RefAdaAST(currentAST.root);
+	returnAST = name_AST;
+}
+
+RefAdaAST  AdaParser::definable_operator_symbol() {
+#line 285 "ada.g"
+	RefAdaAST d;
+#line 2820 "AdaParser.cpp"
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST definable_operator_symbol_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  op = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if (!( definable_operator(LT(1)->getText().c_str()) ))
+		throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" definable_operator(LT(1)->getText().c_str()) ");
+	op = LT(1);
+	if ( inputState->guessing == 0 ) {
+		op_AST = astFactory->create(op);
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST));
+	}
+	match(CHAR_STRING);
+	if ( inputState->guessing==0 ) {
+#line 287 "ada.g"
+		op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
+#line 2838 "AdaParser.cpp"
+	}
+	definable_operator_symbol_AST = RefAdaAST(currentAST.root);
+	returnAST = definable_operator_symbol_AST;
+	return d;
+}
+
+RefAdaAST  AdaParser::is_operator() {
+#line 280 "ada.g"
+	RefAdaAST d;
+#line 2848 "AdaParser.cpp"
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST is_operator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  op = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if (!( is_operator_symbol(LT(1)->getText().c_str()) ))
+		throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(LT(1)->getText().c_str()) ");
+	op = LT(1);
+	if ( inputState->guessing == 0 ) {
+		op_AST = astFactory->create(op);
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST));
+	}
+	match(CHAR_STRING);
+	if ( inputState->guessing==0 ) {
+#line 282 "ada.g"
+		op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
+#line 2866 "AdaParser.cpp"
+	}
+	is_operator_AST = RefAdaAST(currentAST.root);
+	returnAST = is_operator_AST;
+	return d;
+}
+
+void AdaParser::parenthesized_primary() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST parenthesized_primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pp = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pp_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	pp = LT(1);
+	if ( inputState->guessing == 0 ) {
+		pp_AST = astFactory->create(pp);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pp_AST));
+	}
+	match(LPAREN);
+	{
+	if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
+		RefAdaAST tmp94_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp94_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp94_AST));
+		}
+		match(NuLL);
+		match(RECORD);
+	}
+	else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2)))) {
+		value_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		extension_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+#line 295 "ada.g"
+		Set(pp_AST, PARENTHESIZED_PRIMARY);
+#line 2915 "AdaParser.cpp"
+	}
+	parenthesized_primary_AST = RefAdaAST(currentAST.root);
+	returnAST = parenthesized_primary_AST;
+}
+
+void AdaParser::extension_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST extension_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case WITH:
+	{
+		match(WITH);
+		{
+		if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
+			RefAdaAST tmp98_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp98_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp98_AST));
+			}
+			match(NuLL);
+			match(RECORD);
+		}
+		else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
+			value_s();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		break;
+	}
+	case RPAREN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		extension_opt_AST = RefAdaAST(currentAST.root);
+#line 299 "ada.g"
+		extension_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTENSION_OPT,"EXTENSION_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(extension_opt_AST))));
+#line 2969 "AdaParser.cpp"
+		currentAST.root = extension_opt_AST;
+		if ( extension_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			extension_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = extension_opt_AST->getFirstChild();
+		else
+			currentAST.child = extension_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	extension_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = extension_opt_AST;
+}
+
+void AdaParser::separate_or_abstract(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST separate_or_abstract_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case SEPARATE:
+	{
+		match(SEPARATE);
+		if ( inputState->guessing==0 ) {
+#line 315 "ada.g"
+			pop_def_id();
+					  if (t->getType() == AdaTokenTypes::PROCEDURE)
+					    Set(t, PROCEDURE_BODY_STUB);
+					  else
+					    Set(t, FUNCTION_BODY_STUB);
+					
+#line 3001 "AdaParser.cpp"
+		}
+		break;
+	}
+	case ABSTRACT:
+	{
+		match(ABSTRACT);
+		if ( inputState->guessing==0 ) {
+#line 322 "ada.g"
+			pop_def_id();
+					  if (t->getType() == AdaTokenTypes::PROCEDURE)
+					    Set(t, ABSTRACT_PROCEDURE_DECLARATION);
+					  else
+					    Set(t, ABSTRACT_FUNCTION_DECLARATION);
+					
+#line 3016 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = separate_or_abstract_AST;
+}
+
+RefAdaAST  AdaParser::designator() {
+#line 336 "ada.g"
+	RefAdaAST d;
+#line 3031 "AdaParser.cpp"
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 336 "ada.g"
+	RefAdaAST op;
+#line 3039 "AdaParser.cpp"
+	
+	switch ( LA(1)) {
+	case CHAR_STRING:
+	{
+		op=definable_operator_symbol();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 338 "ada.g"
+			d = op;
+#line 3051 "AdaParser.cpp"
+		}
+		designator_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		n = LT(1);
+		if ( inputState->guessing == 0 ) {
+			n_AST = astFactory->create(n);
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+		}
+		match(IDENTIFIER);
+		if ( inputState->guessing==0 ) {
+#line 339 "ada.g"
+			d = n_AST;
+#line 3067 "AdaParser.cpp"
+		}
+		designator_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = designator_AST;
+	return d;
+}
+
+void AdaParser::func_formal_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST func_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		func_param();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == SEMI)) {
+				match(SEMI);
+				func_param();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop100;
+			}
+			
+		}
+		_loop100:;
+		} // ( ... )*
+		match(RPAREN);
+		break;
+	}
+	case RETURN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		func_formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 348 "ada.g"
+		func_formal_part_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_formal_part_opt_AST))));
+#line 3129 "AdaParser.cpp"
+		currentAST.root = func_formal_part_opt_AST;
+		if ( func_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			func_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = func_formal_part_opt_AST->getFirstChild();
+		else
+			currentAST.child = func_formal_part_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	func_formal_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = func_formal_part_opt_AST;
+}
+
+void AdaParser::func_param() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST func_param_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	def_ids_colon();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	in_access_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	init_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		func_param_AST = RefAdaAST(currentAST.root);
+#line 354 "ada.g"
+		func_param_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_param_AST))));
+#line 3168 "AdaParser.cpp"
+		currentAST.root = func_param_AST;
+		if ( func_param_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			func_param_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = func_param_AST->getFirstChild();
+		else
+			currentAST.child = func_param_AST;
+		currentAST.advanceChildToEnd();
+	}
+	func_param_AST = RefAdaAST(currentAST.root);
+	returnAST = func_param_AST;
+}
+
+void AdaParser::in_access_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST in_access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case IN:
+	{
+		RefAdaAST tmp105_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp105_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp105_AST));
+		}
+		match(IN);
+		break;
+	}
+	case ACCESS:
+	{
+		RefAdaAST tmp106_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp106_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp106_AST));
+		}
+		match(ACCESS);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		in_access_opt_AST = RefAdaAST(currentAST.root);
+#line 360 "ada.g"
+		in_access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(in_access_opt_AST))));
+#line 3222 "AdaParser.cpp"
+		currentAST.root = in_access_opt_AST;
+		if ( in_access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			in_access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = in_access_opt_AST->getFirstChild();
+		else
+			currentAST.child = in_access_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	in_access_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = in_access_opt_AST;
+}
+
+void AdaParser::pkg_spec_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST pkg_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	basic_declarative_items_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	private_declarative_items_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	end_id_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	pkg_spec_part_AST = RefAdaAST(currentAST.root);
+	returnAST = pkg_spec_part_AST;
+}
+
+void AdaParser::basic_declarative_items_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST basic_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case IDENTIFIER:
+		case USE:
+		case TYPE:
+		case PACKAGE:
+		case PROCEDURE:
+		case FUNCTION:
+		case TASK:
+		case PROTECTED:
+		case FOR:
+		case SUBTYPE:
+		case GENERIC:
+		{
+			basic_decl_item();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop114;
+		}
+		}
+	}
+	_loop114:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		basic_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+#line 385 "ada.g"
+		basic_declarative_items_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_opt_AST))));
+#line 3303 "AdaParser.cpp"
+		currentAST.root = basic_declarative_items_opt_AST;
+		if ( basic_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			basic_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = basic_declarative_items_opt_AST->getFirstChild();
+		else
+			currentAST.child = basic_declarative_items_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	basic_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = basic_declarative_items_opt_AST;
+}
+
+void AdaParser::private_declarative_items_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST private_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PRIVATE:
+	{
+		match(PRIVATE);
+		{ // ( ... )*
+		for (;;) {
+			switch ( LA(1)) {
+			case IDENTIFIER:
+			case USE:
+			case TYPE:
+			case PACKAGE:
+			case PROCEDURE:
+			case FUNCTION:
+			case TASK:
+			case PROTECTED:
+			case FOR:
+			case SUBTYPE:
+			case GENERIC:
+			{
+				basic_decl_item();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case PRAGMA:
+			{
+				pragma();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				goto _loop111;
+			}
+			}
+		}
+		_loop111:;
+		} // ( ... )*
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		private_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+#line 378 "ada.g"
+		private_declarative_items_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_DECLARATIVE_ITEMS_OPT,"PRIVATE_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_declarative_items_opt_AST))));
+#line 3380 "AdaParser.cpp"
+		currentAST.root = private_declarative_items_opt_AST;
+		if ( private_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			private_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = private_declarative_items_opt_AST->getFirstChild();
+		else
+			currentAST.child = private_declarative_items_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	private_declarative_items_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = private_declarative_items_opt_AST;
+}
+
+void AdaParser::end_id_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST end_id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	e = LT(1);
+	if ( inputState->guessing == 0 ) {
+		e_AST = astFactory->create(e);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+	}
+	match(END);
+	id_opt_aux();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1176 "ada.g"
+		Set(e_AST, END_ID_OPT);
+#line 3413 "AdaParser.cpp"
+	}
+	end_id_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = end_id_opt_AST;
+}
+
+void AdaParser::basic_decl_item() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST basic_decl_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case PACKAGE:
+	{
+		pkg = LT(1);
+		if ( inputState->guessing == 0 ) {
+			pkg_AST = astFactory->create(pkg);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+		}
+		match(PACKAGE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		spec_decl_part(pkg_AST);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		basic_decl_item_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case TASK:
+	{
+		tsk = LT(1);
+		if ( inputState->guessing == 0 ) {
+			tsk_AST = astFactory->create(tsk);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST));
+		}
+		match(TASK);
+		task_type_or_single_decl(tsk_AST);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		basic_decl_item_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PROTECTED:
+	{
+		pro = LT(1);
+		if ( inputState->guessing == 0 ) {
+			pro_AST = astFactory->create(pro);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST));
+		}
+		match(PROTECTED);
+		prot_type_or_single_decl(pro_AST);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		basic_decl_item_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PROCEDURE:
+	case FUNCTION:
+	{
+		subprog_decl(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		basic_decl_item_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	case USE:
+	case TYPE:
+	case FOR:
+	case SUBTYPE:
+	case GENERIC:
+	{
+		decl_common();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		basic_decl_item_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = basic_decl_item_AST;
+}
+
+void AdaParser::basic_declarative_items() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST basic_declarative_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )+
+	int _cnt117=0;
+	for (;;) {
+		switch ( LA(1)) {
+		case IDENTIFIER:
+		case USE:
+		case TYPE:
+		case PACKAGE:
+		case PROCEDURE:
+		case FUNCTION:
+		case TASK:
+		case PROTECTED:
+		case FOR:
+		case SUBTYPE:
+		case GENERIC:
+		{
+			basic_decl_item();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			if ( _cnt117>=1 ) { goto _loop117; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+		}
+		}
+		_cnt117++;
+	}
+	_loop117:;
+	}  // ( ... )+
+	if ( inputState->guessing==0 ) {
+		basic_declarative_items_AST = RefAdaAST(currentAST.root);
+#line 392 "ada.g"
+		basic_declarative_items_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_AST))));
+#line 3562 "AdaParser.cpp"
+		currentAST.root = basic_declarative_items_AST;
+		if ( basic_declarative_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			basic_declarative_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = basic_declarative_items_AST->getFirstChild();
+		else
+			currentAST.child = basic_declarative_items_AST;
+		currentAST.advanceChildToEnd();
+	}
+	basic_declarative_items_AST = RefAdaAST(currentAST.root);
+	returnAST = basic_declarative_items_AST;
+}
+
+void AdaParser::task_type_or_single_decl(
+	RefAdaAST tsk
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST task_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case TYPE:
+	{
+		match(TYPE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrim_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		task_definition_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 408 "ada.g"
+			Set(tsk, TASK_TYPE_DECLARATION);
+#line 3601 "AdaParser.cpp"
+		}
+		task_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		task_definition_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 410 "ada.g"
+			Set(tsk, SINGLE_TASK_DECLARATION);
+#line 3619 "AdaParser.cpp"
+		}
+		task_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = task_type_or_single_decl_AST;
+}
+
+void AdaParser::prot_type_or_single_decl(
+	RefAdaAST pro
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case TYPE:
+	{
+		match(TYPE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrim_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		protected_definition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 539 "ada.g"
+			Set(pro, PROTECTED_TYPE_DECLARATION);
+#line 3658 "AdaParser.cpp"
+		}
+		prot_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		protected_definition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 541 "ada.g"
+			Set(pro, SINGLE_PROTECTED_DECLARATION);
+#line 3676 "AdaParser.cpp"
+		}
+		prot_type_or_single_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = prot_type_or_single_decl_AST;
+}
+
+void AdaParser::decl_common() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST decl_common_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  erd = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST erd_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  ord = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST ord_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  od = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST od_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case TYPE:
+	{
+		t = LT(1);
+		if ( inputState->guessing == 0 ) {
+			t_AST = astFactory->create(t);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+		}
+		match(TYPE);
+		RefAdaAST tmp111_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp111_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST));
+		}
+		match(IDENTIFIER);
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			match(IS);
+			type_def(t_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case LPAREN:
+		{
+			{
+			switch ( LA(1)) {
+			case LPAREN:
+			{
+				discrim_part();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				{
+				switch ( LA(1)) {
+				case IS:
+				{
+					match(IS);
+					derived_or_private_or_record(t_AST, true);
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				case SEMI:
+				{
+					if ( inputState->guessing==0 ) {
+#line 587 "ada.g"
+						Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
+#line 3759 "AdaParser.cpp"
+					}
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				break;
+			}
+			case SEMI:
+			{
+				empty_discrim_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 590 "ada.g"
+					Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
+#line 3780 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(SEMI);
+		decl_common_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case SUBTYPE:
+	{
+		s = LT(1);
+		if ( inputState->guessing == 0 ) {
+			s_AST = astFactory->create(s);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+		}
+		match(SUBTYPE);
+		RefAdaAST tmp115_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp115_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST));
+		}
+		match(IDENTIFIER);
+		match(IS);
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 604 "ada.g"
+			Set(s_AST, SUBTYPE_DECLARATION);
+#line 3825 "AdaParser.cpp"
+		}
+		decl_common_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case GENERIC:
+	{
+		generic_decl(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		decl_common_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case USE:
+	{
+		use_clause();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		decl_common_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FOR:
+	{
+		r = LT(1);
+		if ( inputState->guessing == 0 ) {
+			r_AST = astFactory->create(r);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+		}
+		match(FOR);
+		{
+		bool synPredMatched184 = false;
+		if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) {
+			int _m184 = mark();
+			synPredMatched184 = true;
+			inputState->guessing++;
+			try {
+				{
+				local_enum_name();
+				match(USE);
+				match(LPAREN);
+				}
+			}
+			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+				synPredMatched184 = false;
+			}
+			rewind(_m184);
+			inputState->guessing--;
+		}
+		if ( synPredMatched184 ) {
+			local_enum_name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(USE);
+			enumeration_aggregate();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 609 "ada.g"
+				Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE);
+#line 3888 "AdaParser.cpp"
+			}
+		}
+		else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) {
+			subtype_mark();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(USE);
+			rep_spec_part(r_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		match(SEMI);
+		decl_common_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+		bool synPredMatched186 = false;
+		if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
+			int _m186 = mark();
+			synPredMatched186 = true;
+			inputState->guessing++;
+			try {
+				{
+				match(IDENTIFIER);
+				match(COLON);
+				match(EXCEPTION);
+				match(RENAMES);
+				}
+			}
+			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+				synPredMatched186 = false;
+			}
+			rewind(_m186);
+			inputState->guessing--;
+		}
+		if ( synPredMatched186 ) {
+			RefAdaAST tmp121_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp121_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp121_AST));
+			}
+			match(IDENTIFIER);
+			erd = LT(1);
+			if ( inputState->guessing == 0 ) {
+				erd_AST = astFactory->create(erd);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(erd_AST));
+			}
+			match(COLON);
+			match(EXCEPTION);
+			match(RENAMES);
+			compound_name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(SEMI);
+			if ( inputState->guessing==0 ) {
+#line 615 "ada.g"
+				Set(erd_AST, EXCEPTION_RENAMING_DECLARATION);
+#line 3954 "AdaParser.cpp"
+			}
+			decl_common_AST = RefAdaAST(currentAST.root);
+		}
+		else {
+			bool synPredMatched188 = false;
+			if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
+				int _m188 = mark();
+				synPredMatched188 = true;
+				inputState->guessing++;
+				try {
+					{
+					match(IDENTIFIER);
+					match(COLON);
+					subtype_mark();
+					match(RENAMES);
+					}
+				}
+				catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+					synPredMatched188 = false;
+				}
+				rewind(_m188);
+				inputState->guessing--;
+			}
+			if ( synPredMatched188 ) {
+				RefAdaAST tmp125_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp125_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST));
+				}
+				match(IDENTIFIER);
+				ord = LT(1);
+				if ( inputState->guessing == 0 ) {
+					ord_AST = astFactory->create(ord);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ord_AST));
+				}
+				match(COLON);
+				subtype_mark();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(RENAMES);
+				name();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(SEMI);
+				if ( inputState->guessing==0 ) {
+#line 618 "ada.g"
+					Set(ord_AST, OBJECT_RENAMING_DECLARATION);
+#line 4004 "AdaParser.cpp"
+				}
+				decl_common_AST = RefAdaAST(currentAST.root);
+			}
+			else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) {
+				defining_identifier_list();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				od = LT(1);
+				if ( inputState->guessing == 0 ) {
+					od_AST = astFactory->create(od);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(od_AST));
+				}
+				match(COLON);
+				{
+				if ((LA(1) == EXCEPTION)) {
+					match(EXCEPTION);
+					if ( inputState->guessing==0 ) {
+#line 621 "ada.g"
+						Set(od_AST, EXCEPTION_DECLARATION);
+#line 4025 "AdaParser.cpp"
+					}
+				}
+				else {
+					bool synPredMatched191 = false;
+					if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) {
+						int _m191 = mark();
+						synPredMatched191 = true;
+						inputState->guessing++;
+						try {
+							{
+							match(CONSTANT);
+							match(ASSIGN);
+							}
+						}
+						catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+							synPredMatched191 = false;
+						}
+						rewind(_m191);
+						inputState->guessing--;
+					}
+					if ( synPredMatched191 ) {
+						match(CONSTANT);
+						match(ASSIGN);
+						expression();
+						if (inputState->guessing==0) {
+							astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+						}
+						if ( inputState->guessing==0 ) {
+#line 623 "ada.g"
+							Set(od_AST, NUMBER_DECLARATION);
+#line 4056 "AdaParser.cpp"
+						}
+					}
+					else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) {
+						aliased_constant_opt();
+						if (inputState->guessing==0) {
+							astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+						}
+						{
+						switch ( LA(1)) {
+						case ARRAY:
+						{
+							array_type_definition(od_AST);
+							if (inputState->guessing==0) {
+								astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+							}
+							init_opt();
+							if (inputState->guessing==0) {
+								astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+							}
+							if ( inputState->guessing==0 ) {
+#line 626 "ada.g"
+								Set(od_AST, ARRAY_OBJECT_DECLARATION);
+#line 4079 "AdaParser.cpp"
+							}
+							break;
+						}
+						case IDENTIFIER:
+						{
+							subtype_ind();
+							if (inputState->guessing==0) {
+								astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+							}
+							init_opt();
+							if (inputState->guessing==0) {
+								astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+							}
+							if ( inputState->guessing==0 ) {
+#line 630 "ada.g"
+								Set(od_AST, OBJECT_DECLARATION);
+#line 4096 "AdaParser.cpp"
+							}
+							break;
+						}
+						default:
+						{
+							throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+						}
+						}
+						}
+					}
+				else {
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				match(SEMI);
+				decl_common_AST = RefAdaAST(currentAST.root);
+			}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}}
+	returnAST = decl_common_AST;
+}
+
+void AdaParser::discrim_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrim_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		discrim_part_text();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case IS:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		discrim_part_opt_AST = RefAdaAST(currentAST.root);
+#line 420 "ada.g"
+		discrim_part_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_opt_AST))));
+#line 4153 "AdaParser.cpp"
+		currentAST.root = discrim_part_opt_AST;
+		if ( discrim_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discrim_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discrim_part_opt_AST->getFirstChild();
+		else
+			currentAST.child = discrim_part_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discrim_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = discrim_part_opt_AST;
+}
+
+void AdaParser::task_definition_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST task_definition_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case IS:
+	{
+		match(IS);
+		task_items_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		private_task_items_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		end_id_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		task_definition_opt_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case SEMI:
+	{
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 415 "ada.g"
+			pop_def_id();
+#line 4197 "AdaParser.cpp"
+		}
+		task_definition_opt_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = task_definition_opt_AST;
+}
+
+void AdaParser::task_items_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PRAGMA)) {
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop138;
+		}
+		
+	}
+	_loop138:;
+	} // ( ... )*
+	entrydecls_repspecs_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		task_items_opt_AST = RefAdaAST(currentAST.root);
+#line 473 "ada.g"
+		task_items_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TASK_ITEMS_OPT,"TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(task_items_opt_AST))));
+#line 4239 "AdaParser.cpp"
+		currentAST.root = task_items_opt_AST;
+		if ( task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = task_items_opt_AST->getFirstChild();
+		else
+			currentAST.child = task_items_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	task_items_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = task_items_opt_AST;
+}
+
+void AdaParser::private_task_items_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST private_task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PRIVATE:
+	{
+		match(PRIVATE);
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == PRAGMA)) {
+				pragma();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop163;
+			}
+			
+		}
+		_loop163:;
+		} // ( ... )*
+		entrydecls_repspecs_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		private_task_items_opt_AST = RefAdaAST(currentAST.root);
+#line 530 "ada.g"
+		private_task_items_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_TASK_ITEMS_OPT,"PRIVATE_TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_task_items_opt_AST))));
+#line 4298 "AdaParser.cpp"
+		currentAST.root = private_task_items_opt_AST;
+		if ( private_task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			private_task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = private_task_items_opt_AST->getFirstChild();
+		else
+			currentAST.child = private_task_items_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	private_task_items_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = private_task_items_opt_AST;
+}
+
+void AdaParser::discrim_part_text() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrim_part_text_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(LPAREN);
+	{
+	switch ( LA(1)) {
+	case BOX:
+	{
+		RefAdaAST tmp137_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp137_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST));
+		}
+		match(BOX);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		discriminant_specifications();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(RPAREN);
+	discrim_part_text_AST = RefAdaAST(currentAST.root);
+	returnAST = discrim_part_text_AST;
+}
+
+void AdaParser::discriminant_specifications() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminant_specifications_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	discriminant_specification();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == SEMI)) {
+			match(SEMI);
+			discriminant_specification();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop130;
+		}
+		
+	}
+	_loop130:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		discriminant_specifications_AST = RefAdaAST(currentAST.root);
+#line 450 "ada.g"
+		discriminant_specifications_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATIONS,"DISCRIMINANT_SPECIFICATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specifications_AST))));
+#line 4378 "AdaParser.cpp"
+		currentAST.root = discriminant_specifications_AST;
+		if ( discriminant_specifications_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discriminant_specifications_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discriminant_specifications_AST->getFirstChild();
+		else
+			currentAST.child = discriminant_specifications_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discriminant_specifications_AST = RefAdaAST(currentAST.root);
+	returnAST = discriminant_specifications_AST;
+}
+
+void AdaParser::known_discrim_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST known_discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(LPAREN);
+	discriminant_specifications();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+		known_discrim_part_AST = RefAdaAST(currentAST.root);
+#line 430 "ada.g"
+		known_discrim_part_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(known_discrim_part_AST))));
+#line 4407 "AdaParser.cpp"
+		currentAST.root = known_discrim_part_AST;
+		if ( known_discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			known_discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = known_discrim_part_AST->getFirstChild();
+		else
+			currentAST.child = known_discrim_part_AST;
+		currentAST.advanceChildToEnd();
+	}
+	known_discrim_part_AST = RefAdaAST(currentAST.root);
+	returnAST = known_discrim_part_AST;
+}
+
+void AdaParser::empty_discrim_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST empty_discrim_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if ( inputState->guessing==0 ) {
+		empty_discrim_opt_AST = RefAdaAST(currentAST.root);
+#line 436 "ada.g"
+		empty_discrim_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_discrim_opt_AST))));
+#line 4430 "AdaParser.cpp"
+		currentAST.root = empty_discrim_opt_AST;
+		if ( empty_discrim_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			empty_discrim_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = empty_discrim_opt_AST->getFirstChild();
+		else
+			currentAST.child = empty_discrim_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	empty_discrim_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = empty_discrim_opt_AST;
+}
+
+void AdaParser::discrim_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	discrim_part_text();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		discrim_part_AST = RefAdaAST(currentAST.root);
+#line 443 "ada.g"
+		discrim_part_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_AST))));
+#line 4457 "AdaParser.cpp"
+		currentAST.root = discrim_part_AST;
+		if ( discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discrim_part_AST->getFirstChild();
+		else
+			currentAST.child = discrim_part_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discrim_part_AST = RefAdaAST(currentAST.root);
+	returnAST = discrim_part_AST;
+}
+
+void AdaParser::discriminant_specification() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminant_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	def_ids_colon();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	access_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	init_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		discriminant_specification_AST = RefAdaAST(currentAST.root);
+#line 457 "ada.g"
+		discriminant_specification_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATION,"DISCRIMINANT_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specification_AST))));
+#line 4496 "AdaParser.cpp"
+		currentAST.root = discriminant_specification_AST;
+		if ( discriminant_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discriminant_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discriminant_specification_AST->getFirstChild();
+		else
+			currentAST.child = discriminant_specification_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discriminant_specification_AST = RefAdaAST(currentAST.root);
+	returnAST = discriminant_specification_AST;
+}
+
+void AdaParser::access_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ACCESS:
+	{
+		RefAdaAST tmp142_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp142_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp142_AST));
+		}
+		match(ACCESS);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		access_opt_AST = RefAdaAST(currentAST.root);
+#line 464 "ada.g"
+		access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(access_opt_AST))));
+#line 4540 "AdaParser.cpp"
+		currentAST.root = access_opt_AST;
+		if ( access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = access_opt_AST->getFirstChild();
+		else
+			currentAST.child = access_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	access_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = access_opt_AST;
+}
+
+void AdaParser::entrydecls_repspecs_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entrydecls_repspecs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == ENTRY)) {
+			entry_declaration();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				switch ( LA(1)) {
+				case PRAGMA:
+				{
+					pragma();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				case FOR:
+				{
+					rep_spec();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				default:
+				{
+					goto _loop142;
+				}
+				}
+			}
+			_loop142:;
+			} // ( ... )*
+		}
+		else {
+			goto _loop143;
+		}
+		
+	}
+	_loop143:;
+	} // ( ... )*
+	entrydecls_repspecs_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = entrydecls_repspecs_opt_AST;
+}
+
+void AdaParser::entry_declaration() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_declaration_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	e = LT(1);
+	if ( inputState->guessing == 0 ) {
+		e_AST = astFactory->create(e);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+	}
+	match(ENTRY);
+	RefAdaAST tmp143_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp143_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp143_AST));
+	}
+	match(IDENTIFIER);
+	discrete_subtype_def_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	formal_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 482 "ada.g"
+		Set (e_AST, ENTRY_DECLARATION);
+#line 4635 "AdaParser.cpp"
+	}
+	entry_declaration_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_declaration_AST;
+}
+
+void AdaParser::rep_spec() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST rep_spec_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	r = LT(1);
+	if ( inputState->guessing == 0 ) {
+		r_AST = astFactory->create(r);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+	}
+	match(FOR);
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(USE);
+	rep_spec_part(r_AST);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	rep_spec_AST = RefAdaAST(currentAST.root);
+	returnAST = rep_spec_AST;
+}
+
+void AdaParser::discrete_subtype_def_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrete_subtype_def_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched148 = false;
+	if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+		int _m148 = mark();
+		synPredMatched148 = true;
+		inputState->guessing++;
+		try {
+			{
+			match(LPAREN);
+			discrete_subtype_definition();
+			match(RPAREN);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched148 = false;
+		}
+		rewind(_m148);
+		inputState->guessing--;
+	}
+	if ( synPredMatched148 ) {
+		match(LPAREN);
+		discrete_subtype_definition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+	}
+	else if ((LA(1) == SEMI || LA(1) == LPAREN) && (_tokenSet_14.member(LA(2)))) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	if ( inputState->guessing==0 ) {
+		discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root);
+#line 489 "ada.g"
+		discrete_subtype_def_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,"DISCRETE_SUBTYPE_DEF_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrete_subtype_def_opt_AST))));
+#line 4712 "AdaParser.cpp"
+		currentAST.root = discrete_subtype_def_opt_AST;
+		if ( discrete_subtype_def_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discrete_subtype_def_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discrete_subtype_def_opt_AST->getFirstChild();
+		else
+			currentAST.child = discrete_subtype_def_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = discrete_subtype_def_opt_AST;
+}
+
+void AdaParser::discrete_subtype_definition() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrete_subtype_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched152 = false;
+	if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+		int _m152 = mark();
+		synPredMatched152 = true;
+		inputState->guessing++;
+		try {
+			{
+			range();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched152 = false;
+		}
+		rewind(_m152);
+		inputState->guessing--;
+	}
+	if ( synPredMatched152 ) {
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else if ((LA(1) == IDENTIFIER) && (_tokenSet_15.member(LA(2)))) {
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	discrete_subtype_definition_AST = RefAdaAST(currentAST.root);
+	returnAST = discrete_subtype_definition_AST;
+}
+
+void AdaParser::subtype_ind() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subtype_ind_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	constraint_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		subtype_ind_AST = RefAdaAST(currentAST.root);
+#line 693 "ada.g"
+		subtype_ind_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SUBTYPE_INDICATION,"SUBTYPE_INDICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(subtype_ind_AST))));
+#line 4785 "AdaParser.cpp"
+		currentAST.root = subtype_ind_AST;
+		if ( subtype_ind_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			subtype_ind_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = subtype_ind_AST->getFirstChild();
+		else
+			currentAST.child = subtype_ind_AST;
+		currentAST.advanceChildToEnd();
+	}
+	subtype_ind_AST = RefAdaAST(currentAST.root);
+	returnAST = subtype_ind_AST;
+}
+
+void AdaParser::rep_spec_part(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST rep_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case RECORD:
+	{
+		match(RECORD);
+		align_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		comp_loc_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(END);
+		match(RECORD);
+		if ( inputState->guessing==0 ) {
+#line 512 "ada.g"
+			Set(t, RECORD_REPRESENTATION_CLAUSE);
+#line 4822 "AdaParser.cpp"
+		}
+		rep_spec_part_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case AT:
+	{
+		match(AT);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 514 "ada.g"
+			Set(t, AT_CLAUSE);
+#line 4837 "AdaParser.cpp"
+		}
+		rep_spec_part_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case PLUS:
+	case MINUS:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 517 "ada.g"
+			Set(t, ATTRIBUTE_DEFINITION_CLAUSE);
+#line 4861 "AdaParser.cpp"
+		}
+		rep_spec_part_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = rep_spec_part_AST;
+}
+
+void AdaParser::align_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST align_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case AT:
+	{
+		match(AT);
+		match(MOD);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		break;
+	}
+	case PRAGMA:
+	case IDENTIFIER:
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		align_opt_AST = RefAdaAST(currentAST.root);
+#line 521 "ada.g"
+		align_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MOD_CLAUSE_OPT,"MOD_CLAUSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(align_opt_AST))));
+#line 4908 "AdaParser.cpp"
+		currentAST.root = align_opt_AST;
+		if ( align_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			align_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = align_opt_AST->getFirstChild();
+		else
+			currentAST.child = align_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	align_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = align_opt_AST;
+}
+
+void AdaParser::comp_loc_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST comp_loc_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		{
+			subtype_mark();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(AT);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RANGE);
+			range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(SEMI);
+			break;
+		}
+		default:
+		{
+			goto _loop159;
+		}
+		}
+	}
+	_loop159:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		comp_loc_s_AST = RefAdaAST(currentAST.root);
+#line 525 "ada.g"
+		comp_loc_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_CLAUSES_OPT,"COMPONENT_CLAUSES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_loc_s_AST))));
+#line 4968 "AdaParser.cpp"
+		currentAST.root = comp_loc_s_AST;
+		if ( comp_loc_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			comp_loc_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = comp_loc_s_AST->getFirstChild();
+		else
+			currentAST.child = comp_loc_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	comp_loc_s_AST = RefAdaAST(currentAST.root);
+	returnAST = comp_loc_s_AST;
+}
+
+void AdaParser::protected_definition() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST protected_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(IS);
+	prot_op_decl_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	prot_private_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	end_id_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	protected_definition_AST = RefAdaAST(currentAST.root);
+	returnAST = protected_definition_AST;
+}
+
+void AdaParser::prot_private_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PRIVATE:
+	{
+		match(PRIVATE);
+		{ // ( ... )*
+		for (;;) {
+			switch ( LA(1)) {
+			case PRAGMA:
+			case PROCEDURE:
+			case FUNCTION:
+			case ENTRY:
+			case FOR:
+			{
+				prot_op_decl();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case IDENTIFIER:
+			{
+				comp_decl();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				goto _loop168;
+			}
+			}
+		}
+		_loop168:;
+		} // ( ... )*
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		prot_private_opt_AST = RefAdaAST(currentAST.root);
+#line 545 "ada.g"
+		prot_private_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_PRIVATE_OPT,"PROT_PRIVATE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_private_opt_AST))));
+#line 5061 "AdaParser.cpp"
+		currentAST.root = prot_private_opt_AST;
+		if ( prot_private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			prot_private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = prot_private_opt_AST->getFirstChild();
+		else
+			currentAST.child = prot_private_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	prot_private_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = prot_private_opt_AST;
+}
+
+void AdaParser::prot_op_decl() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_op_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case ENTRY:
+	{
+		entry_declaration();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		prot_op_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PROCEDURE:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PROCEDURE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		formal_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 561 "ada.g"
+			pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
+#line 5113 "AdaParser.cpp"
+		}
+		prot_op_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FUNCTION:
+	{
+		f = LT(1);
+		if ( inputState->guessing == 0 ) {
+			f_AST = astFactory->create(f);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+		}
+		match(FUNCTION);
+		def_designator(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		function_tail();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 563 "ada.g"
+			pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
+#line 5138 "AdaParser.cpp"
+		}
+		prot_op_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FOR:
+	{
+		rep_spec();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		prot_op_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PRAGMA:
+	{
+		pragma();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		prot_op_decl_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = prot_op_decl_AST;
+}
+
+void AdaParser::comp_decl() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST comp_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	def_ids_colon();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	component_subtype_def();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	init_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+		comp_decl_AST = RefAdaAST(currentAST.root);
+#line 575 "ada.g"
+		comp_decl_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_DECLARATION,"COMPONENT_DECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_decl_AST))));
+#line 5192 "AdaParser.cpp"
+		currentAST.root = comp_decl_AST;
+		if ( comp_decl_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			comp_decl_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = comp_decl_AST->getFirstChild();
+		else
+			currentAST.child = comp_decl_AST;
+		currentAST.advanceChildToEnd();
+	}
+	comp_decl_AST = RefAdaAST(currentAST.root);
+	returnAST = comp_decl_AST;
+}
+
+void AdaParser::prot_op_decl_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_op_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		if ((_tokenSet_16.member(LA(1)))) {
+			prot_op_decl();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop172;
+		}
+		
+	}
+	_loop172:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		prot_op_decl_s_AST = RefAdaAST(currentAST.root);
+#line 555 "ada.g"
+		prot_op_decl_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_DECLARATIONS,"PROT_OP_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_decl_s_AST))));
+#line 5229 "AdaParser.cpp"
+		currentAST.root = prot_op_decl_s_AST;
+		if ( prot_op_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			prot_op_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = prot_op_decl_s_AST->getFirstChild();
+		else
+			currentAST.child = prot_op_decl_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	prot_op_decl_s_AST = RefAdaAST(currentAST.root);
+	returnAST = prot_op_decl_s_AST;
+}
+
+void AdaParser::prot_member_decl_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_member_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		case PROCEDURE:
+		case FUNCTION:
+		case ENTRY:
+		case FOR:
+		{
+			prot_op_decl();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		{
+			comp_decl();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop176;
+		}
+		}
+	}
+	_loop176:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		prot_member_decl_s_AST = RefAdaAST(currentAST.root);
+#line 569 "ada.g"
+		prot_member_decl_s_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_MEMBER_DECLARATIONS,"PROT_MEMBER_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_member_decl_s_AST))));
+#line 5283 "AdaParser.cpp"
+		currentAST.root = prot_member_decl_s_AST;
+		if ( prot_member_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			prot_member_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = prot_member_decl_s_AST->getFirstChild();
+		else
+			currentAST.child = prot_member_decl_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	prot_member_decl_s_AST = RefAdaAST(currentAST.root);
+	returnAST = prot_member_decl_s_AST;
+}
+
+void AdaParser::component_subtype_def() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST component_subtype_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	aliased_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	subtype_ind();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	component_subtype_def_AST = RefAdaAST(currentAST.root);
+	returnAST = component_subtype_def_AST;
+}
+
+void AdaParser::type_def(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST type_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		enum_id_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+		if ( inputState->guessing==0 ) {
+#line 638 "ada.g"
+			Set(t, ENUMERATION_TYPE_DECLARATION);
+#line 5332 "AdaParser.cpp"
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case RANGE:
+	{
+		match(RANGE);
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 640 "ada.g"
+			Set(t, SIGNED_INTEGER_TYPE_DECLARATION);
+#line 5347 "AdaParser.cpp"
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case MOD:
+	{
+		match(MOD);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 642 "ada.g"
+			Set(t, MODULAR_TYPE_DECLARATION);
+#line 5362 "AdaParser.cpp"
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case DIGITS:
+	{
+		match(DIGITS);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		range_constraint_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 644 "ada.g"
+			Set(t, FLOATING_POINT_DECLARATION);
+#line 5381 "AdaParser.cpp"
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case DELTA:
+	{
+		match(DELTA);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case RANGE:
+		{
+			match(RANGE);
+			range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 647 "ada.g"
+				Set(t, ORDINARY_FIXED_POINT_DECLARATION);
+#line 5405 "AdaParser.cpp"
+			}
+			break;
+		}
+		case DIGITS:
+		{
+			match(DIGITS);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			range_constraint_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 649 "ada.g"
+				Set(t, DECIMAL_FIXED_POINT_DECLARATION);
+#line 5423 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case ARRAY:
+	{
+		array_type_definition(t);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case ACCESS:
+	{
+		access_type_definition(t);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PRIVATE:
+	case NEW:
+	case NuLL:
+	case RECORD:
+	case ABSTRACT:
+	case TAGGED:
+	case LIMITED:
+	{
+		empty_discrim_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		derived_or_private_or_record(t, false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		type_def_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = type_def_AST;
+}
+
+void AdaParser::derived_or_private_or_record(
+	RefAdaAST t, boolean has_discrim
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST derived_or_private_or_record_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	bool synPredMatched246 = false;
+	if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
+		int _m246 = mark();
+		synPredMatched246 = true;
+		inputState->guessing++;
+		try {
+			{
+			{
+			switch ( LA(1)) {
+			case ABSTRACT:
+			{
+				match(ABSTRACT);
+				break;
+			}
+			case NEW:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(NEW);
+			subtype_ind();
+			match(WITH);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched246 = false;
+		}
+		rewind(_m246);
+		inputState->guessing--;
+	}
+	if ( synPredMatched246 ) {
+		abstract_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(NEW);
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(WITH);
+		{
+		switch ( LA(1)) {
+		case PRIVATE:
+		{
+			match(PRIVATE);
+			if ( inputState->guessing==0 ) {
+#line 772 "ada.g"
+				Set(t, PRIVATE_EXTENSION_DECLARATION);
+#line 5542 "AdaParser.cpp"
+			}
+			break;
+		}
+		case NuLL:
+		case RECORD:
+		{
+			record_definition(has_discrim);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 774 "ada.g"
+				Set(t, DERIVED_RECORD_EXTENSION);
+#line 5556 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
+		match(NEW);
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 776 "ada.g"
+			Set(t, ORDINARY_DERIVED_TYPE_DECLARATION);
+#line 5577 "AdaParser.cpp"
+		}
+		derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
+		abstract_tagged_limited_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case PRIVATE:
+		{
+			match(PRIVATE);
+			if ( inputState->guessing==0 ) {
+#line 778 "ada.g"
+				Set(t, PRIVATE_TYPE_DECLARATION);
+#line 5594 "AdaParser.cpp"
+			}
+			break;
+		}
+		case NuLL:
+		case RECORD:
+		{
+			record_definition(has_discrim);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 780 "ada.g"
+				Set(t, RECORD_TYPE_DECLARATION);
+#line 5608 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		derived_or_private_or_record_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = derived_or_private_or_record_AST;
+}
+
+void AdaParser::local_enum_name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST local_enum_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp177_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp177_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp177_AST));
+	}
+	match(IDENTIFIER);
+	local_enum_name_AST = RefAdaAST(currentAST.root);
+	returnAST = local_enum_name_AST;
+}
+
+void AdaParser::enumeration_aggregate() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST enumeration_aggregate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	parenth_values();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	enumeration_aggregate_AST = RefAdaAST(currentAST.root);
+	returnAST = enumeration_aggregate_AST;
+}
+
+void AdaParser::aliased_constant_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST aliased_constant_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ALIASED:
+	{
+		RefAdaAST tmp178_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp178_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp178_AST));
+		}
+		match(ALIASED);
+		break;
+	}
+	case IDENTIFIER:
+	case CONSTANT:
+	case ARRAY:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	{
+	switch ( LA(1)) {
+	case CONSTANT:
+	{
+		RefAdaAST tmp179_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp179_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp179_AST));
+		}
+		match(CONSTANT);
+		break;
+	}
+	case IDENTIFIER:
+	case ARRAY:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		aliased_constant_opt_AST = RefAdaAST(currentAST.root);
+#line 858 "ada.g"
+		aliased_constant_opt_AST =
+			  RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_constant_opt_AST))));
+#line 5712 "AdaParser.cpp"
+		currentAST.root = aliased_constant_opt_AST;
+		if ( aliased_constant_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			aliased_constant_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = aliased_constant_opt_AST->getFirstChild();
+		else
+			currentAST.child = aliased_constant_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	aliased_constant_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = aliased_constant_opt_AST;
+}
+
+void AdaParser::array_type_definition(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST array_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(ARRAY);
+	match(LPAREN);
+	index_or_discrete_range_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RPAREN);
+	match(OF);
+	component_subtype_def();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 669 "ada.g"
+		Set(t, ARRAY_TYPE_DECLARATION);
+#line 5747 "AdaParser.cpp"
+	}
+	array_type_definition_AST = RefAdaAST(currentAST.root);
+	returnAST = array_type_definition_AST;
+}
+
+void AdaParser::enum_id_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST enum_id_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	enumeration_literal_specification();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			enumeration_literal_specification();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop197;
+		}
+		
+	}
+	_loop197:;
+	} // ( ... )*
+	enum_id_s_AST = RefAdaAST(currentAST.root);
+	returnAST = enum_id_s_AST;
+}
+
+void AdaParser::range_constraint_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case RANGE:
+	{
+		range_constraint();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case COMMA:
+	case RPAREN:
+	case WITH:
+	case ASSIGN:
+	case LOOP:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	range_constraint_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = range_constraint_opt_AST;
+}
+
+void AdaParser::access_type_definition(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST access_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(ACCESS);
+	{
+	switch ( LA(1)) {
+	case PROCEDURE:
+	case FUNCTION:
+	case PROTECTED:
+	{
+		protected_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case PROCEDURE:
+		{
+			match(PROCEDURE);
+			formal_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 751 "ada.g"
+				Set(t, ACCESS_TO_PROCEDURE_DECLARATION);
+#line 5846 "AdaParser.cpp"
+			}
+			break;
+		}
+		case FUNCTION:
+		{
+			match(FUNCTION);
+			func_formal_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RETURN);
+			subtype_mark();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 753 "ada.g"
+				Set(t, ACCESS_TO_FUNCTION_DECLARATION);
+#line 5865 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case IDENTIFIER:
+	case ALL:
+	case CONSTANT:
+	{
+		constant_all_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 756 "ada.g"
+			Set(t, ACCESS_TO_OBJECT_DECLARATION);
+#line 5892 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	access_type_definition_AST = RefAdaAST(currentAST.root);
+	returnAST = access_type_definition_AST;
+}
+
+void AdaParser::enumeration_literal_specification() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST enumeration_literal_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		RefAdaAST tmp189_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp189_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp189_AST));
+		}
+		match(IDENTIFIER);
+		enumeration_literal_specification_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case CHARACTER_LITERAL:
+	{
+		RefAdaAST tmp190_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp190_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp190_AST));
+		}
+		match(CHARACTER_LITERAL);
+		enumeration_literal_specification_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = enumeration_literal_specification_AST;
+}
+
+void AdaParser::index_or_discrete_range_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST index_or_discrete_range_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	index_or_discrete_range();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			RefAdaAST tmp191_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp191_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp191_AST));
+			}
+			match(COMMA);
+			index_or_discrete_range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop204;
+		}
+		
+	}
+	_loop204:;
+	} // ( ... )*
+	index_or_discrete_range_s_AST = RefAdaAST(currentAST.root);
+	returnAST = index_or_discrete_range_s_AST;
+}
+
+void AdaParser::index_or_discrete_range() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST index_or_discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	simple_expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case DOT_DOT:
+	{
+		RefAdaAST tmp192_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp192_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp192_AST));
+		}
+		match(DOT_DOT);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case RANGE:
+	{
+		RefAdaAST tmp193_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp193_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp193_AST));
+		}
+		match(RANGE);
+		{
+		switch ( LA(1)) {
+		case BOX:
+		{
+			RefAdaAST tmp194_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp194_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp194_AST));
+			}
+			match(BOX);
+			break;
+		}
+		case IDENTIFIER:
+		case LPAREN:
+		case NEW:
+		case CHARACTER_LITERAL:
+		case CHAR_STRING:
+		case NuLL:
+		case NOT:
+		case PLUS:
+		case MINUS:
+		case ABS:
+		case NUMERIC_LIT:
+		{
+			range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case COMMA:
+	case RPAREN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	index_or_discrete_range_AST = RefAdaAST(currentAST.root);
+	returnAST = index_or_discrete_range_AST;
+}
+
+void AdaParser::aliased_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST aliased_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ALIASED:
+	{
+		RefAdaAST tmp195_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp195_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp195_AST));
+		}
+		match(ALIASED);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		aliased_opt_AST = RefAdaAST(currentAST.root);
+#line 689 "ada.g"
+		aliased_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_opt_AST))));
+#line 6093 "AdaParser.cpp"
+		currentAST.root = aliased_opt_AST;
+		if ( aliased_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			aliased_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = aliased_opt_AST->getFirstChild();
+		else
+			currentAST.child = aliased_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	aliased_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = aliased_opt_AST;
+}
+
+void AdaParser::constraint_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case RANGE:
+	{
+		range_constraint();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case DIGITS:
+	{
+		digits_constraint();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case DELTA:
+	{
+		delta_constraint();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case COMMA:
+	case RPAREN:
+	case WITH:
+	case ASSIGN:
+	case LOOP:
+	{
+		break;
+	}
+	default:
+		bool synPredMatched215 = false;
+		if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+			int _m215 = mark();
+			synPredMatched215 = true;
+			inputState->guessing++;
+			try {
+				{
+				index_constraint();
+				}
+			}
+			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+				synPredMatched215 = false;
+			}
+			rewind(_m215);
+			inputState->guessing--;
+		}
+		if ( synPredMatched215 ) {
+			index_constraint();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else if ((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2)))) {
+			discriminant_constraint();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	constraint_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = constraint_opt_AST;
+}
+
+void AdaParser::digits_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST digits_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	d = LT(1);
+	if ( inputState->guessing == 0 ) {
+		d_AST = astFactory->create(d);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+	}
+	match(DIGITS);
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	range_constraint_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 706 "ada.g"
+		Set(d_AST, DIGITS_CONSTRAINT);
+#line 6208 "AdaParser.cpp"
+	}
+	digits_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = digits_constraint_AST;
+}
+
+void AdaParser::delta_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST delta_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	d = LT(1);
+	if ( inputState->guessing == 0 ) {
+		d_AST = astFactory->create(d);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+	}
+	match(DELTA);
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	range_constraint_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 710 "ada.g"
+		Set(d_AST, DELTA_CONSTRAINT);
+#line 6238 "AdaParser.cpp"
+	}
+	delta_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = delta_constraint_AST;
+}
+
+void AdaParser::index_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST index_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	p = LT(1);
+	if ( inputState->guessing == 0 ) {
+		p_AST = astFactory->create(p);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+	}
+	match(LPAREN);
+	discrete_range();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			discrete_range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop220;
+		}
+		
+	}
+	_loop220:;
+	} // ( ... )*
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+#line 714 "ada.g"
+		Set(p_AST, INDEX_CONSTRAINT);
+#line 6281 "AdaParser.cpp"
+	}
+	index_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = index_constraint_AST;
+}
+
+void AdaParser::discriminant_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminant_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	p = LT(1);
+	if ( inputState->guessing == 0 ) {
+		p_AST = astFactory->create(p);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+	}
+	match(LPAREN);
+	discriminant_association();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			discriminant_association();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop226;
+		}
+		
+	}
+	_loop226:;
+	} // ( ... )*
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+#line 724 "ada.g"
+		Set(p_AST, DISCRIMINANT_CONSTRAINT);
+#line 6324 "AdaParser.cpp"
+	}
+	discriminant_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = discriminant_constraint_AST;
+}
+
+void AdaParser::discrete_range() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	bool synPredMatched223 = false;
+	if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+		int _m223 = mark();
+		synPredMatched223 = true;
+		inputState->guessing++;
+		try {
+			{
+			range();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched223 = false;
+		}
+		rewind(_m223);
+		inputState->guessing--;
+	}
+	if ( synPredMatched223 ) {
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrete_range_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((LA(1) == IDENTIFIER) && (_tokenSet_19.member(LA(2)))) {
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrete_range_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = discrete_range_AST;
+}
+
+void AdaParser::discriminant_association() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminant_association_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	selector_names_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		discriminant_association_AST = RefAdaAST(currentAST.root);
+#line 728 "ada.g"
+		discriminant_association_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_ASSOCIATION,"DISCRIMINANT_ASSOCIATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_association_AST))));
+#line 6390 "AdaParser.cpp"
+		currentAST.root = discriminant_association_AST;
+		if ( discriminant_association_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			discriminant_association_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = discriminant_association_AST->getFirstChild();
+		else
+			currentAST.child = discriminant_association_AST;
+		currentAST.advanceChildToEnd();
+	}
+	discriminant_association_AST = RefAdaAST(currentAST.root);
+	returnAST = discriminant_association_AST;
+}
+
+void AdaParser::selector_names_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST selector_names_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched231 = false;
+	if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) {
+		int _m231 = mark();
+		synPredMatched231 = true;
+		inputState->guessing++;
+		try {
+			{
+			association_head();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched231 = false;
+		}
+		rewind(_m231);
+		inputState->guessing--;
+	}
+	if ( synPredMatched231 ) {
+		association_head();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+	}
+	else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	if ( inputState->guessing==0 ) {
+		selector_names_opt_AST = RefAdaAST(currentAST.root);
+#line 736 "ada.g"
+		selector_names_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SELECTOR_NAMES_OPT,"SELECTOR_NAMES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(selector_names_opt_AST))));
+#line 6443 "AdaParser.cpp"
+		currentAST.root = selector_names_opt_AST;
+		if ( selector_names_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			selector_names_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = selector_names_opt_AST->getFirstChild();
+		else
+			currentAST.child = selector_names_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	selector_names_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = selector_names_opt_AST;
+}
+
+void AdaParser::association_head() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST association_head_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	selector_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PIPE)) {
+			match(PIPE);
+			selector_name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop234;
+		}
+		
+	}
+	_loop234:;
+	} // ( ... )*
+	match(RIGHT_SHAFT);
+	association_head_AST = RefAdaAST(currentAST.root);
+	returnAST = association_head_AST;
+}
+
+void AdaParser::selector_name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST selector_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp202_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp202_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp202_AST));
+	}
+	match(IDENTIFIER);
+	selector_name_AST = RefAdaAST(currentAST.root);
+	returnAST = selector_name_AST;
+}
+
+void AdaParser::protected_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST protected_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PROTECTED:
+	{
+		RefAdaAST tmp203_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp203_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp203_AST));
+		}
+		match(PROTECTED);
+		break;
+	}
+	case PROCEDURE:
+	case FUNCTION:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		protected_opt_AST = RefAdaAST(currentAST.root);
+#line 761 "ada.g"
+		protected_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(protected_opt_AST))));
+#line 6533 "AdaParser.cpp"
+		currentAST.root = protected_opt_AST;
+		if ( protected_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			protected_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = protected_opt_AST->getFirstChild();
+		else
+			currentAST.child = protected_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	protected_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = protected_opt_AST;
+}
+
+void AdaParser::constant_all_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST constant_all_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case CONSTANT:
+	{
+		RefAdaAST tmp204_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp204_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp204_AST));
+		}
+		match(CONSTANT);
+		break;
+	}
+	case ALL:
+	{
+		RefAdaAST tmp205_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp205_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp205_AST));
+		}
+		match(ALL);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		constant_all_opt_AST = RefAdaAST(currentAST.root);
+#line 765 "ada.g"
+		constant_all_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(constant_all_opt_AST))));
+#line 6588 "AdaParser.cpp"
+		currentAST.root = constant_all_opt_AST;
+		if ( constant_all_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			constant_all_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = constant_all_opt_AST->getFirstChild();
+		else
+			currentAST.child = constant_all_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	constant_all_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = constant_all_opt_AST;
+}
+
+void AdaParser::abstract_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST abstract_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ABSTRACT:
+	{
+		RefAdaAST tmp206_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp206_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp206_AST));
+		}
+		match(ABSTRACT);
+		break;
+	}
+	case NEW:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		abstract_opt_AST = RefAdaAST(currentAST.root);
+#line 785 "ada.g"
+		abstract_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_opt_AST))));
+#line 6632 "AdaParser.cpp"
+		currentAST.root = abstract_opt_AST;
+		if ( abstract_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			abstract_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = abstract_opt_AST->getFirstChild();
+		else
+			currentAST.child = abstract_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	abstract_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = abstract_opt_AST;
+}
+
+void AdaParser::record_definition(
+	boolean has_discrim
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST record_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case RECORD:
+	{
+		match(RECORD);
+		component_list(has_discrim);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(END);
+		match(RECORD);
+		record_definition_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case NuLL:
+	{
+		match(NuLL);
+		match(RECORD);
+		record_definition_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = record_definition_AST;
+}
+
+void AdaParser::abstract_tagged_limited_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST abstract_tagged_limited_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ABSTRACT:
+	{
+		RefAdaAST tmp212_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp212_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp212_AST));
+		}
+		match(ABSTRACT);
+		match(TAGGED);
+		break;
+	}
+	case TAGGED:
+	{
+		RefAdaAST tmp214_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp214_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp214_AST));
+		}
+		match(TAGGED);
+		break;
+	}
+	case PRIVATE:
+	case NuLL:
+	case RECORD:
+	case LIMITED:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	{
+	switch ( LA(1)) {
+	case LIMITED:
+	{
+		RefAdaAST tmp215_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp215_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp215_AST));
+		}
+		match(LIMITED);
+		break;
+	}
+	case PRIVATE:
+	case NuLL:
+	case RECORD:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root);
+#line 847 "ada.g"
+		abstract_tagged_limited_opt_AST =
+			  RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_tagged_limited_opt_AST))));
+#line 6750 "AdaParser.cpp"
+		currentAST.root = abstract_tagged_limited_opt_AST;
+		if ( abstract_tagged_limited_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			abstract_tagged_limited_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = abstract_tagged_limited_opt_AST->getFirstChild();
+		else
+			currentAST.child = abstract_tagged_limited_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = abstract_tagged_limited_opt_AST;
+}
+
+void AdaParser::component_list(
+	boolean has_discrim
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST component_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case NuLL:
+	{
+		match(NuLL);
+		match(SEMI);
+		component_list_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case PRAGMA:
+	case IDENTIFIER:
+	{
+		component_items();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case CASE:
+		{
+			variant_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if (!( has_discrim ))
+				throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
+			break;
+		}
+		case END:
+		case WHEN:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		component_list_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case CASE:
+	{
+		empty_component_items();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		variant_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if (!( has_discrim ))
+			throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
+		component_list_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = component_list_AST;
+}
+
+void AdaParser::component_items() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )+
+	int _cnt256=0;
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		{
+			comp_decl();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			if ( _cnt256>=1 ) { goto _loop256; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+		}
+		}
+		_cnt256++;
+	}
+	_loop256:;
+	}  // ( ... )+
+	if ( inputState->guessing==0 ) {
+		component_items_AST = RefAdaAST(currentAST.root);
+#line 800 "ada.g"
+		component_items_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(component_items_AST))));
+#line 6873 "AdaParser.cpp"
+		currentAST.root = component_items_AST;
+		if ( component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = component_items_AST->getFirstChild();
+		else
+			currentAST.child = component_items_AST;
+		currentAST.advanceChildToEnd();
+	}
+	component_items_AST = RefAdaAST(currentAST.root);
+	returnAST = component_items_AST;
+}
+
+void AdaParser::variant_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST variant_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	c = LT(1);
+	if ( inputState->guessing == 0 ) {
+		c_AST = astFactory->create(c);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST));
+	}
+	match(CASE);
+	discriminant_direct_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(IS);
+	variant_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(END);
+	match(CASE);
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 812 "ada.g"
+		Set (c_AST, VARIANT_PART);
+#line 6914 "AdaParser.cpp"
+	}
+	variant_part_AST = RefAdaAST(currentAST.root);
+	returnAST = variant_part_AST;
+}
+
+void AdaParser::empty_component_items() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST empty_component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if ( inputState->guessing==0 ) {
+		empty_component_items_AST = RefAdaAST(currentAST.root);
+#line 806 "ada.g"
+		empty_component_items_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_component_items_AST))));
+#line 6930 "AdaParser.cpp"
+		currentAST.root = empty_component_items_AST;
+		if ( empty_component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			empty_component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = empty_component_items_AST->getFirstChild();
+		else
+			currentAST.child = empty_component_items_AST;
+		currentAST.advanceChildToEnd();
+	}
+	empty_component_items_AST = RefAdaAST(currentAST.root);
+	returnAST = empty_component_items_AST;
+}
+
+void AdaParser::discriminant_direct_name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminant_direct_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp222_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp222_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp222_AST));
+	}
+	match(IDENTIFIER);
+	discriminant_direct_name_AST = RefAdaAST(currentAST.root);
+	returnAST = discriminant_direct_name_AST;
+}
+
+void AdaParser::variant_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST variant_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )+
+	int _cnt262=0;
+	for (;;) {
+		if ((LA(1) == WHEN)) {
+			variant();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			if ( _cnt262>=1 ) { goto _loop262; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+		}
+		
+		_cnt262++;
+	}
+	_loop262:;
+	}  // ( ... )+
+	if ( inputState->guessing==0 ) {
+		variant_s_AST = RefAdaAST(currentAST.root);
+#line 819 "ada.g"
+		variant_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VARIANTS,"VARIANTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(variant_s_AST))));
+#line 6984 "AdaParser.cpp"
+		currentAST.root = variant_s_AST;
+		if ( variant_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			variant_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = variant_s_AST->getFirstChild();
+		else
+			currentAST.child = variant_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	variant_s_AST = RefAdaAST(currentAST.root);
+	returnAST = variant_s_AST;
+}
+
+void AdaParser::variant() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST variant_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	w = LT(1);
+	if ( inputState->guessing == 0 ) {
+		w_AST = astFactory->create(w);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+	}
+	match(WHEN);
+	choice_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RIGHT_SHAFT);
+	component_list(true);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 823 "ada.g"
+		Set (w_AST, VARIANT);
+#line 7022 "AdaParser.cpp"
+	}
+	variant_AST = RefAdaAST(currentAST.root);
+	returnAST = variant_AST;
+}
+
+void AdaParser::choice_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	choice();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PIPE)) {
+			RefAdaAST tmp224_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp224_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp224_AST));
+			}
+			match(PIPE);
+			choice();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop266;
+		}
+		
+	}
+	_loop266:;
+	} // ( ... )*
+	choice_s_AST = RefAdaAST(currentAST.root);
+	returnAST = choice_s_AST;
+}
+
+void AdaParser::choice() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	if ((LA(1) == OTHERS)) {
+		RefAdaAST tmp225_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp225_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp225_AST));
+		}
+		match(OTHERS);
+		choice_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		bool synPredMatched269 = false;
+		if (((_tokenSet_0.member(LA(1))) && (_tokenSet_20.member(LA(2))))) {
+			int _m269 = mark();
+			synPredMatched269 = true;
+			inputState->guessing++;
+			try {
+				{
+				discrete_with_range();
+				}
+			}
+			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+				synPredMatched269 = false;
+			}
+			rewind(_m269);
+			inputState->guessing--;
+		}
+		if ( synPredMatched269 ) {
+			discrete_with_range();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			choice_AST = RefAdaAST(currentAST.root);
+		}
+		else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			choice_AST = RefAdaAST(currentAST.root);
+		}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = choice_AST;
+}
+
+void AdaParser::discrete_with_range() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discrete_with_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	bool synPredMatched272 = false;
+	if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) {
+		int _m272 = mark();
+		synPredMatched272 = true;
+		inputState->guessing++;
+		try {
+			{
+			mark_with_constraint();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched272 = false;
+		}
+		rewind(_m272);
+		inputState->guessing--;
+	}
+	if ( synPredMatched272 ) {
+		mark_with_constraint();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrete_with_range_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2)))) {
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrete_with_range_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = discrete_with_range_AST;
+}
+
+void AdaParser::mark_with_constraint() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST mark_with_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	subtype_mark();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	range_constraint();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		mark_with_constraint_AST = RefAdaAST(currentAST.root);
+#line 839 "ada.g"
+		mark_with_constraint_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MARK_WITH_CONSTRAINT,"MARK_WITH_CONSTRAINT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mark_with_constraint_AST))));
+#line 7174 "AdaParser.cpp"
+		currentAST.root = mark_with_constraint_AST;
+		if ( mark_with_constraint_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			mark_with_constraint_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = mark_with_constraint_AST->getFirstChild();
+		else
+			currentAST.child = mark_with_constraint_AST;
+		currentAST.advanceChildToEnd();
+	}
+	mark_with_constraint_AST = RefAdaAST(currentAST.root);
+	returnAST = mark_with_constraint_AST;
+}
+
+void AdaParser::generic_formal_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST generic_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case USE:
+		{
+			use_clause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		case WITH:
+		case TYPE:
+		{
+			generic_formal_parameter();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop289;
+		}
+		}
+	}
+	_loop289:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		generic_formal_part_opt_AST = RefAdaAST(currentAST.root);
+#line 885 "ada.g"
+		generic_formal_part_opt_AST =
+					RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(GENERIC_FORMAL_PART,"GENERIC_FORMAL_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(generic_formal_part_opt_AST))));
+#line 7234 "AdaParser.cpp"
+		currentAST.root = generic_formal_part_opt_AST;
+		if ( generic_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			generic_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = generic_formal_part_opt_AST->getFirstChild();
+		else
+			currentAST.child = generic_formal_part_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	generic_formal_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = generic_formal_part_opt_AST;
+}
+
+void AdaParser::generic_formal_parameter() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST generic_formal_parameter_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case TYPE:
+	{
+		t = LT(1);
+		if ( inputState->guessing == 0 ) {
+			t_AST = astFactory->create(t);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+		}
+		match(TYPE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			match(IS);
+			{
+			switch ( LA(1)) {
+			case LPAREN:
+			{
+				match(LPAREN);
+				match(BOX);
+				match(RPAREN);
+				if ( inputState->guessing==0 ) {
+#line 895 "ada.g"
+					Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION);
+#line 7285 "AdaParser.cpp"
+				}
+				break;
+			}
+			case RANGE:
+			{
+				match(RANGE);
+				match(BOX);
+				if ( inputState->guessing==0 ) {
+#line 897 "ada.g"
+					Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
+#line 7296 "AdaParser.cpp"
+				}
+				break;
+			}
+			case MOD:
+			{
+				match(MOD);
+				match(BOX);
+				if ( inputState->guessing==0 ) {
+#line 899 "ada.g"
+					Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION);
+#line 7307 "AdaParser.cpp"
+				}
+				break;
+			}
+			case DELTA:
+			{
+				match(DELTA);
+				match(BOX);
+				{
+				switch ( LA(1)) {
+				case DIGITS:
+				{
+					match(DIGITS);
+					match(BOX);
+					if ( inputState->guessing==0 ) {
+#line 902 "ada.g"
+						Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
+#line 7324 "AdaParser.cpp"
+					}
+					break;
+				}
+				case SEMI:
+				{
+					if ( inputState->guessing==0 ) {
+#line 903 "ada.g"
+						Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
+#line 7333 "AdaParser.cpp"
+					}
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				break;
+			}
+			case DIGITS:
+			{
+				match(DIGITS);
+				match(BOX);
+				if ( inputState->guessing==0 ) {
+#line 906 "ada.g"
+					Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION);
+#line 7352 "AdaParser.cpp"
+				}
+				break;
+			}
+			case ARRAY:
+			{
+				array_type_definition(t_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case ACCESS:
+			{
+				access_type_definition(t_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case PRIVATE:
+			case NEW:
+			case ABSTRACT:
+			case TAGGED:
+			case LIMITED:
+			{
+				empty_discrim_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				discriminable_type_definition(t_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case LPAREN:
+		{
+			discrim_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(IS);
+			discriminable_type_definition(t_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+#line 913 "ada.g"
+			pop_def_id();
+#line 7418 "AdaParser.cpp"
+		}
+		break;
+	}
+	case WITH:
+	{
+		w = LT(1);
+		if ( inputState->guessing == 0 ) {
+			w_AST = astFactory->create(w);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+		}
+		match(WITH);
+		{
+		switch ( LA(1)) {
+		case PROCEDURE:
+		{
+			match(PROCEDURE);
+			def_id(false);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			formal_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			subprogram_default_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 915 "ada.g"
+				Set(w_AST, FORMAL_PROCEDURE_DECLARATION);
+#line 7450 "AdaParser.cpp"
+			}
+			break;
+		}
+		case FUNCTION:
+		{
+			match(FUNCTION);
+			def_designator(false);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			function_tail();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			subprogram_default_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 917 "ada.g"
+				Set(w_AST, FORMAL_FUNCTION_DECLARATION);
+#line 7472 "AdaParser.cpp"
+			}
+			break;
+		}
+		case PACKAGE:
+		{
+			match(PACKAGE);
+			def_id(false);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(IS);
+			match(NEW);
+			compound_name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			formal_package_actual_part_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 919 "ada.g"
+				Set(w_AST, FORMAL_PACKAGE_DECLARATION);
+#line 7496 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+#line 921 "ada.g"
+			pop_def_id();
+#line 7509 "AdaParser.cpp"
+		}
+		break;
+	}
+	case IDENTIFIER:
+	{
+		parameter_specification();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	generic_formal_parameter_AST = RefAdaAST(currentAST.root);
+	returnAST = generic_formal_parameter_AST;
+}
+
+void AdaParser::discriminable_type_definition(
+	RefAdaAST t
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST discriminable_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	bool synPredMatched299 = false;
+	if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
+		int _m299 = mark();
+		synPredMatched299 = true;
+		inputState->guessing++;
+		try {
+			{
+			{
+			switch ( LA(1)) {
+			case ABSTRACT:
+			{
+				match(ABSTRACT);
+				break;
+			}
+			case NEW:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(NEW);
+			subtype_ind();
+			match(WITH);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched299 = false;
+		}
+		rewind(_m299);
+		inputState->guessing--;
+	}
+	if ( synPredMatched299 ) {
+		abstract_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(NEW);
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(WITH);
+		match(PRIVATE);
+		if ( inputState->guessing==0 ) {
+#line 930 "ada.g"
+			Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION);
+#line 7589 "AdaParser.cpp"
+		}
+		discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
+		match(NEW);
+		subtype_ind();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 932 "ada.g"
+			Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
+#line 7602 "AdaParser.cpp"
+		}
+		discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2)))) {
+		abstract_tagged_limited_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(PRIVATE);
+		if ( inputState->guessing==0 ) {
+#line 934 "ada.g"
+			Set (t, FORMAL_PRIVATE_TYPE_DECLARATION);
+#line 7615 "AdaParser.cpp"
+		}
+		discriminable_type_definition_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = discriminable_type_definition_AST;
+}
+
+void AdaParser::subprogram_default_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subprogram_default_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case IS:
+	{
+		match(IS);
+		{
+		switch ( LA(1)) {
+		case BOX:
+		{
+			RefAdaAST tmp253_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp253_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp253_AST));
+			}
+			match(BOX);
+			break;
+		}
+		case IDENTIFIER:
+		{
+			name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	subprogram_default_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = subprogram_default_opt_AST;
+}
+
+void AdaParser::formal_package_actual_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST formal_package_actual_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LPAREN:
+	{
+		match(LPAREN);
+		{
+		switch ( LA(1)) {
+		case BOX:
+		{
+			RefAdaAST tmp255_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp255_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp255_AST));
+			}
+			match(BOX);
+			break;
+		}
+		case IDENTIFIER:
+		{
+			defining_identifier_list();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(RPAREN);
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	formal_package_actual_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = formal_package_actual_part_opt_AST;
+}
+
+void AdaParser::body_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	declarative_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	block_body();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	end_id_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	body_part_AST = RefAdaAST(currentAST.root);
+	returnAST = body_part_AST;
+}
+
+void AdaParser::declarative_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST declarative_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		case USE:
+		case TYPE:
+		case PACKAGE:
+		case PROCEDURE:
+		case FUNCTION:
+		case TASK:
+		case PROTECTED:
+		case FOR:
+		case SUBTYPE:
+		case GENERIC:
+		{
+			declarative_item();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop316;
+		}
+		}
+	}
+	_loop316:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		declarative_part_AST = RefAdaAST(currentAST.root);
+#line 978 "ada.g"
+		declarative_part_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARATIVE_PART,"DECLARATIVE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declarative_part_AST))));
+#line 7799 "AdaParser.cpp"
+		currentAST.root = declarative_part_AST;
+		if ( declarative_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			declarative_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = declarative_part_AST->getFirstChild();
+		else
+			currentAST.child = declarative_part_AST;
+		currentAST.advanceChildToEnd();
+	}
+	declarative_part_AST = RefAdaAST(currentAST.root);
+	returnAST = declarative_part_AST;
+}
+
+void AdaParser::block_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST block_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  b = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST b_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	b = LT(1);
+	if ( inputState->guessing == 0 ) {
+		b_AST = astFactory->create(b);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(b_AST));
+	}
+	match(BEGIN);
+	handled_stmt_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1058 "ada.g"
+		Set(b_AST, BLOCK_BODY);
+#line 7832 "AdaParser.cpp"
+	}
+	block_body_AST = RefAdaAST(currentAST.root);
+	returnAST = block_body_AST;
+}
+
+void AdaParser::declarative_item() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST declarative_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PACKAGE:
+	{
+		pkg = LT(1);
+		if ( inputState->guessing == 0 ) {
+			pkg_AST = astFactory->create(pkg);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST));
+		}
+		match(PACKAGE);
+		{
+		switch ( LA(1)) {
+		case BODY:
+		{
+			body_is();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case SEPARATE:
+			{
+				separate();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 986 "ada.g"
+					Set(pkg_AST, PACKAGE_BODY_STUB);
+#line 7878 "AdaParser.cpp"
+				}
+				break;
+			}
+			case PRAGMA:
+			case IDENTIFIER:
+			case USE:
+			case TYPE:
+			case PACKAGE:
+			case PROCEDURE:
+			case FUNCTION:
+			case TASK:
+			case PROTECTED:
+			case FOR:
+			case END:
+			case SUBTYPE:
+			case GENERIC:
+			case BEGIN:
+			{
+				pkg_body_part();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 988 "ada.g"
+					Set(pkg_AST, PACKAGE_BODY);
+#line 7904 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			break;
+		}
+		case IDENTIFIER:
+		{
+			def_id(false);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			spec_decl_part(pkg_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case TASK:
+	{
+		tsk = LT(1);
+		if ( inputState->guessing == 0 ) {
+			tsk_AST = astFactory->create(tsk);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST));
+		}
+		match(TASK);
+		{
+		switch ( LA(1)) {
+		case BODY:
+		{
+			body_is();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case SEPARATE:
+			{
+				separate();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 994 "ada.g"
+					Set(tsk_AST, TASK_BODY_STUB);
+#line 7964 "AdaParser.cpp"
+				}
+				break;
+			}
+			case PRAGMA:
+			case IDENTIFIER:
+			case USE:
+			case TYPE:
+			case PACKAGE:
+			case PROCEDURE:
+			case FUNCTION:
+			case TASK:
+			case PROTECTED:
+			case FOR:
+			case SUBTYPE:
+			case GENERIC:
+			case BEGIN:
+			{
+				body_part();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 995 "ada.g"
+					Set(tsk_AST, TASK_BODY);
+#line 7989 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			break;
+		}
+		case IDENTIFIER:
+		case TYPE:
+		{
+			task_type_or_single_decl(tsk_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	case PROTECTED:
+	{
+		pro = LT(1);
+		if ( inputState->guessing == 0 ) {
+			pro_AST = astFactory->create(pro);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST));
+		}
+		match(PROTECTED);
+		{
+		switch ( LA(1)) {
+		case BODY:
+		{
+			body_is();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case SEPARATE:
+			{
+				separate();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 1002 "ada.g"
+					Set(pro_AST, PROTECTED_BODY_STUB);
+#line 8046 "AdaParser.cpp"
+				}
+				break;
+			}
+			case PRAGMA:
+			case PROCEDURE:
+			case FUNCTION:
+			case ENTRY:
+			case END:
+			{
+				prot_op_bodies_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				end_id_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				if ( inputState->guessing==0 ) {
+#line 1004 "ada.g"
+					Set(pro_AST, PROTECTED_BODY);
+#line 8067 "AdaParser.cpp"
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case IDENTIFIER:
+		case TYPE:
+		{
+			prot_type_or_single_decl(pro_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(SEMI);
+		break;
+	}
+	case PROCEDURE:
+	case FUNCTION:
+	{
+		subprog_decl_or_rename_or_inst_or_body(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case IDENTIFIER:
+	case USE:
+	case TYPE:
+	case FOR:
+	case SUBTYPE:
+	case GENERIC:
+	{
+		decl_common();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	declarative_item_AST = RefAdaAST(currentAST.root);
+	returnAST = declarative_item_AST;
+}
+
+void AdaParser::body_is() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST body_is_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(BODY);
+	def_id(false);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(IS);
+	body_is_AST = RefAdaAST(currentAST.root);
+	returnAST = body_is_AST;
+}
+
+void AdaParser::separate() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST separate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(SEPARATE);
+	if ( inputState->guessing==0 ) {
+#line 1023 "ada.g"
+		pop_def_id();
+#line 8153 "AdaParser.cpp"
+	}
+	separate_AST = RefAdaAST(currentAST.root);
+	returnAST = separate_AST;
+}
+
+void AdaParser::prot_op_bodies_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST prot_op_bodies_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case ENTRY:
+		{
+			entry_body();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case PROCEDURE:
+		case FUNCTION:
+		{
+			subprog_decl_or_body();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop332;
+		}
+		}
+	}
+	_loop332:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		prot_op_bodies_opt_AST = RefAdaAST(currentAST.root);
+#line 1039 "ada.g"
+		prot_op_bodies_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_BODIES_OPT,"PROT_OP_BODIES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_bodies_opt_AST))));
+#line 8205 "AdaParser.cpp"
+		currentAST.root = prot_op_bodies_opt_AST;
+		if ( prot_op_bodies_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			prot_op_bodies_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = prot_op_bodies_opt_AST->getFirstChild();
+		else
+			currentAST.child = prot_op_bodies_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	prot_op_bodies_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = prot_op_bodies_opt_AST;
+}
+
+void AdaParser::block_body_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST block_body_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case BEGIN:
+	{
+		match(BEGIN);
+		handled_stmt_s();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		block_body_opt_AST = RefAdaAST(currentAST.root);
+#line 1030 "ada.g"
+		block_body_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_BODY_OPT,"BLOCK_BODY_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_body_opt_AST))));
+#line 8249 "AdaParser.cpp"
+		currentAST.root = block_body_opt_AST;
+		if ( block_body_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			block_body_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = block_body_opt_AST->getFirstChild();
+		else
+			currentAST.child = block_body_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	block_body_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = block_body_opt_AST;
+}
+
+void AdaParser::handled_stmt_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST handled_stmt_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	statements();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	except_handler_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		handled_stmt_s_AST = RefAdaAST(currentAST.root);
+#line 1062 "ada.g"
+		handled_stmt_s_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,"HANDLED_SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmt_s_AST))));
+#line 8280 "AdaParser.cpp"
+		currentAST.root = handled_stmt_s_AST;
+		if ( handled_stmt_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			handled_stmt_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = handled_stmt_s_AST->getFirstChild();
+		else
+			currentAST.child = handled_stmt_s_AST;
+		currentAST.advanceChildToEnd();
+	}
+	handled_stmt_s_AST = RefAdaAST(currentAST.root);
+	returnAST = handled_stmt_s_AST;
+}
+
+void AdaParser::entry_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	e = LT(1);
+	if ( inputState->guessing == 0 ) {
+		e_AST = astFactory->create(e);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST));
+	}
+	match(ENTRY);
+	def_id(false);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	entry_body_formal_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	entry_barrier();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(IS);
+	body_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1236 "ada.g"
+		Set (e_AST, ENTRY_BODY);
+#line 8327 "AdaParser.cpp"
+	}
+	entry_body_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_body_AST;
+}
+
+void AdaParser::subprog_decl_or_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subprog_decl_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case PROCEDURE:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PROCEDURE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		formal_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			match(IS);
+			body_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 1046 "ada.g"
+				Set(p_AST, PROCEDURE_BODY);
+#line 8371 "AdaParser.cpp"
+			}
+			break;
+		}
+		case SEMI:
+		{
+			if ( inputState->guessing==0 ) {
+#line 1047 "ada.g"
+				pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
+#line 8380 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(SEMI);
+		subprog_decl_or_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FUNCTION:
+	{
+		f = LT(1);
+		if ( inputState->guessing == 0 ) {
+			f_AST = astFactory->create(f);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+		}
+		match(FUNCTION);
+		def_designator(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		function_tail();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case IS:
+		{
+			match(IS);
+			body_part();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 1051 "ada.g"
+				Set(f_AST, FUNCTION_BODY);
+#line 8422 "AdaParser.cpp"
+			}
+			break;
+		}
+		case SEMI:
+		{
+			if ( inputState->guessing==0 ) {
+#line 1052 "ada.g"
+				pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
+#line 8431 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(SEMI);
+		subprog_decl_or_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = subprog_decl_or_body_AST;
+}
+
+void AdaParser::statements() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST statements_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )+
+	int _cnt342=0;
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		case NuLL:
+		case RETURN:
+		case FOR:
+		case CASE:
+		case BEGIN:
+		case LT_LT:
+		case IF:
+		case LOOP:
+		case WHILE:
+		case DECLARE:
+		case EXIT:
+		case GOTO:
+		case ACCEPT:
+		case DELAY:
+		case SELECT:
+		case ABORT:
+		case RAISE:
+		case REQUEUE:
+		{
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			if ( _cnt342>=1 ) { goto _loop342; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+		}
+		}
+		_cnt342++;
+	}
+	_loop342:;
+	}  // ( ... )+
+	if ( inputState->guessing==0 ) {
+		statements_AST = RefAdaAST(currentAST.root);
+#line 1074 "ada.g"
+		statements_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SEQUENCE_OF_STATEMENTS,"SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statements_AST))));
+#line 8509 "AdaParser.cpp"
+		currentAST.root = statements_AST;
+		if ( statements_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			statements_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = statements_AST->getFirstChild();
+		else
+			currentAST.child = statements_AST;
+		currentAST.advanceChildToEnd();
+	}
+	statements_AST = RefAdaAST(currentAST.root);
+	returnAST = statements_AST;
+}
+
+void AdaParser::except_handler_part_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST except_handler_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case EXCEPTION:
+	{
+		match(EXCEPTION);
+		{ // ( ... )+
+		int _cnt429=0;
+		for (;;) {
+			if ((LA(1) == WHEN)) {
+				exception_handler();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				if ( _cnt429>=1 ) { goto _loop429; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+			}
+			
+			_cnt429++;
+		}
+		_loop429:;
+		}  // ( ... )+
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		except_handler_part_opt_AST = RefAdaAST(currentAST.root);
+#line 1365 "ada.g"
+		except_handler_part_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXCEPT_HANDLER_PART_OPT,"EXCEPT_HANDLER_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(except_handler_part_opt_AST))));
+#line 8566 "AdaParser.cpp"
+		currentAST.root = except_handler_part_opt_AST;
+		if ( except_handler_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			except_handler_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = except_handler_part_opt_AST->getFirstChild();
+		else
+			currentAST.child = except_handler_part_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	except_handler_part_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = except_handler_part_opt_AST;
+}
+
+void AdaParser::handled_stmts_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST handled_stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case PRAGMA:
+	case IDENTIFIER:
+	case NuLL:
+	case RETURN:
+	case FOR:
+	case CASE:
+	case BEGIN:
+	case LT_LT:
+	case IF:
+	case LOOP:
+	case WHILE:
+	case DECLARE:
+	case EXIT:
+	case GOTO:
+	case ACCEPT:
+	case DELAY:
+	case SELECT:
+	case ABORT:
+	case RAISE:
+	case REQUEUE:
+	{
+		statements();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		except_handler_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		handled_stmts_opt_AST = RefAdaAST(currentAST.root);
+#line 1068 "ada.g"
+		handled_stmts_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_STMTS_OPT,"HANDLED_STMTS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmts_opt_AST))));
+#line 8632 "AdaParser.cpp"
+		currentAST.root = handled_stmts_opt_AST;
+		if ( handled_stmts_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			handled_stmts_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = handled_stmts_opt_AST->getFirstChild();
+		else
+			currentAST.child = handled_stmts_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	handled_stmts_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = handled_stmts_opt_AST;
+}
+
+void AdaParser::statement() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST statement_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	def_label_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case NuLL:
+	{
+		null_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case EXIT:
+	{
+		exit_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case RETURN:
+	{
+		return_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case GOTO:
+	{
+		goto_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case DELAY:
+	{
+		delay_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case ABORT:
+	{
+		abort_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case RAISE:
+	{
+		raise_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case REQUEUE:
+	{
+		requeue_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case ACCEPT:
+	{
+		accept_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SELECT:
+	{
+		select_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case IF:
+	{
+		if_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case CASE:
+	{
+		case_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case FOR:
+	case LOOP:
+	case WHILE:
+	{
+		loop_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		break;
+	}
+	case BEGIN:
+	case DECLARE:
+	{
+		block();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(END);
+		match(SEMI);
+		break;
+	}
+	default:
+		if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
+			statement_identifier();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case FOR:
+			case LOOP:
+			case WHILE:
+			{
+				loop_stmt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				id_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(SEMI);
+				break;
+			}
+			case BEGIN:
+			case DECLARE:
+			{
+				block();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				end_id_opt();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(SEMI);
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+		}
+		else if ((LA(1) == IDENTIFIER) && (_tokenSet_24.member(LA(2)))) {
+			call_or_assignment();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		statement_AST = RefAdaAST(currentAST.root);
+#line 1100 "ada.g"
+		statement_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STATEMENT,"STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statement_AST))));
+#line 8833 "AdaParser.cpp"
+		currentAST.root = statement_AST;
+		if ( statement_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			statement_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = statement_AST->getFirstChild();
+		else
+			currentAST.child = statement_AST;
+		currentAST.advanceChildToEnd();
+	}
+	statement_AST = RefAdaAST(currentAST.root);
+	returnAST = statement_AST;
+}
+
+void AdaParser::def_label_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST def_label_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case LT_LT:
+	{
+		match(LT_LT);
+		RefAdaAST tmp277_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp277_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp277_AST));
+		}
+		match(IDENTIFIER);
+		match(GT_GT);
+		break;
+	}
+	case IDENTIFIER:
+	case NuLL:
+	case RETURN:
+	case FOR:
+	case CASE:
+	case BEGIN:
+	case IF:
+	case LOOP:
+	case WHILE:
+	case DECLARE:
+	case EXIT:
+	case GOTO:
+	case ACCEPT:
+	case DELAY:
+	case SELECT:
+	case ABORT:
+	case RAISE:
+	case REQUEUE:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		def_label_opt_AST = RefAdaAST(currentAST.root);
+#line 1104 "ada.g"
+		def_label_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LABEL_OPT,"LABEL_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(def_label_opt_AST))));
+#line 8896 "AdaParser.cpp"
+		currentAST.root = def_label_opt_AST;
+		if ( def_label_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			def_label_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = def_label_opt_AST->getFirstChild();
+		else
+			currentAST.child = def_label_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	def_label_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = def_label_opt_AST;
+}
+
+void AdaParser::null_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST null_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(NuLL);
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1108 "ada.g"
+		Set(s_AST, NULL_STATEMENT);
+#line 8926 "AdaParser.cpp"
+	}
+	null_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = null_stmt_AST;
+}
+
+void AdaParser::exit_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST exit_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(EXIT);
+	{
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		label_name();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case WHEN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	{
+	switch ( LA(1)) {
+	case WHEN:
+	{
+		RefAdaAST tmp280_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp280_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp280_AST));
+		}
+		match(WHEN);
+		condition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1206 "ada.g"
+		Set(s_AST, EXIT_STATEMENT);
+#line 8996 "AdaParser.cpp"
+	}
+	exit_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = exit_stmt_AST;
+}
+
+void AdaParser::return_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST return_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(RETURN);
+	{
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case PLUS:
+	case MINUS:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1213 "ada.g"
+		Set(s_AST, RETURN_STATEMENT);
+#line 9049 "AdaParser.cpp"
+	}
+	return_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = return_stmt_AST;
+}
+
+void AdaParser::goto_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST goto_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(GOTO);
+	label_name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1217 "ada.g"
+		Set(s_AST, GOTO_STATEMENT);
+#line 9076 "AdaParser.cpp"
+	}
+	goto_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = goto_stmt_AST;
+}
+
+void AdaParser::delay_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST delay_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	d = LT(1);
+	if ( inputState->guessing == 0 ) {
+		d_AST = astFactory->create(d);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST));
+	}
+	match(DELAY);
+	until_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1282 "ada.g"
+		Set (d_AST, DELAY_STATEMENT);
+#line 9107 "AdaParser.cpp"
+	}
+	delay_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = delay_stmt_AST;
+}
+
+void AdaParser::abort_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST abort_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	a = LT(1);
+	if ( inputState->guessing == 0 ) {
+		a_AST = astFactory->create(a);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+	}
+	match(ABORT);
+	name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == COMMA)) {
+			match(COMMA);
+			name();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop425;
+		}
+		
+	}
+	_loop425:;
+	} // ( ... )*
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1361 "ada.g"
+		Set (a_AST, ABORT_STATEMENT);
+#line 9150 "AdaParser.cpp"
+	}
+	abort_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = abort_stmt_AST;
+}
+
+void AdaParser::raise_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST raise_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	r = LT(1);
+	if ( inputState->guessing == 0 ) {
+		r_AST = astFactory->create(r);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+	}
+	match(RAISE);
+	{
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		compound_name();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1389 "ada.g"
+		Set (r_AST, RAISE_STATEMENT);
+#line 9193 "AdaParser.cpp"
+	}
+	raise_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = raise_stmt_AST;
+}
+
+void AdaParser::requeue_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST requeue_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	r = LT(1);
+	if ( inputState->guessing == 0 ) {
+		r_AST = astFactory->create(r);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST));
+	}
+	match(REQUEUE);
+	name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case WITH:
+	{
+		match(WITH);
+		RefAdaAST tmp289_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp289_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp289_AST));
+		}
+		match(ABORT);
+		break;
+	}
+	case SEMI:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1393 "ada.g"
+		Set (r_AST, REQUEUE_STATEMENT);
+#line 9243 "AdaParser.cpp"
+	}
+	requeue_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = requeue_stmt_AST;
+}
+
+void AdaParser::accept_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST accept_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	a = LT(1);
+	if ( inputState->guessing == 0 ) {
+		a_AST = astFactory->create(a);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST));
+	}
+	match(ACCEPT);
+	def_id(false);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	entry_index_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	formal_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case DO:
+	{
+		match(DO);
+		handled_stmts_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		end_id_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		break;
+	}
+	case SEMI:
+	{
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 1264 "ada.g"
+			pop_def_id();
+#line 9296 "AdaParser.cpp"
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+#line 1266 "ada.g"
+		Set (a_AST, ACCEPT_STATEMENT);
+#line 9309 "AdaParser.cpp"
+	}
+	accept_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = accept_stmt_AST;
+}
+
+void AdaParser::select_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST select_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(SELECT);
+	{
+	bool synPredMatched403 = false;
+	if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (_tokenSet_25.member(LA(2))))) {
+		int _m403 = mark();
+		synPredMatched403 = true;
+		inputState->guessing++;
+		try {
+			{
+			triggering_alternative();
+			match(THEN);
+			match(ABORT);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched403 = false;
+		}
+		rewind(_m403);
+		inputState->guessing--;
+	}
+	if ( synPredMatched403 ) {
+		triggering_alternative();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(THEN);
+		match(ABORT);
+		abortable_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 1297 "ada.g"
+			Set (s_AST, ASYNCHRONOUS_SELECT);
+#line 9361 "AdaParser.cpp"
+		}
+	}
+	else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) {
+		selective_accept();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 1299 "ada.g"
+			Set (s_AST, SELECTIVE_ACCEPT);
+#line 9372 "AdaParser.cpp"
+		}
+	}
+	else if ((LA(1) == IDENTIFIER) && (_tokenSet_28.member(LA(2)))) {
+		entry_call_alternative();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case OR:
+		{
+			match(OR);
+			delay_alternative();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 1301 "ada.g"
+				Set (s_AST, TIMED_ENTRY_CALL);
+#line 9392 "AdaParser.cpp"
+			}
+			break;
+		}
+		case ELSE:
+		{
+			match(ELSE);
+			statements();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			if ( inputState->guessing==0 ) {
+#line 1302 "ada.g"
+				Set (s_AST, CONDITIONAL_ENTRY_CALL);
+#line 9406 "AdaParser.cpp"
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	match(END);
+	match(SELECT);
+	match(SEMI);
+	select_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = select_stmt_AST;
+}
+
+void AdaParser::if_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST if_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(IF);
+	cond_clause();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	elsifs_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	else_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(END);
+	match(IF);
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1114 "ada.g"
+		Set(s_AST, IF_STATEMENT);
+#line 9460 "AdaParser.cpp"
+	}
+	if_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = if_stmt_AST;
+}
+
+void AdaParser::case_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST case_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(CASE);
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(IS);
+	alternative_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(END);
+	match(CASE);
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1134 "ada.g"
+		Set(s_AST, CASE_STATEMENT);
+#line 9494 "AdaParser.cpp"
+	}
+	case_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = case_stmt_AST;
+}
+
+void AdaParser::loop_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST loop_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  l = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST l_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	iteration_scheme_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	l = LT(1);
+	if ( inputState->guessing == 0 ) {
+		l_AST = astFactory->create(l);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(l_AST));
+	}
+	match(LOOP);
+	statements();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(END);
+	match(LOOP);
+	if ( inputState->guessing==0 ) {
+#line 1146 "ada.g"
+		Set(l_AST, LOOP_STATEMENT);
+#line 9526 "AdaParser.cpp"
+	}
+	loop_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = loop_stmt_AST;
+}
+
+void AdaParser::block() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST block_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	declare_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	block_body();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		block_AST = RefAdaAST(currentAST.root);
+#line 1198 "ada.g"
+		block_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_STATEMENT,"BLOCK_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_AST))));
+#line 9549 "AdaParser.cpp"
+		currentAST.root = block_AST;
+		if ( block_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			block_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = block_AST->getFirstChild();
+		else
+			currentAST.child = block_AST;
+		currentAST.advanceChildToEnd();
+	}
+	block_AST = RefAdaAST(currentAST.root);
+	returnAST = block_AST;
+}
+
+void AdaParser::statement_identifier() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST statement_identifier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	n = LT(1);
+	if ( inputState->guessing == 0 ) {
+		n_AST = astFactory->create(n);
+	}
+	match(IDENTIFIER);
+	match(COLON);
+	if ( inputState->guessing==0 ) {
+#line 1186 "ada.g"
+		push_def_id(n_AST);
+#line 9578 "AdaParser.cpp"
+	}
+	returnAST = statement_identifier_AST;
+}
+
+void AdaParser::id_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	id_opt_aux();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		id_opt_AST = RefAdaAST(currentAST.root);
+#line 1172 "ada.g"
+		id_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ID_OPT,"ID_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_opt_AST))));
+#line 9596 "AdaParser.cpp"
+		currentAST.root = id_opt_AST;
+		if ( id_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			id_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = id_opt_AST->getFirstChild();
+		else
+			currentAST.child = id_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	id_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = id_opt_AST;
+}
+
+void AdaParser::call_or_assignment() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST call_or_assignment_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case ASSIGN:
+	{
+		match(ASSIGN);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+			call_or_assignment_AST = RefAdaAST(currentAST.root);
+#line 1222 "ada.g"
+			call_or_assignment_AST =
+						RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ASSIGNMENT_STATEMENT,"ASSIGNMENT_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST))));
+#line 9632 "AdaParser.cpp"
+			currentAST.root = call_or_assignment_AST;
+			if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = call_or_assignment_AST->getFirstChild();
+			else
+				currentAST.child = call_or_assignment_AST;
+			currentAST.advanceChildToEnd();
+		}
+		break;
+	}
+	case SEMI:
+	{
+		if ( inputState->guessing==0 ) {
+			call_or_assignment_AST = RefAdaAST(currentAST.root);
+#line 1225 "ada.g"
+			call_or_assignment_AST =
+						RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CALL_STATEMENT,"CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST))));
+#line 9650 "AdaParser.cpp"
+			currentAST.root = call_or_assignment_AST;
+			if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = call_or_assignment_AST->getFirstChild();
+			else
+				currentAST.child = call_or_assignment_AST;
+			currentAST.advanceChildToEnd();
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	match(SEMI);
+	call_or_assignment_AST = RefAdaAST(currentAST.root);
+	returnAST = call_or_assignment_AST;
+}
+
+void AdaParser::cond_clause() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST cond_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	condition();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	c = LT(1);
+	if ( inputState->guessing == 0 ) {
+		c_AST = astFactory->create(c);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST));
+	}
+	match(THEN);
+	statements();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1118 "ada.g"
+		Set(c_AST, COND_CLAUSE);
+#line 9696 "AdaParser.cpp"
+	}
+	cond_clause_AST = RefAdaAST(currentAST.root);
+	returnAST = cond_clause_AST;
+}
+
+void AdaParser::elsifs_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST elsifs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == ELSIF)) {
+			match(ELSIF);
+			cond_clause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop354;
+		}
+		
+	}
+	_loop354:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		elsifs_opt_AST = RefAdaAST(currentAST.root);
+#line 1126 "ada.g"
+		elsifs_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSIFS_OPT,"ELSIFS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(elsifs_opt_AST))));
+#line 9727 "AdaParser.cpp"
+		currentAST.root = elsifs_opt_AST;
+		if ( elsifs_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			elsifs_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = elsifs_opt_AST->getFirstChild();
+		else
+			currentAST.child = elsifs_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	elsifs_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = elsifs_opt_AST;
+}
+
+void AdaParser::else_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST else_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case ELSE:
+	{
+		match(ELSE);
+		statements();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case END:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		else_opt_AST = RefAdaAST(currentAST.root);
+#line 1130 "ada.g"
+		else_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSE_OPT,"ELSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(else_opt_AST))));
+#line 9770 "AdaParser.cpp"
+		currentAST.root = else_opt_AST;
+		if ( else_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			else_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = else_opt_AST->getFirstChild();
+		else
+			currentAST.child = else_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	else_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = else_opt_AST;
+}
+
+void AdaParser::condition() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST condition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	condition_AST = RefAdaAST(currentAST.root);
+	returnAST = condition_AST;
+}
+
+void AdaParser::alternative_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST alternative_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )+
+	int _cnt360=0;
+	for (;;) {
+		if ((LA(1) == WHEN)) {
+			case_statement_alternative();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			if ( _cnt360>=1 ) { goto _loop360; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+		}
+		
+		_cnt360++;
+	}
+	_loop360:;
+	}  // ( ... )+
+	alternative_s_AST = RefAdaAST(currentAST.root);
+	returnAST = alternative_s_AST;
+}
+
+void AdaParser::case_statement_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST case_statement_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	s = LT(1);
+	if ( inputState->guessing == 0 ) {
+		s_AST = astFactory->create(s);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+	}
+	match(WHEN);
+	choice_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RIGHT_SHAFT);
+	statements();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1141 "ada.g"
+		Set(s_AST, CASE_STATEMENT_ALTERNATIVE);
+#line 9847 "AdaParser.cpp"
+	}
+	case_statement_alternative_AST = RefAdaAST(currentAST.root);
+	returnAST = case_statement_alternative_AST;
+}
+
+void AdaParser::iteration_scheme_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST iteration_scheme_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case WHILE:
+	{
+		RefAdaAST tmp316_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp316_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp316_AST));
+		}
+		match(WHILE);
+		condition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case FOR:
+	{
+		RefAdaAST tmp317_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp317_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp317_AST));
+		}
+		match(FOR);
+		RefAdaAST tmp318_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp318_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp318_AST));
+		}
+		match(IDENTIFIER);
+		match(IN);
+		reverse_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		discrete_subtype_definition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case LOOP:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		iteration_scheme_opt_AST = RefAdaAST(currentAST.root);
+#line 1152 "ada.g"
+		iteration_scheme_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ITERATION_SCHEME_OPT,"ITERATION_SCHEME_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(iteration_scheme_opt_AST))));
+#line 9914 "AdaParser.cpp"
+		currentAST.root = iteration_scheme_opt_AST;
+		if ( iteration_scheme_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			iteration_scheme_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = iteration_scheme_opt_AST->getFirstChild();
+		else
+			currentAST.child = iteration_scheme_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	iteration_scheme_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = iteration_scheme_opt_AST;
+}
+
+void AdaParser::reverse_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST reverse_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case REVERSE:
+	{
+		RefAdaAST tmp320_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp320_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp320_AST));
+		}
+		match(REVERSE);
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case PLUS:
+	case MINUS:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		reverse_opt_AST = RefAdaAST(currentAST.root);
+#line 1158 "ada.g"
+		reverse_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(reverse_opt_AST))));
+#line 9968 "AdaParser.cpp"
+		currentAST.root = reverse_opt_AST;
+		if ( reverse_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			reverse_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = reverse_opt_AST->getFirstChild();
+		else
+			currentAST.child = reverse_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	reverse_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = reverse_opt_AST;
+}
+
+void AdaParser::id_opt_aux() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST id_opt_aux_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 1161 "ada.g"
+	RefAdaAST endid;
+#line 9988 "AdaParser.cpp"
+	
+	switch ( LA(1)) {
+	case CHAR_STRING:
+	{
+		endid=definable_operator_symbol();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if (!( end_id_matches_def_id (endid) ))
+			throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (endid) ");
+		id_opt_aux_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	{
+		compound_name();
+		if (inputState->guessing==0) {
+			n_AST = returnAST;
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if (!( end_id_matches_def_id (n_AST) ))
+			throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (n_AST) ");
+		id_opt_aux_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case SEMI:
+	{
+		if ( inputState->guessing==0 ) {
+#line 1168 "ada.g"
+			pop_def_id();
+#line 10019 "AdaParser.cpp"
+		}
+		id_opt_aux_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = id_opt_aux_AST;
+}
+
+void AdaParser::declare_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST declare_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case DECLARE:
+	{
+		match(DECLARE);
+		declarative_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case BEGIN:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		declare_opt_AST = RefAdaAST(currentAST.root);
+#line 1202 "ada.g"
+		declare_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARE_OPT,"DECLARE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declare_opt_AST))));
+#line 10062 "AdaParser.cpp"
+		currentAST.root = declare_opt_AST;
+		if ( declare_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			declare_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = declare_opt_AST->getFirstChild();
+		else
+			currentAST.child = declare_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	declare_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = declare_opt_AST;
+}
+
+void AdaParser::label_name() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST label_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	RefAdaAST tmp322_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp322_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp322_AST));
+	}
+	match(IDENTIFIER);
+	label_name_AST = RefAdaAST(currentAST.root);
+	returnAST = label_name_AST;
+}
+
+void AdaParser::entry_body_formal_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_body_formal_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	entry_index_spec_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	formal_part_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	entry_body_formal_part_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_body_formal_part_AST;
+}
+
+void AdaParser::entry_barrier() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_barrier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(WHEN);
+	condition();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	entry_barrier_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_barrier_AST;
+}
+
+void AdaParser::entry_index_spec_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_index_spec_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched388 = false;
+	if (((LA(1) == LPAREN) && (LA(2) == FOR))) {
+		int _m388 = mark();
+		synPredMatched388 = true;
+		inputState->guessing++;
+		try {
+			{
+			match(LPAREN);
+			match(FOR);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched388 = false;
+		}
+		rewind(_m388);
+		inputState->guessing--;
+	}
+	if ( synPredMatched388 ) {
+		match(LPAREN);
+		match(FOR);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(IN);
+		discrete_subtype_definition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+	}
+	else if ((LA(1) == LPAREN || LA(1) == WHEN) && (_tokenSet_0.member(LA(2)))) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	if ( inputState->guessing==0 ) {
+		entry_index_spec_opt_AST = RefAdaAST(currentAST.root);
+#line 1247 "ada.g"
+		entry_index_spec_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_SPECIFICATION,"ENTRY_INDEX_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_spec_opt_AST))));
+#line 10170 "AdaParser.cpp"
+		currentAST.root = entry_index_spec_opt_AST;
+		if ( entry_index_spec_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			entry_index_spec_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = entry_index_spec_opt_AST->getFirstChild();
+		else
+			currentAST.child = entry_index_spec_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	entry_index_spec_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_index_spec_opt_AST;
+}
+
+void AdaParser::entry_call_stmt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_call_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	name();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+		entry_call_stmt_AST = RefAdaAST(currentAST.root);
+#line 1257 "ada.g"
+		entry_call_stmt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_STATEMENT,"ENTRY_CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_stmt_AST))));
+#line 10198 "AdaParser.cpp"
+		currentAST.root = entry_call_stmt_AST;
+		if ( entry_call_stmt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			entry_call_stmt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = entry_call_stmt_AST->getFirstChild();
+		else
+			currentAST.child = entry_call_stmt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	entry_call_stmt_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_call_stmt_AST;
+}
+
+void AdaParser::entry_index_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_index_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	bool synPredMatched396 = false;
+	if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) {
+		int _m396 = mark();
+		synPredMatched396 = true;
+		inputState->guessing++;
+		try {
+			{
+			match(LPAREN);
+			expression();
+			match(RPAREN);
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched396 = false;
+		}
+		rewind(_m396);
+		inputState->guessing--;
+	}
+	if ( synPredMatched396 ) {
+		match(LPAREN);
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+	}
+	else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (_tokenSet_29.member(LA(2)))) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	if ( inputState->guessing==0 ) {
+		entry_index_opt_AST = RefAdaAST(currentAST.root);
+#line 1276 "ada.g"
+		entry_index_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_OPT,"ENTRY_INDEX_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_opt_AST))));
+#line 10255 "AdaParser.cpp"
+		currentAST.root = entry_index_opt_AST;
+		if ( entry_index_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			entry_index_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = entry_index_opt_AST->getFirstChild();
+		else
+			currentAST.child = entry_index_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	entry_index_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_index_opt_AST;
+}
+
+void AdaParser::until_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST until_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case UNTIL:
+	{
+		RefAdaAST tmp331_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp331_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp331_AST));
+		}
+		match(UNTIL);
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case PLUS:
+	case MINUS:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+		until_opt_AST = RefAdaAST(currentAST.root);
+#line 1286 "ada.g"
+		until_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(until_opt_AST))));
+#line 10309 "AdaParser.cpp"
+		currentAST.root = until_opt_AST;
+		if ( until_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			until_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = until_opt_AST->getFirstChild();
+		else
+			currentAST.child = until_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	until_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = until_opt_AST;
+}
+
+void AdaParser::triggering_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST triggering_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case DELAY:
+	{
+		delay_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case IDENTIFIER:
+	{
+		entry_call_stmt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	stmts_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		triggering_alternative_AST = RefAdaAST(currentAST.root);
+#line 1310 "ada.g"
+		triggering_alternative_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TRIGGERING_ALTERNATIVE,"TRIGGERING_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(triggering_alternative_AST))));
+#line 10360 "AdaParser.cpp"
+		currentAST.root = triggering_alternative_AST;
+		if ( triggering_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			triggering_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = triggering_alternative_AST->getFirstChild();
+		else
+			currentAST.child = triggering_alternative_AST;
+		currentAST.advanceChildToEnd();
+	}
+	triggering_alternative_AST = RefAdaAST(currentAST.root);
+	returnAST = triggering_alternative_AST;
+}
+
+void AdaParser::abortable_part() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST abortable_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	stmts_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		abortable_part_AST = RefAdaAST(currentAST.root);
+#line 1316 "ada.g"
+		abortable_part_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ABORTABLE_PART,"ABORTABLE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abortable_part_AST))));
+#line 10387 "AdaParser.cpp"
+		currentAST.root = abortable_part_AST;
+		if ( abortable_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			abortable_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = abortable_part_AST->getFirstChild();
+		else
+			currentAST.child = abortable_part_AST;
+		currentAST.advanceChildToEnd();
+	}
+	abortable_part_AST = RefAdaAST(currentAST.root);
+	returnAST = abortable_part_AST;
+}
+
+void AdaParser::selective_accept() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST selective_accept_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	guard_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	select_alternative();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	or_select_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	else_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	selective_accept_AST = RefAdaAST(currentAST.root);
+	returnAST = selective_accept_AST;
+}
+
+void AdaParser::entry_call_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST entry_call_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	entry_call_stmt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	stmts_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		entry_call_alternative_AST = RefAdaAST(currentAST.root);
+#line 1322 "ada.g"
+		entry_call_alternative_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_ALTERNATIVE,"ENTRY_CALL_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_alternative_AST))));
+#line 10443 "AdaParser.cpp"
+		currentAST.root = entry_call_alternative_AST;
+		if ( entry_call_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			entry_call_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = entry_call_alternative_AST->getFirstChild();
+		else
+			currentAST.child = entry_call_alternative_AST;
+		currentAST.advanceChildToEnd();
+	}
+	entry_call_alternative_AST = RefAdaAST(currentAST.root);
+	returnAST = entry_call_alternative_AST;
+}
+
+void AdaParser::delay_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST delay_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	delay_stmt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	stmts_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		delay_alternative_AST = RefAdaAST(currentAST.root);
+#line 1347 "ada.g"
+		delay_alternative_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DELAY_ALTERNATIVE,"DELAY_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(delay_alternative_AST))));
+#line 10474 "AdaParser.cpp"
+		currentAST.root = delay_alternative_AST;
+		if ( delay_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			delay_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = delay_alternative_AST->getFirstChild();
+		else
+			currentAST.child = delay_alternative_AST;
+		currentAST.advanceChildToEnd();
+	}
+	delay_alternative_AST = RefAdaAST(currentAST.root);
+	returnAST = delay_alternative_AST;
+}
+
+void AdaParser::stmts_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case PRAGMA:
+		{
+			pragma();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case IDENTIFIER:
+		case NuLL:
+		case RETURN:
+		case FOR:
+		case CASE:
+		case BEGIN:
+		case LT_LT:
+		case IF:
+		case LOOP:
+		case WHILE:
+		case DECLARE:
+		case EXIT:
+		case GOTO:
+		case ACCEPT:
+		case DELAY:
+		case SELECT:
+		case ABORT:
+		case RAISE:
+		case REQUEUE:
+		{
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop419;
+		}
+		}
+	}
+	_loop419:;
+	} // ( ... )*
+	stmts_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = stmts_opt_AST;
+}
+
+void AdaParser::guard_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST guard_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case WHEN:
+	{
+		w = LT(1);
+		if ( inputState->guessing == 0 ) {
+			w_AST = astFactory->create(w);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+		}
+		match(WHEN);
+		condition();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RIGHT_SHAFT);
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == PRAGMA)) {
+				pragma();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop413;
+			}
+			
+		}
+		_loop413:;
+		} // ( ... )*
+		break;
+	}
+	case ACCEPT:
+	case DELAY:
+	case TERMINATE:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	if ( inputState->guessing==0 ) {
+#line 1331 "ada.g"
+		Set(w_AST, GUARD_OPT);
+#line 10595 "AdaParser.cpp"
+	}
+	guard_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = guard_opt_AST;
+}
+
+void AdaParser::select_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST select_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case ACCEPT:
+	{
+		accept_alternative();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		select_alternative_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case DELAY:
+	{
+		delay_alternative();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		select_alternative_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case TERMINATE:
+	{
+		t = LT(1);
+		if ( inputState->guessing == 0 ) {
+			t_AST = astFactory->create(t);
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+		}
+		match(TERMINATE);
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 1337 "ada.g"
+			Set(t_AST, TERMINATE_ALTERNATIVE);
+#line 10639 "AdaParser.cpp"
+		}
+		select_alternative_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = select_alternative_AST;
+}
+
+void AdaParser::or_select_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST or_select_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == OR)) {
+			match(OR);
+			guard_opt();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			select_alternative();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop422;
+		}
+		
+	}
+	_loop422:;
+	} // ( ... )*
+	if ( inputState->guessing==0 ) {
+		or_select_opt_AST = RefAdaAST(currentAST.root);
+#line 1356 "ada.g"
+		or_select_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(OR_SELECT_OPT,"OR_SELECT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(or_select_opt_AST))));
+#line 10682 "AdaParser.cpp"
+		currentAST.root = or_select_opt_AST;
+		if ( or_select_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			or_select_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = or_select_opt_AST->getFirstChild();
+		else
+			currentAST.child = or_select_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	or_select_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = or_select_opt_AST;
+}
+
+void AdaParser::accept_alternative() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST accept_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	accept_stmt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	stmts_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+		accept_alternative_AST = RefAdaAST(currentAST.root);
+#line 1341 "ada.g"
+		accept_alternative_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ACCEPT_ALTERNATIVE,"ACCEPT_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(accept_alternative_AST))));
+#line 10713 "AdaParser.cpp"
+		currentAST.root = accept_alternative_AST;
+		if ( accept_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			accept_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = accept_alternative_AST->getFirstChild();
+		else
+			currentAST.child = accept_alternative_AST;
+		currentAST.advanceChildToEnd();
+	}
+	accept_alternative_AST = RefAdaAST(currentAST.root);
+	returnAST = accept_alternative_AST;
+}
+
+void AdaParser::exception_handler() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST exception_handler_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	w = LT(1);
+	if ( inputState->guessing == 0 ) {
+		w_AST = astFactory->create(w);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST));
+	}
+	match(WHEN);
+	identifier_colon_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	except_choice_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RIGHT_SHAFT);
+	statements();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1372 "ada.g"
+		Set (w_AST, EXCEPTION_HANDLER);
+#line 10755 "AdaParser.cpp"
+	}
+	exception_handler_AST = RefAdaAST(currentAST.root);
+	returnAST = exception_handler_AST;
+}
+
+void AdaParser::identifier_colon_opt() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST identifier_colon_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
+		RefAdaAST tmp336_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp336_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp336_AST));
+		}
+		match(IDENTIFIER);
+		match(COLON);
+	}
+	else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) {
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	}
+	if ( inputState->guessing==0 ) {
+		identifier_colon_opt_AST = RefAdaAST(currentAST.root);
+#line 1376 "ada.g"
+		identifier_colon_opt_AST =
+				RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IDENTIFIER_COLON_OPT,"IDENTIFIER_COLON_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(identifier_colon_opt_AST))));
+#line 10788 "AdaParser.cpp"
+		currentAST.root = identifier_colon_opt_AST;
+		if ( identifier_colon_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+			identifier_colon_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			  currentAST.child = identifier_colon_opt_AST->getFirstChild();
+		else
+			currentAST.child = identifier_colon_opt_AST;
+		currentAST.advanceChildToEnd();
+	}
+	identifier_colon_opt_AST = RefAdaAST(currentAST.root);
+	returnAST = identifier_colon_opt_AST;
+}
+
+void AdaParser::except_choice_s() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST except_choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	exception_choice();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == PIPE)) {
+			RefAdaAST tmp338_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp338_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp338_AST));
+			}
+			match(PIPE);
+			exception_choice();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else {
+			goto _loop435;
+		}
+		
+	}
+	_loop435:;
+	} // ( ... )*
+	except_choice_s_AST = RefAdaAST(currentAST.root);
+	returnAST = except_choice_s_AST;
+}
+
+void AdaParser::exception_choice() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST exception_choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		compound_name();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		exception_choice_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case OTHERS:
+	{
+		RefAdaAST tmp339_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp339_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp339_AST));
+		}
+		match(OTHERS);
+		exception_choice_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = exception_choice_AST;
+}
+
+void AdaParser::operator_call() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST operator_call_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	cs = LT(1);
+	if ( inputState->guessing == 0 ) {
+		cs_AST = astFactory->create(cs);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST));
+	}
+	match(CHAR_STRING);
+	operator_call_tail(cs_AST);
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	operator_call_AST = RefAdaAST(currentAST.root);
+	returnAST = operator_call_AST;
+}
+
+void AdaParser::operator_call_tail(
+	RefAdaAST opstr
+) {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST operator_call_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	match(LPAREN);
+	if (!( is_operator_symbol(opstr->getText().c_str()) ))
+		throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(opstr->getText().c_str()) ");
+	value_s();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(RPAREN);
+	if ( inputState->guessing==0 ) {
+#line 1401 "ada.g"
+		opstr->setType(OPERATOR_SYMBOL);
+#line 10908 "AdaParser.cpp"
+	}
+	operator_call_tail_AST = RefAdaAST(currentAST.root);
+	returnAST = operator_call_tail_AST;
+}
+
+void AdaParser::relation() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST relation_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	simple_expression();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{
+	switch ( LA(1)) {
+	case IN:
+	{
+		RefAdaAST tmp342_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp342_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp342_AST));
+		}
+		match(IN);
+		range_or_mark();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case NOT:
+	{
+		n = LT(1);
+		if ( inputState->guessing == 0 ) {
+			n_AST = astFactory->create(n);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+		}
+		match(NOT);
+		match(IN);
+		range_or_mark();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 1425 "ada.g"
+			Set (n_AST, NOT_IN);
+#line 10957 "AdaParser.cpp"
+		}
+		break;
+	}
+	case EQ:
+	{
+		RefAdaAST tmp344_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp344_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp344_AST));
+		}
+		match(EQ);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case NE:
+	{
+		RefAdaAST tmp345_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp345_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp345_AST));
+		}
+		match(NE);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case LT_:
+	{
+		RefAdaAST tmp346_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp346_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp346_AST));
+		}
+		match(LT_);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case LE:
+	{
+		RefAdaAST tmp347_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp347_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp347_AST));
+		}
+		match(LE);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case GT:
+	{
+		RefAdaAST tmp348_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp348_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp348_AST));
+		}
+		match(GT);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case GE:
+	{
+		RefAdaAST tmp349_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp349_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp349_AST));
+		}
+		match(GE);
+		simple_expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case SEMI:
+	case COMMA:
+	case RPAREN:
+	case RIGHT_SHAFT:
+	case WITH:
+	case RANGE:
+	case DIGITS:
+	case IS:
+	case PIPE:
+	case DOT_DOT:
+	case ASSIGN:
+	case THEN:
+	case LOOP:
+	case OR:
+	case AND:
+	case XOR:
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	relation_AST = RefAdaAST(currentAST.root);
+	returnAST = relation_AST;
+}
+
+void AdaParser::range_or_mark() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST range_or_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	bool synPredMatched455 = false;
+	if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) {
+		int _m455 = mark();
+		synPredMatched455 = true;
+		inputState->guessing++;
+		try {
+			{
+			range();
+			}
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+			synPredMatched455 = false;
+		}
+		rewind(_m455);
+		inputState->guessing--;
+	}
+	if ( synPredMatched455 ) {
+		range();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		range_or_mark_AST = RefAdaAST(currentAST.root);
+	}
+	else if ((LA(1) == IDENTIFIER) && (_tokenSet_30.member(LA(2)))) {
+		subtype_mark();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		range_or_mark_AST = RefAdaAST(currentAST.root);
+	}
+	else {
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	
+	returnAST = range_or_mark_AST;
+}
+
+void AdaParser::signed_term() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST signed_term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  m = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST m_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case PLUS:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PLUS);
+		term();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 1447 "ada.g"
+			Set(p_AST, UNARY_PLUS);
+#line 11141 "AdaParser.cpp"
+		}
+		signed_term_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case MINUS:
+	{
+		m = LT(1);
+		if ( inputState->guessing == 0 ) {
+			m_AST = astFactory->create(m);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(m_AST));
+		}
+		match(MINUS);
+		term();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+#line 1448 "ada.g"
+			Set(m_AST, UNARY_MINUS);
+#line 11161 "AdaParser.cpp"
+		}
+		signed_term_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NOT:
+	case ABS:
+	case NUMERIC_LIT:
+	{
+		term();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		signed_term_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = signed_term_AST;
+}
+
+void AdaParser::term() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	factor();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case STAR:
+		{
+			RefAdaAST tmp350_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp350_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp350_AST));
+			}
+			match(STAR);
+			factor();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case DIV:
+		{
+			RefAdaAST tmp351_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp351_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp351_AST));
+			}
+			match(DIV);
+			factor();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case MOD:
+		{
+			RefAdaAST tmp352_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp352_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp352_AST));
+			}
+			match(MOD);
+			factor();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case REM:
+		{
+			RefAdaAST tmp353_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp353_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp353_AST));
+			}
+			match(REM);
+			factor();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop462;
+		}
+		}
+	}
+	_loop462:;
+	} // ( ... )*
+	term_AST = RefAdaAST(currentAST.root);
+	returnAST = term_AST;
+}
+
+void AdaParser::factor() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST factor_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case NOT:
+	{
+		RefAdaAST tmp354_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp354_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp354_AST));
+		}
+		match(NOT);
+		primary();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case ABS:
+	{
+		RefAdaAST tmp355_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp355_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp355_AST));
+		}
+		match(ABS);
+		primary();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case IDENTIFIER:
+	case LPAREN:
+	case NEW:
+	case CHARACTER_LITERAL:
+	case CHAR_STRING:
+	case NuLL:
+	case NUMERIC_LIT:
+	{
+		primary();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case EXPON:
+		{
+			RefAdaAST tmp356_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp356_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp356_AST));
+			}
+			match(EXPON);
+			primary();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case COMMA:
+		case RPAREN:
+		case RIGHT_SHAFT:
+		case WITH:
+		case RANGE:
+		case DIGITS:
+		case IS:
+		case PIPE:
+		case DOT_DOT:
+		case IN:
+		case ASSIGN:
+		case MOD:
+		case THEN:
+		case LOOP:
+		case OR:
+		case AND:
+		case XOR:
+		case NOT:
+		case EQ:
+		case NE:
+		case LT_:
+		case LE:
+		case GT:
+		case GE:
+		case PLUS:
+		case MINUS:
+		case CONCAT:
+		case STAR:
+		case DIV:
+		case REM:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	factor_AST = RefAdaAST(currentAST.root);
+	returnAST = factor_AST;
+}
+
+void AdaParser::primary() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	{
+	switch ( LA(1)) {
+	case IDENTIFIER:
+	{
+		name_or_qualified();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case LPAREN:
+	{
+		parenthesized_primary();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case NEW:
+	{
+		allocator();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		break;
+	}
+	case NuLL:
+	{
+		RefAdaAST tmp357_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp357_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp357_AST));
+		}
+		match(NuLL);
+		break;
+	}
+	case NUMERIC_LIT:
+	{
+		RefAdaAST tmp358_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp358_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp358_AST));
+		}
+		match(NUMERIC_LIT);
+		break;
+	}
+	case CHARACTER_LITERAL:
+	{
+		RefAdaAST tmp359_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp359_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp359_AST));
+		}
+		match(CHARACTER_LITERAL);
+		break;
+	}
+	case CHAR_STRING:
+	{
+		cs = LT(1);
+		if ( inputState->guessing == 0 ) {
+			cs_AST = astFactory->create(cs);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST));
+		}
+		match(CHAR_STRING);
+		{
+		switch ( LA(1)) {
+		case LPAREN:
+		{
+			operator_call_tail(cs_AST);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case COMMA:
+		case RPAREN:
+		case RIGHT_SHAFT:
+		case WITH:
+		case RANGE:
+		case DIGITS:
+		case IS:
+		case PIPE:
+		case DOT_DOT:
+		case IN:
+		case ASSIGN:
+		case MOD:
+		case THEN:
+		case LOOP:
+		case OR:
+		case AND:
+		case XOR:
+		case NOT:
+		case EQ:
+		case NE:
+		case LT_:
+		case LE:
+		case GT:
+		case GE:
+		case PLUS:
+		case MINUS:
+		case CONCAT:
+		case STAR:
+		case DIV:
+		case REM:
+		case EXPON:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	}
+	primary_AST = RefAdaAST(currentAST.root);
+	returnAST = primary_AST;
+}
+
+void AdaParser::name_or_qualified() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST name_or_qualified_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+#line 1479 "ada.g"
+	RefAdaAST dummy;
+#line 11528 "AdaParser.cpp"
+	
+	RefAdaAST tmp360_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	if ( inputState->guessing == 0 ) {
+		tmp360_AST = astFactory->create(LT(1));
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp360_AST));
+	}
+	match(IDENTIFIER);
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case DOT:
+		{
+			RefAdaAST tmp361_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp361_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp361_AST));
+			}
+			match(DOT);
+			{
+			switch ( LA(1)) {
+			case ALL:
+			{
+				RefAdaAST tmp362_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp362_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp362_AST));
+				}
+				match(ALL);
+				break;
+			}
+			case IDENTIFIER:
+			{
+				RefAdaAST tmp363_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp363_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp363_AST));
+				}
+				match(IDENTIFIER);
+				break;
+			}
+			case CHARACTER_LITERAL:
+			{
+				RefAdaAST tmp364_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp364_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp364_AST));
+				}
+				match(CHARACTER_LITERAL);
+				break;
+			}
+			case CHAR_STRING:
+			{
+				dummy=is_operator();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case LPAREN:
+		{
+			p = LT(1);
+			if ( inputState->guessing == 0 ) {
+				p_AST = astFactory->create(p);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+			}
+			match(LPAREN);
+			value_s();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			if ( inputState->guessing==0 ) {
+#line 1487 "ada.g"
+				Set(p_AST, INDEXED_COMPONENT);
+#line 11611 "AdaParser.cpp"
+			}
+			break;
+		}
+		case TIC:
+		{
+			RefAdaAST tmp366_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp366_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp366_AST));
+			}
+			match(TIC);
+			{
+			switch ( LA(1)) {
+			case LPAREN:
+			{
+				parenthesized_primary();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case IDENTIFIER:
+			case RANGE:
+			case DIGITS:
+			case DELTA:
+			case ACCESS:
+			{
+				attribute_id();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		default:
+		{
+			goto _loop473;
+		}
+		}
+	}
+	_loop473:;
+	} // ( ... )*
+	name_or_qualified_AST = RefAdaAST(currentAST.root);
+	returnAST = name_or_qualified_AST;
+}
+
+void AdaParser::allocator() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST allocator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	n = LT(1);
+	if ( inputState->guessing == 0 ) {
+		n_AST = astFactory->create(n);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST));
+	}
+	match(NEW);
+	name_or_qualified();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	if ( inputState->guessing==0 ) {
+#line 1493 "ada.g"
+		Set(n_AST, ALLOCATOR);
+#line 11685 "AdaParser.cpp"
+	}
+	allocator_AST = RefAdaAST(currentAST.root);
+	returnAST = allocator_AST;
+}
+
+void AdaParser::subprogram_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST subprogram_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	switch ( LA(1)) {
+	case PROCEDURE:
+	{
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(PROCEDURE);
+		def_id(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		formal_part_opt();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(IS);
+		body_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 1507 "ada.g"
+			pop_def_id(); Set(p_AST, PROCEDURE_BODY);
+#line 11726 "AdaParser.cpp"
+		}
+		subprogram_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	case FUNCTION:
+	{
+		f = LT(1);
+		if ( inputState->guessing == 0 ) {
+			f_AST = astFactory->create(f);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+		}
+		match(FUNCTION);
+		def_designator(false);
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		function_tail();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(IS);
+		body_part();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		if ( inputState->guessing==0 ) {
+#line 1509 "ada.g"
+			pop_def_id(); Set(f_AST, FUNCTION_BODY);
+#line 11756 "AdaParser.cpp"
+		}
+		subprogram_body_AST = RefAdaAST(currentAST.root);
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+	}
+	}
+	returnAST = subprogram_body_AST;
+}
+
+void AdaParser::package_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST package_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	p = LT(1);
+	if ( inputState->guessing == 0 ) {
+		p_AST = astFactory->create(p);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+	}
+	match(PACKAGE);
+	body_is();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	pkg_body_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1513 "ada.g"
+		Set(p_AST, PACKAGE_BODY);
+#line 11794 "AdaParser.cpp"
+	}
+	package_body_AST = RefAdaAST(currentAST.root);
+	returnAST = package_body_AST;
+}
+
+void AdaParser::task_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST task_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	t = LT(1);
+	if ( inputState->guessing == 0 ) {
+		t_AST = astFactory->create(t);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST));
+	}
+	match(TASK);
+	body_is();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	body_part();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1517 "ada.g"
+		Set(t_AST, TASK_BODY);
+#line 11825 "AdaParser.cpp"
+	}
+	task_body_AST = RefAdaAST(currentAST.root);
+	returnAST = task_body_AST;
+}
+
+void AdaParser::protected_body() {
+	returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefAdaAST protected_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	p = LT(1);
+	if ( inputState->guessing == 0 ) {
+		p_AST = astFactory->create(p);
+		astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+	}
+	match(PROTECTED);
+	body_is();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	prot_op_bodies_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	end_id_opt();
+	if (inputState->guessing==0) {
+		astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+	}
+	match(SEMI);
+	if ( inputState->guessing==0 ) {
+#line 1521 "ada.g"
+		Set(p_AST, PROTECTED_BODY);
+#line 11860 "AdaParser.cpp"
+	}
+	protected_body_AST = RefAdaAST(currentAST.root);
+	returnAST = protected_body_AST;
+}
+
+void AdaParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
+{
+	factory.setMaxNodeType(289);
+}
+const char* AdaParser::tokenNames[] = {
+	"<0>",
+	"EOF",
+	"<2>",
+	"NULL_TREE_LOOKAHEAD",
+	"\"pragma\"",
+	"IDENTIFIER",
+	"SEMI",
+	"LPAREN",
+	"COMMA",
+	"RPAREN",
+	"RIGHT_SHAFT",
+	"\"with\"",
+	"DOT",
+	"\"use\"",
+	"\"type\"",
+	"TIC",
+	"\"range\"",
+	"\"digits\"",
+	"\"delta\"",
+	"\"access\"",
+	"\"private\"",
+	"\"package\"",
+	"\"body\"",
+	"\"is\"",
+	"\"procedure\"",
+	"\"function\"",
+	"\"new\"",
+	"\"others\"",
+	"PIPE",
+	"DOT_DOT",
+	"\"all\"",
+	"COLON",
+	"\"in\"",
+	"\"out\"",
+	"\"renames\"",
+	"CHARACTER_LITERAL",
+	"CHAR_STRING",
+	"\"null\"",
+	"\"record\"",
+	"\"separate\"",
+	"\"abstract\"",
+	"\"return\"",
+	"\"task\"",
+	"\"protected\"",
+	"BOX",
+	"ASSIGN",
+	"\"entry\"",
+	"\"for\"",
+	"\"end\"",
+	"\"at\"",
+	"\"mod\"",
+	"\"subtype\"",
+	"\"exception\"",
+	"\"constant\"",
+	"\"array\"",
+	"\"of\"",
+	"\"aliased\"",
+	"\"case\"",
+	"\"when\"",
+	"\"tagged\"",
+	"\"limited\"",
+	"\"generic\"",
+	"\"begin\"",
+	"LT_LT",
+	"GT_GT",
+	"\"if\"",
+	"\"then\"",
+	"\"elsif\"",
+	"\"else\"",
+	"\"loop\"",
+	"\"while\"",
+	"\"reverse\"",
+	"\"declare\"",
+	"\"exit\"",
+	"\"goto\"",
+	"\"accept\"",
+	"\"do\"",
+	"\"delay\"",
+	"\"until\"",
+	"\"select\"",
+	"\"abort\"",
+	"\"or\"",
+	"\"terminate\"",
+	"\"raise\"",
+	"\"requeue\"",
+	"\"and\"",
+	"\"xor\"",
+	"\"not\"",
+	"EQ",
+	"NE",
+	"LT_",
+	"LE",
+	"GT",
+	"GE",
+	"PLUS",
+	"MINUS",
+	"CONCAT",
+	"STAR",
+	"DIV",
+	"\"rem\"",
+	"\"abs\"",
+	"EXPON",
+	"NUMERIC_LIT",
+	"ABORTABLE_PART",
+	"ABORT_STATEMENT",
+	"ACCEPT_ALTERNATIVE",
+	"ACCEPT_STATEMENT",
+	"ALLOCATOR",
+	"ASSIGNMENT_STATEMENT",
+	"ASYNCHRONOUS_SELECT",
+	"ATTRIBUTE_DEFINITION_CLAUSE",
+	"AT_CLAUSE",
+	"BLOCK_STATEMENT",
+	"CASE_STATEMENT",
+	"CASE_STATEMENT_ALTERNATIVE",
+	"CODE_STATEMENT",
+	"COMPONENT_DECLARATION",
+	"CONDITIONAL_ENTRY_CALL",
+	"CONTEXT_CLAUSE",
+	"DECLARATIVE_PART",
+	"DEFINING_IDENTIFIER_LIST",
+	"DELAY_ALTERNATIVE",
+	"DELAY_STATEMENT",
+	"DELTA_CONSTRAINT",
+	"DIGITS_CONSTRAINT",
+	"DISCRIMINANT_ASSOCIATION",
+	"DISCRIMINANT_CONSTRAINT",
+	"DISCRIMINANT_SPECIFICATION",
+	"ENTRY_BODY",
+	"ENTRY_CALL_ALTERNATIVE",
+	"ENTRY_CALL_STATEMENT",
+	"ENTRY_DECLARATION",
+	"ENTRY_INDEX_SPECIFICATION",
+	"ENUMERATION_REPESENTATION_CLAUSE",
+	"EXCEPTION_DECLARATION",
+	"EXCEPTION_HANDLER",
+	"EXCEPTION_RENAMING_DECLARATION",
+	"EXIT_STATEMENT",
+	"FORMAL_PACKAGE_DECLARATION",
+	"GENERIC_FORMAL_PART",
+	"GENERIC_PACKAGE_DECLARATION",
+	"GOTO_STATEMENT",
+	"HANDLED_SEQUENCE_OF_STATEMENTS",
+	"HANDLED_STMTS_OPT",
+	"IF_STATEMENT",
+	"INCOMPLETE_TYPE_DECLARATION",
+	"INDEXED_COMPONENT",
+	"INDEX_CONSTRAINT",
+	"LIBRARY_ITEM",
+	"LOOP_STATEMENT",
+	"NAME",
+	"NULL_STATEMENT",
+	"NUMBER_DECLARATION",
+	"OBJECT_DECLARATION",
+	"OBJECT_RENAMING_DECLARATION",
+	"OPERATOR_SYMBOL",
+	"PACKAGE_BODY",
+	"PACKAGE_BODY_STUB",
+	"PACKAGE_RENAMING_DECLARATION",
+	"PACKAGE_SPECIFICATION",
+	"PARAMETER_SPECIFICATION",
+	"PRIVATE_EXTENSION_DECLARATION",
+	"PRIVATE_TYPE_DECLARATION",
+	"PROTECTED_BODY",
+	"PROTECTED_BODY_STUB",
+	"PROTECTED_TYPE_DECLARATION",
+	"RAISE_STATEMENT",
+	"RANGE_ATTRIBUTE_REFERENCE",
+	"RECORD_REPRESENTATION_CLAUSE",
+	"REQUEUE_STATEMENT",
+	"RETURN_STATEMENT",
+	"SELECTIVE_ACCEPT",
+	"SEQUENCE_OF_STATEMENTS",
+	"SINGLE_PROTECTED_DECLARATION",
+	"SINGLE_TASK_DECLARATION",
+	"STATEMENT",
+	"SUBTYPE_DECLARATION",
+	"SUBTYPE_INDICATION",
+	"SUBTYPE_MARK",
+	"SUBUNIT",
+	"TASK_BODY",
+	"TASK_BODY_STUB",
+	"TASK_TYPE_DECLARATION",
+	"TERMINATE_ALTERNATIVE",
+	"TIMED_ENTRY_CALL",
+	"TRIGGERING_ALTERNATIVE",
+	"USE_CLAUSE",
+	"USE_TYPE_CLAUSE",
+	"VARIANT",
+	"VARIANT_PART",
+	"WITH_CLAUSE",
+	"ABSTRACT_FUNCTION_DECLARATION",
+	"ABSTRACT_PROCEDURE_DECLARATION",
+	"ACCESS_TO_FUNCTION_DECLARATION",
+	"ACCESS_TO_OBJECT_DECLARATION",
+	"ACCESS_TO_PROCEDURE_DECLARATION",
+	"ARRAY_OBJECT_DECLARATION",
+	"ARRAY_TYPE_DECLARATION",
+	"AND_THEN",
+	"BASIC_DECLARATIVE_ITEMS_OPT",
+	"BLOCK_BODY",
+	"BLOCK_BODY_OPT",
+	"CALL_STATEMENT",
+	"COMPONENT_CLAUSES_OPT",
+	"COMPONENT_ITEMS",
+	"COND_CLAUSE",
+	"DECIMAL_FIXED_POINT_DECLARATION",
+	"DECLARE_OPT",
+	"DERIVED_RECORD_EXTENSION",
+	"DISCRETE_SUBTYPE_DEF_OPT",
+	"DISCRIMINANT_SPECIFICATIONS",
+	"DISCRIM_PART_OPT",
+	"ELSE_OPT",
+	"ELSIFS_OPT",
+	"END_ID_OPT",
+	"ENTRY_INDEX_OPT",
+	"ENUMERATION_TYPE_DECLARATION",
+	"EXCEPT_HANDLER_PART_OPT",
+	"EXTENSION_OPT",
+	"FLOATING_POINT_DECLARATION",
+	"FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
+	"FORMAL_DISCRETE_TYPE_DECLARATION",
+	"FORMAL_FLOATING_POINT_DECLARATION",
+	"FORMAL_FUNCTION_DECLARATION",
+	"FORMAL_MODULAR_TYPE_DECLARATION",
+	"FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
+	"FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
+	"FORMAL_PART_OPT",
+	"FORMAL_PRIVATE_EXTENSION_DECLARATION",
+	"FORMAL_PRIVATE_TYPE_DECLARATION",
+	"FORMAL_PROCEDURE_DECLARATION",
+	"FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
+	"FUNCTION_BODY",
+	"FUNCTION_BODY_STUB",
+	"FUNCTION_DECLARATION",
+	"FUNCTION_RENAMING_DECLARATION",
+	"GENERIC_FUNCTION_DECLARATION",
+	"GENERIC_FUNCTION_INSTANTIATION",
+	"GENERIC_FUNCTION_RENAMING",
+	"GENERIC_PACKAGE_INSTANTIATION",
+	"GENERIC_PACKAGE_RENAMING",
+	"GENERIC_PROCEDURE_DECLARATION",
+	"GENERIC_PROCEDURE_INSTANTIATION",
+	"GENERIC_PROCEDURE_RENAMING",
+	"GUARD_OPT",
+	"IDENTIFIER_COLON_OPT",
+	"ID_OPT",
+	"INIT_OPT",
+	"ITERATION_SCHEME_OPT",
+	"LABEL_OPT",
+	"MARK_WITH_CONSTRAINT",
+	"MODIFIERS",
+	"MODULAR_TYPE_DECLARATION",
+	"MOD_CLAUSE_OPT",
+	"NOT_IN",
+	"ORDINARY_DERIVED_TYPE_DECLARATION",
+	"ORDINARY_FIXED_POINT_DECLARATION",
+	"OR_ELSE",
+	"OR_SELECT_OPT",
+	"PARENTHESIZED_PRIMARY",
+	"PRIVATE_DECLARATIVE_ITEMS_OPT",
+	"PRIVATE_TASK_ITEMS_OPT",
+	"PROCEDURE_BODY",
+	"PROCEDURE_BODY_STUB",
+	"PROCEDURE_DECLARATION",
+	"PROCEDURE_RENAMING_DECLARATION",
+	"PROT_MEMBER_DECLARATIONS",
+	"PROT_OP_BODIES_OPT",
+	"PROT_OP_DECLARATIONS",
+	"PROT_PRIVATE_OPT",
+	"RANGED_EXPRS",
+	"RANGE_CONSTRAINT",
+	"RECORD_TYPE_DECLARATION",
+	"SELECTOR_NAMES_OPT",
+	"SIGNED_INTEGER_TYPE_DECLARATION",
+	"TASK_ITEMS_OPT",
+	"UNARY_MINUS",
+	"UNARY_PLUS",
+	"VALUE",
+	"VALUES",
+	"VARIANTS",
+	"COMMENT_INTRO",
+	"OX",
+	"TIC_OR_CHARACTER_LITERAL",
+	"DIGIT",
+	"EXPONENT",
+	"EXTENDED_DIGIT",
+	"BASED_INTEGER",
+	"WS_",
+	"COMMENT",
+	0
+};
+
+const unsigned long AdaParser::_tokenSet_0_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "not" PLUS 
+// MINUS "abs" NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10);
+const unsigned long AdaParser::_tokenSet_1_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN DOT TIC "new" "others" "in" CHARACTER_LITERAL 
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10);
+const unsigned long AdaParser::_tokenSet_2_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN "is" "renames" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10);
+const unsigned long AdaParser::_tokenSet_3_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" 
+// CHAR_STRING "separate" "abstract" "task" "protected" "for" "end" "subtype" 
+// "generic" "begin" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10);
+const unsigned long AdaParser::_tokenSet_4_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT "is" "in" "renames" "when" "do" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10);
+const unsigned long AdaParser::_tokenSet_5_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN "is" "in" "renames" "when" "do" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10);
+const unsigned long AdaParser::_tokenSet_6_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 
+// "function" CHAR_STRING "separate" "abstract" "task" "protected" "for" 
+// "end" "subtype" "generic" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10);
+const unsigned long AdaParser::_tokenSet_7_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN DOT "is" "return" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10);
+const unsigned long AdaParser::_tokenSet_8_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN DOT TIC "new" "others" DOT_DOT CHARACTER_LITERAL CHAR_STRING 
+// "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10);
+const unsigned long AdaParser::_tokenSet_9_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN "new" "others" CHARACTER_LITERAL CHAR_STRING "null" 
+// "not" PLUS MINUS "abs" NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10);
+const unsigned long AdaParser::_tokenSet_10_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "new" 
+// "others" PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" 
+// "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV 
+// "rem" "abs" EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10);
+const unsigned long AdaParser::_tokenSet_11_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT DOT TIC "range" "new" "others" 
+// PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" "or" "and" 
+// "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" "abs" 
+// EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10);
+const unsigned long AdaParser::_tokenSet_12_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER "constant" "array" "aliased" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10);
+const unsigned long AdaParser::_tokenSet_13_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN DOT TIC "range" "digits" "delta" ASSIGN "constant" 
+// "array" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10);
+const unsigned long AdaParser::_tokenSet_14_data_[] = { 51380274UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "pragma" IDENTIFIER "private" "procedure" "function" "entry" "for" 
+// "end" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10);
+const unsigned long AdaParser::_tokenSet_15_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN RPAREN DOT TIC "range" "digits" "delta" "loop" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10);
+const unsigned long AdaParser::_tokenSet_16_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" "procedure" "function" "entry" "for" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10);
+const unsigned long AdaParser::_tokenSet_17_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "private" "null" "record" "abstract" "tagged" "limited" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10);
+const unsigned long AdaParser::_tokenSet_18_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" IDENTIFIER SEMI "private" "null" "record" "case" "tagged" "limited" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10);
+const unsigned long AdaParser::_tokenSet_19_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN COMMA RPAREN DOT TIC "range" "digits" "delta" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10);
+const unsigned long AdaParser::_tokenSet_20_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN DOT TIC "range" "new" "others" DOT_DOT CHARACTER_LITERAL 
+// CHAR_STRING "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" 
+// EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10);
+const unsigned long AdaParser::_tokenSet_21_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER LPAREN RIGHT_SHAFT DOT TIC "new" "others" PIPE "in" CHARACTER_LITERAL 
+// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 
+// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10);
+const unsigned long AdaParser::_tokenSet_22_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "private" "abstract" "tagged" "limited" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10);
+const unsigned long AdaParser::_tokenSet_23_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "private" "tagged" "limited" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10);
+const unsigned long AdaParser::_tokenSet_24_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT TIC ASSIGN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10);
+const unsigned long AdaParser::_tokenSet_25_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN DOT TIC "new" CHARACTER_LITERAL CHAR_STRING "null" 
+// "until" "not" PLUS MINUS "abs" NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10);
+const unsigned long AdaParser::_tokenSet_26_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "when" "accept" "delay" "terminate" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10);
+const unsigned long AdaParser::_tokenSet_27_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENTIFIER SEMI LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "until" 
+// "not" PLUS MINUS "abs" NUMERIC_LIT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10);
+const unsigned long AdaParser::_tokenSet_28_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN DOT TIC 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10);
+const unsigned long AdaParser::_tokenSet_29_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "pragma" IDENTIFIER "null" "return" "for" "end" "exception" "case" "when" 
+// "begin" LT_LT "if" "then" "elsif" "else" "loop" "while" "declare" "exit" 
+// "goto" "accept" "delay" "select" "abort" "or" "raise" "requeue" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10);
+const unsigned long AdaParser::_tokenSet_30_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" "is" PIPE 
+// DOT_DOT ASSIGN "then" "loop" "or" "and" "xor" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10);
+
+