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, 6540 insertions, 0 deletions

diff --git a/languages/java/JavaRecognizer.cpp b/languages/java/JavaRecognizer.cpp
new file mode 100644
index 00000000..1021c6a0
--- /dev/null
+++ b/languages/java/JavaRecognizer.cpp
@@ -0,0 +1,6540 @@
+/* $ANTLR 2.7.7 (20061129): "java.g" -> "JavaRecognizer.cpp"$ */
+#include "JavaRecognizer.hpp"
+#include <antlr/NoViableAltException.hpp>
+#include <antlr/SemanticException.hpp>
+#include <antlr/ASTFactory.hpp>
+#line 1 "java.g"
+#line 8 "JavaRecognizer.cpp"
+JavaRecognizer::JavaRecognizer(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
+{
+}
+
+JavaRecognizer::JavaRecognizer(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
+{
+}
+
+JavaRecognizer::JavaRecognizer(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
+{
+}
+
+JavaRecognizer::JavaRecognizer(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
+{
+}
+
+JavaRecognizer::JavaRecognizer(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
+{
+}
+
+void JavaRecognizer::compilationUnit() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST compilationUnit_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_package:
+		{
+			packageDefinition();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
+		case FINAL:
+		case ABSTRACT:
+		case STRICTFP:
+		case SEMI:
+		case LITERAL_import:
+		case LITERAL_private:
+		case LITERAL_public:
+		case LITERAL_protected:
+		case LITERAL_static:
+		case LITERAL_transient:
+		case LITERAL_native:
+		case LITERAL_threadsafe:
+		case LITERAL_synchronized:
+		case LITERAL_volatile:
+		case LITERAL_class:
+		case LITERAL_interface:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LITERAL_import)) {
+				importDefinition();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop4;
+			}
+			
+		}
+		_loop4:;
+		} // ( ... )*
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_0.member(LA(1)))) {
+				typeDefinition();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop6;
+			}
+			
+		}
+		_loop6:;
+		} // ( ... )*
+		match(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
+		compilationUnit_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_1);
+		} else {
+			throw;
+		}
+	}
+	returnAST = compilationUnit_AST;
+}
+
+void JavaRecognizer::packageDefinition() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST packageDefinition_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST p_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		p = LT(1);
+		if ( inputState->guessing == 0 ) {
+			p_AST = astFactory->create(p);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST));
+		}
+		match(LITERAL_package);
+		if ( inputState->guessing==0 ) {
+#line 196 "java.g"
+			p_AST->setType(PACKAGE_DEF);
+#line 137 "JavaRecognizer.cpp"
+		}
+		identifier();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		packageDefinition_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_2);
+		} else {
+			throw;
+		}
+	}
+	returnAST = packageDefinition_AST;
+}
+
+void JavaRecognizer::importDefinition() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST importDefinition_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  i = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST i_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		i = LT(1);
+		if ( inputState->guessing == 0 ) {
+			i_AST = astFactory->create(i);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(i_AST));
+		}
+		match(LITERAL_import);
+		if ( inputState->guessing==0 ) {
+#line 202 "java.g"
+			i_AST->setType(IMPORT);
+#line 174 "JavaRecognizer.cpp"
+		}
+		identifierStar();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(SEMI);
+		importDefinition_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_2);
+		} else {
+			throw;
+		}
+	}
+	returnAST = importDefinition_AST;
+}
+
+void JavaRecognizer::typeDefinition() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST typeDefinition_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST m_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case FINAL:
+		case ABSTRACT:
+		case STRICTFP:
+		case LITERAL_private:
+		case LITERAL_public:
+		case LITERAL_protected:
+		case LITERAL_static:
+		case LITERAL_transient:
+		case LITERAL_native:
+		case LITERAL_threadsafe:
+		case LITERAL_synchronized:
+		case LITERAL_volatile:
+		case LITERAL_class:
+		case LITERAL_interface:
+		{
+			modifiers();
+			if (inputState->guessing==0) {
+				m_AST = returnAST;
+			}
+			{
+			switch ( LA(1)) {
+			case LITERAL_class:
+			{
+				classDefinition(m_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case LITERAL_interface:
+			{
+				interfaceDefinition(m_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());
+			}
+			}
+			}
+			typeDefinition_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case SEMI:
+		{
+			match(SEMI);
+			typeDefinition_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_3);
+		} else {
+			throw;
+		}
+	}
+	returnAST = typeDefinition_AST;
+}
+
+void JavaRecognizer::identifier() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST identifier_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp5_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp5_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp5_AST));
+		}
+		match(IDENT);
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == DOT)) {
+				RefJavaAST tmp6_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp6_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp6_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp7_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp7_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp7_AST));
+				}
+				match(IDENT);
+			}
+			else {
+				goto _loop23;
+			}
+			
+		}
+		_loop23:;
+		} // ( ... )*
+		identifier_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_4);
+		} else {
+			throw;
+		}
+	}
+	returnAST = identifier_AST;
+}
+
+void JavaRecognizer::identifierStar() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST identifierStar_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp8_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp8_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp8_AST));
+		}
+		match(IDENT);
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == DOT) && (LA(2) == IDENT)) {
+				RefJavaAST tmp9_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp9_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp10_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp10_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST));
+				}
+				match(IDENT);
+			}
+			else {
+				goto _loop26;
+			}
+			
+		}
+		_loop26:;
+		} // ( ... )*
+		{
+		switch ( LA(1)) {
+		case DOT:
+		{
+			RefJavaAST tmp11_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp11_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp11_AST));
+			}
+			match(DOT);
+			RefJavaAST tmp12_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp12_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp12_AST));
+			}
+			match(STAR);
+			break;
+		}
+		case SEMI:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		identifierStar_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_5);
+		} else {
+			throw;
+		}
+	}
+	returnAST = identifierStar_AST;
+}
+
+void JavaRecognizer::modifiers() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST modifiers_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_6.member(LA(1)))) {
+				modifier();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop30;
+			}
+			
+		}
+		_loop30:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+			modifiers_AST = RefJavaAST(currentAST.root);
+#line 290 "java.g"
+			modifiers_AST = RefJavaAST(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(modifiers_AST))));
+#line 420 "JavaRecognizer.cpp"
+			currentAST.root = modifiers_AST;
+			if ( modifiers_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				modifiers_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = modifiers_AST->getFirstChild();
+			else
+				currentAST.child = modifiers_AST;
+			currentAST.advanceChildToEnd();
+		}
+		modifiers_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_7);
+		} else {
+			throw;
+		}
+	}
+	returnAST = modifiers_AST;
+}
+
+void JavaRecognizer::classDefinition(
+	RefJavaAST modifiers
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST classDefinition_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST sc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST ic_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST cb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		match(LITERAL_class);
+		RefJavaAST tmp14_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp14_AST = astFactory->create(LT(1));
+		}
+		match(IDENT);
+		superClassClause();
+		if (inputState->guessing==0) {
+			sc_AST = returnAST;
+		}
+		implementsClause();
+		if (inputState->guessing==0) {
+			ic_AST = returnAST;
+		}
+		classBlock();
+		if (inputState->guessing==0) {
+			cb_AST = returnAST;
+		}
+		if ( inputState->guessing==0 ) {
+			classDefinition_AST = RefJavaAST(currentAST.root);
+#line 319 "java.g"
+			classDefinition_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(6))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CLASS_DEF,"CLASS_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(modifiers))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(tmp14_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(sc_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ic_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(cb_AST))));
+#line 475 "JavaRecognizer.cpp"
+			currentAST.root = classDefinition_AST;
+			if ( classDefinition_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				classDefinition_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = classDefinition_AST->getFirstChild();
+			else
+				currentAST.child = classDefinition_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_8);
+		} else {
+			throw;
+		}
+	}
+	returnAST = classDefinition_AST;
+}
+
+void JavaRecognizer::interfaceDefinition(
+	RefJavaAST modifiers
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST interfaceDefinition_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST ie_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST cb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		match(LITERAL_interface);
+		RefJavaAST tmp16_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp16_AST = astFactory->create(LT(1));
+		}
+		match(IDENT);
+		interfaceExtends();
+		if (inputState->guessing==0) {
+			ie_AST = returnAST;
+		}
+		classBlock();
+		if (inputState->guessing==0) {
+			cb_AST = returnAST;
+		}
+		if ( inputState->guessing==0 ) {
+			interfaceDefinition_AST = RefJavaAST(currentAST.root);
+#line 335 "java.g"
+			interfaceDefinition_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(5))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INTERFACE_DEF,"INTERFACE_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(modifiers))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(ie_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(cb_AST))));
+#line 524 "JavaRecognizer.cpp"
+			currentAST.root = interfaceDefinition_AST;
+			if ( interfaceDefinition_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				interfaceDefinition_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = interfaceDefinition_AST->getFirstChild();
+			else
+				currentAST.child = interfaceDefinition_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_9);
+		} else {
+			throw;
+		}
+	}
+	returnAST = interfaceDefinition_AST;
+}
+
+/** A declaration is the creation of a reference or primitive-type variable
+ *  Create a separate Type/Var tree for each var in the var list.
+ */
+void JavaRecognizer::declaration() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST declaration_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST m_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST t_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST v_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		modifiers();
+		if (inputState->guessing==0) {
+			m_AST = returnAST;
+		}
+		typeSpec(false);
+		if (inputState->guessing==0) {
+			t_AST = returnAST;
+		}
+		variableDefinitions(m_AST,t_AST);
+		if (inputState->guessing==0) {
+			v_AST = returnAST;
+		}
+		if ( inputState->guessing==0 ) {
+			declaration_AST = RefJavaAST(currentAST.root);
+#line 220 "java.g"
+			declaration_AST = v_AST;
+#line 573 "JavaRecognizer.cpp"
+			currentAST.root = declaration_AST;
+			if ( declaration_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				declaration_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = declaration_AST->getFirstChild();
+			else
+				currentAST.child = declaration_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_5);
+		} else {
+			throw;
+		}
+	}
+	returnAST = declaration_AST;
+}
+
+void JavaRecognizer::typeSpec(
+	bool addImagNode
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST typeSpec_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case IDENT:
+		{
+			classTypeSpec(addImagNode);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			typeSpec_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		{
+			builtInTypeSpec(addImagNode);
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			typeSpec_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_10);
+		} else {
+			throw;
+		}
+	}
+	returnAST = typeSpec_AST;
+}
+
+void JavaRecognizer::variableDefinitions(
+	RefJavaAST mods, RefJavaAST t
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST variableDefinitions_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		variableDeclarator((RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)mods),
+				   (RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)t));
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == COMMA)) {
+				match(COMMA);
+				variableDeclarator((RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)mods),
+					   (RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)t));
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop59;
+			}
+			
+		}
+		_loop59:;
+		} // ( ... )*
+		variableDefinitions_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_5);
+		} else {
+			throw;
+		}
+	}
+	returnAST = variableDefinitions_AST;
+}
+
+void JavaRecognizer::classTypeSpec(
+	bool addImagNode
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST classTypeSpec_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		identifier();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LBRACK)) {
+				lb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lb_AST = astFactory->create(lb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lb_AST));
+				}
+				match(LBRACK);
+				if ( inputState->guessing==0 ) {
+#line 233 "java.g"
+					lb_AST->setType(ARRAY_DECLARATOR);
+#line 715 "JavaRecognizer.cpp"
+				}
+				match(RBRACK);
+			}
+			else {
+				goto _loop15;
+			}
+			
+		}
+		_loop15:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+			classTypeSpec_AST = RefJavaAST(currentAST.root);
+#line 234 "java.g"
+			
+						if ( addImagNode ) {
+							classTypeSpec_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TYPE,"TYPE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(classTypeSpec_AST))));
+						}
+					
+#line 734 "JavaRecognizer.cpp"
+			currentAST.root = classTypeSpec_AST;
+			if ( classTypeSpec_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				classTypeSpec_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = classTypeSpec_AST->getFirstChild();
+			else
+				currentAST.child = classTypeSpec_AST;
+			currentAST.advanceChildToEnd();
+		}
+		classTypeSpec_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_10);
+		} else {
+			throw;
+		}
+	}
+	returnAST = classTypeSpec_AST;
+}
+
+void JavaRecognizer::builtInTypeSpec(
+	bool addImagNode
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST builtInTypeSpec_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		builtInType();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LBRACK)) {
+				lb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lb_AST = astFactory->create(lb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lb_AST));
+				}
+				match(LBRACK);
+				if ( inputState->guessing==0 ) {
+#line 244 "java.g"
+					lb_AST->setType(ARRAY_DECLARATOR);
+#line 782 "JavaRecognizer.cpp"
+				}
+				match(RBRACK);
+			}
+			else {
+				goto _loop18;
+			}
+			
+		}
+		_loop18:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+			builtInTypeSpec_AST = RefJavaAST(currentAST.root);
+#line 245 "java.g"
+			
+						if ( addImagNode ) {
+							builtInTypeSpec_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TYPE,"TYPE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(builtInTypeSpec_AST))));
+						}
+					
+#line 801 "JavaRecognizer.cpp"
+			currentAST.root = builtInTypeSpec_AST;
+			if ( builtInTypeSpec_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				builtInTypeSpec_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = builtInTypeSpec_AST->getFirstChild();
+			else
+				currentAST.child = builtInTypeSpec_AST;
+			currentAST.advanceChildToEnd();
+		}
+		builtInTypeSpec_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_10);
+		} else {
+			throw;
+		}
+	}
+	returnAST = builtInTypeSpec_AST;
+}
+
+void JavaRecognizer::builtInType() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST builtInType_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case LITERAL_void:
+		{
+			RefJavaAST tmp20_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp20_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST));
+			}
+			match(LITERAL_void);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_boolean:
+		{
+			RefJavaAST tmp21_AST = RefJavaAST(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(LITERAL_boolean);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_byte:
+		{
+			RefJavaAST tmp22_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp22_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
+			}
+			match(LITERAL_byte);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_char:
+		{
+			RefJavaAST tmp23_AST = RefJavaAST(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(LITERAL_char);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_short:
+		{
+			RefJavaAST tmp24_AST = RefJavaAST(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(LITERAL_short);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_int:
+		{
+			RefJavaAST tmp25_AST = RefJavaAST(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(LITERAL_int);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_float:
+		{
+			RefJavaAST tmp26_AST = RefJavaAST(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(LITERAL_float);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_long:
+		{
+			RefJavaAST tmp27_AST = RefJavaAST(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(LITERAL_long);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_double:
+		{
+			RefJavaAST tmp28_AST = RefJavaAST(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(LITERAL_double);
+			builtInType_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_11);
+		} else {
+			throw;
+		}
+	}
+	returnAST = builtInType_AST;
+}
+
+void JavaRecognizer::type() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST type_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case IDENT:
+		{
+			identifier();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			type_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		{
+			builtInType();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			type_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_12);
+		} else {
+			throw;
+		}
+	}
+	returnAST = type_AST;
+}
+
+void JavaRecognizer::modifier() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST modifier_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case LITERAL_private:
+		{
+			RefJavaAST tmp29_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp29_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp29_AST));
+			}
+			match(LITERAL_private);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_public:
+		{
+			RefJavaAST tmp30_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp30_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST));
+			}
+			match(LITERAL_public);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_protected:
+		{
+			RefJavaAST tmp31_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp31_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST));
+			}
+			match(LITERAL_protected);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_static:
+		{
+			RefJavaAST tmp32_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp32_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp32_AST));
+			}
+			match(LITERAL_static);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_transient:
+		{
+			RefJavaAST tmp33_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp33_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST));
+			}
+			match(LITERAL_transient);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case FINAL:
+		{
+			RefJavaAST tmp34_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp34_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp34_AST));
+			}
+			match(FINAL);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case ABSTRACT:
+		{
+			RefJavaAST tmp35_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp35_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp35_AST));
+			}
+			match(ABSTRACT);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_native:
+		{
+			RefJavaAST tmp36_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp36_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp36_AST));
+			}
+			match(LITERAL_native);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_threadsafe:
+		{
+			RefJavaAST tmp37_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp37_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST));
+			}
+			match(LITERAL_threadsafe);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_synchronized:
+		{
+			RefJavaAST tmp38_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp38_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp38_AST));
+			}
+			match(LITERAL_synchronized);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_volatile:
+		{
+			RefJavaAST tmp39_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp39_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp39_AST));
+			}
+			match(LITERAL_volatile);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case STRICTFP:
+		{
+			RefJavaAST tmp40_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp40_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp40_AST));
+			}
+			match(STRICTFP);
+			modifier_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_13);
+		} else {
+			throw;
+		}
+	}
+	returnAST = modifier_AST;
+}
+
+void JavaRecognizer::superClassClause() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST superClassClause_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST id_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_extends:
+		{
+			match(LITERAL_extends);
+			identifier();
+			if (inputState->guessing==0) {
+				id_AST = returnAST;
+			}
+			break;
+		}
+		case LCURLY:
+		case LITERAL_implements:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			superClassClause_AST = RefJavaAST(currentAST.root);
+#line 325 "java.g"
+			superClassClause_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST))));
+#line 1185 "JavaRecognizer.cpp"
+			currentAST.root = superClassClause_AST;
+			if ( superClassClause_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				superClassClause_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = superClassClause_AST->getFirstChild();
+			else
+				currentAST.child = superClassClause_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_14);
+		} else {
+			throw;
+		}
+	}
+	returnAST = superClassClause_AST;
+}
+
+void JavaRecognizer::implementsClause() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST implementsClause_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  i = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST i_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_implements:
+		{
+			i = LT(1);
+			if ( inputState->guessing == 0 ) {
+				i_AST = astFactory->create(i);
+			}
+			match(LITERAL_implements);
+			identifier();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == COMMA)) {
+					match(COMMA);
+					identifier();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop46;
+				}
+				
+			}
+			_loop46:;
+			} // ( ... )*
+			break;
+		}
+		case LCURLY:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			implementsClause_AST = RefJavaAST(currentAST.root);
+#line 363 "java.g"
+			implementsClause_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(implementsClause_AST))));
+#line 1259 "JavaRecognizer.cpp"
+			currentAST.root = implementsClause_AST;
+			if ( implementsClause_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				implementsClause_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = implementsClause_AST->getFirstChild();
+			else
+				currentAST.child = implementsClause_AST;
+			currentAST.advanceChildToEnd();
+		}
+		implementsClause_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_15);
+		} else {
+			throw;
+		}
+	}
+	returnAST = implementsClause_AST;
+}
+
+void JavaRecognizer::classBlock() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST classBlock_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		match(LCURLY);
+		{ // ( ... )*
+		for (;;) {
+			switch ( LA(1)) {
+			case FINAL:
+			case ABSTRACT:
+			case STRICTFP:
+			case LITERAL_void:
+			case LITERAL_boolean:
+			case LITERAL_byte:
+			case LITERAL_char:
+			case LITERAL_short:
+			case LITERAL_int:
+			case LITERAL_float:
+			case LITERAL_long:
+			case LITERAL_double:
+			case IDENT:
+			case LITERAL_private:
+			case LITERAL_public:
+			case LITERAL_protected:
+			case LITERAL_static:
+			case LITERAL_transient:
+			case LITERAL_native:
+			case LITERAL_threadsafe:
+			case LITERAL_synchronized:
+			case LITERAL_volatile:
+			case LITERAL_class:
+			case LITERAL_interface:
+			case LCURLY:
+			{
+				field();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case SEMI:
+			{
+				match(SEMI);
+				break;
+			}
+			default:
+			{
+				goto _loop38;
+			}
+			}
+		}
+		_loop38:;
+		} // ( ... )*
+		match(RCURLY);
+		if ( inputState->guessing==0 ) {
+			classBlock_AST = RefJavaAST(currentAST.root);
+#line 345 "java.g"
+			classBlock_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(OBJBLOCK,"OBJBLOCK")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(classBlock_AST))));
+#line 1341 "JavaRecognizer.cpp"
+			currentAST.root = classBlock_AST;
+			if ( classBlock_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				classBlock_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = classBlock_AST->getFirstChild();
+			else
+				currentAST.child = classBlock_AST;
+			currentAST.advanceChildToEnd();
+		}
+		classBlock_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_16);
+		} else {
+			throw;
+		}
+	}
+	returnAST = classBlock_AST;
+}
+
+void JavaRecognizer::interfaceExtends() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST interfaceExtends_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST e_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_extends:
+		{
+			e = LT(1);
+			if ( inputState->guessing == 0 ) {
+				e_AST = astFactory->create(e);
+			}
+			match(LITERAL_extends);
+			identifier();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == COMMA)) {
+					match(COMMA);
+					identifier();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop42;
+				}
+				
+			}
+			_loop42:;
+			} // ( ... )*
+			break;
+		}
+		case LCURLY:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			interfaceExtends_AST = RefJavaAST(currentAST.root);
+#line 354 "java.g"
+			interfaceExtends_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(interfaceExtends_AST))));
+#line 1416 "JavaRecognizer.cpp"
+			currentAST.root = interfaceExtends_AST;
+			if ( interfaceExtends_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				interfaceExtends_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = interfaceExtends_AST->getFirstChild();
+			else
+				currentAST.child = interfaceExtends_AST;
+			currentAST.advanceChildToEnd();
+		}
+		interfaceExtends_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_15);
+		} else {
+			throw;
+		}
+	}
+	returnAST = interfaceExtends_AST;
+}
+
+void JavaRecognizer::field() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST field_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST mods_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST h_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST s_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST cd_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST id_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST t_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST param_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST rt_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST tc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST s2_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST v_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST s3_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST s4_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		if ((_tokenSet_13.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
+			modifiers();
+			if (inputState->guessing==0) {
+				mods_AST = returnAST;
+			}
+			{
+			switch ( LA(1)) {
+			case LITERAL_class:
+			{
+				classDefinition(mods_AST);
+				if (inputState->guessing==0) {
+					cd_AST = returnAST;
+				}
+				if ( inputState->guessing==0 ) {
+					field_AST = RefJavaAST(currentAST.root);
+#line 378 "java.g"
+					field_AST = cd_AST;
+#line 1474 "JavaRecognizer.cpp"
+					currentAST.root = field_AST;
+					if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+						field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+						  currentAST.child = field_AST->getFirstChild();
+					else
+						currentAST.child = field_AST;
+					currentAST.advanceChildToEnd();
+				}
+				break;
+			}
+			case LITERAL_interface:
+			{
+				interfaceDefinition(mods_AST);
+				if (inputState->guessing==0) {
+					id_AST = returnAST;
+				}
+				if ( inputState->guessing==0 ) {
+					field_AST = RefJavaAST(currentAST.root);
+#line 381 "java.g"
+					field_AST = id_AST;
+#line 1495 "JavaRecognizer.cpp"
+					currentAST.root = field_AST;
+					if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+						field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+						  currentAST.child = field_AST->getFirstChild();
+					else
+						currentAST.child = field_AST;
+					currentAST.advanceChildToEnd();
+				}
+				break;
+			}
+			default:
+				if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
+					ctorHead();
+					if (inputState->guessing==0) {
+						h_AST = returnAST;
+					}
+					constructorBody();
+					if (inputState->guessing==0) {
+						s_AST = returnAST;
+					}
+					if ( inputState->guessing==0 ) {
+						field_AST = RefJavaAST(currentAST.root);
+#line 375 "java.g"
+						field_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(4))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CTOR_DEF,"CTOR_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mods_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(h_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST))));
+#line 1520 "JavaRecognizer.cpp"
+						currentAST.root = field_AST;
+						if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+							field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+							  currentAST.child = field_AST->getFirstChild();
+						else
+							currentAST.child = field_AST;
+						currentAST.advanceChildToEnd();
+					}
+				}
+				else if (((LA(1) >= LITERAL_void && LA(1) <= IDENT)) && (_tokenSet_18.member(LA(2)))) {
+					typeSpec(false);
+					if (inputState->guessing==0) {
+						t_AST = returnAST;
+					}
+					{
+					if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
+						RefJavaAST tmp47_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp47_AST = astFactory->create(LT(1));
+						}
+						match(IDENT);
+						match(LPAREN);
+						parameterDeclarationList();
+						if (inputState->guessing==0) {
+							param_AST = returnAST;
+						}
+						match(RPAREN);
+						declaratorBrackets(t_AST);
+						if (inputState->guessing==0) {
+							rt_AST = returnAST;
+						}
+						{
+						switch ( LA(1)) {
+						case LITERAL_throws:
+						{
+							throwsClause();
+							if (inputState->guessing==0) {
+								tc_AST = returnAST;
+							}
+							break;
+						}
+						case SEMI:
+						case LCURLY:
+						{
+							break;
+						}
+						default:
+						{
+							throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+						}
+						}
+						}
+						{
+						switch ( LA(1)) {
+						case LCURLY:
+						{
+							compoundStatement();
+							if (inputState->guessing==0) {
+								s2_AST = returnAST;
+							}
+							break;
+						}
+						case SEMI:
+						{
+							RefJavaAST tmp50_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+							if ( inputState->guessing == 0 ) {
+								tmp50_AST = astFactory->create(LT(1));
+							}
+							match(SEMI);
+							break;
+						}
+						default:
+						{
+							throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+						}
+						}
+						}
+						if ( inputState->guessing==0 ) {
+							field_AST = RefJavaAST(currentAST.root);
+#line 396 "java.g"
+							field_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(7))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(METHOD_DEF,"METHOD_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mods_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TYPE,"TYPE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(rt_AST))))))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(tmp47_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(param_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(tc_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s2_AST))));
+#line 1602 "JavaRecognizer.cpp"
+							currentAST.root = field_AST;
+							if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+								field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+								  currentAST.child = field_AST->getFirstChild();
+							else
+								currentAST.child = field_AST;
+							currentAST.advanceChildToEnd();
+						}
+					}
+					else if ((LA(1) == IDENT) && (_tokenSet_19.member(LA(2)))) {
+						variableDefinitions(mods_AST,t_AST);
+						if (inputState->guessing==0) {
+							v_AST = returnAST;
+						}
+						RefJavaAST tmp51_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp51_AST = astFactory->create(LT(1));
+						}
+						match(SEMI);
+						if ( inputState->guessing==0 ) {
+							field_AST = RefJavaAST(currentAST.root);
+#line 405 "java.g"
+							field_AST = v_AST;
+#line 1626 "JavaRecognizer.cpp"
+							currentAST.root = field_AST;
+							if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+								field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+								  currentAST.child = field_AST->getFirstChild();
+							else
+								currentAST.child = field_AST;
+							currentAST.advanceChildToEnd();
+						}
+					}
+					else {
+						throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+					}
+					
+					}
+				}
+			else {
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+		}
+		else if ((LA(1) == LITERAL_static) && (LA(2) == LCURLY)) {
+			match(LITERAL_static);
+			compoundStatement();
+			if (inputState->guessing==0) {
+				s3_AST = returnAST;
+			}
+			if ( inputState->guessing==0 ) {
+				field_AST = RefJavaAST(currentAST.root);
+#line 411 "java.g"
+				field_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STATIC_INIT,"STATIC_INIT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s3_AST))));
+#line 1658 "JavaRecognizer.cpp"
+				currentAST.root = field_AST;
+				if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+					field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+					  currentAST.child = field_AST->getFirstChild();
+				else
+					currentAST.child = field_AST;
+				currentAST.advanceChildToEnd();
+			}
+		}
+		else if ((LA(1) == LCURLY)) {
+			compoundStatement();
+			if (inputState->guessing==0) {
+				s4_AST = returnAST;
+			}
+			if ( inputState->guessing==0 ) {
+				field_AST = RefJavaAST(currentAST.root);
+#line 415 "java.g"
+				field_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INSTANCE_INIT,"INSTANCE_INIT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s4_AST))));
+#line 1677 "JavaRecognizer.cpp"
+				currentAST.root = field_AST;
+				if ( field_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+					field_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+					  currentAST.child = field_AST->getFirstChild();
+				else
+					currentAST.child = field_AST;
+				currentAST.advanceChildToEnd();
+			}
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_20);
+		} else {
+			throw;
+		}
+	}
+	returnAST = field_AST;
+}
+
+void JavaRecognizer::ctorHead() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST ctorHead_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp53_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp53_AST = astFactory->create(LT(1));
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp53_AST));
+		}
+		match(IDENT);
+		match(LPAREN);
+		parameterDeclarationList();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+		{
+		switch ( LA(1)) {
+		case LITERAL_throws:
+		{
+			throwsClause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case LCURLY:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		ctorHead_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_15);
+		} else {
+			throw;
+		}
+	}
+	returnAST = ctorHead_AST;
+}
+
+void JavaRecognizer::constructorBody() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST constructorBody_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lc = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		lc = LT(1);
+		if ( inputState->guessing == 0 ) {
+			lc_AST = astFactory->create(lc);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lc_AST));
+		}
+		match(LCURLY);
+		if ( inputState->guessing==0 ) {
+#line 419 "java.g"
+			lc_AST->setType(SLIST);
+#line 1771 "JavaRecognizer.cpp"
+		}
+		{
+		if ((LA(1) == LITERAL_this || LA(1) == LITERAL_super) && (LA(2) == LPAREN)) {
+			explicitConstructorInvocation();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else if ((_tokenSet_21.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_23.member(LA(1)))) {
+				statement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop55;
+			}
+			
+		}
+		_loop55:;
+		} // ( ... )*
+		match(RCURLY);
+		constructorBody_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_20);
+		} else {
+			throw;
+		}
+	}
+	returnAST = constructorBody_AST;
+}
+
+void JavaRecognizer::parameterDeclarationList() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST parameterDeclarationList_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case FINAL:
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		{
+			parameterDeclaration();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == COMMA)) {
+					match(COMMA);
+					parameterDeclaration();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop80;
+				}
+				
+			}
+			_loop80:;
+			} // ( ... )*
+			break;
+		}
+		case RPAREN:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			parameterDeclarationList_AST = RefJavaAST(currentAST.root);
+#line 508 "java.g"
+			parameterDeclarationList_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETERS,"PARAMETERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(parameterDeclarationList_AST))));
+#line 1872 "JavaRecognizer.cpp"
+			currentAST.root = parameterDeclarationList_AST;
+			if ( parameterDeclarationList_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				parameterDeclarationList_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = parameterDeclarationList_AST->getFirstChild();
+			else
+				currentAST.child = parameterDeclarationList_AST;
+			currentAST.advanceChildToEnd();
+		}
+		parameterDeclarationList_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_24);
+		} else {
+			throw;
+		}
+	}
+	returnAST = parameterDeclarationList_AST;
+}
+
+void JavaRecognizer::declaratorBrackets(
+	RefJavaAST typ
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST declaratorBrackets_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		if ( inputState->guessing==0 ) {
+			declaratorBrackets_AST = RefJavaAST(currentAST.root);
+#line 452 "java.g"
+			declaratorBrackets_AST=typ;
+#line 1908 "JavaRecognizer.cpp"
+			currentAST.root = declaratorBrackets_AST;
+			if ( declaratorBrackets_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				declaratorBrackets_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = declaratorBrackets_AST->getFirstChild();
+			else
+				currentAST.child = declaratorBrackets_AST;
+			currentAST.advanceChildToEnd();
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LBRACK)) {
+				lb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lb_AST = astFactory->create(lb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lb_AST));
+				}
+				match(LBRACK);
+				if ( inputState->guessing==0 ) {
+#line 453 "java.g"
+					lb_AST->setType(ARRAY_DECLARATOR);
+#line 1929 "JavaRecognizer.cpp"
+				}
+				match(RBRACK);
+			}
+			else {
+				goto _loop63;
+			}
+			
+		}
+		_loop63:;
+		} // ( ... )*
+		declaratorBrackets_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_25);
+		} else {
+			throw;
+		}
+	}
+	returnAST = declaratorBrackets_AST;
+}
+
+void JavaRecognizer::throwsClause() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST throwsClause_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp59_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp59_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp59_AST));
+		}
+		match(LITERAL_throws);
+		identifier();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == COMMA)) {
+				match(COMMA);
+				identifier();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop76;
+			}
+			
+		}
+		_loop76:;
+		} // ( ... )*
+		throwsClause_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_26);
+		} else {
+			throw;
+		}
+	}
+	returnAST = throwsClause_AST;
+}
+
+void JavaRecognizer::compoundStatement() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST compoundStatement_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lc = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		lc = LT(1);
+		if ( inputState->guessing == 0 ) {
+			lc_AST = astFactory->create(lc);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lc_AST));
+		}
+		match(LCURLY);
+		if ( inputState->guessing==0 ) {
+#line 535 "java.g"
+			lc_AST->setType(SLIST);
+#line 2015 "JavaRecognizer.cpp"
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_23.member(LA(1)))) {
+				statement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop86;
+			}
+			
+		}
+		_loop86:;
+		} // ( ... )*
+		match(RCURLY);
+		compoundStatement_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_27);
+		} else {
+			throw;
+		}
+	}
+	returnAST = compoundStatement_AST;
+}
+
+/** Catch obvious constructor calls, but not the expr.super(...) calls */
+void JavaRecognizer::explicitConstructorInvocation() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST explicitConstructorInvocation_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp1 = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp1_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp2 = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp2_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case LITERAL_this:
+		{
+			match(LITERAL_this);
+			lp1 = LT(1);
+			if ( inputState->guessing == 0 ) {
+				lp1_AST = astFactory->create(lp1);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp1_AST));
+			}
+			match(LPAREN);
+			argList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			match(SEMI);
+			if ( inputState->guessing==0 ) {
+#line 428 "java.g"
+				lp1_AST->setType(CTOR_CALL);
+#line 2076 "JavaRecognizer.cpp"
+			}
+			explicitConstructorInvocation_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_super:
+		{
+			match(LITERAL_super);
+			lp2 = LT(1);
+			if ( inputState->guessing == 0 ) {
+				lp2_AST = astFactory->create(lp2);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp2_AST));
+			}
+			match(LPAREN);
+			argList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			match(SEMI);
+			if ( inputState->guessing==0 ) {
+#line 430 "java.g"
+				lp2_AST->setType(SUPER_CTOR_CALL);
+#line 2099 "JavaRecognizer.cpp"
+			}
+			explicitConstructorInvocation_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_21);
+		} else {
+			throw;
+		}
+	}
+	returnAST = explicitConstructorInvocation_AST;
+}
+
+void JavaRecognizer::statement() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST statement_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST m_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST c_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST s_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case LCURLY:
+		{
+			compoundStatement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_if:
+		{
+			RefJavaAST tmp68_AST = RefJavaAST(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(LITERAL_if);
+			match(LPAREN);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			if ((LA(1) == LITERAL_else) && (_tokenSet_23.member(LA(2)))) {
+				match(LITERAL_else);
+				statement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
+			}
+			else {
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_for:
+		{
+			RefJavaAST tmp72_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp72_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp72_AST));
+			}
+			match(LITERAL_for);
+			match(LPAREN);
+			forInit();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(SEMI);
+			forCond();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(SEMI);
+			forIter();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_while:
+		{
+			RefJavaAST tmp77_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp77_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp77_AST));
+			}
+			match(LITERAL_while);
+			match(LPAREN);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_do:
+		{
+			RefJavaAST tmp80_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp80_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST));
+			}
+			match(LITERAL_do);
+			statement();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(LITERAL_while);
+			match(LPAREN);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			match(SEMI);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_break:
+		{
+			RefJavaAST tmp85_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp85_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp85_AST));
+			}
+			match(LITERAL_break);
+			{
+			switch ( LA(1)) {
+			case IDENT:
+			{
+				RefJavaAST tmp86_AST = RefJavaAST(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(IDENT);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_continue:
+		{
+			RefJavaAST tmp88_AST = RefJavaAST(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(LITERAL_continue);
+			{
+			switch ( LA(1)) {
+			case IDENT:
+			{
+				RefJavaAST tmp89_AST = RefJavaAST(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(IDENT);
+				break;
+			}
+			case SEMI:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			match(SEMI);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_return:
+		{
+			RefJavaAST tmp91_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp91_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp91_AST));
+			}
+			match(LITERAL_return);
+			{
+			switch ( LA(1)) {
+			case LITERAL_void:
+			case LITERAL_boolean:
+			case LITERAL_byte:
+			case LITERAL_char:
+			case LITERAL_short:
+			case LITERAL_int:
+			case LITERAL_float:
+			case LITERAL_long:
+			case LITERAL_double:
+			case IDENT:
+			case LPAREN:
+			case LITERAL_this:
+			case LITERAL_super:
+			case PLUS:
+			case MINUS:
+			case INC:
+			case DEC:
+			case BNOT:
+			case LNOT:
+			case LITERAL_true:
+			case LITERAL_false:
+			case LITERAL_null:
+			case LITERAL_new:
+			case NUM_INT:
+			case CHAR_LITERAL:
+			case STRING_LITERAL:
+			case NUM_FLOAT:
+			case NUM_LONG:
+			case NUM_DOUBLE:
+			{
+				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);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_switch:
+		{
+			RefJavaAST tmp93_AST = RefJavaAST(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(LITERAL_switch);
+			match(LPAREN);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			match(LCURLY);
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)) {
+					casesGroup();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop95;
+				}
+				
+			}
+			_loop95:;
+			} // ( ... )*
+			match(RCURLY);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_try:
+		{
+			tryBlock();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_throw:
+		{
+			RefJavaAST tmp98_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp98_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp98_AST));
+			}
+			match(LITERAL_throw);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(SEMI);
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case SEMI:
+		{
+			s = LT(1);
+			if ( inputState->guessing == 0 ) {
+				s_AST = astFactory->create(s);
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST));
+			}
+			match(SEMI);
+			if ( inputState->guessing==0 ) {
+#line 617 "java.g"
+				s_AST->setType(EMPTY_STAT);
+#line 2451 "JavaRecognizer.cpp"
+			}
+			statement_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+			bool synPredMatched89 = false;
+			if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
+				int _m89 = mark();
+				synPredMatched89 = true;
+				inputState->guessing++;
+				try {
+					{
+					declaration();
+					}
+				}
+				catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+					synPredMatched89 = false;
+				}
+				rewind(_m89);
+				inputState->guessing--;
+			}
+			if ( synPredMatched89 ) {
+				declaration();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(SEMI);
+				statement_AST = RefJavaAST(currentAST.root);
+			}
+			else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
+				expression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(SEMI);
+				statement_AST = RefJavaAST(currentAST.root);
+			}
+			else if ((_tokenSet_34.member(LA(1))) && (_tokenSet_35.member(LA(2)))) {
+				modifiers();
+				if (inputState->guessing==0) {
+					m_AST = returnAST;
+				}
+				classDefinition(m_AST);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				statement_AST = RefJavaAST(currentAST.root);
+			}
+			else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+				RefJavaAST tmp102_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp102_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp102_AST));
+				}
+				match(IDENT);
+				c = LT(1);
+				if ( inputState->guessing == 0 ) {
+					c_AST = astFactory->create(c);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST));
+				}
+				match(COLON);
+				if ( inputState->guessing==0 ) {
+#line 560 "java.g"
+					c_AST->setType(LABELED_STAT);
+#line 2516 "JavaRecognizer.cpp"
+				}
+				statement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				statement_AST = RefJavaAST(currentAST.root);
+			}
+			else if ((LA(1) == LITERAL_synchronized) && (LA(2) == LPAREN)) {
+				RefJavaAST tmp103_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp103_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp103_AST));
+				}
+				match(LITERAL_synchronized);
+				match(LPAREN);
+				expression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(RPAREN);
+				compoundStatement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				statement_AST = RefJavaAST(currentAST.root);
+			}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_28);
+		} else {
+			throw;
+		}
+	}
+	returnAST = statement_AST;
+}
+
+void JavaRecognizer::argList() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST argList_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			expressionList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case RPAREN:
+		{
+			if ( inputState->guessing==0 ) {
+				argList_AST = RefJavaAST(currentAST.root);
+#line 1008 "java.g"
+				argList_AST = astFactory->create(ELIST,"ELIST");
+#line 2609 "JavaRecognizer.cpp"
+				currentAST.root = argList_AST;
+				if ( argList_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+					argList_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+					  currentAST.child = argList_AST->getFirstChild();
+				else
+					currentAST.child = argList_AST;
+				currentAST.advanceChildToEnd();
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		argList_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_24);
+		} else {
+			throw;
+		}
+	}
+	returnAST = argList_AST;
+}
+
+/** Declaration of a variable.  This can be a class/instance variable,
+ *   or a local variable in a method
+ * It can also include possible initialization.
+ */
+void JavaRecognizer::variableDeclarator(
+	RefJavaAST mods, RefJavaAST t
+) {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST variableDeclarator_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  id = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST id_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST d_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST v_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		id = LT(1);
+		if ( inputState->guessing == 0 ) {
+			id_AST = astFactory->create(id);
+		}
+		match(IDENT);
+		declaratorBrackets(t);
+		if (inputState->guessing==0) {
+			d_AST = returnAST;
+		}
+		varInitializer();
+		if (inputState->guessing==0) {
+			v_AST = returnAST;
+		}
+		if ( inputState->guessing==0 ) {
+			variableDeclarator_AST = RefJavaAST(currentAST.root);
+#line 448 "java.g"
+			variableDeclarator_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(5))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VARIABLE_DEF,"VARIABLE_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mods))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TYPE,"TYPE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST))))))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(v_AST))));
+#line 2672 "JavaRecognizer.cpp"
+			currentAST.root = variableDeclarator_AST;
+			if ( variableDeclarator_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				variableDeclarator_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = variableDeclarator_AST->getFirstChild();
+			else
+				currentAST.child = variableDeclarator_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_36);
+		} else {
+			throw;
+		}
+	}
+	returnAST = variableDeclarator_AST;
+}
+
+void JavaRecognizer::varInitializer() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST varInitializer_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case ASSIGN:
+		{
+			RefJavaAST tmp106_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp106_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp106_AST));
+			}
+			match(ASSIGN);
+			initializer();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case COMMA:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		varInitializer_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_36);
+		} else {
+			throw;
+		}
+	}
+	returnAST = varInitializer_AST;
+}
+
+void JavaRecognizer::initializer() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST initializer_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			initializer_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LCURLY:
+		{
+			arrayInitializer();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			initializer_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_37);
+		} else {
+			throw;
+		}
+	}
+	returnAST = initializer_AST;
+}
+
+void JavaRecognizer::arrayInitializer() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST arrayInitializer_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lc = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		lc = LT(1);
+		if ( inputState->guessing == 0 ) {
+			lc_AST = astFactory->create(lc);
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lc_AST));
+		}
+		match(LCURLY);
+		if ( inputState->guessing==0 ) {
+#line 462 "java.g"
+			lc_AST->setType(ARRAY_INIT);
+#line 2826 "JavaRecognizer.cpp"
+		}
+		{
+		switch ( LA(1)) {
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LCURLY:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			initializer();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == COMMA) && (_tokenSet_38.member(LA(2)))) {
+					match(COMMA);
+					initializer();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop69;
+				}
+				
+			}
+			_loop69:;
+			} // ( ... )*
+			{
+			switch ( LA(1)) {
+			case COMMA:
+			{
+				match(COMMA);
+				break;
+			}
+			case RCURLY:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case RCURLY:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(RCURLY);
+		arrayInitializer_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_39);
+		} else {
+			throw;
+		}
+	}
+	returnAST = arrayInitializer_AST;
+}
+
+void JavaRecognizer::expression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST expression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		assignmentExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+			expression_AST = RefJavaAST(currentAST.root);
+#line 715 "java.g"
+			expression_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXPR,"EXPR")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(expression_AST))));
+#line 2938 "JavaRecognizer.cpp"
+			currentAST.root = expression_AST;
+			if ( expression_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				expression_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = expression_AST->getFirstChild();
+			else
+				currentAST.child = expression_AST;
+			currentAST.advanceChildToEnd();
+		}
+		expression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_40);
+		} else {
+			throw;
+		}
+	}
+	returnAST = expression_AST;
+}
+
+void JavaRecognizer::parameterDeclaration() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST parameterDeclaration_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST pm_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST t_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  id = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST id_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	RefJavaAST pd_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		parameterModifier();
+		if (inputState->guessing==0) {
+			pm_AST = returnAST;
+		}
+		typeSpec(false);
+		if (inputState->guessing==0) {
+			t_AST = returnAST;
+		}
+		id = LT(1);
+		if ( inputState->guessing == 0 ) {
+			id_AST = astFactory->create(id);
+		}
+		match(IDENT);
+		declaratorBrackets(t_AST);
+		if (inputState->guessing==0) {
+			pd_AST = returnAST;
+		}
+		if ( inputState->guessing==0 ) {
+			parameterDeclaration_AST = RefJavaAST(currentAST.root);
+#line 516 "java.g"
+			parameterDeclaration_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(4))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_DEF,"PARAMETER_DEF")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(pm_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TYPE,"TYPE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(pd_AST))))))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST))));
+#line 2992 "JavaRecognizer.cpp"
+			currentAST.root = parameterDeclaration_AST;
+			if ( parameterDeclaration_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				parameterDeclaration_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = parameterDeclaration_AST->getFirstChild();
+			else
+				currentAST.child = parameterDeclaration_AST;
+			currentAST.advanceChildToEnd();
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_41);
+		} else {
+			throw;
+		}
+	}
+	returnAST = parameterDeclaration_AST;
+}
+
+void JavaRecognizer::parameterModifier() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST parameterModifier_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST f_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case FINAL:
+		{
+			f = LT(1);
+			if ( inputState->guessing == 0 ) {
+				f_AST = astFactory->create(f);
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST));
+			}
+			match(FINAL);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			parameterModifier_AST = RefJavaAST(currentAST.root);
+#line 522 "java.g"
+			parameterModifier_AST = RefJavaAST(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(f_AST))));
+#line 3056 "JavaRecognizer.cpp"
+			currentAST.root = parameterModifier_AST;
+			if ( parameterModifier_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				parameterModifier_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = parameterModifier_AST->getFirstChild();
+			else
+				currentAST.child = parameterModifier_AST;
+			currentAST.advanceChildToEnd();
+		}
+		parameterModifier_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_42);
+		} else {
+			throw;
+		}
+	}
+	returnAST = parameterModifier_AST;
+}
+
+void JavaRecognizer::forInit() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST forInit_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		bool synPredMatched107 = false;
+		if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
+			int _m107 = mark();
+			synPredMatched107 = true;
+			inputState->guessing++;
+			try {
+				{
+				declaration();
+				}
+			}
+			catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+				synPredMatched107 = false;
+			}
+			rewind(_m107);
+			inputState->guessing--;
+		}
+		if ( synPredMatched107 ) {
+			declaration();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_43.member(LA(2)))) {
+			expressionList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+		}
+		else if ((LA(1) == SEMI)) {
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		if ( inputState->guessing==0 ) {
+			forInit_AST = RefJavaAST(currentAST.root);
+#line 651 "java.g"
+			forInit_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FOR_INIT,"FOR_INIT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(forInit_AST))));
+#line 3124 "JavaRecognizer.cpp"
+			currentAST.root = forInit_AST;
+			if ( forInit_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				forInit_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = forInit_AST->getFirstChild();
+			else
+				currentAST.child = forInit_AST;
+			currentAST.advanceChildToEnd();
+		}
+		forInit_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_5);
+		} else {
+			throw;
+		}
+	}
+	returnAST = forInit_AST;
+}
+
+void JavaRecognizer::forCond() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST forCond_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			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());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			forCond_AST = RefJavaAST(currentAST.root);
+#line 656 "java.g"
+			forCond_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FOR_CONDITION,"FOR_CONDITION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(forCond_AST))));
+#line 3204 "JavaRecognizer.cpp"
+			currentAST.root = forCond_AST;
+			if ( forCond_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				forCond_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = forCond_AST->getFirstChild();
+			else
+				currentAST.child = forCond_AST;
+			currentAST.advanceChildToEnd();
+		}
+		forCond_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_5);
+		} else {
+			throw;
+		}
+	}
+	returnAST = forCond_AST;
+}
+
+void JavaRecognizer::forIter() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST forIter_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			expressionList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case RPAREN:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		if ( inputState->guessing==0 ) {
+			forIter_AST = RefJavaAST(currentAST.root);
+#line 661 "java.g"
+			forIter_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FOR_ITERATOR,"FOR_ITERATOR")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(forIter_AST))));
+#line 3284 "JavaRecognizer.cpp"
+			currentAST.root = forIter_AST;
+			if ( forIter_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				forIter_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = forIter_AST->getFirstChild();
+			else
+				currentAST.child = forIter_AST;
+			currentAST.advanceChildToEnd();
+		}
+		forIter_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_24);
+		} else {
+			throw;
+		}
+	}
+	returnAST = forIter_AST;
+}
+
+void JavaRecognizer::casesGroup() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST casesGroup_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{ // ( ... )+
+		int _cnt98=0;
+		for (;;) {
+			if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default) && (_tokenSet_44.member(LA(2)))) {
+				aCase();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+			}
+			
+			_cnt98++;
+		}
+		_loop98:;
+		}  // ( ... )+
+		caseSList();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		if ( inputState->guessing==0 ) {
+			casesGroup_AST = RefJavaAST(currentAST.root);
+#line 632 "java.g"
+			casesGroup_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CASE_GROUP,"CASE_GROUP")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(casesGroup_AST))));
+#line 3337 "JavaRecognizer.cpp"
+			currentAST.root = casesGroup_AST;
+			if ( casesGroup_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				casesGroup_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = casesGroup_AST->getFirstChild();
+			else
+				currentAST.child = casesGroup_AST;
+			currentAST.advanceChildToEnd();
+		}
+		casesGroup_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_45);
+		} else {
+			throw;
+		}
+	}
+	returnAST = casesGroup_AST;
+}
+
+void JavaRecognizer::tryBlock() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST tryBlock_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp110_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp110_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp110_AST));
+		}
+		match(LITERAL_try);
+		compoundStatement();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LITERAL_catch)) {
+				handler();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop114;
+			}
+			
+		}
+		_loop114:;
+		} // ( ... )*
+		{
+		switch ( LA(1)) {
+		case LITERAL_finally:
+		{
+			finallyClause();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case FINAL:
+		case ABSTRACT:
+		case STRICTFP:
+		case SEMI:
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LITERAL_private:
+		case LITERAL_public:
+		case LITERAL_protected:
+		case LITERAL_static:
+		case LITERAL_transient:
+		case LITERAL_native:
+		case LITERAL_threadsafe:
+		case LITERAL_synchronized:
+		case LITERAL_volatile:
+		case LITERAL_class:
+		case LCURLY:
+		case RCURLY:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case LITERAL_if:
+		case LITERAL_else:
+		case LITERAL_for:
+		case LITERAL_while:
+		case LITERAL_do:
+		case LITERAL_break:
+		case LITERAL_continue:
+		case LITERAL_return:
+		case LITERAL_switch:
+		case LITERAL_throw:
+		case LITERAL_case:
+		case LITERAL_default:
+		case LITERAL_try:
+		case PLUS:
+		case MINUS:
+		case INC:
+		case DEC:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		tryBlock_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_28);
+		} else {
+			throw;
+		}
+	}
+	returnAST = tryBlock_AST;
+}
+
+void JavaRecognizer::aCase() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST aCase_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{
+		switch ( LA(1)) {
+		case LITERAL_case:
+		{
+			RefJavaAST tmp111_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp111_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST));
+			}
+			match(LITERAL_case);
+			expression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case LITERAL_default:
+		{
+			RefJavaAST tmp112_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp112_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp112_AST));
+			}
+			match(LITERAL_default);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		match(COLON);
+		aCase_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_46);
+		} else {
+			throw;
+		}
+	}
+	returnAST = aCase_AST;
+}
+
+void JavaRecognizer::caseSList() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST caseSList_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_23.member(LA(1)))) {
+				statement();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop103;
+			}
+			
+		}
+		_loop103:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+			caseSList_AST = RefJavaAST(currentAST.root);
+#line 641 "java.g"
+			caseSList_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SLIST,"SLIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(caseSList_AST))));
+#line 3557 "JavaRecognizer.cpp"
+			currentAST.root = caseSList_AST;
+			if ( caseSList_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				caseSList_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = caseSList_AST->getFirstChild();
+			else
+				currentAST.child = caseSList_AST;
+			currentAST.advanceChildToEnd();
+		}
+		caseSList_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_45);
+		} else {
+			throw;
+		}
+	}
+	returnAST = caseSList_AST;
+}
+
+void JavaRecognizer::expressionList() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST expressionList_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		expression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == COMMA)) {
+				match(COMMA);
+				expression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop121;
+			}
+			
+		}
+		_loop121:;
+		} // ( ... )*
+		if ( inputState->guessing==0 ) {
+			expressionList_AST = RefJavaAST(currentAST.root);
+#line 721 "java.g"
+			expressionList_AST = RefJavaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELIST,"ELIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(expressionList_AST))));
+#line 3609 "JavaRecognizer.cpp"
+			currentAST.root = expressionList_AST;
+			if ( expressionList_AST!=RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+				expressionList_AST->getFirstChild() != RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				  currentAST.child = expressionList_AST->getFirstChild();
+			else
+				currentAST.child = expressionList_AST;
+			currentAST.advanceChildToEnd();
+		}
+		expressionList_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_47);
+		} else {
+			throw;
+		}
+	}
+	returnAST = expressionList_AST;
+}
+
+void JavaRecognizer::handler() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST handler_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp115_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp115_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST));
+		}
+		match(LITERAL_catch);
+		match(LPAREN);
+		parameterDeclaration();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		match(RPAREN);
+		compoundStatement();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		handler_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_48);
+		} else {
+			throw;
+		}
+	}
+	returnAST = handler_AST;
+}
+
+void JavaRecognizer::finallyClause() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST finallyClause_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp118_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp118_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp118_AST));
+		}
+		match(LITERAL_finally);
+		compoundStatement();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		finallyClause_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_28);
+		} else {
+			throw;
+		}
+	}
+	returnAST = finallyClause_AST;
+}
+
+void JavaRecognizer::assignmentExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST assignmentExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		conditionalExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case ASSIGN:
+		case PLUS_ASSIGN:
+		case MINUS_ASSIGN:
+		case STAR_ASSIGN:
+		case DIV_ASSIGN:
+		case MOD_ASSIGN:
+		case SR_ASSIGN:
+		case BSR_ASSIGN:
+		case SL_ASSIGN:
+		case BAND_ASSIGN:
+		case BXOR_ASSIGN:
+		case BOR_ASSIGN:
+		{
+			{
+			switch ( LA(1)) {
+			case ASSIGN:
+			{
+				RefJavaAST tmp119_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp119_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp119_AST));
+				}
+				match(ASSIGN);
+				break;
+			}
+			case PLUS_ASSIGN:
+			{
+				RefJavaAST tmp120_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp120_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp120_AST));
+				}
+				match(PLUS_ASSIGN);
+				break;
+			}
+			case MINUS_ASSIGN:
+			{
+				RefJavaAST tmp121_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp121_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp121_AST));
+				}
+				match(MINUS_ASSIGN);
+				break;
+			}
+			case STAR_ASSIGN:
+			{
+				RefJavaAST tmp122_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp122_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp122_AST));
+				}
+				match(STAR_ASSIGN);
+				break;
+			}
+			case DIV_ASSIGN:
+			{
+				RefJavaAST tmp123_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp123_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp123_AST));
+				}
+				match(DIV_ASSIGN);
+				break;
+			}
+			case MOD_ASSIGN:
+			{
+				RefJavaAST tmp124_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp124_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp124_AST));
+				}
+				match(MOD_ASSIGN);
+				break;
+			}
+			case SR_ASSIGN:
+			{
+				RefJavaAST tmp125_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp125_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST));
+				}
+				match(SR_ASSIGN);
+				break;
+			}
+			case BSR_ASSIGN:
+			{
+				RefJavaAST tmp126_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp126_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp126_AST));
+				}
+				match(BSR_ASSIGN);
+				break;
+			}
+			case SL_ASSIGN:
+			{
+				RefJavaAST tmp127_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp127_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp127_AST));
+				}
+				match(SL_ASSIGN);
+				break;
+			}
+			case BAND_ASSIGN:
+			{
+				RefJavaAST tmp128_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp128_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp128_AST));
+				}
+				match(BAND_ASSIGN);
+				break;
+			}
+			case BXOR_ASSIGN:
+			{
+				RefJavaAST tmp129_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp129_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp129_AST));
+				}
+				match(BXOR_ASSIGN);
+				break;
+			}
+			case BOR_ASSIGN:
+			{
+				RefJavaAST tmp130_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp130_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp130_AST));
+				}
+				match(BOR_ASSIGN);
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			assignmentExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case RBRACK:
+		case RCURLY:
+		case COMMA:
+		case RPAREN:
+		case COLON:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		assignmentExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_40);
+		} else {
+			throw;
+		}
+	}
+	returnAST = assignmentExpression_AST;
+}
+
+void JavaRecognizer::conditionalExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST conditionalExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		logicalOrExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case QUESTION:
+		{
+			RefJavaAST tmp131_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp131_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp131_AST));
+			}
+			match(QUESTION);
+			assignmentExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(COLON);
+			conditionalExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			break;
+		}
+		case SEMI:
+		case RBRACK:
+		case RCURLY:
+		case COMMA:
+		case RPAREN:
+		case ASSIGN:
+		case COLON:
+		case PLUS_ASSIGN:
+		case MINUS_ASSIGN:
+		case STAR_ASSIGN:
+		case DIV_ASSIGN:
+		case MOD_ASSIGN:
+		case SR_ASSIGN:
+		case BSR_ASSIGN:
+		case SL_ASSIGN:
+		case BAND_ASSIGN:
+		case BXOR_ASSIGN:
+		case BOR_ASSIGN:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		conditionalExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_49);
+		} else {
+			throw;
+		}
+	}
+	returnAST = conditionalExpression_AST;
+}
+
+void JavaRecognizer::logicalOrExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST logicalOrExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		logicalAndExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LOR)) {
+				RefJavaAST tmp133_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp133_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp133_AST));
+				}
+				match(LOR);
+				logicalAndExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop129;
+			}
+			
+		}
+		_loop129:;
+		} // ( ... )*
+		logicalOrExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_50);
+		} else {
+			throw;
+		}
+	}
+	returnAST = logicalOrExpression_AST;
+}
+
+void JavaRecognizer::logicalAndExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST logicalAndExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		inclusiveOrExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == LAND)) {
+				RefJavaAST tmp134_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp134_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp134_AST));
+				}
+				match(LAND);
+				inclusiveOrExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop132;
+			}
+			
+		}
+		_loop132:;
+		} // ( ... )*
+		logicalAndExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_51);
+		} else {
+			throw;
+		}
+	}
+	returnAST = logicalAndExpression_AST;
+}
+
+void JavaRecognizer::inclusiveOrExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST inclusiveOrExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		exclusiveOrExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == BOR)) {
+				RefJavaAST tmp135_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp135_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp135_AST));
+				}
+				match(BOR);
+				exclusiveOrExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop135;
+			}
+			
+		}
+		_loop135:;
+		} // ( ... )*
+		inclusiveOrExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_52);
+		} else {
+			throw;
+		}
+	}
+	returnAST = inclusiveOrExpression_AST;
+}
+
+void JavaRecognizer::exclusiveOrExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST exclusiveOrExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		andExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == BXOR)) {
+				RefJavaAST tmp136_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp136_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp136_AST));
+				}
+				match(BXOR);
+				andExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop138;
+			}
+			
+		}
+		_loop138:;
+		} // ( ... )*
+		exclusiveOrExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_53);
+		} else {
+			throw;
+		}
+	}
+	returnAST = exclusiveOrExpression_AST;
+}
+
+void JavaRecognizer::andExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST andExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		equalityExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == BAND)) {
+				RefJavaAST tmp137_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp137_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST));
+				}
+				match(BAND);
+				equalityExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop141;
+			}
+			
+		}
+		_loop141:;
+		} // ( ... )*
+		andExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_54);
+		} else {
+			throw;
+		}
+	}
+	returnAST = andExpression_AST;
+}
+
+void JavaRecognizer::equalityExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST equalityExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		relationalExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == NOT_EQUAL || LA(1) == EQUAL)) {
+				{
+				switch ( LA(1)) {
+				case NOT_EQUAL:
+				{
+					RefJavaAST tmp138_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp138_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp138_AST));
+					}
+					match(NOT_EQUAL);
+					break;
+				}
+				case EQUAL:
+				{
+					RefJavaAST tmp139_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp139_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp139_AST));
+					}
+					match(EQUAL);
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				relationalExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop145;
+			}
+			
+		}
+		_loop145:;
+		} // ( ... )*
+		equalityExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_55);
+		} else {
+			throw;
+		}
+	}
+	returnAST = equalityExpression_AST;
+}
+
+void JavaRecognizer::relationalExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST relationalExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		shiftExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case SEMI:
+		case RBRACK:
+		case RCURLY:
+		case COMMA:
+		case RPAREN:
+		case ASSIGN:
+		case COLON:
+		case PLUS_ASSIGN:
+		case MINUS_ASSIGN:
+		case STAR_ASSIGN:
+		case DIV_ASSIGN:
+		case MOD_ASSIGN:
+		case SR_ASSIGN:
+		case BSR_ASSIGN:
+		case SL_ASSIGN:
+		case BAND_ASSIGN:
+		case BXOR_ASSIGN:
+		case BOR_ASSIGN:
+		case QUESTION:
+		case LOR:
+		case LAND:
+		case BOR:
+		case BXOR:
+		case BAND:
+		case NOT_EQUAL:
+		case EQUAL:
+		case LT_:
+		case GT:
+		case LE:
+		case GE:
+		{
+			{ // ( ... )*
+			for (;;) {
+				if (((LA(1) >= LT_ && LA(1) <= GE))) {
+					{
+					switch ( LA(1)) {
+					case LT_:
+					{
+						RefJavaAST tmp140_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp140_AST = astFactory->create(LT(1));
+							astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp140_AST));
+						}
+						match(LT_);
+						break;
+					}
+					case GT:
+					{
+						RefJavaAST tmp141_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp141_AST = astFactory->create(LT(1));
+							astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp141_AST));
+						}
+						match(GT);
+						break;
+					}
+					case LE:
+					{
+						RefJavaAST tmp142_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp142_AST = astFactory->create(LT(1));
+							astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp142_AST));
+						}
+						match(LE);
+						break;
+					}
+					case GE:
+					{
+						RefJavaAST tmp143_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+						if ( inputState->guessing == 0 ) {
+							tmp143_AST = astFactory->create(LT(1));
+							astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp143_AST));
+						}
+						match(GE);
+						break;
+					}
+					default:
+					{
+						throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+					}
+					}
+					}
+					shiftExpression();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else {
+					goto _loop150;
+				}
+				
+			}
+			_loop150:;
+			} // ( ... )*
+			break;
+		}
+		case LITERAL_instanceof:
+		{
+			RefJavaAST tmp144_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp144_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp144_AST));
+			}
+			match(LITERAL_instanceof);
+			typeSpec(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());
+		}
+		}
+		}
+		relationalExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_56);
+		} else {
+			throw;
+		}
+	}
+	returnAST = relationalExpression_AST;
+}
+
+void JavaRecognizer::shiftExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST shiftExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		additiveExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if (((LA(1) >= SL && LA(1) <= BSR))) {
+				{
+				switch ( LA(1)) {
+				case SL:
+				{
+					RefJavaAST tmp145_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp145_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp145_AST));
+					}
+					match(SL);
+					break;
+				}
+				case SR:
+				{
+					RefJavaAST tmp146_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp146_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp146_AST));
+					}
+					match(SR);
+					break;
+				}
+				case BSR:
+				{
+					RefJavaAST tmp147_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp147_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp147_AST));
+					}
+					match(BSR);
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				additiveExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop154;
+			}
+			
+		}
+		_loop154:;
+		} // ( ... )*
+		shiftExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_57);
+		} else {
+			throw;
+		}
+	}
+	returnAST = shiftExpression_AST;
+}
+
+void JavaRecognizer::additiveExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST additiveExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		multiplicativeExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == PLUS || LA(1) == MINUS)) {
+				{
+				switch ( LA(1)) {
+				case PLUS:
+				{
+					RefJavaAST tmp148_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp148_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp148_AST));
+					}
+					match(PLUS);
+					break;
+				}
+				case MINUS:
+				{
+					RefJavaAST tmp149_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp149_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp149_AST));
+					}
+					match(MINUS);
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				multiplicativeExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop158;
+			}
+			
+		}
+		_loop158:;
+		} // ( ... )*
+		additiveExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_58);
+		} else {
+			throw;
+		}
+	}
+	returnAST = additiveExpression_AST;
+}
+
+void JavaRecognizer::multiplicativeExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST multiplicativeExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		unaryExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((_tokenSet_59.member(LA(1)))) {
+				{
+				switch ( LA(1)) {
+				case STAR:
+				{
+					RefJavaAST tmp150_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp150_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp150_AST));
+					}
+					match(STAR);
+					break;
+				}
+				case DIV:
+				{
+					RefJavaAST tmp151_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp151_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp151_AST));
+					}
+					match(DIV);
+					break;
+				}
+				case MOD:
+				{
+					RefJavaAST tmp152_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp152_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp152_AST));
+					}
+					match(MOD);
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				unaryExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				goto _loop162;
+			}
+			
+		}
+		_loop162:;
+		} // ( ... )*
+		multiplicativeExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_60);
+		} else {
+			throw;
+		}
+	}
+	returnAST = multiplicativeExpression_AST;
+}
+
+void JavaRecognizer::unaryExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST unaryExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case INC:
+		{
+			RefJavaAST tmp153_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp153_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp153_AST));
+			}
+			match(INC);
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case DEC:
+		{
+			RefJavaAST tmp154_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp154_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp154_AST));
+			}
+			match(DEC);
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case MINUS:
+		{
+			RefJavaAST tmp155_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp155_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp155_AST));
+			}
+			match(MINUS);
+			if ( inputState->guessing==0 ) {
+#line 812 "java.g"
+				tmp155_AST->setType(UNARY_MINUS);
+#line 4646 "JavaRecognizer.cpp"
+			}
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case PLUS:
+		{
+			RefJavaAST tmp156_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp156_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp156_AST));
+			}
+			match(PLUS);
+			if ( inputState->guessing==0 ) {
+#line 813 "java.g"
+				tmp156_AST->setType(UNARY_PLUS);
+#line 4666 "JavaRecognizer.cpp"
+			}
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case BNOT:
+		case LNOT:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			unaryExpressionNotPlusMinus();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_61);
+		} else {
+			throw;
+		}
+	}
+	returnAST = unaryExpression_AST;
+}
+
+void JavaRecognizer::unaryExpressionNotPlusMinus() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST unaryExpressionNotPlusMinus_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lpb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lpb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case BNOT:
+		{
+			RefJavaAST tmp157_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp157_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp157_AST));
+			}
+			match(BNOT);
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpressionNotPlusMinus_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LNOT:
+		{
+			RefJavaAST tmp158_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp158_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp158_AST));
+			}
+			match(LNOT);
+			unaryExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			unaryExpressionNotPlusMinus_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		case IDENT:
+		case LPAREN:
+		case LITERAL_this:
+		case LITERAL_super:
+		case LITERAL_true:
+		case LITERAL_false:
+		case LITERAL_null:
+		case LITERAL_new:
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			{
+			if ((LA(1) == LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double))) {
+				lpb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lpb_AST = astFactory->create(lpb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lpb_AST));
+				}
+				match(LPAREN);
+				if ( inputState->guessing==0 ) {
+#line 829 "java.g"
+					lpb_AST->setType(TYPECAST);
+#line 4801 "JavaRecognizer.cpp"
+				}
+				builtInTypeSpec(true);
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(RPAREN);
+				unaryExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else {
+				bool synPredMatched167 = false;
+				if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
+					int _m167 = mark();
+					synPredMatched167 = true;
+					inputState->guessing++;
+					try {
+						{
+						match(LPAREN);
+						classTypeSpec(true);
+						match(RPAREN);
+						unaryExpressionNotPlusMinus();
+						}
+					}
+					catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+						synPredMatched167 = false;
+					}
+					rewind(_m167);
+					inputState->guessing--;
+				}
+				if ( synPredMatched167 ) {
+					lp = LT(1);
+					if ( inputState->guessing == 0 ) {
+						lp_AST = astFactory->create(lp);
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp_AST));
+					}
+					match(LPAREN);
+					if ( inputState->guessing==0 ) {
+#line 836 "java.g"
+						lp_AST->setType(TYPECAST);
+#line 4843 "JavaRecognizer.cpp"
+					}
+					classTypeSpec(true);
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					match(RPAREN);
+					unaryExpressionNotPlusMinus();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+				else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_63.member(LA(2)))) {
+					postfixExpression();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+				}
+			else {
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			unaryExpressionNotPlusMinus_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_61);
+		} else {
+			throw;
+		}
+	}
+	returnAST = unaryExpressionNotPlusMinus_AST;
+}
+
+void JavaRecognizer::postfixExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST postfixExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp3 = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp3_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lps = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lps_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  in = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST in_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  de = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST de_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		primaryExpression();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == DOT) && (LA(2) == IDENT)) {
+				RefJavaAST tmp161_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp161_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp161_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp162_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp162_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp162_AST));
+				}
+				match(IDENT);
+				{
+				switch ( LA(1)) {
+				case LPAREN:
+				{
+					lp = LT(1);
+					if ( inputState->guessing == 0 ) {
+						lp_AST = astFactory->create(lp);
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp_AST));
+					}
+					match(LPAREN);
+					if ( inputState->guessing==0 ) {
+#line 867 "java.g"
+						lp_AST->setType(METHOD_CALL);
+#line 4936 "JavaRecognizer.cpp"
+					}
+					argList();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					match(RPAREN);
+					break;
+				}
+				case SEMI:
+				case LBRACK:
+				case RBRACK:
+				case DOT:
+				case STAR:
+				case RCURLY:
+				case COMMA:
+				case RPAREN:
+				case ASSIGN:
+				case COLON:
+				case PLUS_ASSIGN:
+				case MINUS_ASSIGN:
+				case STAR_ASSIGN:
+				case DIV_ASSIGN:
+				case MOD_ASSIGN:
+				case SR_ASSIGN:
+				case BSR_ASSIGN:
+				case SL_ASSIGN:
+				case BAND_ASSIGN:
+				case BXOR_ASSIGN:
+				case BOR_ASSIGN:
+				case QUESTION:
+				case LOR:
+				case LAND:
+				case BOR:
+				case BXOR:
+				case BAND:
+				case NOT_EQUAL:
+				case EQUAL:
+				case LT_:
+				case GT:
+				case LE:
+				case GE:
+				case LITERAL_instanceof:
+				case SL:
+				case SR:
+				case BSR:
+				case PLUS:
+				case MINUS:
+				case DIV:
+				case MOD:
+				case INC:
+				case DEC:
+				{
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+			}
+			else if ((LA(1) == DOT) && (LA(2) == LITERAL_this)) {
+				RefJavaAST tmp164_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp164_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp164_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp165_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp165_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp165_AST));
+				}
+				match(LITERAL_this);
+			}
+			else if ((LA(1) == DOT) && (LA(2) == LITERAL_super)) {
+				RefJavaAST tmp166_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp166_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp166_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp167_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp167_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp167_AST));
+				}
+				match(LITERAL_super);
+				{
+				switch ( LA(1)) {
+				case LPAREN:
+				{
+					lp3 = LT(1);
+					if ( inputState->guessing == 0 ) {
+						lp3_AST = astFactory->create(lp3);
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp3_AST));
+					}
+					match(LPAREN);
+					argList();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					match(RPAREN);
+					if ( inputState->guessing==0 ) {
+#line 876 "java.g"
+						lp3_AST->setType(SUPER_CTOR_CALL);
+#line 5043 "JavaRecognizer.cpp"
+					}
+					break;
+				}
+				case DOT:
+				{
+					RefJavaAST tmp169_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp169_AST = astFactory->create(LT(1));
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp169_AST));
+					}
+					match(DOT);
+					RefJavaAST tmp170_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+					if ( inputState->guessing == 0 ) {
+						tmp170_AST = astFactory->create(LT(1));
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp170_AST));
+					}
+					match(IDENT);
+					{
+					switch ( LA(1)) {
+					case LPAREN:
+					{
+						lps = LT(1);
+						if ( inputState->guessing == 0 ) {
+							lps_AST = astFactory->create(lps);
+							astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lps_AST));
+						}
+						match(LPAREN);
+						if ( inputState->guessing==0 ) {
+#line 878 "java.g"
+							lps_AST->setType(METHOD_CALL);
+#line 5074 "JavaRecognizer.cpp"
+						}
+						argList();
+						if (inputState->guessing==0) {
+							astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+						}
+						match(RPAREN);
+						break;
+					}
+					case SEMI:
+					case LBRACK:
+					case RBRACK:
+					case DOT:
+					case STAR:
+					case RCURLY:
+					case COMMA:
+					case RPAREN:
+					case ASSIGN:
+					case COLON:
+					case PLUS_ASSIGN:
+					case MINUS_ASSIGN:
+					case STAR_ASSIGN:
+					case DIV_ASSIGN:
+					case MOD_ASSIGN:
+					case SR_ASSIGN:
+					case BSR_ASSIGN:
+					case SL_ASSIGN:
+					case BAND_ASSIGN:
+					case BXOR_ASSIGN:
+					case BOR_ASSIGN:
+					case QUESTION:
+					case LOR:
+					case LAND:
+					case BOR:
+					case BXOR:
+					case BAND:
+					case NOT_EQUAL:
+					case EQUAL:
+					case LT_:
+					case GT:
+					case LE:
+					case GE:
+					case LITERAL_instanceof:
+					case SL:
+					case SR:
+					case BSR:
+					case PLUS:
+					case MINUS:
+					case DIV:
+					case MOD:
+					case INC:
+					case DEC:
+					{
+						break;
+					}
+					default:
+					{
+						throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+					}
+					}
+					}
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+			}
+			else if ((LA(1) == DOT) && (LA(2) == LITERAL_new)) {
+				RefJavaAST tmp172_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp172_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp172_AST));
+				}
+				match(DOT);
+				newExpression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+			}
+			else if ((LA(1) == LBRACK)) {
+				lb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lb_AST = astFactory->create(lb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lb_AST));
+				}
+				match(LBRACK);
+				if ( inputState->guessing==0 ) {
+#line 884 "java.g"
+					lb_AST->setType(INDEX_OP);
+#line 5166 "JavaRecognizer.cpp"
+				}
+				expression();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				match(RBRACK);
+			}
+			else {
+				goto _loop173;
+			}
+			
+		}
+		_loop173:;
+		} // ( ... )*
+		{
+		switch ( LA(1)) {
+		case INC:
+		{
+			in = LT(1);
+			if ( inputState->guessing == 0 ) {
+				in_AST = astFactory->create(in);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(in_AST));
+			}
+			match(INC);
+			if ( inputState->guessing==0 ) {
+#line 889 "java.g"
+				in_AST->setType(POST_INC);
+#line 5194 "JavaRecognizer.cpp"
+			}
+			break;
+		}
+		case DEC:
+		{
+			de = LT(1);
+			if ( inputState->guessing == 0 ) {
+				de_AST = astFactory->create(de);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(de_AST));
+			}
+			match(DEC);
+			if ( inputState->guessing==0 ) {
+#line 890 "java.g"
+				de_AST->setType(POST_DEC);
+#line 5209 "JavaRecognizer.cpp"
+			}
+			break;
+		}
+		case SEMI:
+		case RBRACK:
+		case STAR:
+		case RCURLY:
+		case COMMA:
+		case RPAREN:
+		case ASSIGN:
+		case COLON:
+		case PLUS_ASSIGN:
+		case MINUS_ASSIGN:
+		case STAR_ASSIGN:
+		case DIV_ASSIGN:
+		case MOD_ASSIGN:
+		case SR_ASSIGN:
+		case BSR_ASSIGN:
+		case SL_ASSIGN:
+		case BAND_ASSIGN:
+		case BXOR_ASSIGN:
+		case BOR_ASSIGN:
+		case QUESTION:
+		case LOR:
+		case LAND:
+		case BOR:
+		case BXOR:
+		case BAND:
+		case NOT_EQUAL:
+		case EQUAL:
+		case LT_:
+		case GT:
+		case LE:
+		case GE:
+		case LITERAL_instanceof:
+		case SL:
+		case SR:
+		case BSR:
+		case PLUS:
+		case MINUS:
+		case DIV:
+		case MOD:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		postfixExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_61);
+		} else {
+			throw;
+		}
+	}
+	returnAST = postfixExpression_AST;
+}
+
+void JavaRecognizer::primaryExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST primaryExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lbt = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lbt_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case IDENT:
+		{
+			identPrimary();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			if ((LA(1) == DOT) && (LA(2) == LITERAL_class)) {
+				RefJavaAST tmp174_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp174_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp174_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp175_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp175_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp175_AST));
+				}
+				match(LITERAL_class);
+			}
+			else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_64.member(LA(2)))) {
+			}
+			else {
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			
+			}
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case NUM_INT:
+		case CHAR_LITERAL:
+		case STRING_LITERAL:
+		case NUM_FLOAT:
+		case NUM_LONG:
+		case NUM_DOUBLE:
+		{
+			constant();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_true:
+		{
+			RefJavaAST tmp176_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp176_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp176_AST));
+			}
+			match(LITERAL_true);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_false:
+		{
+			RefJavaAST tmp177_AST = RefJavaAST(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(LITERAL_false);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_null:
+		{
+			RefJavaAST tmp178_AST = RefJavaAST(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(LITERAL_null);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_new:
+		{
+			newExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_this:
+		{
+			RefJavaAST tmp179_AST = RefJavaAST(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(LITERAL_this);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_super:
+		{
+			RefJavaAST tmp180_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp180_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp180_AST));
+			}
+			match(LITERAL_super);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LPAREN:
+		{
+			match(LPAREN);
+			assignmentExpression();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case LITERAL_void:
+		case LITERAL_boolean:
+		case LITERAL_byte:
+		case LITERAL_char:
+		case LITERAL_short:
+		case LITERAL_int:
+		case LITERAL_float:
+		case LITERAL_long:
+		case LITERAL_double:
+		{
+			builtInType();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{ // ( ... )*
+			for (;;) {
+				if ((LA(1) == LBRACK)) {
+					lbt = LT(1);
+					if ( inputState->guessing == 0 ) {
+						lbt_AST = astFactory->create(lbt);
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbt_AST));
+					}
+					match(LBRACK);
+					if ( inputState->guessing==0 ) {
+#line 907 "java.g"
+						lbt_AST->setType(ARRAY_DECLARATOR);
+#line 5429 "JavaRecognizer.cpp"
+					}
+					match(RBRACK);
+				}
+				else {
+					goto _loop178;
+				}
+				
+			}
+			_loop178:;
+			} // ( ... )*
+			RefJavaAST tmp184_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp184_AST = astFactory->create(LT(1));
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp184_AST));
+			}
+			match(DOT);
+			RefJavaAST tmp185_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp185_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp185_AST));
+			}
+			match(LITERAL_class);
+			primaryExpression_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_39);
+		} else {
+			throw;
+		}
+	}
+	returnAST = primaryExpression_AST;
+}
+
+/** object instantiation.
+ *  Trees are built as illustrated by the following input/tree pairs:
+ *
+ *  new T()
+ *
+ *  new
+ *   |
+ *   T --  ELIST
+ *           |
+ *          arg1 -- arg2 -- .. -- argn
+ *
+ *  new int[]
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *
+ *  new int[] {1,2}
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
+ *                                  |
+ *                                EXPR -- EXPR
+ *                                  |      |
+ *                                  1      2
+ *
+ *  new int[3]
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *                |
+ *              EXPR
+ *                |
+ *                3
+ *
+ *  new int[1][2]
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *               |
+ *         ARRAY_DECLARATOR -- EXPR
+ *               |              |
+ *             EXPR             1
+ *               |
+ *               2
+ *
+ */
+void JavaRecognizer::newExpression() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST newExpression_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp186_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+		if ( inputState->guessing == 0 ) {
+			tmp186_AST = astFactory->create(LT(1));
+			astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp186_AST));
+		}
+		match(LITERAL_new);
+		type();
+		if (inputState->guessing==0) {
+			astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+		}
+		{
+		switch ( LA(1)) {
+		case LPAREN:
+		{
+			match(LPAREN);
+			argList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			{
+			switch ( LA(1)) {
+			case LCURLY:
+			{
+				classBlock();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case SEMI:
+			case LBRACK:
+			case RBRACK:
+			case DOT:
+			case STAR:
+			case RCURLY:
+			case COMMA:
+			case RPAREN:
+			case ASSIGN:
+			case COLON:
+			case PLUS_ASSIGN:
+			case MINUS_ASSIGN:
+			case STAR_ASSIGN:
+			case DIV_ASSIGN:
+			case MOD_ASSIGN:
+			case SR_ASSIGN:
+			case BSR_ASSIGN:
+			case SL_ASSIGN:
+			case BAND_ASSIGN:
+			case BXOR_ASSIGN:
+			case BOR_ASSIGN:
+			case QUESTION:
+			case LOR:
+			case LAND:
+			case BOR:
+			case BXOR:
+			case BAND:
+			case NOT_EQUAL:
+			case EQUAL:
+			case LT_:
+			case GT:
+			case LE:
+			case GE:
+			case LITERAL_instanceof:
+			case SL:
+			case SR:
+			case BSR:
+			case PLUS:
+			case MINUS:
+			case DIV:
+			case MOD:
+			case INC:
+			case DEC:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		case LBRACK:
+		{
+			newArrayDeclarator();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			{
+			switch ( LA(1)) {
+			case LCURLY:
+			{
+				arrayInitializer();
+				if (inputState->guessing==0) {
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+				}
+				break;
+			}
+			case SEMI:
+			case LBRACK:
+			case RBRACK:
+			case DOT:
+			case STAR:
+			case RCURLY:
+			case COMMA:
+			case RPAREN:
+			case ASSIGN:
+			case COLON:
+			case PLUS_ASSIGN:
+			case MINUS_ASSIGN:
+			case STAR_ASSIGN:
+			case DIV_ASSIGN:
+			case MOD_ASSIGN:
+			case SR_ASSIGN:
+			case BSR_ASSIGN:
+			case SL_ASSIGN:
+			case BAND_ASSIGN:
+			case BXOR_ASSIGN:
+			case BOR_ASSIGN:
+			case QUESTION:
+			case LOR:
+			case LAND:
+			case BOR:
+			case BXOR:
+			case BAND:
+			case NOT_EQUAL:
+			case EQUAL:
+			case LT_:
+			case GT:
+			case LE:
+			case GE:
+			case LITERAL_instanceof:
+			case SL:
+			case SR:
+			case BSR:
+			case PLUS:
+			case MINUS:
+			case DIV:
+			case MOD:
+			case INC:
+			case DEC:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+			}
+			}
+			}
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+		}
+		newExpression_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_39);
+		} else {
+			throw;
+		}
+	}
+	returnAST = newExpression_AST;
+}
+
+/** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
+ *  and a.b.c.class refs.  Also this(...) and super(...).  Match
+ *  this or super.
+ */
+void JavaRecognizer::identPrimary() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST identPrimary_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lp = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lp_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lbc = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lbc_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		RefJavaAST tmp189_AST = RefJavaAST(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(IDENT);
+		{ // ( ... )*
+		for (;;) {
+			if ((LA(1) == DOT) && (LA(2) == IDENT)) {
+				RefJavaAST tmp190_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp190_AST = astFactory->create(LT(1));
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp190_AST));
+				}
+				match(DOT);
+				RefJavaAST tmp191_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+				if ( inputState->guessing == 0 ) {
+					tmp191_AST = astFactory->create(LT(1));
+					astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp191_AST));
+				}
+				match(IDENT);
+			}
+			else {
+				goto _loop181;
+			}
+			
+		}
+		_loop181:;
+		} // ( ... )*
+		{
+		if ((LA(1) == LPAREN)) {
+			{
+			lp = LT(1);
+			if ( inputState->guessing == 0 ) {
+				lp_AST = astFactory->create(lp);
+				astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lp_AST));
+			}
+			match(LPAREN);
+			if ( inputState->guessing==0 ) {
+#line 933 "java.g"
+				lp_AST->setType(METHOD_CALL);
+#line 5755 "JavaRecognizer.cpp"
+			}
+			argList();
+			if (inputState->guessing==0) {
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+			}
+			match(RPAREN);
+			}
+		}
+		else if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
+			{ // ( ... )+
+			int _cnt185=0;
+			for (;;) {
+				if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
+					lbc = LT(1);
+					if ( inputState->guessing == 0 ) {
+						lbc_AST = astFactory->create(lbc);
+						astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lbc_AST));
+					}
+					match(LBRACK);
+					if ( inputState->guessing==0 ) {
+#line 935 "java.g"
+						lbc_AST->setType(ARRAY_DECLARATOR);
+#line 5778 "JavaRecognizer.cpp"
+					}
+					match(RBRACK);
+				}
+				else {
+					if ( _cnt185>=1 ) { goto _loop185; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+				}
+				
+				_cnt185++;
+			}
+			_loop185:;
+			}  // ( ... )+
+		}
+		else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_64.member(LA(2)))) {
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		
+		}
+		identPrimary_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_39);
+		} else {
+			throw;
+		}
+	}
+	returnAST = identPrimary_AST;
+}
+
+void JavaRecognizer::constant() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST constant_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		switch ( LA(1)) {
+		case NUM_INT:
+		{
+			RefJavaAST tmp194_AST = RefJavaAST(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(NUM_INT);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case CHAR_LITERAL:
+		{
+			RefJavaAST tmp195_AST = RefJavaAST(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(CHAR_LITERAL);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case STRING_LITERAL:
+		{
+			RefJavaAST tmp196_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp196_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp196_AST));
+			}
+			match(STRING_LITERAL);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case NUM_FLOAT:
+		{
+			RefJavaAST tmp197_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp197_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp197_AST));
+			}
+			match(NUM_FLOAT);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case NUM_LONG:
+		{
+			RefJavaAST tmp198_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp198_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp198_AST));
+			}
+			match(NUM_LONG);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		case NUM_DOUBLE:
+		{
+			RefJavaAST tmp199_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+			if ( inputState->guessing == 0 ) {
+				tmp199_AST = astFactory->create(LT(1));
+				astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp199_AST));
+			}
+			match(NUM_DOUBLE);
+			constant_AST = RefJavaAST(currentAST.root);
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_39);
+		} else {
+			throw;
+		}
+	}
+	returnAST = constant_AST;
+}
+
+void JavaRecognizer::newArrayDeclarator() {
+	returnAST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+	RefJavaAST newArrayDeclarator_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	ANTLR_USE_NAMESPACE(antlr)RefToken  lb = ANTLR_USE_NAMESPACE(antlr)nullToken;
+	RefJavaAST lb_AST = RefJavaAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+	
+	try {      // for error handling
+		{ // ( ... )+
+		int _cnt195=0;
+		for (;;) {
+			if ((LA(1) == LBRACK) && (_tokenSet_65.member(LA(2)))) {
+				lb = LT(1);
+				if ( inputState->guessing == 0 ) {
+					lb_AST = astFactory->create(lb);
+					astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(lb_AST));
+				}
+				match(LBRACK);
+				if ( inputState->guessing==0 ) {
+#line 1023 "java.g"
+					lb_AST->setType(ARRAY_DECLARATOR);
+#line 5922 "JavaRecognizer.cpp"
+				}
+				{
+				switch ( LA(1)) {
+				case LITERAL_void:
+				case LITERAL_boolean:
+				case LITERAL_byte:
+				case LITERAL_char:
+				case LITERAL_short:
+				case LITERAL_int:
+				case LITERAL_float:
+				case LITERAL_long:
+				case LITERAL_double:
+				case IDENT:
+				case LPAREN:
+				case LITERAL_this:
+				case LITERAL_super:
+				case PLUS:
+				case MINUS:
+				case INC:
+				case DEC:
+				case BNOT:
+				case LNOT:
+				case LITERAL_true:
+				case LITERAL_false:
+				case LITERAL_null:
+				case LITERAL_new:
+				case NUM_INT:
+				case CHAR_LITERAL:
+				case STRING_LITERAL:
+				case NUM_FLOAT:
+				case NUM_LONG:
+				case NUM_DOUBLE:
+				{
+					expression();
+					if (inputState->guessing==0) {
+						astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+					}
+					break;
+				}
+				case RBRACK:
+				{
+					break;
+				}
+				default:
+				{
+					throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+				}
+				}
+				}
+				match(RBRACK);
+			}
+			else {
+				if ( _cnt195>=1 ) { goto _loop195; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+			}
+			
+			_cnt195++;
+		}
+		_loop195:;
+		}  // ( ... )+
+		newArrayDeclarator_AST = RefJavaAST(currentAST.root);
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		if( inputState->guessing == 0 ) {
+			reportError(ex);
+			recover(ex,_tokenSet_66);
+		} else {
+			throw;
+		}
+	}
+	returnAST = newArrayDeclarator_AST;
+}
+
+void JavaRecognizer::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
+{
+	factory.setMaxNodeType(151);
+}
+const char* JavaRecognizer::tokenNames[] = {
+	"<0>",
+	"EOF",
+	"<2>",
+	"NULL_TREE_LOOKAHEAD",
+	"BLOCK",
+	"MODIFIERS",
+	"OBJBLOCK",
+	"SLIST",
+	"CTOR_DEF",
+	"METHOD_DEF",
+	"VARIABLE_DEF",
+	"INSTANCE_INIT",
+	"STATIC_INIT",
+	"TYPE",
+	"CLASS_DEF",
+	"INTERFACE_DEF",
+	"PACKAGE_DEF",
+	"ARRAY_DECLARATOR",
+	"EXTENDS_CLAUSE",
+	"IMPLEMENTS_CLAUSE",
+	"PARAMETERS",
+	"PARAMETER_DEF",
+	"LABELED_STAT",
+	"TYPECAST",
+	"INDEX_OP",
+	"POST_INC",
+	"POST_DEC",
+	"METHOD_CALL",
+	"EXPR",
+	"ARRAY_INIT",
+	"IMPORT",
+	"UNARY_MINUS",
+	"UNARY_PLUS",
+	"CASE_GROUP",
+	"ELIST",
+	"FOR_INIT",
+	"FOR_CONDITION",
+	"FOR_ITERATOR",
+	"EMPTY_STAT",
+	"\"final\"",
+	"\"abstract\"",
+	"\"strictfp\"",
+	"SUPER_CTOR_CALL",
+	"CTOR_CALL",
+	"\"package\"",
+	"SEMI",
+	"\"import\"",
+	"LBRACK",
+	"RBRACK",
+	"\"void\"",
+	"\"boolean\"",
+	"\"byte\"",
+	"\"char\"",
+	"\"short\"",
+	"\"int\"",
+	"\"float\"",
+	"\"long\"",
+	"\"double\"",
+	"IDENT",
+	"DOT",
+	"STAR",
+	"\"private\"",
+	"\"public\"",
+	"\"protected\"",
+	"\"static\"",
+	"\"transient\"",
+	"\"native\"",
+	"\"threadsafe\"",
+	"\"synchronized\"",
+	"\"volatile\"",
+	"\"class\"",
+	"\"extends\"",
+	"\"interface\"",
+	"LCURLY",
+	"RCURLY",
+	"COMMA",
+	"\"implements\"",
+	"LPAREN",
+	"RPAREN",
+	"\"this\"",
+	"\"super\"",
+	"ASSIGN",
+	"\"throws\"",
+	"COLON",
+	"\"if\"",
+	"\"else\"",
+	"\"for\"",
+	"\"while\"",
+	"\"do\"",
+	"\"break\"",
+	"\"continue\"",
+	"\"return\"",
+	"\"switch\"",
+	"\"throw\"",
+	"\"case\"",
+	"\"default\"",
+	"\"try\"",
+	"\"finally\"",
+	"\"catch\"",
+	"PLUS_ASSIGN",
+	"MINUS_ASSIGN",
+	"STAR_ASSIGN",
+	"DIV_ASSIGN",
+	"MOD_ASSIGN",
+	"SR_ASSIGN",
+	"BSR_ASSIGN",
+	"SL_ASSIGN",
+	"BAND_ASSIGN",
+	"BXOR_ASSIGN",
+	"BOR_ASSIGN",
+	"QUESTION",
+	"LOR",
+	"LAND",
+	"BOR",
+	"BXOR",
+	"BAND",
+	"NOT_EQUAL",
+	"EQUAL",
+	"LT_",
+	"GT",
+	"LE",
+	"GE",
+	"\"instanceof\"",
+	"SL",
+	"SR",
+	"BSR",
+	"PLUS",
+	"MINUS",
+	"DIV",
+	"MOD",
+	"INC",
+	"DEC",
+	"BNOT",
+	"LNOT",
+	"\"true\"",
+	"\"false\"",
+	"\"null\"",
+	"\"new\"",
+	"NUM_INT",
+	"CHAR_LITERAL",
+	"STRING_LITERAL",
+	"NUM_FLOAT",
+	"NUM_LONG",
+	"NUM_DOUBLE",
+	"WS",
+	"SL_COMMENT",
+	"ML_COMMENT",
+	"ESC",
+	"HEX_DIGIT",
+	"VOCAB",
+	"EXPONENT",
+	"FLOAT_SUFFIX",
+	0
+};
+
+const unsigned long JavaRecognizer::_tokenSet_0_data_[] = { 0UL, 3758105472UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// "interface" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_0(_tokenSet_0_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_1(_tokenSet_1_data_,6);
+const unsigned long JavaRecognizer::_tokenSet_2_data_[] = { 2UL, 3758121856UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "final" "abstract" "strictfp" SEMI "import" "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+// "class" "interface" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_2(_tokenSet_2_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_3_data_[] = { 2UL, 3758105472UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "final" "abstract" "strictfp" SEMI "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+// "class" "interface" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_3(_tokenSet_3_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_4_data_[] = { 0UL, 67215360UL, 687616UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK RBRACK IDENT LCURLY RCURLY COMMA "implements" LPAREN RPAREN 
+// ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN 
+// SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION 
+// LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_4(_tokenSet_4_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_5_data_[] = { 0UL, 8192UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_5(_tokenSet_5_data_,6);
+const unsigned long JavaRecognizer::_tokenSet_6_data_[] = { 0UL, 3758097280UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_6(_tokenSet_6_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_7_data_[] = { 0UL, 134086656UL, 320UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT "class" "interface" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_7(_tokenSet_7_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_8_data_[] = { 2UL, 3892192128UL, 4294027135UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+// "class" "interface" LCURLY RCURLY LPAREN "this" "super" "if" "else" 
+// "for" "while" "do" "break" "continue" "return" "switch" "throw" "case" 
+// "default" "try" PLUS MINUS INC DEC BNOT LNOT "true" "false" "null" "new" 
+// NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_8(_tokenSet_8_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_9_data_[] = { 2UL, 3892192128UL, 1919UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+// "class" "interface" LCURLY RCURLY 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_9(_tokenSet_9_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_10_data_[] = { 0UL, 67182592UL, 674816UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK IDENT RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_10(_tokenSet_10_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_11_data_[] = { 0UL, 201433088UL, 683008UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK RBRACK IDENT DOT RCURLY COMMA LPAREN RPAREN ASSIGN COLON 
+// PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN 
+// BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR 
+// LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_11(_tokenSet_11_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_12_data_[] = { 0UL, 32768UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LBRACK LPAREN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_12(_tokenSet_12_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_13_data_[] = { 0UL, 3892183936UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// "interface" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_13(_tokenSet_13_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_14_data_[] = { 0UL, 0UL, 4608UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LCURLY "implements" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_14(_tokenSet_14_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_15_data_[] = { 0UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LCURLY 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_15(_tokenSet_15_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_16_data_[] = { 2UL, 4294943616UL, 4294700927UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF "final" "abstract" "strictfp" SEMI LBRACK RBRACK "void" "boolean" 
+// "byte" "char" "short" "int" "float" "long" "double" IDENT DOT STAR "private" 
+// "public" "protected" "static" "transient" "native" "threadsafe" "synchronized" 
+// "volatile" "class" "interface" LCURLY RCURLY COMMA LPAREN RPAREN "this" 
+// "super" ASSIGN COLON "if" "else" "for" "while" "do" "break" "continue" 
+// "return" "switch" "throw" "case" "default" "try" PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS DIV MOD INC DEC BNOT 
+// LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_16(_tokenSet_16_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_17_data_[] = { 0UL, 4026434432UL, 8575UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" LBRACK "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT DOT "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+// "class" "interface" LPAREN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_17(_tokenSet_17_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_18_data_[] = { 0UL, 201359360UL, 0UL, 0UL, 0UL, 0UL };
+// LBRACK IDENT DOT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_18(_tokenSet_18_data_,6);
+const unsigned long JavaRecognizer::_tokenSet_19_data_[] = { 0UL, 40960UL, 133120UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK COMMA ASSIGN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_19(_tokenSet_19_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_20_data_[] = { 0UL, 3892192128UL, 1919UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// "interface" LCURLY RCURLY 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_20(_tokenSet_20_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_21_data_[] = { 0UL, 3892192128UL, 1070704255UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// LCURLY RCURLY LPAREN "this" "super" "if" "for" "while" "do" "break" 
+// "continue" "return" "switch" "throw" "try" PLUS MINUS INC DEC BNOT LNOT 
+// "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT 
+// NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_21(_tokenSet_21_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_22_data_[] = { 0UL, 4294878080UL, 1071359871UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI LBRACK "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT DOT STAR "private" "public" 
+// "protected" "static" "transient" "native" "threadsafe" "synchronized" 
+// "volatile" "class" "interface" LCURLY RCURLY LPAREN "this" "super" ASSIGN 
+// COLON "if" "for" "while" "do" "break" "continue" "return" "switch" "throw" 
+// "try" PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN 
+// BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR 
+// LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL SR BSR 
+// PLUS MINUS DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT 
+// CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_22(_tokenSet_22_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_23_data_[] = { 0UL, 3892192128UL, 1070703231UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// LCURLY LPAREN "this" "super" "if" "for" "while" "do" "break" "continue" 
+// "return" "switch" "throw" "try" PLUS MINUS INC DEC BNOT LNOT "true" 
+// "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG 
+// NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_23(_tokenSet_23_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_24_data_[] = { 0UL, 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// RPAREN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_24(_tokenSet_24_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_25_data_[] = { 0UL, 8192UL, 412160UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LCURLY COMMA RPAREN ASSIGN "throws" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_25(_tokenSet_25_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_26_data_[] = { 0UL, 8192UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LCURLY 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_26(_tokenSet_26_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_27_data_[] = { 0UL, 3892192128UL, 4294027135UL, 3221225479UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// "interface" LCURLY RCURLY LPAREN "this" "super" "if" "else" "for" "while" 
+// "do" "break" "continue" "return" "switch" "throw" "case" "default" "try" 
+// "finally" "catch" PLUS MINUS INC DEC BNOT LNOT "true" "false" "null" 
+// "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_27(_tokenSet_27_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_28_data_[] = { 0UL, 3892192128UL, 4294026879UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// LCURLY RCURLY LPAREN "this" "super" "if" "else" "for" "while" "do" "break" 
+// "continue" "return" "switch" "throw" "case" "default" "try" PLUS MINUS 
+// INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_28(_tokenSet_28_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_29_data_[] = { 0UL, 4294878080UL, 4294682495UL, 4294967295UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI LBRACK "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT DOT STAR "private" "public" 
+// "protected" "static" "transient" "native" "threadsafe" "synchronized" 
+// "volatile" "class" "interface" LCURLY RCURLY LPAREN "this" "super" ASSIGN 
+// COLON "if" "else" "for" "while" "do" "break" "continue" "return" "switch" 
+// "throw" "case" "default" "try" "finally" "catch" PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS DIV MOD INC DEC BNOT 
+// LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_29(_tokenSet_29_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_30_data_[] = { 0UL, 3892183936UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_30(_tokenSet_30_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_31_data_[] = { 0UL, 4026434432UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" LBRACK "void" "boolean" "byte" "char" 
+// "short" "int" "float" "long" "double" IDENT DOT "private" "public" "protected" 
+// "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_31(_tokenSet_31_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_32_data_[] = { 0UL, 134086656UL, 106496UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT LPAREN "this" "super" PLUS MINUS INC DEC BNOT LNOT "true" "false" 
+// "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG 
+// NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_32(_tokenSet_32_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_33_data_[] = { 0UL, 536780800UL, 237568UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK "void" "boolean" "byte" "char" "short" "int" "float" "long" 
+// "double" IDENT DOT STAR LPAREN "this" "super" ASSIGN PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS DIV MOD INC DEC BNOT 
+// LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_33(_tokenSet_33_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_34_data_[] = { 0UL, 3758097280UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_34(_tokenSet_34_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_35_data_[] = { 0UL, 3825206144UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_35(_tokenSet_35_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_36_data_[] = { 0UL, 8192UL, 2048UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI COMMA 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_36(_tokenSet_36_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_37_data_[] = { 0UL, 8192UL, 3072UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RCURLY COMMA 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_37(_tokenSet_37_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_38_data_[] = { 0UL, 134086656UL, 107008UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT LCURLY LPAREN "this" "super" PLUS MINUS INC DEC BNOT LNOT "true" 
+// "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG 
+// NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_38(_tokenSet_38_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_39_data_[] = { 0UL, 402759680UL, 674816UL, 4294967288UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK RBRACK DOT STAR RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN 
+// MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN 
+// SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR 
+// BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS 
+// DIV MOD INC DEC 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_39(_tokenSet_39_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_40_data_[] = { 0UL, 73728UL, 543744UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN COLON 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_40(_tokenSet_40_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_41_data_[] = { 0UL, 0UL, 18432UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// COMMA RPAREN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_41(_tokenSet_41_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_42_data_[] = { 0UL, 134086656UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_42(_tokenSet_42_data_,6);
+const unsigned long JavaRecognizer::_tokenSet_43_data_[] = { 0UL, 536780800UL, 239616UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK "void" "boolean" "byte" "char" "short" "int" "float" "long" 
+// "double" IDENT DOT STAR COMMA LPAREN "this" "super" ASSIGN PLUS_ASSIGN 
+// MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN 
+// SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR 
+// BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS 
+// DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL 
+// STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_43(_tokenSet_43_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_44_data_[] = { 0UL, 134086656UL, 630784UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT LPAREN "this" "super" COLON PLUS MINUS INC DEC BNOT LNOT "true" 
+// "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG 
+// NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_44(_tokenSet_44_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_45_data_[] = { 0UL, 0UL, 3221226496UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// RCURLY "case" "default" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_45(_tokenSet_45_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_46_data_[] = { 0UL, 3892192128UL, 4291929727UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// LCURLY RCURLY LPAREN "this" "super" "if" "for" "while" "do" "break" 
+// "continue" "return" "switch" "throw" "case" "default" "try" PLUS MINUS 
+// INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_46(_tokenSet_46_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_47_data_[] = { 0UL, 8192UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RPAREN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_47(_tokenSet_47_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_48_data_[] = { 0UL, 3892192128UL, 4294026879UL, 3221225479UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI "void" "boolean" "byte" "char" "short" 
+// "int" "float" "long" "double" IDENT "private" "public" "protected" "static" 
+// "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
+// LCURLY RCURLY LPAREN "this" "super" "if" "else" "for" "while" "do" "break" 
+// "continue" "return" "switch" "throw" "case" "default" "try" "finally" 
+// "catch" PLUS MINUS INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT 
+// CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_48(_tokenSet_48_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_49_data_[] = { 0UL, 73728UL, 674816UL, 16376UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_49(_tokenSet_49_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_50_data_[] = { 0UL, 73728UL, 674816UL, 32760UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_50(_tokenSet_50_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_51_data_[] = { 0UL, 73728UL, 674816UL, 65528UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_51(_tokenSet_51_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_52_data_[] = { 0UL, 73728UL, 674816UL, 131064UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_52(_tokenSet_52_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_53_data_[] = { 0UL, 73728UL, 674816UL, 262136UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_53(_tokenSet_53_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_54_data_[] = { 0UL, 73728UL, 674816UL, 524280UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_54(_tokenSet_54_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_55_data_[] = { 0UL, 73728UL, 674816UL, 1048568UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_55(_tokenSet_55_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_56_data_[] = { 0UL, 73728UL, 674816UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_56(_tokenSet_56_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_57_data_[] = { 0UL, 73728UL, 674816UL, 134217720UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_57(_tokenSet_57_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_58_data_[] = { 0UL, 73728UL, 674816UL, 1073741816UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_58(_tokenSet_58_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_59_data_[] = { 0UL, 268435456UL, 0UL, 0UL, 3UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// STAR DIV MOD 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_59(_tokenSet_59_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_60_data_[] = { 0UL, 73728UL, 674816UL, 4294967288UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_60(_tokenSet_60_data_,8);
+const unsigned long JavaRecognizer::_tokenSet_61_data_[] = { 0UL, 268509184UL, 674816UL, 4294967288UL, 3UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RBRACK STAR RCURLY COMMA RPAREN ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS DIV MOD 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_61(_tokenSet_61_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_62_data_[] = { 0UL, 134086656UL, 106496UL, 0UL, 65472UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT LPAREN "this" "super" "true" "false" "null" "new" NUM_INT CHAR_LITERAL 
+// STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_62(_tokenSet_62_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_63_data_[] = { 0UL, 536846336UL, 781312UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK RBRACK "void" "boolean" "byte" "char" "short" "int" "float" 
+// "long" "double" IDENT DOT STAR RCURLY COMMA LPAREN RPAREN "this" "super" 
+// ASSIGN COLON PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN 
+// SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION 
+// LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL 
+// SR BSR PLUS MINUS DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" 
+// NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_63(_tokenSet_63_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_64_data_[] = { 0UL, 4294943616UL, 4294700927UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "final" "abstract" "strictfp" SEMI LBRACK RBRACK "void" "boolean" "byte" 
+// "char" "short" "int" "float" "long" "double" IDENT DOT STAR "private" 
+// "public" "protected" "static" "transient" "native" "threadsafe" "synchronized" 
+// "volatile" "class" "interface" LCURLY RCURLY COMMA LPAREN RPAREN "this" 
+// "super" ASSIGN COLON "if" "else" "for" "while" "do" "break" "continue" 
+// "return" "switch" "throw" "case" "default" "try" PLUS_ASSIGN MINUS_ASSIGN 
+// STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN 
+// BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL 
+// LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS DIV MOD INC DEC BNOT 
+// LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL 
+// NUM_FLOAT NUM_LONG NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_64(_tokenSet_64_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_65_data_[] = { 0UL, 134152192UL, 106496UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// RBRACK "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
+// IDENT LPAREN "this" "super" PLUS MINUS INC DEC BNOT LNOT "true" "false" 
+// "null" "new" NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG 
+// NUM_DOUBLE 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_65(_tokenSet_65_data_,12);
+const unsigned long JavaRecognizer::_tokenSet_66_data_[] = { 0UL, 402759680UL, 675328UL, 4294967288UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LBRACK RBRACK DOT STAR LCURLY RCURLY COMMA RPAREN ASSIGN COLON 
+// PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN 
+// BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR 
+// LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL SR BSR 
+// PLUS MINUS DIV MOD INC DEC 
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaRecognizer::_tokenSet_66(_tokenSet_66_data_,12);
+
+