// $ANTLR 2.7.7 (20060906): "java.g" -> "GeneratedJavaRecognizer.java"$

package com.puppycrawl.tools.checkstyle.grammars;

import com.puppycrawl.tools.checkstyle.api.DetailAST;
import java.text.MessageFormat;
import antlr.CommonHiddenStreamToken;

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
 *
 * This grammar is in the PUBLIC DOMAIN
 */
public class GeneratedJavaRecognizer extends antlr.LLkParser       implements GeneratedJavaTokenTypes
 {

    /**
     * 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;

    /**
     * Counts the number of '>' characters that have been seen but
     * have not yet been associated with the end of a typeParameters or
     * typeArguments production. This is necessary because SR and BSR
     * tokens have significance (the extra '>' characters) not only for the production
     * that sees them but also productions higher in the stack (possibly right up to an outer-most
     * typeParameters production). As the stack of the typeArguments/typeParameters productions
     * unwind, any '>' characters seen prematurely through SRs or BSRs are reconciled.
     */
    private int gtToReconcile = 0;

    /**
     * The most recently seen gt sequence (GT, SR or BSR)
     * encountered in any type argument or type parameter production.
     * We retain this so we can keep manage the synthetic GT tokens/
     * AST nodes we emit to have '<' & '>' balanced trees when encountering
     * SR and BSR tokens.
     */
    private DetailAST currentGtSequence = null;

    /**
     * Consume a sequence of '>' characters (GT, SR or BSR)
     * and match these against the '<' characters seen.
     */
    private void consumeCurrentGtSequence(DetailAST gtSequence)
    {
        currentGtSequence = gtSequence;
        gtToReconcile += currentGtSequence.getText().length();
        ltCounter -= currentGtSequence.getText().length();
    }

    /**
     * Emits a single GT AST node with the line and column correctly
     * set to its position in the source file. This must only
     * ever be called when a typeParameters or typeArguments production
     * is ending and there is at least one GT character to be emitted.
     *
     * @see #areThereGtsToEmit
     */
    private DetailAST emitSingleGt()
    {
        gtToReconcile -= 1;
        CommonHiddenStreamToken gtToken = new CommonHiddenStreamToken(GENERIC_END, ">");
        gtToken.setLine(currentGtSequence.getLineNo());
        gtToken.setColumn(currentGtSequence.getColumnNo()
                            + (currentGtSequence.getText().length() - gtToReconcile));
        return (DetailAST)astFactory.create(gtToken);
    }

    /**
     * @return true if there is at least one '>' seen but
     * not reconciled with the end of a typeParameters or
     * typeArguments production; returns false otherwise
     */
    private boolean areThereGtsToEmit()
    {
        return (gtToReconcile > 0);
    }

    /**
     * @return true if there is exactly one '>' seen but
     * not reconciled with the end of a typeParameters
     * production; returns false otherwise
     */
    private boolean isThereASingleGtToEmit()
    {
        return (gtToReconcile == 1);
    }

    /**
     * @return true if the '<' and '>' are evenly matched
     * at the current typeParameters/typeArguments nested depth
     */
    private boolean areLtsAndGtsBalanced(int currentLtLevel)
    {
        return ((currentLtLevel != 0) || ltCounter == currentLtLevel);
    }

protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public GeneratedJavaRecognizer(TokenBuffer tokenBuf) {
  this(tokenBuf,2);
}

protected GeneratedJavaRecognizer(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public GeneratedJavaRecognizer(TokenStream lexer) {
  this(lexer,2);
}

public GeneratedJavaRecognizer(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)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_1.member(LA(2)))) {
                                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;
                
                {
                _loop68:
                do {
                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
                                annotation();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop68;
                        }
                        
                } 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);
                        AST tmp2_AST = null;
                        tmp2_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp2_AST);
                        match(SEMI);
                        packageDefinition_AST = (AST)currentAST.root;
                }
                catch (RecognitionException ex) {
                        if (inputState.guessing==0) {
                                reportError(ex);
                                recover(ex,_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;
                
                try {      // for error handling
                        switch ( LA(1)) {
                        case LITERAL_import:
                        {
                                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:
                                {
                                        AST tmp3_AST = null;
                                        tmp3_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp3_AST);
                                        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);
                                AST tmp4_AST = null;
                                tmp4_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp4_AST);
                                match(SEMI);
                                importDefinition_AST = (AST)currentAST.root;
                                break;
                        }
                        case SEMI:
                        {
                                AST tmp5_AST = null;
                                tmp5_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp5_AST);
                                match(SEMI);
                                importDefinition_AST = (AST)currentAST.root;
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                }
                catch (RecognitionException ex) {
                        if (inputState.guessing==0) {
                                reportError(ex);
                                recover(ex,_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_private:
                        case LITERAL_public:
                        case LITERAL_protected:
                        case LITERAL_static:
                        case LITERAL_transient:
                        case LITERAL_native:
                        case LITERAL_synchronized:
                        case LITERAL_volatile:
                        case LITERAL_class:
                        case LITERAL_interface:
                        case LITERAL_default:
                        case ENUM:
                        case AT:
                        {
                                modifiers();
                                m_AST = (AST)returnAST;
                                typeDefinitionInternal(m_AST);
                                astFactory.addASTChild(currentAST, returnAST);
                                typeDefinition_AST = (AST)currentAST.root;
                                break;
                        }
                        case SEMI:
                        {
                                AST tmp6_AST = null;
                                tmp6_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp6_AST);
                                match(SEMI);
                                typeDefinition_AST = (AST)currentAST.root;
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                }
                catch (RecognitionException ex) {
                        if (inputState.guessing==0) {
                                reportError(ex);
                                recover(ex,_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 tmp7_AST = null;
                tmp7_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp7_AST);
                match(IDENT);
                {
                _loop54:
                do {
                        if ((LA(1)==DOT)) {
                                AST tmp8_AST = null;
                                tmp8_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp8_AST);
                                match(DOT);
                                AST tmp9_AST = null;
                                tmp9_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp9_AST);
                                match(IDENT);
                        }
                        else {
                                break _loop54;
                        }
                        
                } 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 tmp10_AST = null;
                tmp10_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp10_AST);
                match(IDENT);
                {
                _loop57:
                do {
                        if ((LA(1)==DOT) && (LA(2)==IDENT)) {
                                AST tmp11_AST = null;
                                tmp11_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp11_AST);
                                match(DOT);
                                AST tmp12_AST = null;
                                tmp12_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp12_AST);
                                match(IDENT);
                        }
                        else {
                                break _loop57;
                        }
                        
                } while (true);
                }
                {
                switch ( LA(1)) {
                case DOT:
                {
                        AST tmp13_AST = null;
                        tmp13_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp13_AST);
                        match(DOT);
                        AST tmp14_AST = null;
                        tmp14_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp14_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;
                
                {
                _loop61:
                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 _loop61;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        modifiers_AST = (AST)currentAST.root;
                        modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).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 modifiers
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeDefinitionInternal_AST = null;
                
                switch ( LA(1)) {
                case LITERAL_class:
                {
                        classDefinition(modifiers);
                        astFactory.addASTChild(currentAST, returnAST);
                        typeDefinitionInternal_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_interface:
                {
                        interfaceDefinition(modifiers);
                        astFactory.addASTChild(currentAST, returnAST);
                        typeDefinitionInternal_AST = (AST)currentAST.root;
                        break;
                }
                case ENUM:
                {
                        enumDefinition(modifiers);
                        astFactory.addASTChild(currentAST, returnAST);
                        typeDefinitionInternal_AST = (AST)currentAST.root;
                        break;
                }
                case AT:
                {
                        annotationDefinition(modifiers);
                        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;
                Token  c = null;
                AST c_AST = null;
                AST tp_AST = null;
                AST sc_AST = null;
                AST ic_AST = null;
                AST cb_AST = null;
                
                c = LT(1);
                c_AST = astFactory.create(c);
                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(8)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).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;
                Token  i = null;
                AST i_AST = null;
                AST tp_AST = null;
                AST ie_AST = null;
                AST cb_AST = null;
                
                i = LT(1);
                i_AST = astFactory.create(i);
                match(LITERAL_interface);
                AST tmp16_AST = null;
                tmp16_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;
                classBlock();
                cb_AST = (AST)returnAST;
                if ( inputState.guessing==0 ) {
                        interfaceDefinition_AST = (AST)currentAST.root;
                        interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(tmp16_AST).add(tp_AST).add(ie_AST).add(cb_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;
                Token  e = null;
                AST e_AST = null;
                AST ic_AST = null;
                AST eb_AST = null;
                
                e = LT(1);
                e_AST = astFactory.create(e);
                match(ENUM);
                AST tmp17_AST = null;
                tmp17_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(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(tmp17_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;
                Token  a = null;
                AST a_AST = null;
                Token  i = null;
                AST i_AST = null;
                AST ab_AST = null;
                
                a = LT(1);
                a_AST = astFactory.create(a);
                match(AT);
                i = LT(1);
                i_AST = astFactory.create(i);
                match(LITERAL_interface);
                AST tmp18_AST = null;
                tmp18_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(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(tmp18_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 typeSpec(
                boolean addImagNode
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeSpec_AST = null;
                
                switch ( LA(1)) {
                case IDENT:
                case AT:
                {
                        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 classTypeSpec(
                boolean addImagNode
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST classTypeSpec_AST = null;
                Token  lb = null;
                AST lb_AST = null;
                
                classOrInterfaceType(addImagNode);
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop18:
                do {
                        if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
                                {
                                if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
                                        annotations();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                                lb = LT(1);
                                lb_AST = astFactory.create(lb);
                                astFactory.makeASTRoot(currentAST, lb_AST);
                                match(LBRACK);
                                if ( inputState.guessing==0 ) {
                                        lb_AST.setType(ARRAY_DECLARATOR);
                                }
                                AST tmp19_AST = null;
                                tmp19_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp19_AST);
                                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(astFactory.create(TYPE,"TYPE")).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;
                
                builtInType();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop48:
                do {
                        if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
                                {
                                if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
                                        annotations();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                                lb = LT(1);
                                lb_AST = astFactory.create(lb);
                                astFactory.makeASTRoot(currentAST, lb_AST);
                                match(LBRACK);
                                if ( inputState.guessing==0 ) {
                                        lb_AST.setType(ARRAY_DECLARATOR);
                                }
                                AST tmp20_AST = null;
                                tmp20_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp20_AST);
                                match(RBRACK);
                        }
                        else {
                                break _loop48;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        builtInTypeSpec_AST = (AST)currentAST.root;
                        
                        if ( addImagNode ) {
                        builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).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;
                
                {
                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
                        annotations();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                AST tmp21_AST = null;
                tmp21_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp21_AST);
                match(IDENT);
                {
                if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
                        typeArguments(addImagNode);
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                _loop25:
                do {
                        if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==AT)) {
                                AST tmp22_AST = null;
                                tmp22_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp22_AST);
                                match(DOT);
                                {
                                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
                                        annotations();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                                AST tmp23_AST = null;
                                tmp23_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp23_AST);
                                match(IDENT);
                                {
                                if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
                                        typeArguments(addImagNode);
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                        }
                        else {
                                break _loop25;
                        }
                        
                } while (true);
                }
                classOrInterfaceType_AST = (AST)currentAST.root;
                returnAST = classOrInterfaceType_AST;
        }
        
        public final void typeArguments(
                boolean addImagNode
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeArguments_AST = null;
                Token  lt = null;
                AST lt_AST = null;
                int currentLtLevel = 0;
                
                if ( inputState.guessing==0 ) {
                        currentLtLevel = ltCounter;
                }
                lt = LT(1);
                lt_AST = astFactory.create(lt);
                astFactory.addASTChild(currentAST, lt_AST);
                match(LT);
                if ( inputState.guessing==0 ) {
                        lt_AST.setType(GENERIC_START); ;ltCounter++;
                }
                {
                if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
                        typeArgument(addImagNode);
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop37:
                        do {
                                if (((LA(1)==COMMA) && (_tokenSet_7.member(LA(2))))&&(gtToReconcile == 0)) {
                                        AST tmp24_AST = null;
                                        tmp24_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp24_AST);
                                        match(COMMA);
                                        typeArgument(addImagNode);
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop37;
                                }
                                
                        } while (true);
                        }
                }
                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                if ((_tokenSet_8.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
                        typeArgumentsOrParametersEnd();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                if ( inputState.guessing==0 ) {
                        
                        if (areThereGtsToEmit())
                        {
                        astFactory.addASTChild(currentAST, emitSingleGt());
                        }
                        
                }
                if (!(areLtsAndGtsBalanced(currentLtLevel)))
                  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
                if ( inputState.guessing==0 ) {
                        typeArguments_AST = (AST)currentAST.root;
                        typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).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 typeArgument(
                boolean addImagNode
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeArgument_AST = null;
                
                {
                {
                if (((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
                        annotations();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                switch ( LA(1)) {
                case IDENT:
                case AT:
                {
                        classTypeSpec(addImagNode);
                        astFactory.addASTChild(currentAST, returnAST);
                        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);
                        break;
                }
                case QUESTION:
                {
                        wildcardType(addImagNode);
                        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(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).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(
                boolean addImagNode
        ) 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.addASTChild(currentAST, q_AST);
                match(QUESTION);
                if ( inputState.guessing==0 ) {
                        q_AST.setType(WILDCARD_TYPE);
                }
                {
                boolean synPredMatched33 = false;
                if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_9.member(LA(2))))) {
                        int _m33 = mark();
                        synPredMatched33 = 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) {
                                synPredMatched33 = false;
                        }
                        rewind(_m33);
inputState.guessing--;
                }
                if ( synPredMatched33 ) {
                        typeArgumentBounds(addImagNode);
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                wildcardType_AST = (AST)currentAST.root;
                returnAST = wildcardType_AST;
        }
        
        public final void typeArgumentBounds(
                boolean addImagNode
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeArgumentBounds_AST = null;
                Token  e = null;
                AST e_AST = null;
                Token  s = null;
                AST s_AST = null;
                Token  lb = null;
                AST lb_AST = null;
                
                {
                switch ( LA(1)) {
                case LITERAL_extends:
                {
                        e = LT(1);
                        e_AST = astFactory.create(e);
                        astFactory.makeASTRoot(currentAST, e_AST);
                        match(LITERAL_extends);
                        if ( inputState.guessing==0 ) {
                                e_AST.setType(TYPE_UPPER_BOUNDS);
                        }
                        break;
                }
                case LITERAL_super:
                {
                        s = LT(1);
                        s_AST = astFactory.create(s);
                        astFactory.makeASTRoot(currentAST, s_AST);
                        match(LITERAL_super);
                        if ( inputState.guessing==0 ) {
                                s_AST.setType(TYPE_LOWER_BOUNDS);
                        }
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                {
                switch ( LA(1)) {
                case IDENT:
                case AT:
                {
                        classOrInterfaceType(addImagNode);
                        astFactory.addASTChild(currentAST, returnAST);
                        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);
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                {
                _loop44:
                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);
                                }
                                AST tmp25_AST = null;
                                tmp25_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp25_AST);
                                match(RBRACK);
                        }
                        else {
                                break _loop44;
                        }
                        
                } while (true);
                }
                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;
                Token  g = null;
                AST g_AST = null;
                Token  sr = null;
                AST sr_AST = null;
                Token  bsr = null;
                AST bsr_AST = null;
                
                switch ( LA(1)) {
                case GT:
                {
                        g = LT(1);
                        g_AST = astFactory.create(g);
                        match(GT);
                        if ( inputState.guessing==0 ) {
                                consumeCurrentGtSequence((DetailAST)g_AST);
                        }
                        break;
                }
                case SR:
                {
                        sr = LT(1);
                        sr_AST = astFactory.create(sr);
                        match(SR);
                        if ( inputState.guessing==0 ) {
                                consumeCurrentGtSequence((DetailAST)sr_AST);
                        }
                        break;
                }
                case BSR:
                {
                        bsr = LT(1);
                        bsr_AST = astFactory.create(bsr);
                        match(BSR);
                        if ( inputState.guessing==0 ) {
                                consumeCurrentGtSequence((DetailAST)bsr_AST);
                        }
                        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 tmp26_AST = null;
                        tmp26_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp26_AST);
                        match(LITERAL_void);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_boolean:
                {
                        AST tmp27_AST = null;
                        tmp27_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp27_AST);
                        match(LITERAL_boolean);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_byte:
                {
                        AST tmp28_AST = null;
                        tmp28_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp28_AST);
                        match(LITERAL_byte);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_char:
                {
                        AST tmp29_AST = null;
                        tmp29_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp29_AST);
                        match(LITERAL_char);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_short:
                {
                        AST tmp30_AST = null;
                        tmp30_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp30_AST);
                        match(LITERAL_short);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_int:
                {
                        AST tmp31_AST = null;
                        tmp31_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp31_AST);
                        match(LITERAL_int);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_float:
                {
                        AST tmp32_AST = null;
                        tmp32_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp32_AST);
                        match(LITERAL_float);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_long:
                {
                        AST tmp33_AST = null;
                        tmp33_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp33_AST);
                        match(LITERAL_long);
                        builtInType_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_double:
                {
                        AST tmp34_AST = null;
                        tmp34_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp34_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:
                case AT:
                {
                        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;
        }
        
/** A declaration is the creation of a reference or primitive-type variable
 *  Create a separate Type/Var tree for each var in the var list.
    @throws RecognitionException if recognition problem occurs.
    @throws TokenStreamException if problem occurs while generating a stream of tokens.
 */
        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 variableDefinitions(
                AST mods, AST t
        ) throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST variableDefinitions_AST = null;
                
                variableDeclarator((AST) getASTFactory().dupTree(mods),
                           //dupList as this also copies siblings (like TYPE_ARGUMENTS)
                           (AST) getASTFactory().dupList(t));
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop165:
                do {
                        if ((LA(1)==COMMA)) {
                                AST tmp35_AST = null;
                                tmp35_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp35_AST);
                                match(COMMA);
                                variableDeclarator((AST) getASTFactory().dupTree(mods),
                               //dupList as this also copies siblings (like TYPE_ARGUMENTS)
                               (AST) getASTFactory().dupList(t));
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop165;
                        }
                        
                } while (true);
                }
                variableDefinitions_AST = (AST)currentAST.root;
                returnAST = variableDefinitions_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 tmp36_AST = null;
                        tmp36_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp36_AST);
                        match(LITERAL_private);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_public:
                {
                        AST tmp37_AST = null;
                        tmp37_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp37_AST);
                        match(LITERAL_public);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_protected:
                {
                        AST tmp38_AST = null;
                        tmp38_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp38_AST);
                        match(LITERAL_protected);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_static:
                {
                        AST tmp39_AST = null;
                        tmp39_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp39_AST);
                        match(LITERAL_static);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_transient:
                {
                        AST tmp40_AST = null;
                        tmp40_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp40_AST);
                        match(LITERAL_transient);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case FINAL:
                {
                        AST tmp41_AST = null;
                        tmp41_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp41_AST);
                        match(FINAL);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case ABSTRACT:
                {
                        AST tmp42_AST = null;
                        tmp42_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp42_AST);
                        match(ABSTRACT);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_native:
                {
                        AST tmp43_AST = null;
                        tmp43_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp43_AST);
                        match(LITERAL_native);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_synchronized:
                {
                        AST tmp44_AST = null;
                        tmp44_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp44_AST);
                        match(LITERAL_synchronized);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_volatile:
                {
                        AST tmp45_AST = null;
                        tmp45_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp45_AST);
                        match(LITERAL_volatile);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case STRICTFP:
                {
                        AST tmp46_AST = null;
                        tmp46_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp46_AST);
                        match(STRICTFP);
                        modifier_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_default:
                {
                        AST tmp47_AST = null;
                        tmp47_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp47_AST);
                        match(LITERAL_default);
                        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;
                Token  l = null;
                AST l_AST = null;
                AST args_AST = null;
                Token  r = null;
                AST r_AST = null;
                
                AST tmp48_AST = null;
                tmp48_AST = astFactory.create(LT(1));
                match(AT);
                identifier();
                i_AST = (AST)returnAST;
                {
                switch ( LA(1)) {
                case LPAREN:
                {
                        l = LT(1);
                        l_AST = astFactory.create(l);
                        match(LPAREN);
                        {
                        switch ( LA(1)) {
                        case LITERAL_void:
                        case LITERAL_boolean:
                        case LITERAL_byte:
                        case LITERAL_char:
                        case LITERAL_short:
                        case LITERAL_int:
                        case LITERAL_float:
                        case LITERAL_long:
                        case LITERAL_double:
                        case IDENT:
                        case LCURLY:
                        case LPAREN:
                        case LITERAL_this:
                        case LITERAL_super:
                        case PLUS:
                        case MINUS:
                        case INC:
                        case DEC:
                        case BNOT:
                        case LNOT:
                        case LITERAL_true:
                        case LITERAL_false:
                        case LITERAL_null:
                        case LITERAL_new:
                        case NUM_INT:
                        case CHAR_LITERAL:
                        case STRING_LITERAL:
                        case NUM_FLOAT:
                        case NUM_LONG:
                        case NUM_DOUBLE:
                        case AT:
                        {
                                annotationArguments();
                                args_AST = (AST)returnAST;
                                break;
                        }
                        case RPAREN:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        r = LT(1);
                        r_AST = astFactory.create(r);
                        match(RPAREN);
                        break;
                }
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case LITERAL_package:
                case SEMI:
                case LBRACK:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LITERAL_interface:
                case RCURLY:
                case COMMA:
                case RPAREN:
                case LITERAL_this:
                case LITERAL_default:
                case QUESTION:
                case LT:
                case ENUM:
                case AT:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                if ( inputState.guessing==0 ) {
                        annotation_AST = (AST)currentAST.root;
                        annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp48_AST).add(i_AST).add(l_AST).add(args_AST).add(r_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)) {
                        annotationMemberValuePairs();
                        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;
                
                boolean synPredMatched76 = false;
                if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
                        int _m76 = mark();
                        synPredMatched76 = true;
                        inputState.guessing++;
                        try {
                                {
                                annotationExpression();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched76 = false;
                        }
                        rewind(_m76);
inputState.guessing--;
                }
                if ( synPredMatched76 ) {
                        annotationExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
                }
                else if ((LA(1)==AT) && (LA(2)==IDENT)) {
                        annotation();
                        astFactory.addASTChild(currentAST, returnAST);
                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
                }
                else if ((LA(1)==LCURLY)) {
                        annotationMemberArrayInitializer();
                        astFactory.addASTChild(currentAST, returnAST);
                        annotationMemberValueInitializer_AST = (AST)currentAST.root;
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                returnAST = annotationMemberValueInitializer_AST;
        }
        
        public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST annotationMemberValuePairs_AST = null;
                
                annotationMemberValuePair();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop72:
                do {
                        if ((LA(1)==COMMA)) {
                                AST tmp49_AST = null;
                                tmp49_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp49_AST);
                                match(COMMA);
                                annotationMemberValuePair();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop72;
                        }
                        
                } while (true);
                }
                annotationMemberValuePairs_AST = (AST)currentAST.root;
                returnAST = annotationMemberValuePairs_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;
                Token  a = null;
                AST a_AST = null;
                AST v_AST = null;
                
                i = LT(1);
                i_AST = astFactory.create(i);
                match(IDENT);
                a = LT(1);
                a_AST = astFactory.create(a);
                match(ASSIGN);
                annotationMemberValueInitializer();
                v_AST = (AST)returnAST;
                if ( inputState.guessing==0 ) {
                        annotationMemberValuePair_AST = (AST)currentAST.root;
                        annotationMemberValuePair_AST =
                        (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(a_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 annotationExpression() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST annotationExpression_AST = null;
                
                conditionalExpression();
                astFactory.addASTChild(currentAST, returnAST);
                if ( inputState.guessing==0 ) {
                        annotationExpression_AST = (AST)currentAST.root;
                        annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST));
                        currentAST.root = annotationExpression_AST;
                        currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ?
                                annotationExpression_AST.getFirstChild() : annotationExpression_AST;
                        currentAST.advanceChildToEnd();
                }
                annotationExpression_AST = (AST)currentAST.root;
                returnAST = annotationExpression_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 LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        annotationMemberArrayValueInitializer();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop80:
                        do {
                                if ((LA(1)==COMMA) && (_tokenSet_12.member(LA(2)))) {
                                        AST tmp50_AST = null;
                                        tmp50_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp50_AST);
                                        match(COMMA);
                                        annotationMemberArrayValueInitializer();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop80;
                                }
                                
                        } while (true);
                        }
                        {
                        switch ( LA(1)) {
                        case COMMA:
                        {
                                AST tmp51_AST = null;
                                tmp51_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp51_AST);
                                match(COMMA);
                                break;
                        }
                        case RCURLY:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        break;
                }
                case RCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp52_AST = null;
                tmp52_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp52_AST);
                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;
                
                boolean synPredMatched84 = false;
                if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
                        int _m84 = mark();
                        synPredMatched84 = true;
                        inputState.guessing++;
                        try {
                                {
                                annotationExpression();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched84 = false;
                        }
                        rewind(_m84);
inputState.guessing--;
                }
                if ( synPredMatched84 ) {
                        annotationExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
                }
                else if ((LA(1)==AT) && (LA(2)==IDENT)) {
                        annotation();
                        astFactory.addASTChild(currentAST, returnAST);
                        annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                returnAST = annotationMemberArrayValueInitializer_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 tmp53_AST = null;
                        tmp53_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp53_AST);
                        match(QUESTION);
                        {
                        boolean synPredMatched284 = false;
                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
                                int _m284 = mark();
                                synPredMatched284 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        lambdaExpression();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched284 = false;
                                }
                                rewind(_m284);
inputState.guessing--;
                        }
                        if ( synPredMatched284 ) {
                                lambdaExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
                                assignmentExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        AST tmp54_AST = null;
                        tmp54_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp54_AST);
                        match(COLON);
                        {
                        boolean synPredMatched287 = false;
                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
                                int _m287 = mark();
                                synPredMatched287 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        lambdaExpression();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched287 = false;
                                }
                                rewind(_m287);
inputState.guessing--;
                        }
                        if ( synPredMatched287 ) {
                                lambdaExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
                                conditionalExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        break;
                }
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case SEMI:
                case RBRACK:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case STAR:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LITERAL_interface:
                case LCURLY:
                case RCURLY:
                case COMMA:
                case LPAREN:
                case RPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case ASSIGN:
                case COLON:
                case LITERAL_if:
                case LITERAL_while:
                case LITERAL_do:
                case LITERAL_break:
                case LITERAL_continue:
                case LITERAL_return:
                case LITERAL_switch:
                case LITERAL_throw:
                case LITERAL_for:
                case LITERAL_else:
                case LITERAL_case:
                case LITERAL_default:
                case LITERAL_try:
                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 LT:
                case GT:
                case LE:
                case GE:
                case LITERAL_instanceof:
                case SL:
                case SR:
                case BSR:
                case PLUS:
                case MINUS:
                case DIV:
                case MOD:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case ASSERT:
                case ENUM:
                case AT:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                conditionalExpression_AST = (AST)currentAST.root;
                returnAST = conditionalExpression_AST;
        }
        
        public final void typeParameters() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeParameters_AST = null;
                Token  lt = null;
                AST lt_AST = null;
                int currentLtLevel = 0;
                
                if ( inputState.guessing==0 ) {
                        currentLtLevel = ltCounter;
                }
                lt = LT(1);
                lt_AST = astFactory.create(lt);
                astFactory.addASTChild(currentAST, lt_AST);
                match(LT);
                if ( inputState.guessing==0 ) {
                        lt_AST.setType(GENERIC_START); ltCounter++;
                }
                typeParameter();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop96:
                do {
                        if ((LA(1)==COMMA)) {
                                AST tmp55_AST = null;
                                tmp55_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp55_AST);
                                match(COMMA);
                                typeParameter();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop96;
                        }
                        
                } while (true);
                }
                {
                switch ( LA(1)) {
                case GT:
                case SR:
                case BSR:
                {
                        typeArgumentsOrParametersEnd();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_extends:
                case LCURLY:
                case LITERAL_implements:
                case AT:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                if ( inputState.guessing==0 ) {
                        
                        if (isThereASingleGtToEmit()) {
                        astFactory.addASTChild(currentAST, emitSingleGt());
                        }
                        
                }
                if (!(areLtsAndGtsBalanced(currentLtLevel)))
                  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
                if ( inputState.guessing==0 ) {
                        typeParameters_AST = (AST)currentAST.root;
                        typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).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 superClassClause() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST superClassClause_AST = null;
                Token  e = null;
                AST e_AST = null;
                AST c_AST = null;
                
                {
                switch ( LA(1)) {
                case LITERAL_extends:
                {
                        e = LT(1);
                        e_AST = astFactory.create(e);
                        astFactory.makeASTRoot(currentAST, e_AST);
                        match(LITERAL_extends);
                        if ( inputState.guessing==0 ) {
                                e_AST.setType(EXTENDS_CLAUSE);
                        }
                        classOrInterfaceType(false);
                        c_AST = (AST)returnAST;
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case LCURLY:
                case LITERAL_implements:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                superClassClause_AST = (AST)currentAST.root;
                returnAST = superClassClause_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;
                
                {
                switch ( LA(1)) {
                case LITERAL_implements:
                {
                        i = LT(1);
                        i_AST = astFactory.create(i);
                        astFactory.makeASTRoot(currentAST, i_AST);
                        match(LITERAL_implements);
                        if ( inputState.guessing==0 ) {
                                i_AST.setType(IMPLEMENTS_CLAUSE);
                        }
                        classOrInterfaceType(false);
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop143:
                        do {
                                if ((LA(1)==COMMA)) {
                                        AST tmp56_AST = null;
                                        tmp56_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp56_AST);
                                        match(COMMA);
                                        classOrInterfaceType(false);
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop143;
                                }
                                
                        } while (true);
                        }
                        break;
                }
                case LCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                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;
                
                AST tmp57_AST = null;
                tmp57_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp57_AST);
                match(LCURLY);
                {
                _loop135:
                do {
                        switch ( LA(1)) {
                        case FINAL:
                        case ABSTRACT:
                        case STRICTFP:
                        case LITERAL_void:
                        case LITERAL_boolean:
                        case LITERAL_byte:
                        case LITERAL_char:
                        case LITERAL_short:
                        case LITERAL_int:
                        case LITERAL_float:
                        case LITERAL_long:
                        case LITERAL_double:
                        case IDENT:
                        case LITERAL_private:
                        case LITERAL_public:
                        case LITERAL_protected:
                        case LITERAL_static:
                        case LITERAL_transient:
                        case LITERAL_native:
                        case LITERAL_synchronized:
                        case LITERAL_volatile:
                        case LITERAL_class:
                        case LITERAL_interface:
                        case LCURLY:
                        case LITERAL_default:
                        case LT:
                        case ENUM:
                        case AT:
                        {
                                field();
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case SEMI:
                        {
                                AST tmp58_AST = null;
                                tmp58_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp58_AST);
                                match(SEMI);
                                break;
                        }
                        default:
                        {
                                break _loop135;
                        }
                        }
                } while (true);
                }
                AST tmp59_AST = null;
                tmp59_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp59_AST);
                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;
                
                {
                switch ( LA(1)) {
                case LITERAL_extends:
                {
                        e = LT(1);
                        e_AST = astFactory.create(e);
                        astFactory.makeASTRoot(currentAST, e_AST);
                        match(LITERAL_extends);
                        if ( inputState.guessing==0 ) {
                                e_AST.setType(EXTENDS_CLAUSE);
                        }
                        classOrInterfaceType(false);
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop139:
                        do {
                                if ((LA(1)==COMMA)) {
                                        AST tmp60_AST = null;
                                        tmp60_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp60_AST);
                                        match(COMMA);
                                        classOrInterfaceType(false);
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop139;
                                }
                                
                        } while (true);
                        }
                        break;
                }
                case LCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                interfaceExtends_AST = (AST)currentAST.root;
                returnAST = interfaceExtends_AST;
        }
        
        public final void enumBlock() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST enumBlock_AST = null;
                
                AST tmp61_AST = null;
                tmp61_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp61_AST);
                match(LCURLY);
                {
                switch ( LA(1)) {
                case IDENT:
                case AT:
                {
                        enumConstant();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop116:
                        do {
                                if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) {
                                        AST tmp62_AST = null;
                                        tmp62_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp62_AST);
                                        match(COMMA);
                                        enumConstant();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop116;
                                }
                                
                        } while (true);
                        }
                        {
                        switch ( LA(1)) {
                        case COMMA:
                        {
                                AST tmp63_AST = null;
                                tmp63_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp63_AST);
                                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:
                {
                        AST tmp64_AST = null;
                        tmp64_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp64_AST);
                        match(SEMI);
                        {
                        _loop120:
                        do {
                                switch ( LA(1)) {
                                case FINAL:
                                case ABSTRACT:
                                case STRICTFP:
                                case LITERAL_void:
                                case LITERAL_boolean:
                                case LITERAL_byte:
                                case LITERAL_char:
                                case LITERAL_short:
                                case LITERAL_int:
                                case LITERAL_float:
                                case LITERAL_long:
                                case LITERAL_double:
                                case IDENT:
                                case LITERAL_private:
                                case LITERAL_public:
                                case LITERAL_protected:
                                case LITERAL_static:
                                case LITERAL_transient:
                                case LITERAL_native:
                                case LITERAL_synchronized:
                                case LITERAL_volatile:
                                case LITERAL_class:
                                case LITERAL_interface:
                                case LCURLY:
                                case LITERAL_default:
                                case LT:
                                case ENUM:
                                case AT:
                                {
                                        field();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        break;
                                }
                                case SEMI:
                                {
                                        AST tmp65_AST = null;
                                        tmp65_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp65_AST);
                                        match(SEMI);
                                        break;
                                }
                                default:
                                {
                                        break _loop120;
                                }
                                }
                        } while (true);
                        }
                        break;
                }
                case RCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp66_AST = null;
                tmp66_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp66_AST);
                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;
                
                AST tmp67_AST = null;
                tmp67_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp67_AST);
                match(LCURLY);
                {
                _loop107:
                do {
                        switch ( LA(1)) {
                        case FINAL:
                        case ABSTRACT:
                        case STRICTFP:
                        case LITERAL_void:
                        case LITERAL_boolean:
                        case LITERAL_byte:
                        case LITERAL_char:
                        case LITERAL_short:
                        case LITERAL_int:
                        case LITERAL_float:
                        case LITERAL_long:
                        case LITERAL_double:
                        case IDENT:
                        case LITERAL_private:
                        case LITERAL_public:
                        case LITERAL_protected:
                        case LITERAL_static:
                        case LITERAL_transient:
                        case LITERAL_native:
                        case LITERAL_synchronized:
                        case LITERAL_volatile:
                        case LITERAL_class:
                        case LITERAL_interface:
                        case LITERAL_default:
                        case ENUM:
                        case AT:
                        {
                                annotationField();
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case SEMI:
                        {
                                AST tmp68_AST = null;
                                tmp68_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp68_AST);
                                match(SEMI);
                                break;
                        }
                        default:
                        {
                                break _loop107;
                        }
                        }
                } while (true);
                }
                AST tmp69_AST = null;
                tmp69_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp69_AST);
                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;
                
                {
                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_18.member(LA(2))))&&(LA(1) == AT)) {
                        annotations();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((LA(1)==IDENT) && (_tokenSet_18.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                id = LT(1);
                id_AST = astFactory.create(id);
                astFactory.addASTChild(currentAST, id_AST);
                match(IDENT);
                }
                {
                if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==AT)) {
                        typeParameterBounds();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.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(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).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  e = null;
                AST e_AST = null;
                Token  b = null;
                AST b_AST = null;
                
                e = LT(1);
                e_AST = astFactory.create(e);
                astFactory.makeASTRoot(currentAST, e_AST);
                match(LITERAL_extends);
                classOrInterfaceType(true);
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop104:
                do {
                        if ((LA(1)==BAND)) {
                                b = LT(1);
                                b_AST = astFactory.create(b);
                                astFactory.addASTChild(currentAST, b_AST);
                                match(BAND);
                                if ( inputState.guessing==0 ) {
                                        b_AST.setType(TYPE_EXTENSION_AND);
                                }
                                classOrInterfaceType(true);
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop104;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        e_AST.setType(TYPE_UPPER_BOUNDS);
                }
                typeParameterBounds_AST = (AST)currentAST.root;
                returnAST = typeParameterBounds_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 d_AST = null;
                Token  s = null;
                AST s_AST = null;
                AST v_AST = null;
                Token  s6 = null;
                AST s6_AST = null;
                
                modifiers();
                mods_AST = (AST)returnAST;
                {
                if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
                        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();
                        }
                }
                else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
                        typeSpec(false);
                        t_AST = (AST)returnAST;
                        {
                        if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
                                i = LT(1);
                                i_AST = astFactory.create(i);
                                match(IDENT);
                                AST tmp70_AST = null;
                                tmp70_AST = astFactory.create(LT(1));
                                match(LPAREN);
                                AST tmp71_AST = null;
                                tmp71_AST = astFactory.create(LT(1));
                                match(RPAREN);
                                declaratorBrackets(t_AST);
                                rt_AST = (AST)returnAST;
                                {
                                switch ( LA(1)) {
                                case LITERAL_default:
                                {
                                        annotationDefault();
                                        d_AST = (AST)returnAST;
                                        break;
                                }
                                case SEMI:
                                {
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                s = LT(1);
                                s_AST = astFactory.create(s);
                                match(SEMI);
                                if ( inputState.guessing==0 ) {
                                        annotationField_AST = (AST)currentAST.root;
                                        annotationField_AST =
                                        (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(i_AST).add(tmp70_AST).add(tmp71_AST).add(d_AST).add(s_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_22.member(LA(2)))) {
                                variableDefinitions(mods_AST,t_AST);
                                v_AST = (AST)returnAST;
                                s6 = LT(1);
                                s6_AST = astFactory.create(s6);
                                match(SEMI);
                                if ( inputState.guessing==0 ) {
                                        annotationField_AST = (AST)currentAST.root;
                                        
                                        annotationField_AST = v_AST;
                                        v_AST.addChild(s6_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());
                        }
                        
                        }
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                returnAST = annotationField_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();
                }
                {
                _loop169:
                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);
                                }
                                AST tmp72_AST = null;
                                tmp72_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp72_AST);
                                match(RBRACK);
                        }
                        else {
                                break _loop169;
                        }
                        
                } while (true);
                }
                declaratorBrackets_AST = (AST)currentAST.root;
                returnAST = declaratorBrackets_AST;
        }
        
        public final void annotationDefault() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST annotationDefault_AST = null;
                
                AST tmp73_AST = null;
                tmp73_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp73_AST);
                match(LITERAL_default);
                annotationMemberValueInitializer();
                astFactory.addASTChild(currentAST, returnAST);
                annotationDefault_AST = (AST)currentAST.root;
                returnAST = annotationDefault_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;
                Token  l = null;
                AST l_AST = null;
                AST args_AST = null;
                Token  r = null;
                AST r_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:
                {
                        l = LT(1);
                        l_AST = astFactory.create(l);
                        match(LPAREN);
                        argList();
                        args_AST = (AST)returnAST;
                        r = LT(1);
                        r_AST = astFactory.create(r);
                        match(RPAREN);
                        break;
                }
                case SEMI:
                case LCURLY:
                case RCURLY:
                case COMMA:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                {
                switch ( LA(1)) {
                case LCURLY:
                {
                        enumConstantBlock();
                        b_AST = (AST)returnAST;
                        break;
                }
                case SEMI:
                case RCURLY:
                case COMMA:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                if ( inputState.guessing==0 ) {
                        enumConstant_AST = (AST)currentAST.root;
                        enumConstant_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(l_AST).add(args_AST).add(r_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 field() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST field_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;
                Token  s5 = null;
                AST s5_AST = null;
                AST v_AST = null;
                Token  s6 = null;
                AST s6_AST = null;
                Token  si = null;
                AST si_AST = null;
                AST s3_AST = null;
                AST s4_AST = null;
                
                if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) {
                        modifiers();
                        mods_AST = (AST)returnAST;
                        {
                        if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
                                typeDefinitionInternal(mods_AST);
                                td_AST = (AST)returnAST;
                                if ( inputState.guessing==0 ) {
                                        field_AST = (AST)currentAST.root;
                                        field_AST = td_AST;
                                        currentAST.root = field_AST;
                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                                field_AST.getFirstChild() : field_AST;
                                        currentAST.advanceChildToEnd();
                                }
                        }
                        else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case LT:
                                {
                                        typeParameters();
                                        tp_AST = (AST)returnAST;
                                        break;
                                }
                                case LITERAL_void:
                                case LITERAL_boolean:
                                case LITERAL_byte:
                                case LITERAL_char:
                                case LITERAL_short:
                                case LITERAL_int:
                                case LITERAL_float:
                                case LITERAL_long:
                                case LITERAL_double:
                                case IDENT:
                                case AT:
                                {
                                        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 ) {
                                                field_AST = (AST)currentAST.root;
                                                field_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST));
                                                currentAST.root = field_AST;
                                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                                        field_AST.getFirstChild() : field_AST;
                                                currentAST.advanceChildToEnd();
                                        }
                                }
                                else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
                                        typeSpec(false);
                                        t_AST = (AST)returnAST;
                                        {
                                        if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
                                                AST tmp74_AST = null;
                                                tmp74_AST = astFactory.create(LT(1));
                                                match(IDENT);
                                                AST tmp75_AST = null;
                                                tmp75_AST = astFactory.create(LT(1));
                                                match(LPAREN);
                                                parameterDeclarationList();
                                                param_AST = (AST)returnAST;
                                                AST tmp76_AST = null;
                                                tmp76_AST = astFactory.create(LT(1));
                                                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:
                                                {
                                                        s5 = LT(1);
                                                        s5_AST = astFactory.create(s5);
                                                        match(SEMI);
                                                        break;
                                                }
                                                default:
                                                {
                                                        throw new NoViableAltException(LT(1), getFilename());
                                                }
                                                }
                                                }
                                                if ( inputState.guessing==0 ) {
                                                        field_AST = (AST)currentAST.root;
                                                        field_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp74_AST).add(tmp75_AST).add(param_AST).add(tmp76_AST).add(tc_AST).add(s2_AST).add(s5_AST));
                                                        currentAST.root = field_AST;
                                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                                                field_AST.getFirstChild() : field_AST;
                                                        currentAST.advanceChildToEnd();
                                                }
                                        }
                                        else if ((LA(1)==IDENT) && (_tokenSet_27.member(LA(2)))) {
                                                variableDefinitions(mods_AST,t_AST);
                                                v_AST = (AST)returnAST;
                                                {
                                                if ((LA(1)==SEMI) && (_tokenSet_28.member(LA(2)))) {
                                                        s6 = LT(1);
                                                        s6_AST = astFactory.create(s6);
                                                        match(SEMI);
                                                }
                                                else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
                                                }
                                                else {
                                                        throw new NoViableAltException(LT(1), getFilename());
                                                }
                                                
                                                }
                                                if ( inputState.guessing==0 ) {
                                                        field_AST = (AST)currentAST.root;
                                                        
                                                        field_AST = v_AST;
                                                        v_AST.addChild(s6_AST);
                                                        
                                                        currentAST.root = field_AST;
                                                        currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                                                field_AST.getFirstChild() : field_AST;
                                                        currentAST.advanceChildToEnd();
                                                }
                                        }
                                        else {
                                                throw new NoViableAltException(LT(1), getFilename());
                                        }
                                        
                                        }
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                }
                else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
                        si = LT(1);
                        si_AST = astFactory.create(si);
                        match(LITERAL_static);
                        compoundStatement();
                        s3_AST = (AST)returnAST;
                        if ( inputState.guessing==0 ) {
                                field_AST = (AST)currentAST.root;
                                si_AST.setType(STATIC_INIT);
                                si_AST.setText("STATIC_INIT");
                                field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST));
                                currentAST.root = field_AST;
                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                        field_AST.getFirstChild() : field_AST;
                                currentAST.advanceChildToEnd();
                        }
                }
                else if ((LA(1)==LCURLY)) {
                        compoundStatement();
                        s4_AST = (AST)returnAST;
                        if ( inputState.guessing==0 ) {
                                field_AST = (AST)currentAST.root;
                                field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
                                currentAST.root = field_AST;
                                currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
                                        field_AST.getFirstChild() : field_AST;
                                currentAST.advanceChildToEnd();
                        }
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                returnAST = field_AST;
        }
        
        public final void argList() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST argList_AST = null;
                
                {
                if (((_tokenSet_12.member(LA(1))))&&(LA(1)!=RPAREN)) {
                        expressionList();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((LA(1)==RPAREN)) {
                        if ( inputState.guessing==0 ) {
                                argList_AST = (AST)currentAST.root;
                                argList_AST = astFactory.create(ELIST,"ELIST");
                                currentAST.root = argList_AST;
                                currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
                                        argList_AST.getFirstChild() : argList_AST;
                                currentAST.advanceChildToEnd();
                        }
                }
                else {
                        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;
                
                AST tmp77_AST = null;
                tmp77_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp77_AST);
                match(LCURLY);
                {
                _loop126:
                do {
                        switch ( LA(1)) {
                        case FINAL:
                        case ABSTRACT:
                        case STRICTFP:
                        case LITERAL_void:
                        case LITERAL_boolean:
                        case LITERAL_byte:
                        case LITERAL_char:
                        case LITERAL_short:
                        case LITERAL_int:
                        case LITERAL_float:
                        case LITERAL_long:
                        case LITERAL_double:
                        case IDENT:
                        case LITERAL_private:
                        case LITERAL_public:
                        case LITERAL_protected:
                        case LITERAL_static:
                        case LITERAL_transient:
                        case LITERAL_native:
                        case LITERAL_synchronized:
                        case LITERAL_volatile:
                        case LITERAL_class:
                        case LITERAL_interface:
                        case LCURLY:
                        case LITERAL_default:
                        case LT:
                        case ENUM:
                        case AT:
                        {
                                enumConstantField();
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case SEMI:
                        {
                                AST tmp78_AST = null;
                                tmp78_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp78_AST);
                                match(SEMI);
                                break;
                        }
                        default:
                        {
                                break _loop126;
                        }
                        }
                } while (true);
                }
                AST tmp79_AST = null;
                tmp79_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp79_AST);
                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;
                Token  s3 = null;
                AST s3_AST = null;
                AST v_AST = null;
                Token  s6 = null;
                AST s6_AST = null;
                AST s4_AST = null;
                
                switch ( LA(1)) {
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LITERAL_interface:
                case LITERAL_default:
                case LT:
                case ENUM:
                case AT:
                {
                        modifiers();
                        mods_AST = (AST)returnAST;
                        {
                        if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
                                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();
                                }
                        }
                        else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case LT:
                                {
                                        typeParameters();
                                        tp_AST = (AST)returnAST;
                                        break;
                                }
                                case LITERAL_void:
                                case LITERAL_boolean:
                                case LITERAL_byte:
                                case LITERAL_char:
                                case LITERAL_short:
                                case LITERAL_int:
                                case LITERAL_float:
                                case LITERAL_long:
                                case LITERAL_double:
                                case IDENT:
                                case AT:
                                {
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                typeSpec(false);
                                t_AST = (AST)returnAST;
                                {
                                if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
                                        AST tmp80_AST = null;
                                        tmp80_AST = astFactory.create(LT(1));
                                        match(IDENT);
                                        AST tmp81_AST = null;
                                        tmp81_AST = astFactory.create(LT(1));
                                        match(LPAREN);
                                        parameterDeclarationList();
                                        param_AST = (AST)returnAST;
                                        AST tmp82_AST = null;
                                        tmp82_AST = astFactory.create(LT(1));
                                        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:
                                        {
                                                s3 = LT(1);
                                                s3_AST = astFactory.create(s3);
                                                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(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp80_AST).add(tmp81_AST).add(param_AST).add(tmp82_AST).add(tc_AST).add(s2_AST).add(s3_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_22.member(LA(2)))) {
                                        variableDefinitions(mods_AST,t_AST);
                                        v_AST = (AST)returnAST;
                                        s6 = LT(1);
                                        s6_AST = astFactory.create(s6);
                                        match(SEMI);
                                        if ( inputState.guessing==0 ) {
                                                enumConstantField_AST = (AST)currentAST.root;
                                                
                                                enumConstantField_AST = v_AST;
                                                v_AST.addChild(s6_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());
                                }
                                
                                }
                        }
                        else {
                                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(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).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;
                
                {
                boolean synPredMatched188 = false;
                if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
                        int _m188 = mark();
                        synPredMatched188 = true;
                        inputState.guessing++;
                        try {
                                {
                                parameterDeclaration();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched188 = false;
                        }
                        rewind(_m188);
inputState.guessing--;
                }
                if ( synPredMatched188 ) {
                        parameterDeclaration();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop192:
                        do {
                                boolean synPredMatched191 = false;
                                if (((LA(1)==COMMA) && (_tokenSet_30.member(LA(2))))) {
                                        int _m191 = mark();
                                        synPredMatched191 = true;
                                        inputState.guessing++;
                                        try {
                                                {
                                                match(COMMA);
                                                parameterDeclaration();
                                                }
                                        }
                                        catch (RecognitionException pe) {
                                                synPredMatched191 = false;
                                        }
                                        rewind(_m191);
inputState.guessing--;
                                }
                                if ( synPredMatched191 ) {
                                        AST tmp83_AST = null;
                                        tmp83_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp83_AST);
                                        match(COMMA);
                                        parameterDeclaration();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop192;
                                }
                                
                        } while (true);
                        }
                        {
                        switch ( LA(1)) {
                        case COMMA:
                        {
                                AST tmp84_AST = null;
                                tmp84_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp84_AST);
                                match(COMMA);
                                variableLengthParameterDeclaration();
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case RPAREN:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                }
                else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.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(astFactory.create(PARAMETERS,"PARAMETERS")).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 tmp85_AST = null;
                tmp85_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp85_AST);
                match(LITERAL_throws);
                {
                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
                        annotations();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                identifier();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop184:
                do {
                        if ((LA(1)==COMMA)) {
                                AST tmp86_AST = null;
                                tmp86_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp86_AST);
                                match(COMMA);
                                {
                                if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
                                        annotations();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                                identifier();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop184;
                        }
                        
                } 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);
                }
                {
                _loop212:
                do {
                        if ((_tokenSet_36.member(LA(1)))) {
                                statement();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop212;
                        }
                        
                } while (true);
                }
                AST tmp87_AST = null;
                tmp87_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp87_AST);
                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 tmp88_AST = null;
                tmp88_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp88_AST);
                match(IDENT);
                AST tmp89_AST = null;
                tmp89_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp89_AST);
                match(LPAREN);
                parameterDeclarationList();
                astFactory.addASTChild(currentAST, returnAST);
                AST tmp90_AST = null;
                tmp90_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp90_AST);
                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);
                }
                {
                boolean synPredMatched155 = false;
                if (((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2))))) {
                        int _m155 = mark();
                        synPredMatched155 = true;
                        inputState.guessing++;
                        try {
                                {
                                explicitConstructorInvocation();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched155 = false;
                        }
                        rewind(_m155);
inputState.guessing--;
                }
                if ( synPredMatched155 ) {
                        explicitConstructorInvocation();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                _loop157:
                do {
                        if ((_tokenSet_36.member(LA(1)))) {
                                statement();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop157;
                        }
                        
                } while (true);
                }
                AST tmp91_AST = null;
                tmp91_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp91_AST);
                match(RCURLY);
                constructorBody_AST = (AST)currentAST.root;
                returnAST = constructorBody_AST;
        }
        
        public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST explicitConstructorInvocation_AST = null;
                Token  t = null;
                AST t_AST = null;
                Token  s = null;
                AST s_AST = null;
                Token  s1 = null;
                AST s1_AST = null;
                
                {
                if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
                        {
                        switch ( LA(1)) {
                        case LT:
                        {
                                typeArguments(false);
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case LITERAL_this:
                        case LITERAL_super:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        {
                        switch ( LA(1)) {
                        case LITERAL_this:
                        {
                                t = LT(1);
                                t_AST = astFactory.create(t);
                                astFactory.makeASTRoot(currentAST, t_AST);
                                match(LITERAL_this);
                                AST tmp92_AST = null;
                                tmp92_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp92_AST);
                                match(LPAREN);
                                argList();
                                astFactory.addASTChild(currentAST, returnAST);
                                AST tmp93_AST = null;
                                tmp93_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp93_AST);
                                match(RPAREN);
                                AST tmp94_AST = null;
                                tmp94_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp94_AST);
                                match(SEMI);
                                if ( inputState.guessing==0 ) {
                                        t_AST.setType(CTOR_CALL);
                                }
                                break;
                        }
                        case LITERAL_super:
                        {
                                s = LT(1);
                                s_AST = astFactory.create(s);
                                astFactory.makeASTRoot(currentAST, s_AST);
                                match(LITERAL_super);
                                AST tmp95_AST = null;
                                tmp95_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp95_AST);
                                match(LPAREN);
                                argList();
                                astFactory.addASTChild(currentAST, returnAST);
                                AST tmp96_AST = null;
                                tmp96_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp96_AST);
                                match(RPAREN);
                                AST tmp97_AST = null;
                                tmp97_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp97_AST);
                                match(SEMI);
                                if ( inputState.guessing==0 ) {
                                        s_AST.setType(SUPER_CTOR_CALL);
                                }
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                }
                else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
                        primaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp98_AST = null;
                        tmp98_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp98_AST);
                        match(DOT);
                        {
                        switch ( LA(1)) {
                        case LT:
                        {
                                typeArguments(false);
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case LITERAL_super:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        s1 = LT(1);
                        s1_AST = astFactory.create(s1);
                        astFactory.makeASTRoot(currentAST, s1_AST);
                        match(LITERAL_super);
                        AST tmp99_AST = null;
                        tmp99_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp99_AST);
                        match(LPAREN);
                        argList();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp100_AST = null;
                        tmp100_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp100_AST);
                        match(RPAREN);
                        AST tmp101_AST = null;
                        tmp101_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp101_AST);
                        match(SEMI);
                        if ( inputState.guessing==0 ) {
                                s1_AST.setType(SUPER_CTOR_CALL);
                        }
                }
                else {
                        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;
                
                switch ( LA(1)) {
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case SEMI:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LCURLY:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case LITERAL_if:
                case LITERAL_while:
                case LITERAL_do:
                case LITERAL_break:
                case LITERAL_continue:
                case LITERAL_return:
                case LITERAL_switch:
                case LITERAL_throw:
                case LITERAL_for:
                case LITERAL_default:
                case LITERAL_try:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        traditionalStatement();
                        astFactory.addASTChild(currentAST, returnAST);
                        statement_AST = (AST)currentAST.root;
                        break;
                }
                case ASSERT:
                {
                        assertStatement();
                        astFactory.addASTChild(currentAST, returnAST);
                        statement_AST = (AST)currentAST.root;
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                returnAST = statement_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 NUM_INT:
                case CHAR_LITERAL:
                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 tmp102_AST = null;
                        tmp102_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp102_AST);
                        match(LITERAL_true);
                        primaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_false:
                {
                        AST tmp103_AST = null;
                        tmp103_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp103_AST);
                        match(LITERAL_false);
                        primaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_this:
                {
                        AST tmp104_AST = null;
                        tmp104_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp104_AST);
                        match(LITERAL_this);
                        primaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_null:
                {
                        AST tmp105_AST = null;
                        tmp105_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp105_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 LPAREN:
                {
                        AST tmp106_AST = null;
                        tmp106_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp106_AST);
                        match(LPAREN);
                        {
                        boolean synPredMatched355 = false;
                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
                                int _m355 = mark();
                                synPredMatched355 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        lambdaExpression();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched355 = false;
                                }
                                rewind(_m355);
inputState.guessing--;
                        }
                        if ( synPredMatched355 ) {
                                lambdaExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
                                assignmentExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        AST tmp107_AST = null;
                        tmp107_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp107_AST);
                        match(RPAREN);
                        primaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_super:
                {
                        AST tmp108_AST = null;
                        tmp108_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp108_AST);
                        match(LITERAL_super);
                        primaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                default:
                        boolean synPredMatched352 = false;
                        if (((_tokenSet_9.member(LA(1))) && (_tokenSet_17.member(LA(2))))) {
                                int _m352 = mark();
                                synPredMatched352 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        typeSpec(false);
                                        match(DOUBLE_COLON);
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched352 = false;
                                }
                                rewind(_m352);
inputState.guessing--;
                        }
                        if ( synPredMatched352 ) {
                                typeSpec(false);
                                astFactory.addASTChild(currentAST, returnAST);
                                primaryExpression_AST = (AST)currentAST.root;
                        }
                        else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) {
                                AST tmp109_AST = null;
                                tmp109_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp109_AST);
                                match(IDENT);
                                primaryExpression_AST = (AST)currentAST.root;
                        }
                        else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double)) && (_tokenSet_17.member(LA(2)))) {
                                builtInType();
                                astFactory.addASTChild(currentAST, returnAST);
                                {
                                _loop357:
                                do {
                                        if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
                                                lbt = LT(1);
                                                lbt_AST = astFactory.create(lbt);
                                                astFactory.makeASTRoot(currentAST, lbt_AST);
                                                match(LBRACK);
                                                if ( inputState.guessing==0 ) {
                                                        lbt_AST.setType(ARRAY_DECLARATOR);
                                                }
                                                AST tmp110_AST = null;
                                                tmp110_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp110_AST);
                                                match(RBRACK);
                                        }
                                        else {
                                                break _loop357;
                                        }
                                        
                                } while (true);
                                }
                                {
                                if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
                                        AST tmp111_AST = null;
                                        tmp111_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp111_AST);
                                        match(DOT);
                                        AST tmp112_AST = null;
                                        tmp112_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp112_AST);
                                        match(LITERAL_class);
                                }
                                else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                                }
                                else {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                                primaryExpression_AST = (AST)currentAST.root;
                        }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                returnAST = primaryExpression_AST;
        }
        
/** Declaration of a variable.  This can be a class/instance variable,
 *   or a local variable in a method.
    @param mods declaration mods.
    @param t variable declaration type.
    @throws RecognitionException if recognition problem occurs.
    @throws TokenStreamException if problem occurs while generating a stream of tokens.
 * 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;
                
                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(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).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 tmp113_AST = null;
                        tmp113_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp113_AST);
                        match(ASSIGN);
                        initializer();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case SEMI:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LITERAL_interface:
                case LCURLY:
                case RCURLY:
                case COMMA:
                case LITERAL_default:
                case LT:
                case ENUM:
                case AT:
                {
                        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;
                
                switch ( LA(1)) {
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        initializer_AST = (AST)currentAST.root;
                        break;
                }
                case LCURLY:
                {
                        arrayInitializer();
                        astFactory.addASTChild(currentAST, returnAST);
                        initializer_AST = (AST)currentAST.root;
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                returnAST = initializer_AST;
        }
        
        public final void arrayInitializer() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST arrayInitializer_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(ARRAY_INIT);
                }
                {
                switch ( LA(1)) {
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LCURLY:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        initializer();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        _loop175:
                        do {
                                if ((LA(1)==COMMA) && (_tokenSet_10.member(LA(2)))) {
                                        AST tmp114_AST = null;
                                        tmp114_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp114_AST);
                                        match(COMMA);
                                        initializer();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop175;
                                }
                                
                        } while (true);
                        }
                        break;
                }
                case RCURLY:
                case COMMA:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                {
                switch ( LA(1)) {
                case COMMA:
                {
                        AST tmp115_AST = null;
                        tmp115_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp115_AST);
                        match(COMMA);
                        break;
                }
                case RCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp116_AST = null;
                tmp116_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp116_AST);
                match(RCURLY);
                arrayInitializer_AST = (AST)currentAST.root;
                returnAST = arrayInitializer_AST;
        }
        
        public final void expression() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST expression_AST = null;
                
                boolean synPredMatched270 = false;
                if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
                        int _m270 = mark();
                        synPredMatched270 = true;
                        inputState.guessing++;
                        try {
                                {
                                lambdaExpression();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched270 = false;
                        }
                        rewind(_m270);
inputState.guessing--;
                }
                if ( synPredMatched270 ) {
                        lambdaExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        expression_AST = (AST)currentAST.root;
                }
                else if (((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(LA(1)!=RPAREN)) {
                        assignmentExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        if ( inputState.guessing==0 ) {
                                expression_AST = (AST)currentAST.root;
                                expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).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;
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                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;
                AST id_AST = null;
                AST pd_AST = null;
                
                parameterModifier();
                pm_AST = (AST)returnAST;
                {
                if ((_tokenSet_9.member(LA(1))) && (_tokenSet_47.member(LA(2)))) {
                        typeSpec(false);
                        t_AST = (AST)returnAST;
                }
                else if ((LA(1)==IDENT||LA(1)==LITERAL_this) && (_tokenSet_48.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                parameterIdent();
                id_AST = (AST)returnAST;
                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(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).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  td = null;
                AST td_AST = null;
                AST pd_AST = null;
                
                parameterModifier();
                pm_AST = (AST)returnAST;
                typeSpec(false);
                t_AST = (AST)returnAST;
                td = LT(1);
                td_AST = astFactory.create(td);
                match(ELLIPSIS);
                AST tmp117_AST = null;
                tmp117_AST = astFactory.create(LT(1));
                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(5)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(td_AST).add(tmp117_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;
                
                {
                _loop197:
                do {
                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
                                annotation();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop197;
                        }
                        
                } while (true);
                }
                {
                switch ( LA(1)) {
                case FINAL:
                {
                        f = LT(1);
                        f_AST = astFactory.create(f);
                        astFactory.addASTChild(currentAST, f_AST);
                        match(FINAL);
                        break;
                }
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LITERAL_this:
                case AT:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                {
                _loop200:
                do {
                        if ((LA(1)==AT) && (LA(2)==IDENT)) {
                                annotation();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop200;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        parameterModifier_AST = (AST)currentAST.root;
                        parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).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 parameterIdent() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST parameterIdent_AST = null;
                
                switch ( LA(1)) {
                case LITERAL_this:
                {
                        AST tmp118_AST = null;
                        tmp118_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp118_AST);
                        match(LITERAL_this);
                        parameterIdent_AST = (AST)currentAST.root;
                        break;
                }
                case IDENT:
                {
                        {
                        AST tmp119_AST = null;
                        tmp119_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp119_AST);
                        match(IDENT);
                        {
                        switch ( LA(1)) {
                        case DOT:
                        {
                                AST tmp120_AST = null;
                                tmp120_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp120_AST);
                                match(DOT);
                                AST tmp121_AST = null;
                                tmp121_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp121_AST);
                                match(LITERAL_this);
                                break;
                        }
                        case LBRACK:
                        case COMMA:
                        case RPAREN:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        }
                        parameterIdent_AST = (AST)currentAST.root;
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                returnAST = parameterIdent_AST;
        }
        
        public final void catchParameterDeclaration() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST catchParameterDeclaration_AST = null;
                AST pm_AST = null;
                AST mct_AST = null;
                Token  id = null;
                AST id_AST = null;
                
                parameterModifier();
                pm_AST = (AST)returnAST;
                multiCatchTypes();
                mct_AST = (AST)returnAST;
                id = LT(1);
                id_AST = astFactory.create(id);
                match(IDENT);
                if ( inputState.guessing==0 ) {
                        catchParameterDeclaration_AST = (AST)currentAST.root;
                        catchParameterDeclaration_AST =
                        (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(mct_AST))).add(id_AST));
                        currentAST.root = catchParameterDeclaration_AST;
                        currentAST.child = catchParameterDeclaration_AST!=null &&catchParameterDeclaration_AST.getFirstChild()!=null ?
                                catchParameterDeclaration_AST.getFirstChild() : catchParameterDeclaration_AST;
                        currentAST.advanceChildToEnd();
                }
                returnAST = catchParameterDeclaration_AST;
        }
        
        public final void multiCatchTypes() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST multiCatchTypes_AST = null;
                
                typeSpec(false);
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop209:
                do {
                        if ((LA(1)==BOR)) {
                                AST tmp122_AST = null;
                                tmp122_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp122_AST);
                                match(BOR);
                                typeSpec(false);
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop209;
                        }
                        
                } while (true);
                }
                multiCatchTypes_AST = (AST)currentAST.root;
                returnAST = multiCatchTypes_AST;
        }
        
        public final void traditionalStatement() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST traditionalStatement_AST = null;
                AST m_AST = null;
                Token  c = null;
                AST c_AST = null;
                Token  w = null;
                AST w_AST = null;
                Token  s = null;
                AST s_AST = null;
                
                switch ( LA(1)) {
                case LCURLY:
                {
                        compoundStatement();
                        astFactory.addASTChild(currentAST, returnAST);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_if:
                {
                        AST tmp123_AST = null;
                        tmp123_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp123_AST);
                        match(LITERAL_if);
                        AST tmp124_AST = null;
                        tmp124_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp124_AST);
                        match(LPAREN);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp125_AST = null;
                        tmp125_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp125_AST);
                        match(RPAREN);
                        statement();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        if ((LA(1)==LITERAL_else) && (_tokenSet_36.member(LA(2)))) {
                                elseStatement();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_for:
                {
                        forStatement();
                        astFactory.addASTChild(currentAST, returnAST);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_while:
                {
                        AST tmp126_AST = null;
                        tmp126_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp126_AST);
                        match(LITERAL_while);
                        AST tmp127_AST = null;
                        tmp127_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp127_AST);
                        match(LPAREN);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp128_AST = null;
                        tmp128_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp128_AST);
                        match(RPAREN);
                        statement();
                        astFactory.addASTChild(currentAST, returnAST);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_do:
                {
                        AST tmp129_AST = null;
                        tmp129_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp129_AST);
                        match(LITERAL_do);
                        statement();
                        astFactory.addASTChild(currentAST, returnAST);
                        w = LT(1);
                        w_AST = astFactory.create(w);
                        astFactory.addASTChild(currentAST, w_AST);
                        match(LITERAL_while);
                        if ( inputState.guessing==0 ) {
                                w_AST.setType(DO_WHILE);
                        }
                        AST tmp130_AST = null;
                        tmp130_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp130_AST);
                        match(LPAREN);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp131_AST = null;
                        tmp131_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp131_AST);
                        match(RPAREN);
                        AST tmp132_AST = null;
                        tmp132_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp132_AST);
                        match(SEMI);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_break:
                {
                        AST tmp133_AST = null;
                        tmp133_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp133_AST);
                        match(LITERAL_break);
                        {
                        switch ( LA(1)) {
                        case IDENT:
                        {
                                AST tmp134_AST = null;
                                tmp134_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp134_AST);
                                match(IDENT);
                                break;
                        }
                        case SEMI:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        AST tmp135_AST = null;
                        tmp135_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp135_AST);
                        match(SEMI);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_continue:
                {
                        AST tmp136_AST = null;
                        tmp136_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp136_AST);
                        match(LITERAL_continue);
                        {
                        switch ( LA(1)) {
                        case IDENT:
                        {
                                AST tmp137_AST = null;
                                tmp137_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp137_AST);
                                match(IDENT);
                                break;
                        }
                        case SEMI:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        AST tmp138_AST = null;
                        tmp138_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp138_AST);
                        match(SEMI);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_return:
                {
                        AST tmp139_AST = null;
                        tmp139_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp139_AST);
                        match(LITERAL_return);
                        {
                        switch ( LA(1)) {
                        case LITERAL_void:
                        case LITERAL_boolean:
                        case LITERAL_byte:
                        case LITERAL_char:
                        case LITERAL_short:
                        case LITERAL_int:
                        case LITERAL_float:
                        case LITERAL_long:
                        case LITERAL_double:
                        case IDENT:
                        case LPAREN:
                        case LITERAL_this:
                        case LITERAL_super:
                        case PLUS:
                        case MINUS:
                        case INC:
                        case DEC:
                        case BNOT:
                        case LNOT:
                        case LITERAL_true:
                        case LITERAL_false:
                        case LITERAL_null:
                        case LITERAL_new:
                        case NUM_INT:
                        case CHAR_LITERAL:
                        case STRING_LITERAL:
                        case NUM_FLOAT:
                        case NUM_LONG:
                        case NUM_DOUBLE:
                        case AT:
                        {
                                expression();
                                astFactory.addASTChild(currentAST, returnAST);
                                break;
                        }
                        case SEMI:
                        {
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        AST tmp140_AST = null;
                        tmp140_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp140_AST);
                        match(SEMI);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_switch:
                {
                        AST tmp141_AST = null;
                        tmp141_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp141_AST);
                        match(LITERAL_switch);
                        AST tmp142_AST = null;
                        tmp142_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp142_AST);
                        match(LPAREN);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp143_AST = null;
                        tmp143_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp143_AST);
                        match(RPAREN);
                        AST tmp144_AST = null;
                        tmp144_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp144_AST);
                        match(LCURLY);
                        {
                        _loop228:
                        do {
                                if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) {
                                        casesGroup();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        break _loop228;
                                }
                                
                        } while (true);
                        }
                        AST tmp145_AST = null;
                        tmp145_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp145_AST);
                        match(RCURLY);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_try:
                {
                        tryBlock();
                        astFactory.addASTChild(currentAST, returnAST);
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                case LITERAL_throw:
                {
                        AST tmp146_AST = null;
                        tmp146_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp146_AST);
                        match(LITERAL_throw);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp147_AST = null;
                        tmp147_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp147_AST);
                        match(SEMI);
                        traditionalStatement_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);
                        }
                        traditionalStatement_AST = (AST)currentAST.root;
                        break;
                }
                default:
                        boolean synPredMatched218 = false;
                        if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
                                int _m218 = mark();
                                synPredMatched218 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        declaration();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched218 = false;
                                }
                                rewind(_m218);
inputState.guessing--;
                        }
                        if ( synPredMatched218 ) {
                                declaration();
                                astFactory.addASTChild(currentAST, returnAST);
                                AST tmp148_AST = null;
                                tmp148_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp148_AST);
                                match(SEMI);
                                traditionalStatement_AST = (AST)currentAST.root;
                        }
                        else {
                                boolean synPredMatched221 = false;
                                if ((((_tokenSet_12.member(LA(1))) && (_tokenSet_53.member(LA(2))))&&(LA(2) != COLON))) {
                                        int _m221 = mark();
                                        synPredMatched221 = true;
                                        inputState.guessing++;
                                        try {
                                                {
                                                if (!(LA(2) != COLON))
                                                  throw new SemanticException("LA(2) != COLON");
                                                expression();
                                                {
                                                if ((LA(1)==SEMI)) {
                                                        match(SEMI);
                                                }
                                                else {
                                                }
                                                
                                                }
                                                }
                                        }
                                        catch (RecognitionException pe) {
                                                synPredMatched221 = false;
                                        }
                                        rewind(_m221);
inputState.guessing--;
                                }
                                if ( synPredMatched221 ) {
                                        expression();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        {
                                        if ((LA(1)==SEMI) && (_tokenSet_49.member(LA(2)))) {
                                                AST tmp149_AST = null;
                                                tmp149_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp149_AST);
                                                match(SEMI);
                                        }
                                        else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
                                        }
                                        else {
                                                throw new NoViableAltException(LT(1), getFilename());
                                        }
                                        
                                        }
                                        traditionalStatement_AST = (AST)currentAST.root;
                                }
                                else if ((_tokenSet_54.member(LA(1))) && (_tokenSet_55.member(LA(2)))) {
                                        modifiers();
                                        m_AST = (AST)returnAST;
                                        classDefinition(m_AST);
                                        astFactory.addASTChild(currentAST, returnAST);
                                        traditionalStatement_AST = (AST)currentAST.root;
                                }
                                else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
                                        AST tmp150_AST = null;
                                        tmp150_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp150_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);
                                        traditionalStatement_AST = (AST)currentAST.root;
                                }
                                else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
                                        AST tmp151_AST = null;
                                        tmp151_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp151_AST);
                                        match(LITERAL_synchronized);
                                        AST tmp152_AST = null;
                                        tmp152_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp152_AST);
                                        match(LPAREN);
                                        expression();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        AST tmp153_AST = null;
                                        tmp153_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp153_AST);
                                        match(RPAREN);
                                        compoundStatement();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        traditionalStatement_AST = (AST)currentAST.root;
                                }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }}
                        returnAST = traditionalStatement_AST;
                }
                
        public final void assertStatement() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST assertStatement_AST = null;
                
                AST tmp154_AST = null;
                tmp154_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp154_AST);
                match(ASSERT);
                expression();
                astFactory.addASTChild(currentAST, returnAST);
                {
                switch ( LA(1)) {
                case COLON:
                {
                        AST tmp155_AST = null;
                        tmp155_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp155_AST);
                        match(COLON);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case SEMI:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp156_AST = null;
                tmp156_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp156_AST);
                match(SEMI);
                assertStatement_AST = (AST)currentAST.root;
                returnAST = assertStatement_AST;
        }
        
        public final void elseStatement() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST elseStatement_AST = null;
                
                AST tmp157_AST = null;
                tmp157_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp157_AST);
                match(LITERAL_else);
                statement();
                astFactory.addASTChild(currentAST, returnAST);
                elseStatement_AST = (AST)currentAST.root;
                returnAST = elseStatement_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);
                AST tmp158_AST = null;
                tmp158_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp158_AST);
                match(LPAREN);
                {
                boolean synPredMatched232 = false;
                if (((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2))))) {
                        int _m232 = mark();
                        synPredMatched232 = true;
                        inputState.guessing++;
                        try {
                                {
                                forInit();
                                match(SEMI);
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched232 = false;
                        }
                        rewind(_m232);
inputState.guessing--;
                }
                if ( synPredMatched232 ) {
                        traditionalForClause();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
                        forEachClause();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                AST tmp159_AST = null;
                tmp159_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp159_AST);
                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 _cnt239=0;
                _loop239:
                do {
                        if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_58.member(LA(2)))) {
                                aCase();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                if ( _cnt239>=1 ) { break _loop239; } else {throw new NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt239++;
                } while (true);
                }
                {
                if ((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2)))) {
                        caseSList();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_60.member(LA(1))) && (_tokenSet_49.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                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 tmp160_AST = null;
                tmp160_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp160_AST);
                match(LITERAL_try);
                {
                switch ( LA(1)) {
                case LPAREN:
                {
                        resourceSpecification();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case LCURLY:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                compoundStatement();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop257:
                do {
                        if ((LA(1)==LITERAL_catch)) {
                                handler();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop257;
                        }
                        
                } while (true);
                }
                {
                switch ( LA(1)) {
                case LITERAL_finally:
                {
                        finallyHandler();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case SEMI:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case STAR:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LCURLY:
                case RCURLY:
                case LPAREN:
                case RPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case COLON:
                case LITERAL_if:
                case LITERAL_while:
                case LITERAL_do:
                case LITERAL_break:
                case LITERAL_continue:
                case LITERAL_return:
                case LITERAL_switch:
                case LITERAL_throw:
                case LITERAL_for:
                case LITERAL_else:
                case LITERAL_case:
                case LITERAL_default:
                case LITERAL_try:
                case LT:
                case GT:
                case LE:
                case GE:
                case LITERAL_instanceof:
                case SL:
                case SR:
                case BSR:
                case PLUS:
                case MINUS:
                case DIV:
                case MOD:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case ASSERT:
                case AT:
                {
                        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;
                
                {
                boolean synPredMatched249 = false;
                if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
                        int _m249 = mark();
                        synPredMatched249 = true;
                        inputState.guessing++;
                        try {
                                {
                                declaration();
                                }
                        }
                        catch (RecognitionException pe) {
                                synPredMatched249 = false;
                        }
                        rewind(_m249);
inputState.guessing--;
                }
                if ( synPredMatched249 ) {
                        declaration();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_61.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(astFactory.create(FOR_INIT,"FOR_INIT")).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);
                AST tmp161_AST = null;
                tmp161_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp161_AST);
                match(SEMI);
                forCond();
                astFactory.addASTChild(currentAST, returnAST);
                AST tmp162_AST = null;
                tmp162_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp162_AST);
                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;
                
                forEachDeclarator();
                astFactory.addASTChild(currentAST, returnAST);
                AST tmp163_AST = null;
                tmp163_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp163_AST);
                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(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).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;
                
                {
                switch ( LA(1)) {
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        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(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).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;
                
                {
                switch ( LA(1)) {
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case PLUS:
                case MINUS:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        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(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).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 forEachDeclarator() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST forEachDeclarator_AST = null;
                AST m_AST = null;
                AST t_AST = null;
                Token  id = null;
                AST id_AST = null;
                AST d_AST = null;
                
                modifiers();
                m_AST = (AST)returnAST;
                typeSpec(false);
                t_AST = (AST)returnAST;
                id = LT(1);
                id_AST = astFactory.create(id);
                match(IDENT);
                declaratorBrackets(t_AST);
                d_AST = (AST)returnAST;
                if ( inputState.guessing==0 ) {
                        forEachDeclarator_AST = (AST)currentAST.root;
                        forEachDeclarator_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(m_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST));
                        currentAST.root = forEachDeclarator_AST;
                        currentAST.child = forEachDeclarator_AST!=null &&forEachDeclarator_AST.getFirstChild()!=null ?
                                forEachDeclarator_AST.getFirstChild() : forEachDeclarator_AST;
                        currentAST.advanceChildToEnd();
                }
                returnAST = forEachDeclarator_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 tmp164_AST = null;
                        tmp164_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp164_AST);
                        match(LITERAL_case);
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case LITERAL_default:
                {
                        AST tmp165_AST = null;
                        tmp165_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp165_AST);
                        match(LITERAL_default);
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp166_AST = null;
                tmp166_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp166_AST);
                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;
                
                {
                int _cnt245=0;
                _loop245:
                do {
                        if (((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2))))&&(LA(1)!=LITERAL_default)) {
                                statement();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                if ( _cnt245>=1 ) { break _loop245; } else {throw new NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt245++;
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        caseSList_AST = (AST)currentAST.root;
                        caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).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;
                
                expression();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop273:
                do {
                        if ((LA(1)==COMMA)) {
                                AST tmp167_AST = null;
                                tmp167_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp167_AST);
                                match(COMMA);
                                expression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop273;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        expressionList_AST = (AST)currentAST.root;
                        expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).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 resourceSpecification() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST resourceSpecification_AST = null;
                
                AST tmp168_AST = null;
                tmp168_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp168_AST);
                match(LPAREN);
                resources();
                astFactory.addASTChild(currentAST, returnAST);
                {
                switch ( LA(1)) {
                case SEMI:
                {
                        AST tmp169_AST = null;
                        tmp169_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp169_AST);
                        match(SEMI);
                        break;
                }
                case RPAREN:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                AST tmp170_AST = null;
                tmp170_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp170_AST);
                match(RPAREN);
                if ( inputState.guessing==0 ) {
                        resourceSpecification_AST = (AST)currentAST.root;
                        resourceSpecification_AST =
                        (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE_SPECIFICATION,"RESOURCE_SPECIFICATION")).add(resourceSpecification_AST));
                        currentAST.root = resourceSpecification_AST;
                        currentAST.child = resourceSpecification_AST!=null &&resourceSpecification_AST.getFirstChild()!=null ?
                                resourceSpecification_AST.getFirstChild() : resourceSpecification_AST;
                        currentAST.advanceChildToEnd();
                }
                resourceSpecification_AST = (AST)currentAST.root;
                returnAST = resourceSpecification_AST;
        }
        
        public final void handler() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST handler_AST = null;
                
                AST tmp171_AST = null;
                tmp171_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp171_AST);
                match(LITERAL_catch);
                AST tmp172_AST = null;
                tmp172_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp172_AST);
                match(LPAREN);
                catchParameterDeclaration();
                astFactory.addASTChild(currentAST, returnAST);
                AST tmp173_AST = null;
                tmp173_AST = astFactory.create(LT(1));
                astFactory.addASTChild(currentAST, tmp173_AST);
                match(RPAREN);
                compoundStatement();
                astFactory.addASTChild(currentAST, returnAST);
                handler_AST = (AST)currentAST.root;
                returnAST = handler_AST;
        }
        
        public final void finallyHandler() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST finallyHandler_AST = null;
                
                AST tmp174_AST = null;
                tmp174_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp174_AST);
                match(LITERAL_finally);
                compoundStatement();
                astFactory.addASTChild(currentAST, returnAST);
                finallyHandler_AST = (AST)currentAST.root;
                returnAST = finallyHandler_AST;
        }
        
        public final void resources() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST resources_AST = null;
                
                resource();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop263:
                do {
                        if ((LA(1)==SEMI) && (_tokenSet_51.member(LA(2)))) {
                                AST tmp175_AST = null;
                                tmp175_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp175_AST);
                                match(SEMI);
                                resource();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop263;
                        }
                        
                } while (true);
                }
                if ( inputState.guessing==0 ) {
                        resources_AST = (AST)currentAST.root;
                        resources_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCES,"RESOURCES")).add(resources_AST));
                        currentAST.root = resources_AST;
                        currentAST.child = resources_AST!=null &&resources_AST.getFirstChild()!=null ?
                                resources_AST.getFirstChild() : resources_AST;
                        currentAST.advanceChildToEnd();
                }
                resources_AST = (AST)currentAST.root;
                returnAST = resources_AST;
        }
        
        public final void resource() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST resource_AST = null;
                
                if ((LA(1)==IDENT) && (LA(2)==SEMI||LA(2)==RPAREN)) {
                        AST tmp176_AST = null;
                        tmp176_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp176_AST);
                        match(IDENT);
                        resource_AST = (AST)currentAST.root;
                }
                else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
                        modifiers();
                        astFactory.addASTChild(currentAST, returnAST);
                        typeSpec(true);
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp177_AST = null;
                        tmp177_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp177_AST);
                        match(IDENT);
                        resource_assign();
                        astFactory.addASTChild(currentAST, returnAST);
                        if ( inputState.guessing==0 ) {
                                resource_AST = (AST)currentAST.root;
                                resource_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE,"RESOURCE")).add(resource_AST));
                                currentAST.root = resource_AST;
                                currentAST.child = resource_AST!=null &&resource_AST.getFirstChild()!=null ?
                                        resource_AST.getFirstChild() : resource_AST;
                                currentAST.advanceChildToEnd();
                        }
                        resource_AST = (AST)currentAST.root;
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                returnAST = resource_AST;
        }
        
        public final void resource_assign() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST resource_assign_AST = null;
                
                AST tmp178_AST = null;
                tmp178_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp178_AST);
                match(ASSIGN);
                expression();
                astFactory.addASTChild(currentAST, returnAST);
                resource_assign_AST = (AST)currentAST.root;
                returnAST = resource_assign_AST;
        }
        
        public final void lambdaExpression() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST lambdaExpression_AST = null;
                
                lambdaParameters();
                astFactory.addASTChild(currentAST, returnAST);
                AST tmp179_AST = null;
                tmp179_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp179_AST);
                match(LAMBDA);
                lambdaBody();
                astFactory.addASTChild(currentAST, returnAST);
                lambdaExpression_AST = (AST)currentAST.root;
                returnAST = lambdaExpression_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 tmp180_AST = null;
                                tmp180_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp180_AST);
                                match(ASSIGN);
                                break;
                        }
                        case PLUS_ASSIGN:
                        {
                                AST tmp181_AST = null;
                                tmp181_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp181_AST);
                                match(PLUS_ASSIGN);
                                break;
                        }
                        case MINUS_ASSIGN:
                        {
                                AST tmp182_AST = null;
                                tmp182_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp182_AST);
                                match(MINUS_ASSIGN);
                                break;
                        }
                        case STAR_ASSIGN:
                        {
                                AST tmp183_AST = null;
                                tmp183_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp183_AST);
                                match(STAR_ASSIGN);
                                break;
                        }
                        case DIV_ASSIGN:
                        {
                                AST tmp184_AST = null;
                                tmp184_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp184_AST);
                                match(DIV_ASSIGN);
                                break;
                        }
                        case MOD_ASSIGN:
                        {
                                AST tmp185_AST = null;
                                tmp185_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp185_AST);
                                match(MOD_ASSIGN);
                                break;
                        }
                        case SR_ASSIGN:
                        {
                                AST tmp186_AST = null;
                                tmp186_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp186_AST);
                                match(SR_ASSIGN);
                                break;
                        }
                        case BSR_ASSIGN:
                        {
                                AST tmp187_AST = null;
                                tmp187_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp187_AST);
                                match(BSR_ASSIGN);
                                break;
                        }
                        case SL_ASSIGN:
                        {
                                AST tmp188_AST = null;
                                tmp188_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp188_AST);
                                match(SL_ASSIGN);
                                break;
                        }
                        case BAND_ASSIGN:
                        {
                                AST tmp189_AST = null;
                                tmp189_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp189_AST);
                                match(BAND_ASSIGN);
                                break;
                        }
                        case BXOR_ASSIGN:
                        {
                                AST tmp190_AST = null;
                                tmp190_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp190_AST);
                                match(BXOR_ASSIGN);
                                break;
                        }
                        case BOR_ASSIGN:
                        {
                                AST tmp191_AST = null;
                                tmp191_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp191_AST);
                                match(BOR_ASSIGN);
                                break;
                        }
                        default:
                        {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        }
                        }
                        {
                        boolean synPredMatched279 = false;
                        if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
                                int _m279 = mark();
                                synPredMatched279 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        lambdaExpression();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched279 = false;
                                }
                                rewind(_m279);
inputState.guessing--;
                        }
                        if ( synPredMatched279 ) {
                                lambdaExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
                                assignmentExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        break;
                }
                case FINAL:
                case ABSTRACT:
                case STRICTFP:
                case SEMI:
                case RBRACK:
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case STAR:
                case LITERAL_private:
                case LITERAL_public:
                case LITERAL_protected:
                case LITERAL_static:
                case LITERAL_transient:
                case LITERAL_native:
                case LITERAL_synchronized:
                case LITERAL_volatile:
                case LITERAL_class:
                case LITERAL_interface:
                case LCURLY:
                case RCURLY:
                case COMMA:
                case LPAREN:
                case RPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case COLON:
                case LITERAL_if:
                case LITERAL_while:
                case LITERAL_do:
                case LITERAL_break:
                case LITERAL_continue:
                case LITERAL_return:
                case LITERAL_switch:
                case LITERAL_throw:
                case LITERAL_for:
                case LITERAL_else:
                case LITERAL_case:
                case LITERAL_default:
                case LITERAL_try:
                case LT:
                case GT:
                case LE:
                case GE:
                case LITERAL_instanceof:
                case SL:
                case SR:
                case BSR:
                case PLUS:
                case MINUS:
                case DIV:
                case MOD:
                case INC:
                case DEC:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case ASSERT:
                case ENUM:
                case AT:
                {
                        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);
                {
                _loop290:
                do {
                        if ((LA(1)==LOR)) {
                                AST tmp192_AST = null;
                                tmp192_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp192_AST);
                                match(LOR);
                                logicalAndExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop290;
                        }
                        
                } 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);
                {
                _loop293:
                do {
                        if ((LA(1)==LAND)) {
                                AST tmp193_AST = null;
                                tmp193_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp193_AST);
                                match(LAND);
                                inclusiveOrExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop293;
                        }
                        
                } 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);
                {
                _loop296:
                do {
                        if ((LA(1)==BOR)) {
                                AST tmp194_AST = null;
                                tmp194_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp194_AST);
                                match(BOR);
                                exclusiveOrExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop296;
                        }
                        
                } 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);
                {
                _loop299:
                do {
                        if ((LA(1)==BXOR)) {
                                AST tmp195_AST = null;
                                tmp195_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp195_AST);
                                match(BXOR);
                                andExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop299;
                        }
                        
                } 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);
                {
                _loop302:
                do {
                        if ((LA(1)==BAND)) {
                                AST tmp196_AST = null;
                                tmp196_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp196_AST);
                                match(BAND);
                                equalityExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop302;
                        }
                        
                } 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);
                {
                _loop306:
                do {
                        if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
                                {
                                switch ( LA(1)) {
                                case NOT_EQUAL:
                                {
                                        AST tmp197_AST = null;
                                        tmp197_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp197_AST);
                                        match(NOT_EQUAL);
                                        break;
                                }
                                case EQUAL:
                                {
                                        AST tmp198_AST = null;
                                        tmp198_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp198_AST);
                                        match(EQUAL);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                relationalExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop306;
                        }
                        
                } 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);
                {
                if ((LA(1)==LITERAL_instanceof) && (_tokenSet_9.member(LA(2)))) {
                        AST tmp199_AST = null;
                        tmp199_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp199_AST);
                        match(LITERAL_instanceof);
                        typeSpec(true);
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                {
                {
                _loop312:
                do {
                        if (((LA(1) >= LT && LA(1) <= GE)) && (_tokenSet_12.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case LT:
                                {
                                        AST tmp200_AST = null;
                                        tmp200_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp200_AST);
                                        match(LT);
                                        break;
                                }
                                case GT:
                                {
                                        AST tmp201_AST = null;
                                        tmp201_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp201_AST);
                                        match(GT);
                                        break;
                                }
                                case LE:
                                {
                                        AST tmp202_AST = null;
                                        tmp202_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp202_AST);
                                        match(LE);
                                        break;
                                }
                                case GE:
                                {
                                        AST tmp203_AST = null;
                                        tmp203_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp203_AST);
                                        match(GE);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                shiftExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop312;
                        }
                        
                } while (true);
                }
                }
                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);
                {
                _loop316:
                do {
                        if (((LA(1) >= SL && LA(1) <= BSR)) && (_tokenSet_12.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case SL:
                                {
                                        AST tmp204_AST = null;
                                        tmp204_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp204_AST);
                                        match(SL);
                                        break;
                                }
                                case SR:
                                {
                                        AST tmp205_AST = null;
                                        tmp205_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp205_AST);
                                        match(SR);
                                        break;
                                }
                                case BSR:
                                {
                                        AST tmp206_AST = null;
                                        tmp206_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp206_AST);
                                        match(BSR);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                additiveExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop316;
                        }
                        
                } 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);
                {
                _loop320:
                do {
                        if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_12.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case PLUS:
                                {
                                        AST tmp207_AST = null;
                                        tmp207_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp207_AST);
                                        match(PLUS);
                                        break;
                                }
                                case MINUS:
                                {
                                        AST tmp208_AST = null;
                                        tmp208_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp208_AST);
                                        match(MINUS);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                multiplicativeExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop320;
                        }
                        
                } 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);
                {
                _loop324:
                do {
                        if ((_tokenSet_63.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
                                {
                                switch ( LA(1)) {
                                case STAR:
                                {
                                        AST tmp209_AST = null;
                                        tmp209_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp209_AST);
                                        match(STAR);
                                        break;
                                }
                                case DIV:
                                {
                                        AST tmp210_AST = null;
                                        tmp210_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp210_AST);
                                        match(DIV);
                                        break;
                                }
                                case MOD:
                                {
                                        AST tmp211_AST = null;
                                        tmp211_AST = astFactory.create(LT(1));
                                        astFactory.makeASTRoot(currentAST, tmp211_AST);
                                        match(MOD);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                unaryExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop324;
                        }
                        
                } 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 tmp212_AST = null;
                        tmp212_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp212_AST);
                        match(INC);
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case DEC:
                {
                        AST tmp213_AST = null;
                        tmp213_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp213_AST);
                        match(DEC);
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case MINUS:
                {
                        AST tmp214_AST = null;
                        tmp214_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp214_AST);
                        match(MINUS);
                        if ( inputState.guessing==0 ) {
                                tmp214_AST.setType(UNARY_MINUS);
                        }
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpression_AST = (AST)currentAST.root;
                        break;
                }
                case PLUS:
                {
                        AST tmp215_AST = null;
                        tmp215_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp215_AST);
                        match(PLUS);
                        if ( inputState.guessing==0 ) {
                                tmp215_AST.setType(UNARY_PLUS);
                        }
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpression_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:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case BNOT:
                case LNOT:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        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;
                Token  lpl = null;
                AST lpl_AST = null;
                
                switch ( LA(1)) {
                case BNOT:
                {
                        AST tmp216_AST = null;
                        tmp216_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp216_AST);
                        match(BNOT);
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
                        break;
                }
                case LNOT:
                {
                        AST tmp217_AST = null;
                        tmp217_AST = astFactory.create(LT(1));
                        astFactory.makeASTRoot(currentAST, tmp217_AST);
                        match(LNOT);
                        unaryExpression();
                        astFactory.addASTChild(currentAST, returnAST);
                        unaryExpressionNotPlusMinus_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:
                case IDENT:
                case LPAREN:
                case LITERAL_this:
                case LITERAL_super:
                case LITERAL_true:
                case LITERAL_false:
                case LITERAL_null:
                case LITERAL_new:
                case NUM_INT:
                case CHAR_LITERAL:
                case STRING_LITERAL:
                case NUM_FLOAT:
                case NUM_LONG:
                case NUM_DOUBLE:
                case AT:
                {
                        {
                        boolean synPredMatched329 = false;
                        if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
                                int _m329 = mark();
                                synPredMatched329 = true;
                                inputState.guessing++;
                                try {
                                        {
                                        match(LPAREN);
                                        builtInTypeSpec(true);
                                        match(RPAREN);
                                        unaryExpression();
                                        }
                                }
                                catch (RecognitionException pe) {
                                        synPredMatched329 = false;
                                }
                                rewind(_m329);
inputState.guessing--;
                        }
                        if ( synPredMatched329 ) {
                                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);
                                AST tmp218_AST = null;
                                tmp218_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp218_AST);
                                match(RPAREN);
                                unaryExpression();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                boolean synPredMatched331 = false;
                                if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
                                        int _m331 = mark();
                                        synPredMatched331 = true;
                                        inputState.guessing++;
                                        try {
                                                {
                                                match(LPAREN);
                                                typeCastParameters();
                                                match(RPAREN);
                                                unaryExpressionNotPlusMinus();
                                                }
                                        }
                                        catch (RecognitionException pe) {
                                                synPredMatched331 = false;
                                        }
                                        rewind(_m331);
inputState.guessing--;
                                }
                                if ( synPredMatched331 ) {
                                        lp = LT(1);
                                        lp_AST = astFactory.create(lp);
                                        astFactory.makeASTRoot(currentAST, lp_AST);
                                        match(LPAREN);
                                        if ( inputState.guessing==0 ) {
                                                lp_AST.setType(TYPECAST);
                                        }
                                        typeCastParameters();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        AST tmp219_AST = null;
                                        tmp219_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp219_AST);
                                        match(RPAREN);
                                        unaryExpressionNotPlusMinus();
                                        astFactory.addASTChild(currentAST, returnAST);
                                }
                                else {
                                        boolean synPredMatched333 = false;
                                        if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
                                                int _m333 = mark();
                                                synPredMatched333 = true;
                                                inputState.guessing++;
                                                try {
                                                        {
                                                        match(LPAREN);
                                                        typeCastParameters();
                                                        match(RPAREN);
                                                        lambdaExpression();
                                                        }
                                                }
                                                catch (RecognitionException pe) {
                                                        synPredMatched333 = false;
                                                }
                                                rewind(_m333);
inputState.guessing--;
                                        }
                                        if ( synPredMatched333 ) {
                                                lpl = LT(1);
                                                lpl_AST = astFactory.create(lpl);
                                                astFactory.makeASTRoot(currentAST, lpl_AST);
                                                match(LPAREN);
                                                if ( inputState.guessing==0 ) {
                                                        lpl_AST.setType(TYPECAST);
                                                }
                                                typeCastParameters();
                                                astFactory.addASTChild(currentAST, returnAST);
                                                AST tmp220_AST = null;
                                                tmp220_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp220_AST);
                                                match(RPAREN);
                                                lambdaExpression();
                                                astFactory.addASTChild(currentAST, returnAST);
                                        }
                                        else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_17.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 typeCastParameters() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST typeCastParameters_AST = null;
                
                classTypeSpec(true);
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop336:
                do {
                        if ((LA(1)==BAND)) {
                                AST tmp221_AST = null;
                                tmp221_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp221_AST);
                                match(BAND);
                                classTypeSpec(true);
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else {
                                break _loop336;
                        }
                        
                } while (true);
                }
                typeCastParameters_AST = (AST)currentAST.root;
                returnAST = typeCastParameters_AST;
        }
        
        public final void postfixExpression() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST postfixExpression_AST = null;
                Token  dc = null;
                AST dc_AST = null;
                Token  lbc = null;
                AST lbc_AST = null;
                Token  lb = null;
                AST lb_AST = null;
                Token  lp = null;
                AST lp_AST = null;
                Token  in = null;
                AST in_AST = null;
                Token  de = null;
                AST de_AST = null;
                
                primaryExpression();
                astFactory.addASTChild(currentAST, returnAST);
                {
                _loop348:
                do {
                        switch ( LA(1)) {
                        case DOT:
                        {
                                AST tmp222_AST = null;
                                tmp222_AST = astFactory.create(LT(1));
                                astFactory.makeASTRoot(currentAST, tmp222_AST);
                                match(DOT);
                                {
                                switch ( LA(1)) {
                                case IDENT:
                                case LITERAL_this:
                                case LITERAL_super:
                                case LT:
                                {
                                        {
                                        switch ( LA(1)) {
                                        case LT:
                                        {
                                                typeArguments(false);
                                                astFactory.addASTChild(currentAST, returnAST);
                                                break;
                                        }
                                        case IDENT:
                                        case LITERAL_this:
                                        case LITERAL_super:
                                        {
                                                break;
                                        }
                                        default:
                                        {
                                                throw new NoViableAltException(LT(1), getFilename());
                                        }
                                        }
                                        }
                                        {
                                        switch ( LA(1)) {
                                        case IDENT:
                                        {
                                                AST tmp223_AST = null;
                                                tmp223_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp223_AST);
                                                match(IDENT);
                                                break;
                                        }
                                        case LITERAL_this:
                                        {
                                                AST tmp224_AST = null;
                                                tmp224_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp224_AST);
                                                match(LITERAL_this);
                                                break;
                                        }
                                        case LITERAL_super:
                                        {
                                                AST tmp225_AST = null;
                                                tmp225_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp225_AST);
                                                match(LITERAL_super);
                                                break;
                                        }
                                        default:
                                        {
                                                throw new NoViableAltException(LT(1), getFilename());
                                        }
                                        }
                                        }
                                        break;
                                }
                                case LITERAL_class:
                                {
                                        AST tmp226_AST = null;
                                        tmp226_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp226_AST);
                                        match(LITERAL_class);
                                        break;
                                }
                                case LITERAL_new:
                                {
                                        newExpression();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                break;
                        }
                        case DOUBLE_COLON:
                        {
                                dc = LT(1);
                                dc_AST = astFactory.create(dc);
                                astFactory.makeASTRoot(currentAST, dc_AST);
                                match(DOUBLE_COLON);
                                if ( inputState.guessing==0 ) {
                                        dc_AST.setType(METHOD_REF);
                                }
                                {
                                {
                                switch ( LA(1)) {
                                case LT:
                                {
                                        typeArguments(false);
                                        astFactory.addASTChild(currentAST, returnAST);
                                        break;
                                }
                                case IDENT:
                                case LITERAL_new:
                                {
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                {
                                switch ( LA(1)) {
                                case IDENT:
                                {
                                        AST tmp227_AST = null;
                                        tmp227_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp227_AST);
                                        match(IDENT);
                                        break;
                                }
                                case LITERAL_new:
                                {
                                        AST tmp228_AST = null;
                                        tmp228_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp228_AST);
                                        match(LITERAL_new);
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                }
                                break;
                        }
                        default:
                                if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
                                        {
                                        int _cnt346=0;
                                        _loop346:
                                        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);
                                                        }
                                                        AST tmp229_AST = null;
                                                        tmp229_AST = astFactory.create(LT(1));
                                                        astFactory.addASTChild(currentAST, tmp229_AST);
                                                        match(RBRACK);
                                                }
                                                else {
                                                        if ( _cnt346>=1 ) { break _loop346; } else {throw new NoViableAltException(LT(1), getFilename());}
                                                }
                                                
                                                _cnt346++;
                                        } while (true);
                                        }
                                        {
                                        if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
                                                AST tmp230_AST = null;
                                                tmp230_AST = astFactory.create(LT(1));
                                                astFactory.makeASTRoot(currentAST, tmp230_AST);
                                                match(DOT);
                                                AST tmp231_AST = null;
                                                tmp231_AST = astFactory.create(LT(1));
                                                astFactory.addASTChild(currentAST, tmp231_AST);
                                                match(LITERAL_class);
                                        }
                                        else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                                        }
                                        else {
                                                throw new NoViableAltException(LT(1), getFilename());
                                        }
                                        
                                        }
                                }
                                else if ((LA(1)==LBRACK) && (_tokenSet_12.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(INDEX_OP);
                                        }
                                        expression();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        AST tmp232_AST = null;
                                        tmp232_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp232_AST);
                                        match(RBRACK);
                                }
                                else if ((LA(1)==LPAREN) && (_tokenSet_64.member(LA(2)))) {
                                        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);
                                        AST tmp233_AST = null;
                                        tmp233_AST = astFactory.create(LT(1));
                                        astFactory.addASTChild(currentAST, tmp233_AST);
                                        match(RPAREN);
                                }
                        else {
                                break _loop348;
                        }
                        }
                } while (true);
                }
                {
                if ((LA(1)==INC) && (_tokenSet_62.member(LA(2)))) {
                        in = LT(1);
                        in_AST = astFactory.create(in);
                        astFactory.makeASTRoot(currentAST, in_AST);
                        match(INC);
                        if ( inputState.guessing==0 ) {
                                in_AST.setType(POST_INC);
                        }
                }
                else if ((LA(1)==DEC) && (_tokenSet_62.member(LA(2)))) {
                        de = LT(1);
                        de_AST = astFactory.create(de);
                        astFactory.makeASTRoot(currentAST, de_AST);
                        match(DEC);
                        if ( inputState.guessing==0 ) {
                                de_AST.setType(POST_DEC);
                        }
                }
                else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                postfixExpression_AST = (AST)currentAST.root;
                returnAST = postfixExpression_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
 *
 *
 * @throws RecognitionException if recognition problem occurs.
 * @throws TokenStreamException if problem occurs while generating a stream of tokens.
 */
        public final void newExpression() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST newExpression_AST = null;
                
                AST tmp234_AST = null;
                tmp234_AST = astFactory.create(LT(1));
                astFactory.makeASTRoot(currentAST, tmp234_AST);
                match(LITERAL_new);
                {
                switch ( LA(1)) {
                case LT:
                {
                        typeArguments(false);
                        astFactory.addASTChild(currentAST, returnAST);
                        break;
                }
                case LITERAL_void:
                case LITERAL_boolean:
                case LITERAL_byte:
                case LITERAL_char:
                case LITERAL_short:
                case LITERAL_int:
                case LITERAL_float:
                case LITERAL_long:
                case LITERAL_double:
                case IDENT:
                case AT:
                {
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                type();
                astFactory.addASTChild(currentAST, returnAST);
                {
                switch ( LA(1)) {
                case LPAREN:
                {
                        AST tmp235_AST = null;
                        tmp235_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp235_AST);
                        match(LPAREN);
                        argList();
                        astFactory.addASTChild(currentAST, returnAST);
                        AST tmp236_AST = null;
                        tmp236_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp236_AST);
                        match(RPAREN);
                        {
                        if ((LA(1)==LCURLY) && (_tokenSet_28.member(LA(2)))) {
                                classBlock();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        break;
                }
                case LBRACK:
                {
                        newArrayDeclarator();
                        astFactory.addASTChild(currentAST, returnAST);
                        {
                        if ((LA(1)==LCURLY) && (_tokenSet_65.member(LA(2)))) {
                                arrayInitializer();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                }
                newExpression_AST = (AST)currentAST.root;
                returnAST = newExpression_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 tmp237_AST = null;
                        tmp237_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp237_AST);
                        match(NUM_INT);
                        constant_AST = (AST)currentAST.root;
                        break;
                }
                case NUM_LONG:
                {
                        AST tmp238_AST = null;
                        tmp238_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp238_AST);
                        match(NUM_LONG);
                        constant_AST = (AST)currentAST.root;
                        break;
                }
                case NUM_FLOAT:
                {
                        AST tmp239_AST = null;
                        tmp239_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp239_AST);
                        match(NUM_FLOAT);
                        constant_AST = (AST)currentAST.root;
                        break;
                }
                case NUM_DOUBLE:
                {
                        AST tmp240_AST = null;
                        tmp240_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp240_AST);
                        match(NUM_DOUBLE);
                        constant_AST = (AST)currentAST.root;
                        break;
                }
                case CHAR_LITERAL:
                {
                        AST tmp241_AST = null;
                        tmp241_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp241_AST);
                        match(CHAR_LITERAL);
                        constant_AST = (AST)currentAST.root;
                        break;
                }
                case STRING_LITERAL:
                {
                        AST tmp242_AST = null;
                        tmp242_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp242_AST);
                        match(STRING_LITERAL);
                        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 _cnt369=0;
                _loop369:
                do {
                        if ((LA(1)==LBRACK) && (_tokenSet_66.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 LITERAL_void:
                                case LITERAL_boolean:
                                case LITERAL_byte:
                                case LITERAL_char:
                                case LITERAL_short:
                                case LITERAL_int:
                                case LITERAL_float:
                                case LITERAL_long:
                                case LITERAL_double:
                                case IDENT:
                                case LPAREN:
                                case LITERAL_this:
                                case LITERAL_super:
                                case PLUS:
                                case MINUS:
                                case INC:
                                case DEC:
                                case BNOT:
                                case LNOT:
                                case LITERAL_true:
                                case LITERAL_false:
                                case LITERAL_null:
                                case LITERAL_new:
                                case NUM_INT:
                                case CHAR_LITERAL:
                                case STRING_LITERAL:
                                case NUM_FLOAT:
                                case NUM_LONG:
                                case NUM_DOUBLE:
                                case AT:
                                {
                                        expression();
                                        astFactory.addASTChild(currentAST, returnAST);
                                        break;
                                }
                                case RBRACK:
                                {
                                        break;
                                }
                                default:
                                {
                                        throw new NoViableAltException(LT(1), getFilename());
                                }
                                }
                                }
                                AST tmp243_AST = null;
                                tmp243_AST = astFactory.create(LT(1));
                                astFactory.addASTChild(currentAST, tmp243_AST);
                                match(RBRACK);
                        }
                        else {
                                if ( _cnt369>=1 ) { break _loop369; } else {throw new NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt369++;
                } while (true);
                }
                newArrayDeclarator_AST = (AST)currentAST.root;
                returnAST = newArrayDeclarator_AST;
        }
        
        public final void lambdaParameters() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST lambdaParameters_AST = null;
                
                switch ( LA(1)) {
                case IDENT:
                {
                        AST tmp244_AST = null;
                        tmp244_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp244_AST);
                        match(IDENT);
                        lambdaParameters_AST = (AST)currentAST.root;
                        break;
                }
                case LPAREN:
                {
                        AST tmp245_AST = null;
                        tmp245_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp245_AST);
                        match(LPAREN);
                        {
                        if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
                                parameterDeclarationList();
                                astFactory.addASTChild(currentAST, returnAST);
                        }
                        else if ((LA(1)==RPAREN) && (LA(2)==LAMBDA)) {
                        }
                        else {
                                throw new NoViableAltException(LT(1), getFilename());
                        }
                        
                        }
                        AST tmp246_AST = null;
                        tmp246_AST = astFactory.create(LT(1));
                        astFactory.addASTChild(currentAST, tmp246_AST);
                        match(RPAREN);
                        lambdaParameters_AST = (AST)currentAST.root;
                        break;
                }
                default:
                {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                }
                returnAST = lambdaParameters_AST;
        }
        
        public final void lambdaBody() throws RecognitionException, TokenStreamException {
                
                returnAST = null;
                ASTPair currentAST = new ASTPair();
                AST lambdaBody_AST = null;
                
                {
                if ((_tokenSet_12.member(LA(1))) && (_tokenSet_69.member(LA(2)))) {
                        expression();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_69.member(LA(2)))) {
                        statement();
                        astFactory.addASTChild(currentAST, returnAST);
                }
                else {
                        throw new NoViableAltException(LT(1), getFilename());
                }
                
                }
                lambdaBody_AST = (AST)currentAST.root;
                returnAST = lambdaBody_AST;
        }
        
        
        public static final String[] _tokenNames = {
                "<0>",
                "EOF",
                "<2>",
                "NULL_TREE_LOOKAHEAD",
                "BLOCK",
                "MODIFIERS",
                "OBJBLOCK",
                "SLIST",
                "CTOR_DEF",
                "METHOD_DEF",
                "VARIABLE_DEF",
                "INSTANCE_INIT",
                "STATIC_INIT",
                "TYPE",
                "CLASS_DEF",
                "INTERFACE_DEF",
                "PACKAGE_DEF",
                "ARRAY_DECLARATOR",
                "EXTENDS_CLAUSE",
                "IMPLEMENTS_CLAUSE",
                "PARAMETERS",
                "PARAMETER_DEF",
                "LABELED_STAT",
                "TYPECAST",
                "INDEX_OP",
                "POST_INC",
                "POST_DEC",
                "METHOD_CALL",
                "EXPR",
                "ARRAY_INIT",
                "IMPORT",
                "UNARY_MINUS",
                "UNARY_PLUS",
                "CASE_GROUP",
                "ELIST",
                "FOR_INIT",
                "FOR_CONDITION",
                "FOR_ITERATOR",
                "EMPTY_STAT",
                "\"final\"",
                "\"abstract\"",
                "\"strictfp\"",
                "SUPER_CTOR_CALL",
                "CTOR_CALL",
                "\"package\"",
                "SEMI",
                "\"import\"",
                "LBRACK",
                "RBRACK",
                "\"void\"",
                "\"boolean\"",
                "\"byte\"",
                "\"char\"",
                "\"short\"",
                "\"int\"",
                "\"float\"",
                "\"long\"",
                "\"double\"",
                "IDENT",
                "DOT",
                "STAR",
                "\"private\"",
                "\"public\"",
                "\"protected\"",
                "\"static\"",
                "\"transient\"",
                "\"native\"",
                "\"synchronized\"",
                "\"volatile\"",
                "\"class\"",
                "\"extends\"",
                "\"interface\"",
                "LCURLY",
                "RCURLY",
                "COMMA",
                "\"implements\"",
                "LPAREN",
                "RPAREN",
                "\"this\"",
                "\"super\"",
                "ASSIGN",
                "\"throws\"",
                "COLON",
                "\"if\"",
                "\"while\"",
                "\"do\"",
                "\"break\"",
                "\"continue\"",
                "\"return\"",
                "\"switch\"",
                "\"throw\"",
                "\"for\"",
                "\"else\"",
                "\"case\"",
                "\"default\"",
                "\"try\"",
                "\"catch\"",
                "\"finally\"",
                "PLUS_ASSIGN",
                "MINUS_ASSIGN",
                "STAR_ASSIGN",
                "DIV_ASSIGN",
                "MOD_ASSIGN",
                "SR_ASSIGN",
                "BSR_ASSIGN",
                "SL_ASSIGN",
                "BAND_ASSIGN",
                "BXOR_ASSIGN",
                "BOR_ASSIGN",
                "QUESTION",
                "LOR",
                "LAND",
                "BOR",
                "BXOR",
                "BAND",
                "NOT_EQUAL",
                "EQUAL",
                "LT",
                "GT",
                "LE",
                "GE",
                "\"instanceof\"",
                "SL",
                "SR",
                "BSR",
                "PLUS",
                "MINUS",
                "DIV",
                "MOD",
                "INC",
                "DEC",
                "BNOT",
                "LNOT",
                "\"true\"",
                "\"false\"",
                "\"null\"",
                "\"new\"",
                "NUM_INT",
                "CHAR_LITERAL",
                "STRING_LITERAL",
                "NUM_FLOAT",
                "NUM_LONG",
                "NUM_DOUBLE",
                "WS",
                "SINGLE_LINE_COMMENT",
                "BLOCK_COMMENT_BEGIN",
                "ESC",
                "HEX_DIGIT",
                "VOCAB",
                "EXPONENT",
                "FLOAT_SUFFIX",
                "ASSERT",
                "STATIC_IMPORT",
                "ENUM",
                "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",
                "AT",
                "ELLIPSIS",
                "GENERIC_START",
                "GENERIC_END",
                "TYPE_EXTENSION_AND",
                "DO_WHILE",
                "RESOURCE_SPECIFICATION",
                "RESOURCES",
                "RESOURCE",
                "DOUBLE_COLON",
                "METHOD_REF",
                "LAMBDA",
                "BLOCK_COMMENT_END",
                "COMMENT_CONTENT",
                "SINGLE_LINE_COMMENT_CONTENT",
                "BLOCK_COMMENT_CONTENT",
                "STD_ESC",
                "BINARY_DIGIT",
                "ID_START",
                "ID_PART",
                "INT_LITERAL",
                "LONG_LITERAL",
                "FLOAT_LITERAL",
                "DOUBLE_LITERAL",
                "HEX_FLOAT_LITERAL",
                "HEX_DOUBLE_LITERAL",
                "SIGNED_INTEGER",
                "BINARY_EXPONENT"
        };
        
        protected void buildTokenTypeASTClassMap() {
                tokenTypeToASTClassMap=null;
        };
        
        private static final long[] mk_tokenSet_0() {
                long[] data = { -2305733607806730238L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
        private static final long[] mk_tokenSet_1() {
                long[] data = { -2017503231655018494L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
        private static final long[] mk_tokenSet_2() {
                long[] data = { -2305803976550907904L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
        private static final long[] mk_tokenSet_3() {
                long[] data = { -2305803976550907902L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
        private static final long[] mk_tokenSet_4() {
                long[] data = { -2305839160922996736L, 1073741855L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
        private static final long[] mk_tokenSet_5() {
                long[] data = { -101704825569280L, -12885032961L, 2264993995194367L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
        private static final long[] mk_tokenSet_6() {
                long[] data = { -84112639524862L, -131073L, 11272193249935359L, 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 = { 575897802350002176L, 35184372088832L, 4398046511104L, 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, 1747396655419752448L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
        private static final long[] mk_tokenSet_9() {
                long[] data = { 575897802350002176L, 0L, 4398046511104L, 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 = { 575897802350002176L, 6917529027641135360L, 4398046543870L, 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 = { 2305420796748627968L, -35184372026880L, 2256197860229119L, 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 = { 575897802350002176L, 6917529027641135104L, 4398046543870L, 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 = { 2305455981120716800L, -35184372026368L, 2256197860229119L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
        private static final long[] mk_tokenSet_14() {
                long[] data = { 2305420796748627968L, -35184372034048L, 2256197860229119L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
        private static final long[] mk_tokenSet_15() {
                long[] data = { 575898352105816064L, 24576L, 9011597301252096L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
        private static final long[] mk_tokenSet_16() {
                long[] data = { 2305420796748627968L, -17179488256L, 2256197860229119L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
        private static final long[] mk_tokenSet_17() {
                long[] data = { -101704825569280L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
        private static final long[] mk_tokenSet_18() {
                long[] data = { 575897802350002176L, 1747396655419755840L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
        private static final long[] mk_tokenSet_19() {
                long[] data = { -1153304684409126912L, 9007200328489983L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
        private static final long[] mk_tokenSet_20() {
                long[] data = { 0L, 160L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
        private static final long[] mk_tokenSet_21() {
                long[] data = { 864831865943490560L, 9007199254740992L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
        private static final long[] mk_tokenSet_22() {
                long[] data = { 175921860444160L, 66560L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
        private static final long[] mk_tokenSet_23() {
                long[] data = { -1729941358572994560L, 9007200328483007L, 4398080065536L, 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 = { -1153339868781215744L, 9007200328487103L, 4398080065536L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
        private static final long[] mk_tokenSet_25() {
                long[] data = { 575897802350002176L, 9007199254740992L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
        private static final long[] mk_tokenSet_26() {
                long[] data = { 864831865943490560L, 9007199254745088L, 4398046511104L, 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 = { -1729765436712550400L, 9007200328550335L, 4398080065536L, 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 = { -1729906174200905728L, 9007200328483775L, 4398080065536L, 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 = { -101704825569278L, -12885035073L, 2256197902172159L, 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 = { 575898352105816064L, 16384L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
        private static final long[] mk_tokenSet_31() {
                long[] data = { 1152499292141780992L, 9007199254766592L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
        private static final long[] mk_tokenSet_32() {
                long[] data = { 575898352105816064L, 0L, 4398046511104L, 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 = { 1152499292141780992L, 9007199254740992L, 13194139533312L, 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 = { 864726312827224064L, 1280L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
        private static final long[] mk_tokenSet_35() {
                long[] data = { 576495936675512320L, 1280L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
        private static final long[] mk_tokenSet_36() {
                long[] data = { -1729906174200905728L, 6917529031130272063L, 4398054932478L, 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 = { 575897802350002176L, 9007199254794240L, 4398046543840L, 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 = { 1152499292141780992L, 8673968066687717376L, 4398046543870L, 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 = { -1729906174200905728L, 6917529031130272575L, 4398054932478L, 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 = { -383179802279936L, -13690342465L, 11263397156913151L, 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, 9007199254790144L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
        private static final long[] mk_tokenSet_42() {
                long[] data = { 575897802350002176L, 1747431839791894528L, 4398046511104L, 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 = { 575897802350002176L, 53248L, 4398046543840L, 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 = { 1152499292141780992L, 6926536226895876096L, 4398046543870L, 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 = { 2305420796748627968L, -17179742208L, 2256197860229119L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
        private static final long[] mk_tokenSet_46() {
                long[] data = { -84112639524862L, -133185L, 11263397156913151L, 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 = { 864831865943490560L, 9007199254757376L, 4398046511104L, 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 = { 576601489791778816L, 9216L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
        private static final long[] mk_tokenSet_49() {
                long[] data = { -576984669594058752L, -9007194959973569L, 4398054932479L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
        private static final long[] mk_tokenSet_50() {
                long[] data = { -101704825569280L, -133185L, 11263397156913151L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
        private static final long[] mk_tokenSet_51() {
                long[] data = { -1729941358572994560L, 1073741855L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
        private static final long[] mk_tokenSet_52() {
                long[] data = { -1153339868781215744L, 9007200328482847L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
        private static final long[] mk_tokenSet_53() {
                long[] data = { -383179802279936L, -12885036225L, 11263397123358719L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
        private static final long[] mk_tokenSet_54() {
                long[] data = { -2305839160922996736L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
        private static final long[] mk_tokenSet_55() {
                long[] data = { -2017608784771284992L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
        private static final long[] mk_tokenSet_56() {
                long[] data = { -1729906174200905728L, 6917529028714876959L, 4398046543870L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
        private static final long[] mk_tokenSet_57() {
                long[] data = { -383179802279936L, -16105999329L, 11263397114970111L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
        private static final long[] mk_tokenSet_58() {
                long[] data = { 575897802350002176L, 6917529027641397248L, 4398046543870L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
        private static final long[] mk_tokenSet_59() {
                long[] data = { -383179802279936L, -13153471681L, 11263397123358719L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
        private static final long[] mk_tokenSet_60() {
                long[] data = { 0L, 1610613248L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
        private static final long[] mk_tokenSet_61() {
                long[] data = { 2305456530876530688L, -17179741184L, 11263397114970111L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
        private static final long[] mk_tokenSet_62() {
                long[] data = { -576703194617348096L, -12885035073L, 4398088486911L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
        private static final long[] mk_tokenSet_63() {
                long[] data = { 1152921504606846976L, -9223372036854775808L, 1L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
        private static final long[] mk_tokenSet_64() {
                long[] data = { 575897802350002176L, 6917529027641143296L, 4398046543870L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
        private static final long[] mk_tokenSet_65() {
                long[] data = { 575897802350002176L, 6917529027641136896L, 4398046543870L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
        private static final long[] mk_tokenSet_66() {
                long[] data = { 576179277326712832L, 6917529027641135104L, 4398046543870L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
        private static final long[] mk_tokenSet_67() {
                long[] data = { 575898352105816064L, 24576L, 4398046511104L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
        private static final long[] mk_tokenSet_68() {
                long[] data = { 1152499292141780992L, 9007199254766592L, 9020393394274304L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
        private static final long[] mk_tokenSet_69() {
                long[] data = { -101704825569280L, -12885035073L, 11263397156913151L, 0L, 0L, 0L};
                return data;
        }
        public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
        
        }