---

DepthFirstAdapter.java

package edu.ksu.cis.bandera.jjjc.analysis;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Bandera, a Java(TM) analysis and transformation toolkit           *
 * Copyright (C) 1998-2001 SAnToS Laboratories (santos@cis.ksu.edu)  *

 * All rights reserved.                                              *
 *                                                                   *
 * This work was done as a project in the SAnToS Laboratory,         *
 * Department of Computing and Information Sciences, Kansas State    *
 * University, USA (http://www.cis.ksu.edu/santos).                  *
 * It is understood that any modification not identified as such is  *
 * not covered by the preceding statement.                           *
 *                                                                   *
 * This work is free software; you can redistribute it and/or        *
 * modify it under the terms of the GNU Library General Public       *
 * License as published by the Free Software Foundation; either      *
 * version 2 of the License, or (at your option) any later version.  *
 *                                                                   *
 * This work is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
 * Library General Public License for more details.                  *
 *                                                                   *
 * You should have received a copy of the GNU Library General Public *
 * License along with this toolkit; if not, write to the             *
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
 * Boston, MA  02111-1307, USA.                                      *
 *                                                                   *
 * Java is a trademark of Sun Microsystems, Inc.                     *
 *                                                                   *
 * To submit a bug report, send a comment, or get the latest news on *
 * this project and other SAnToS projects, please visit the web-site *
 *                http://www.cis.ksu.edu/santos                      *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
import ca.mcgill.sable.util.*;
import edu.ksu.cis.bandera.jjjc.node.*;

public class DepthFirstAdapter extends AnalysisAdapter
{
    public void caseAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
    {
        inAAbstractMethodDeclaration(node);
        if(node.getMethodHeader() != null)
        {
            node.getMethodHeader().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAAbstractMethodDeclaration(node);
    }
    public void caseAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        inAAbstractMethodDeclarationInterfaceMemberDeclaration(node);
        if(node.getMethodHeader() != null)
        {
            node.getMethodHeader().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAAbstractMethodDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAAbstractModifier(AAbstractModifier node)
    {
        inAAbstractModifier(node);
        if(node.getAbstract() != null)
        {
            node.getAbstract().apply(this);
        }
        outAAbstractModifier(node);
    }
    public void caseAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
    {
        inAAdditiveExpShiftExp(node);
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        outAAdditiveExpShiftExp(node);
    }
    public void caseAAndBinaryOperator(AAndBinaryOperator node)
    {
        inAAndBinaryOperator(node);
        if(node.getAnd() != null)
        {
            node.getAnd().apply(this);
        }
        outAAndBinaryOperator(node);
    }
    public void caseAAndExpAndExp(AAndExpAndExp node)
    {
        inAAndExpAndExp(node);
        if(node.getAndExp() != null)
        {
            node.getAndExp().apply(this);
        }
        if(node.getBitAnd() != null)
        {
            node.getBitAnd().apply(this);
        }
        if(node.getEqualityExp() != null)
        {
            node.getEqualityExp().apply(this);
        }
        outAAndExpAndExp(node);
    }
    public void caseAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
    {
        inAAndExpExclusiveOrExp(node);
        if(node.getAndExp() != null)
        {
            node.getAndExp().apply(this);
        }
        outAAndExpExclusiveOrExp(node);
    }
    public void caseAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        inAArgumentListArgumentList(node);
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAArgumentListArgumentList(node);
    }
    public void caseAArrayAccessExp(AArrayAccessExp node)
    {
        inAArrayAccessExp(node);
        if(node.getArrayAccess() != null)
        {
            node.getArrayAccess().apply(this);
        }
        outAArrayAccessExp(node);
    }
    public void caseAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
    {
        inAArrayAccessLeftHandSide(node);
        if(node.getArrayAccess() != null)
        {
            node.getArrayAccess().apply(this);
        }
        outAArrayAccessLeftHandSide(node);
    }
    public void caseAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
    {
        inAArrayAccessPrimaryNoNewArray(node);
        if(node.getArrayAccess() != null)
        {
            node.getArrayAccess().apply(this);
        }
        outAArrayAccessPrimaryNoNewArray(node);
    }
    public void caseAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
    {
        inAArrayCreationExpPrimary(node);
        if(node.getArrayCreationExp() != null)
        {
            node.getArrayCreationExp().apply(this);
        }
        outAArrayCreationExpPrimary(node);
    }
    public void caseAArrayInitializer(AArrayInitializer node)
    {
        inAArrayInitializer(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getVariableInitializer().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PVariableInitializer) temp[i]).apply(this);
            }
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAArrayInitializer(node);
    }
    public void caseAArrayReferenceType(AArrayReferenceType node)
    {
        inAArrayReferenceType(node);
        if(node.getArrayType() != null)
        {
            node.getArrayType().apply(this);
        }
        outAArrayReferenceType(node);
    }
    public void caseAArrayVariableInitializer(AArrayVariableInitializer node)
    {
        inAArrayVariableInitializer(node);
        if(node.getArrayInitializer() != null)
        {
            node.getArrayInitializer().apply(this);
        }
        outAArrayVariableInitializer(node);
    }
    public void caseAAssertionCompilationUnit(AAssertionCompilationUnit node)
    {
        inAAssertionCompilationUnit(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAAssertionCompilationUnit(node);
    }
    public void caseAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        inAAssignAssignmentOperator(node);
        if(node.getAssign() != null)
        {
            node.getAssign().apply(this);
        }
        outAAssignAssignmentOperator(node);
    }
    public void caseAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
    {
        inAAssignedVariableDeclarator(node);
        if(node.getVariableDeclaratorId() != null)
        {
            node.getVariableDeclaratorId().apply(this);
        }
        if(node.getAssign() != null)
        {
            node.getAssign().apply(this);
        }
        if(node.getVariableInitializer() != null)
        {
            node.getVariableInitializer().apply(this);
        }
        outAAssignedVariableDeclarator(node);
    }
    public void caseAAssignment(AAssignment node)
    {
        inAAssignment(node);
        if(node.getLeftHandSide() != null)
        {
            node.getLeftHandSide().apply(this);
        }
        if(node.getAssignmentOperator() != null)
        {
            node.getAssignmentOperator().apply(this);
        }
        if(node.getAssignmentExp() != null)
        {
            node.getAssignmentExp().apply(this);
        }
        outAAssignment(node);
    }
    public void caseAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
    {
        inAAssignmentAssignmentExp(node);
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outAAssignmentAssignmentExp(node);
    }
    public void caseAAssignmentExp(AAssignmentExp node)
    {
        inAAssignmentExp(node);
        if(node.getLeftHandSide() != null)
        {
            node.getLeftHandSide().apply(this);
        }
        if(node.getAssignmentOperator() != null)
        {
            node.getAssignmentOperator().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAAssignmentExp(node);
    }
    public void caseAAssignmentStmtExp(AAssignmentStmtExp node)
    {
        inAAssignmentStmtExp(node);
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outAAssignmentStmtExp(node);
    }
    public void caseABinaryExp(ABinaryExp node)
    {
        inABinaryExp(node);
        if(node.getFirst() != null)
        {
            node.getFirst().apply(this);
        }
        if(node.getBinaryOperator() != null)
        {
            node.getBinaryOperator().apply(this);
        }
        if(node.getSecond() != null)
        {
            node.getSecond().apply(this);
        }
        outABinaryExp(node);
    }
    public void caseABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
    {
        inABitAndAssignAssignmentOperator(node);
        if(node.getBitAndAssign() != null)
        {
            node.getBitAndAssign().apply(this);
        }
        outABitAndAssignAssignmentOperator(node);
    }
    public void caseABitAndBinaryOperator(ABitAndBinaryOperator node)
    {
        inABitAndBinaryOperator(node);
        if(node.getBitAnd() != null)
        {
            node.getBitAnd().apply(this);
        }
        outABitAndBinaryOperator(node);
    }
    public void caseABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
    {
        inABitComplementUnaryExpNotPlusMinus(node);
        if(node.getBitComplement() != null)
        {
            node.getBitComplement().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outABitComplementUnaryExpNotPlusMinus(node);
    }
    public void caseABitComplementUnaryOperator(ABitComplementUnaryOperator node)
    {
        inABitComplementUnaryOperator(node);
        if(node.getBitComplement() != null)
        {
            node.getBitComplement().apply(this);
        }
        outABitComplementUnaryOperator(node);
    }
    public void caseABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
    {
        inABitOrAssignAssignmentOperator(node);
        if(node.getBitOrAssign() != null)
        {
            node.getBitOrAssign().apply(this);
        }
        outABitOrAssignAssignmentOperator(node);
    }
    public void caseABitOrBinaryOperator(ABitOrBinaryOperator node)
    {
        inABitOrBinaryOperator(node);
        if(node.getBitOr() != null)
        {
            node.getBitOr().apply(this);
        }
        outABitOrBinaryOperator(node);
    }
    public void caseABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
    {
        inABitXorAssignAssignmentOperator(node);
        if(node.getBitXorAssign() != null)
        {
            node.getBitXorAssign().apply(this);
        }
        outABitXorAssignAssignmentOperator(node);
    }
    public void caseABitXorBinaryOperator(ABitXorBinaryOperator node)
    {
        inABitXorBinaryOperator(node);
        if(node.getBitXor() != null)
        {
            node.getBitXor().apply(this);
        }
        outABitXorBinaryOperator(node);
    }
    public void caseABlock(ABlock node)
    {
        inABlock(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getBlockedStmt().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PBlockedStmt) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outABlock(node);
    }
    public void caseABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
    {
        inABlockClassBodyDeclaration(node);
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outABlockClassBodyDeclaration(node);
    }
    public void caseABlockMethodBody(ABlockMethodBody node)
    {
        inABlockMethodBody(node);
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outABlockMethodBody(node);
    }
    public void caseABlockStmt(ABlockStmt node)
    {
        inABlockStmt(node);
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outABlockStmt(node);
    }
    public void caseABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
    {
        inABlockStmtWithoutTrailingSubstmt(node);
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outABlockStmtWithoutTrailingSubstmt(node);
    }
    public void caseABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        inABooleanLiteralLiteral(node);
        if(node.getBooleanLiteral() != null)
        {
            node.getBooleanLiteral().apply(this);
        }
        outABooleanLiteralLiteral(node);
    }
    public void caseABooleanPrimitiveType(ABooleanPrimitiveType node)
    {
        inABooleanPrimitiveType(node);
        if(node.getBoolean() != null)
        {
            node.getBoolean().apply(this);
        }
        outABooleanPrimitiveType(node);
    }
    public void caseABreakStmt(ABreakStmt node)
    {
        inABreakStmt(node);
        if(node.getBreak() != null)
        {
            node.getBreak().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outABreakStmt(node);
    }
    public void caseABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
    {
        inABreakStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneBreakStmt() != null)
        {
            node.getOneBreakStmt().apply(this);
        }
        outABreakStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseAByteIntegralType(AByteIntegralType node)
    {
        inAByteIntegralType(node);
        if(node.getByte() != null)
        {
            node.getByte().apply(this);
        }
        outAByteIntegralType(node);
    }
    public void caseABytePrimitiveType(ABytePrimitiveType node)
    {
        inABytePrimitiveType(node);
        if(node.getByte() != null)
        {
            node.getByte().apply(this);
        }
        outABytePrimitiveType(node);
    }
    public void caseACaseSwitchLabel(ACaseSwitchLabel node)
    {
        inACaseSwitchLabel(node);
        if(node.getCase() != null)
        {
            node.getCase().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        outACaseSwitchLabel(node);
    }
    public void caseACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
    {
        inACastExpUnaryExpNotPlusMinus(node);
        if(node.getCastExp() != null)
        {
            node.getCastExp().apply(this);
        }
        outACastExpUnaryExpNotPlusMinus(node);
    }
    public void caseACatchClause(ACatchClause node)
    {
        inACatchClause(node);
        if(node.getCatch() != null)
        {
            node.getCatch().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getFormalParameter() != null)
        {
            node.getFormalParameter().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outACatchClause(node);
    }
    public void caseACharacterLiteralLiteral(ACharacterLiteralLiteral node)
    {
        inACharacterLiteralLiteral(node);
        if(node.getCharacterLiteral() != null)
        {
            node.getCharacterLiteral().apply(this);
        }
        outACharacterLiteralLiteral(node);
    }
    public void caseACharIntegralType(ACharIntegralType node)
    {
        inACharIntegralType(node);
        if(node.getChar() != null)
        {
            node.getChar().apply(this);
        }
        outACharIntegralType(node);
    }
    public void caseACharPrimitiveType(ACharPrimitiveType node)
    {
        inACharPrimitiveType(node);
        if(node.getChar() != null)
        {
            node.getChar().apply(this);
        }
        outACharPrimitiveType(node);
    }
    public void caseAClassBody(AClassBody node)
    {
        inAClassBody(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getClassBodyDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PClassBodyDeclaration) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAClassBody(node);
    }
    public void caseAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
    {
        inAClassClassBodyDeclaration(node);
        if(node.getClassDeclaration() != null)
        {
            node.getClassDeclaration().apply(this);
        }
        outAClassClassBodyDeclaration(node);
    }
    public void caseAClassDeclaration(AClassDeclaration node)
    {
        inAClassDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getInterfaces() != null)
        {
            node.getInterfaces().apply(this);
        }
        if(node.getClassBody() != null)
        {
            node.getClassBody().apply(this);
        }
        outAClassDeclaration(node);
    }
    public void caseAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
    {
        inAClassDeclarationBlockedStmt(node);
        if(node.getClassDeclaration() != null)
        {
            node.getClassDeclaration().apply(this);
        }
        outAClassDeclarationBlockedStmt(node);
    }
    public void caseAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
    {
        inAClassDeclarationClassMemberDeclaration(node);
        if(node.getClassDeclaration() != null)
        {
            node.getClassDeclaration().apply(this);
        }
        outAClassDeclarationClassMemberDeclaration(node);
    }
    public void caseAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
    {
        inAClassDeclarationInterfaceMemberDeclaration(node);
        if(node.getClassDeclaration() != null)
        {
            node.getClassDeclaration().apply(this);
        }
        outAClassDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
    {
        inAClassInstanceCreationExpPrimaryNoNewArray(node);
        if(node.getClassInstanceCreationExp() != null)
        {
            node.getClassInstanceCreationExp().apply(this);
        }
        outAClassInstanceCreationExpPrimaryNoNewArray(node);
    }
    public void caseAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
    {
        inAClassInstanceCreationExpStmtExp(node);
        if(node.getClassInstanceCreationExp() != null)
        {
            node.getClassInstanceCreationExp().apply(this);
        }
        outAClassInstanceCreationExpStmtExp(node);
    }
    public void caseAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
    {
        inAClassMemberDeclarationClassBodyDeclaration(node);
        if(node.getClassMemberDeclaration() != null)
        {
            node.getClassMemberDeclaration().apply(this);
        }
        outAClassMemberDeclarationClassBodyDeclaration(node);
    }
    public void caseAClassOrInterfaceType(AClassOrInterfaceType node)
    {
        inAClassOrInterfaceType(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outAClassOrInterfaceType(node);
    }
    public void caseAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
    {
        inAClassOrInterfaceTypeArrayCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        {
            Object temp[] = node.getDimExp().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDimExp) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAClassOrInterfaceTypeArrayCreationExp(node);
    }
    public void caseAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
    {
        inAClassOrInterfaceTypeExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        {
            Object temp[] = node.getDimExp().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDimExp) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAClassOrInterfaceTypeExp(node);
    }
    public void caseAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
    {
        inAClassOrInterfaceTypeReferenceType(node);
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        outAClassOrInterfaceTypeReferenceType(node);
    }
    public void caseAClassType(AClassType node)
    {
        inAClassType(node);
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        outAClassType(node);
    }
    public void caseAClassTypeClassTypeList(AClassTypeClassTypeList node)
    {
        inAClassTypeClassTypeList(node);
        if(node.getClassType() != null)
        {
            node.getClassType().apply(this);
        }
        outAClassTypeClassTypeList(node);
    }
    public void caseAClassTypeDeclaration(AClassTypeDeclaration node)
    {
        inAClassTypeDeclaration(node);
        if(node.getClassDeclaration() != null)
        {
            node.getClassDeclaration().apply(this);
        }
        outAClassTypeDeclaration(node);
    }
    public void caseAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
    {
        inAClassTypeListClassTypeList(node);
        if(node.getClassTypeList() != null)
        {
            node.getClassTypeList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getClassType() != null)
        {
            node.getClassType().apply(this);
        }
        outAClassTypeListClassTypeList(node);
    }
    public void caseACompilationUnit(ACompilationUnit node)
    {
        inACompilationUnit(node);
        if(node.getPackage() != null)
        {
            node.getPackage().apply(this);
        }
        if(node.getPackageDeclaration() != null)
        {
            node.getPackageDeclaration().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        {
            Object temp[] = node.getImportDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PImportDeclaration) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getTypeDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PTypeDeclaration) temp[i]).apply(this);
            }
        }
        outACompilationUnit(node);
    }
    public void caseAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
    {
        inAComplementUnaryExpNotPlusMinus(node);
        if(node.getComplement() != null)
        {
            node.getComplement().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAComplementUnaryExpNotPlusMinus(node);
    }
    public void caseAComplementUnaryOperator(AComplementUnaryOperator node)
    {
        inAComplementUnaryOperator(node);
        if(node.getComplement() != null)
        {
            node.getComplement().apply(this);
        }
        outAComplementUnaryOperator(node);
    }
    public void caseAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
    {
        inAConditionalAndExpConditionalAndExp(node);
        if(node.getConditionalAndExp() != null)
        {
            node.getConditionalAndExp().apply(this);
        }
        if(node.getAnd() != null)
        {
            node.getAnd().apply(this);
        }
        if(node.getInclusiveOrExp() != null)
        {
            node.getInclusiveOrExp().apply(this);
        }
        outAConditionalAndExpConditionalAndExp(node);
    }
    public void caseAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
    {
        inAConditionalAndExpConditionalOrExp(node);
        if(node.getConditionalAndExp() != null)
        {
            node.getConditionalAndExp().apply(this);
        }
        outAConditionalAndExpConditionalOrExp(node);
    }
    public void caseAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
    {
        inAConditionalExpAssignmentExp(node);
        if(node.getConditionalExp() != null)
        {
            node.getConditionalExp().apply(this);
        }
        outAConditionalExpAssignmentExp(node);
    }
    public void caseAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
    {
        inAConditionalOrExpConditionalExp(node);
        if(node.getConditionalOrExp() != null)
        {
            node.getConditionalOrExp().apply(this);
        }
        outAConditionalOrExpConditionalExp(node);
    }
    public void caseAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
    {
        inAConditionalOrExpConditionalOrExp(node);
        if(node.getConditionalOrExp() != null)
        {
            node.getConditionalOrExp().apply(this);
        }
        if(node.getOr() != null)
        {
            node.getOr().apply(this);
        }
        if(node.getConditionalAndExp() != null)
        {
            node.getConditionalAndExp().apply(this);
        }
        outAConditionalOrExpConditionalOrExp(node);
    }
    public void caseAConstantDeclaration(AConstantDeclaration node)
    {
        inAConstantDeclaration(node);
        if(node.getFieldDeclaration() != null)
        {
            node.getFieldDeclaration().apply(this);
        }
        outAConstantDeclaration(node);
    }
    public void caseAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
    {
        inAConstantDeclarationInterfaceMemberDeclaration(node);
        if(node.getFieldDeclaration() != null)
        {
            node.getFieldDeclaration().apply(this);
        }
        outAConstantDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAConstantExp(AConstantExp node)
    {
        inAConstantExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAConstantExp(node);
    }
    public void caseAConstructorBody(AConstructorBody node)
    {
        inAConstructorBody(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        if(node.getConstructorInvocation() != null)
        {
            node.getConstructorInvocation().apply(this);
        }
        {
            Object temp[] = node.getBlockedStmt().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PBlockedStmt) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAConstructorBody(node);
    }
    public void caseAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
    {
        inAConstructorClassBodyDeclaration(node);
        if(node.getConstructorDeclaration() != null)
        {
            node.getConstructorDeclaration().apply(this);
        }
        outAConstructorClassBodyDeclaration(node);
    }
    public void caseAConstructorDeclaration(AConstructorDeclaration node)
    {
        inAConstructorDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getConstructorDeclarator() != null)
        {
            node.getConstructorDeclarator().apply(this);
        }
        if(node.getThrows() != null)
        {
            node.getThrows().apply(this);
        }
        if(node.getConstructorBody() != null)
        {
            node.getConstructorBody().apply(this);
        }
        outAConstructorDeclaration(node);
    }
    public void caseAConstructorDeclarator(AConstructorDeclarator node)
    {
        inAConstructorDeclarator(node);
        if(node.getSimpleName() != null)
        {
            node.getSimpleName().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getFormalParameter().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PFormalParameter) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outAConstructorDeclarator(node);
    }
    public void caseAContinueStmt(AContinueStmt node)
    {
        inAContinueStmt(node);
        if(node.getContinue() != null)
        {
            node.getContinue().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAContinueStmt(node);
    }
    public void caseAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
    {
        inAContinueStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneContinueStmt() != null)
        {
            node.getOneContinueStmt().apply(this);
        }
        outAContinueStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        inADecimalIntegerLiteral(node);
        if(node.getDecimalIntegerLiteral() != null)
        {
            node.getDecimalIntegerLiteral().apply(this);
        }
        outADecimalIntegerLiteral(node);
    }
    public void caseADecrementUnaryOperator(ADecrementUnaryOperator node)
    {
        inADecrementUnaryOperator(node);
        if(node.getMinusMinus() != null)
        {
            node.getMinusMinus().apply(this);
        }
        outADecrementUnaryOperator(node);
    }
    public void caseADefaultSwitchLabel(ADefaultSwitchLabel node)
    {
        inADefaultSwitchLabel(node);
        if(node.getDefault() != null)
        {
            node.getDefault().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        outADefaultSwitchLabel(node);
    }
    public void caseADim(ADim node)
    {
        inADim(node);
        if(node.getLBracket() != null)
        {
            node.getLBracket().apply(this);
        }
        if(node.getRBracket() != null)
        {
            node.getRBracket().apply(this);
        }
        outADim(node);
    }
    public void caseADimExp(ADimExp node)
    {
        inADimExp(node);
        if(node.getLBracket() != null)
        {
            node.getLBracket().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRBracket() != null)
        {
            node.getRBracket().apply(this);
        }
        outADimExp(node);
    }
    public void caseADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
    {
        inADivAssignAssignmentOperator(node);
        if(node.getDivAssign() != null)
        {
            node.getDivAssign().apply(this);
        }
        outADivAssignAssignmentOperator(node);
    }
    public void caseADivBinaryOperator(ADivBinaryOperator node)
    {
        inADivBinaryOperator(node);
        if(node.getDiv() != null)
        {
            node.getDiv().apply(this);
        }
        outADivBinaryOperator(node);
    }
    public void caseADivMultiplicativeExp(ADivMultiplicativeExp node)
    {
        inADivMultiplicativeExp(node);
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        if(node.getDiv() != null)
        {
            node.getDiv().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outADivMultiplicativeExp(node);
    }
    public void caseADoStmt(ADoStmt node)
    {
        inADoStmt(node);
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outADoStmt(node);
    }
    public void caseADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
    {
        inADoStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneDoStmt() != null)
        {
            node.getOneDoStmt().apply(this);
        }
        outADoStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseADoubleFloatingPointType(ADoubleFloatingPointType node)
    {
        inADoubleFloatingPointType(node);
        if(node.getDouble() != null)
        {
            node.getDouble().apply(this);
        }
        outADoubleFloatingPointType(node);
    }
    public void caseADoublePrimitiveType(ADoublePrimitiveType node)
    {
        inADoublePrimitiveType(node);
        if(node.getDouble() != null)
        {
            node.getDouble().apply(this);
        }
        outADoublePrimitiveType(node);
    }
    public void caseAEmptyMethodBody(AEmptyMethodBody node)
    {
        inAEmptyMethodBody(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAEmptyMethodBody(node);
    }
    public void caseAEmptyStmt(AEmptyStmt node)
    {
        inAEmptyStmt(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAEmptyStmt(node);
    }
    public void caseAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
    {
        inAEmptyStmtStmtWithoutTrailingSubstmt(node);
        if(node.getSemicolonStmt() != null)
        {
            node.getSemicolonStmt().apply(this);
        }
        outAEmptyStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
    {
        inAEmptyTypeDeclaration(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAEmptyTypeDeclaration(node);
    }
    public void caseAEqBinaryOperator(AEqBinaryOperator node)
    {
        inAEqBinaryOperator(node);
        if(node.getEq() != null)
        {
            node.getEq().apply(this);
        }
        outAEqBinaryOperator(node);
    }
    public void caseAEqEqualityExp(AEqEqualityExp node)
    {
        inAEqEqualityExp(node);
        if(node.getEqualityExp() != null)
        {
            node.getEqualityExp().apply(this);
        }
        if(node.getEq() != null)
        {
            node.getEq().apply(this);
        }
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        outAEqEqualityExp(node);
    }
    public void caseAEqualityExpAndExp(AEqualityExpAndExp node)
    {
        inAEqualityExpAndExp(node);
        if(node.getEqualityExp() != null)
        {
            node.getEqualityExp().apply(this);
        }
        outAEqualityExpAndExp(node);
    }
    public void caseAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
    {
        inAExclusiveOrExpExclusiveOrExp(node);
        if(node.getExclusiveOrExp() != null)
        {
            node.getExclusiveOrExp().apply(this);
        }
        if(node.getBitXor() != null)
        {
            node.getBitXor().apply(this);
        }
        if(node.getAndExp() != null)
        {
            node.getAndExp().apply(this);
        }
        outAExclusiveOrExpExclusiveOrExp(node);
    }
    public void caseAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
    {
        inAExclusiveOrExpInclusiveOrExp(node);
        if(node.getExclusiveOrExp() != null)
        {
            node.getExclusiveOrExp().apply(this);
        }
        outAExclusiveOrExpInclusiveOrExp(node);
    }
    public void caseAExpArgumentList(AExpArgumentList node)
    {
        inAExpArgumentList(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAExpArgumentList(node);
    }
    public void caseAExpCastExp(AExpCastExp node)
    {
        inAExpCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getFirst() != null)
        {
            node.getFirst().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSecond() != null)
        {
            node.getSecond().apply(this);
        }
        outAExpCastExp(node);
    }
    public void caseAExpListForInit(AExpListForInit node)
    {
        inAExpListForInit(node);
        {
            Object temp[] = node.getExp().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        outAExpListForInit(node);
    }
    public void caseAExpStmt(AExpStmt node)
    {
        inAExpStmt(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAExpStmt(node);
    }
    public void caseAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
    {
        inAExpStmtStmtWithoutTrailingSubstmt(node);
        if(node.getExpStmt() != null)
        {
            node.getExpStmt().apply(this);
        }
        outAExpStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseAExpVariableInitializer(AExpVariableInitializer node)
    {
        inAExpVariableInitializer(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAExpVariableInitializer(node);
    }
    public void caseAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
    {
        inAExtendsExtendsInterfaces(node);
        if(node.getExtends() != null)
        {
            node.getExtends().apply(this);
        }
        if(node.getInterfaceType() != null)
        {
            node.getInterfaceType().apply(this);
        }
        outAExtendsExtendsInterfaces(node);
    }
    public void caseAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
    {
        inAExtendsInterfacesExtendsInterfaces(node);
        if(node.getExtendsInterfaces() != null)
        {
            node.getExtendsInterfaces().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getInterfaceType() != null)
        {
            node.getInterfaceType().apply(this);
        }
        outAExtendsInterfacesExtendsInterfaces(node);
    }
    public void caseAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        inAFalseBooleanLiteral(node);
        if(node.getFalse() != null)
        {
            node.getFalse().apply(this);
        }
        outAFalseBooleanLiteral(node);
    }
    public void caseAFieldAccessExp(AFieldAccessExp node)
    {
        inAFieldAccessExp(node);
        if(node.getFieldAccess() != null)
        {
            node.getFieldAccess().apply(this);
        }
        outAFieldAccessExp(node);
    }
    public void caseAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
    {
        inAFieldAccessLeftHandSide(node);
        if(node.getFieldAccess() != null)
        {
            node.getFieldAccess().apply(this);
        }
        outAFieldAccessLeftHandSide(node);
    }
    public void caseAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
    {
        inAFieldAccessPrimaryNoNewArray(node);
        if(node.getFieldAccess() != null)
        {
            node.getFieldAccess().apply(this);
        }
        outAFieldAccessPrimaryNoNewArray(node);
    }
    public void caseAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
    {
        inAFieldClassBodyDeclaration(node);
        if(node.getFieldDeclaration() != null)
        {
            node.getFieldDeclaration().apply(this);
        }
        outAFieldClassBodyDeclaration(node);
    }
    public void caseAFieldDeclaration(AFieldDeclaration node)
    {
        inAFieldDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        {
            Object temp[] = node.getVariableDeclarator().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PVariableDeclarator) temp[i]).apply(this);
            }
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAFieldDeclaration(node);
    }
    public void caseAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
    {
        inAFieldDeclarationClassMemberDeclaration(node);
        if(node.getFieldDeclaration() != null)
        {
            node.getFieldDeclaration().apply(this);
        }
        outAFieldDeclarationClassMemberDeclaration(node);
    }
    public void caseAFinally(AFinally node)
    {
        inAFinally(node);
        if(node.getFinally() != null)
        {
            node.getFinally().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAFinally(node);
    }
    public void caseAFinallyOneTryStmt(AFinallyOneTryStmt node)
    {
        inAFinallyOneTryStmt(node);
        if(node.getTry() != null)
        {
            node.getTry().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        {
            Object temp[] = node.getCatchClause().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PCatchClause) temp[i]).apply(this);
            }
        }
        if(node.getFinally() != null)
        {
            node.getFinally().apply(this);
        }
        outAFinallyOneTryStmt(node);
    }
    public void caseAFinalModifier(AFinalModifier node)
    {
        inAFinalModifier(node);
        if(node.getFinal() != null)
        {
            node.getFinal().apply(this);
        }
        outAFinalModifier(node);
    }
    public void caseAFloatFloatingPointType(AFloatFloatingPointType node)
    {
        inAFloatFloatingPointType(node);
        if(node.getFloat() != null)
        {
            node.getFloat().apply(this);
        }
        outAFloatFloatingPointType(node);
    }
    public void caseAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        inAFloatingPointLiteralLiteral(node);
        if(node.getFloatingPointLiteral() != null)
        {
            node.getFloatingPointLiteral().apply(this);
        }
        outAFloatingPointLiteralLiteral(node);
    }
    public void caseAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
    {
        inAFloatingPointTypeNumericType(node);
        if(node.getFloatingPointType() != null)
        {
            node.getFloatingPointType().apply(this);
        }
        outAFloatingPointTypeNumericType(node);
    }
    public void caseAFloatPrimitiveType(AFloatPrimitiveType node)
    {
        inAFloatPrimitiveType(node);
        if(node.getFloat() != null)
        {
            node.getFloat().apply(this);
        }
        outAFloatPrimitiveType(node);
    }
    public void caseAFormalParameter(AFormalParameter node)
    {
        inAFormalParameter(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        if(node.getVariableDeclaratorId() != null)
        {
            node.getVariableDeclaratorId().apply(this);
        }
        outAFormalParameter(node);
    }
    public void caseAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
    {
        inAFormalParameterFormalParameterList(node);
        if(node.getFormalParameter() != null)
        {
            node.getFormalParameter().apply(this);
        }
        outAFormalParameterFormalParameterList(node);
    }
    public void caseAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
    {
        inAFormalParameterListFormalParameterList(node);
        if(node.getFormalParameterList() != null)
        {
            node.getFormalParameterList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getFormalParameter() != null)
        {
            node.getFormalParameter().apply(this);
        }
        outAFormalParameterListFormalParameterList(node);
    }
    public void caseAForStmt(AForStmt node)
    {
        inAForStmt(node);
        if(node.getFor() != null)
        {
            node.getFor().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getForInit() != null)
        {
            node.getForInit().apply(this);
        }
        if(node.getSemicolon1() != null)
        {
            node.getSemicolon1().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon2() != null)
        {
            node.getSemicolon2().apply(this);
        }
        {
            Object temp[] = node.getForUpdate().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAForStmt(node);
    }
    public void caseAForStmtNoShortIf(AForStmtNoShortIf node)
    {
        inAForStmtNoShortIf(node);
        if(node.getFor() != null)
        {
            node.getFor().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getForInit() != null)
        {
            node.getForInit().apply(this);
        }
        if(node.getSemicolon1() != null)
        {
            node.getSemicolon1().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon2() != null)
        {
            node.getSemicolon2().apply(this);
        }
        if(node.getForUpdate() != null)
        {
            node.getForUpdate().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmtNoShortIf() != null)
        {
            node.getStmtNoShortIf().apply(this);
        }
        outAForStmtNoShortIf(node);
    }
    public void caseAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
    {
        inAForStmtNoShortIfStmtNoShortIf(node);
        if(node.getForStmtNoShortIf() != null)
        {
            node.getForStmtNoShortIf().apply(this);
        }
        outAForStmtNoShortIfStmtNoShortIf(node);
    }
    public void caseAForStmtStmt(AForStmtStmt node)
    {
        inAForStmtStmt(node);
        if(node.getOneForStmt() != null)
        {
            node.getOneForStmt().apply(this);
        }
        outAForStmtStmt(node);
    }
    public void caseAForUpdate(AForUpdate node)
    {
        inAForUpdate(node);
        if(node.getStmtExpList() != null)
        {
            node.getStmtExpList().apply(this);
        }
        outAForUpdate(node);
    }
    public void caseAGtBinaryOperator(AGtBinaryOperator node)
    {
        inAGtBinaryOperator(node);
        if(node.getGt() != null)
        {
            node.getGt().apply(this);
        }
        outAGtBinaryOperator(node);
    }
    public void caseAGteqBinaryOperator(AGteqBinaryOperator node)
    {
        inAGteqBinaryOperator(node);
        if(node.getGteq() != null)
        {
            node.getGteq().apply(this);
        }
        outAGteqBinaryOperator(node);
    }
    public void caseAGteqRelationalExp(AGteqRelationalExp node)
    {
        inAGteqRelationalExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        if(node.getGteq() != null)
        {
            node.getGteq().apply(this);
        }
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        outAGteqRelationalExp(node);
    }
    public void caseAGtRelationalExp(AGtRelationalExp node)
    {
        inAGtRelationalExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        if(node.getGt() != null)
        {
            node.getGt().apply(this);
        }
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        outAGtRelationalExp(node);
    }
    public void caseAHexIntegerLiteral(AHexIntegerLiteral node)
    {
        inAHexIntegerLiteral(node);
        if(node.getHexIntegerLiteral() != null)
        {
            node.getHexIntegerLiteral().apply(this);
        }
        outAHexIntegerLiteral(node);
    }
    public void caseAIdVariableDeclarator(AIdVariableDeclarator node)
    {
        inAIdVariableDeclarator(node);
        if(node.getVariableDeclaratorId() != null)
        {
            node.getVariableDeclaratorId().apply(this);
        }
        outAIdVariableDeclarator(node);
    }
    public void caseAIfStmt(AIfStmt node)
    {
        inAIfStmt(node);
        if(node.getIf() != null)
        {
            node.getIf().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getThenPart() != null)
        {
            node.getThenPart().apply(this);
        }
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAIfStmt(node);
    }
    public void caseAIfThenElseStmt(AIfThenElseStmt node)
    {
        inAIfThenElseStmt(node);
        if(node.getIf() != null)
        {
            node.getIf().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmtNoShortIf() != null)
        {
            node.getStmtNoShortIf().apply(this);
        }
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outAIfThenElseStmt(node);
    }
    public void caseAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
    {
        inAIfThenElseStmtNoShortIf(node);
        if(node.getIf() != null)
        {
            node.getIf().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmtNoShortIf1() != null)
        {
            node.getStmtNoShortIf1().apply(this);
        }
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        if(node.getStmtNoShortIf2() != null)
        {
            node.getStmtNoShortIf2().apply(this);
        }
        outAIfThenElseStmtNoShortIf(node);
    }
    public void caseAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
    {
        inAIfThenElseStmtNoShortIfStmtNoShortIf(node);
        if(node.getIfThenElseStmtNoShortIf() != null)
        {
            node.getIfThenElseStmtNoShortIf().apply(this);
        }
        outAIfThenElseStmtNoShortIfStmtNoShortIf(node);
    }
    public void caseAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
    {
        inAIfThenElseStmtStmt(node);
        if(node.getIfThenElseStmt() != null)
        {
            node.getIfThenElseStmt().apply(this);
        }
        outAIfThenElseStmtStmt(node);
    }
    public void caseAIfThenStmt(AIfThenStmt node)
    {
        inAIfThenStmt(node);
        if(node.getIf() != null)
        {
            node.getIf().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outAIfThenStmt(node);
    }
    public void caseAIfThenStmtStmt(AIfThenStmtStmt node)
    {
        inAIfThenStmtStmt(node);
        if(node.getIfThenStmt() != null)
        {
            node.getIfThenStmt().apply(this);
        }
        outAIfThenStmtStmt(node);
    }
    public void caseAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
    {
        inAInclusiveOrExpConditionalAndExp(node);
        if(node.getInclusiveOrExp() != null)
        {
            node.getInclusiveOrExp().apply(this);
        }
        outAInclusiveOrExpConditionalAndExp(node);
    }
    public void caseAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
    {
        inAInclusiveOrExpInclusiveOrExp(node);
        if(node.getInclusiveOrExp() != null)
        {
            node.getInclusiveOrExp().apply(this);
        }
        if(node.getBitOr() != null)
        {
            node.getBitOr().apply(this);
        }
        if(node.getExclusiveOrExp() != null)
        {
            node.getExclusiveOrExp().apply(this);
        }
        outAInclusiveOrExpInclusiveOrExp(node);
    }
    public void caseAIncrementUnaryOperator(AIncrementUnaryOperator node)
    {
        inAIncrementUnaryOperator(node);
        if(node.getPlusPlus() != null)
        {
            node.getPlusPlus().apply(this);
        }
        outAIncrementUnaryOperator(node);
    }
    public void caseAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
    {
        inAInitClassInterfaceArrayCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getArrayInitializer() != null)
        {
            node.getArrayInitializer().apply(this);
        }
        outAInitClassInterfaceArrayCreationExp(node);
    }
    public void caseAInitClassInterfaceExp(AInitClassInterfaceExp node)
    {
        inAInitClassInterfaceExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getArrayInitializer() != null)
        {
            node.getArrayInitializer().apply(this);
        }
        outAInitClassInterfaceExp(node);
    }
    public void caseAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
    {
        inAInitPrimitiveArrayCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getArrayInitializer() != null)
        {
            node.getArrayInitializer().apply(this);
        }
        outAInitPrimitiveArrayCreationExp(node);
    }
    public void caseAInitPrimitiveExp(AInitPrimitiveExp node)
    {
        inAInitPrimitiveExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getArrayInitializer() != null)
        {
            node.getArrayInitializer().apply(this);
        }
        outAInitPrimitiveExp(node);
    }
    public void caseAInstanceofExp(AInstanceofExp node)
    {
        inAInstanceofExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getInstanceof() != null)
        {
            node.getInstanceof().apply(this);
        }
        if(node.getReferenceType() != null)
        {
            node.getReferenceType().apply(this);
        }
        outAInstanceofExp(node);
    }
    public void caseAInstanceofRelationalExp(AInstanceofRelationalExp node)
    {
        inAInstanceofRelationalExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        if(node.getInstanceof() != null)
        {
            node.getInstanceof().apply(this);
        }
        if(node.getReferenceType() != null)
        {
            node.getReferenceType().apply(this);
        }
        outAInstanceofRelationalExp(node);
    }
    public void caseAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        inAIntegerLiteralLiteral(node);
        if(node.getIntegerLiteral() != null)
        {
            node.getIntegerLiteral().apply(this);
        }
        outAIntegerLiteralLiteral(node);
    }
    public void caseAIntegralTypeNumericType(AIntegralTypeNumericType node)
    {
        inAIntegralTypeNumericType(node);
        if(node.getIntegralType() != null)
        {
            node.getIntegralType().apply(this);
        }
        outAIntegralTypeNumericType(node);
    }
    public void caseAInterfaceBody(AInterfaceBody node)
    {
        inAInterfaceBody(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getInterfaceMemberDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PInterfaceMemberDeclaration) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAInterfaceBody(node);
    }
    public void caseAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
    {
        inAInterfaceClassBodyDeclaration(node);
        if(node.getInterfaceDeclaration() != null)
        {
            node.getInterfaceDeclaration().apply(this);
        }
        outAInterfaceClassBodyDeclaration(node);
    }
    public void caseAInterfaceDeclaration(AInterfaceDeclaration node)
    {
        inAInterfaceDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getInterface() != null)
        {
            node.getInterface().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getExtends() != null)
        {
            node.getExtends().apply(this);
        }
        {
            Object temp[] = node.getName().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PName) temp[i]).apply(this);
            }
        }
        if(node.getInterfaceBody() != null)
        {
            node.getInterfaceBody().apply(this);
        }
        outAInterfaceDeclaration(node);
    }
    public void caseAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
    {
        inAInterfaceDeclarationClassMemberDeclaration(node);
        if(node.getInterfaceDeclaration() != null)
        {
            node.getInterfaceDeclaration().apply(this);
        }
        outAInterfaceDeclarationClassMemberDeclaration(node);
    }
    public void caseAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
    {
        inAInterfaceDeclarationInterfaceMemberDeclaration(node);
        if(node.getInterfaceDeclaration() != null)
        {
            node.getInterfaceDeclaration().apply(this);
        }
        outAInterfaceDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAInterfaces(AInterfaces node)
    {
        inAInterfaces(node);
        if(node.getImplements() != null)
        {
            node.getImplements().apply(this);
        }
        {
            Object temp[] = node.getName().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PName) temp[i]).apply(this);
            }
        }
        outAInterfaces(node);
    }
    public void caseAInterfaceType(AInterfaceType node)
    {
        inAInterfaceType(node);
        if(node.getClassOrInterfaceType() != null)
        {
            node.getClassOrInterfaceType().apply(this);
        }
        outAInterfaceType(node);
    }
    public void caseAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
    {
        inAInterfaceTypeDeclaration(node);
        if(node.getInterfaceDeclaration() != null)
        {
            node.getInterfaceDeclaration().apply(this);
        }
        outAInterfaceTypeDeclaration(node);
    }
    public void caseAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
    {
        inAInterfaceTypeInterfaceTypeList(node);
        if(node.getInterfaceType() != null)
        {
            node.getInterfaceType().apply(this);
        }
        outAInterfaceTypeInterfaceTypeList(node);
    }
    public void caseAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
    {
        inAInterfaceTypeListInterfaceTypeList(node);
        if(node.getInterfaceTypeList() != null)
        {
            node.getInterfaceTypeList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getInterfaceType() != null)
        {
            node.getInterfaceType().apply(this);
        }
        outAInterfaceTypeListInterfaceTypeList(node);
    }
    public void caseAIntIntegralType(AIntIntegralType node)
    {
        inAIntIntegralType(node);
        if(node.getInt() != null)
        {
            node.getInt().apply(this);
        }
        outAIntIntegralType(node);
    }
    public void caseAIntPrimitiveType(AIntPrimitiveType node)
    {
        inAIntPrimitiveType(node);
        if(node.getInt() != null)
        {
            node.getInt().apply(this);
        }
        outAIntPrimitiveType(node);
    }
    public void caseALabeledStmt(ALabeledStmt node)
    {
        inALabeledStmt(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outALabeledStmt(node);
    }
    public void caseALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
    {
        inALabeledStmtNoShortIf(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getStmtNoShortIf() != null)
        {
            node.getStmtNoShortIf().apply(this);
        }
        outALabeledStmtNoShortIf(node);
    }
    public void caseALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
    {
        inALabeledStmtNoShortIfStmtNoShortIf(node);
        if(node.getLabeledStmtNoShortIf() != null)
        {
            node.getLabeledStmtNoShortIf().apply(this);
        }
        outALabeledStmtNoShortIfStmtNoShortIf(node);
    }
    public void caseALabeledStmtStmt(ALabeledStmtStmt node)
    {
        inALabeledStmtStmt(node);
        if(node.getLabeledStmt() != null)
        {
            node.getLabeledStmt().apply(this);
        }
        outALabeledStmtStmt(node);
    }
    public void caseALabelStmt(ALabelStmt node)
    {
        inALabelStmt(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outALabelStmt(node);
    }
    public void caseALiteralExp(ALiteralExp node)
    {
        inALiteralExp(node);
        if(node.getLiteral() != null)
        {
            node.getLiteral().apply(this);
        }
        outALiteralExp(node);
    }
    public void caseALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        inALiteralPrimaryNoNewArray(node);
        if(node.getLiteral() != null)
        {
            node.getLiteral().apply(this);
        }
        outALiteralPrimaryNoNewArray(node);
    }
    public void caseALocalVariableDeclaration(ALocalVariableDeclaration node)
    {
        inALocalVariableDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        {
            Object temp[] = node.getVariableDeclarator().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PVariableDeclarator) temp[i]).apply(this);
            }
        }
        outALocalVariableDeclaration(node);
    }
    public void caseALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
    {
        inALocalVariableDeclarationForInit(node);
        if(node.getLocalVariableDeclaration() != null)
        {
            node.getLocalVariableDeclaration().apply(this);
        }
        outALocalVariableDeclarationForInit(node);
    }
    public void caseALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
    {
        inALocalVariableDeclarationInBlockedStmt(node);
        if(node.getLocalVariableDeclaration() != null)
        {
            node.getLocalVariableDeclaration().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outALocalVariableDeclarationInBlockedStmt(node);
    }
    public void caseALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
    {
        inALocalVariableDeclarationStmt(node);
        if(node.getLocalVariableDeclaration() != null)
        {
            node.getLocalVariableDeclaration().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outALocalVariableDeclarationStmt(node);
    }
    public void caseALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
    {
        inALocalVariableDeclarationStmtBlockedStmt(node);
        if(node.getLocalVariableDeclarationStmt() != null)
        {
            node.getLocalVariableDeclarationStmt().apply(this);
        }
        outALocalVariableDeclarationStmtBlockedStmt(node);
    }
    public void caseALongIntegralType(ALongIntegralType node)
    {
        inALongIntegralType(node);
        if(node.getLong() != null)
        {
            node.getLong().apply(this);
        }
        outALongIntegralType(node);
    }
    public void caseALongPrimitiveType(ALongPrimitiveType node)
    {
        inALongPrimitiveType(node);
        if(node.getLong() != null)
        {
            node.getLong().apply(this);
        }
        outALongPrimitiveType(node);
    }
    public void caseALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
    {
        inALParPrimaryNoNewArray(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outALParPrimaryNoNewArray(node);
    }
    public void caseALtBinaryOperator(ALtBinaryOperator node)
    {
        inALtBinaryOperator(node);
        if(node.getLt() != null)
        {
            node.getLt().apply(this);
        }
        outALtBinaryOperator(node);
    }
    public void caseALteqBinaryOperator(ALteqBinaryOperator node)
    {
        inALteqBinaryOperator(node);
        if(node.getLteq() != null)
        {
            node.getLteq().apply(this);
        }
        outALteqBinaryOperator(node);
    }
    public void caseALteqRelationalExp(ALteqRelationalExp node)
    {
        inALteqRelationalExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        if(node.getLteq() != null)
        {
            node.getLteq().apply(this);
        }
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        outALteqRelationalExp(node);
    }
    public void caseALtRelationalExp(ALtRelationalExp node)
    {
        inALtRelationalExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        if(node.getLt() != null)
        {
            node.getLt().apply(this);
        }
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        outALtRelationalExp(node);
    }
    public void caseAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
    {
        inAMethodClassBodyDeclaration(node);
        if(node.getMethodDeclaration() != null)
        {
            node.getMethodDeclaration().apply(this);
        }
        outAMethodClassBodyDeclaration(node);
    }
    public void caseAMethodDeclaration(AMethodDeclaration node)
    {
        inAMethodDeclaration(node);
        if(node.getMethodHeader() != null)
        {
            node.getMethodHeader().apply(this);
        }
        if(node.getMethodBody() != null)
        {
            node.getMethodBody().apply(this);
        }
        outAMethodDeclaration(node);
    }
    public void caseAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
    {
        inAMethodDeclarationClassMemberDeclaration(node);
        if(node.getMethodDeclaration() != null)
        {
            node.getMethodDeclaration().apply(this);
        }
        outAMethodDeclarationClassMemberDeclaration(node);
    }
    public void caseAMethodDeclarator(AMethodDeclarator node)
    {
        inAMethodDeclarator(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getFormalParameter().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PFormalParameter) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAMethodDeclarator(node);
    }
    public void caseAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        inAMethodInvocationPrimaryNoNewArray(node);
        if(node.getMethodInvocation() != null)
        {
            node.getMethodInvocation().apply(this);
        }
        outAMethodInvocationPrimaryNoNewArray(node);
    }
    public void caseAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
    {
        inAMethodInvocationStmtExp(node);
        if(node.getMethodInvocation() != null)
        {
            node.getMethodInvocation().apply(this);
        }
        outAMethodInvocationStmtExp(node);
    }
    public void caseAMinusAdditiveExp(AMinusAdditiveExp node)
    {
        inAMinusAdditiveExp(node);
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        outAMinusAdditiveExp(node);
    }
    public void caseAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
    {
        inAMinusAssignAssignmentOperator(node);
        if(node.getMinusAssign() != null)
        {
            node.getMinusAssign().apply(this);
        }
        outAMinusAssignAssignmentOperator(node);
    }
    public void caseAMinusBinaryOperator(AMinusBinaryOperator node)
    {
        inAMinusBinaryOperator(node);
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        outAMinusBinaryOperator(node);
    }
    public void caseAMinusUnaryExp(AMinusUnaryExp node)
    {
        inAMinusUnaryExp(node);
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAMinusUnaryExp(node);
    }
    public void caseAMinusUnaryOperator(AMinusUnaryOperator node)
    {
        inAMinusUnaryOperator(node);
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        outAMinusUnaryOperator(node);
    }
    public void caseAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
    {
        inAModAssignAssignmentOperator(node);
        if(node.getModAssign() != null)
        {
            node.getModAssign().apply(this);
        }
        outAModAssignAssignmentOperator(node);
    }
    public void caseAModBinaryOperator(AModBinaryOperator node)
    {
        inAModBinaryOperator(node);
        if(node.getMod() != null)
        {
            node.getMod().apply(this);
        }
        outAModBinaryOperator(node);
    }
    public void caseAModMultiplicativeExp(AModMultiplicativeExp node)
    {
        inAModMultiplicativeExp(node);
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        if(node.getMod() != null)
        {
            node.getMod().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAModMultiplicativeExp(node);
    }
    public void caseAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
    {
        inAMultiplicativeExpAdditiveExp(node);
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        outAMultiplicativeExpAdditiveExp(node);
    }
    public void caseANameArrayAccess(ANameArrayAccess node)
    {
        inANameArrayAccess(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLBracket() != null)
        {
            node.getLBracket().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRBracket() != null)
        {
            node.getRBracket().apply(this);
        }
        outANameArrayAccess(node);
    }
    public void caseANameArrayType(ANameArrayType node)
    {
        inANameArrayType(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outANameArrayType(node);
    }
    public void caseANameCastExp(ANameCastExp node)
    {
        inANameCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outANameCastExp(node);
    }
    public void caseANamedTypeExp(ANamedTypeExp node)
    {
        inANamedTypeExp(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outANamedTypeExp(node);
    }
    public void caseANameExp(ANameExp node)
    {
        inANameExp(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outANameExp(node);
    }
    public void caseANameLeftHandSide(ANameLeftHandSide node)
    {
        inANameLeftHandSide(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outANameLeftHandSide(node);
    }
    public void caseANameMethodInvocation(ANameMethodInvocation node)
    {
        inANameMethodInvocation(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outANameMethodInvocation(node);
    }
    public void caseANameMethodInvocationExp(ANameMethodInvocationExp node)
    {
        inANameMethodInvocationExp(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outANameMethodInvocationExp(node);
    }
    public void caseANamePostfixExp(ANamePostfixExp node)
    {
        inANamePostfixExp(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outANamePostfixExp(node);
    }
    public void caseANameReferenceType(ANameReferenceType node)
    {
        inANameReferenceType(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outANameReferenceType(node);
    }
    public void caseANativeModifier(ANativeModifier node)
    {
        inANativeModifier(node);
        if(node.getNative() != null)
        {
            node.getNative().apply(this);
        }
        outANativeModifier(node);
    }
    public void caseANeqBinaryOperator(ANeqBinaryOperator node)
    {
        inANeqBinaryOperator(node);
        if(node.getNeq() != null)
        {
            node.getNeq().apply(this);
        }
        outANeqBinaryOperator(node);
    }
    public void caseANeqEqualityExp(ANeqEqualityExp node)
    {
        inANeqEqualityExp(node);
        if(node.getEqualityExp() != null)
        {
            node.getEqualityExp().apply(this);
        }
        if(node.getNeq() != null)
        {
            node.getNeq().apply(this);
        }
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        outANeqEqualityExp(node);
    }
    public void caseANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
    {
        inANotPlusMinusUnaryExp(node);
        if(node.getUnaryExpNotPlusMinus() != null)
        {
            node.getUnaryExpNotPlusMinus().apply(this);
        }
        outANotPlusMinusUnaryExp(node);
    }
    public void caseANullLiteral(ANullLiteral node)
    {
        inANullLiteral(node);
        if(node.getNull() != null)
        {
            node.getNull().apply(this);
        }
        outANullLiteral(node);
    }
    public void caseANullLiteralLiteral(ANullLiteralLiteral node)
    {
        inANullLiteralLiteral(node);
        if(node.getNullLiteral() != null)
        {
            node.getNullLiteral().apply(this);
        }
        outANullLiteralLiteral(node);
    }
    public void caseANumericTypePrimitiveType(ANumericTypePrimitiveType node)
    {
        inANumericTypePrimitiveType(node);
        if(node.getNumericType() != null)
        {
            node.getNumericType().apply(this);
        }
        outANumericTypePrimitiveType(node);
    }
    public void caseAOctalIntegerLiteral(AOctalIntegerLiteral node)
    {
        inAOctalIntegerLiteral(node);
        if(node.getOctalIntegerLiteral() != null)
        {
            node.getOctalIntegerLiteral().apply(this);
        }
        outAOctalIntegerLiteral(node);
    }
    public void caseAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        inAOldAbstractMethodDeclarationInterfaceMemberDeclaration(node);
        if(node.getAbstractMethodDeclaration() != null)
        {
            node.getAbstractMethodDeclaration().apply(this);
        }
        outAOldAbstractMethodDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAOldArrayInitializer(AOldArrayInitializer node)
    {
        inAOldArrayInitializer(node);
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        if(node.getVariableInitializers() != null)
        {
            node.getVariableInitializers().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAOldArrayInitializer(node);
    }
    public void caseAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
    {
        inAOldCaseSwitchLabel(node);
        if(node.getCase() != null)
        {
            node.getCase().apply(this);
        }
        if(node.getConstantExp() != null)
        {
            node.getConstantExp().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        outAOldCaseSwitchLabel(node);
    }
    public void caseAOldCompilationUnit(AOldCompilationUnit node)
    {
        inAOldCompilationUnit(node);
        if(node.getPackageDeclaration() != null)
        {
            node.getPackageDeclaration().apply(this);
        }
        {
            Object temp[] = node.getImportDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PImportDeclaration) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getTypeDeclaration().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PTypeDeclaration) temp[i]).apply(this);
            }
        }
        outAOldCompilationUnit(node);
    }
    public void caseAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
    {
        inAOldConstantDeclarationInterfaceMemberDeclaration(node);
        if(node.getConstantDeclaration() != null)
        {
            node.getConstantDeclaration().apply(this);
        }
        outAOldConstantDeclarationInterfaceMemberDeclaration(node);
    }
    public void caseAOldConstructorDeclarator(AOldConstructorDeclarator node)
    {
        inAOldConstructorDeclarator(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getFormalParameterList() != null)
        {
            node.getFormalParameterList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outAOldConstructorDeclarator(node);
    }
    public void caseAOldExp(AOldExp node)
    {
        inAOldExp(node);
        if(node.getAssignmentExp() != null)
        {
            node.getAssignmentExp().apply(this);
        }
        outAOldExp(node);
    }
    public void caseAOldExpCastExp(AOldExpCastExp node)
    {
        inAOldExpCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getUnaryExpNotPlusMinus() != null)
        {
            node.getUnaryExpNotPlusMinus().apply(this);
        }
        outAOldExpCastExp(node);
    }
    public void caseAOldFieldDeclaration(AOldFieldDeclaration node)
    {
        inAOldFieldDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        if(node.getVariableDeclarators() != null)
        {
            node.getVariableDeclarators().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOldFieldDeclaration(node);
    }
    public void caseAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
    {
        inAOldInterfaceDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getInterface() != null)
        {
            node.getInterface().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getExtendsInterfaces() != null)
        {
            node.getExtendsInterfaces().apply(this);
        }
        if(node.getInterfaceBody() != null)
        {
            node.getInterfaceBody().apply(this);
        }
        outAOldInterfaceDeclaration(node);
    }
    public void caseAOldInterfaces(AOldInterfaces node)
    {
        inAOldInterfaces(node);
        if(node.getImplements() != null)
        {
            node.getImplements().apply(this);
        }
        if(node.getInterfaceTypeList() != null)
        {
            node.getInterfaceTypeList().apply(this);
        }
        outAOldInterfaces(node);
    }
    public void caseAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
    {
        inAOldLocalVariableDeclaration(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        if(node.getVariableDeclarators() != null)
        {
            node.getVariableDeclarators().apply(this);
        }
        outAOldLocalVariableDeclaration(node);
    }
    public void caseAOldMethodDeclarator(AOldMethodDeclarator node)
    {
        inAOldMethodDeclarator(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getFormalParameterList() != null)
        {
            node.getFormalParameterList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAOldMethodDeclarator(node);
    }
    public void caseAOldNameCastExp(AOldNameCastExp node)
    {
        inAOldNameCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getUnaryExpNotPlusMinus() != null)
        {
            node.getUnaryExpNotPlusMinus().apply(this);
        }
        outAOldNameCastExp(node);
    }
    public void caseAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
    {
        inAOldNamedTypePrimaryNoNewArray(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outAOldNamedTypePrimaryNoNewArray(node);
    }
    public void caseAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
    {
        inAOldPrimaryFieldAccess(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAOldPrimaryFieldAccess(node);
    }
    public void caseAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
    {
        inAOldPrimaryNoNewArrayArrayAccess(node);
        if(node.getPrimaryNoNewArray() != null)
        {
            node.getPrimaryNoNewArray().apply(this);
        }
        if(node.getLBracket() != null)
        {
            node.getLBracket().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRBracket() != null)
        {
            node.getRBracket().apply(this);
        }
        outAOldPrimaryNoNewArrayArrayAccess(node);
    }
    public void caseAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
    {
        inAOldPrimitiveTypeCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAOldPrimitiveTypeCastExp(node);
    }
    public void caseAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
    {
        inAOldPrimitiveTypePrimaryNoNewArray(node);
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outAOldPrimitiveTypePrimaryNoNewArray(node);
    }
    public void caseAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
    {
        inAOldQualifiedClassInstanceCreationExp(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getClassBody() != null)
        {
            node.getClassBody().apply(this);
        }
        outAOldQualifiedClassInstanceCreationExp(node);
    }
    public void caseAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
    {
        inAOldQualifiedConstructorInvocation(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOldQualifiedConstructorInvocation(node);
    }
    public void caseAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
    {
        inAOldSimpleClassInstanceCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getClassBody() != null)
        {
            node.getClassBody().apply(this);
        }
        outAOldSimpleClassInstanceCreationExp(node);
    }
    public void caseAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
    {
        inAOldStaticInitializerClassBodyDeclaration(node);
        if(node.getStaticInitializer() != null)
        {
            node.getStaticInitializer().apply(this);
        }
        outAOldStaticInitializerClassBodyDeclaration(node);
    }
    public void caseAOldSuper(AOldSuper node)
    {
        inAOldSuper(node);
        if(node.getExtends() != null)
        {
            node.getExtends().apply(this);
        }
        if(node.getClassType() != null)
        {
            node.getClassType().apply(this);
        }
        outAOldSuper(node);
    }
    public void caseAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
    {
        inAOldSuperConstructorInvocation(node);
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOldSuperConstructorInvocation(node);
    }
    public void caseAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
    {
        inAOldThisConstructorInvocation(node);
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOldThisConstructorInvocation(node);
    }
    public void caseAOldThrows(AOldThrows node)
    {
        inAOldThrows(node);
        if(node.getThrows() != null)
        {
            node.getThrows().apply(this);
        }
        if(node.getClassTypeList() != null)
        {
            node.getClassTypeList().apply(this);
        }
        outAOldThrows(node);
    }
    public void caseAOneBreakStmt(AOneBreakStmt node)
    {
        inAOneBreakStmt(node);
        if(node.getBreak() != null)
        {
            node.getBreak().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneBreakStmt(node);
    }
    public void caseAOneContinueStmt(AOneContinueStmt node)
    {
        inAOneContinueStmt(node);
        if(node.getContinue() != null)
        {
            node.getContinue().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneContinueStmt(node);
    }
    public void caseAOneDoStmt(AOneDoStmt node)
    {
        inAOneDoStmt(node);
        if(node.getDo() != null)
        {
            node.getDo().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneDoStmt(node);
    }
    public void caseAOneForStmt(AOneForStmt node)
    {
        inAOneForStmt(node);
        if(node.getFor() != null)
        {
            node.getFor().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getForInit() != null)
        {
            node.getForInit().apply(this);
        }
        if(node.getSemicolon1() != null)
        {
            node.getSemicolon1().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon2() != null)
        {
            node.getSemicolon2().apply(this);
        }
        if(node.getForUpdate() != null)
        {
            node.getForUpdate().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outAOneForStmt(node);
    }
    public void caseAOneQualifiedName(AOneQualifiedName node)
    {
        inAOneQualifiedName(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAOneQualifiedName(node);
    }
    public void caseAOneReturnStmt(AOneReturnStmt node)
    {
        inAOneReturnStmt(node);
        if(node.getReturn() != null)
        {
            node.getReturn().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneReturnStmt(node);
    }
    public void caseAOneSimpleName(AOneSimpleName node)
    {
        inAOneSimpleName(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAOneSimpleName(node);
    }
    public void caseAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
    {
        inAOneSingleTypeImportDeclaration(node);
        if(node.getImport() != null)
        {
            node.getImport().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneSingleTypeImportDeclaration(node);
    }
    public void caseAOneSwitchStmt(AOneSwitchStmt node)
    {
        inAOneSwitchStmt(node);
        if(node.getSwitch() != null)
        {
            node.getSwitch().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getSwitchBlockStmtGroup().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PSwitchBlockStmtGroup) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getSwitchLabel().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PSwitchLabel) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outAOneSwitchStmt(node);
    }
    public void caseAOneSynchronizedStmt(AOneSynchronizedStmt node)
    {
        inAOneSynchronizedStmt(node);
        if(node.getSynchronized() != null)
        {
            node.getSynchronized().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAOneSynchronizedStmt(node);
    }
    public void caseAOneThrowStmt(AOneThrowStmt node)
    {
        inAOneThrowStmt(node);
        if(node.getThrow() != null)
        {
            node.getThrow().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneThrowStmt(node);
    }
    public void caseAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
    {
        inAOneTypeImportOnDemandDeclaration(node);
        if(node.getImport() != null)
        {
            node.getImport().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getStar() != null)
        {
            node.getStar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOneTypeImportOnDemandDeclaration(node);
    }
    public void caseAOneWhileStmt(AOneWhileStmt node)
    {
        inAOneWhileStmt(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outAOneWhileStmt(node);
    }
    public void caseAOrBinaryOperator(AOrBinaryOperator node)
    {
        inAOrBinaryOperator(node);
        if(node.getOr() != null)
        {
            node.getOr().apply(this);
        }
        outAOrBinaryOperator(node);
    }
    public void caseAOriginalExpStmt(AOriginalExpStmt node)
    {
        inAOriginalExpStmt(node);
        if(node.getStmtExp() != null)
        {
            node.getStmtExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAOriginalExpStmt(node);
    }
    public void caseAPackageDeclaration(APackageDeclaration node)
    {
        inAPackageDeclaration(node);
        if(node.getPackage() != null)
        {
            node.getPackage().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAPackageDeclaration(node);
    }
    public void caseAParExp(AParExp node)
    {
        inAParExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outAParExp(node);
    }
    public void caseAPlusAdditiveExp(APlusAdditiveExp node)
    {
        inAPlusAdditiveExp(node);
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        outAPlusAdditiveExp(node);
    }
    public void caseAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
    {
        inAPlusAssignAssignmentOperator(node);
        if(node.getPlusAssign() != null)
        {
            node.getPlusAssign().apply(this);
        }
        outAPlusAssignAssignmentOperator(node);
    }
    public void caseAPlusBinaryOperator(APlusBinaryOperator node)
    {
        inAPlusBinaryOperator(node);
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        outAPlusBinaryOperator(node);
    }
    public void caseAPlusUnaryExp(APlusUnaryExp node)
    {
        inAPlusUnaryExp(node);
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAPlusUnaryExp(node);
    }
    public void caseAPlusUnaryOperator(APlusUnaryOperator node)
    {
        inAPlusUnaryOperator(node);
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        outAPlusUnaryOperator(node);
    }
    public void caseAPostDecrementExp(APostDecrementExp node)
    {
        inAPostDecrementExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getMinusMinus() != null)
        {
            node.getMinusMinus().apply(this);
        }
        outAPostDecrementExp(node);
    }
    public void caseAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
    {
        inAPostDecrementExpPostfixExp(node);
        if(node.getPostDecrementExpr() != null)
        {
            node.getPostDecrementExpr().apply(this);
        }
        outAPostDecrementExpPostfixExp(node);
    }
    public void caseAPostDecrementExpr(APostDecrementExpr node)
    {
        inAPostDecrementExpr(node);
        if(node.getPostfixExp() != null)
        {
            node.getPostfixExp().apply(this);
        }
        if(node.getMinusMinus() != null)
        {
            node.getMinusMinus().apply(this);
        }
        outAPostDecrementExpr(node);
    }
    public void caseAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
    {
        inAPostDecrementExpStmtExp(node);
        if(node.getPostDecrementExpr() != null)
        {
            node.getPostDecrementExpr().apply(this);
        }
        outAPostDecrementExpStmtExp(node);
    }
    public void caseAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
    {
        inAPostfixExpUnaryExpNotPlusMinus(node);
        if(node.getPostfixExp() != null)
        {
            node.getPostfixExp().apply(this);
        }
        outAPostfixExpUnaryExpNotPlusMinus(node);
    }
    public void caseAPostIncrementExp(APostIncrementExp node)
    {
        inAPostIncrementExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getPlusPlus() != null)
        {
            node.getPlusPlus().apply(this);
        }
        outAPostIncrementExp(node);
    }
    public void caseAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
    {
        inAPostIncrementExpPostfixExp(node);
        if(node.getPostIncrementExpr() != null)
        {
            node.getPostIncrementExpr().apply(this);
        }
        outAPostIncrementExpPostfixExp(node);
    }
    public void caseAPostIncrementExpr(APostIncrementExpr node)
    {
        inAPostIncrementExpr(node);
        if(node.getPostfixExp() != null)
        {
            node.getPostfixExp().apply(this);
        }
        if(node.getPlusPlus() != null)
        {
            node.getPlusPlus().apply(this);
        }
        outAPostIncrementExpr(node);
    }
    public void caseAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
    {
        inAPostIncrementExpStmtExp(node);
        if(node.getPostIncrementExpr() != null)
        {
            node.getPostIncrementExpr().apply(this);
        }
        outAPostIncrementExpStmtExp(node);
    }
    public void caseAPreDecrementExp(APreDecrementExp node)
    {
        inAPreDecrementExp(node);
        if(node.getMinusMinus() != null)
        {
            node.getMinusMinus().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAPreDecrementExp(node);
    }
    public void caseAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
    {
        inAPreDecrementExpStmtExp(node);
        if(node.getPreDecrementExp() != null)
        {
            node.getPreDecrementExp().apply(this);
        }
        outAPreDecrementExpStmtExp(node);
    }
    public void caseAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
    {
        inAPreDecrementExpUnaryExp(node);
        if(node.getPreDecrementExp() != null)
        {
            node.getPreDecrementExp().apply(this);
        }
        outAPreDecrementExpUnaryExp(node);
    }
    public void caseAPreIncrementExp(APreIncrementExp node)
    {
        inAPreIncrementExp(node);
        if(node.getPlusPlus() != null)
        {
            node.getPlusPlus().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAPreIncrementExp(node);
    }
    public void caseAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
    {
        inAPreIncrementExpStmtExp(node);
        if(node.getPreIncrementExp() != null)
        {
            node.getPreIncrementExp().apply(this);
        }
        outAPreIncrementExpStmtExp(node);
    }
    public void caseAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
    {
        inAPreIncrementExpUnaryExp(node);
        if(node.getPreIncrementExp() != null)
        {
            node.getPreIncrementExp().apply(this);
        }
        outAPreIncrementExpUnaryExp(node);
    }
    public void caseAPrimaryFieldAccess(APrimaryFieldAccess node)
    {
        inAPrimaryFieldAccess(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAPrimaryFieldAccess(node);
    }
    public void caseAPrimaryMethodInvocation(APrimaryMethodInvocation node)
    {
        inAPrimaryMethodInvocation(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outAPrimaryMethodInvocation(node);
    }
    public void caseAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
    {
        inAPrimaryMethodInvocationExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outAPrimaryMethodInvocationExp(node);
    }
    public void caseAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
    {
        inAPrimaryNoNewArrayArrayAccess(node);
        if(node.getFirst() != null)
        {
            node.getFirst().apply(this);
        }
        if(node.getLBracket() != null)
        {
            node.getLBracket().apply(this);
        }
        if(node.getSecond() != null)
        {
            node.getSecond().apply(this);
        }
        if(node.getRBracket() != null)
        {
            node.getRBracket().apply(this);
        }
        outAPrimaryNoNewArrayArrayAccess(node);
    }
    public void caseAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        inAPrimaryNoNewArrayPrimary(node);
        if(node.getPrimaryNoNewArray() != null)
        {
            node.getPrimaryNoNewArray().apply(this);
        }
        outAPrimaryNoNewArrayPrimary(node);
    }
    public void caseAPrimaryPostfixExp(APrimaryPostfixExp node)
    {
        inAPrimaryPostfixExp(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        outAPrimaryPostfixExp(node);
    }
    public void caseAPrimitiveArrayType(APrimitiveArrayType node)
    {
        inAPrimitiveArrayType(node);
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAPrimitiveArrayType(node);
    }
    public void caseAPrimitiveType(APrimitiveType node)
    {
        inAPrimitiveType(node);
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        outAPrimitiveType(node);
    }
    public void caseAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
    {
        inAPrimitiveTypeArrayCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDimExp().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDimExp) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAPrimitiveTypeArrayCreationExp(node);
    }
    public void caseAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
    {
        inAPrimitiveTypeArrayExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDimExp().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDimExp) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAPrimitiveTypeArrayExp(node);
    }
    public void caseAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
    {
        inAPrimitiveTypeCastExp(node);
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAPrimitiveTypeCastExp(node);
    }
    public void caseAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
    {
        inAPrimitiveTypePrimaryExp(node);
        if(node.getPrimitiveType() != null)
        {
            node.getPrimitiveType().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outAPrimitiveTypePrimaryExp(node);
    }
    public void caseAPrivateModifier(APrivateModifier node)
    {
        inAPrivateModifier(node);
        if(node.getPrivate() != null)
        {
            node.getPrivate().apply(this);
        }
        outAPrivateModifier(node);
    }
    public void caseAProtectedModifier(AProtectedModifier node)
    {
        inAProtectedModifier(node);
        if(node.getProtected() != null)
        {
            node.getProtected().apply(this);
        }
        outAProtectedModifier(node);
    }
    public void caseAPublicModifier(APublicModifier node)
    {
        inAPublicModifier(node);
        if(node.getPublic() != null)
        {
            node.getPublic().apply(this);
        }
        outAPublicModifier(node);
    }
    public void caseAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
    {
        inAQualifiedClassInstanceCreationExp(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getClassBody() != null)
        {
            node.getClassBody().apply(this);
        }
        outAQualifiedClassInstanceCreationExp(node);
    }
    public void caseAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
    {
        inAQualifiedConstructorInvocation(node);
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAQualifiedConstructorInvocation(node);
    }
    public void caseAQualifiedName(AQualifiedName node)
    {
        inAQualifiedName(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAQualifiedName(node);
    }
    public void caseAQualifiedNameName(AQualifiedNameName node)
    {
        inAQualifiedNameName(node);
        if(node.getOneQualifiedName() != null)
        {
            node.getOneQualifiedName().apply(this);
        }
        outAQualifiedNameName(node);
    }
    public void caseAQualifiedThisExp(AQualifiedThisExp node)
    {
        inAQualifiedThisExp(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        outAQualifiedThisExp(node);
    }
    public void caseAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
    {
        inAQualifiedThisPrimaryNoNewArray(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        outAQualifiedThisPrimaryNoNewArray(node);
    }
    public void caseAQuestionConditionalExp(AQuestionConditionalExp node)
    {
        inAQuestionConditionalExp(node);
        if(node.getConditionalOrExp() != null)
        {
            node.getConditionalOrExp().apply(this);
        }
        if(node.getQuestion() != null)
        {
            node.getQuestion().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getConditionalExp() != null)
        {
            node.getConditionalExp().apply(this);
        }
        outAQuestionConditionalExp(node);
    }
    public void caseAQuestionExp(AQuestionExp node)
    {
        inAQuestionExp(node);
        if(node.getFirst() != null)
        {
            node.getFirst().apply(this);
        }
        if(node.getQuestion() != null)
        {
            node.getQuestion().apply(this);
        }
        if(node.getSecond() != null)
        {
            node.getSecond().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getThird() != null)
        {
            node.getThird().apply(this);
        }
        outAQuestionExp(node);
    }
    public void caseAReferenceType(AReferenceType node)
    {
        inAReferenceType(node);
        if(node.getReferenceType() != null)
        {
            node.getReferenceType().apply(this);
        }
        outAReferenceType(node);
    }
    public void caseARelationalExpEqualityExp(ARelationalExpEqualityExp node)
    {
        inARelationalExpEqualityExp(node);
        if(node.getRelationalExp() != null)
        {
            node.getRelationalExp().apply(this);
        }
        outARelationalExpEqualityExp(node);
    }
    public void caseAReturnStmt(AReturnStmt node)
    {
        inAReturnStmt(node);
        if(node.getReturn() != null)
        {
            node.getReturn().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAReturnStmt(node);
    }
    public void caseAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
    {
        inAReturnStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneReturnStmt() != null)
        {
            node.getOneReturnStmt().apply(this);
        }
        outAReturnStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseASemicolonStmt(ASemicolonStmt node)
    {
        inASemicolonStmt(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outASemicolonStmt(node);
    }
    public void caseAShiftExpRelationalExp(AShiftExpRelationalExp node)
    {
        inAShiftExpRelationalExp(node);
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        outAShiftExpRelationalExp(node);
    }
    public void caseAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
    {
        inAShiftLeftAssignAssignmentOperator(node);
        if(node.getShiftLeftAssign() != null)
        {
            node.getShiftLeftAssign().apply(this);
        }
        outAShiftLeftAssignAssignmentOperator(node);
    }
    public void caseAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
    {
        inAShiftLeftBinaryOperator(node);
        if(node.getShiftLeft() != null)
        {
            node.getShiftLeft().apply(this);
        }
        outAShiftLeftBinaryOperator(node);
    }
    public void caseAShiftLeftShiftExp(AShiftLeftShiftExp node)
    {
        inAShiftLeftShiftExp(node);
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        if(node.getShiftLeft() != null)
        {
            node.getShiftLeft().apply(this);
        }
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        outAShiftLeftShiftExp(node);
    }
    public void caseAShortIntegralType(AShortIntegralType node)
    {
        inAShortIntegralType(node);
        if(node.getShort() != null)
        {
            node.getShort().apply(this);
        }
        outAShortIntegralType(node);
    }
    public void caseAShortPrimitiveType(AShortPrimitiveType node)
    {
        inAShortPrimitiveType(node);
        if(node.getShort() != null)
        {
            node.getShort().apply(this);
        }
        outAShortPrimitiveType(node);
    }
    public void caseASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
    {
        inASignedShiftRightAssignAssignmentOperator(node);
        if(node.getSignedShiftRightAssign() != null)
        {
            node.getSignedShiftRightAssign().apply(this);
        }
        outASignedShiftRightAssignAssignmentOperator(node);
    }
    public void caseASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
    {
        inASignedShiftRightBinaryOperator(node);
        if(node.getSignedShiftRight() != null)
        {
            node.getSignedShiftRight().apply(this);
        }
        outASignedShiftRightBinaryOperator(node);
    }
    public void caseASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
    {
        inASignedShiftRightShiftExp(node);
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        if(node.getSignedShiftRight() != null)
        {
            node.getSignedShiftRight().apply(this);
        }
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        outASignedShiftRightShiftExp(node);
    }
    public void caseASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
    {
        inASimpleClassInstanceCreationExp(node);
        if(node.getNew() != null)
        {
            node.getNew().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getClassBody() != null)
        {
            node.getClassBody().apply(this);
        }
        outASimpleClassInstanceCreationExp(node);
    }
    public void caseASimpleName(ASimpleName node)
    {
        inASimpleName(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outASimpleName(node);
    }
    public void caseASimpleNameName(ASimpleNameName node)
    {
        inASimpleNameName(node);
        if(node.getOneSimpleName() != null)
        {
            node.getOneSimpleName().apply(this);
        }
        outASimpleNameName(node);
    }
    public void caseASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
    {
        inASingleTypeImportDeclaration(node);
        if(node.getImport() != null)
        {
            node.getImport().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outASingleTypeImportDeclaration(node);
    }
    public void caseASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
    {
        inASingleTypeImportDeclarationImportDeclaration(node);
        if(node.getOneSingleTypeImportDeclaration() != null)
        {
            node.getOneSingleTypeImportDeclaration().apply(this);
        }
        outASingleTypeImportDeclarationImportDeclaration(node);
    }
    public void caseAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
    {
        inAStarAssignAssignmentOperator(node);
        if(node.getStarAssign() != null)
        {
            node.getStarAssign().apply(this);
        }
        outAStarAssignAssignmentOperator(node);
    }
    public void caseAStarBinaryOperator(AStarBinaryOperator node)
    {
        inAStarBinaryOperator(node);
        if(node.getStar() != null)
        {
            node.getStar().apply(this);
        }
        outAStarBinaryOperator(node);
    }
    public void caseAStarMultiplicativeExp(AStarMultiplicativeExp node)
    {
        inAStarMultiplicativeExp(node);
        if(node.getMultiplicativeExp() != null)
        {
            node.getMultiplicativeExp().apply(this);
        }
        if(node.getStar() != null)
        {
            node.getStar().apply(this);
        }
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAStarMultiplicativeExp(node);
    }
    public void caseAStaticInitializer(AStaticInitializer node)
    {
        inAStaticInitializer(node);
        if(node.getStatic() != null)
        {
            node.getStatic().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAStaticInitializer(node);
    }
    public void caseAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
    {
        inAStaticInitializerClassBodyDeclaration(node);
        if(node.getStatic() != null)
        {
            node.getStatic().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAStaticInitializerClassBodyDeclaration(node);
    }
    public void caseAStaticModifier(AStaticModifier node)
    {
        inAStaticModifier(node);
        if(node.getStatic() != null)
        {
            node.getStatic().apply(this);
        }
        outAStaticModifier(node);
    }
    public void caseAStmtBlockedStmt(AStmtBlockedStmt node)
    {
        inAStmtBlockedStmt(node);
        if(node.getStmt() != null)
        {
            node.getStmt().apply(this);
        }
        outAStmtBlockedStmt(node);
    }
    public void caseAStmtExpListForInit(AStmtExpListForInit node)
    {
        inAStmtExpListForInit(node);
        if(node.getStmtExpList() != null)
        {
            node.getStmtExpList().apply(this);
        }
        outAStmtExpListForInit(node);
    }
    public void caseAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
    {
        inAStmtExpListStmtExpList(node);
        if(node.getStmtExpList() != null)
        {
            node.getStmtExpList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getStmtExp() != null)
        {
            node.getStmtExp().apply(this);
        }
        outAStmtExpListStmtExpList(node);
    }
    public void caseAStmtExpStmtExpList(AStmtExpStmtExpList node)
    {
        inAStmtExpStmtExpList(node);
        if(node.getStmtExp() != null)
        {
            node.getStmtExp().apply(this);
        }
        outAStmtExpStmtExpList(node);
    }
    public void caseAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
    {
        inAStmtWithoutTrailingSubstmtStmt(node);
        if(node.getStmtWithoutTrailingSubstmt() != null)
        {
            node.getStmtWithoutTrailingSubstmt().apply(this);
        }
        outAStmtWithoutTrailingSubstmtStmt(node);
    }
    public void caseAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
    {
        inAStmtWithoutTrailingSubstmtStmtNoShortIf(node);
        if(node.getStmtWithoutTrailingSubstmt() != null)
        {
            node.getStmtWithoutTrailingSubstmt().apply(this);
        }
        outAStmtWithoutTrailingSubstmtStmtNoShortIf(node);
    }
    public void caseAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        inAStringLiteralLiteral(node);
        if(node.getStringLiteral() != null)
        {
            node.getStringLiteral().apply(this);
        }
        outAStringLiteralLiteral(node);
    }
    public void caseASuper(ASuper node)
    {
        inASuper(node);
        if(node.getExtends() != null)
        {
            node.getExtends().apply(this);
        }
        if(node.getClassType() != null)
        {
            node.getClassType().apply(this);
        }
        outASuper(node);
    }
    public void caseASuperConstructorInvocation(ASuperConstructorInvocation node)
    {
        inASuperConstructorInvocation(node);
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outASuperConstructorInvocation(node);
    }
    public void caseASuperFieldAccess(ASuperFieldAccess node)
    {
        inASuperFieldAccess(node);
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outASuperFieldAccess(node);
    }
    public void caseASuperMethodInvocation(ASuperMethodInvocation node)
    {
        inASuperMethodInvocation(node);
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outASuperMethodInvocation(node);
    }
    public void caseASuperMethodInvocationExp(ASuperMethodInvocationExp node)
    {
        inASuperMethodInvocationExp(node);
        if(node.getSuper() != null)
        {
            node.getSuper().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        outASuperMethodInvocationExp(node);
    }
    public void caseASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
    {
        inASwitchBlockStmtGroup(node);
        {
            Object temp[] = node.getSwitchLabel().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PSwitchLabel) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getBlockedStmt().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PBlockedStmt) temp[i]).apply(this);
            }
        }
        outASwitchBlockStmtGroup(node);
    }
    public void caseASwitchStmt(ASwitchStmt node)
    {
        inASwitchStmt(node);
        if(node.getSwitch() != null)
        {
            node.getSwitch().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getLBrace() != null)
        {
            node.getLBrace().apply(this);
        }
        {
            Object temp[] = node.getSwitchBlockStmtGroup().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PSwitchBlockStmtGroup) temp[i]).apply(this);
            }
        }
        {
            Object temp[] = node.getSwitchLabel().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PSwitchLabel) temp[i]).apply(this);
            }
        }
        if(node.getRBrace() != null)
        {
            node.getRBrace().apply(this);
        }
        outASwitchStmt(node);
    }
    public void caseASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
    {
        inASwitchStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneSwitchStmt() != null)
        {
            node.getOneSwitchStmt().apply(this);
        }
        outASwitchStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseASynchronizedModifier(ASynchronizedModifier node)
    {
        inASynchronizedModifier(node);
        if(node.getSynchronized() != null)
        {
            node.getSynchronized().apply(this);
        }
        outASynchronizedModifier(node);
    }
    public void caseASynchronizedStmt(ASynchronizedStmt node)
    {
        inASynchronizedStmt(node);
        if(node.getSynchronized() != null)
        {
            node.getSynchronized().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outASynchronizedStmt(node);
    }
    public void caseASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
    {
        inASynchronizedStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneSynchronizedStmt() != null)
        {
            node.getOneSynchronizedStmt().apply(this);
        }
        outASynchronizedStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseAThisConstructorInvocation(AThisConstructorInvocation node)
    {
        inAThisConstructorInvocation(node);
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        {
            Object temp[] = node.getArgumentList().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PExp) temp[i]).apply(this);
            }
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAThisConstructorInvocation(node);
    }
    public void caseAThisExp(AThisExp node)
    {
        inAThisExp(node);
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        outAThisExp(node);
    }
    public void caseAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
    {
        inAThisPrimaryNoNewArray(node);
        if(node.getThis() != null)
        {
            node.getThis().apply(this);
        }
        outAThisPrimaryNoNewArray(node);
    }
    public void caseAThrows(AThrows node)
    {
        inAThrows(node);
        if(node.getThrows() != null)
        {
            node.getThrows().apply(this);
        }
        {
            Object temp[] = node.getName().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PName) temp[i]).apply(this);
            }
        }
        outAThrows(node);
    }
    public void caseAThrowStmt(AThrowStmt node)
    {
        inAThrowStmt(node);
        if(node.getThrow() != null)
        {
            node.getThrow().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAThrowStmt(node);
    }
    public void caseAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
    {
        inAThrowStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneThrowStmt() != null)
        {
            node.getOneThrowStmt().apply(this);
        }
        outAThrowStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseATransientModifier(ATransientModifier node)
    {
        inATransientModifier(node);
        if(node.getTransient() != null)
        {
            node.getTransient().apply(this);
        }
        outATransientModifier(node);
    }
    public void caseATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        inATrueBooleanLiteral(node);
        if(node.getTrue() != null)
        {
            node.getTrue().apply(this);
        }
        outATrueBooleanLiteral(node);
    }
    public void caseATryFinallyStmt(ATryFinallyStmt node)
    {
        inATryFinallyStmt(node);
        if(node.getTry() != null)
        {
            node.getTry().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        {
            Object temp[] = node.getCatchClause().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PCatchClause) temp[i]).apply(this);
            }
        }
        if(node.getFinally() != null)
        {
            node.getFinally().apply(this);
        }
        outATryFinallyStmt(node);
    }
    public void caseATryOneTryStmt(ATryOneTryStmt node)
    {
        inATryOneTryStmt(node);
        if(node.getTry() != null)
        {
            node.getTry().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        {
            Object temp[] = node.getCatchClause().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PCatchClause) temp[i]).apply(this);
            }
        }
        outATryOneTryStmt(node);
    }
    public void caseATryStmt(ATryStmt node)
    {
        inATryStmt(node);
        if(node.getTry() != null)
        {
            node.getTry().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        {
            Object temp[] = node.getCatchClause().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PCatchClause) temp[i]).apply(this);
            }
        }
        outATryStmt(node);
    }
    public void caseATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
    {
        inATryStmtStmtWithoutTrailingSubstmt(node);
        if(node.getOneTryStmt() != null)
        {
            node.getOneTryStmt().apply(this);
        }
        outATryStmtStmtWithoutTrailingSubstmt(node);
    }
    public void caseATypedMethodHeader(ATypedMethodHeader node)
    {
        inATypedMethodHeader(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getType() != null)
        {
            node.getType().apply(this);
        }
        if(node.getMethodDeclarator() != null)
        {
            node.getMethodDeclarator().apply(this);
        }
        if(node.getThrows() != null)
        {
            node.getThrows().apply(this);
        }
        outATypedMethodHeader(node);
    }
    public void caseATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
    {
        inATypeImportOnDemandDeclarationImportDeclaration(node);
        if(node.getOneTypeImportOnDemandDeclaration() != null)
        {
            node.getOneTypeImportOnDemandDeclaration().apply(this);
        }
        outATypeImportOnDemandDeclarationImportDeclaration(node);
    }
    public void caseATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
    {
        inATypeOnDemandImportDeclaration(node);
        if(node.getImport() != null)
        {
            node.getImport().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getStar() != null)
        {
            node.getStar().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outATypeOnDemandImportDeclaration(node);
    }
    public void caseAUnaryExp(AUnaryExp node)
    {
        inAUnaryExp(node);
        if(node.getUnaryOperator() != null)
        {
            node.getUnaryOperator().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        outAUnaryExp(node);
    }
    public void caseAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
    {
        inAUnaryExpMultiplicativeExp(node);
        if(node.getUnaryExp() != null)
        {
            node.getUnaryExp().apply(this);
        }
        outAUnaryExpMultiplicativeExp(node);
    }
    public void caseAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
    {
        inAUnsignedShiftRightAssignAssignmentOperator(node);
        if(node.getUnsignedShiftRightAssign() != null)
        {
            node.getUnsignedShiftRightAssign().apply(this);
        }
        outAUnsignedShiftRightAssignAssignmentOperator(node);
    }
    public void caseAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
    {
        inAUnsignedShiftRightBinaryOperator(node);
        if(node.getUnsignedShiftRight() != null)
        {
            node.getUnsignedShiftRight().apply(this);
        }
        outAUnsignedShiftRightBinaryOperator(node);
    }
    public void caseAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
    {
        inAUnsignedShiftRightShiftExp(node);
        if(node.getShiftExp() != null)
        {
            node.getShiftExp().apply(this);
        }
        if(node.getUnsignedShiftRight() != null)
        {
            node.getUnsignedShiftRight().apply(this);
        }
        if(node.getAdditiveExp() != null)
        {
            node.getAdditiveExp().apply(this);
        }
        outAUnsignedShiftRightShiftExp(node);
    }
    public void caseAVariableDeclaratorId(AVariableDeclaratorId node)
    {
        inAVariableDeclaratorId(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        {
            Object temp[] = node.getDim().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PDim) temp[i]).apply(this);
            }
        }
        outAVariableDeclaratorId(node);
    }
    public void caseAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
    {
        inAVariableDeclaratorsVariableDeclarators(node);
        if(node.getVariableDeclarators() != null)
        {
            node.getVariableDeclarators().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getVariableDeclarator() != null)
        {
            node.getVariableDeclarator().apply(this);
        }
        outAVariableDeclaratorsVariableDeclarators(node);
    }
    public void caseAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
    {
        inAVariableDeclaratorVariableDeclarators(node);
        if(node.getVariableDeclarator() != null)
        {
            node.getVariableDeclarator().apply(this);
        }
        outAVariableDeclaratorVariableDeclarators(node);
    }
    public void caseAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
    {
        inAVariableInitializersVariableInitializers(node);
        if(node.getVariableInitializers() != null)
        {
            node.getVariableInitializers().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getVariableInitializer() != null)
        {
            node.getVariableInitializer().apply(this);
        }
        outAVariableInitializersVariableInitializers(node);
    }
    public void caseAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
    {
        inAVariableInitializerVariableInitializers(node);
        if(node.getVariableInitializer() != null)
        {
            node.getVariableInitializer().apply(this);
        }
        outAVariableInitializerVariableInitializers(node);
    }
    public void caseAVoidExp(AVoidExp node)
    {
        inAVoidExp(node);
        if(node.getVoid() != null)
        {
            node.getVoid().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outAVoidExp(node);
    }
    public void caseAVoidMethodHeader(AVoidMethodHeader node)
    {
        inAVoidMethodHeader(node);
        {
            Object temp[] = node.getModifier().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PModifier) temp[i]).apply(this);
            }
        }
        if(node.getVoid() != null)
        {
            node.getVoid().apply(this);
        }
        if(node.getMethodDeclarator() != null)
        {
            node.getMethodDeclarator().apply(this);
        }
        if(node.getThrows() != null)
        {
            node.getThrows().apply(this);
        }
        outAVoidMethodHeader(node);
    }
    public void caseAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
    {
        inAVoidPrimaryNoNewArray(node);
        if(node.getVoid() != null)
        {
            node.getVoid().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getTClass() != null)
        {
            node.getTClass().apply(this);
        }
        outAVoidPrimaryNoNewArray(node);
    }
    public void caseAVolatileModifier(AVolatileModifier node)
    {
        inAVolatileModifier(node);
        if(node.getVolatile() != null)
        {
            node.getVolatile().apply(this);
        }
        outAVolatileModifier(node);
    }
    public void caseAWhileStmt(AWhileStmt node)
    {
        inAWhileStmt(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getBlock() != null)
        {
            node.getBlock().apply(this);
        }
        outAWhileStmt(node);
    }
    public void caseAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
    {
        inAWhileStmtNoShortIf(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getExp() != null)
        {
            node.getExp().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getStmtNoShortIf() != null)
        {
            node.getStmtNoShortIf().apply(this);
        }
        outAWhileStmtNoShortIf(node);
    }
    public void caseAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
    {
        inAWhileStmtNoShortIfStmtNoShortIf(node);
        if(node.getWhileStmtNoShortIf() != null)
        {
            node.getWhileStmtNoShortIf().apply(this);
        }
        outAWhileStmtNoShortIfStmtNoShortIf(node);
    }
    public void caseAWhileStmtStmt(AWhileStmtStmt node)
    {
        inAWhileStmtStmt(node);
        if(node.getOneWhileStmt() != null)
        {
            node.getOneWhileStmt().apply(this);
        }
        outAWhileStmtStmt(node);
    }
    public void caseStart(Start node)
    {
        inStart(node);
        node.getPCompilationUnit().apply(this);
        node.getEOF().apply(this);
        outStart(node);
    }
    public void defaultIn(Node node)
    {
    }
    public void defaultOut(Node node)
    {
    }
    public void inAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
    {
        defaultIn(node);
    }
    public void inAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAAbstractModifier(AAbstractModifier node)
    {
        defaultIn(node);
    }
    public void inAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
    {
        defaultIn(node);
    }
    public void inAAndBinaryOperator(AAndBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAAndExpAndExp(AAndExpAndExp node)
    {
        defaultIn(node);
    }
    public void inAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
    {
        defaultIn(node);
    }
    public void inAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        defaultIn(node);
    }
    public void inAArrayAccessExp(AArrayAccessExp node)
    {
        defaultIn(node);
    }
    public void inAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
    {
        defaultIn(node);
    }
    public void inAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
    {
        defaultIn(node);
    }
    public void inAArrayInitializer(AArrayInitializer node)
    {
        defaultIn(node);
    }
    public void inAArrayReferenceType(AArrayReferenceType node)
    {
        defaultIn(node);
    }
    public void inAArrayVariableInitializer(AArrayVariableInitializer node)
    {
        defaultIn(node);
    }
    public void inAAssertionCompilationUnit(AAssertionCompilationUnit node)
    {
        defaultIn(node);
    }
    public void inAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
    {
        defaultIn(node);
    }
    public void inAAssignment(AAssignment node)
    {
        defaultIn(node);
    }
    public void inAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
    {
        defaultIn(node);
    }
    public void inAAssignmentExp(AAssignmentExp node)
    {
        defaultIn(node);
    }
    public void inAAssignmentStmtExp(AAssignmentStmtExp node)
    {
        defaultIn(node);
    }
    public void inABinaryExp(ABinaryExp node)
    {
        defaultIn(node);
    }
    public void inABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inABitAndBinaryOperator(ABitAndBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
    {
        defaultIn(node);
    }
    public void inABitComplementUnaryOperator(ABitComplementUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inABitOrBinaryOperator(ABitOrBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inABitXorBinaryOperator(ABitXorBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inABlock(ABlock node)
    {
        defaultIn(node);
    }
    public void inABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inABlockMethodBody(ABlockMethodBody node)
    {
        defaultIn(node);
    }
    public void inABlockStmt(ABlockStmt node)
    {
        defaultIn(node);
    }
    public void inABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inABooleanPrimitiveType(ABooleanPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inABreakStmt(ABreakStmt node)
    {
        defaultIn(node);
    }
    public void inABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inAByteIntegralType(AByteIntegralType node)
    {
        defaultIn(node);
    }
    public void inABytePrimitiveType(ABytePrimitiveType node)
    {
        defaultIn(node);
    }
    public void inACaseSwitchLabel(ACaseSwitchLabel node)
    {
        defaultIn(node);
    }
    public void inACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
    {
        defaultIn(node);
    }
    public void inACatchClause(ACatchClause node)
    {
        defaultIn(node);
    }
    public void inACharacterLiteralLiteral(ACharacterLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inACharIntegralType(ACharIntegralType node)
    {
        defaultIn(node);
    }
    public void inACharPrimitiveType(ACharPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inAClassBody(AClassBody node)
    {
        defaultIn(node);
    }
    public void inAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassDeclaration(AClassDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
    {
        defaultIn(node);
    }
    public void inAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
    {
        defaultIn(node);
    }
    public void inAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassOrInterfaceType(AClassOrInterfaceType node)
    {
        defaultIn(node);
    }
    public void inAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
    {
        defaultIn(node);
    }
    public void inAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
    {
        defaultIn(node);
    }
    public void inAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
    {
        defaultIn(node);
    }
    public void inAClassType(AClassType node)
    {
        defaultIn(node);
    }
    public void inAClassTypeClassTypeList(AClassTypeClassTypeList node)
    {
        defaultIn(node);
    }
    public void inAClassTypeDeclaration(AClassTypeDeclaration node)
    {
        defaultIn(node);
    }
    public void inAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
    {
        defaultIn(node);
    }
    public void inACompilationUnit(ACompilationUnit node)
    {
        defaultIn(node);
    }
    public void inAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
    {
        defaultIn(node);
    }
    public void inAComplementUnaryOperator(AComplementUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
    {
        defaultIn(node);
    }
    public void inAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
    {
        defaultIn(node);
    }
    public void inAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
    {
        defaultIn(node);
    }
    public void inAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
    {
        defaultIn(node);
    }
    public void inAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
    {
        defaultIn(node);
    }
    public void inAConstantDeclaration(AConstantDeclaration node)
    {
        defaultIn(node);
    }
    public void inAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAConstantExp(AConstantExp node)
    {
        defaultIn(node);
    }
    public void inAConstructorBody(AConstructorBody node)
    {
        defaultIn(node);
    }
    public void inAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAConstructorDeclaration(AConstructorDeclaration node)
    {
        defaultIn(node);
    }
    public void inAConstructorDeclarator(AConstructorDeclarator node)
    {
        defaultIn(node);
    }
    public void inAContinueStmt(AContinueStmt node)
    {
        defaultIn(node);
    }
    public void inAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        defaultIn(node);
    }
    public void inADecrementUnaryOperator(ADecrementUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inADefaultSwitchLabel(ADefaultSwitchLabel node)
    {
        defaultIn(node);
    }
    public void inADim(ADim node)
    {
        defaultIn(node);
    }
    public void inADimExp(ADimExp node)
    {
        defaultIn(node);
    }
    public void inADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inADivBinaryOperator(ADivBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inADivMultiplicativeExp(ADivMultiplicativeExp node)
    {
        defaultIn(node);
    }
    public void inADoStmt(ADoStmt node)
    {
        defaultIn(node);
    }
    public void inADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inADoubleFloatingPointType(ADoubleFloatingPointType node)
    {
        defaultIn(node);
    }
    public void inADoublePrimitiveType(ADoublePrimitiveType node)
    {
        defaultIn(node);
    }
    public void inAEmptyMethodBody(AEmptyMethodBody node)
    {
        defaultIn(node);
    }
    public void inAEmptyStmt(AEmptyStmt node)
    {
        defaultIn(node);
    }
    public void inAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
    {
        defaultIn(node);
    }
    public void inAEqBinaryOperator(AEqBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAEqEqualityExp(AEqEqualityExp node)
    {
        defaultIn(node);
    }
    public void inAEqualityExpAndExp(AEqualityExpAndExp node)
    {
        defaultIn(node);
    }
    public void inAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
    {
        defaultIn(node);
    }
    public void inAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
    {
        defaultIn(node);
    }
    public void inAExpArgumentList(AExpArgumentList node)
    {
        defaultIn(node);
    }
    public void inAExpCastExp(AExpCastExp node)
    {
        defaultIn(node);
    }
    public void inAExpListForInit(AExpListForInit node)
    {
        defaultIn(node);
    }
    public void inAExpStmt(AExpStmt node)
    {
        defaultIn(node);
    }
    public void inAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inAExpVariableInitializer(AExpVariableInitializer node)
    {
        defaultIn(node);
    }
    public void inAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
    {
        defaultIn(node);
    }
    public void inAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
    {
        defaultIn(node);
    }
    public void inAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        defaultIn(node);
    }
    public void inAFieldAccessExp(AFieldAccessExp node)
    {
        defaultIn(node);
    }
    public void inAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
    {
        defaultIn(node);
    }
    public void inAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAFieldDeclaration(AFieldDeclaration node)
    {
        defaultIn(node);
    }
    public void inAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAFinally(AFinally node)
    {
        defaultIn(node);
    }
    public void inAFinallyOneTryStmt(AFinallyOneTryStmt node)
    {
        defaultIn(node);
    }
    public void inAFinalModifier(AFinalModifier node)
    {
        defaultIn(node);
    }
    public void inAFloatFloatingPointType(AFloatFloatingPointType node)
    {
        defaultIn(node);
    }
    public void inAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
    {
        defaultIn(node);
    }
    public void inAFloatPrimitiveType(AFloatPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inAFormalParameter(AFormalParameter node)
    {
        defaultIn(node);
    }
    public void inAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
    {
        defaultIn(node);
    }
    public void inAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
    {
        defaultIn(node);
    }
    public void inAForStmt(AForStmt node)
    {
        defaultIn(node);
    }
    public void inAForStmtNoShortIf(AForStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAForStmtStmt(AForStmtStmt node)
    {
        defaultIn(node);
    }
    public void inAForUpdate(AForUpdate node)
    {
        defaultIn(node);
    }
    public void inAGtBinaryOperator(AGtBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAGteqBinaryOperator(AGteqBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAGteqRelationalExp(AGteqRelationalExp node)
    {
        defaultIn(node);
    }
    public void inAGtRelationalExp(AGtRelationalExp node)
    {
        defaultIn(node);
    }
    public void inAHexIntegerLiteral(AHexIntegerLiteral node)
    {
        defaultIn(node);
    }
    public void inAIdVariableDeclarator(AIdVariableDeclarator node)
    {
        defaultIn(node);
    }
    public void inAIfStmt(AIfStmt node)
    {
        defaultIn(node);
    }
    public void inAIfThenElseStmt(AIfThenElseStmt node)
    {
        defaultIn(node);
    }
    public void inAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
    {
        defaultIn(node);
    }
    public void inAIfThenStmt(AIfThenStmt node)
    {
        defaultIn(node);
    }
    public void inAIfThenStmtStmt(AIfThenStmtStmt node)
    {
        defaultIn(node);
    }
    public void inAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
    {
        defaultIn(node);
    }
    public void inAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
    {
        defaultIn(node);
    }
    public void inAIncrementUnaryOperator(AIncrementUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
    {
        defaultIn(node);
    }
    public void inAInitClassInterfaceExp(AInitClassInterfaceExp node)
    {
        defaultIn(node);
    }
    public void inAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
    {
        defaultIn(node);
    }
    public void inAInitPrimitiveExp(AInitPrimitiveExp node)
    {
        defaultIn(node);
    }
    public void inAInstanceofExp(AInstanceofExp node)
    {
        defaultIn(node);
    }
    public void inAInstanceofRelationalExp(AInstanceofRelationalExp node)
    {
        defaultIn(node);
    }
    public void inAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inAIntegralTypeNumericType(AIntegralTypeNumericType node)
    {
        defaultIn(node);
    }
    public void inAInterfaceBody(AInterfaceBody node)
    {
        defaultIn(node);
    }
    public void inAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAInterfaceDeclaration(AInterfaceDeclaration node)
    {
        defaultIn(node);
    }
    public void inAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAInterfaces(AInterfaces node)
    {
        defaultIn(node);
    }
    public void inAInterfaceType(AInterfaceType node)
    {
        defaultIn(node);
    }
    public void inAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
    {
        defaultIn(node);
    }
    public void inAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
    {
        defaultIn(node);
    }
    public void inAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
    {
        defaultIn(node);
    }
    public void inAIntIntegralType(AIntIntegralType node)
    {
        defaultIn(node);
    }
    public void inAIntPrimitiveType(AIntPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inALabeledStmt(ALabeledStmt node)
    {
        defaultIn(node);
    }
    public void inALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inALabeledStmtStmt(ALabeledStmtStmt node)
    {
        defaultIn(node);
    }
    public void inALabelStmt(ALabelStmt node)
    {
        defaultIn(node);
    }
    public void inALiteralExp(ALiteralExp node)
    {
        defaultIn(node);
    }
    public void inALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inALocalVariableDeclaration(ALocalVariableDeclaration node)
    {
        defaultIn(node);
    }
    public void inALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
    {
        defaultIn(node);
    }
    public void inALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
    {
        defaultIn(node);
    }
    public void inALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
    {
        defaultIn(node);
    }
    public void inALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
    {
        defaultIn(node);
    }
    public void inALongIntegralType(ALongIntegralType node)
    {
        defaultIn(node);
    }
    public void inALongPrimitiveType(ALongPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inALtBinaryOperator(ALtBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inALteqBinaryOperator(ALteqBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inALteqRelationalExp(ALteqRelationalExp node)
    {
        defaultIn(node);
    }
    public void inALtRelationalExp(ALtRelationalExp node)
    {
        defaultIn(node);
    }
    public void inAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAMethodDeclaration(AMethodDeclaration node)
    {
        defaultIn(node);
    }
    public void inAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAMethodDeclarator(AMethodDeclarator node)
    {
        defaultIn(node);
    }
    public void inAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
    {
        defaultIn(node);
    }
    public void inAMinusAdditiveExp(AMinusAdditiveExp node)
    {
        defaultIn(node);
    }
    public void inAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAMinusBinaryOperator(AMinusBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAMinusUnaryExp(AMinusUnaryExp node)
    {
        defaultIn(node);
    }
    public void inAMinusUnaryOperator(AMinusUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAModBinaryOperator(AModBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAModMultiplicativeExp(AModMultiplicativeExp node)
    {
        defaultIn(node);
    }
    public void inAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
    {
        defaultIn(node);
    }
    public void inANameArrayAccess(ANameArrayAccess node)
    {
        defaultIn(node);
    }
    public void inANameArrayType(ANameArrayType node)
    {
        defaultIn(node);
    }
    public void inANameCastExp(ANameCastExp node)
    {
        defaultIn(node);
    }
    public void inANamedTypeExp(ANamedTypeExp node)
    {
        defaultIn(node);
    }
    public void inANameExp(ANameExp node)
    {
        defaultIn(node);
    }
    public void inANameLeftHandSide(ANameLeftHandSide node)
    {
        defaultIn(node);
    }
    public void inANameMethodInvocation(ANameMethodInvocation node)
    {
        defaultIn(node);
    }
    public void inANameMethodInvocationExp(ANameMethodInvocationExp node)
    {
        defaultIn(node);
    }
    public void inANamePostfixExp(ANamePostfixExp node)
    {
        defaultIn(node);
    }
    public void inANameReferenceType(ANameReferenceType node)
    {
        defaultIn(node);
    }
    public void inANativeModifier(ANativeModifier node)
    {
        defaultIn(node);
    }
    public void inANeqBinaryOperator(ANeqBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inANeqEqualityExp(ANeqEqualityExp node)
    {
        defaultIn(node);
    }
    public void inANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
    {
        defaultIn(node);
    }
    public void inANullLiteral(ANullLiteral node)
    {
        defaultIn(node);
    }
    public void inANullLiteralLiteral(ANullLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inANumericTypePrimitiveType(ANumericTypePrimitiveType node)
    {
        defaultIn(node);
    }
    public void inAOctalIntegerLiteral(AOctalIntegerLiteral node)
    {
        defaultIn(node);
    }
    public void inAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldArrayInitializer(AOldArrayInitializer node)
    {
        defaultIn(node);
    }
    public void inAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
    {
        defaultIn(node);
    }
    public void inAOldCompilationUnit(AOldCompilationUnit node)
    {
        defaultIn(node);
    }
    public void inAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldConstructorDeclarator(AOldConstructorDeclarator node)
    {
        defaultIn(node);
    }
    public void inAOldExp(AOldExp node)
    {
        defaultIn(node);
    }
    public void inAOldExpCastExp(AOldExpCastExp node)
    {
        defaultIn(node);
    }
    public void inAOldFieldDeclaration(AOldFieldDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldInterfaces(AOldInterfaces node)
    {
        defaultIn(node);
    }
    public void inAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldMethodDeclarator(AOldMethodDeclarator node)
    {
        defaultIn(node);
    }
    public void inAOldNameCastExp(AOldNameCastExp node)
    {
        defaultIn(node);
    }
    public void inAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
    {
        defaultIn(node);
    }
    public void inAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
    {
        defaultIn(node);
    }
    public void inAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
    {
        defaultIn(node);
    }
    public void inAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
    {
        defaultIn(node);
    }
    public void inAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
    {
        defaultIn(node);
    }
    public void inAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOldSuper(AOldSuper node)
    {
        defaultIn(node);
    }
    public void inAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inAOldThrows(AOldThrows node)
    {
        defaultIn(node);
    }
    public void inAOneBreakStmt(AOneBreakStmt node)
    {
        defaultIn(node);
    }
    public void inAOneContinueStmt(AOneContinueStmt node)
    {
        defaultIn(node);
    }
    public void inAOneDoStmt(AOneDoStmt node)
    {
        defaultIn(node);
    }
    public void inAOneForStmt(AOneForStmt node)
    {
        defaultIn(node);
    }
    public void inAOneQualifiedName(AOneQualifiedName node)
    {
        defaultIn(node);
    }
    public void inAOneReturnStmt(AOneReturnStmt node)
    {
        defaultIn(node);
    }
    public void inAOneSimpleName(AOneSimpleName node)
    {
        defaultIn(node);
    }
    public void inAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOneSwitchStmt(AOneSwitchStmt node)
    {
        defaultIn(node);
    }
    public void inAOneSynchronizedStmt(AOneSynchronizedStmt node)
    {
        defaultIn(node);
    }
    public void inAOneThrowStmt(AOneThrowStmt node)
    {
        defaultIn(node);
    }
    public void inAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
    {
        defaultIn(node);
    }
    public void inAOneWhileStmt(AOneWhileStmt node)
    {
        defaultIn(node);
    }
    public void inAOrBinaryOperator(AOrBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAOriginalExpStmt(AOriginalExpStmt node)
    {
        defaultIn(node);
    }
    public void inAPackageDeclaration(APackageDeclaration node)
    {
        defaultIn(node);
    }
    public void inAParExp(AParExp node)
    {
        defaultIn(node);
    }
    public void inAPlusAdditiveExp(APlusAdditiveExp node)
    {
        defaultIn(node);
    }
    public void inAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAPlusBinaryOperator(APlusBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAPlusUnaryExp(APlusUnaryExp node)
    {
        defaultIn(node);
    }
    public void inAPlusUnaryOperator(APlusUnaryOperator node)
    {
        defaultIn(node);
    }
    public void inAPostDecrementExp(APostDecrementExp node)
    {
        defaultIn(node);
    }
    public void inAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
    {
        defaultIn(node);
    }
    public void inAPostDecrementExpr(APostDecrementExpr node)
    {
        defaultIn(node);
    }
    public void inAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
    {
        defaultIn(node);
    }
    public void inAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
    {
        defaultIn(node);
    }
    public void inAPostIncrementExp(APostIncrementExp node)
    {
        defaultIn(node);
    }
    public void inAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
    {
        defaultIn(node);
    }
    public void inAPostIncrementExpr(APostIncrementExpr node)
    {
        defaultIn(node);
    }
    public void inAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
    {
        defaultIn(node);
    }
    public void inAPreDecrementExp(APreDecrementExp node)
    {
        defaultIn(node);
    }
    public void inAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
    {
        defaultIn(node);
    }
    public void inAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
    {
        defaultIn(node);
    }
    public void inAPreIncrementExp(APreIncrementExp node)
    {
        defaultIn(node);
    }
    public void inAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
    {
        defaultIn(node);
    }
    public void inAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
    {
        defaultIn(node);
    }
    public void inAPrimaryFieldAccess(APrimaryFieldAccess node)
    {
        defaultIn(node);
    }
    public void inAPrimaryMethodInvocation(APrimaryMethodInvocation node)
    {
        defaultIn(node);
    }
    public void inAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
    {
        defaultIn(node);
    }
    public void inAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
    {
        defaultIn(node);
    }
    public void inAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        defaultIn(node);
    }
    public void inAPrimaryPostfixExp(APrimaryPostfixExp node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveArrayType(APrimitiveArrayType node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveType(APrimitiveType node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
    {
        defaultIn(node);
    }
    public void inAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
    {
        defaultIn(node);
    }
    public void inAPrivateModifier(APrivateModifier node)
    {
        defaultIn(node);
    }
    public void inAProtectedModifier(AProtectedModifier node)
    {
        defaultIn(node);
    }
    public void inAPublicModifier(APublicModifier node)
    {
        defaultIn(node);
    }
    public void inAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
    {
        defaultIn(node);
    }
    public void inAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inAQualifiedName(AQualifiedName node)
    {
        defaultIn(node);
    }
    public void inAQualifiedNameName(AQualifiedNameName node)
    {
        defaultIn(node);
    }
    public void inAQualifiedThisExp(AQualifiedThisExp node)
    {
        defaultIn(node);
    }
    public void inAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAQuestionConditionalExp(AQuestionConditionalExp node)
    {
        defaultIn(node);
    }
    public void inAQuestionExp(AQuestionExp node)
    {
        defaultIn(node);
    }
    public void inAReferenceType(AReferenceType node)
    {
        defaultIn(node);
    }
    public void inARelationalExpEqualityExp(ARelationalExpEqualityExp node)
    {
        defaultIn(node);
    }
    public void inAReturnStmt(AReturnStmt node)
    {
        defaultIn(node);
    }
    public void inAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inASemicolonStmt(ASemicolonStmt node)
    {
        defaultIn(node);
    }
    public void inAShiftExpRelationalExp(AShiftExpRelationalExp node)
    {
        defaultIn(node);
    }
    public void inAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAShiftLeftShiftExp(AShiftLeftShiftExp node)
    {
        defaultIn(node);
    }
    public void inAShortIntegralType(AShortIntegralType node)
    {
        defaultIn(node);
    }
    public void inAShortPrimitiveType(AShortPrimitiveType node)
    {
        defaultIn(node);
    }
    public void inASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
    {
        defaultIn(node);
    }
    public void inASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
    {
        defaultIn(node);
    }
    public void inASimpleName(ASimpleName node)
    {
        defaultIn(node);
    }
    public void inASimpleNameName(ASimpleNameName node)
    {
        defaultIn(node);
    }
    public void inASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
    {
        defaultIn(node);
    }
    public void inASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
    {
        defaultIn(node);
    }
    public void inAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAStarBinaryOperator(AStarBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAStarMultiplicativeExp(AStarMultiplicativeExp node)
    {
        defaultIn(node);
    }
    public void inAStaticInitializer(AStaticInitializer node)
    {
        defaultIn(node);
    }
    public void inAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
    {
        defaultIn(node);
    }
    public void inAStaticModifier(AStaticModifier node)
    {
        defaultIn(node);
    }
    public void inAStmtBlockedStmt(AStmtBlockedStmt node)
    {
        defaultIn(node);
    }
    public void inAStmtExpListForInit(AStmtExpListForInit node)
    {
        defaultIn(node);
    }
    public void inAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
    {
        defaultIn(node);
    }
    public void inAStmtExpStmtExpList(AStmtExpStmtExpList node)
    {
        defaultIn(node);
    }
    public void inAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
    {
        defaultIn(node);
    }
    public void inAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        defaultIn(node);
    }
    public void inASuper(ASuper node)
    {
        defaultIn(node);
    }
    public void inASuperConstructorInvocation(ASuperConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inASuperFieldAccess(ASuperFieldAccess node)
    {
        defaultIn(node);
    }
    public void inASuperMethodInvocation(ASuperMethodInvocation node)
    {
        defaultIn(node);
    }
    public void inASuperMethodInvocationExp(ASuperMethodInvocationExp node)
    {
        defaultIn(node);
    }
    public void inASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
    {
        defaultIn(node);
    }
    public void inASwitchStmt(ASwitchStmt node)
    {
        defaultIn(node);
    }
    public void inASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inASynchronizedModifier(ASynchronizedModifier node)
    {
        defaultIn(node);
    }
    public void inASynchronizedStmt(ASynchronizedStmt node)
    {
        defaultIn(node);
    }
    public void inASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inAThisConstructorInvocation(AThisConstructorInvocation node)
    {
        defaultIn(node);
    }
    public void inAThisExp(AThisExp node)
    {
        defaultIn(node);
    }
    public void inAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAThrows(AThrows node)
    {
        defaultIn(node);
    }
    public void inAThrowStmt(AThrowStmt node)
    {
        defaultIn(node);
    }
    public void inAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inATransientModifier(ATransientModifier node)
    {
        defaultIn(node);
    }
    public void inATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        defaultIn(node);
    }
    public void inATryFinallyStmt(ATryFinallyStmt node)
    {
        defaultIn(node);
    }
    public void inATryOneTryStmt(ATryOneTryStmt node)
    {
        defaultIn(node);
    }
    public void inATryStmt(ATryStmt node)
    {
        defaultIn(node);
    }
    public void inATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
    {
        defaultIn(node);
    }
    public void inATypedMethodHeader(ATypedMethodHeader node)
    {
        defaultIn(node);
    }
    public void inATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
    {
        defaultIn(node);
    }
    public void inATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
    {
        defaultIn(node);
    }
    public void inAUnaryExp(AUnaryExp node)
    {
        defaultIn(node);
    }
    public void inAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
    {
        defaultIn(node);
    }
    public void inAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
    {
        defaultIn(node);
    }
    public void inAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
    {
        defaultIn(node);
    }
    public void inAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
    {
        defaultIn(node);
    }
    public void inAVariableDeclaratorId(AVariableDeclaratorId node)
    {
        defaultIn(node);
    }
    public void inAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
    {
        defaultIn(node);
    }
    public void inAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
    {
        defaultIn(node);
    }
    public void inAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
    {
        defaultIn(node);
    }
    public void inAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
    {
        defaultIn(node);
    }
    public void inAVoidExp(AVoidExp node)
    {
        defaultIn(node);
    }
    public void inAVoidMethodHeader(AVoidMethodHeader node)
    {
        defaultIn(node);
    }
    public void inAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
    {
        defaultIn(node);
    }
    public void inAVolatileModifier(AVolatileModifier node)
    {
        defaultIn(node);
    }
    public void inAWhileStmt(AWhileStmt node)
    {
        defaultIn(node);
    }
    public void inAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
    {
        defaultIn(node);
    }
    public void inAWhileStmtStmt(AWhileStmtStmt node)
    {
        defaultIn(node);
    }
    public void inStart(Start node)
    {
        defaultIn(node);
    }
    public void outAAbstractMethodDeclaration(AAbstractMethodDeclaration node)
    {
        defaultOut(node);
    }
    public void outAAbstractMethodDeclarationInterfaceMemberDeclaration(AAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAAbstractModifier(AAbstractModifier node)
    {
        defaultOut(node);
    }
    public void outAAdditiveExpShiftExp(AAdditiveExpShiftExp node)
    {
        defaultOut(node);
    }
    public void outAAndBinaryOperator(AAndBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAAndExpAndExp(AAndExpAndExp node)
    {
        defaultOut(node);
    }
    public void outAAndExpExclusiveOrExp(AAndExpExclusiveOrExp node)
    {
        defaultOut(node);
    }
    public void outAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        defaultOut(node);
    }
    public void outAArrayAccessExp(AArrayAccessExp node)
    {
        defaultOut(node);
    }
    public void outAArrayAccessLeftHandSide(AArrayAccessLeftHandSide node)
    {
        defaultOut(node);
    }
    public void outAArrayAccessPrimaryNoNewArray(AArrayAccessPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAArrayCreationExpPrimary(AArrayCreationExpPrimary node)
    {
        defaultOut(node);
    }
    public void outAArrayInitializer(AArrayInitializer node)
    {
        defaultOut(node);
    }
    public void outAArrayReferenceType(AArrayReferenceType node)
    {
        defaultOut(node);
    }
    public void outAArrayVariableInitializer(AArrayVariableInitializer node)
    {
        defaultOut(node);
    }
    public void outAAssertionCompilationUnit(AAssertionCompilationUnit node)
    {
        defaultOut(node);
    }
    public void outAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAAssignedVariableDeclarator(AAssignedVariableDeclarator node)
    {
        defaultOut(node);
    }
    public void outAAssignment(AAssignment node)
    {
        defaultOut(node);
    }
    public void outAAssignmentAssignmentExp(AAssignmentAssignmentExp node)
    {
        defaultOut(node);
    }
    public void outAAssignmentExp(AAssignmentExp node)
    {
        defaultOut(node);
    }
    public void outAAssignmentStmtExp(AAssignmentStmtExp node)
    {
        defaultOut(node);
    }
    public void outABinaryExp(ABinaryExp node)
    {
        defaultOut(node);
    }
    public void outABitAndAssignAssignmentOperator(ABitAndAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outABitAndBinaryOperator(ABitAndBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outABitComplementUnaryExpNotPlusMinus(ABitComplementUnaryExpNotPlusMinus node)
    {
        defaultOut(node);
    }
    public void outABitComplementUnaryOperator(ABitComplementUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outABitOrAssignAssignmentOperator(ABitOrAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outABitOrBinaryOperator(ABitOrBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outABitXorAssignAssignmentOperator(ABitXorAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outABitXorBinaryOperator(ABitXorBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outABlock(ABlock node)
    {
        defaultOut(node);
    }
    public void outABlockClassBodyDeclaration(ABlockClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outABlockMethodBody(ABlockMethodBody node)
    {
        defaultOut(node);
    }
    public void outABlockStmt(ABlockStmt node)
    {
        defaultOut(node);
    }
    public void outABlockStmtWithoutTrailingSubstmt(ABlockStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outABooleanPrimitiveType(ABooleanPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outABreakStmt(ABreakStmt node)
    {
        defaultOut(node);
    }
    public void outABreakStmtStmtWithoutTrailingSubstmt(ABreakStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outAByteIntegralType(AByteIntegralType node)
    {
        defaultOut(node);
    }
    public void outABytePrimitiveType(ABytePrimitiveType node)
    {
        defaultOut(node);
    }
    public void outACaseSwitchLabel(ACaseSwitchLabel node)
    {
        defaultOut(node);
    }
    public void outACastExpUnaryExpNotPlusMinus(ACastExpUnaryExpNotPlusMinus node)
    {
        defaultOut(node);
    }
    public void outACatchClause(ACatchClause node)
    {
        defaultOut(node);
    }
    public void outACharacterLiteralLiteral(ACharacterLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outACharIntegralType(ACharIntegralType node)
    {
        defaultOut(node);
    }
    public void outACharPrimitiveType(ACharPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outAClassBody(AClassBody node)
    {
        defaultOut(node);
    }
    public void outAClassClassBodyDeclaration(AClassClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassDeclaration(AClassDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassDeclarationBlockedStmt(AClassDeclarationBlockedStmt node)
    {
        defaultOut(node);
    }
    public void outAClassDeclarationClassMemberDeclaration(AClassDeclarationClassMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassDeclarationInterfaceMemberDeclaration(AClassDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassInstanceCreationExpPrimaryNoNewArray(AClassInstanceCreationExpPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAClassInstanceCreationExpStmtExp(AClassInstanceCreationExpStmtExp node)
    {
        defaultOut(node);
    }
    public void outAClassMemberDeclarationClassBodyDeclaration(AClassMemberDeclarationClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassOrInterfaceType(AClassOrInterfaceType node)
    {
        defaultOut(node);
    }
    public void outAClassOrInterfaceTypeArrayCreationExp(AClassOrInterfaceTypeArrayCreationExp node)
    {
        defaultOut(node);
    }
    public void outAClassOrInterfaceTypeExp(AClassOrInterfaceTypeExp node)
    {
        defaultOut(node);
    }
    public void outAClassOrInterfaceTypeReferenceType(AClassOrInterfaceTypeReferenceType node)
    {
        defaultOut(node);
    }
    public void outAClassType(AClassType node)
    {
        defaultOut(node);
    }
    public void outAClassTypeClassTypeList(AClassTypeClassTypeList node)
    {
        defaultOut(node);
    }
    public void outAClassTypeDeclaration(AClassTypeDeclaration node)
    {
        defaultOut(node);
    }
    public void outAClassTypeListClassTypeList(AClassTypeListClassTypeList node)
    {
        defaultOut(node);
    }
    public void outACompilationUnit(ACompilationUnit node)
    {
        defaultOut(node);
    }
    public void outAComplementUnaryExpNotPlusMinus(AComplementUnaryExpNotPlusMinus node)
    {
        defaultOut(node);
    }
    public void outAComplementUnaryOperator(AComplementUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outAConditionalAndExpConditionalAndExp(AConditionalAndExpConditionalAndExp node)
    {
        defaultOut(node);
    }
    public void outAConditionalAndExpConditionalOrExp(AConditionalAndExpConditionalOrExp node)
    {
        defaultOut(node);
    }
    public void outAConditionalExpAssignmentExp(AConditionalExpAssignmentExp node)
    {
        defaultOut(node);
    }
    public void outAConditionalOrExpConditionalExp(AConditionalOrExpConditionalExp node)
    {
        defaultOut(node);
    }
    public void outAConditionalOrExpConditionalOrExp(AConditionalOrExpConditionalOrExp node)
    {
        defaultOut(node);
    }
    public void outAConstantDeclaration(AConstantDeclaration node)
    {
        defaultOut(node);
    }
    public void outAConstantDeclarationInterfaceMemberDeclaration(AConstantDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAConstantExp(AConstantExp node)
    {
        defaultOut(node);
    }
    public void outAConstructorBody(AConstructorBody node)
    {
        defaultOut(node);
    }
    public void outAConstructorClassBodyDeclaration(AConstructorClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAConstructorDeclaration(AConstructorDeclaration node)
    {
        defaultOut(node);
    }
    public void outAConstructorDeclarator(AConstructorDeclarator node)
    {
        defaultOut(node);
    }
    public void outAContinueStmt(AContinueStmt node)
    {
        defaultOut(node);
    }
    public void outAContinueStmtStmtWithoutTrailingSubstmt(AContinueStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        defaultOut(node);
    }
    public void outADecrementUnaryOperator(ADecrementUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outADefaultSwitchLabel(ADefaultSwitchLabel node)
    {
        defaultOut(node);
    }
    public void outADim(ADim node)
    {
        defaultOut(node);
    }
    public void outADimExp(ADimExp node)
    {
        defaultOut(node);
    }
    public void outADivAssignAssignmentOperator(ADivAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outADivBinaryOperator(ADivBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outADivMultiplicativeExp(ADivMultiplicativeExp node)
    {
        defaultOut(node);
    }
    public void outADoStmt(ADoStmt node)
    {
        defaultOut(node);
    }
    public void outADoStmtStmtWithoutTrailingSubstmt(ADoStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outADoubleFloatingPointType(ADoubleFloatingPointType node)
    {
        defaultOut(node);
    }
    public void outADoublePrimitiveType(ADoublePrimitiveType node)
    {
        defaultOut(node);
    }
    public void outAEmptyMethodBody(AEmptyMethodBody node)
    {
        defaultOut(node);
    }
    public void outAEmptyStmt(AEmptyStmt node)
    {
        defaultOut(node);
    }
    public void outAEmptyStmtStmtWithoutTrailingSubstmt(AEmptyStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outAEmptyTypeDeclaration(AEmptyTypeDeclaration node)
    {
        defaultOut(node);
    }
    public void outAEqBinaryOperator(AEqBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAEqEqualityExp(AEqEqualityExp node)
    {
        defaultOut(node);
    }
    public void outAEqualityExpAndExp(AEqualityExpAndExp node)
    {
        defaultOut(node);
    }
    public void outAExclusiveOrExpExclusiveOrExp(AExclusiveOrExpExclusiveOrExp node)
    {
        defaultOut(node);
    }
    public void outAExclusiveOrExpInclusiveOrExp(AExclusiveOrExpInclusiveOrExp node)
    {
        defaultOut(node);
    }
    public void outAExpArgumentList(AExpArgumentList node)
    {
        defaultOut(node);
    }
    public void outAExpCastExp(AExpCastExp node)
    {
        defaultOut(node);
    }
    public void outAExpListForInit(AExpListForInit node)
    {
        defaultOut(node);
    }
    public void outAExpStmt(AExpStmt node)
    {
        defaultOut(node);
    }
    public void outAExpStmtStmtWithoutTrailingSubstmt(AExpStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outAExpVariableInitializer(AExpVariableInitializer node)
    {
        defaultOut(node);
    }
    public void outAExtendsExtendsInterfaces(AExtendsExtendsInterfaces node)
    {
        defaultOut(node);
    }
    public void outAExtendsInterfacesExtendsInterfaces(AExtendsInterfacesExtendsInterfaces node)
    {
        defaultOut(node);
    }
    public void outAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        defaultOut(node);
    }
    public void outAFieldAccessExp(AFieldAccessExp node)
    {
        defaultOut(node);
    }
    public void outAFieldAccessLeftHandSide(AFieldAccessLeftHandSide node)
    {
        defaultOut(node);
    }
    public void outAFieldAccessPrimaryNoNewArray(AFieldAccessPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAFieldClassBodyDeclaration(AFieldClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAFieldDeclaration(AFieldDeclaration node)
    {
        defaultOut(node);
    }
    public void outAFieldDeclarationClassMemberDeclaration(AFieldDeclarationClassMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAFinally(AFinally node)
    {
        defaultOut(node);
    }
    public void outAFinallyOneTryStmt(AFinallyOneTryStmt node)
    {
        defaultOut(node);
    }
    public void outAFinalModifier(AFinalModifier node)
    {
        defaultOut(node);
    }
    public void outAFloatFloatingPointType(AFloatFloatingPointType node)
    {
        defaultOut(node);
    }
    public void outAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outAFloatingPointTypeNumericType(AFloatingPointTypeNumericType node)
    {
        defaultOut(node);
    }
    public void outAFloatPrimitiveType(AFloatPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outAFormalParameter(AFormalParameter node)
    {
        defaultOut(node);
    }
    public void outAFormalParameterFormalParameterList(AFormalParameterFormalParameterList node)
    {
        defaultOut(node);
    }
    public void outAFormalParameterListFormalParameterList(AFormalParameterListFormalParameterList node)
    {
        defaultOut(node);
    }
    public void outAForStmt(AForStmt node)
    {
        defaultOut(node);
    }
    public void outAForStmtNoShortIf(AForStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAForStmtNoShortIfStmtNoShortIf(AForStmtNoShortIfStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAForStmtStmt(AForStmtStmt node)
    {
        defaultOut(node);
    }
    public void outAForUpdate(AForUpdate node)
    {
        defaultOut(node);
    }
    public void outAGtBinaryOperator(AGtBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAGteqBinaryOperator(AGteqBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAGteqRelationalExp(AGteqRelationalExp node)
    {
        defaultOut(node);
    }
    public void outAGtRelationalExp(AGtRelationalExp node)
    {
        defaultOut(node);
    }
    public void outAHexIntegerLiteral(AHexIntegerLiteral node)
    {
        defaultOut(node);
    }
    public void outAIdVariableDeclarator(AIdVariableDeclarator node)
    {
        defaultOut(node);
    }
    public void outAIfStmt(AIfStmt node)
    {
        defaultOut(node);
    }
    public void outAIfThenElseStmt(AIfThenElseStmt node)
    {
        defaultOut(node);
    }
    public void outAIfThenElseStmtNoShortIf(AIfThenElseStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAIfThenElseStmtNoShortIfStmtNoShortIf(AIfThenElseStmtNoShortIfStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAIfThenElseStmtStmt(AIfThenElseStmtStmt node)
    {
        defaultOut(node);
    }
    public void outAIfThenStmt(AIfThenStmt node)
    {
        defaultOut(node);
    }
    public void outAIfThenStmtStmt(AIfThenStmtStmt node)
    {
        defaultOut(node);
    }
    public void outAInclusiveOrExpConditionalAndExp(AInclusiveOrExpConditionalAndExp node)
    {
        defaultOut(node);
    }
    public void outAInclusiveOrExpInclusiveOrExp(AInclusiveOrExpInclusiveOrExp node)
    {
        defaultOut(node);
    }
    public void outAIncrementUnaryOperator(AIncrementUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outAInitClassInterfaceArrayCreationExp(AInitClassInterfaceArrayCreationExp node)
    {
        defaultOut(node);
    }
    public void outAInitClassInterfaceExp(AInitClassInterfaceExp node)
    {
        defaultOut(node);
    }
    public void outAInitPrimitiveArrayCreationExp(AInitPrimitiveArrayCreationExp node)
    {
        defaultOut(node);
    }
    public void outAInitPrimitiveExp(AInitPrimitiveExp node)
    {
        defaultOut(node);
    }
    public void outAInstanceofExp(AInstanceofExp node)
    {
        defaultOut(node);
    }
    public void outAInstanceofRelationalExp(AInstanceofRelationalExp node)
    {
        defaultOut(node);
    }
    public void outAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outAIntegralTypeNumericType(AIntegralTypeNumericType node)
    {
        defaultOut(node);
    }
    public void outAInterfaceBody(AInterfaceBody node)
    {
        defaultOut(node);
    }
    public void outAInterfaceClassBodyDeclaration(AInterfaceClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAInterfaceDeclaration(AInterfaceDeclaration node)
    {
        defaultOut(node);
    }
    public void outAInterfaceDeclarationClassMemberDeclaration(AInterfaceDeclarationClassMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAInterfaceDeclarationInterfaceMemberDeclaration(AInterfaceDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAInterfaces(AInterfaces node)
    {
        defaultOut(node);
    }
    public void outAInterfaceType(AInterfaceType node)
    {
        defaultOut(node);
    }
    public void outAInterfaceTypeDeclaration(AInterfaceTypeDeclaration node)
    {
        defaultOut(node);
    }
    public void outAInterfaceTypeInterfaceTypeList(AInterfaceTypeInterfaceTypeList node)
    {
        defaultOut(node);
    }
    public void outAInterfaceTypeListInterfaceTypeList(AInterfaceTypeListInterfaceTypeList node)
    {
        defaultOut(node);
    }
    public void outAIntIntegralType(AIntIntegralType node)
    {
        defaultOut(node);
    }
    public void outAIntPrimitiveType(AIntPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outALabeledStmt(ALabeledStmt node)
    {
        defaultOut(node);
    }
    public void outALabeledStmtNoShortIf(ALabeledStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outALabeledStmtNoShortIfStmtNoShortIf(ALabeledStmtNoShortIfStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outALabeledStmtStmt(ALabeledStmtStmt node)
    {
        defaultOut(node);
    }
    public void outALabelStmt(ALabelStmt node)
    {
        defaultOut(node);
    }
    public void outALiteralExp(ALiteralExp node)
    {
        defaultOut(node);
    }
    public void outALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outALocalVariableDeclaration(ALocalVariableDeclaration node)
    {
        defaultOut(node);
    }
    public void outALocalVariableDeclarationForInit(ALocalVariableDeclarationForInit node)
    {
        defaultOut(node);
    }
    public void outALocalVariableDeclarationInBlockedStmt(ALocalVariableDeclarationInBlockedStmt node)
    {
        defaultOut(node);
    }
    public void outALocalVariableDeclarationStmt(ALocalVariableDeclarationStmt node)
    {
        defaultOut(node);
    }
    public void outALocalVariableDeclarationStmtBlockedStmt(ALocalVariableDeclarationStmtBlockedStmt node)
    {
        defaultOut(node);
    }
    public void outALongIntegralType(ALongIntegralType node)
    {
        defaultOut(node);
    }
    public void outALongPrimitiveType(ALongPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outALParPrimaryNoNewArray(ALParPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outALtBinaryOperator(ALtBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outALteqBinaryOperator(ALteqBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outALteqRelationalExp(ALteqRelationalExp node)
    {
        defaultOut(node);
    }
    public void outALtRelationalExp(ALtRelationalExp node)
    {
        defaultOut(node);
    }
    public void outAMethodClassBodyDeclaration(AMethodClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAMethodDeclaration(AMethodDeclaration node)
    {
        defaultOut(node);
    }
    public void outAMethodDeclarationClassMemberDeclaration(AMethodDeclarationClassMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAMethodDeclarator(AMethodDeclarator node)
    {
        defaultOut(node);
    }
    public void outAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAMethodInvocationStmtExp(AMethodInvocationStmtExp node)
    {
        defaultOut(node);
    }
    public void outAMinusAdditiveExp(AMinusAdditiveExp node)
    {
        defaultOut(node);
    }
    public void outAMinusAssignAssignmentOperator(AMinusAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAMinusBinaryOperator(AMinusBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAMinusUnaryExp(AMinusUnaryExp node)
    {
        defaultOut(node);
    }
    public void outAMinusUnaryOperator(AMinusUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outAModAssignAssignmentOperator(AModAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAModBinaryOperator(AModBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAModMultiplicativeExp(AModMultiplicativeExp node)
    {
        defaultOut(node);
    }
    public void outAMultiplicativeExpAdditiveExp(AMultiplicativeExpAdditiveExp node)
    {
        defaultOut(node);
    }
    public void outANameArrayAccess(ANameArrayAccess node)
    {
        defaultOut(node);
    }
    public void outANameArrayType(ANameArrayType node)
    {
        defaultOut(node);
    }
    public void outANameCastExp(ANameCastExp node)
    {
        defaultOut(node);
    }
    public void outANamedTypeExp(ANamedTypeExp node)
    {
        defaultOut(node);
    }
    public void outANameExp(ANameExp node)
    {
        defaultOut(node);
    }
    public void outANameLeftHandSide(ANameLeftHandSide node)
    {
        defaultOut(node);
    }
    public void outANameMethodInvocation(ANameMethodInvocation node)
    {
        defaultOut(node);
    }
    public void outANameMethodInvocationExp(ANameMethodInvocationExp node)
    {
        defaultOut(node);
    }
    public void outANamePostfixExp(ANamePostfixExp node)
    {
        defaultOut(node);
    }
    public void outANameReferenceType(ANameReferenceType node)
    {
        defaultOut(node);
    }
    public void outANativeModifier(ANativeModifier node)
    {
        defaultOut(node);
    }
    public void outANeqBinaryOperator(ANeqBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outANeqEqualityExp(ANeqEqualityExp node)
    {
        defaultOut(node);
    }
    public void outANotPlusMinusUnaryExp(ANotPlusMinusUnaryExp node)
    {
        defaultOut(node);
    }
    public void outANullLiteral(ANullLiteral node)
    {
        defaultOut(node);
    }
    public void outANullLiteralLiteral(ANullLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outANumericTypePrimitiveType(ANumericTypePrimitiveType node)
    {
        defaultOut(node);
    }
    public void outAOctalIntegerLiteral(AOctalIntegerLiteral node)
    {
        defaultOut(node);
    }
    public void outAOldAbstractMethodDeclarationInterfaceMemberDeclaration(AOldAbstractMethodDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldArrayInitializer(AOldArrayInitializer node)
    {
        defaultOut(node);
    }
    public void outAOldCaseSwitchLabel(AOldCaseSwitchLabel node)
    {
        defaultOut(node);
    }
    public void outAOldCompilationUnit(AOldCompilationUnit node)
    {
        defaultOut(node);
    }
    public void outAOldConstantDeclarationInterfaceMemberDeclaration(AOldConstantDeclarationInterfaceMemberDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldConstructorDeclarator(AOldConstructorDeclarator node)
    {
        defaultOut(node);
    }
    public void outAOldExp(AOldExp node)
    {
        defaultOut(node);
    }
    public void outAOldExpCastExp(AOldExpCastExp node)
    {
        defaultOut(node);
    }
    public void outAOldFieldDeclaration(AOldFieldDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldInterfaceDeclaration(AOldInterfaceDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldInterfaces(AOldInterfaces node)
    {
        defaultOut(node);
    }
    public void outAOldLocalVariableDeclaration(AOldLocalVariableDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldMethodDeclarator(AOldMethodDeclarator node)
    {
        defaultOut(node);
    }
    public void outAOldNameCastExp(AOldNameCastExp node)
    {
        defaultOut(node);
    }
    public void outAOldNamedTypePrimaryNoNewArray(AOldNamedTypePrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAOldPrimaryFieldAccess(AOldPrimaryFieldAccess node)
    {
        defaultOut(node);
    }
    public void outAOldPrimaryNoNewArrayArrayAccess(AOldPrimaryNoNewArrayArrayAccess node)
    {
        defaultOut(node);
    }
    public void outAOldPrimitiveTypeCastExp(AOldPrimitiveTypeCastExp node)
    {
        defaultOut(node);
    }
    public void outAOldPrimitiveTypePrimaryNoNewArray(AOldPrimitiveTypePrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAOldQualifiedClassInstanceCreationExp(AOldQualifiedClassInstanceCreationExp node)
    {
        defaultOut(node);
    }
    public void outAOldQualifiedConstructorInvocation(AOldQualifiedConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outAOldSimpleClassInstanceCreationExp(AOldSimpleClassInstanceCreationExp node)
    {
        defaultOut(node);
    }
    public void outAOldStaticInitializerClassBodyDeclaration(AOldStaticInitializerClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOldSuper(AOldSuper node)
    {
        defaultOut(node);
    }
    public void outAOldSuperConstructorInvocation(AOldSuperConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outAOldThisConstructorInvocation(AOldThisConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outAOldThrows(AOldThrows node)
    {
        defaultOut(node);
    }
    public void outAOneBreakStmt(AOneBreakStmt node)
    {
        defaultOut(node);
    }
    public void outAOneContinueStmt(AOneContinueStmt node)
    {
        defaultOut(node);
    }
    public void outAOneDoStmt(AOneDoStmt node)
    {
        defaultOut(node);
    }
    public void outAOneForStmt(AOneForStmt node)
    {
        defaultOut(node);
    }
    public void outAOneQualifiedName(AOneQualifiedName node)
    {
        defaultOut(node);
    }
    public void outAOneReturnStmt(AOneReturnStmt node)
    {
        defaultOut(node);
    }
    public void outAOneSimpleName(AOneSimpleName node)
    {
        defaultOut(node);
    }
    public void outAOneSingleTypeImportDeclaration(AOneSingleTypeImportDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOneSwitchStmt(AOneSwitchStmt node)
    {
        defaultOut(node);
    }
    public void outAOneSynchronizedStmt(AOneSynchronizedStmt node)
    {
        defaultOut(node);
    }
    public void outAOneThrowStmt(AOneThrowStmt node)
    {
        defaultOut(node);
    }
    public void outAOneTypeImportOnDemandDeclaration(AOneTypeImportOnDemandDeclaration node)
    {
        defaultOut(node);
    }
    public void outAOneWhileStmt(AOneWhileStmt node)
    {
        defaultOut(node);
    }
    public void outAOrBinaryOperator(AOrBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAOriginalExpStmt(AOriginalExpStmt node)
    {
        defaultOut(node);
    }
    public void outAPackageDeclaration(APackageDeclaration node)
    {
        defaultOut(node);
    }
    public void outAParExp(AParExp node)
    {
        defaultOut(node);
    }
    public void outAPlusAdditiveExp(APlusAdditiveExp node)
    {
        defaultOut(node);
    }
    public void outAPlusAssignAssignmentOperator(APlusAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAPlusBinaryOperator(APlusBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAPlusUnaryExp(APlusUnaryExp node)
    {
        defaultOut(node);
    }
    public void outAPlusUnaryOperator(APlusUnaryOperator node)
    {
        defaultOut(node);
    }
    public void outAPostDecrementExp(APostDecrementExp node)
    {
        defaultOut(node);
    }
    public void outAPostDecrementExpPostfixExp(APostDecrementExpPostfixExp node)
    {
        defaultOut(node);
    }
    public void outAPostDecrementExpr(APostDecrementExpr node)
    {
        defaultOut(node);
    }
    public void outAPostDecrementExpStmtExp(APostDecrementExpStmtExp node)
    {
        defaultOut(node);
    }
    public void outAPostfixExpUnaryExpNotPlusMinus(APostfixExpUnaryExpNotPlusMinus node)
    {
        defaultOut(node);
    }
    public void outAPostIncrementExp(APostIncrementExp node)
    {
        defaultOut(node);
    }
    public void outAPostIncrementExpPostfixExp(APostIncrementExpPostfixExp node)
    {
        defaultOut(node);
    }
    public void outAPostIncrementExpr(APostIncrementExpr node)
    {
        defaultOut(node);
    }
    public void outAPostIncrementExpStmtExp(APostIncrementExpStmtExp node)
    {
        defaultOut(node);
    }
    public void outAPreDecrementExp(APreDecrementExp node)
    {
        defaultOut(node);
    }
    public void outAPreDecrementExpStmtExp(APreDecrementExpStmtExp node)
    {
        defaultOut(node);
    }
    public void outAPreDecrementExpUnaryExp(APreDecrementExpUnaryExp node)
    {
        defaultOut(node);
    }
    public void outAPreIncrementExp(APreIncrementExp node)
    {
        defaultOut(node);
    }
    public void outAPreIncrementExpStmtExp(APreIncrementExpStmtExp node)
    {
        defaultOut(node);
    }
    public void outAPreIncrementExpUnaryExp(APreIncrementExpUnaryExp node)
    {
        defaultOut(node);
    }
    public void outAPrimaryFieldAccess(APrimaryFieldAccess node)
    {
        defaultOut(node);
    }
    public void outAPrimaryMethodInvocation(APrimaryMethodInvocation node)
    {
        defaultOut(node);
    }
    public void outAPrimaryMethodInvocationExp(APrimaryMethodInvocationExp node)
    {
        defaultOut(node);
    }
    public void outAPrimaryNoNewArrayArrayAccess(APrimaryNoNewArrayArrayAccess node)
    {
        defaultOut(node);
    }
    public void outAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        defaultOut(node);
    }
    public void outAPrimaryPostfixExp(APrimaryPostfixExp node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveArrayType(APrimitiveArrayType node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveType(APrimitiveType node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveTypeArrayCreationExp(APrimitiveTypeArrayCreationExp node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveTypeArrayExp(APrimitiveTypeArrayExp node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveTypeCastExp(APrimitiveTypeCastExp node)
    {
        defaultOut(node);
    }
    public void outAPrimitiveTypePrimaryExp(APrimitiveTypePrimaryExp node)
    {
        defaultOut(node);
    }
    public void outAPrivateModifier(APrivateModifier node)
    {
        defaultOut(node);
    }
    public void outAProtectedModifier(AProtectedModifier node)
    {
        defaultOut(node);
    }
    public void outAPublicModifier(APublicModifier node)
    {
        defaultOut(node);
    }
    public void outAQualifiedClassInstanceCreationExp(AQualifiedClassInstanceCreationExp node)
    {
        defaultOut(node);
    }
    public void outAQualifiedConstructorInvocation(AQualifiedConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outAQualifiedName(AQualifiedName node)
    {
        defaultOut(node);
    }
    public void outAQualifiedNameName(AQualifiedNameName node)
    {
        defaultOut(node);
    }
    public void outAQualifiedThisExp(AQualifiedThisExp node)
    {
        defaultOut(node);
    }
    public void outAQualifiedThisPrimaryNoNewArray(AQualifiedThisPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAQuestionConditionalExp(AQuestionConditionalExp node)
    {
        defaultOut(node);
    }
    public void outAQuestionExp(AQuestionExp node)
    {
        defaultOut(node);
    }
    public void outAReferenceType(AReferenceType node)
    {
        defaultOut(node);
    }
    public void outARelationalExpEqualityExp(ARelationalExpEqualityExp node)
    {
        defaultOut(node);
    }
    public void outAReturnStmt(AReturnStmt node)
    {
        defaultOut(node);
    }
    public void outAReturnStmtStmtWithoutTrailingSubstmt(AReturnStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outASemicolonStmt(ASemicolonStmt node)
    {
        defaultOut(node);
    }
    public void outAShiftExpRelationalExp(AShiftExpRelationalExp node)
    {
        defaultOut(node);
    }
    public void outAShiftLeftAssignAssignmentOperator(AShiftLeftAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAShiftLeftBinaryOperator(AShiftLeftBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAShiftLeftShiftExp(AShiftLeftShiftExp node)
    {
        defaultOut(node);
    }
    public void outAShortIntegralType(AShortIntegralType node)
    {
        defaultOut(node);
    }
    public void outAShortPrimitiveType(AShortPrimitiveType node)
    {
        defaultOut(node);
    }
    public void outASignedShiftRightAssignAssignmentOperator(ASignedShiftRightAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outASignedShiftRightBinaryOperator(ASignedShiftRightBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outASignedShiftRightShiftExp(ASignedShiftRightShiftExp node)
    {
        defaultOut(node);
    }
    public void outASimpleClassInstanceCreationExp(ASimpleClassInstanceCreationExp node)
    {
        defaultOut(node);
    }
    public void outASimpleName(ASimpleName node)
    {
        defaultOut(node);
    }
    public void outASimpleNameName(ASimpleNameName node)
    {
        defaultOut(node);
    }
    public void outASingleTypeImportDeclaration(ASingleTypeImportDeclaration node)
    {
        defaultOut(node);
    }
    public void outASingleTypeImportDeclarationImportDeclaration(ASingleTypeImportDeclarationImportDeclaration node)
    {
        defaultOut(node);
    }
    public void outAStarAssignAssignmentOperator(AStarAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAStarBinaryOperator(AStarBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAStarMultiplicativeExp(AStarMultiplicativeExp node)
    {
        defaultOut(node);
    }
    public void outAStaticInitializer(AStaticInitializer node)
    {
        defaultOut(node);
    }
    public void outAStaticInitializerClassBodyDeclaration(AStaticInitializerClassBodyDeclaration node)
    {
        defaultOut(node);
    }
    public void outAStaticModifier(AStaticModifier node)
    {
        defaultOut(node);
    }
    public void outAStmtBlockedStmt(AStmtBlockedStmt node)
    {
        defaultOut(node);
    }
    public void outAStmtExpListForInit(AStmtExpListForInit node)
    {
        defaultOut(node);
    }
    public void outAStmtExpListStmtExpList(AStmtExpListStmtExpList node)
    {
        defaultOut(node);
    }
    public void outAStmtExpStmtExpList(AStmtExpStmtExpList node)
    {
        defaultOut(node);
    }
    public void outAStmtWithoutTrailingSubstmtStmt(AStmtWithoutTrailingSubstmtStmt node)
    {
        defaultOut(node);
    }
    public void outAStmtWithoutTrailingSubstmtStmtNoShortIf(AStmtWithoutTrailingSubstmtStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        defaultOut(node);
    }
    public void outASuper(ASuper node)
    {
        defaultOut(node);
    }
    public void outASuperConstructorInvocation(ASuperConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outASuperFieldAccess(ASuperFieldAccess node)
    {
        defaultOut(node);
    }
    public void outASuperMethodInvocation(ASuperMethodInvocation node)
    {
        defaultOut(node);
    }
    public void outASuperMethodInvocationExp(ASuperMethodInvocationExp node)
    {
        defaultOut(node);
    }
    public void outASwitchBlockStmtGroup(ASwitchBlockStmtGroup node)
    {
        defaultOut(node);
    }
    public void outASwitchStmt(ASwitchStmt node)
    {
        defaultOut(node);
    }
    public void outASwitchStmtStmtWithoutTrailingSubstmt(ASwitchStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outASynchronizedModifier(ASynchronizedModifier node)
    {
        defaultOut(node);
    }
    public void outASynchronizedStmt(ASynchronizedStmt node)
    {
        defaultOut(node);
    }
    public void outASynchronizedStmtStmtWithoutTrailingSubstmt(ASynchronizedStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outAThisConstructorInvocation(AThisConstructorInvocation node)
    {
        defaultOut(node);
    }
    public void outAThisExp(AThisExp node)
    {
        defaultOut(node);
    }
    public void outAThisPrimaryNoNewArray(AThisPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAThrows(AThrows node)
    {
        defaultOut(node);
    }
    public void outAThrowStmt(AThrowStmt node)
    {
        defaultOut(node);
    }
    public void outAThrowStmtStmtWithoutTrailingSubstmt(AThrowStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outATransientModifier(ATransientModifier node)
    {
        defaultOut(node);
    }
    public void outATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        defaultOut(node);
    }
    public void outATryFinallyStmt(ATryFinallyStmt node)
    {
        defaultOut(node);
    }
    public void outATryOneTryStmt(ATryOneTryStmt node)
    {
        defaultOut(node);
    }
    public void outATryStmt(ATryStmt node)
    {
        defaultOut(node);
    }
    public void outATryStmtStmtWithoutTrailingSubstmt(ATryStmtStmtWithoutTrailingSubstmt node)
    {
        defaultOut(node);
    }
    public void outATypedMethodHeader(ATypedMethodHeader node)
    {
        defaultOut(node);
    }
    public void outATypeImportOnDemandDeclarationImportDeclaration(ATypeImportOnDemandDeclarationImportDeclaration node)
    {
        defaultOut(node);
    }
    public void outATypeOnDemandImportDeclaration(ATypeOnDemandImportDeclaration node)
    {
        defaultOut(node);
    }
    public void outAUnaryExp(AUnaryExp node)
    {
        defaultOut(node);
    }
    public void outAUnaryExpMultiplicativeExp(AUnaryExpMultiplicativeExp node)
    {
        defaultOut(node);
    }
    public void outAUnsignedShiftRightAssignAssignmentOperator(AUnsignedShiftRightAssignAssignmentOperator node)
    {
        defaultOut(node);
    }
    public void outAUnsignedShiftRightBinaryOperator(AUnsignedShiftRightBinaryOperator node)
    {
        defaultOut(node);
    }
    public void outAUnsignedShiftRightShiftExp(AUnsignedShiftRightShiftExp node)
    {
        defaultOut(node);
    }
    public void outAVariableDeclaratorId(AVariableDeclaratorId node)
    {
        defaultOut(node);
    }
    public void outAVariableDeclaratorsVariableDeclarators(AVariableDeclaratorsVariableDeclarators node)
    {
        defaultOut(node);
    }
    public void outAVariableDeclaratorVariableDeclarators(AVariableDeclaratorVariableDeclarators node)
    {
        defaultOut(node);
    }
    public void outAVariableInitializersVariableInitializers(AVariableInitializersVariableInitializers node)
    {
        defaultOut(node);
    }
    public void outAVariableInitializerVariableInitializers(AVariableInitializerVariableInitializers node)
    {
        defaultOut(node);
    }
    public void outAVoidExp(AVoidExp node)
    {
        defaultOut(node);
    }
    public void outAVoidMethodHeader(AVoidMethodHeader node)
    {
        defaultOut(node);
    }
    public void outAVoidPrimaryNoNewArray(AVoidPrimaryNoNewArray node)
    {
        defaultOut(node);
    }
    public void outAVolatileModifier(AVolatileModifier node)
    {
        defaultOut(node);
    }
    public void outAWhileStmt(AWhileStmt node)
    {
        defaultOut(node);
    }
    public void outAWhileStmtNoShortIf(AWhileStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAWhileStmtNoShortIfStmtNoShortIf(AWhileStmtNoShortIfStmtNoShortIf node)
    {
        defaultOut(node);
    }
    public void outAWhileStmtStmt(AWhileStmtStmt node)
    {
        defaultOut(node);
    }
    public void outStart(Start node)
    {
        defaultOut(node);
    }
}

---