//
// Generated by JTB 1.3.2
//

package jtb.visitor;
import jtb.syntaxtree.*;
import java.util.*;

/**
 * Provides default methods which visit each node in the tree in depth-first
 * order.  Your visitors may extend this class.
 */
public class GJDepthFirst<R,A> implements GJVisitor<R,A> {
   //
   // Auto class visitors--probably don't need to be overridden.
   //
   public R visit(NodeList n, A argu) {
      R _ret=null;
      int _count=0;
      for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
         e.nextElement().accept(this,argu);
         _count++;
      }
      return _ret;
   }

   public R visit(NodeListOptional n, A argu) {
      if ( n.present() ) {
         R _ret=null;
         int _count=0;
         for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
            e.nextElement().accept(this,argu);
            _count++;
         }
         return _ret;
      }
      else
         return null;
   }

   public R visit(NodeOptional n, A argu) {
      if ( n.present() )
         return n.node.accept(this,argu);
      else
         return null;
   }

   public R visit(NodeSequence n, A argu) {
      R _ret=null;
      int _count=0;
      for ( Enumeration<Node> e = n.elements(); e.hasMoreElements(); ) {
         e.nextElement().accept(this,argu);
         _count++;
      }
      return _ret;
   }

   public R visit(NodeToken n, A argu) { return null; }

   //
   // User-generated visitor methods below
   //

   // f0 -> [ PackageDeclaration() ]
   // f1 -> ( ImportDeclaration() )*
   // f2 -> ( TypeDeclaration() )*
   // f3 -> ( <"\u001a"> )?
   // f4 -> ( <STUFF_TO_IGNORE: ~[]> )?
   // f5 -> <EOF>
   public R visit(CompilationUnit n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      return _ret;
   }

   // f0 -> Modifiers()
   // f1 -> "package"
   // f2 -> Name()
   // f3 -> ";"
   public R visit(PackageDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> "import"
   // f1 -> [ "static" ]
   // f2 -> Name()
   // f3 -> [ "." "*" ]
   // f4 -> ";"
   public R visit(ImportDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> ( ( "public" | "static" | "protected" | "private" | "final" | "abstract" | "synchronized" | "native" | "transient" | "volatile" | "strictfp" | Annotation() ) )*
   public R visit(Modifiers n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> ";"
   //       | Modifiers() ( ClassOrInterfaceDeclaration(modifiers) | EnumDeclaration(modifiers) | AnnotationTypeDeclaration(modifiers) )
   public R visit(TypeDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> ( "class" | "interface" )
   // f1 -> <IDENTIFIER>
   // f2 -> [ TypeParameters() ]
   // f3 -> [ ExtendsList(isInterface) ]
   // f4 -> [ ImplementsList(isInterface) ]
   // f5 -> ClassOrInterfaceBody(isInterface)
   public R visit(ClassOrInterfaceDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      return _ret;
   }

   // f0 -> "extends"
   // f1 -> ClassOrInterfaceType()
   // f2 -> ( "," ClassOrInterfaceType() )*
   public R visit(ExtendsList n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "implements"
   // f1 -> ClassOrInterfaceType()
   // f2 -> ( "," ClassOrInterfaceType() )*
   public R visit(ImplementsList n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "enum"
   // f1 -> <IDENTIFIER>
   // f2 -> [ ImplementsList(false) ]
   // f3 -> EnumBody()
   public R visit(EnumDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> [ EnumConstant() ( "," EnumConstant() )* ]
   // f2 -> [ "," ]
   // f3 -> [ ";" ( ClassOrInterfaceBodyDeclaration(false) )* ]
   // f4 -> "}"
   public R visit(EnumBody n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> Modifiers()
   // f1 -> <IDENTIFIER>
   // f2 -> [ Arguments() ]
   // f3 -> [ ClassOrInterfaceBody(false) ]
   public R visit(EnumConstant n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> "<"
   // f1 -> TypeParameter()
   // f2 -> ( "," TypeParameter() )*
   // f3 -> ">"
   public R visit(TypeParameters n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> [ TypeBound() ]
   public R visit(TypeParameter n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "extends"
   // f1 -> ClassOrInterfaceType()
   // f2 -> ( "&" ClassOrInterfaceType() )*
   public R visit(TypeBound n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> ( ClassOrInterfaceBodyDeclaration(isInterface) )*
   // f2 -> "}"
   public R visit(ClassOrInterfaceBody n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Initializer()
   //       | Modifiers() ( ClassOrInterfaceDeclaration(modifiers) | EnumDeclaration(modifiers) | ConstructorDeclaration() | FieldDeclaration(modifiers) | MethodDeclaration(modifiers) | AnnotationTypeDeclaration(modifiers) )
   //       | ";"
   public R visit(ClassOrInterfaceBodyDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> Type()
   // f1 -> VariableDeclarator()
   // f2 -> ( "," VariableDeclarator() )*
   // f3 -> ";"
   public R visit(FieldDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> VariableDeclaratorId()
   // f1 -> [ "=" VariableInitializer() ]
   public R visit(VariableDeclarator n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> ( "[" "]" )*
   public R visit(VariableDeclaratorId n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ArrayInitializer()
   //       | Expression()
   public R visit(VariableInitializer n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> [ VariableInitializer() ( "," VariableInitializer() )* ]
   // f2 -> [ "," ]
   // f3 -> "}"
   public R visit(ArrayInitializer n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> [ TypeParameters() ]
   // f1 -> ResultType()
   // f2 -> MethodDeclarator()
   // f3 -> [ "throws" NameList() ]
   // f4 -> ( Block() | ";" )
   public R visit(MethodDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> FormalParameters()
   // f2 -> ( "[" "]" )*
   public R visit(MethodDeclarator n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "("
   // f1 -> [ FormalParameter() ( "," FormalParameter() )* ]
   // f2 -> ")"
   public R visit(FormalParameters n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Modifiers()
   // f1 -> [ "final" | Annotation() ]
   // f2 -> Type()
   // f3 -> [ "..." ]
   // f4 -> VariableDeclaratorId()
   public R visit(FormalParameter n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> [ TypeParameters() ]
   // f1 -> <IDENTIFIER>
   // f2 -> FormalParameters()
   // f3 -> [ "throws" NameList() ]
   // f4 -> "{"
   // f5 -> [ ExplicitConstructorInvocation() ]
   // f6 -> ( BlockStatement() )*
   // f7 -> "}"
   public R visit(ConstructorDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      n.f6.accept(this, argu);
      n.f7.accept(this, argu);
      return _ret;
   }

   // f0 -> [ TypeArguments() ] ( "this" | "super" ) Arguments() ";"
   //       | PrimaryExpression() "." [ TypeArguments() ] "super" Arguments() ";"
   public R visit(ExplicitConstructorInvocation n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> [ "static" ]
   // f1 -> Block()
   public R visit(Initializer n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ReferenceType()
   //       | PrimitiveType()
   public R visit(Type n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> PrimitiveType() ( "[" "]" )+
   //       | ( ClassOrInterfaceType() ) ( "[" "]" )*
   public R visit(ReferenceType n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> [ TypeArguments() ]
   // f2 -> ( "." <IDENTIFIER> [ TypeArguments() ] )*
   public R visit(ClassOrInterfaceType n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "<"
   // f1 -> TypeArgument()
   // f2 -> ( "," TypeArgument() )*
   // f3 -> ">"
   public R visit(TypeArguments n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> ReferenceType()
   //       | "?" [ WildcardBounds() ]
   public R visit(TypeArgument n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "extends" ReferenceType()
   //       | "super" ReferenceType()
   public R visit(WildcardBounds n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "boolean"
   //       | "char"
   //       | "byte"
   //       | "short"
   //       | "int"
   //       | "long"
   //       | "float"
   //       | "double"
   public R visit(PrimitiveType n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "void"
   //       | Type()
   public R visit(ResultType n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> ( "." <IDENTIFIER> )*
   public R visit(Name n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> Name()
   // f1 -> ( "," Name() )*
   public R visit(NameList n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ConditionalExpression()
   // f1 -> [ AssignmentOperator() Expression() ]
   public R visit(Expression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "="
   //       | "*="
   //       | "/="
   //       | "%="
   //       | "+="
   //       | "-="
   //       | "<<="
   //       | ">>="
   //       | ">>>="
   //       | "&="
   //       | "^="
   //       | "|="
   public R visit(AssignmentOperator n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> ConditionalOrExpression()
   // f1 -> [ "?" Expression() ":" Expression() ]
   public R visit(ConditionalExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ConditionalAndExpression()
   // f1 -> ( "||" ConditionalAndExpression() )*
   public R visit(ConditionalOrExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> InclusiveOrExpression()
   // f1 -> ( "&&" InclusiveOrExpression() )*
   public R visit(ConditionalAndExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ExclusiveOrExpression()
   // f1 -> ( "|" ExclusiveOrExpression() )*
   public R visit(InclusiveOrExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> AndExpression()
   // f1 -> ( "^" AndExpression() )*
   public R visit(ExclusiveOrExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> EqualityExpression()
   // f1 -> ( "&" EqualityExpression() )*
   public R visit(AndExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> InstanceOfExpression()
   // f1 -> ( ( "==" | "!=" ) InstanceOfExpression() )*
   public R visit(EqualityExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> RelationalExpression()
   // f1 -> [ "instanceof" Type() ]
   public R visit(InstanceOfExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ShiftExpression()
   // f1 -> ( ( "<" | ">" | "<=" | ">=" ) ShiftExpression() )*
   public R visit(RelationalExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> AdditiveExpression()
   // f1 -> ( ( "<<" | RSIGNEDSHIFT() | RUNSIGNEDSHIFT() ) AdditiveExpression() )*
   public R visit(ShiftExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> MultiplicativeExpression()
   // f1 -> ( ( "+" | "-" ) MultiplicativeExpression() )*
   public R visit(AdditiveExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> UnaryExpression()
   // f1 -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
   public R visit(MultiplicativeExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ( "+" | "-" ) UnaryExpression()
   //       | PreIncrementExpression()
   //       | PreDecrementExpression()
   //       | UnaryExpressionNotPlusMinus()
   public R visit(UnaryExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "++"
   // f1 -> PrimaryExpression()
   public R visit(PreIncrementExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "--"
   // f1 -> PrimaryExpression()
   public R visit(PreDecrementExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> ( "~" | "!" ) UnaryExpression()
   //       | CastExpression()
   //       | PostfixExpression()
   public R visit(UnaryExpressionNotPlusMinus n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "(" PrimitiveType()
   //       | "(" Type() "[" "]"
   //       | "(" Type() ")" ( "~" | "!" | "(" | <IDENTIFIER> | "this" | "super" | "new" | Literal() )
   public R visit(CastLookahead n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> PrimaryExpression()
   // f1 -> [ "++" | "--" ]
   public R visit(PostfixExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "(" Type() ")" UnaryExpression()
   //       | "(" Type() ")" UnaryExpressionNotPlusMinus()
   public R visit(CastExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> PrimaryPrefix()
   // f1 -> ( PrimarySuffix() )*
   public R visit(PrimaryExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "."
   // f1 -> TypeArguments()
   // f2 -> <IDENTIFIER>
   public R visit(MemberSelector n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Literal()
   //       | ( <IDENTIFIER> "." )* "this"
   //       | "super" "." <IDENTIFIER>
   //       | ClassOrInterfaceType() "." "super" "." <IDENTIFIER>
   //       | "(" Expression() ")"
   //       | AllocationExpression()
   //       | ResultType() "." "class"
   //       | Name()
   public R visit(PrimaryPrefix n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "." "super"
   //       | "." "this"
   //       | "." AllocationExpression()
   //       | MemberSelector()
   //       | "[" Expression() "]"
   //       | "." <IDENTIFIER>
   //       | Arguments()
   public R visit(PrimarySuffix n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> <INTEGER_LITERAL>
   //       | <FLOATING_POINT_LITERAL>
   //       | <CHARACTER_LITERAL>
   //       | <STRING_LITERAL>
   //       | BooleanLiteral()
   //       | NullLiteral()
   public R visit(Literal n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "true"
   //       | "false"
   public R visit(BooleanLiteral n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "null"
   public R visit(NullLiteral n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "("
   // f1 -> [ ArgumentList() ]
   // f2 -> ")"
   public R visit(Arguments n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Expression()
   // f1 -> ( "," Expression() )*
   public R visit(ArgumentList n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "new" PrimitiveType() ArrayDimsAndInits()
   //       | "new" ClassOrInterfaceType() [ TypeArguments() ] ( ArrayDimsAndInits() | Arguments() [ ClassOrInterfaceBody(false) ] )
   public R visit(AllocationExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> ( "[" Expression() "]" )+ ( "[" "]" )*
   //       | ( "[" "]" )+ ArrayInitializer()
   public R visit(ArrayDimsAndInits n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> LabeledStatement()
   //       | AssertStatement()
   //       | Block()
   //       | EmptyStatement()
   //       | StatementExpression() ";"
   //       | SwitchStatement()
   //       | IfStatement()
   //       | WhileStatement()
   //       | DoStatement()
   //       | ForStatement()
   //       | BreakStatement()
   //       | ContinueStatement()
   //       | ReturnStatement()
   //       | ThrowStatement()
   //       | SynchronizedStatement()
   //       | TryStatement()
   public R visit(Statement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "assert"
   // f1 -> Expression()
   // f2 -> [ ":" Expression() ]
   // f3 -> ";"
   public R visit(AssertStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> ":"
   // f2 -> Statement()
   public R visit(LabeledStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> ( BlockStatement() )*
   // f2 -> "}"
   public R visit(Block n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> LocalVariableDeclaration() ";"
   //       | Statement()
   //       | ClassOrInterfaceDeclaration(0)
   public R visit(BlockStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> Modifiers()
   // f1 -> Type()
   // f2 -> VariableDeclarator()
   // f3 -> ( "," VariableDeclarator() )*
   public R visit(LocalVariableDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> ";"
   public R visit(EmptyStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> PreIncrementExpression()
   //       | PreDecrementExpression()
   //       | PrimaryExpression() [ "++" | "--" | AssignmentOperator() Expression() ]
   public R visit(StatementExpression n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "switch"
   // f1 -> "("
   // f2 -> Expression()
   // f3 -> ")"
   // f4 -> "{"
   // f5 -> ( SwitchLabel() ( BlockStatement() )* )*
   // f6 -> "}"
   public R visit(SwitchStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      n.f6.accept(this, argu);
      return _ret;
   }

   // f0 -> "case" Expression() ":"
   //       | "default" ":"
   public R visit(SwitchLabel n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "if"
   // f1 -> "("
   // f2 -> Expression()
   // f3 -> ")"
   // f4 -> Statement()
   // f5 -> [ "else" Statement() ]
   public R visit(IfStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      return _ret;
   }

   // f0 -> "while"
   // f1 -> "("
   // f2 -> Expression()
   // f3 -> ")"
   // f4 -> Statement()
   public R visit(WhileStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> "do"
   // f1 -> Statement()
   // f2 -> "while"
   // f3 -> "("
   // f4 -> Expression()
   // f5 -> ")"
   // f6 -> ";"
   public R visit(DoStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      n.f5.accept(this, argu);
      n.f6.accept(this, argu);
      return _ret;
   }

   // f0 -> "for"
   // f1 -> "("
   // f2 -> ( Modifiers() Type() <IDENTIFIER> ":" Expression() | [ ForInit() ] ";" [ Expression() ] ";" [ ForUpdate() ] )
   // f3 -> ")"
   // f4 -> Statement()
   public R visit(ForStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> LocalVariableDeclaration()
   //       | StatementExpressionList()
   public R visit(ForInit n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> StatementExpression()
   // f1 -> ( "," StatementExpression() )*
   public R visit(StatementExpressionList n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> StatementExpressionList()
   public R visit(ForUpdate n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "break"
   // f1 -> [ <IDENTIFIER> ]
   // f2 -> ";"
   public R visit(BreakStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "continue"
   // f1 -> [ <IDENTIFIER> ]
   // f2 -> ";"
   public R visit(ContinueStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "return"
   // f1 -> [ Expression() ]
   // f2 -> ";"
   public R visit(ReturnStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "throw"
   // f1 -> Expression()
   // f2 -> ";"
   public R visit(ThrowStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "synchronized"
   // f1 -> "("
   // f2 -> Expression()
   // f3 -> ")"
   // f4 -> Block()
   public R visit(SynchronizedStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> "try"
   // f1 -> Block()
   // f2 -> ( "catch" "(" FormalParameter() ")" Block() )*
   // f3 -> [ "finally" Block() ]
   public R visit(TryStatement n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> ( ">" ">" ">" )
   public R visit(RUNSIGNEDSHIFT n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> ( ">" ">" )
   public R visit(RSIGNEDSHIFT n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> NormalAnnotation()
   //       | SingleMemberAnnotation()
   //       | MarkerAnnotation()
   public R visit(Annotation n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "@"
   // f1 -> Name()
   // f2 -> "("
   // f3 -> [ MemberValuePairs() ]
   // f4 -> ")"
   public R visit(NormalAnnotation n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> "@"
   // f1 -> Name()
   public R visit(MarkerAnnotation n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> "@"
   // f1 -> Name()
   // f2 -> "("
   // f3 -> MemberValue()
   // f4 -> ")"
   public R visit(SingleMemberAnnotation n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      n.f4.accept(this, argu);
      return _ret;
   }

   // f0 -> MemberValuePair()
   // f1 -> ( "," MemberValuePair() )*
   public R visit(MemberValuePairs n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

   // f0 -> <IDENTIFIER>
   // f1 -> "="
   // f2 -> MemberValue()
   public R visit(MemberValuePair n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Annotation()
   //       | MemberValueArrayInitializer()
   //       | ConditionalExpression()
   public R visit(MemberValue n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> ( MemberValue() ( "," MemberValue() )* [ "," ] )?
   // f2 -> "}"
   public R visit(MemberValueArrayInitializer n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> "@"
   // f1 -> "interface"
   // f2 -> <IDENTIFIER>
   // f3 -> AnnotationTypeBody()
   public R visit(AnnotationTypeDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      n.f3.accept(this, argu);
      return _ret;
   }

   // f0 -> "{"
   // f1 -> ( AnnotationTypeMemberDeclaration() )*
   // f2 -> "}"
   public R visit(AnnotationTypeBody n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      n.f2.accept(this, argu);
      return _ret;
   }

   // f0 -> Modifiers() ( Type() <IDENTIFIER> "(" ")" [ DefaultValue() ] ";" | ClassOrInterfaceDeclaration(modifiers) | EnumDeclaration(modifiers) | AnnotationTypeDeclaration(modifiers) | FieldDeclaration(modifiers) )
   //       | ( ";" )
   public R visit(AnnotationTypeMemberDeclaration n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      return _ret;
   }

   // f0 -> "default"
   // f1 -> MemberValue()
   public R visit(DefaultValue n, A argu) {
      R _ret=null;
      n.f0.accept(this, argu);
      n.f1.accept(this, argu);
      return _ret;
   }

}
