// $ANTLR 2.7.2: "java.g" -> "JavaRecognizer.java"$
   
   package org.codehaus.groovy.antlr.java;
   import org.codehaus.groovy.antlr.*;
   import org.codehaus.groovy.antlr.parser.*;
   import java.util.*;
   import java.io.InputStream;
   import java.io.Reader;
   import antlr.InputBuffer;
  import antlr.LexerSharedInputState;
  
  import antlr.TokenBuffer;
  import antlr.TokenStreamException;
  import antlr.TokenStreamIOException;
  import antlr.ANTLRException;
  import antlr.LLkParser;
  import antlr.Token;
  import antlr.TokenStream;
  import antlr.RecognitionException;
  import antlr.NoViableAltException;
  import antlr.MismatchedTokenException;
  import antlr.SemanticException;
  import antlr.ParserSharedInputState;
  import antlr.collections.impl.BitSet;
  import antlr.collections.AST;
  import java.util.Hashtable;
  import antlr.ASTFactory;
  import antlr.ASTPair;
  import antlr.collections.impl.ASTArray;
  
  /*** Java 1.5 Recognizer
   *
   * Run 'java Main [-showtree] directory-full-of-java-files'
   *
   * [The -showtree option pops up a Swing frame that shows
   *  the AST constructed from the parser.]
   *
   * Run 'java Main <directory full of java files>'
   *
   * Contributing authors:
   *      Jeremy Rayner       groovy@ross-rayner.com
   *		John Mitchell		johnm@non.net
   *		Terence Parr		parrt@magelang.com
   *		John Lilley		jlilley@empathy.com
   *		Scott Stanchfield	thetick@magelang.com
   *		Markus Mohnen		mohnen@informatik.rwth-aachen.de
   *		Peter Williams		pete.williams@sun.com
   *		Allan Jacobs		Allan.Jacobs@eng.sun.com
   *		Steve Messick		messick@redhills.com
   *		John Pybus		john@pybus.org
   *
   * Version 1.00 December 9, 1997 -- initial release
   * Version 1.01 December 10, 1997
   *		fixed bug in octal def (0..7 not 0..8)
   * Version 1.10 August 1998 (parrt)
   *		added tree construction
   *		fixed definition of WS,comments for mac,pc,unix newlines
   *		added unary plus
   * Version 1.11 (Nov 20, 1998)
   *		Added "shutup" option to turn off last ambig warning.
   *		Fixed inner class def to allow named class defs as statements
   *		synchronized requires compound not simple statement
   *		add [] after builtInType DOT class in primaryExpression
   *		"const" is reserved but not valid..removed from modifiers
   * Version 1.12 (Feb 2, 1999)
   *		Changed LITERAL_xxx to xxx in tree grammar.
   *		Updated java.g to use tokens {...} now for 2.6.0 (new feature).
   *
   * Version 1.13 (Apr 23, 1999)
   *		Didn't have (stat)? for else clause in tree parser.
   *		Didn't gen ASTs for interface extends.  Updated tree parser too.
   *		Updated to 2.6.0.
   * Version 1.14 (Jun 20, 1999)
   *		Allowed final/abstract on local classes.
   *		Removed local interfaces from methods
   *		Put instanceof precedence where it belongs...in relationalExpr
   *			It also had expr not type as arg; fixed it.
   *		Missing ! on SEMI in classBlock
   *		fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
   *		fixed: didn't like Object[].class in parser or tree parser
   * Version 1.15 (Jun 26, 1999)
   *		Screwed up rule with instanceof in it. :(  Fixed.
   *		Tree parser didn't like (expr).something; fixed.
   *		Allowed multiple inheritance in tree grammar. oops.
   * Version 1.16 (August 22, 1999)
   *		Extending an interface built a wacky tree: had extra EXTENDS.
   *		Tree grammar didn't allow multiple superinterfaces.
   *		Tree grammar didn't allow empty var initializer: {}
   * Version 1.17 (October 12, 1999)
   *		ESC lexer rule allowed 399 max not 377 max.
   *		java.tree.g didn't handle the expression of synchronized
   *		statements.
   * Version 1.18 (August 12, 2001)
   *	  	Terence updated to Java 2 Version 1.3 by
   *		observing/combining work of Allan Jacobs and Steve
   *		Messick.  Handles 1.3 src.  Summary:
   *		o  primary didn't include boolean.class kind of thing
   *	  	o  constructor calls parsed explicitly now:
   * 		   see explicitConstructorInvocation
  *		o  add strictfp modifier
  *	  	o  missing objBlock after new expression in tree grammar
  *		o  merged local class definition alternatives, moved after declaration
  *		o  fixed problem with ClassName.super.field
  *	  	o  reordered some alternatives to make things more efficient
  *		o  long and double constants were not differentiated from int/float
  *		o  whitespace rule was inefficient: matched only one char
  *		o  add an examples directory with some nasty 1.3 cases
  *		o  made Main.java use buffered IO and a Reader for Unicode support
  *		o  supports UNICODE?
  *		   Using Unicode charVocabulay makes code file big, but only
  *		   in the bitsets at the end. I need to make ANTLR generate
  *		   unicode bitsets more efficiently.
  * Version 1.19 (April 25, 2002)
  *		Terence added in nice fixes by John Pybus concerning floating
  *		constants and problems with super() calls.  John did a nice
  *		reorg of the primary/postfix expression stuff to read better
  *		and makes f.g.super() parse properly (it was METHOD_CALL not
  *		a SUPER_CTOR_CALL).  Also:
  *
  *		o  "finally" clause was a root...made it a child of "try"
  *		o  Added stuff for asserts too for Java 1.4, but *commented out*
  *		   as it is not backward compatible.
  *
  * Version 1.20 (October 27, 2002)
  *
  *	  Terence ended up reorging John Pybus' stuff to
  *	  remove some nondeterminisms and some syntactic predicates.
  *	  Note that the grammar is stricter now; e.g., this(...) must
  *	be the first statement.
  *
  *	  Trinary ?: operator wasn't working as array name:
  *		  (isBig ? bigDigits : digits)[i];
  *
  *	  Checked parser/tree parser on source for
  *		  Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
  *		and the 110k-line jGuru server source.
  *
  * Version 1.21 (October 17, 2003)
  *  Fixed lots of problems including:
  *  Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g
  *  He found a problem/fix with floating point that start with 0
  *  Ray also fixed problem that (int.class) was not recognized.
  *  Thorsten van Ellen noticed that \n are allowed incorrectly in strings.
  *  TJP fixed CHAR_LITERAL analogously.
  *
  * Version 1.21.2 (March, 2003)
  *	  Changes by Matt Quail to support generics (as per JDK1.5/JSR14)
  *	  Notes:
  *	  o We only allow the "extends" keyword and not the "implements"
  *		keyword, since thats what JSR14 seems to imply.
  *	  o Thanks to Monty Zukowski for his help on the antlr-interest
  *		mail list.
  *	  o Thanks to Alan Eliasen for testing the grammar over his
  *		Fink source base
  *
  * Version 1.22 (July, 2004)
  *	  Changes by Michael Studman to support Java 1.5 language extensions
  *	  Notes:
  *	  o Added support for annotations types
  *	  o Finished off Matt Quail's generics enhancements to support bound type arguments
  *	  o Added support for new for statement syntax
  *	  o Added support for static import syntax
  *	  o Added support for enum types
  *	  o Tested against JDK 1.5 source base and source base of jdigraph project
  *	  o Thanks to Matt Quail for doing the hard part by doing most of the generics work
  *
  * Version 1.22.1 (July 28, 2004)
  *	  Bug/omission fixes for Java 1.5 language support
  *	  o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for
  *		spotting this
  *	  o Fixed bug where incorrect handling of SR and BSR tokens would cause type
  *		parameters to be recognised as type arguments.
  *	  o Enabled type parameters on constructors, annotations on enum constants
  *		and package definitions
  *	  o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua
  *
  * Version 1.22.2 (July 28, 2004)
  *	  Slight refactoring of Java 1.5 language support
  *	  o Refactored for/"foreach" productions so that original literal "for" literal
  *	    is still used but the for sub-clauses vary by token type
  *	  o Fixed bug where type parameter was not included in generic constructor's branch of AST
  *
  * Version 1.22.3 (August 26, 2004)
  *	  Bug fixes as identified by Michael Stahl; clean up of tabs/spaces
  *        and other refactorings
  *	  o Fixed typeParameters omission in identPrimary and newStatement
  *	  o Replaced GT reconcilliation code with simple semantic predicate
  *	  o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar
  *	  o Refactored typeDefinition production and field productions to reduce duplication
  *
  * Version 1.22.4 (October 21, 2004)
  *    Small bux fixes
  *    o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised()
  *    o Added typeArguments to postfixExpression productions for anonymous inner class super
  *      constructor invocation, e.g. new Outer().<String>super()
  *    o Fixed bug in array declarations identified by Geoff Roy
  *
  * Version 1.22.4.j.1
  *	  Changes by Jeremy Rayner to support java2groovy tool
  *    o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
  *      and have made some changes to enable use by java2groovy tool (Jan 2007)
  *
  * This grammar is in the PUBLIC DOMAIN
  */
 public class JavaRecognizer extends antlr.LLkParser       implements JavaTokenTypes
  {
 
     /*** This factory is the correct way to wire together a Groovy parser and lexer. */
     public static JavaRecognizer make(JavaLexer lexer) {
         JavaRecognizer parser = new JavaRecognizer(lexer.plumb());
         // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
         parser.lexer = lexer;
         lexer.parser = parser;
         parser.setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
         return parser;
     }
     // Create a scanner that reads from the input stream passed to us...
     public static JavaRecognizer make(InputStream in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(Reader in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(InputBuffer in) { return make(new JavaLexer(in)); }
     public static JavaRecognizer make(LexerSharedInputState in) { return make(new JavaLexer(in)); }
     
     private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
     
     JavaLexer lexer;
     public JavaLexer getLexer() { return lexer; }
     public void setFilename(String f) { super.setFilename(f); lexer.setFilename(f); }
     private SourceBuffer sourceBuffer;
     public void setSourceBuffer(SourceBuffer sourceBuffer) {
         this.sourceBuffer = sourceBuffer;
     }
 
     /*** Create an AST node with the token type and text passed in, but
      *  with the same background information as another supplied Token (e.g. line numbers)
      * to be used in place of antlr tree construction syntax,
      * i.e. #[TOKEN,"text"]  becomes  create(TOKEN,"text",anotherToken)
      *
      * todo - change antlr.ASTFactory to do this instead...
      */
     public AST create(int type, String txt, Token first, Token last) {
         AST t = astFactory.create(type,txt);
         if ( t != null && first != null) {
             // first copy details from first token
             t.initialize(first);
             // then ensure that type and txt are specific to this new node
             t.initialize(type,txt);
         }
 
         if ((t instanceof GroovySourceAST) && last != null) {
             GroovySourceAST node = (GroovySourceAST)t;
             node.setLast(last);
             // This is a good point to call node.setSnippet(),
             // but it bulks up the AST too much for production code.
         }
         return t;
     }
 
     
     /***
 	 * Counts the number of LT seen in the typeArguments production.
 	 * It is used in semantic predicates to ensure we have seen
 	 * enough closing '>' characters; which actually may have been
 	 * either GT, SR or BSR tokens.
 	 */
 	private int ltCounter = 0;
 
 protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
   super(tokenBuf,k);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public JavaRecognizer(TokenBuffer tokenBuf) {
   this(tokenBuf,2);
 }
 
 protected JavaRecognizer(TokenStream lexer, int k) {
   super(lexer,k);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 public JavaRecognizer(TokenStream lexer) {
   this(lexer,2);
 }
 
 public JavaRecognizer(ParserSharedInputState state) {
   super(state,2);
   tokenNames = _tokenNames;
   buildTokenTypeASTClassMap();
   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
 }
 
 	public final void compilationUnit() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST compilationUnit_AST = null;
 		
 		{
 		boolean synPredMatched4 = false;
 		if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) {
 			int _m4 = mark();
 			synPredMatched4 = true;
 			inputState.guessing++;
 			try {
 				{
 				annotations();
 				match(LITERAL_package);
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched4 = false;
 			}
 			rewind(_m4);
 			inputState.guessing--;
 		}
 		if ( synPredMatched4 ) {
 			packageDefinition();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		{
 		_loop6:
 		do {
 			if ((LA(1)==LITERAL_import)) {
 				importDefinition();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop6;
 			}
 			
 		} while (true);
 		}
 		{
 		_loop8:
 		do {
 			if ((_tokenSet_2.member(LA(1)))) {
 				typeDefinition();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop8;
 			}
 			
 		} while (true);
 		}
 		match(Token.EOF_TYPE);
 		compilationUnit_AST = (AST)currentAST.root;
 		returnAST = compilationUnit_AST;
 	}
 	
 	public final void annotations() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotations_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop62:
 		do {
 			if ((LA(1)==AT)) {
 				annotation();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop62;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			annotations_AST = (AST)currentAST.root;
 			annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST));
 			currentAST.root = annotations_AST;
 			currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ?
 				annotations_AST.getFirstChild() : annotations_AST;
 			currentAST.advanceChildToEnd();
 		}
 		annotations_AST = (AST)currentAST.root;
 		returnAST = annotations_AST;
 	}
 	
 	public> final void packageDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST packageDefinition_AST = null;
 		Token  p = null;
 		AST p_AST = null;
 		
 		try {      // for error handling
 			annotations();
 			astFactory.addASTChild(currentAST, returnAST);
 			p = LT(1);
 			p_AST = astFactory.create(p);
 			astFactory.makeASTRoot(currentAST, p_AST);
 			match(LITERAL_package);
 			if ( inputState.guessing==0 ) {
 				p_AST.setType(PACKAGE_DEF);
 			}
 			identifier();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(SEMI);
 			packageDefinition_AST = (AST)currentAST.root;
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				consume();
 				consumeUntil(_tokenSet_0);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = packageDefinition_AST;
 	}
 	
 	public final void importDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST importDefinition_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		boolean isStatic = false;
 		
 		try {      // for error handling
 			i = LT(1);
 			i_AST = astFactory.create(i);
 			astFactory.makeASTRoot(currentAST, i_AST);
 			match(LITERAL_import);
 			if ( inputState.guessing==0 ) {
 				i_AST.setType(IMPORT);
 			}
 			{
 			switch ( LA(1)) {
 			case LITERAL_static:
 			{
 				match(LITERAL_static);
 				if ( inputState.guessing==0 ) {
 					i_AST.setType(STATIC_IMPORT);
 				}
 				break;
 			}
 			case IDENT:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			identifierStar();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(SEMI);
 			importDefinition_AST = (AST)currentAST.root;
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				consume();
 				consumeUntil(_tokenSet_0);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = importDefinition_AST;
 	}
 	
 	public final void typeDefinition() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeDefinition_AST = null;
 		AST m_AST = null;
 		
 		try {      // for error handling
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_static:
 			case LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case AT:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				modifiers();
 				m_AST = (AST)returnAST;
 				typeDefinitionInternal(m_AST);
 				astFactory.addASTChild(currentAST, returnAST);
 				typeDefinition_AST = (AST)currentAST.root;
 				break;
 			}
 			case SEMI:
 			{
 				match(SEMI);
 				typeDefinition_AST = (AST)currentAST.root;
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 		}
 		catch (RecognitionException ex) {
 			if (inputState.guessing==0) {
 				reportError(ex);
 				consume();
 				consumeUntil(_tokenSet_3);
 			} else {
 			  throw ex;
 			}
 		}
 		returnAST = typeDefinition_AST;
 	}
 	
 	public final void identifier() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifier_AST = null;
 		
 		AST tmp6_AST = null;
 		tmp6_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp6_AST);
 		match(IDENT);
 		{
 		_loop48:
 		do {
 			if ((LA(1)==DOT)) {
 				AST tmp7_AST = null;
 				tmp7_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp7_AST);
 				match(DOT);
 				AST tmp8_AST = null;
 				tmp8_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp8_AST);
 				match(IDENT);
 			}
 			else {
 				break _loop48;
 			}
 			
 		} while (true);
 		}
 		identifier_AST = (AST)currentAST.root;
 		returnAST = identifier_AST;
 	}
 	
 	public final void identifierStar() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identifierStar_AST = null;
 		
 		AST tmp9_AST = null;
 		tmp9_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp9_AST);
 		match(IDENT);
 		{
 		_loop51:
 		do {
 			if ((LA(1)==DOT) && (LA(2)==IDENT)) {
 				AST tmp10_AST = null;
 				tmp10_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp10_AST);
 				match(DOT);
 				AST tmp11_AST = null;
 				tmp11_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp11_AST);
 				match(IDENT);
 			}
 			else {
 				break _loop51;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case DOT:
 		{
 			AST tmp12_AST = null;
 			tmp12_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp12_AST);
 			match(DOT);
 			AST tmp13_AST = null;
 			tmp13_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp13_AST);
 			match(STAR);
 			break;
 		}
 		case SEMI:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		identifierStar_AST = (AST)currentAST.root;
 		returnAST = identifierStar_AST;
 	}
 	
 	public final void modifiers() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST modifiers_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop55:
 		do {
 			if ((_tokenSet_4.member(LA(1)))) {
 				modifier();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) {
 				annotation();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop55;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			modifiers_AST = (AST)currentAST.root;
 			modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(modifiers_AST));
 			currentAST.root = modifiers_AST;
 			currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
 				modifiers_AST.getFirstChild() : modifiers_AST;
 			currentAST.advanceChildToEnd();
 		}
 		modifiers_AST = (AST)currentAST.root;
 		returnAST = modifiers_AST;
 	}
 	
 	protected final void typeDefinitionInternal(
 		AST mods
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeDefinitionInternal_AST = null;
 		
 		switch ( LA(1)) {
 		case LITERAL_class:
 		{
 			classDefinition(mods);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_interface:
 		{
 			interfaceDefinition(mods);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_enum:
 		{
 			enumDefinition(mods);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		case AT:
 		{
 			annotationDefinition(mods);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeDefinitionInternal_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeDefinitionInternal_AST;
 	}
 	
 	public final void classDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classDefinition_AST = null;
 		AST tp_AST = null;
 		AST sc_AST = null;
 		AST ic_AST = null;
 		AST cb_AST = null;
 		Token first = LT(1);
 		
 		match(LITERAL_class);
 		AST tmp15_AST = null;
 		tmp15_AST = astFactory.create(LT(1));
 		match(IDENT);
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeParameters();
 			tp_AST = (AST)returnAST;
 			break;
 		}
 		case LITERAL_extends:
 		case LCURLY:
 		case LITERAL_implements:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		superClassClause();
 		sc_AST = (AST)returnAST;
 		implementsClause();
 		ic_AST = (AST)returnAST;
 		classBlock();
 		cb_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			classDefinition_AST = (AST)currentAST.root;
 			classDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(CLASS_DEF,"CLASS_DEF",first,LT(1))).add(modifiers).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
 			currentAST.root = classDefinition_AST;
 			currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
 				classDefinition_AST.getFirstChild() : classDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = classDefinition_AST;
 	}
 	
 	public final void interfaceDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST interfaceDefinition_AST = null;
 		AST tp_AST = null;
 		AST ie_AST = null;
 		AST ib_AST = null;
 		Token first = LT(1);
 		
 		match(LITERAL_interface);
 		AST tmp17_AST = null;
 		tmp17_AST = astFactory.create(LT(1));
 		match(IDENT);
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeParameters();
 			tp_AST = (AST)returnAST;
 			break;
 		}
 		case LITERAL_extends:
 		case LCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		interfaceExtends();
 		ie_AST = (AST)returnAST;
 		interfaceBlock();
 		ib_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			interfaceDefinition_AST = (AST)currentAST.root;
 			interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(create(INTERFACE_DEF,"INTERFACE_DEF",first,LT(1))).add(modifiers).add(tmp17_AST).add(tp_AST).add(ie_AST).add(ib_AST));
 			currentAST.root = interfaceDefinition_AST;
 			currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
 				interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = interfaceDefinition_AST;
 	}
 	
 	public final void enumDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumDefinition_AST = null;
 		AST ic_AST = null;
 		AST eb_AST = null;
 		Token first = LT(1);
 		
 		match(LITERAL_enum);
 		AST tmp19_AST = null;
 		tmp19_AST = astFactory.create(LT(1));
 		match(IDENT);
 		implementsClause();
 		ic_AST = (AST)returnAST;
 		enumBlock();
 		eb_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			enumDefinition_AST = (AST)currentAST.root;
 			enumDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(ENUM_DEF,"ENUM_DEF",first,LT(1))).add(modifiers).add(tmp19_AST).add(ic_AST).add(eb_AST));
 			currentAST.root = enumDefinition_AST;
 			currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
 				enumDefinition_AST.getFirstChild() : enumDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = enumDefinition_AST;
 	}
 	
 	public final void annotationDefinition(
 		AST modifiers
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationDefinition_AST = null;
 		AST ab_AST = null;
 		Token first = LT(1);
 		
 		AST tmp20_AST = null;
 		tmp20_AST = astFactory.create(LT(1));
 		match(AT);
 		match(LITERAL_interface);
 		AST tmp22_AST = null;
 		tmp22_AST = astFactory.create(LT(1));
 		match(IDENT);
 		annotationBlock();
 		ab_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			annotationDefinition_AST = (AST)currentAST.root;
 			annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(ANNOTATION_DEF,"ANNOTATION_DEF",first,LT(1))).add(modifiers).add(tmp22_AST).add(ab_AST));
 			currentAST.root = annotationDefinition_AST;
 			currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
 				annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = annotationDefinition_AST;
 	}
 	
 	public final void declaration() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST declaration_AST = null;
 		AST m_AST = null;
 		AST t_AST = null;
 		AST v_AST = null;
 		
 		modifiers();
 		m_AST = (AST)returnAST;
 		typeSpec(false);
 		t_AST = (AST)returnAST;
 		variableDefinitions(m_AST,t_AST);
 		v_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			declaration_AST = (AST)currentAST.root;
 			declaration_AST = v_AST;
 			currentAST.root = declaration_AST;
 			currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
 				declaration_AST.getFirstChild() : declaration_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = declaration_AST;
 	}
 	
 	public final void typeSpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeSpec_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		{
 			classTypeSpec(addImagNode);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeSpec_AST = (AST)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);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeSpec_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeSpec_AST;
 	}
 	
 	public final void variableDefinitions(
 		AST mods, AST t
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST variableDefinitions_AST = null;
 		
 		variableDeclarator(getASTFactory().dupTree(mods),
 							getASTFactory().dupTree(t));
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop155:
 		do {
 			if ((LA(1)==COMMA)) {
 				match(COMMA);
 				variableDeclarator(getASTFactory().dupTree(mods),
 							getASTFactory().dupTree(t));
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop155;
 			}
 			
 		} while (true);
 		}
 		variableDefinitions_AST = (AST)currentAST.root;
 		returnAST = variableDefinitions_AST;
 	}
 	
 	public final void classTypeSpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classTypeSpec_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		Token first = LT(1);
 		
 		classOrInterfaceType(false);
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop18:
 		do {
 			if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(ARRAY_DECLARATOR);
 				}
 				match(RBRACK);
 			}
 			else {
 				break _loop18;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			classTypeSpec_AST = (AST)currentAST.root;
 			
 						if ( addImagNode ) {
 							classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classTypeSpec_AST));
 						}
 					
 			currentAST.root = classTypeSpec_AST;
 			currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
 				classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
 			currentAST.advanceChildToEnd();
 		}
 		classTypeSpec_AST = (AST)currentAST.root;
 		returnAST = classTypeSpec_AST;
 	}
 	
 	public final void builtInTypeSpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST builtInTypeSpec_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		Token first = LT(1);
 		
 		builtInType();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop43:
 		do {
 			if ((LA(1)==LBRACK)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(ARRAY_DECLARATOR);
 				}
 				match(RBRACK);
 			}
 			else {
 				break _loop43;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			builtInTypeSpec_AST = (AST)currentAST.root;
 			
 						if ( addImagNode ) {
 							builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeSpec_AST));
 						}
 					
 			currentAST.root = builtInTypeSpec_AST;
 			currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
 				builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
 			currentAST.advanceChildToEnd();
 		}
 		builtInTypeSpec_AST = (AST)currentAST.root;
 		returnAST = builtInTypeSpec_AST;
 	}
 	
 	public final void classOrInterfaceType(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classOrInterfaceType_AST = null;
 		Token first = LT(1);
 		
 		AST tmp26_AST = null;
 		tmp26_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp26_AST);
 		match(IDENT);
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeArguments();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case SEMI:
 		case LBRACK:
 		case RBRACK:
 		case IDENT:
 		case DOT:
 		case QUESTION:
 		case LITERAL_extends:
 		case LITERAL_super:
 		case COMMA:
 		case GT:
 		case SR:
 		case BSR:
 		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 LPAREN:
 		case RPAREN:
 		case ASSIGN:
 		case LCURLY:
 		case RCURLY:
 		case BAND:
 		case LITERAL_implements:
 		case LITERAL_this:
 		case TRIPLE_DOT:
 		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 LOR:
 		case LAND:
 		case BOR:
 		case BXOR:
 		case NOT_EQUAL:
 		case EQUAL:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		_loop23:
 		do {
 			if ((LA(1)==DOT) && (LA(2)==IDENT)) {
 				AST tmp27_AST = null;
 				tmp27_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp27_AST);
 				match(DOT);
 				AST tmp28_AST = null;
 				tmp28_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp28_AST);
 				match(IDENT);
 				{
 				switch ( LA(1)) {
 				case LT:
 				{
 					typeArguments();
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case SEMI:
 				case LBRACK:
 				case RBRACK:
 				case IDENT:
 				case DOT:
 				case QUESTION:
 				case LITERAL_extends:
 				case LITERAL_super:
 				case COMMA:
 				case GT:
 				case SR:
 				case BSR:
 				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 LPAREN:
 				case RPAREN:
 				case ASSIGN:
 				case LCURLY:
 				case RCURLY:
 				case BAND:
 				case LITERAL_implements:
 				case LITERAL_this:
 				case TRIPLE_DOT:
 				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 LOR:
 				case LAND:
 				case BOR:
 				case BXOR:
 				case NOT_EQUAL:
 				case EQUAL:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 			}
 			else {
 				break _loop23;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			classOrInterfaceType_AST = (AST)currentAST.root;
 			
 						if ( addImagNode ) {
 							classOrInterfaceType_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(classOrInterfaceType_AST));
 						}
 					
 			currentAST.root = classOrInterfaceType_AST;
 			currentAST.child = classOrInterfaceType_AST!=null &&classOrInterfaceType_AST.getFirstChild()!=null ?
 				classOrInterfaceType_AST.getFirstChild() : classOrInterfaceType_AST;
 			currentAST.advanceChildToEnd();
 		}
 		classOrInterfaceType_AST = (AST)currentAST.root;
 		returnAST = classOrInterfaceType_AST;
 	}
 	
 	public final void typeArguments() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeArguments_AST = null;
 		int currentLtLevel = 0;  Token first = LT(1);
 		
 		if ( inputState.guessing==0 ) {
 			currentLtLevel = ltCounter;
 		}
 		match(LT);
 		if ( inputState.guessing==0 ) {
 			ltCounter++;
 		}
 		typeArgument();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop33:
 		do {
 			if (((LA(1)==COMMA) && (_tokenSet_5.member(LA(2))))&&(inputState.guessing !=0 || ltCounter == currentLtLevel + 1)) {
 				match(COMMA);
 				typeArgument();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop33;
 			}
 			
 		} while (true);
 		}
 		{
 		if (((LA(1) >= GT && LA(1) <= BSR)) && (_tokenSet_6.member(LA(2)))) {
 			typeArgumentsOrParametersEnd();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
 		  throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
 		if ( inputState.guessing==0 ) {
 			typeArguments_AST = (AST)currentAST.root;
 			typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS",first,LT(1))).add(typeArguments_AST));
 			currentAST.root = typeArguments_AST;
 			currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
 				typeArguments_AST.getFirstChild() : typeArguments_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeArguments_AST = (AST)currentAST.root;
 		returnAST = typeArguments_AST;
 	}
 	
 	public final void typeArgumentSpec() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeArgumentSpec_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		{
 			classTypeSpec(true);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeArgumentSpec_AST = (AST)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:
 		{
 			builtInTypeArraySpec(true);
 			astFactory.addASTChild(currentAST, returnAST);
 			typeArgumentSpec_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeArgumentSpec_AST;
 	}
 	
 	public final void builtInTypeArraySpec(
 		boolean addImagNode
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST builtInTypeArraySpec_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		Token first = LT(1);
 		
 		builtInType();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		int _cnt40=0;
 		_loop40:
 		do {
 			if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(ARRAY_DECLARATOR);
 				}
 				match(RBRACK);
 			}
 			else {
 				if ( _cnt40>=1 ) { break _loop40; } else {throw new NoViableAltException(LT(1), getFilename());}
 			}
 			
 			_cnt40++;
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			builtInTypeArraySpec_AST = (AST)currentAST.root;
 			
 						if ( addImagNode ) {
 							builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(builtInTypeArraySpec_AST));
 						}
 					
 			currentAST.root = builtInTypeArraySpec_AST;
 			currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ?
 				builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST;
 			currentAST.advanceChildToEnd();
 		}
 		builtInTypeArraySpec_AST = (AST)currentAST.root;
 		returnAST = builtInTypeArraySpec_AST;
 	}
 	
 	public final void typeArgument() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeArgument_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		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:
 		{
 			typeArgumentSpec();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case QUESTION:
 		{
 			wildcardType();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			typeArgument_AST = (AST)currentAST.root;
 			typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_ARGUMENT,"TYPE_ARGUMENT",first,LT(1))).add(typeArgument_AST));
 			currentAST.root = typeArgument_AST;
 			currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
 				typeArgument_AST.getFirstChild() : typeArgument_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeArgument_AST = (AST)currentAST.root;
 		returnAST = typeArgument_AST;
 	}
 	
 	public final void wildcardType() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST wildcardType_AST = null;
 		Token  q = null;
 		AST q_AST = null;
 		
 		q = LT(1);
 		q_AST = astFactory.create(q);
 		astFactory.makeASTRoot(currentAST, q_AST);
 		match(QUESTION);
 		if ( inputState.guessing==0 ) {
 			q_AST.setType(WILDCARD_TYPE);
 		}
 		{
 		boolean synPredMatched30 = false;
 		if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (LA(2)==IDENT))) {
 			int _m30 = mark();
 			synPredMatched30 = true;
 			inputState.guessing++;
 			try {
 				{
 				switch ( LA(1)) {
 				case LITERAL_extends:
 				{
 					match(LITERAL_extends);
 					break;
 				}
 				case LITERAL_super:
 				{
 					match(LITERAL_super);
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched30 = false;
 			}
 			rewind(_m30);
 			inputState.guessing--;
 		}
 		if ( synPredMatched30 ) {
 			typeArgumentBounds();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		wildcardType_AST = (AST)currentAST.root;
 		returnAST = wildcardType_AST;
 	}
 	
 	public final void typeArgumentBounds() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeArgumentBounds_AST = null;
 		boolean isUpperBounds = false;  Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case LITERAL_extends:
 		{
 			match(LITERAL_extends);
 			if ( inputState.guessing==0 ) {
 				isUpperBounds=true;
 			}
 			break;
 		}
 		case LITERAL_super:
 		{
 			match(LITERAL_super);
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		classOrInterfaceType(false);
 		astFactory.addASTChild(currentAST, returnAST);
 		if ( inputState.guessing==0 ) {
 			typeArgumentBounds_AST = (AST)currentAST.root;
 			
 						if (isUpperBounds)
 						{
 							typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
 						}
 						else
 						{
 							typeArgumentBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_LOWER_BOUNDS,"TYPE_LOWER_BOUNDS",first,LT(1))).add(typeArgumentBounds_AST));
 						}
 					
 			currentAST.root = typeArgumentBounds_AST;
 			currentAST.child = typeArgumentBounds_AST!=null &&typeArgumentBounds_AST.getFirstChild()!=null ?
 				typeArgumentBounds_AST.getFirstChild() : typeArgumentBounds_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeArgumentBounds_AST = (AST)currentAST.root;
 		returnAST = typeArgumentBounds_AST;
 	}
 	
 	protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeArgumentsOrParametersEnd_AST = null;
 		
 		switch ( LA(1)) {
 		case GT:
 		{
 			match(GT);
 			if ( inputState.guessing==0 ) {
 				ltCounter-=1;
 			}
 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
 			break;
 		}
 		case SR:
 		{
 			match(SR);
 			if ( inputState.guessing==0 ) {
 				ltCounter-=2;
 			}
 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
 			break;
 		}
 		case BSR:
 		{
 			match(BSR);
 			if ( inputState.guessing==0 ) {
 				ltCounter-=3;
 			}
 			typeArgumentsOrParametersEnd_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = typeArgumentsOrParametersEnd_AST;
 	}
 	
 	public final void builtInType() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST builtInType_AST = null;
 		
 		switch ( LA(1)) {
 		case LITERAL_void:
 		{
 			AST tmp37_AST = null;
 			tmp37_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp37_AST);
 			match(LITERAL_void);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_boolean:
 		{
 			AST tmp38_AST = null;
 			tmp38_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp38_AST);
 			match(LITERAL_boolean);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_byte:
 		{
 			AST tmp39_AST = null;
 			tmp39_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp39_AST);
 			match(LITERAL_byte);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_char:
 		{
 			AST tmp40_AST = null;
 			tmp40_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp40_AST);
 			match(LITERAL_char);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_short:
 		{
 			AST tmp41_AST = null;
 			tmp41_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp41_AST);
 			match(LITERAL_short);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_int:
 		{
 			AST tmp42_AST = null;
 			tmp42_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp42_AST);
 			match(LITERAL_int);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_float:
 		{
 			AST tmp43_AST = null;
 			tmp43_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp43_AST);
 			match(LITERAL_float);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_long:
 		{
 			AST tmp44_AST = null;
 			tmp44_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp44_AST);
 			match(LITERAL_long);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_double:
 		{
 			AST tmp45_AST = null;
 			tmp45_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp45_AST);
 			match(LITERAL_double);
 			builtInType_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = builtInType_AST;
 	}
 	
 	public final void type() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST type_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		{
 			classOrInterfaceType(false);
 			astFactory.addASTChild(currentAST, returnAST);
 			type_AST = (AST)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();
 			astFactory.addASTChild(currentAST, returnAST);
 			type_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = type_AST;
 	}
 	
 	public final void modifier() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST modifier_AST = null;
 		
 		switch ( LA(1)) {
 		case LITERAL_private:
 		{
 			AST tmp46_AST = null;
 			tmp46_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp46_AST);
 			match(LITERAL_private);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_public:
 		{
 			AST tmp47_AST = null;
 			tmp47_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp47_AST);
 			match(LITERAL_public);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_protected:
 		{
 			AST tmp48_AST = null;
 			tmp48_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp48_AST);
 			match(LITERAL_protected);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_static:
 		{
 			AST tmp49_AST = null;
 			tmp49_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp49_AST);
 			match(LITERAL_static);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_transient:
 		{
 			AST tmp50_AST = null;
 			tmp50_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp50_AST);
 			match(LITERAL_transient);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case FINAL:
 		{
 			AST tmp51_AST = null;
 			tmp51_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp51_AST);
 			match(FINAL);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case ABSTRACT:
 		{
 			AST tmp52_AST = null;
 			tmp52_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp52_AST);
 			match(ABSTRACT);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_native:
 		{
 			AST tmp53_AST = null;
 			tmp53_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp53_AST);
 			match(LITERAL_native);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_threadsafe:
 		{
 			AST tmp54_AST = null;
 			tmp54_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp54_AST);
 			match(LITERAL_threadsafe);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_synchronized:
 		{
 			AST tmp55_AST = null;
 			tmp55_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp55_AST);
 			match(LITERAL_synchronized);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_volatile:
 		{
 			AST tmp56_AST = null;
 			tmp56_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp56_AST);
 			match(LITERAL_volatile);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		case STRICTFP:
 		{
 			AST tmp57_AST = null;
 			tmp57_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp57_AST);
 			match(STRICTFP);
 			modifier_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = modifier_AST;
 	}
 	
 	public final void annotation() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotation_AST = null;
 		AST i_AST = null;
 		AST args_AST = null;
 		Token first = LT(1);
 		
 		match(AT);
 		identifier();
 		i_AST = (AST)returnAST;
 		{
 		switch ( LA(1)) {
 		case LPAREN:
 		{
 			match(LPAREN);
 			{
 			switch ( LA(1)) {
 			case IDENT:
 			case LITERAL_super:
 			case LT:
 			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 AT:
 			case LPAREN:
 			case LCURLY:
 			case LITERAL_this:
 			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 STRING_LITERAL:
 			case NUM_FLOAT:
 			case NUM_LONG:
 			case NUM_DOUBLE:
 			{
 				annotationArguments();
 				args_AST = (AST)returnAST;
 				break;
 			}
 			case RPAREN:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			match(RPAREN);
 			break;
 		}
 		case FINAL:
 		case ABSTRACT:
 		case STRICTFP:
 		caseg> LITERAL_package:
 		case SEMI:
 		case LITERAL_static:
 		case IDENT:
 		case LT:
 		case COMMA:
 		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 LITERAL_private:
 		case LITERAL_public:
 		case LITERAL_protected:
 		case LITERAL_transient:
 		case LITERAL_native:
 		case LITERAL_threadsafe:
 		case LITERAL_synchronized:
 		case LITERAL_volatile:
 		case AT:
 		case RPAREN:
 		case RCURLY:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			annotation_AST = (AST)currentAST.root;
 			annotation_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION,"ANNOTATION",first,LT(1))).add(i_AST).add(args_AST));
 			currentAST.root = annotation_AST;
 			currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
 				annotation_AST.getFirstChild() : annotation_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = annotation_AST;
 	}
 	
 	public final void annotationArguments() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationArguments_AST = null;
 		
 		if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
 			annotationMemberValueInitializer();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationArguments_AST = (AST)currentAST.root;
 		}
 		else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) {
 			anntotationMemberValuePairs();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationArguments_AST = (AST)currentAST.root;
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		returnAST = annotationArguments_AST;
 	}
 	
 	public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationMemberValueInitializer_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			conditionalExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
 			break;
 		}
 		case AT:
 		{
 			annotation();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
 			break;
 		}
 		case LCURLY:
 		{
 			annotationMemberArrayInitializer();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = annotationMemberValueInitializer_AST;
 	}
 	
 	public final void anntotationMemberValuePairs() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST anntotationMemberValuePairs_AST = null;
 		
 		annotationMemberValuePair();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop66:
 		do {
 			if ((LA(1)==COMMA)) {
 				match(COMMA);
 				annotationMemberValuePair();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop66;
 			}
 			
 		} while (true);
 		}
 		anntotationMemberValuePairs_AST = (AST)currentAST.root;
 		returnAST = anntotationMemberValuePairs_AST;
 	}
 	
 	public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationMemberValuePair_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		AST v_AST = null;
 		Token first = LT(1);
 		
 		i = LT(1);
 		i_AST = astFactory.create(i);
 		match(IDENT);
 		match(ASSIGN);
 		annotationMemberValueInitializer();
 		v_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			annotationMemberValuePair_AST = (AST)currentAST.root;
 			annotationMemberValuePair_AST = (AST)astFactory.make( (new ASTArray(3)).add(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1))).add(i_AST).add(v_AST));
 			currentAST.root = annotationMemberValuePair_AST;
 			currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
 				annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = annotationMemberValuePair_AST;
 	}
 	
 	public final void conditionalExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST conditionalExpression_AST = null;
 		
 		logicalOrExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		switch ( LA(1)) {
 		case QUESTION:
 		{
 			AST tmp63_AST = null;
 			tmp63_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp63_AST);
 			match(QUESTION);
 			assignmentExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(COLON);
 			conditionalExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case SEMI:
 		case RBRACK:
 		case COMMA:
 		case RPAREN:
 		case ASSIGN:
 		case RCURLY:
 		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 new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		conditionalExpression_AST = (AST)currentAST.root;
 		returnAST = conditionalExpression_AST;
 	}
 	
 	public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationMemberArrayInitializer_AST = null;
 		Token  lc = null;
 		AST lc_AST = null;
 		
 		lc = LT(1);
 		lc_AST = astFactory.create(lc);
 		astFactory.makeASTRoot(currentAST, lc_AST);
 		match(LCURLY);
 		if ( inputState.guessing==0 ) {
 			lc_AST.setType(ANNOTATION_ARRAY_INIT);
 		}
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 AT:
 		case LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			annotationMemberArrayValueInitializer();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop72:
 			do {
 				if ((LA(1)==COMMA) && (_tokenSet_12.member(LA(2)))) {
 					match(COMMA);
 					annotationMemberArrayValueInitializer();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop72;
 				}
 				
 			} while (true);
 			}
 			{
 			switch ( LA(1)) {
 			case COMMA:
 			{
 				match(COMMA);
 				break;
 			}
 			case RCURLY:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			break;
 		}
 		case RCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		match(RCURLY);
 		annotationMemberArrayInitializer_AST = (AST)currentAST.root;
 		returnAST = annotationMemberArrayInitializer_AST;
 	}
 	
 	public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationMemberArrayValueInitializer_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			conditionalExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
 			break;
 		}
 		case AT:
 		{
 			annotation();
 			astFactory.addASTChild(currentAST, returnAST);
 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = annotationMemberArrayValueInitializer_AST;
 	}
 	
 	public final void superClassClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST superClassClause_AST = null;
 		AST c_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case LITERAL_extends:
 		{
 			match(LITERAL_extends);
 			classOrInterfaceType(false);
 			c_AST = (AST)returnAST;
 			break;
 		}
 		case LCURLY:
 		case LITERAL_implements:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			superClassClause_AST = (AST)currentAST.root;
 			superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(c_AST));
 			currentAST.root = superClassClause_AST;
 			currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ?
 				superClassClause_AST.getFirstChild() : superClassClause_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = superClassClause_AST;
 	}
 	
 	public final void typeParameters() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeParameters_AST = null;
 		int currentLtLevel = 0; Token first = LT(1);
 		
 		if ( inputState.guessing==0 ) {
 			currentLtLevel = ltCounter;
 		}
 		match(LT);
 		if ( inputState.guessing==0 ) {
 			ltCounter++;
 		}
 		typeParameter();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop85:
 		do {
 			if ((LA(1)==COMMA)) {
 				match(COMMA);
 				typeParameter();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop85;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case GT:
 		case SR:
 		case BSR:
 		{
 			typeArgumentsOrParametersEnd();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case IDENT:
 		case LITERAL_extends:
 		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 LCURLY:
 		case LITERAL_implements:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
 		  throw new SemanticException("(currentLtLevel != 0) || ltCounter == currentLtLevel");
 		if ( inputState.guessing==0 ) {
 			typeParameters_AST = (AST)currentAST.root;
 			typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETERS,"TYPE_PARAMETERS",first,LT(1))).add(typeParameters_AST));
 			currentAST.root = typeParameters_AST;
 			currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
 				typeParameters_AST.getFirstChild() : typeParameters_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeParameters_AST = (AST)currentAST.root;
 		returnAST = typeParameters_AST;
 	}
 	
 	public final void implementsClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST implementsClause_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case LITERAL_implements:
 		{
 			i = LT(1);
 			i_AST = astFactory.create(i);
 			match(LITERAL_implements);
 			classOrInterfaceType(false);
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop133:
 			do {
 				if ((LA(1)==COMMA)) {
 					match(COMMA);
 					classOrInterfaceType(false);
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop133;
 				}
 				
 			} while (true);
 			}
 			break;
 		}
 		case LCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			implementsClause_AST = (AST)currentAST.root;
 			implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE",first,LT(1))).add(implementsClause_AST));
 			currentAST.root = implementsClause_AST;
 			currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ?
 				implementsClause_AST.getFirstChild() : implementsClause_AST;
 			currentAST.advanceChildToEnd();
 		}
 		implementsClause_AST = (AST)currentAST.root;
 		returnAST = implementsClause_AST;
 	}
 	
 	public final void classBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classBlock_AST = null;
 		
 		match(LCURLY);
 		{
 		_loop95:
 		do {
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_static:
 			case IDENT:
 			case LT:
 			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 LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case AT:
 			case LCURLY:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				classField();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				match(SEMI);
 				break;
 			}
 			default:
 			{
 				break _loop95;
 			}
 			}
 		} while (true);
 		}
 		match(RCURLY);
 		if ( inputState.guessing==0 ) {
 			classBlock_AST = (AST)currentAST.root;
 			classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST));
 			currentAST.root = classBlock_AST;
 			currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
 				classBlock_AST.getFirstChild() : classBlock_AST;
 			currentAST.advanceChildToEnd();
 		}
 		classBlock_AST = (AST)currentAST.root;
 		returnAST = classBlock_AST;
 	}
 	
 	public final void interfaceExtends() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST interfaceExtends_AST = null;
 		Token  e = null;
 		AST e_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case LITERAL_extends:
 		{
 			e = LT(1);
 			e_AST = astFactory.create(e);
 			match(LITERAL_extends);
 			classOrInterfaceType(false);
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop129:
 			do {
 				if ((LA(1)==COMMA)) {
 					match(COMMA);
 					classOrInterfaceType(false);
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop129;
 				}
 				
 			} while (true);
 			}
 			break;
 		}
 		case LCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			interfaceExtends_AST = (AST)currentAST.root;
 			interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE",first,LT(1))).add(interfaceExtends_AST));
 			currentAST.root = interfaceExtends_AST;
 			currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ?
 				interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
 			currentAST.advanceChildToEnd();
 		}
 		interfaceExtends_AST = (AST)currentAST.root;
 		returnAST = interfaceExtends_AST;
 	}
 	
 	public final void interfaceBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST interfaceBlock_AST = null;
 		
 		match(LCURLY);
 		{
 		_loop98:
 		do {
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_static:
 			case IDENT:
 			case LT:
 			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 LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case AT:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				interfaceField();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				match(SEMI);
 				break;
 			}
 			default:
 			{
 				break _loop98;
 			}
 			}
 		} while (true);
 		}
 		match(RCURLY);
 		if ( inputState.guessing==0 ) {
 			interfaceBlock_AST = (AST)currentAST.root;
 			interfaceBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(interfaceBlock_AST));
 			currentAST.root = interfaceBlock_AST;
 			currentAST.child = interfaceBlock_AST!=null &&interfaceBlock_AST.getFirstChild()!=null ?
 				interfaceBlock_AST.getFirstChild() : interfaceBlock_AST;
 			currentAST.advanceChildToEnd();
 		}
 		interfaceBlock_AST = (AST)currentAST.root;
 		returnAST = interfaceBlock_AST;
 	}
 	
 	public final void enumBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumBlock_AST = null;
 		
 		match(LCURLY);
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		case AT:
 		{
 			enumConstant();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop105:
 			do {
 				if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) {
 					match(COMMA);
 					enumConstant();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop105;
 				}
 				
 			} while (true);
 			}
 			{
 			switch ( LA(1)) {
 			case COMMA:
 			{
 				match(COMMA);
 				break;
 			}
 			case SEMI:
 			case RCURLY:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			break;
 		}
 		case SEMI:
 		case RCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		switch ( LA(1)) {
 		case SEMI:
 		{
 			match(SEMI);
 			{
 			_loop109:
 			do {
 				switch ( LA(1)) {
 				case FINAL:
 				case ABSTRACT:
 				case STRICTFP:
 				case LITERAL_static:
 				case IDENT:
 				case LT:
 				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 LITERAL_private:
 				case LITERAL_public:
 				case LITERAL_protected:
 				case LITERAL_transient:
 				case LITERAL_native:
 				case LITERAL_threadsafe:
 				case LITERAL_synchronized:
 				case LITERAL_volatile:
 				case AT:
 				case LCURLY:
 				case LITERAL_class:
 				case LITERAL_interface:
 				case LITERAL_enum:
 				{
 					classField();
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case SEMI:
 				{
 					match(SEMI);
 					break;
 				}
 				default:
 				{
 					break _loop109;
 				}
 				}
 			} while (true);
 			}
 			break;
 		}
 		case RCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		match(RCURLY);
 		if ( inputState.guessing==0 ) {
 			enumBlock_AST = (AST)currentAST.root;
 			enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST));
 			currentAST.root = enumBlock_AST;
 			currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
 				enumBlock_AST.getFirstChild() : enumBlock_AST;
 			currentAST.advanceChildToEnd();
 		}
 		enumBlock_AST = (AST)currentAST.root;
 		returnAST = enumBlock_AST;
 	}
 	
 	public final void annotationBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationBlock_AST = null;
 		
 		match(LCURLY);
 		{
 		_loop101:
 		do {
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_static:
 			case IDENT:
 			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 LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case AT:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				annotationField();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				match(SEMI);
 				break;
 			}
 			default:
 			{
 				break _loop101;
 			}
 			}
 		} while (true);
 		}
 		match(RCURLY);
 		if ( inputState.guessing==0 ) {
 			annotationBlock_AST = (AST)currentAST.root;
 			annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST));
 			currentAST.root = annotationBlock_AST;
 			currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
 				annotationBlock_AST.getFirstChild() : annotationBlock_AST;
 			currentAST.advanceChildToEnd();
 		}
 		annotationBlock_AST = (AST)currentAST.root;
 		returnAST = annotationBlock_AST;
 	}
 	
 	public final void typeParameter() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeParameter_AST = null;
 		Token  id = null;
 		AST id_AST = null;
 		Token first = LT(1);
 		
 		{
 		id = LT(1);
 		id_AST = astFactory.create(id);
 		astFactory.addASTChild(currentAST, id_AST);
 		match(IDENT);
 		}
 		{
 		if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT)) {
 			typeParameterBounds();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		if ( inputState.guessing==0 ) {
 			typeParameter_AST = (AST)currentAST.root;
 			typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_PARAMETER,"TYPE_PARAMETER",first,LT(1))).add(typeParameter_AST));
 			currentAST.root = typeParameter_AST;
 			currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
 				typeParameter_AST.getFirstChild() : typeParameter_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeParameter_AST = (AST)currentAST.root;
 		returnAST = typeParameter_AST;
 	}
 	
 	public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST typeParameterBounds_AST = null;
 		Token first = LT(1);
 		
 		match(LITERAL_extends);
 		classOrInterfaceType(false);
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop92:
 		do {
 			if ((LA(1)==BAND)) {
 				match(BAND);
 				classOrInterfaceType(false);
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop92;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			typeParameterBounds_AST = (AST)currentAST.root;
 			typeParameterBounds_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS",first,LT(1))).add(typeParameterBounds_AST));
 			currentAST.root = typeParameterBounds_AST;
 			currentAST.child = typeParameterBounds_AST!=null &&typeParameterBounds_AST.getFirstChild()!=null ?
 				typeParameterBounds_AST.getFirstChild() : typeParameterBounds_AST;
 			currentAST.advanceChildToEnd();
 		}
 		typeParameterBounds_AST = (AST)currentAST.root;
 		returnAST = typeParameterBounds_AST;
 	}
 	
 	public final void classField() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST classField_AST = null;
 		AST mods_AST = null;
 		AST td_AST = null;
 		AST tp_AST = null;
 		AST h_AST = null;
 		AST s_AST = null;
 		AST t_AST = null;
 		AST param_AST = null;
 		AST rt_AST = null;
 		AST tc_AST = null;
 		AST s2_AST = null;
 		AST v_AST = null;
 		AST s3_AST = null;
 		AST s4_AST = null;
 		Token first = LT(1);
 		
 		if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
 			modifiers();
 			mods_AST = (AST)returnAST;
 			{
 			switch ( LA(1)) {
 			case AT:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				typeDefinitionInternal(mods_AST);
 				td_AST = (AST)returnAST;
 				if ( inputState.guessing==0 ) {
 					classField_AST = (AST)currentAST.root;
 					classField_AST = td_AST;
 					currentAST.root = classField_AST;
 					currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 						classField_AST.getFirstChild() : classField_AST;
 					currentAST.advanceChildToEnd();
 				}
 				break;
 			}
 			case IDENT:
 			case LT:
 			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:
 			{
 				{
 				switch ( LA(1)) {
 				case LT:
 				{
 					typeParameters();
 					tp_AST = (AST)returnAST;
 					break;
 				}
 				case IDENT:
 				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:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				{
 				if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 					ctorHead();
 					h_AST = (AST)returnAST;
 					constructorBody();
 					s_AST = (AST)returnAST;
 					if ( inputState.guessing==0 ) {
 						classField_AST = (AST)currentAST.root;
 						classField_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST));
 						currentAST.root = classField_AST;
 						currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 							classField_AST.getFirstChild() : classField_AST;
 						currentAST.advanceChildToEnd();
 					}
 				}
 				else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
 					typeSpec(false);
 					t_AST = (AST)returnAST;
 					{
 					if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 						AST tmp90_AST = null;
 						tmp90_AST = astFactory.create(LT(1));
 						match(IDENT);
 						match(LPAREN);
 						parameterDeclarationList();
 						param_AST = (AST)returnAST;
 						match(RPAREN);
 						declaratorBrackets(t_AST);
 						rt_AST = (AST)returnAST;
 						{
 						switch ( LA(1)) {
 						case LITERAL_throws:
 						{
 							throwsClause();
 							tc_AST = (AST)returnAST;
 							break;
 						}
 						case SEMI:
 						case LCURLY:
 						{
 							break;
 						}
 						default:
 						{
 							throw new NoViableAltException(LT(1), getFilename());
 						}
 						}
 						}
 						{
 						switch ( LA(1)) {
 						case LCURLY:
 						{
 							compoundStatement();
 							s2_AST = (AST)returnAST;
 							break;
 						}
 						case SEMI:
 						{
 							AST tmp93_AST = null;
 							tmp93_AST = astFactory.create(LT(1));
 							match(SEMI);
 							break;
 						}
 						default:
 						{
 							throw new NoViableAltException(LT(1), getFilename());
 						}
 						}
 						}
 						if ( inputState.guessing==0 ) {
 							classField_AST = (AST)currentAST.root;
 							classField_AST = (AST)astFactory.make( (new ASTArray(8)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(rt_AST))).add(tmp90_AST).add(param_AST).add(tc_AST).add(s2_AST));
 							currentAST.root = classField_AST;
 							currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 								classField_AST.getFirstChild() : classField_AST;
 							currentAST.advanceChildToEnd();
 						}
 					}
 					else if ((LA(1)==IDENT) && (_tokenSet_19.member(LA(2)))) {
 						variableDefinitions(mods_AST,t_AST);
 						v_AST = (AST)returnAST;
 						AST tmp94_AST = null;
 						tmp94_AST = astFactory.create(LT(1));
 						match(SEMI);
 						if ( inputState.guessing==0 ) {
 							classField_AST = (AST)currentAST.root;
 							classField_AST = v_AST;
 							currentAST.root = classField_AST;
 							currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 								classField_AST.getFirstChild() : classField_AST;
 							currentAST.advanceChildToEnd();
 						}
 					}
 					else {
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					
 					}
 				}
 				else {
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				
 				}
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 		}
 		else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
 			match(LITERAL_static);
 			compoundStatement();
 			s3_AST = (AST)returnAST;
 			if ( inputState.guessing==0 ) {
 				classField_AST = (AST)currentAST.root;
 				classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(STATIC_INIT,"STATIC_INIT",first,LT(1))).add(s3_AST));
 				currentAST.root = classField_AST;
 				currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 					classField_AST.getFirstChild() : classField_AST;
 				currentAST.advanceChildToEnd();
 			}
 		}
 		else if ((LA(1)==LCURLY)) {
 			compoundStatement();
 			s4_AST = (AST)returnAST;
 			if ( inputState.guessing==0 ) {
 				classField_AST = (AST)currentAST.root;
 				classField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
 				currentAST.root = classField_AST;
 				currentAST.child = classField_AST!=null &&classField_AST.getFirstChild()!=null ?
 					classField_AST.getFirstChild() : classField_AST;
 				currentAST.advanceChildToEnd();
 			}
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		returnAST = classField_AST;
 	}
 	
 	public final void interfaceField() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST interfaceField_AST = null;
 		AST mods_AST = null;
 		AST td_AST = null;
 		AST tp_AST = null;
 		AST t_AST = null;
 		AST param_AST = null;
 		AST rt_AST = null;
 		AST tc_AST = null;
 		AST v_AST = null;
 		Token first = LT(1);
 		
 		modifiers();
 		mods_AST = (AST)returnAST;
 		{
 		switch ( LA(1)) {
 		case AT:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		{
 			typeDefinitionInternal(mods_AST);
 			td_AST = (AST)returnAST;
 			if ( inputState.guessing==0 ) {
 				interfaceField_AST = (AST)currentAST.root;
 				interfaceField_AST = td_AST;
 				currentAST.root = interfaceField_AST;
 				currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
 					interfaceField_AST.getFirstChild() : interfaceField_AST;
 				currentAST.advanceChildToEnd();
 			}
 			break;
 		}
 		case IDENT:
 		case LT:
 		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:
 		{
 			{
 			switch ( LA(1)) {
 			case LT:
 			{
 				typeParameters();
 				tp_AST = (AST)returnAST;
 				break;
 			}
 			case IDENT:
 			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:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			typeSpec(false);
 			t_AST = (AST)returnAST;
 			{
 			if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 				AST tmp96_AST = null;
 				tmp96_AST = astFactory.create(LT(1));
 				match(IDENT);
 				match(LPAREN);
 				parameterDeclarationList();
 				param_AST = (AST)returnAST;
 				match(RPAREN);
 				declaratorBrackets(t_AST);
 				rt_AST = (AST)returnAST;
 				{
 				switch ( LA(1)) {
 				case LITERAL_throws:
 				{
 					throwsClause();
 					tc_AST = (AST)returnAST;
 					break;
 				}
 				case SEMI:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				AST tmp99_AST = null;
 				tmp99_AST = astFactory.create(LT(1));
 				match(SEMI);
 				if ( inputState.guessing==0 ) {
 					interfaceField_AST = (AST)currentAST.root;
 					interfaceField_AST = (AST)astFactory.make( (new ASTArray(7)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(rt_AST))).add(tmp96_AST).add(param_AST).add(tc_AST));
 					currentAST.root = interfaceField_AST;
 					currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
 						interfaceField_AST.getFirstChild() : interfaceField_AST;
 					currentAST.advanceChildToEnd();
 				}
 			}
 			else if ((LA(1)==IDENT) && (_tokenSet_19.member(LA(2)))) {
 				variableDefinitions(mods_AST,t_AST);
 				v_AST = (AST)returnAST;
 				AST tmp100_AST = null;
 				tmp100_AST = astFactory.create(LT(1));
 				match(SEMI);
 				if ( inputState.guessing==0 ) {
 					interfaceField_AST = (AST)currentAST.root;
 					interfaceField_AST = v_AST;
 					currentAST.root = interfaceField_AST;
 					currentAST.child = interfaceField_AST!=null &&interfaceField_AST.getFirstChild()!=null ?
 						interfaceField_AST.getFirstChild() : interfaceField_AST;
 					currentAST.advanceChildToEnd();
 				}
 			}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		returnAST = interfaceField_AST;
 	}
 	
 	public final void annotationField() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST annotationField_AST = null;
 		AST mods_AST = null;
 		AST td_AST = null;
 		AST t_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		AST rt_AST = null;
 		AST amvi_AST = null;
 		AST v_AST = null;
 		Token first = LT(1);
 		
 		modifiers();
 		mods_AST = (AST)returnAST;
 		{
 		switch ( LA(1)) {
 		case AT:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		{
 			typeDefinitionInternal(mods_AST);
 			td_AST = (AST)returnAST;
 			if ( inputState.guessing==0 ) {
 				annotationField_AST = (AST)currentAST.root;
 				annotationField_AST = td_AST;
 				currentAST.root = annotationField_AST;
 				currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 					annotationField_AST.getFirstChild() : annotationField_AST;
 				currentAST.advanceChildToEnd();
 			}
 			break;
 		}
 		case IDENT:
 		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:
 		{
 			typeSpec(false);
 			t_AST = (AST)returnAST;
 			{
 			if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 				i = LT(1);
 				i_AST = astFactory.create(i);
 				match(IDENT);
 				match(LPAREN);
 				match(RPAREN);
 				declaratorBrackets(t_AST);
 				rt_AST = (AST)returnAST;
 				{
 				switch ( LA(1)) {
 				case LITERAL_default:
 				{
 					match(LITERAL_default);
 					annotationMemberValueInitializer();
 					amvi_AST = (AST)returnAST;
 					break;
 				}
 				case SEMI:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				AST tmp104_AST = null;
 				tmp104_AST = astFactory.create(LT(1));
 				match(SEMI);
 				if ( inputState.guessing==0 ) {
 					annotationField_AST = (AST)currentAST.root;
 					annotationField_AST =
 										(AST)astFactory.make( (new ASTArray(5)).add(create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF",first,LT(1))).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(rt_AST))).add(i_AST).add(amvi_AST));
 					currentAST.root = annotationField_AST;
 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 						annotationField_AST.getFirstChild() : annotationField_AST;
 					currentAST.advanceChildToEnd();
 				}
 			}
 			else if ((LA(1)==IDENT) && (_tokenSet_19.member(LA(2)))) {
 				variableDefinitions(mods_AST,t_AST);
 				v_AST = (AST)returnAST;
 				AST tmp105_AST = null;
 				tmp105_AST = astFactory.create(LT(1));
 				match(SEMI);
 				if ( inputState.guessing==0 ) {
 					annotationField_AST = (AST)currentAST.root;
 					annotationField_AST = v_AST;
 					currentAST.root = annotationField_AST;
 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
 						annotationField_AST.getFirstChild() : annotationField_AST;
 					currentAST.advanceChildToEnd();
 				}
 			}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		returnAST = annotationField_AST;
 	}
 	
 	public final void enumConstant() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumConstant_AST = null;
 		AST an_AST = null;
 		Token  i = null;
 		AST i_AST = null;
 		AST a_AST = null;
 		AST b_AST = null;
 		
 		annotations();
 		an_AST = (AST)returnAST;
 		i = LT(1);
 		i_AST = astFactory.create(i);
 		match(IDENT);
 		{
 		switch ( LA(1)) {
 		case LPAREN:
 		{
 			match(LPAREN);
 			argList();
 			a_AST = (AST)returnAST;
 			match(RPAREN);
 			break;
 		}
 		case SEMI:
 		case COMMA:
 		case LCURLY:
 		case RCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		switch ( LA(1)) {
 		case LCURLY:
 		{
 			enumConstantBlock();
 			b_AST = (AST)returnAST;
 			break;
 		}
 		case SEMI:
 		case COMMA:
 		case RCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			enumConstant_AST = (AST)currentAST.root;
 			enumConstant_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(a_AST).add(b_AST));
 			currentAST.root = enumConstant_AST;
 			currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
 				enumConstant_AST.getFirstChild() : enumConstant_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = enumConstant_AST;
 	}
 	
 	public final void declaratorBrackets(
 		AST typ
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST declaratorBrackets_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		
 		if ( inputState.guessing==0 ) {
 			declaratorBrackets_AST = (AST)currentAST.root;
 			declaratorBrackets_AST=typ;
 			currentAST.root = declaratorBrackets_AST;
 			currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
 				declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
 			currentAST.advanceChildToEnd();
 		}
 		{
 		_loop159:
 		do {
 			if ((LA(1)==LBRACK)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(ARRAY_DECLARATOR);
 				}
 				match(RBRACK);
 			}
 			else {
 				break _loop159;
 			}
 			
 		} while (true);
 		}
 		declaratorBrackets_AST = (AST)currentAST.root;
 		returnAST = declaratorBrackets_AST;
 	}
 	
 	public final void argList() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST argList_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			expressionList();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case RPAREN:
 		{
 			if ( inputState.guessing==0 ) {
 				argList_AST = (AST)currentAST.root;
 				argList_AST = create(ELIST,"ELIST",first,LT(1));
 				currentAST.root = argList_AST;
 				currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
 					argList_AST.getFirstChild() : argList_AST;
 				currentAST.advanceChildToEnd();
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		argList_AST = (AST)currentAST.root;
 		returnAST = argList_AST;
 	}
 	
 	public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumConstantBlock_AST = null;
 		
 		match(LCURLY);
 		{
 		_loop119:
 		do {
 			switch ( LA(1)) {
 			case FINAL:
 			case ABSTRACT:
 			case STRICTFP:
 			case LITERAL_static:
 			case IDENT:
 			case LT:
 			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 LITERAL_private:
 			case LITERAL_public:
 			case LITERAL_protected:
 			case LITERAL_transient:
 			case LITERAL_native:
 			case LITERAL_threadsafe:
 			case LITERAL_synchronized:
 			case LITERAL_volatile:
 			case AT:
 			case LCURLY:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				enumConstantField();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				match(SEMI);
 				break;
 			}
 			default:
 			{
 				break _loop119;
 			}
 			}
 		} while (true);
 		}
 		match(RCURLY);
 		if ( inputState.guessing==0 ) {
 			enumConstantBlock_AST = (AST)currentAST.root;
 			enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST));
 			currentAST.root = enumConstantBlock_AST;
 			currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
 				enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
 			currentAST.advanceChildToEnd();
 		}
 		enumConstantBlock_AST = (AST)currentAST.root;
 		returnAST = enumConstantBlock_AST;
 	}
 	
 	public final void enumConstantField() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST enumConstantField_AST = null;
 		AST mods_AST = null;
 		AST td_AST = null;
 		AST tp_AST = null;
 		AST t_AST = null;
 		AST param_AST = null;
 		AST rt_AST = null;
 		AST tc_AST = null;
 		AST s2_AST = null;
 		AST v_AST = null;
 		AST s4_AST = null;
 		Token first = LT(1);
 		
 		switch ( LA(1)) {
 		case FINAL:
 		case ABSTRACT:
 		case STRICTFP:
 		case LITERAL_static:
 		case IDENT:
 		case LT:
 		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 LITERAL_private:
 		case LITERAL_public:
 		case LITERAL_protected:
 		case LITERAL_transient:
 		case LITERAL_native:
 		case LITERAL_threadsafe:
 		case LITERAL_synchronized:
 		case LITERAL_volatile:
 		case AT:
 		case LITERAL_class:
 		case LITERAL_interface:
 		case LITERAL_enum:
 		{
 			modifiers();
 			mods_AST = (AST)returnAST;
 			{
 			switch ( LA(1)) {
 			case AT:
 			case LITERAL_class:
 			case LITERAL_interface:
 			case LITERAL_enum:
 			{
 				typeDefinitionInternal(mods_AST);
 				td_AST = (AST)returnAST;
 				if ( inputState.guessing==0 ) {
 					enumConstantField_AST = (AST)currentAST.root;
 					enumConstantField_AST = td_AST;
 					currentAST.root = enumConstantField_AST;
 					currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 						enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 					currentAST.advanceChildToEnd();
 				}
 				break;
 			}
 			case IDENT:
 			case LT:
 			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:
 			{
 				{
 				switch ( LA(1)) {
 				case LT:
 				{
 					typeParameters();
 					tp_AST = (AST)returnAST;
 					break;
 				}
 				case IDENT:
 				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:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				typeSpec(false);
 				t_AST = (AST)returnAST;
 				{
 				if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
 					AST tmp112_AST = null;
 					tmp112_AST = astFactory.create(LT(1));
 					match(IDENT);
 					match(LPAREN);
 					parameterDeclarationList();
 					param_AST = (AST)returnAST;
 					match(RPAREN);
 					declaratorBrackets(t_AST);
 					rt_AST = (AST)returnAST;
 					{
 					switch ( LA(1)) {
 					case LITERAL_throws:
 					{
 						throwsClause();
 						tc_AST = (AST)returnAST;
 						break;
 					}
 					case SEMI:
 					case LCURLY:
 					{
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					{
 					switch ( LA(1)) {
 					case LCURLY:
 					{
 						compoundStatement();
 						s2_AST = (AST)returnAST;
 						break;
 					}
 					case SEMI:
 					{
 						AST tmp115_AST = null;
 						tmp115_AST = astFactory.create(LT(1));
 						match(SEMI);
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					if ( inputState.guessing==0 ) {
 						enumConstantField_AST = (AST)currentAST.root;
 						enumConstantField_AST = (AST)astFactory.make( (new ASTArray(8)).add(create(METHOD_DEF,"METHOD_DEF",first,LT(1))).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(rt_AST))).add(tmp112_AST).add(param_AST).add(tc_AST).add(s2_AST));
 						currentAST.root = enumConstantField_AST;
 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 						currentAST.advanceChildToEnd();
 					}
 				}
 				else if ((LA(1)==IDENT) && (_tokenSet_19.member(LA(2)))) {
 					variableDefinitions(mods_AST,t_AST);
 					v_AST = (AST)returnAST;
 					AST tmp116_AST = null;
 					tmp116_AST = astFactory.create(LT(1));
 					match(SEMI);
 					if ( inputState.guessing==0 ) {
 						enumConstantField_AST = (AST)currentAST.root;
 						enumConstantField_AST = v_AST;
 						currentAST.root = enumConstantField_AST;
 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 						currentAST.advanceChildToEnd();
 					}
 				}
 				else {
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				
 				}
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			break;
 		}
 		case LCURLY:
 		{
 			compoundStatement();
 			s4_AST = (AST)returnAST;
 			if ( inputState.guessing==0 ) {
 				enumConstantField_AST = (AST)currentAST.root;
 				enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(INSTANCE_INIT,"INSTANCE_INIT",first,LT(1))).add(s4_AST));
 				currentAST.root = enumConstantField_AST;
 				currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
 					enumConstantField_AST.getFirstChild() : enumConstantField_AST;
 				currentAST.advanceChildToEnd();
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = enumConstantField_AST;
 	}
 	
 	public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST parameterDeclarationList_AST = null;
 		Token first = LT(1);
 		
 		{
 		boolean synPredMatched171 = false;
 		if (((_tokenSet_20.member(LA(1))) && (_tokenSet_21.member(LA(2))))) {
 			int _m171 = mark();
 			synPredMatched171 = true;
 			inputState.guessing++;
 			try {
 				{
 				parameterDeclaration();
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched171 = false;
 			}
 			rewind(_m171);
 			inputState.guessing--;
 		}
 		if ( synPredMatched171 ) {
 			parameterDeclaration();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop175:
 			do {
 				boolean synPredMatched174 = false;
 				if (((LA(1)==COMMA) && (_tokenSet_20.member(LA(2))))) {
 					int _m174 = mark();
 					synPredMatched174 = true;
 					inputState.guessing++;
 					try {
 						{
 						match(COMMA);
 						parameterDeclaration();
 						}
 					}
 					catch (RecognitionException pe) {
 						synPredMatched174 = false;
 					}
 					rewind(_m174);
 					inputState.guessing--;
 				}
 				if ( synPredMatched174 ) {
 					match(COMMA);
 					parameterDeclaration();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop175;
 				}
 				
 			} while (true);
 			}
 			{
 			switch ( LA(1)) {
 			case COMMA:
 			{
 				match(COMMA);
 				variableLengthParameterDeclaration();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case RPAREN:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 		}
 		else if ((_tokenSet_20.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
 			variableLengthParameterDeclaration();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((LA(1)==RPAREN)) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		if ( inputState.guessing==0 ) {
 			parameterDeclarationList_AST = (AST)currentAST.root;
 			parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(PARAMETERS,"PARAMETERS",first,LT(1))).add(parameterDeclarationList_AST));
 			currentAST.root = parameterDeclarationList_AST;
 			currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
 				parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
 			currentAST.advanceChildToEnd();
 		}
 		parameterDeclarationList_AST = (AST)currentAST.root;
 		returnAST = parameterDeclarationList_AST;
 	}
 	
 	public final void throwsClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST throwsClause_AST = null;
 		
 		AST tmp119_AST = null;
 		tmp119_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp119_AST);
 		match(LITERAL_throws);
 		identifier();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop167:
 		do {
 			if ((LA(1)==COMMA)) {
 				match(COMMA);
 				identifier();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop167;
 			}
 			
 		} while (true);
 		}
 		throwsClause_AST = (AST)currentAST.root;
 		returnAST = throwsClause_AST;
 	}
 	
 	public final void compoundStatement() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST compoundStatement_AST = null;
 		Token  lc = null;
 		AST lc_AST = null;
 		
 		lc = LT(1);
 		lc_AST = astFactory.create(lc);
 		astFactory.makeASTRoot(currentAST, lc_AST);
 		match(LCURLY);
 		if ( inputState.guessing==0 ) {
 			lc_AST.setType(SLIST);
 		}
 		{
 		_loop187:
 		do {
 			if ((_tokenSet_23.member(LA(1)))) {
 				statement();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop187;
 			}
 			
 		} while (true);
 		}
 		match(RCURLY);
 		compoundStatement_AST = (AST)currentAST.root;
 		returnAST = compoundStatement_AST;
 	}
 	
 	public final void ctorHead() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST ctorHead_AST = null;
 		
 		AST tmp122_AST = null;
 		tmp122_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp122_AST);
 		match(IDENT);
 		match(LPAREN);
 		parameterDeclarationList();
 		astFactory.addASTChild(currentAST, returnAST);
 		match(RPAREN);
 		{
 		switch ( LA(1)) {
 		case LITERAL_throws:
 		{
 			throwsClause();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case LCURLY:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		ctorHead_AST = (AST)currentAST.root;
 		returnAST = ctorHead_AST;
 	}
 	
 	public final void constructorBody() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST constructorBody_AST = null;
 		Token  lc = null;
 		AST lc_AST = null;
 		
 		lc = LT(1);
 		lc_AST = astFactory.create(lc);
 		astFactory.makeASTRoot(currentAST, lc_AST);
 		match(LCURLY);
 		if ( inputState.guessing==0 ) {
 			lc_AST.setType(SLIST);
 		}
 		{
 		if ((_tokenSet_24.member(LA(1))) && (_tokenSet_25.member(LA(2)))) {
 			explicitConstructorInvocation();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		{
 		_loop149:
 		do {
 			if ((_tokenSet_23.member(LA(1)))) {
 				statement();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop149;
 			}
 			
 		} while (true);
 		}
 		match(RCURLY);
 		constructorBody_AST = (AST)currentAST.root;
 		returnAST = constructorBody_AST;
 	}
 	
 /*** Catch obvious constructor calls, but not the expr.super(...) calls */
 	public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST explicitConstructorInvocation_AST = null;
 		Token  lp1 = null;
 		AST lp1_AST = null;
 		Token  lp2 = null;
 		AST lp2_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeArguments();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case LITERAL_super:
 		case LITERAL_this:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		switch ( LA(1)) {
 		case LITERAL_this:
 		{
 			match(LITERAL_this);
 			lp1 = LT(1);
 			lp1_AST = astFactory.create(lp1);
 			astFactory.makeASTRoot(currentAST, lp1_AST);
 			match(LPAREN);
 			argList();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			match(SEMI);
 			if ( inputState.guessing==0 ) {
 				lp1_AST.setType(CTOR_CALL);
 			}
 			break;
 		}
 		case LITERAL_super:
 		{
 			match(LITERAL_super);
 			lp2 = LT(1);
 			lp2_AST = astFactory.create(lp2);
 			astFactory.makeASTRoot(currentAST, lp2_AST);
 			match(LPAREN);
 			argList();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			match(SEMI);
 			if ( inputState.guessing==0 ) {
 				lp2_AST.setType(SUPER_CTOR_CALL);
 			}
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		explicitConstructorInvocation_AST = (AST)currentAST.root;
 		returnAST = explicitConstructorInvocation_AST;
 	}
 	
 	public final void statement() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST statement_AST = null;
 		AST m_AST = null;
 		Token  c = null;
 		AST c_AST = null;
 		Token  s = null;
 		AST s_AST = null;
 		
 		switch ( LA(1)) {
 		case LCURLY:
 		{
 			compoundStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_if:
 		{
 			AST tmp132_AST = null;
 			tmp132_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp132_AST);
 			match(LITERAL_if);
 			match(LPAREN);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			statement();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			if ((LA(1)==LITERAL_else) && (_tokenSet_23.member(LA(2)))) {
 				match(LITERAL_else);
 				statement();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
 			}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			
 			}
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_for:
 		{
 			forStatement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_while:
 		{
 			AST tmp136_AST = null;
 			tmp136_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp136_AST);
 			match(LITERAL_while);
 			match(LPAREN);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			statement();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_break:
 		{
 			AST tmp139_AST = null;
 			tmp139_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp139_AST);
 			match(LITERAL_break);
 			{
 			switch ( LA(1)) {
 			case IDENT:
 			{
 				AST tmp140_AST = null;
 				tmp140_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp140_AST);
 				match(IDENT);
 				break;
 			}
 			case SEMI:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			match(SEMI);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_continue:
 		{
 			AST tmp142_AST = null;
 			tmp142_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp142_AST);
 			match(LITERAL_continue);
 			{
 			switch ( LA(1)) {
 			case IDENT:
 			{
 				AST tmp143_AST = null;
 				tmp143_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp143_AST);
 				match(IDENT);
 				break;
 			}
 			case SEMI:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			match(SEMI);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_return:
 		{
 			AST tmp145_AST = null;
 			tmp145_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp145_AST);
 			match(LITERAL_return);
 			{
 			switch ( LA(1)) {
 			case IDENT:
 			case LITERAL_super:
 			case LT:
 			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 LPAREN:
 			case LITERAL_this:
 			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 STRING_LITERAL:
 			case NUM_FLOAT:
 			case NUM_LONG:
 			case NUM_DOUBLE:
 			{
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			match(SEMI);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_switch:
 		{
 			AST tmp147_AST = null;
 			tmp147_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp147_AST);
 			match(LITERAL_switch);
 			match(LPAREN);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			match(LCURLY);
 			{
 			_loop196:
 			do {
 				if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case)) {
 					casesGroup();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop196;
 				}
 				
 			} while (true);
 			}
 			match(RCURLY);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_try:
 		{
 			tryBlock();
 			astFactory.addASTChild(currentAST, returnAST);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_throw:
 		{
 			AST tmp152_AST = null;
 			tmp152_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp152_AST);
 			match(LITERAL_throw);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(SEMI);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_assert:
 		{
 			AST tmp154_AST = null;
 			tmp154_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp154_AST);
 			match(LITERAL_assert);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			switch ( LA(1)) {
 			case COLON:
 			{
 				match(COLON);
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			match(SEMI);
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		case SEMI:
 		{
 			s = LT(1);
 			s_AST = astFactory.create(s);
 			astFactory.addASTChild(currentAST, s_AST);
 			match(SEMI);
 			if ( inputState.guessing==0 ) {
 				s_AST.setType(EMPTY_STAT);
 			}
 			statement_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 			boolean synPredMatched190 = false;
 			if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
 				int _m190 = mark();
 				synPredMatched190 = true;
 				inputState.guessing++;
 				try {
 					{
 					declaration();
 					}
 				}
 				catch (RecognitionException pe) {
 					synPredMatched190 = false;
 				}
 				rewind(_m190);
 				inputState.guessing--;
 			}
 			if ( synPredMatched190 ) {
 				declaration();
 				astFactory.addASTChild(currentAST, returnAST);
 				match(SEMI);
 				statement_AST = (AST)currentAST.root;
 			}
 			else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 				match(SEMI);
 				statement_AST = (AST)currentAST.root;
 			}
 			else if ((_tokenSet_34.member(LA(1))) && (_tokenSet_35.member(LA(2)))) {
 				modifiers();
 				m_AST = (AST)returnAST;
 				classDefinition(m_AST);
 				astFactory.addASTChild(currentAST, returnAST);
 				statement_AST = (AST)currentAST.root;
 			}
 			else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
 				AST tmp159_AST = null;
 				tmp159_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp159_AST);
 				match(IDENT);
 				c = LT(1);
 				c_AST = astFactory.create(c);
 				astFactory.makeASTRoot(currentAST, c_AST);
 				match(COLON);
 				if ( inputState.guessing==0 ) {
 					c_AST.setType(LABELED_STAT);
 				}
 				statement();
 				astFactory.addASTChild(currentAST, returnAST);
 				statement_AST = (AST)currentAST.root;
 			}
 			else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
 				AST tmp160_AST = null;
 				tmp160_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp160_AST);
 				match(LITERAL_synchronized);
 				match(LPAREN);
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 				match(RPAREN);
 				compoundStatement();
 				astFactory.addASTChild(currentAST, returnAST);
 				statement_AST = (AST)currentAST.root;
 			}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = statement_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.
  */
 	public final void variableDeclarator(
 		AST mods, AST t
 	) throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST variableDeclarator_AST = null;
 		Token  id = null;
 		AST id_AST = null;
 		AST d_AST = null;
 		AST v_AST = null;
 		Token first = LT(1);
 		
 		id = LT(1);
 		id_AST = astFactory.create(id);
 		match(IDENT);
 		declaratorBrackets(t);
 		d_AST = (AST)returnAST;
 		varInitializer();
 		v_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			variableDeclarator_AST = (AST)currentAST.root;
 			variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(create(VARIABLE_DEF,"VARIABLE_DEF",first,LT(1))).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(d_AST))).add(id_AST).add(v_AST));
 			currentAST.root = variableDeclarator_AST;
 			currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
 				variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = variableDeclarator_AST;
 	}
 	
 	public final void varInitializer() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST varInitializer_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case ASSIGN:
 		{
 			AST tmp163_AST = null;
 			tmp163_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp163_AST);
 			match(ASSIGN);
 			initializer();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case SEMI:
 		case COMMA:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		varInitializer_AST = (AST)currentAST.root;
 		returnAST = varInitializer_AST;
 	}
 	
 	public final void initializer() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST initializer_AST = null;
 		
 		expression();
 		astFactory.addASTChild(currentAST, returnAST);
 		initializer_AST = (AST)currentAST.root;
 		returnAST = initializer_AST;
 	}
 	
 	public final void expression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST expression_AST = null;
 		Token first = LT(1);
 		
 		assignmentExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		if ( inputState.guessing==0 ) {
 			expression_AST = (AST)currentAST.root;
 			expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(EXPR,"EXPR",first,LT(1))).add(expression_AST));
 			currentAST.root = expression_AST;
 			currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
 				expression_AST.getFirstChild() : expression_AST;
 			currentAST.advanceChildToEnd();
 		}
 		expression_AST = (AST)currentAST.root;
 		returnAST = expression_AST;
 	}
 	
 	public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST parameterDeclaration_AST = null;
 		AST pm_AST = null;
 		AST t_AST = null;
 		Token  id = null;
 		AST id_AST = null;
 		AST pd_AST = null;
 		Token first = LT(1);
 		
 		parameterModifier();
 		pm_AST = (AST)returnAST;
 		typeSpec(false);
 		t_AST = (AST)returnAST;
 		id = LT(1);
 		id_AST = astFactory.create(id);
 		match(IDENT);
 		declaratorBrackets(t_AST);
 		pd_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			parameterDeclaration_AST = (AST)currentAST.root;
 			parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(PARAMETER_DEF,"PARAMETER_DEF",first,LT(1))).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(pd_AST))).add(id_AST));
 			currentAST.root = parameterDeclaration_AST;
 			currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
 				parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = parameterDeclaration_AST;
 	}
 	
 	public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST variableLengthParameterDeclaration_AST = null;
 		AST pm_AST = null;
 		AST t_AST = null;
 		Token  id = null;
 		AST id_AST = null;
 		AST pd_AST = null;
 		Token first = LT(1);
 		
 		parameterModifier();
 		pm_AST = (AST)returnAST;
 		typeSpec(false);
 		t_AST = (AST)returnAST;
 		match(TRIPLE_DOT);
 		id = LT(1);
 		id_AST = astFactory.create(id);
 		match(IDENT);
 		declaratorBrackets(t_AST);
 		pd_AST = (AST)returnAST;
 		if ( inputState.guessing==0 ) {
 			variableLengthParameterDeclaration_AST = (AST)currentAST.root;
 			variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(create(VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF",first,LT(1))).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(create(TYPE,"TYPE",first,LT(1))).add(pd_AST))).add(id_AST));
 			currentAST.root = variableLengthParameterDeclaration_AST;
 			currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ?
 				variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST;
 			currentAST.advanceChildToEnd();
 		}
 		returnAST = variableLengthParameterDeclaration_AST;
 	}
 	
 	public final void parameterModifier() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST parameterModifier_AST = null;
 		Token  f = null;
 		AST f_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop181:
 		do {
 			if ((LA(1)==AT) && (LA(2)==IDENT)) {
 				annotation();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop181;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case FINAL:
 		{
 			f = LT(1);
 			f_AST = astFactory.create(f);
 			astFactory.addASTChild(currentAST, f_AST);
 			match(FINAL);
 			break;
 		}
 		case IDENT:
 		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 AT:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		{
 		_loop184:
 		do {
 			if ((LA(1)==AT)) {
 				annotation();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop184;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			parameterModifier_AST = (AST)currentAST.root;
 			parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(MODIFIERS,"MODIFIERS",first,LT(1))).add(parameterModifier_AST));
 			currentAST.root = parameterModifier_AST;
 			currentAST.child = parameterModifier_AST!=null &&parameterModifier_AST.getFirstChild()!=null ?
 				parameterModifier_AST.getFirstChild() : parameterModifier_AST;
 			currentAST.advanceChildToEnd();
 		}
 		parameterModifier_AST = (AST)currentAST.root;
 		returnAST = parameterModifier_AST;
 	}
 	
 	public final void forStatement() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST forStatement_AST = null;
 		Token  f = null;
 		AST f_AST = null;
 		
 		f = LT(1);
 		f_AST = astFactory.create(f);
 		astFactory.makeASTRoot(currentAST, f_AST);
 		match(LITERAL_for);
 		match(LPAREN);
 		{
 		boolean synPredMatched201 = false;
 		if (((_tokenSet_36.member(LA(1))) && (_tokenSet_37.member(LA(2))))) {
 			int _m201 = mark();
 			synPredMatched201 = true;
 			inputState.guessing++;
 			try {
 				{
 				forInit();
 				match(SEMI);
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched201 = false;
 			}
 			rewind(_m201);
 			inputState.guessing--;
 		}
 		if ( synPredMatched201 ) {
 			traditionalForClause();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_20.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
 			forEachClause();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		match(RPAREN);
 		statement();
 		astFactory.addASTChild(currentAST, returnAST);
 		forStatement_AST = (AST)currentAST.root;
 		returnAST = forStatement_AST;
 	}
 	
 	public final void casesGroup() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST casesGroup_AST = null;
 		
 		{
 		int _cnt206=0;
 		_loop206:
 		do {
 			if ((LA(1)==LITERAL_default||LA(1)==LITERAL_case) && (_tokenSet_38.member(LA(2)))) {
 				aCase();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				if ( _cnt206>=1 ) { break _loop206; } else {throw new NoViableAltException(LT(1), getFilename());}
 			}
 			
 			_cnt206++;
 		} while (true);
 		}
 		caseSList();
 		astFactory.addASTChild(currentAST, returnAST);
 		if ( inputState.guessing==0 ) {
 			casesGroup_AST = (AST)currentAST.root;
 			casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST));
 			currentAST.root = casesGroup_AST;
 			currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ?
 				casesGroup_AST.getFirstChild() : casesGroup_AST;
 			currentAST.advanceChildToEnd();
 		}
 		casesGroup_AST = (AST)currentAST.root;
 		returnAST = casesGroup_AST;
 	}
 	
 	public final void tryBlock() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST tryBlock_AST = null;
 		
 		AST tmp167_AST = null;
 		tmp167_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp167_AST);
 		match(LITERAL_try);
 		compoundStatement();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop222:
 		do {
 			if ((LA(1)==LITERAL_catch)) {
 				handler();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop222;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case LITERAL_finally:
 		{
 			finallyClause();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case FINAL:
 		case ABSTRACT:
 		case STRICTFP:
 		case SEMI:
 		case LITERAL_static:
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LITERAL_private:
 		case LITERAL_public:
 		case LITERAL_protected:
 		case LITERAL_transient:
 		case LITERAL_native:
 		case LITERAL_threadsafe:
 		case LITERAL_synchronized:
 		case LITERAL_volatile:
 		case AT:
 		case LPAREN:
 		case LCURLY:
 		case RCURLY:
 		case LITERAL_class:
 		case LITERAL_default:
 		case LITERAL_this:
 		case LITERAL_if:
 		case LITERAL_else:
 		case LITERAL_while:
 		case LITERAL_break:
 		case LITERAL_continue:
 		case LITERAL_return:
 		case LITERAL_switch:
 		case LITERAL_throw:
 		case LITERAL_assert:
 		case LITERAL_for:
 		case LITERAL_case:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		tryBlock_AST = (AST)currentAST.root;
 		returnAST = tryBlock_AST;
 	}
 	
 	public final void forInit() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST forInit_AST = null;
 		Token first = LT(1);
 		
 		{
 		boolean synPredMatched215 = false;
 		if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
 			int _m215 = mark();
 			synPredMatched215 = true;
 			inputState.guessing++;
 			try {
 				{
 				declaration();
 				}
 			}
 			catch (RecognitionException pe) {
 				synPredMatched215 = false;
 			}
 			rewind(_m215);
 			inputState.guessing--;
 		}
 		if ( synPredMatched215 ) {
 			declaration();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_39.member(LA(2)))) {
 			expressionList();
 			astFactory.addASTChild(currentAST, returnAST);
 		}
 		else if ((LA(1)==SEMI)) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		if ( inputState.guessing==0 ) {
 			forInit_AST = (AST)currentAST.root;
 			forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_INIT,"FOR_INIT",first,LT(1))).add(forInit_AST));
 			currentAST.root = forInit_AST;
 			currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ?
 				forInit_AST.getFirstChild() : forInit_AST;
 			currentAST.advanceChildToEnd();
 		}
 		forInit_AST = (AST)currentAST.root;
 		returnAST = forInit_AST;
 	}
 	
 	public final void traditionalForClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST traditionalForClause_AST = null;
 		
 		forInit();
 		astFactory.addASTChild(currentAST, returnAST);
 		match(SEMI);
 		forCond();
 		astFactory.addASTChild(currentAST, returnAST);
 		match(SEMI);
 		forIter();
 		astFactory.addASTChild(currentAST, returnAST);
 		traditionalForClause_AST = (AST)currentAST.root;
 		returnAST = traditionalForClause_AST;
 	}
 	
 	public final void forEachClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST forEachClause_AST = null;
 		AST p_AST = null;
 		Token first = LT(1);
 		
 		parameterDeclaration();
 		p_AST = (AST)returnAST;
 		astFactory.addASTChild(currentAST, returnAST);
 		match(COLON);
 		expression();
 		astFactory.addASTChild(currentAST, returnAST);
 		if ( inputState.guessing==0 ) {
 			forEachClause_AST = (AST)currentAST.root;
 			forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE",first,LT(1))).add(forEachClause_AST));
 			currentAST.root = forEachClause_AST;
 			currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ?
 				forEachClause_AST.getFirstChild() : forEachClause_AST;
 			currentAST.advanceChildToEnd();
 		}
 		forEachClause_AST = (AST)currentAST.root;
 		returnAST = forEachClause_AST;
 	}
 	
 	public final void forCond() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST forCond_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case SEMI:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			forCond_AST = (AST)currentAST.root;
 			forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_CONDITION,"FOR_CONDITION",first,LT(1))).add(forCond_AST));
 			currentAST.root = forCond_AST;
 			currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ?
 				forCond_AST.getFirstChild() : forCond_AST;
 			currentAST.advanceChildToEnd();
 		}
 		forCond_AST = (AST)currentAST.root;
 		returnAST = forCond_AST;
 	}
 	
 	public final void forIter() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST forIter_AST = null;
 		Token first = LT(1);
 		
 		{
 		switch ( LA(1)) {
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		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 STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			expressionList();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case RPAREN:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		if ( inputState.guessing==0 ) {
 			forIter_AST = (AST)currentAST.root;
 			forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(FOR_ITERATOR,"FOR_ITERATOR",first,LT(1))).add(forIter_AST));
 			currentAST.root = forIter_AST;
 			currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ?
 				forIter_AST.getFirstChild() : forIter_AST;
 			currentAST.advanceChildToEnd();
 		}
 		forIter_AST = (AST)currentAST.root;
 		returnAST = forIter_AST;
 	}
 	
 	public final void aCase() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST aCase_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case LITERAL_case:
 		{
 			AST tmp171_AST = null;
 			tmp171_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp171_AST);
 			match(LITERAL_case);
 			expression();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case LITERAL_default:
 		{
 			AST tmp172_AST = null;
 			tmp172_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp172_AST);
 			match(LITERAL_default);
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		match(COLON);
 		aCase_AST = (AST)currentAST.root;
 		returnAST = aCase_AST;
 	}
 	
 	public final void caseSList() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST caseSList_AST = null;
 		Token first = LT(1);
 		
 		{
 		_loop211:
 		do {
 			if ((_tokenSet_23.member(LA(1)))) {
 				statement();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop211;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			caseSList_AST = (AST)currentAST.root;
 			caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(SLIST,"SLIST",first,LT(1))).add(caseSList_AST));
 			currentAST.root = caseSList_AST;
 			currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ?
 				caseSList_AST.getFirstChild() : caseSList_AST;
 			currentAST.advanceChildToEnd();
 		}
 		caseSList_AST = (AST)currentAST.root;
 		returnAST = caseSList_AST;
 	}
 	
 	public final void expressionList() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST expressionList_AST = null;
 		Token first = LT(1);
 		
 		expression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop229:
 		do {
 			if ((LA(1)==COMMA)) {
 				match(COMMA);
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop229;
 			}
 			
 		} while (true);
 		}
 		if ( inputState.guessing==0 ) {
 			expressionList_AST = (AST)currentAST.root;
 			expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(create(ELIST,"ELIST",first,LT(1))).add(expressionList_AST));
 			currentAST.root = expressionList_AST;
 			currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ?
 				expressionList_AST.getFirstChild() : expressionList_AST;
 			currentAST.advanceChildToEnd();
 		}
 		expressionList_AST = (AST)currentAST.root;
 		returnAST = expressionList_AST;
 	}
 	
 	public final void handler() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST handler_AST = null;
 		
 		AST tmp175_AST = null;
 		tmp175_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp175_AST);
 		match(LITERAL_catch);
 		match(LPAREN);
 		parameterDeclaration();
 		astFactory.addASTChild(currentAST, returnAST);
 		match(RPAREN);
 		compoundStatement();
 		astFactory.addASTChild(currentAST, returnAST);
 		handler_AST = (AST)currentAST.root;
 		returnAST = handler_AST;
 	}
 	
 	public final void finallyClause() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST finallyClause_AST = null;
 		
 		AST tmp178_AST = null;
 		tmp178_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp178_AST);
 		match(LITERAL_finally);
 		compoundStatement();
 		astFactory.addASTChild(currentAST, returnAST);
 		finallyClause_AST = (AST)currentAST.root;
 		returnAST = finallyClause_AST;
 	}
 	
 	public final void assignmentExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST assignmentExpression_AST = null;
 		
 		conditionalExpression();
 		astFactory.addASTChild(currentAST, 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:
 			{
 				AST tmp179_AST = null;
 				tmp179_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp179_AST);
 				match(ASSIGN);
 				break;
 			}
 			case PLUS_ASSIGN:
 			{
 				AST tmp180_AST = null;
 				tmp180_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp180_AST);
 				match(PLUS_ASSIGN);
 				break;
 			}
 			case MINUS_ASSIGN:
 			{
 				AST tmp181_AST = null;
 				tmp181_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp181_AST);
 				match(MINUS_ASSIGN);
 				break;
 			}
 			case STAR_ASSIGN:
 			{
 				AST tmp182_AST = null;
 				tmp182_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp182_AST);
 				match(STAR_ASSIGN);
 				break;
 			}
 			case DIV_ASSIGN:
 			{
 				AST tmp183_AST = null;
 				tmp183_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp183_AST);
 				match(DIV_ASSIGN);
 				break;
 			}
 			case MOD_ASSIGN:
 			{
 				AST tmp184_AST = null;
 				tmp184_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp184_AST);
 				match(MOD_ASSIGN);
 				break;
 			}
 			case SR_ASSIGN:
 			{
 				AST tmp185_AST = null;
 				tmp185_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp185_AST);
 				match(SR_ASSIGN);
 				break;
 			}
 			case BSR_ASSIGN:
 			{
 				AST tmp186_AST = null;
 				tmp186_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp186_AST);
 				match(BSR_ASSIGN);
 				break;
 			}
 			case SL_ASSIGN:
 			{
 				AST tmp187_AST = null;
 				tmp187_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp187_AST);
 				match(SL_ASSIGN);
 				break;
 			}
 			case BAND_ASSIGN:
 			{
 				AST tmp188_AST = null;
 				tmp188_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp188_AST);
 				match(BAND_ASSIGN);
 				break;
 			}
 			case BXOR_ASSIGN:
 			{
 				AST tmp189_AST = null;
 				tmp189_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp189_AST);
 				match(BXOR_ASSIGN);
 				break;
 			}
 			case BOR_ASSIGN:
 			{
 				AST tmp190_AST = null;
 				tmp190_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp190_AST);
 				match(BOR_ASSIGN);
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			assignmentExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case SEMI:
 		case RBRACK:
 		case COMMA:
 		case RPAREN:
 		case COLON:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		assignmentExpression_AST = (AST)currentAST.root;
 		returnAST = assignmentExpression_AST;
 	}
 	
 	public final void logicalOrExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST logicalOrExpression_AST = null;
 		
 		logicalAndExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop237:
 		do {
 			if ((LA(1)==LOR)) {
 				AST tmp191_AST = null;
 				tmp191_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp191_AST);
 				match(LOR);
 				logicalAndExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop237;
 			}
 			
 		} while (true);
 		}
 		logicalOrExpression_AST = (AST)currentAST.root;
 		returnAST = logicalOrExpression_AST;
 	}
 	
 	public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST logicalAndExpression_AST = null;
 		
 		inclusiveOrExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop240:
 		do {
 			if ((LA(1)==LAND)) {
 				AST tmp192_AST = null;
 				tmp192_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp192_AST);
 				match(LAND);
 				inclusiveOrExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop240;
 			}
 			
 		} while (true);
 		}
 		logicalAndExpression_AST = (AST)currentAST.root;
 		returnAST = logicalAndExpression_AST;
 	}
 	
 	public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST inclusiveOrExpression_AST = null;
 		
 		exclusiveOrExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop243:
 		do {
 			if ((LA(1)==BOR)) {
 				AST tmp193_AST = null;
 				tmp193_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp193_AST);
 				match(BOR);
 				exclusiveOrExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop243;
 			}
 			
 		} while (true);
 		}
 		inclusiveOrExpression_AST = (AST)currentAST.root;
 		returnAST = inclusiveOrExpression_AST;
 	}
 	
 	public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST exclusiveOrExpression_AST = null;
 		
 		andExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop246:
 		do {
 			if ((LA(1)==BXOR)) {
 				AST tmp194_AST = null;
 				tmp194_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp194_AST);
 				match(BXOR);
 				andExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop246;
 			}
 			
 		} while (true);
 		}
 		exclusiveOrExpression_AST = (AST)currentAST.root;
 		returnAST = exclusiveOrExpression_AST;
 	}
 	
 	public final void andExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST andExpression_AST = null;
 		
 		equalityExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop249:
 		do {
 			if ((LA(1)==BAND)) {
 				AST tmp195_AST = null;
 				tmp195_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp195_AST);
 				match(BAND);
 				equalityExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop249;
 			}
 			
 		} while (true);
 		}
 		andExpression_AST = (AST)currentAST.root;
 		returnAST = andExpression_AST;
 	}
 	
 	public final void equalityExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST equalityExpression_AST = null;
 		
 		relationalExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop253:
 		do {
 			if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
 				{
 				switch ( LA(1)) {
 				case NOT_EQUAL:
 				{
 					AST tmp196_AST = null;
 					tmp196_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp196_AST);
 					match(NOT_EQUAL);
 					break;
 				}
 				case EQUAL:
 				{
 					AST tmp197_AST = null;
 					tmp197_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp197_AST);
 					match(EQUAL);
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				relationalExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop253;
 			}
 			
 		} while (true);
 		}
 		equalityExpression_AST = (AST)currentAST.root;
 		returnAST = equalityExpression_AST;
 	}
 	
 	public final void relationalExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST relationalExpression_AST = null;
 		
 		shiftExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		switch ( LA(1)) {
 		case SEMI:
 		case RBRACK:
 		case QUESTION:
 		case LT:
 		case COMMA:
 		case GT:
 		case RPAREN:
 		case ASSIGN:
 		case RCURLY:
 		case BAND:
 		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 LOR:
 		case LAND:
 		case BOR:
 		case BXOR:
 		case NOT_EQUAL:
 		case EQUAL:
 		case LE:
 		case GE:
 		{
 			{
 			_loop258:
 			do {
 				if ((_tokenSet_40.member(LA(1)))) {
 					{
 					switch ( LA(1)) {
 					case LT:
 					{
 						AST tmp198_AST = null;
 						tmp198_AST = astFactory.create(LT(1));
 						astFactory.makeASTRoot(currentAST, tmp198_AST);
 						match(LT);
 						break;
 					}
 					case GT:
 					{
 						AST tmp199_AST = null;
 						tmp199_AST = astFactory.create(LT(1));
 						astFactory.makeASTRoot(currentAST, tmp199_AST);
 						match(GT);
 						break;
 					}
 					case LE:
 					{
 						AST tmp200_AST = null;
 						tmp200_AST = astFactory.create(LT(1));
 						astFactory.makeASTRoot(currentAST, tmp200_AST);
 						match(LE);
 						break;
 					}
 					case GE:
 					{
 						AST tmp201_AST = null;
 						tmp201_AST = astFactory.create(LT(1));
 						astFactory.makeASTRoot(currentAST, tmp201_AST);
 						match(GE);
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					shiftExpression();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					break _loop258;
 				}
 				
 			} while (true);
 			}
 			break;
 		}
 		case LITERAL_instanceof:
 		{
 			AST tmp202_AST = null;
 			tmp202_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp202_AST);
 			match(LITERAL_instanceof);
 			typeSpec(true);
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		relationalExpression_AST = (AST)currentAST.root;
 		returnAST = relationalExpression_AST;
 	}
 	
 	public final void shiftExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST shiftExpression_AST = null;
 		
 		additiveExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop262:
 		do {
 			if ((_tokenSet_41.member(LA(1)))) {
 				{
 				switch ( LA(1)) {
 				case SL:
 				{
 					AST tmp203_AST = null;
 					tmp203_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp203_AST);
 					match(SL);
 					break;
 				}
 				case SR:
 				{
 					AST tmp204_AST = null;
 					tmp204_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp204_AST);
 					match(SR);
 					break;
 				}
 				case BSR:
 				{
 					AST tmp205_AST = null;
 					tmp205_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp205_AST);
 					match(BSR);
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				additiveExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop262;
 			}
 			
 		} while (true);
 		}
 		shiftExpression_AST = (AST)currentAST.root;
 		returnAST = shiftExpression_AST;
 	}
 	
 	public final void additiveExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST additiveExpression_AST = null;
 		
 		multiplicativeExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop266:
 		do {
 			if ((LA(1)==PLUS||LA(1)==MINUS)) {
 				{
 				switch ( LA(1)) {
 				case PLUS:
 				{
 					AST tmp206_AST = null;
 					tmp206_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp206_AST);
 					match(PLUS);
 					break;
 				}
 				case MINUS:
 				{
 					AST tmp207_AST = null;
 					tmp207_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp207_AST);
 					match(MINUS);
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				multiplicativeExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop266;
 			}
 			
 		} while (true);
 		}
 		additiveExpression_AST = (AST)currentAST.root;
 		returnAST = additiveExpression_AST;
 	}
 	
 	public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST multiplicativeExpression_AST = null;
 		
 		unaryExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop270:
 		do {
 			if ((_tokenSet_42.member(LA(1)))) {
 				{
 				switch ( LA(1)) {
 				case STAR:
 				{
 					AST tmp208_AST = null;
 					tmp208_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp208_AST);
 					match(STAR);
 					break;
 				}
 				case DIV:
 				{
 					AST tmp209_AST = null;
 					tmp209_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp209_AST);
 					match(DIV);
 					break;
 				}
 				case MOD:
 				{
 					AST tmp210_AST = null;
 					tmp210_AST = astFactory.create(LT(1));
 					astFactory.makeASTRoot(currentAST, tmp210_AST);
 					match(MOD);
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				unaryExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				break _loop270;
 			}
 			
 		} while (true);
 		}
 		multiplicativeExpression_AST = (AST)currentAST.root;
 		returnAST = multiplicativeExpression_AST;
 	}
 	
 	public final void unaryExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST unaryExpression_AST = null;
 		
 		switch ( LA(1)) {
 		case INC:
 		{
 			AST tmp211_AST = null;
 			tmp211_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp211_AST);
 			match(INC);
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case DEC:
 		{
 			AST tmp212_AST = null;
 			tmp212_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp212_AST);
 			match(DEC);
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case MINUS:
 		{
 			AST tmp213_AST = null;
 			tmp213_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp213_AST);
 			match(MINUS);
 			if ( inputState.guessing==0 ) {
 				tmp213_AST.setType(UNARY_MINUS);
 			}
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case PLUS:
 		{
 			AST tmp214_AST = null;
 			tmp214_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp214_AST);
 			match(PLUS);
 			if ( inputState.guessing==0 ) {
 				tmp214_AST.setType(UNARY_PLUS);
 			}
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		case BNOT:
 		case LNOT:
 		case LITERAL_true:
 		case LITERAL_false:
 		case LITERAL_null:
 		case LITERAL_new:
 		case NUM_INT:
 		case STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			unaryExpressionNotPlusMinus();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = unaryExpression_AST;
 	}
 	
 	public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST unaryExpressionNotPlusMinus_AST = null;
 		Token  lpb = null;
 		AST lpb_AST = null;
 		Token  lp = null;
 		AST lp_AST = null;
 		
 		switch ( LA(1)) {
 		case BNOT:
 		{
 			AST tmp215_AST = null;
 			tmp215_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp215_AST);
 			match(BNOT);
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
 			break;
 		}
 		case LNOT:
 		{
 			AST tmp216_AST = null;
 			tmp216_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp216_AST);
 			match(LNOT);
 			unaryExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
 			break;
 		}
 		case IDENT:
 		case LITERAL_super:
 		case LT:
 		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 LPAREN:
 		case LITERAL_this:
 		case LITERAL_true:
 		case LITERAL_false:
 		case LITERAL_null:
 		case LITERAL_new:
 		case NUM_INT:
 		case STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			{
 			boolean synPredMatched275 = false;
 			if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
 				int _m275 = mark();
 				synPredMatched275 = true;
 				inputState.guessing++;
 				try {
 					{
 					match(LPAREN);
 					builtInTypeSpec(true);
 					match(RPAREN);
 					unaryExpression();
 					}
 				}
 				catch (RecognitionException pe) {
 					synPredMatched275 = false;
 				}
 				rewind(_m275);
 				inputState.guessing--;
 			}
 			if ( synPredMatched275 ) {
 				lpb = LT(1);
 				lpb_AST = astFactory.create(lpb);
 				astFactory.makeASTRoot(currentAST, lpb_AST);
 				match(LPAREN);
 				if ( inputState.guessing==0 ) {
 					lpb_AST.setType(TYPECAST);
 				}
 				builtInTypeSpec(true);
 				astFactory.addASTChild(currentAST, returnAST);
 				match(RPAREN);
 				unaryExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else {
 				boolean synPredMatched277 = false;
 				if (((LA(1)==LPAREN) && (LA(2)==IDENT))) {
 					int _m277 = mark();
 					synPredMatched277 = true;
 					inputState.guessing++;
 					try {
 						{
 						match(LPAREN);
 						classTypeSpec(true);
 						match(RPAREN);
 						unaryExpressionNotPlusMinus();
 						}
 					}
 					catch (RecognitionException pe) {
 						synPredMatched277 = false;
 					}
 					rewind(_m277);
 					inputState.guessing--;
 				}
 				if ( synPredMatched277 ) {
 					lp = LT(1);
 					lp_AST = astFactory.create(lp);
 					astFactory.makeASTRoot(currentAST, lp_AST);
 					match(LPAREN);
 					if ( inputState.guessing==0 ) {
 						lp_AST.setType(TYPECAST);
 					}
 					classTypeSpec(true);
 					astFactory.addASTChild(currentAST, returnAST);
 					match(RPAREN);
 					unaryExpressionNotPlusMinus();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
 					postfixExpression();
 					astFactory.addASTChild(currentAST, returnAST);
 				}
 				else {
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			returnAST = unaryExpressionNotPlusMinus_AST;
 		}
 		
 	public final void postfixExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST postfixExpression_AST = null;
 		Token  lp = null;
 		AST lp_AST = null;
 		Token  lp3 = null;
 		AST lp3_AST = null;
 		Token  lps = null;
 		AST lps_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		Token  in = null;
 		AST in_AST = null;
 		Token  de = null;
 		AST de_AST = null;
 		
 		primaryExpression();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		_loop286:
 		do {
 			if ((LA(1)==DOT) && (_tokenSet_45.member(LA(2)))) {
 				AST tmp219_AST = null;
 				tmp219_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp219_AST);
 				match(DOT);
 				{
 				switch ( LA(1)) {
 				case LT:
 				{
 					typeArguments();
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case IDENT:
 				case LITERAL_super:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				{
 				switch ( LA(1)) {
 				case IDENT:
 				{
 					AST tmp220_AST = null;
 					tmp220_AST = astFactory.create(LT(1));
 					astFactory.addASTChild(currentAST, tmp220_AST);
 					match(IDENT);
 					{
 					switch ( LA(1)) {
 					case LPAREN:
 					{
 						lp = LT(1);
 						lp_AST = astFactory.create(lp);
 						astFactory.makeASTRoot(currentAST, lp_AST);
 						match(LPAREN);
 						if ( inputState.guessing==0 ) {
 							lp_AST.setType(METHOD_CALL);
 						}
 						argList();
 						astFactory.addASTChild(currentAST, returnAST);
 						match(RPAREN);
 						break;
 					}
 					case SEMI:
 					case LBRACK:
 					case RBRACK:
 					case DOT:
 					case QUESTION:
 					case LT:
 					case COMMA:
 					case GT:
 					case SR:
 					case BSR:
 					case STAR:
 					case RPAREN:
 					case ASSIGN:
 					case RCURLY:
 					case BAND:
 					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 LOR:
 					case LAND:
 					case BOR:
 					case BXOR:
 					case NOT_EQUAL:
 					case EQUAL:
 					case LE:
 					case GE:
 					case LITERAL_instanceof:
 					case SL:
 					case PLUS:
 					case MINUS:
 					case DIV:
 					case MOD:
 					case INC:
 					case DEC:
 					{
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					break;
 				}
 				case LITERAL_super:
 				{
 					AST tmp222_AST = null;
 					tmp222_AST = astFactory.create(LT(1));
 					astFactory.addASTChild(currentAST, tmp222_AST);
 					match(LITERAL_super);
 					{
 					switch ( LA(1)) {
 					case LPAREN:
 					{
 						lp3 = LT(1);
 						lp3_AST = astFactory.create(lp3);
 						astFactory.makeASTRoot(currentAST, lp3_AST);
 						match(LPAREN);
 						argList();
 						astFactory.addASTChild(currentAST, returnAST);
 						match(RPAREN);
 						if ( inputState.guessing==0 ) {
 							lp3_AST.setType(SUPER_CTOR_CALL);
 						}
 						break;
 					}
 					case DOT:
 					{
 						AST tmp224_AST = null;
 						tmp224_AST = astFactory.create(LT(1));
 						astFactory.makeASTRoot(currentAST, tmp224_AST);
 						match(DOT);
 						{
 						switch ( LA(1)) {
 						case LT:
 						{
 							typeArguments();
 							astFactory.addASTChild(currentAST, returnAST);
 							break;
 						}
 						case IDENT:
 						{
 							break;
 						}
 						default:
 						{
 							throw new NoViableAltException(LT(1), getFilename());
 						}
 						}
 						}
 						AST tmp225_AST = null;
 						tmp225_AST = astFactory.create(LT(1));
 						astFactory.addASTChild(currentAST, tmp225_AST);
 						match(IDENT);
 						{
 						switch ( LA(1)) {
 						case LPAREN:
 						{
 							lps = LT(1);
 							lps_AST = astFactory.create(lps);
 							astFactory.makeASTRoot(currentAST, lps_AST);
 							match(LPAREN);
 							if ( inputState.guessing==0 ) {
 								lps_AST.setType(METHOD_CALL);
 							}
 							argList();
 							astFactory.addASTChild(currentAST, returnAST);
 							match(RPAREN);
 							break;
 						}
 						case SEMI:
 						case LBRACK:
 						case RBRACK:
 						case DOT:
 						case QUESTION:
 						case LT:
 						case COMMA:
 						case GT:
 						case SR:
 						case BSR:
 						case STAR:
 						case RPAREN:
 						case ASSIGN:
 						case RCURLY:
 						case BAND:
 						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 LOR:
 						case LAND:
 						case BOR:
 						case BXOR:
 						case NOT_EQUAL:
 						case EQUAL:
 						case LE:
 						case GE:
 						case LITERAL_instanceof:
 						case SL:
 						case PLUS:
 						case MINUS:
 						case DIV:
 						case MOD:
 						case INC:
 						case DEC:
 						{
 							break;
 						}
 						default:
 						{
 							throw new NoViableAltException(LT(1), getFilename());
 						}
 						}
 						}
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 			}
 			else if ((LA(1)==DOT) && (LA(2)==LITERAL_this)) {
 				AST tmp227_AST = null;
 				tmp227_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp227_AST);
 				match(DOT);
 				AST tmp228_AST = null;
 				tmp228_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp228_AST);
 				match(LITERAL_this);
 			}
 			else if ((LA(1)==DOT) && (LA(2)==LITERAL_new)) {
 				AST tmp229_AST = null;
 				tmp229_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp229_AST);
 				match(DOT);
 				newExpression();
 				astFactory.addASTChild(currentAST, returnAST);
 			}
 			else if ((LA(1)==LBRACK)) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(INDEX_OP);
 				}
 				expression();
 				astFactory.addASTChild(currentAST, returnAST);
 				match(RBRACK);
 			}
 			else {
 				break _loop286;
 			}
 			
 		} while (true);
 		}
 		{
 		switch ( LA(1)) {
 		case INC:
 		{
 			in = LT(1);
 			in_AST = astFactory.create(in);
 			astFactory.makeASTRoot(currentAST, in_AST);
 			match(INC);
 			if ( inputState.guessing==0 ) {
 				in_AST.setType(POST_INC);
 			}
 			break;
 		}
 		case DEC:
 		{
 			de = LT(1);
 			de_AST = astFactory.create(de);
 			astFactory.makeASTRoot(currentAST, de_AST);
 			match(DEC);
 			if ( inputState.guessing==0 ) {
 				de_AST.setType(POST_DEC);
 			}
 			break;
 		}
 		case SEMI:
 		case RBRACK:
 		case QUESTION:
 		case LT:
 		case COMMA:
 		case GT:
 		case SR:
 		case BSR:
 		case STAR:
 		case RPAREN:
 		case ASSIGN:
 		case RCURLY:
 		case BAND:
 		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 LOR:
 		case LAND:
 		case BOR:
 		case BXOR:
 		case NOT_EQUAL:
 		case EQUAL:
 		case LE:
 		case GE:
 		case LITERAL_instanceof:
 		case SL:
 		case PLUS:
 		case MINUS:
 		case DIV:
 		case MOD:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		postfixExpression_AST = (AST)currentAST.root;
 		returnAST = postfixExpression_AST;
 	}
 	
 	public final void primaryExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST primaryExpression_AST = null;
 		Token  lbt = null;
 		AST lbt_AST = null;
 		
 		switch ( LA(1)) {
 		case IDENT:
 		case LT:
 		{
 			identPrimary();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
 				AST tmp231_AST = null;
 				tmp231_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp231_AST);
 				match(DOT);
 				AST tmp232_AST = null;
 				tmp232_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp232_AST);
 				match(LITERAL_class);
 			}
 			else if ((_tokenSet_46.member(LA(1))) && (_tokenSet_47.member(LA(2)))) {
 			}
 			else {
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			
 			}
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case NUM_INT:
 		case STRING_LITERAL:
 		case NUM_FLOAT:
 		case NUM_LONG:
 		case NUM_DOUBLE:
 		{
 			constant();
 			astFactory.addASTChild(currentAST, returnAST);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_true:
 		{
 			AST tmp233_AST = null;
 			tmp233_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp233_AST);
 			match(LITERAL_true);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_false:
 		{
 			AST tmp234_AST = null;
 			tmp234_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp234_AST);
 			match(LITERAL_false);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_null:
 		{
 			AST tmp235_AST = null;
 			tmp235_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp235_AST);
 			match(LITERAL_null);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_new:
 		{
 			newExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_this:
 		{
 			AST tmp236_AST = null;
 			tmp236_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp236_AST);
 			match(LITERAL_this);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LITERAL_super:
 		{
 			AST tmp237_AST = null;
 			tmp237_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp237_AST);
 			match(LITERAL_super);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		case LPAREN:
 		{
 			match(LPAREN);
 			assignmentExpression();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			primaryExpression_AST = (AST)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();
 			astFactory.addASTChild(currentAST, returnAST);
 			{
 			_loop291:
 			do {
 				if ((LA(1)==LBRACK)) {
 					lbt = LT(1);
 					lbt_AST = astFactory.create(lbt);
 					astFactory.makeASTRoot(currentAST, lbt_AST);
 					match(LBRACK);
 					if ( inputState.guessing==0 ) {
 						lbt_AST.setType(ARRAY_DECLARATOR);
 					}
 					match(RBRACK);
 				}
 				else {
 					break _loop291;
 				}
 				
 			} while (true);
 			}
 			AST tmp241_AST = null;
 			tmp241_AST = astFactory.create(LT(1));
 			astFactory.makeASTRoot(currentAST, tmp241_AST);
 			match(DOT);
 			AST tmp242_AST = null;
 			tmp242_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp242_AST);
 			match(LITERAL_class);
 			primaryExpression_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		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
  *
  */
 	public final void newExpression() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST newExpression_AST = null;
 		
 		AST tmp243_AST = null;
 		tmp243_AST = astFactory.create(LT(1));
 		astFactory.makeASTRoot(currentAST, tmp243_AST);
 		match(LITERAL_new);
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeArguments();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		case IDENT:
 		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:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		type();
 		astFactory.addASTChild(currentAST, returnAST);
 		{
 		switch ( LA(1)) {
 		case LPAREN:
 		{
 			match(LPAREN);
 			argList();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			{
 			switch ( LA(1)) {
 			case LCURLY:
 			{
 				classBlock();
 				astFactory.addASTChild(currentAST, returnAST);
 				break;
 			}
 			case SEMI:
 			case LBRACK:
 			case RBRACK:
 			case DOT:
 			case QUESTION:
 			case LT:
 			case COMMA:
 			case GT:
 			case SR:
 			case BSR:
 			case STAR:
 			case RPAREN:
 			case ASSIGN:
 			case RCURLY:
 			case BAND:
 			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 LOR:
 			case LAND:
 			case BOR:
 			case BXOR:
 			case NOT_EQUAL:
 			case EQUAL:
 			case LE:
 			case GE:
 			case LITERAL_instanceof:
 			case SL:
 			case PLUS:
 			case MINUS:
 			case DIV:
 			case MOD:
 			case INC:
 			case DEC:
 			{
 				break;
 			}
 			default:
 			{
 				throw new NoViableAltException(LT(1), getFilename());
 			}
 			}
 			}
 			break;
 		}
 		case LBRACK:
 		{
 			newArrayDeclarator();
 			astFactory.addASTChild(currentAST, returnAST);
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		newExpression_AST = (AST)currentAST.root;
 		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.
  */
 	public final void identPrimary() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST identPrimary_AST = null;
 		AST ta1_AST = null;
 		AST ta2_AST = null;
 		Token  lp = null;
 		AST lp_AST = null;
 		Token  lbc = null;
 		AST lbc_AST = null;
 		
 		{
 		switch ( LA(1)) {
 		case LT:
 		{
 			typeArguments();
 			ta1_AST = (AST)returnAST;
 			break;
 		}
 		case IDENT:
 		{
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		}
 		AST tmp246_AST = null;
 		tmp246_AST = astFactory.create(LT(1));
 		astFactory.addASTChild(currentAST, tmp246_AST);
 		match(IDENT);
 		{
 		_loop299:
 		do {
 			boolean synPredMatched297 = false;
 			if (((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==LT))) {
 				int _m297 = mark();
 				synPredMatched297 = true;
 				inputState.guessing++;
 				try {
 					{
 					match(DOT);
 					{
 					switch ( LA(1)) {
 					case LT:
 					{
 						typeArguments();
 						break;
 					}
 					case IDENT:
 					{
 						break;
 					}
 					default:
 					{
 						throw new NoViableAltException(LT(1), getFilename());
 					}
 					}
 					}
 					match(IDENT);
 					}
 				}
 				catch (RecognitionException pe) {
 					synPredMatched297 = false;
 				}
 				rewind(_m297);
 				inputState.guessing--;
 			}
 			if ( synPredMatched297 ) {
 				AST tmp247_AST = null;
 				tmp247_AST = astFactory.create(LT(1));
 				astFactory.makeASTRoot(currentAST, tmp247_AST);
 				match(DOT);
 				{
 				switch ( LA(1)) {
 				case LT:
 				{
 					typeArguments();
 					ta2_AST = (AST)returnAST;
 					break;
 				}
 				case IDENT:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				AST tmp248_AST = null;
 				tmp248_AST = astFactory.create(LT(1));
 				astFactory.addASTChild(currentAST, tmp248_AST);
 				match(IDENT);
 			}
 			else if (((_tokenSet_48.member(LA(1))) && (_tokenSet_47.member(LA(2))))&&(false)) {
 			}
 			else {
 				break _loop299;
 			}
 			
 		} while (true);
 		}
 		{
 		if ((LA(1)==LPAREN)) {
 			{
 			lp = LT(1);
 			lp_AST = astFactory.create(lp);
 			astFactory.makeASTRoot(currentAST, lp_AST);
 			match(LPAREN);
 			if ( inputState.guessing==0 ) {
 				lp_AST.setType(METHOD_CALL);
 			}
 			if ( inputState.guessing==0 ) {
 				if (ta2_AST != null) astFactory.addASTChild(currentAST, ta2_AST);
 			}
 			if ( inputState.guessing==0 ) {
 				if (ta2_AST == null) astFactory.addASTChild(currentAST, ta1_AST);
 			}
 			argList();
 			astFactory.addASTChild(currentAST, returnAST);
 			match(RPAREN);
 			}
 		}
 		else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 			{
 			int _cnt303=0;
 			_loop303:
 			do {
 				if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
 					lbc = LT(1);
 					lbc_AST = astFactory.create(lbc);
 					astFactory.makeASTRoot(currentAST, lbc_AST);
 					match(LBRACK);
 					if ( inputState.guessing==0 ) {
 						lbc_AST.setType(ARRAY_DECLARATOR);
 					}
 					match(RBRACK);
 				}
 				else {
 					if ( _cnt303>=1 ) { break _loop303; } else {throw new NoViableAltException(LT(1), getFilename());}
 				}
 				
 				_cnt303++;
 			} while (true);
 			}
 		}
 		else if ((_tokenSet_46.member(LA(1))) && (_tokenSet_47.member(LA(2)))) {
 		}
 		else {
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		
 		}
 		identPrimary_AST = (AST)currentAST.root;
 		returnAST = identPrimary_AST;
 	}
 	
 	public final void constant() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST constant_AST = null;
 		
 		switch ( LA(1)) {
 		case NUM_INT:
 		{
 			AST tmp251_AST = null;
 			tmp251_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp251_AST);
 			match(NUM_INT);
 			constant_AST = (AST)currentAST.root;
 			break;
 		}
 		case STRING_LITERAL:
 		{
 			AST tmp252_AST = null;
 			tmp252_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp252_AST);
 			match(STRING_LITERAL);
 			constant_AST = (AST)currentAST.root;
 			break;
 		}
 		case NUM_FLOAT:
 		{
 			AST tmp253_AST = null;
 			tmp253_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp253_AST);
 			match(NUM_FLOAT);
 			constant_AST = (AST)currentAST.root;
 			break;
 		}
 		case NUM_LONG:
 		{
 			AST tmp254_AST = null;
 			tmp254_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp254_AST);
 			match(NUM_LONG);
 			constant_AST = (AST)currentAST.root;
 			break;
 		}
 		case NUM_DOUBLE:
 		{
 			AST tmp255_AST = null;
 			tmp255_AST = astFactory.create(LT(1));
 			astFactory.addASTChild(currentAST, tmp255_AST);
 			match(NUM_DOUBLE);
 			constant_AST = (AST)currentAST.root;
 			break;
 		}
 		default:
 		{
 			throw new NoViableAltException(LT(1), getFilename());
 		}
 		}
 		returnAST = constant_AST;
 	}
 	
 	public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
 		
 		returnAST = null;
 		ASTPair currentAST = new ASTPair();
 		AST newArrayDeclarator_AST = null;
 		Token  lb = null;
 		AST lb_AST = null;
 		
 		{
 		int _cnt313=0;
 		_loop313:
 		do {
 			if ((LA(1)==LBRACK) && (_tokenSet_49.member(LA(2)))) {
 				lb = LT(1);
 				lb_AST = astFactory.create(lb);
 				astFactory.makeASTRoot(currentAST, lb_AST);
 				match(LBRACK);
 				if ( inputState.guessing==0 ) {
 					lb_AST.setType(ARRAY_DECLARATOR);
 				}
 				{
 				switch ( LA(1)) {
 				case IDENT:
 				case LITERAL_super:
 				case LT:
 				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 LPAREN:
 				case LITERAL_this:
 				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 STRING_LITERAL:
 				case NUM_FLOAT:
 				case NUM_LONG:
 				case NUM_DOUBLE:
 				{
 					expression();
 					astFactory.addASTChild(currentAST, returnAST);
 					break;
 				}
 				case RBRACK:
 				{
 					break;
 				}
 				default:
 				{
 					throw new NoViableAltException(LT(1), getFilename());
 				}
 				}
 				}
 				match(RBRACK);
 			}
 			else {
 				if ( _cnt313>=1 ) { break _loop313; } else {throw new NoViableAltException(LT(1), getFilename());}
 			}
 			
 			_cnt313++;
 		} while (true);
 		}
 		newArrayDeclarator_AST = (AST)currentAST.root;
 		returnAST = newArrayDeclarator_AST;
 	}
 	
 	
 	public static final String[] _tokenNames = {
 		"<0>",
 		"EOF",
 		"<2>",
 		"NULL_TREE_LOOKAHEAD",
 		"BLOCK",
 		"MODIFIERS",
 		"OBJBLOCK",
 		"SLIST",
 		"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",
 		"VARIABLE_PARAMETER_DEF",
 		"STATIC_IMPORT",
 		"ENUM_DEF",
 		"ENUM_CONSTANT_DEF",
 		"FOR_EACH_CLAUSE",
 		"ANNOTATION_DEF",
 		"ANNOTATIONS",
 		"ANNOTATION",
 		"ANNOTATION_MEMBER_VALUE_PAIR",
 		"ANNOTATION_FIELD_DEF",
 		"ANNOTATION_ARRAY_INIT",
 		"TYPE_ARGUMENTS",
 		"TYPE_ARGUMENT",
 		"TYPE_PARAMETERS",
 		"TYPE_PARAMETER",
 		"WILDCARD_TYPE",
 		"TYPE_UPPER_BOUNDS",
 		"TYPE_LOWER_BOUNDS",
 		"\"package\"",
 		"SEMI",
 		"\"import\"",
 		"\"static\"",
 		"LBRACK",
 		"RBRACK",
 		"IDENT",
 		"DOT",
 		"QUESTION",
 		"\"extends\"",
 		"\"super\"",
 		"LT",
 		"COMMA",
 		"GT",
 		"SR",
 		"BSR",
 		"\"void\"",
 		"\"boolean\"",
 		"\"byte\"",
 		"\"char\"",
 		"\"short\"",
 		"\"int\"",
 		"\"float\"",
 		"\"long\"",
 		"\"double\"",
 		"STAR",
 		"\"private\"",
 		"\"public\"",
 		"\"protected\"",
 		"\"transient\"",
 		"\"native\"",
 		"\"threadsafe\"",
 		"\"synchronized\"",
 		"\"volatile\"",
 		"AT",
 		"LPAREN",
 		"RPAREN",
 		"ASSIGN",
 		"LCURLY",
 		"RCURLY",
 		"\"class\"",
 		"\"interface\"",
 		"\"enum\"",
 		"BAND",
 		"\"default\"",
 		"\"implements\"",
 		"\"this\"",
 		"\"throws\"",
 		"TRIPLE_DOT",
 		"COLON",
 		"\"if\"",
 		"\"else\"",
 		"\"while\"",
 		"\"break\"",
 		"\"continue\"",
 		"\"return\"",
 		"\"switch\"",
 		"\"throw\"",
 		"\"assert\"",
 		"\"for\"",
 		"\"case\"",
 		"\"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",
 		"LOR",
 		"LAND",
 		"BOR",
 		"BXOR",
 		"NOT_EQUAL",
 		"EQUAL",
 		"LE",
 		"GE",
 		"\"instanceof\"",
 		"SL",
 		"PLUS",
 		"MINUS",
 		"DIV",
 		"MOD",
 		"INC",
 		"DEC",
 		"BNOT",
 		"LNOT",
 		"\"true\"",
 		"\"false\"",
 		"\"null\"",
 		"\"new\"",
 		"NUM_INT",
 		"STRING_LITERAL",
 		"NUM_FLOAT",
 		"NUM_LONG",
 		"NUM_DOUBLE",
 		"WS",
 		"SL_COMMENT",
 		"ML_COMMENT",
 		"ESC",
 		"HEX_DIGIT",
 		"VOCAB",
 		"EXPONENT",
 		"FLOAT_SUFFIX"
 	};
 	
 	protected void buildTokenTypeASTClassMap() {
 		tokenTypeToASTClassMap=null;
 	};
 	
 	private static final long[] mk_tokenSet_0() {
 		long[] data = { -4611684094282039294L, 966359252993L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
 	private static final long[] mk_tokenSet_1() {
 		long[] data = { 4611687942572736514L, 966359253001L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
 	private static final long[] mk_tokenSet_2() {
 		long[] data = { 4611687942572736512L, 966359252993L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
 	private static final long[] mk_tokenSet_3() {
 		long[] data = { 4611687942572736514L, 966359252993L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
 	private static final long[] mk_tokenSet_4() {
 		long[] data = { 1924145348608L, 2139095041L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
 	private static final long[] mk_tokenSet_5() {
 		long[] data = { 0L, 4186152L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
 	private static final long[] mk_tokenSet_6() {
 		long[] data = { 4611686018427387904L, -2305723029298086146L, 16383L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
 	private static final long[] mk_tokenSet_7() {
 		long[] data = { 6917530951786430464L, -1729399849096314881L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
 	private static final long[] mk_tokenSet_8() {
 		long[] data = { 0L, 14332310060762L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
 	private static final long[] mk_tokenSet_9() {
 		long[] data = { 4611687942572736512L, -2305722062934638593L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
 	private static final long[] mk_tokenSet_10() {
 		long[] data = { 0L, 8836899398024L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
 	private static final long[] mk_tokenSet_11() {
 		long[] data = { 0L, 9979364900282L, 34359738112L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
 	private static final long[] mk_tokenSet_12() {
 		long[] data = { 0L, 8802539659656L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
 	private static final long[] mk_tokenSet_13() {
 		long[] data = { 0L, 4432410443336L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
 	private static final long[] mk_tokenSet_14() {
 		long[] data = { 4611687942572736512L, 5471784132955L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
 	private static final long[] mk_tokenSet_15() {
 		long[] data = { 1924145348608L, 966363439369L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
 	private static final long[] mk_tokenSet_16() {
 		long[] data = { 1924145348608L, 970658406683L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
 	private static final long[] mk_tokenSet_17() {
 		long[] data = { 0L, 4186120L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
 	private static final long[] mk_tokenSet_18() {
 		long[] data = { 0L, 282L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
 	private static final long[] mk_tokenSet_19() {
 		long[] data = { 4611686018427387904L, 17179869698L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
 	private static final long[] mk_tokenSet_20() {
 		long[] data = { 274877906944L, 2151669768L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
 	private static final long[] mk_tokenSet_21() {
 		long[] data = { 0L, 2151670042L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
 	private static final long[] mk_tokenSet_22() {
 		long[] data = { 0L, 35186523758874L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
 	private static final long[] mk_tokenSet_23() {
 		long[] data = { 4611687942572736512L, 431932328239948169L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
 	private static final long[] mk_tokenSet_24() {
 		long[] data = { 0L, 8796093022592L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
 	private static final long[] mk_tokenSet_25() {
 		long[] data = { 0L, 4299153448L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
 	private static final long[] mk_tokenSet_26() {
 		long[] data = { 4611687942572736512L, 431932396959424905L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
 	private static final long[] mk_tokenSet_27() {
 		long[] data = { 4611687942572736512L, -1873838302180672069L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
 	private static final long[] mk_tokenSet_28() {
 		long[] data = { 4611687942572736512L, 576331259035246985L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
 	private static final long[] mk_tokenSet_29() {
 		long[] data = { 4611687942572736512L, -57183194579525L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
 	private static final long[] mk_tokenSet_30() {
 		long[] data = { 1924145348608L, 4290764809L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
 	private static final long[] mk_tokenSet_31() {
 		long[] data = { 1924145348608L, 4290765083L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
 	private static final long[] mk_tokenSet_32() {
 		long[] data = { 0L, 8800392176008L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
 	private static final long[] mk_tokenSet_33() {
 		long[] data = { 4611686018427387904L, -2305833092125819462L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
 	private static final long[] mk_tokenSet_34() {
 		long[] data = { 1924145348608L, 141725532161L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
 	private static final long[] mk_tokenSet_35() {
 		long[] data = { 1924145348608L, 141725532169L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
 	private static final long[] mk_tokenSet_36() {
 		long[] data = { 4611687942572736512L, 8804678754697L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
 	private static final long[] mk_tokenSet_37() {
 		long[] data = { 4611687942572736512L, -2305833087839240261L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
 	private static final long[] mk_tokenSet_38() {
 		long[] data = { 0L, 79169136353672L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
 	private static final long[] mk_tokenSet_39() {
 		long[] data = { 4611686018427387904L, -2305833092125818950L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
 	private static final long[] mk_tokenSet_40() {
 		long[] data = { 0L, 1280L, 49152L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
 	private static final long[] mk_tokenSet_41() {
 		long[] data = { 0L, 6144L, 131072L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
 	private static final long[] mk_tokenSet_42() {
 		long[] data = { 0L, 4194304L, 3145728L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
 	private static final long[] mk_tokenSet_43() {
 		long[] data = { 0L, 8800392176008L, 34292629504L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
 	private static final long[] mk_tokenSet_44() {
 		long[] data = { 4611686018427387904L, -2305762646072229954L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
 	private static final long[] mk_tokenSet_45() {
 		long[] data = { 0L, 392L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
 	private static final long[] mk_tokenSet_46() {
 		long[] data = { 4611686018427387904L, -2305771446464405706L, 16777215L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
 	private static final long[] mk_tokenSet_47() {
 		long[] data = { 6917530951786430464L, -1729439431514914881L, 34359738367L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
 	private static final long[] mk_tokenSet_48() {
 		long[] data = { 4611686018427387904L, -2305771442169438410L, 16777215L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
 	private static final long[] mk_tokenSet_49() {
 		long[] data = { 0L, 8800392176012L, 34356330496L, 0L, 0L, 0L};
 		return data;
 	}
 	public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
 	
 	}