content: /* This file was generated by SableCC (http://www.sablecc.org/). */
  
  package com.abstratt.mdd.frontend.textuml.grammar.analysis;
  
  import java.util.*;
  import com.abstratt.mdd.frontend.textuml.grammar.node.*;
  
  public class ReversedDepthFirstAdapter extends AnalysisAdapter
  {
      public void inStart(Start node)
      {
          defaultIn(node);
      }
  
      public void outStart(Start node)
      {
          defaultOut(node);
      }
  
      public void defaultIn(@SuppressWarnings("unused") Node node)
      {
          // Do nothing
      }
  
      public void defaultOut(@SuppressWarnings("unused") Node node)
      {
          // Do nothing
      }
  
      @Override
      public void caseStart(Start node)
      {
          inStart(node);
          node.getEOF().apply(this);
          node.getPStart().apply(this);
          outStart(node);
      }
  
      public void inAStart(AStart node)
      {
          defaultIn(node);
      }
  
      public void outAStart(AStart node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStart(AStart node)
      {
          inAStart(node);
          if(node.getDot() != null)
          {
              node.getDot().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getNamespaceContents() != null)
          {
              node.getNamespaceContents().apply(this);
          }
          if(node.getGlobalDirectiveSection() != null)
          {
              node.getGlobalDirectiveSection().apply(this);
          }
          if(node.getPackageHeading() != null)
          {
              node.getPackageHeading().apply(this);
          }
          outAStart(node);
      }
  
      public void inAPackageHeading(APackageHeading node)
      {
          defaultIn(node);
      }
  
      public void outAPackageHeading(APackageHeading node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPackageHeading(APackageHeading node)
      {
          inAPackageHeading(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          if(node.getPackageType() != null)
          {
              node.getPackageType().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAPackageHeading(node);
      }
  
      public void inAModelPackageType(AModelPackageType node)
      {
          defaultIn(node);
      }
  
      public void outAModelPackageType(AModelPackageType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAModelPackageType(AModelPackageType node)
      {
          inAModelPackageType(node);
          if(node.getModel() != null)
          {
              node.getModel().apply(this);
          }
          outAModelPackageType(node);
      }
  
      public void inAProfilePackageType(AProfilePackageType node)
      {
          defaultIn(node);
      }
  
      public void outAProfilePackageType(AProfilePackageType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAProfilePackageType(AProfilePackageType node)
      {
          inAProfilePackageType(node);
          if(node.getProfile() != null)
          {
              node.getProfile().apply(this);
          }
          outAProfilePackageType(node);
      }
  
      public void inAPackagePackageType(APackagePackageType node)
      {
          defaultIn(node);
      }
  
      public void outAPackagePackageType(APackagePackageType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPackagePackageType(APackagePackageType node)
      {
          inAPackagePackageType(node);
          if(node.getPackage() != null)
          {
              node.getPackage().apply(this);
          }
          outAPackagePackageType(node);
      }
  
      public void inAQualifiedIdentifierList(AQualifiedIdentifierList node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedIdentifierList(AQualifiedIdentifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedIdentifierList(AQualifiedIdentifierList node)
      {
          inAQualifiedIdentifierList(node);
          {
              List<PQualifiedIdentifierListTail> copy = new ArrayList<PQualifiedIdentifierListTail>(node.getQualifiedIdentifierListTail());
              Collections.reverse(copy);
              for(PQualifiedIdentifierListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          outAQualifiedIdentifierList(node);
      }
  
      public void inAQualifiedIdentifierListTail(AQualifiedIdentifierListTail node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedIdentifierListTail(AQualifiedIdentifierListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedIdentifierListTail(AQualifiedIdentifierListTail node)
      {
          inAQualifiedIdentifierListTail(node);
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAQualifiedIdentifierListTail(node);
      }
  
      public void inAQualifiedIdentifier(AQualifiedIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedIdentifier(AQualifiedIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedIdentifier(AQualifiedIdentifier node)
      {
          inAQualifiedIdentifier(node);
          if(node.getQualifiedIdentifierBase() != null)
          {
              node.getQualifiedIdentifierBase().apply(this);
          }
          outAQualifiedIdentifier(node);
      }
  
      public void inAForcefullyQualifiedIdentifier(AForcefullyQualifiedIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAForcefullyQualifiedIdentifier(AForcefullyQualifiedIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAForcefullyQualifiedIdentifier(AForcefullyQualifiedIdentifier node)
      {
          inAForcefullyQualifiedIdentifier(node);
          if(node.getQualifiedIdentifierTail() != null)
          {
              node.getQualifiedIdentifierTail().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAForcefullyQualifiedIdentifier(node);
      }
  
      public void inAQualifiedIdentifierBase(AQualifiedIdentifierBase node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedIdentifierBase(AQualifiedIdentifierBase node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedIdentifierBase(AQualifiedIdentifierBase node)
      {
          inAQualifiedIdentifierBase(node);
          if(node.getQualifiedIdentifierTail() != null)
          {
              node.getQualifiedIdentifierTail().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAQualifiedIdentifierBase(node);
      }
  
      public void inAQualifiedIdentifierTail(AQualifiedIdentifierTail node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedIdentifierTail(AQualifiedIdentifierTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedIdentifierTail(AQualifiedIdentifierTail node)
      {
          inAQualifiedIdentifierTail(node);
          if(node.getQualifiedIdentifierBase() != null)
          {
              node.getQualifiedIdentifierBase().apply(this);
          }
          if(node.getNamespaceSeparator() != null)
          {
              node.getNamespaceSeparator().apply(this);
          }
          outAQualifiedIdentifierTail(node);
      }
  
      public void inAGlobalDirectiveSection(AGlobalDirectiveSection node)
      {
          defaultIn(node);
      }
  
      public void outAGlobalDirectiveSection(AGlobalDirectiveSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAGlobalDirectiveSection(AGlobalDirectiveSection node)
      {
          inAGlobalDirectiveSection(node);
          {
              List<PGlobalDirective> copy = new ArrayList<PGlobalDirective>(node.getGlobalDirective());
              Collections.reverse(copy);
              for(PGlobalDirective e : copy)
              {
                  e.apply(this);
              }
          }
          outAGlobalDirectiveSection(node);
      }
  
      public void inALoadGlobalDirective(ALoadGlobalDirective node)
      {
          defaultIn(node);
      }
  
      public void outALoadGlobalDirective(ALoadGlobalDirective node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALoadGlobalDirective(ALoadGlobalDirective node)
      {
          inALoadGlobalDirective(node);
          if(node.getLoadDecl() != null)
          {
              node.getLoadDecl().apply(this);
          }
          outALoadGlobalDirective(node);
      }
  
      public void inAApplyGlobalDirective(AApplyGlobalDirective node)
      {
          defaultIn(node);
      }
  
      public void outAApplyGlobalDirective(AApplyGlobalDirective node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAApplyGlobalDirective(AApplyGlobalDirective node)
      {
          inAApplyGlobalDirective(node);
          if(node.getApplyProfileDecl() != null)
          {
              node.getApplyProfileDecl().apply(this);
          }
          outAApplyGlobalDirective(node);
      }
  
      public void inAImportGlobalDirective(AImportGlobalDirective node)
      {
          defaultIn(node);
      }
  
      public void outAImportGlobalDirective(AImportGlobalDirective node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAImportGlobalDirective(AImportGlobalDirective node)
      {
          inAImportGlobalDirective(node);
          if(node.getImportDecl() != null)
          {
              node.getImportDecl().apply(this);
          }
          outAImportGlobalDirective(node);
      }
  
      public void inALoadDecl(ALoadDecl node)
      {
          defaultIn(node);
      }
  
      public void outALoadDecl(ALoadDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALoadDecl(ALoadDecl node)
      {
          inALoadDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getUri() != null)
          {
              node.getUri().apply(this);
          }
          if(node.getLoad() != null)
          {
              node.getLoad().apply(this);
          }
          outALoadDecl(node);
      }
  
      public void inAApplyProfileDecl(AApplyProfileDecl node)
      {
          defaultIn(node);
      }
  
      public void outAApplyProfileDecl(AApplyProfileDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAApplyProfileDecl(AApplyProfileDecl node)
      {
          inAApplyProfileDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          if(node.getApply() != null)
          {
              node.getApply().apply(this);
          }
          outAApplyProfileDecl(node);
      }
  
      public void inAImportDecl(AImportDecl node)
      {
          defaultIn(node);
      }
  
      public void outAImportDecl(AImportDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAImportDecl(AImportDecl node)
      {
          inAImportDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getOptionalAlias() != null)
          {
              node.getOptionalAlias().apply(this);
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          if(node.getImport() != null)
          {
              node.getImport().apply(this);
          }
          if(node.getOptionalImportModifier() != null)
          {
              node.getOptionalImportModifier().apply(this);
          }
          outAImportDecl(node);
      }
  
      public void inAOptionalAlias(AOptionalAlias node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalAlias(AOptionalAlias node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalAlias(AOptionalAlias node)
      {
          inAOptionalAlias(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getAlias() != null)
          {
              node.getAlias().apply(this);
          }
          outAOptionalAlias(node);
      }
  
      public void inAEmptyOptionalAlias(AEmptyOptionalAlias node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyOptionalAlias(AEmptyOptionalAlias node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyOptionalAlias(AEmptyOptionalAlias node)
      {
          inAEmptyOptionalAlias(node);
          outAEmptyOptionalAlias(node);
      }
  
      public void inANamespaceContents(ANamespaceContents node)
      {
          defaultIn(node);
      }
  
      public void outANamespaceContents(ANamespaceContents node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamespaceContents(ANamespaceContents node)
      {
          inANamespaceContents(node);
          {
              List<PTopLevelElement> copy = new ArrayList<PTopLevelElement>(node.getTopLevelElement());
              Collections.reverse(copy);
              for(PTopLevelElement e : copy)
              {
                  e.apply(this);
              }
          }
          outANamespaceContents(node);
      }
  
      public void inASubNamespace(ASubNamespace node)
      {
          defaultIn(node);
      }
  
      public void outASubNamespace(ASubNamespace node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASubNamespace(ASubNamespace node)
      {
          inASubNamespace(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getNamespaceContents() != null)
          {
              node.getNamespaceContents().apply(this);
          }
          if(node.getGlobalDirectiveSection() != null)
          {
              node.getGlobalDirectiveSection().apply(this);
          }
          if(node.getPackageHeading() != null)
          {
              node.getPackageHeading().apply(this);
          }
          outASubNamespace(node);
      }
  
      public void inATopLevelElement(ATopLevelElement node)
      {
          defaultIn(node);
      }
  
      public void outATopLevelElement(ATopLevelElement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATopLevelElement(ATopLevelElement node)
      {
          inATopLevelElement(node);
          if(node.getTopLevelElementChoice() != null)
          {
              node.getTopLevelElementChoice().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outATopLevelElement(node);
      }
  
      public void inAClassTopLevelElementChoice(AClassTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAClassTopLevelElementChoice(AClassTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassTopLevelElementChoice(AClassTopLevelElementChoice node)
      {
          inAClassTopLevelElementChoice(node);
          if(node.getClassDef() != null)
          {
              node.getClassDef().apply(this);
          }
          outAClassTopLevelElementChoice(node);
      }
  
      public void inAAssociationTopLevelElementChoice(AAssociationTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationTopLevelElementChoice(AAssociationTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationTopLevelElementChoice(AAssociationTopLevelElementChoice node)
      {
          inAAssociationTopLevelElementChoice(node);
          if(node.getAssociationDef() != null)
          {
              node.getAssociationDef().apply(this);
          }
          outAAssociationTopLevelElementChoice(node);
      }
  
      public void inAStereotypeTopLevelElementChoice(AStereotypeTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeTopLevelElementChoice(AStereotypeTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeTopLevelElementChoice(AStereotypeTopLevelElementChoice node)
      {
          inAStereotypeTopLevelElementChoice(node);
          if(node.getStereotypeDef() != null)
          {
              node.getStereotypeDef().apply(this);
          }
          outAStereotypeTopLevelElementChoice(node);
      }
  
      public void inAOperationTopLevelElementChoice(AOperationTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAOperationTopLevelElementChoice(AOperationTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationTopLevelElementChoice(AOperationTopLevelElementChoice node)
      {
          inAOperationTopLevelElementChoice(node);
          if(node.getDetachedOperationDef() != null)
          {
              node.getDetachedOperationDef().apply(this);
          }
          outAOperationTopLevelElementChoice(node);
      }
  
      public void inAFunctionTopLevelElementChoice(AFunctionTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAFunctionTopLevelElementChoice(AFunctionTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFunctionTopLevelElementChoice(AFunctionTopLevelElementChoice node)
      {
          inAFunctionTopLevelElementChoice(node);
          if(node.getFunctionDecl() != null)
          {
              node.getFunctionDecl().apply(this);
          }
          outAFunctionTopLevelElementChoice(node);
      }
  
      public void inAPrimitiveTopLevelElementChoice(APrimitiveTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outAPrimitiveTopLevelElementChoice(APrimitiveTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPrimitiveTopLevelElementChoice(APrimitiveTopLevelElementChoice node)
      {
          inAPrimitiveTopLevelElementChoice(node);
          if(node.getPrimitiveDef() != null)
          {
              node.getPrimitiveDef().apply(this);
          }
          outAPrimitiveTopLevelElementChoice(node);
      }
  
      public void inASubnamespaceTopLevelElementChoice(ASubnamespaceTopLevelElementChoice node)
      {
          defaultIn(node);
      }
  
      public void outASubnamespaceTopLevelElementChoice(ASubnamespaceTopLevelElementChoice node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASubnamespaceTopLevelElementChoice(ASubnamespaceTopLevelElementChoice node)
      {
          inASubnamespaceTopLevelElementChoice(node);
          if(node.getSubNamespace() != null)
          {
              node.getSubNamespace().apply(this);
          }
          outASubnamespaceTopLevelElementChoice(node);
      }
  
      public void inAMinimalTypeIdentifier(AMinimalTypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAMinimalTypeIdentifier(AMinimalTypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMinimalTypeIdentifier(AMinimalTypeIdentifier node)
      {
          inAMinimalTypeIdentifier(node);
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          outAMinimalTypeIdentifier(node);
      }
  
      public void inAQualifiedSingleTypeIdentifier(AQualifiedSingleTypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedSingleTypeIdentifier(AQualifiedSingleTypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedSingleTypeIdentifier(AQualifiedSingleTypeIdentifier node)
      {
          inAQualifiedSingleTypeIdentifier(node);
          if(node.getTemplateBinding() != null)
          {
              node.getTemplateBinding().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAQualifiedSingleTypeIdentifier(node);
      }
  
      public void inAAnySingleTypeIdentifier(AAnySingleTypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAAnySingleTypeIdentifier(AAnySingleTypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnySingleTypeIdentifier(AAnySingleTypeIdentifier node)
      {
          inAAnySingleTypeIdentifier(node);
          if(node.getAny() != null)
          {
              node.getAny().apply(this);
          }
          outAAnySingleTypeIdentifier(node);
      }
  
      public void inATupleTypeSingleTypeIdentifier(ATupleTypeSingleTypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outATupleTypeSingleTypeIdentifier(ATupleTypeSingleTypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleTypeSingleTypeIdentifier(ATupleTypeSingleTypeIdentifier node)
      {
          inATupleTypeSingleTypeIdentifier(node);
          if(node.getTupleType() != null)
          {
              node.getTupleType().apply(this);
          }
          outATupleTypeSingleTypeIdentifier(node);
      }
  
      public void inAMinimalTypeIdentifierList(AMinimalTypeIdentifierList node)
      {
          defaultIn(node);
      }
  
      public void outAMinimalTypeIdentifierList(AMinimalTypeIdentifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMinimalTypeIdentifierList(AMinimalTypeIdentifierList node)
      {
          inAMinimalTypeIdentifierList(node);
          {
              List<PMinimalTypeIdentifierListTail> copy = new ArrayList<PMinimalTypeIdentifierListTail>(node.getMinimalTypeIdentifierListTail());
              Collections.reverse(copy);
              for(PMinimalTypeIdentifierListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAMinimalTypeIdentifierList(node);
      }
  
      public void inAMinimalTypeIdentifierListTail(AMinimalTypeIdentifierListTail node)
      {
          defaultIn(node);
      }
  
      public void outAMinimalTypeIdentifierListTail(AMinimalTypeIdentifierListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMinimalTypeIdentifierListTail(AMinimalTypeIdentifierListTail node)
      {
          inAMinimalTypeIdentifierListTail(node);
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAMinimalTypeIdentifierListTail(node);
      }
  
      public void inATypeIdentifier(ATypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outATypeIdentifier(ATypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATypeIdentifier(ATypeIdentifier node)
      {
          inATypeIdentifier(node);
          if(node.getOptionalMultiplicity() != null)
          {
              node.getOptionalMultiplicity().apply(this);
          }
          if(node.getSingleTypeIdentifier() != null)
          {
              node.getSingleTypeIdentifier().apply(this);
          }
          outATypeIdentifier(node);
      }
  
      public void inAFunctionTypeIdentifier(AFunctionTypeIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAFunctionTypeIdentifier(AFunctionTypeIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFunctionTypeIdentifier(AFunctionTypeIdentifier node)
      {
          inAFunctionTypeIdentifier(node);
          if(node.getOptionalMultiplicity() != null)
          {
              node.getOptionalMultiplicity().apply(this);
          }
          if(node.getFunctionSignature() != null)
          {
              node.getFunctionSignature().apply(this);
          }
          outAFunctionTypeIdentifier(node);
      }
  
      public void inAOptionalMultiplicity(AOptionalMultiplicity node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalMultiplicity(AOptionalMultiplicity node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalMultiplicity(AOptionalMultiplicity node)
      {
          inAOptionalMultiplicity(node);
          if(node.getMultiplicityConstraints() != null)
          {
              node.getMultiplicityConstraints().apply(this);
          }
          if(node.getRBracket() != null)
          {
              node.getRBracket().apply(this);
          }
          if(node.getMultiplicitySpec() != null)
          {
              node.getMultiplicitySpec().apply(this);
          }
          if(node.getLBracket() != null)
          {
              node.getLBracket().apply(this);
          }
          outAOptionalMultiplicity(node);
      }
  
      public void inASingleMultiplicitySpec(ASingleMultiplicitySpec node)
      {
          defaultIn(node);
      }
  
      public void outASingleMultiplicitySpec(ASingleMultiplicitySpec node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASingleMultiplicitySpec(ASingleMultiplicitySpec node)
      {
          inASingleMultiplicitySpec(node);
          if(node.getMultiplicityValue() != null)
          {
              node.getMultiplicityValue().apply(this);
          }
          outASingleMultiplicitySpec(node);
      }
  
      public void inAIntervalMultiplicitySpec(AIntervalMultiplicitySpec node)
      {
          defaultIn(node);
      }
  
      public void outAIntervalMultiplicitySpec(AIntervalMultiplicitySpec node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIntervalMultiplicitySpec(AIntervalMultiplicitySpec node)
      {
          inAIntervalMultiplicitySpec(node);
          if(node.getUpper() != null)
          {
              node.getUpper().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          if(node.getLower() != null)
          {
              node.getLower().apply(this);
          }
          outAIntervalMultiplicitySpec(node);
      }
  
      public void inAMultiplicityConstraints(AMultiplicityConstraints node)
      {
          defaultIn(node);
      }
  
      public void outAMultiplicityConstraints(AMultiplicityConstraints node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMultiplicityConstraints(AMultiplicityConstraints node)
      {
          inAMultiplicityConstraints(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          if(node.getMultiplicityConstraintList() != null)
          {
              node.getMultiplicityConstraintList().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outAMultiplicityConstraints(node);
      }
  
      public void inAMultiplicityConstraintList(AMultiplicityConstraintList node)
      {
          defaultIn(node);
      }
  
      public void outAMultiplicityConstraintList(AMultiplicityConstraintList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMultiplicityConstraintList(AMultiplicityConstraintList node)
      {
          inAMultiplicityConstraintList(node);
          {
              List<PMultiplicityConstraintTail> copy = new ArrayList<PMultiplicityConstraintTail>(node.getMultiplicityConstraintTail());
              Collections.reverse(copy);
              for(PMultiplicityConstraintTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getMultiplicityConstraint() != null)
          {
              node.getMultiplicityConstraint().apply(this);
          }
          outAMultiplicityConstraintList(node);
      }
  
      public void inAMultiplicityConstraintTail(AMultiplicityConstraintTail node)
      {
          defaultIn(node);
      }
  
      public void outAMultiplicityConstraintTail(AMultiplicityConstraintTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMultiplicityConstraintTail(AMultiplicityConstraintTail node)
      {
          inAMultiplicityConstraintTail(node);
          if(node.getMultiplicityConstraint() != null)
          {
              node.getMultiplicityConstraint().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAMultiplicityConstraintTail(node);
      }
  
      public void inAOrderedMultiplicityConstraint(AOrderedMultiplicityConstraint node)
      {
          defaultIn(node);
      }
  
      public void outAOrderedMultiplicityConstraint(AOrderedMultiplicityConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOrderedMultiplicityConstraint(AOrderedMultiplicityConstraint node)
      {
          inAOrderedMultiplicityConstraint(node);
          if(node.getOrdered() != null)
          {
              node.getOrdered().apply(this);
          }
          outAOrderedMultiplicityConstraint(node);
      }
  
      public void inAUnorderedMultiplicityConstraint(AUnorderedMultiplicityConstraint node)
      {
          defaultIn(node);
      }
  
      public void outAUnorderedMultiplicityConstraint(AUnorderedMultiplicityConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAUnorderedMultiplicityConstraint(AUnorderedMultiplicityConstraint node)
      {
          inAUnorderedMultiplicityConstraint(node);
          if(node.getUnordered() != null)
          {
              node.getUnordered().apply(this);
          }
          outAUnorderedMultiplicityConstraint(node);
      }
  
      public void inAUniqueMultiplicityConstraint(AUniqueMultiplicityConstraint node)
      {
          defaultIn(node);
      }
  
      public void outAUniqueMultiplicityConstraint(AUniqueMultiplicityConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAUniqueMultiplicityConstraint(AUniqueMultiplicityConstraint node)
      {
          inAUniqueMultiplicityConstraint(node);
          if(node.getUnique() != null)
          {
              node.getUnique().apply(this);
          }
          outAUniqueMultiplicityConstraint(node);
      }
  
      public void inANonuniqueMultiplicityConstraint(ANonuniqueMultiplicityConstraint node)
      {
          defaultIn(node);
      }
  
      public void outANonuniqueMultiplicityConstraint(ANonuniqueMultiplicityConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANonuniqueMultiplicityConstraint(ANonuniqueMultiplicityConstraint node)
      {
          inANonuniqueMultiplicityConstraint(node);
          if(node.getNonunique() != null)
          {
              node.getNonunique().apply(this);
          }
          outANonuniqueMultiplicityConstraint(node);
      }
  
      public void inAOptionalFormalTemplateParameters(AOptionalFormalTemplateParameters node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalFormalTemplateParameters(AOptionalFormalTemplateParameters node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalFormalTemplateParameters(AOptionalFormalTemplateParameters node)
      {
          inAOptionalFormalTemplateParameters(node);
          if(node.getRab() != null)
          {
              node.getRab().apply(this);
          }
          if(node.getFormalTemplateParameterList() != null)
          {
              node.getFormalTemplateParameterList().apply(this);
          }
          if(node.getLab() != null)
          {
              node.getLab().apply(this);
          }
          outAOptionalFormalTemplateParameters(node);
      }
  
      public void inAFormalTemplateParameterList(AFormalTemplateParameterList node)
      {
          defaultIn(node);
      }
  
      public void outAFormalTemplateParameterList(AFormalTemplateParameterList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFormalTemplateParameterList(AFormalTemplateParameterList node)
      {
          inAFormalTemplateParameterList(node);
          {
              List<PFormalTemplateParameterTail> copy = new ArrayList<PFormalTemplateParameterTail>(node.getFormalTemplateParameterTail());
              Collections.reverse(copy);
              for(PFormalTemplateParameterTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getFormalTemplateParameter() != null)
          {
              node.getFormalTemplateParameter().apply(this);
          }
          outAFormalTemplateParameterList(node);
      }
  
      public void inAFormalTemplateParameterTail(AFormalTemplateParameterTail node)
      {
          defaultIn(node);
      }
  
      public void outAFormalTemplateParameterTail(AFormalTemplateParameterTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFormalTemplateParameterTail(AFormalTemplateParameterTail node)
      {
          inAFormalTemplateParameterTail(node);
          if(node.getFormalTemplateParameter() != null)
          {
              node.getFormalTemplateParameter().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAFormalTemplateParameterTail(node);
      }
  
      public void inAFormalTemplateParameter(AFormalTemplateParameter node)
      {
          defaultIn(node);
      }
  
      public void outAFormalTemplateParameter(AFormalTemplateParameter node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFormalTemplateParameter(AFormalTemplateParameter node)
      {
          inAFormalTemplateParameter(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAFormalTemplateParameter(node);
      }
  
      public void inATemplateBinding(ATemplateBinding node)
      {
          defaultIn(node);
      }
  
      public void outATemplateBinding(ATemplateBinding node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATemplateBinding(ATemplateBinding node)
      {
          inATemplateBinding(node);
          if(node.getRab() != null)
          {
              node.getRab().apply(this);
          }
          if(node.getTemplateParameterList() != null)
          {
              node.getTemplateParameterList().apply(this);
          }
          if(node.getLab() != null)
          {
              node.getLab().apply(this);
          }
          outATemplateBinding(node);
      }
  
      public void inATemplateParameterList(ATemplateParameterList node)
      {
          defaultIn(node);
      }
  
      public void outATemplateParameterList(ATemplateParameterList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATemplateParameterList(ATemplateParameterList node)
      {
          inATemplateParameterList(node);
          {
              List<PTemplateParameterTail> copy = new ArrayList<PTemplateParameterTail>(node.getTemplateParameterTail());
              Collections.reverse(copy);
              for(PTemplateParameterTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getTemplateParameter() != null)
          {
              node.getTemplateParameter().apply(this);
          }
          outATemplateParameterList(node);
      }
  
      public void inATemplateParameterTail(ATemplateParameterTail node)
      {
          defaultIn(node);
      }
  
      public void outATemplateParameterTail(ATemplateParameterTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATemplateParameterTail(ATemplateParameterTail node)
      {
          inATemplateParameterTail(node);
          if(node.getTemplateParameter() != null)
          {
              node.getTemplateParameter().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outATemplateParameterTail(node);
      }
  
      public void inATemplateParameter(ATemplateParameter node)
      {
          defaultIn(node);
      }
  
      public void outATemplateParameter(ATemplateParameter node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATemplateParameter(ATemplateParameter node)
      {
          inATemplateParameter(node);
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          outATemplateParameter(node);
      }
  
      public void inAAssociationDef(AAssociationDef node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationDef(AAssociationDef node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationDef(AAssociationDef node)
      {
          inAAssociationDef(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getAssociationRoleDeclList() != null)
          {
              node.getAssociationRoleDeclList().apply(this);
          }
          if(node.getAssociationHeader() != null)
          {
              node.getAssociationHeader().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAAssociationDef(node);
      }
  
      public void inAAssociationHeader(AAssociationHeader node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationHeader(AAssociationHeader node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationHeader(AAssociationHeader node)
      {
          inAAssociationHeader(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getAssociationKind() != null)
          {
              node.getAssociationKind().apply(this);
          }
          outAAssociationHeader(node);
      }
  
      public void inAAssociationAssociationKind(AAssociationAssociationKind node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationAssociationKind(AAssociationAssociationKind node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationAssociationKind(AAssociationAssociationKind node)
      {
          inAAssociationAssociationKind(node);
          if(node.getAssociation() != null)
          {
              node.getAssociation().apply(this);
          }
          outAAssociationAssociationKind(node);
      }
  
      public void inAAggregationAssociationKind(AAggregationAssociationKind node)
      {
          defaultIn(node);
      }
  
      public void outAAggregationAssociationKind(AAggregationAssociationKind node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAggregationAssociationKind(AAggregationAssociationKind node)
      {
          inAAggregationAssociationKind(node);
          if(node.getAggregation() != null)
          {
              node.getAggregation().apply(this);
          }
          outAAggregationAssociationKind(node);
      }
  
      public void inACompositionAssociationKind(ACompositionAssociationKind node)
      {
          defaultIn(node);
      }
  
      public void outACompositionAssociationKind(ACompositionAssociationKind node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACompositionAssociationKind(ACompositionAssociationKind node)
      {
          inACompositionAssociationKind(node);
          if(node.getComposition() != null)
          {
              node.getComposition().apply(this);
          }
          outACompositionAssociationKind(node);
      }
  
      public void inAAssociationRoleDeclList(AAssociationRoleDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationRoleDeclList(AAssociationRoleDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationRoleDeclList(AAssociationRoleDeclList node)
      {
          inAAssociationRoleDeclList(node);
          if(node.getAssociationRoleDeclList() != null)
          {
              node.getAssociationRoleDeclList().apply(this);
          }
          if(node.getAssociationRoleDecl() != null)
          {
              node.getAssociationRoleDecl().apply(this);
          }
          outAAssociationRoleDeclList(node);
      }
  
      public void inAEmptyAssociationRoleDeclList(AEmptyAssociationRoleDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyAssociationRoleDeclList(AEmptyAssociationRoleDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyAssociationRoleDeclList(AEmptyAssociationRoleDeclList node)
      {
          inAEmptyAssociationRoleDeclList(node);
          outAEmptyAssociationRoleDeclList(node);
      }
  
      public void inAAssociationRoleDecl(AAssociationRoleDecl node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationRoleDecl(AAssociationRoleDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationRoleDecl(AAssociationRoleDecl node)
      {
          inAAssociationRoleDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getAssociationEnd() != null)
          {
              node.getAssociationEnd().apply(this);
          }
          if(node.getAssociationModifiers() != null)
          {
              node.getAssociationModifiers().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAAssociationRoleDecl(node);
      }
  
      public void inAOwnedAssociationEnd(AOwnedAssociationEnd node)
      {
          defaultIn(node);
      }
  
      public void outAOwnedAssociationEnd(AOwnedAssociationEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOwnedAssociationEnd(AOwnedAssociationEnd node)
      {
          inAOwnedAssociationEnd(node);
          if(node.getAssociationOwnedEnd() != null)
          {
              node.getAssociationOwnedEnd().apply(this);
          }
          outAOwnedAssociationEnd(node);
      }
  
      public void inAMemberAssociationEnd(AMemberAssociationEnd node)
      {
          defaultIn(node);
      }
  
      public void outAMemberAssociationEnd(AMemberAssociationEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMemberAssociationEnd(AMemberAssociationEnd node)
      {
          inAMemberAssociationEnd(node);
          if(node.getAssociationMemberEnd() != null)
          {
              node.getAssociationMemberEnd().apply(this);
          }
          outAMemberAssociationEnd(node);
      }
  
      public void inAAssociationOwnedEnd(AAssociationOwnedEnd node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationOwnedEnd(AAssociationOwnedEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationOwnedEnd(AAssociationOwnedEnd node)
      {
          inAAssociationOwnedEnd(node);
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getRole() != null)
          {
              node.getRole().apply(this);
          }
          outAAssociationOwnedEnd(node);
      }
  
      public void inAAssociationMemberEnd(AAssociationMemberEnd node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationMemberEnd(AAssociationMemberEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationMemberEnd(AAssociationMemberEnd node)
      {
          inAAssociationMemberEnd(node);
          if(node.getProperty() != null)
          {
              node.getProperty().apply(this);
          }
          if(node.getDot() != null)
          {
              node.getDot().apply(this);
          }
          if(node.getClassifier() != null)
          {
              node.getClassifier().apply(this);
          }
          if(node.getRole() != null)
          {
              node.getRole().apply(this);
          }
          outAAssociationMemberEnd(node);
      }
  
      public void inAAssociationModifiers(AAssociationModifiers node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationModifiers(AAssociationModifiers node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationModifiers(AAssociationModifiers node)
      {
          inAAssociationModifiers(node);
          if(node.getAssociationModifierList() != null)
          {
              node.getAssociationModifierList().apply(this);
          }
          outAAssociationModifiers(node);
      }
  
      public void inAAssociationModifierList(AAssociationModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationModifierList(AAssociationModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationModifierList(AAssociationModifierList node)
      {
          inAAssociationModifierList(node);
          if(node.getAssociationModifierList() != null)
          {
              node.getAssociationModifierList().apply(this);
          }
          if(node.getAssociationModifier() != null)
          {
              node.getAssociationModifier().apply(this);
          }
          outAAssociationModifierList(node);
      }
  
      public void inAEmptyAssociationModifierList(AEmptyAssociationModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyAssociationModifierList(AEmptyAssociationModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyAssociationModifierList(AEmptyAssociationModifierList node)
      {
          inAEmptyAssociationModifierList(node);
          outAEmptyAssociationModifierList(node);
      }
  
      public void inANavigableAssociationModifier(ANavigableAssociationModifier node)
      {
          defaultIn(node);
      }
  
      public void outANavigableAssociationModifier(ANavigableAssociationModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANavigableAssociationModifier(ANavigableAssociationModifier node)
      {
          inANavigableAssociationModifier(node);
          if(node.getNavigable() != null)
          {
              node.getNavigable().apply(this);
          }
          if(node.getNot() != null)
          {
              node.getNot().apply(this);
          }
          outANavigableAssociationModifier(node);
      }
  
      public void inAReadonlyAssociationModifier(AReadonlyAssociationModifier node)
      {
          defaultIn(node);
      }
  
      public void outAReadonlyAssociationModifier(AReadonlyAssociationModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReadonlyAssociationModifier(AReadonlyAssociationModifier node)
      {
          inAReadonlyAssociationModifier(node);
          if(node.getReadonly() != null)
          {
              node.getReadonly().apply(this);
          }
          outAReadonlyAssociationModifier(node);
      }
  
      public void inAClassDef(AClassDef node)
      {
          defaultIn(node);
      }
  
      public void outAClassDef(AClassDef node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassDef(AClassDef node)
      {
          inAClassDef(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getFeatureDeclList() != null)
          {
              node.getFeatureDeclList().apply(this);
          }
          if(node.getClassHeader() != null)
          {
              node.getClassHeader().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAClassDef(node);
      }
  
      public void inAClassHeader(AClassHeader node)
      {
          defaultIn(node);
      }
  
      public void outAClassHeader(AClassHeader node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassHeader(AClassHeader node)
      {
          inAClassHeader(node);
          if(node.getClassImplementsSection() != null)
          {
              node.getClassImplementsSection().apply(this);
          }
          if(node.getClassSpecializesSection() != null)
          {
              node.getClassSpecializesSection().apply(this);
          }
          if(node.getOptionalFormalTemplateParameters() != null)
          {
              node.getOptionalFormalTemplateParameters().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getClassType() != null)
          {
              node.getClassType().apply(this);
          }
          if(node.getClassModifiers() != null)
          {
              node.getClassModifiers().apply(this);
          }
          outAClassHeader(node);
      }
  
      public void inAClassModifiers(AClassModifiers node)
      {
          defaultIn(node);
      }
  
      public void outAClassModifiers(AClassModifiers node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassModifiers(AClassModifiers node)
      {
          inAClassModifiers(node);
          if(node.getClassModifierList() != null)
          {
              node.getClassModifierList().apply(this);
          }
          outAClassModifiers(node);
      }
  
      public void inAClassModifierList(AClassModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAClassModifierList(AClassModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassModifierList(AClassModifierList node)
      {
          inAClassModifierList(node);
          if(node.getClassModifierList() != null)
          {
              node.getClassModifierList().apply(this);
          }
          if(node.getClassModifier() != null)
          {
              node.getClassModifier().apply(this);
          }
          outAClassModifierList(node);
      }
  
      public void inAEmptyClassModifierList(AEmptyClassModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyClassModifierList(AEmptyClassModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyClassModifierList(AEmptyClassModifierList node)
      {
          inAEmptyClassModifierList(node);
          outAEmptyClassModifierList(node);
      }
  
      public void inAVisibilityClassModifier(AVisibilityClassModifier node)
      {
          defaultIn(node);
      }
  
      public void outAVisibilityClassModifier(AVisibilityClassModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVisibilityClassModifier(AVisibilityClassModifier node)
      {
          inAVisibilityClassModifier(node);
          if(node.getVisibilityModifier() != null)
          {
              node.getVisibilityModifier().apply(this);
          }
          outAVisibilityClassModifier(node);
      }
  
      public void inAAbstractClassModifier(AAbstractClassModifier node)
      {
          defaultIn(node);
      }
  
      public void outAAbstractClassModifier(AAbstractClassModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAbstractClassModifier(AAbstractClassModifier node)
      {
          inAAbstractClassModifier(node);
          if(node.getAbstract() != null)
          {
              node.getAbstract().apply(this);
          }
          outAAbstractClassModifier(node);
      }
  
      public void inAExternalClassModifier(AExternalClassModifier node)
      {
          defaultIn(node);
      }
  
      public void outAExternalClassModifier(AExternalClassModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExternalClassModifier(AExternalClassModifier node)
      {
          inAExternalClassModifier(node);
          if(node.getExternal() != null)
          {
              node.getExternal().apply(this);
          }
          outAExternalClassModifier(node);
      }
  
      public void inARoleClassModifier(ARoleClassModifier node)
      {
          defaultIn(node);
      }
  
      public void outARoleClassModifier(ARoleClassModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARoleClassModifier(ARoleClassModifier node)
      {
          inARoleClassModifier(node);
          if(node.getRole() != null)
          {
              node.getRole().apply(this);
          }
          outARoleClassModifier(node);
      }
  
      public void inAClassClassType(AClassClassType node)
      {
          defaultIn(node);
      }
  
      public void outAClassClassType(AClassClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassClassType(AClassClassType node)
      {
          inAClassClassType(node);
          if(node.getClazz() != null)
          {
              node.getClazz().apply(this);
          }
          outAClassClassType(node);
      }
  
      public void inAInterfaceClassType(AInterfaceClassType node)
      {
          defaultIn(node);
      }
  
      public void outAInterfaceClassType(AInterfaceClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInterfaceClassType(AInterfaceClassType node)
      {
          inAInterfaceClassType(node);
          if(node.getInterface() != null)
          {
              node.getInterface().apply(this);
          }
          outAInterfaceClassType(node);
      }
  
      public void inADatatypeClassType(ADatatypeClassType node)
      {
          defaultIn(node);
      }
  
      public void outADatatypeClassType(ADatatypeClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADatatypeClassType(ADatatypeClassType node)
      {
          inADatatypeClassType(node);
          if(node.getDatatype() != null)
          {
              node.getDatatype().apply(this);
          }
          outADatatypeClassType(node);
      }
  
      public void inAActorClassType(AActorClassType node)
      {
          defaultIn(node);
      }
  
      public void outAActorClassType(AActorClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAActorClassType(AActorClassType node)
      {
          inAActorClassType(node);
          if(node.getActor() != null)
          {
              node.getActor().apply(this);
          }
          outAActorClassType(node);
      }
  
      public void inASignalClassType(ASignalClassType node)
      {
          defaultIn(node);
      }
  
      public void outASignalClassType(ASignalClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASignalClassType(ASignalClassType node)
      {
          inASignalClassType(node);
          if(node.getSignal() != null)
          {
              node.getSignal().apply(this);
          }
          outASignalClassType(node);
      }
  
      public void inAComponentClassType(AComponentClassType node)
      {
          defaultIn(node);
      }
  
      public void outAComponentClassType(AComponentClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAComponentClassType(AComponentClassType node)
      {
          inAComponentClassType(node);
          if(node.getComponent() != null)
          {
              node.getComponent().apply(this);
          }
          outAComponentClassType(node);
      }
  
      public void inAEnumerationClassType(AEnumerationClassType node)
      {
          defaultIn(node);
      }
  
      public void outAEnumerationClassType(AEnumerationClassType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEnumerationClassType(AEnumerationClassType node)
      {
          inAEnumerationClassType(node);
          if(node.getEnumeration() != null)
          {
              node.getEnumeration().apply(this);
          }
          outAEnumerationClassType(node);
      }
  
      public void inAClassImplementsSection(AClassImplementsSection node)
      {
          defaultIn(node);
      }
  
      public void outAClassImplementsSection(AClassImplementsSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassImplementsSection(AClassImplementsSection node)
      {
          inAClassImplementsSection(node);
          if(node.getClassImplementsList() != null)
          {
              node.getClassImplementsList().apply(this);
          }
          if(node.getImplements() != null)
          {
              node.getImplements().apply(this);
          }
          outAClassImplementsSection(node);
      }
  
      public void inAEmptyClassImplementsSection(AEmptyClassImplementsSection node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyClassImplementsSection(AEmptyClassImplementsSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyClassImplementsSection(AEmptyClassImplementsSection node)
      {
          inAEmptyClassImplementsSection(node);
          outAEmptyClassImplementsSection(node);
      }
  
      public void inAClassImplementsList(AClassImplementsList node)
      {
          defaultIn(node);
      }
  
      public void outAClassImplementsList(AClassImplementsList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassImplementsList(AClassImplementsList node)
      {
          inAClassImplementsList(node);
          {
              List<PClassImplementsListTail> copy = new ArrayList<PClassImplementsListTail>(node.getClassImplementsListTail());
              Collections.reverse(copy);
              for(PClassImplementsListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getClassImplementsItem() != null)
          {
              node.getClassImplementsItem().apply(this);
          }
          outAClassImplementsList(node);
      }
  
      public void inAClassImplementsListTail(AClassImplementsListTail node)
      {
          defaultIn(node);
      }
  
      public void outAClassImplementsListTail(AClassImplementsListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassImplementsListTail(AClassImplementsListTail node)
      {
          inAClassImplementsListTail(node);
          if(node.getClassImplementsItem() != null)
          {
              node.getClassImplementsItem().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAClassImplementsListTail(node);
      }
  
      public void inAClassImplementsItem(AClassImplementsItem node)
      {
          defaultIn(node);
      }
  
      public void outAClassImplementsItem(AClassImplementsItem node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassImplementsItem(AClassImplementsItem node)
      {
          inAClassImplementsItem(node);
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAClassImplementsItem(node);
      }
  
      public void inAClassSpecializesSection(AClassSpecializesSection node)
      {
          defaultIn(node);
      }
  
      public void outAClassSpecializesSection(AClassSpecializesSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassSpecializesSection(AClassSpecializesSection node)
      {
          inAClassSpecializesSection(node);
          if(node.getClassSpecializesList() != null)
          {
              node.getClassSpecializesList().apply(this);
          }
          if(node.getSpecializes() != null)
          {
              node.getSpecializes().apply(this);
          }
          outAClassSpecializesSection(node);
      }
  
      public void inAEmptyClassSpecializesSection(AEmptyClassSpecializesSection node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyClassSpecializesSection(AEmptyClassSpecializesSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyClassSpecializesSection(AEmptyClassSpecializesSection node)
      {
          inAEmptyClassSpecializesSection(node);
          outAEmptyClassSpecializesSection(node);
      }
  
      public void inAClassSpecializesList(AClassSpecializesList node)
      {
          defaultIn(node);
      }
  
      public void outAClassSpecializesList(AClassSpecializesList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassSpecializesList(AClassSpecializesList node)
      {
          inAClassSpecializesList(node);
          {
              List<PClassSpecializesListTail> copy = new ArrayList<PClassSpecializesListTail>(node.getClassSpecializesListTail());
              Collections.reverse(copy);
              for(PClassSpecializesListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getClassSpecializesItem() != null)
          {
              node.getClassSpecializesItem().apply(this);
          }
          outAClassSpecializesList(node);
      }
  
      public void inAClassSpecializesItem(AClassSpecializesItem node)
      {
          defaultIn(node);
      }
  
      public void outAClassSpecializesItem(AClassSpecializesItem node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassSpecializesItem(AClassSpecializesItem node)
      {
          inAClassSpecializesItem(node);
          if(node.getSingleTypeIdentifier() != null)
          {
              node.getSingleTypeIdentifier().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAClassSpecializesItem(node);
      }
  
      public void inAClassSpecializesListTail(AClassSpecializesListTail node)
      {
          defaultIn(node);
      }
  
      public void outAClassSpecializesListTail(AClassSpecializesListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassSpecializesListTail(AClassSpecializesListTail node)
      {
          inAClassSpecializesListTail(node);
          if(node.getClassSpecializesItem() != null)
          {
              node.getClassSpecializesItem().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAClassSpecializesListTail(node);
      }
  
      public void inAFeatureDeclList(AFeatureDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAFeatureDeclList(AFeatureDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFeatureDeclList(AFeatureDeclList node)
      {
          inAFeatureDeclList(node);
          if(node.getFeatureDeclList() != null)
          {
              node.getFeatureDeclList().apply(this);
          }
          if(node.getFeatureDecl() != null)
          {
              node.getFeatureDecl().apply(this);
          }
          outAFeatureDeclList(node);
      }
  
      public void inAEmptyFeatureDeclList(AEmptyFeatureDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyFeatureDeclList(AEmptyFeatureDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyFeatureDeclList(AEmptyFeatureDeclList node)
      {
          inAEmptyFeatureDeclList(node);
          outAEmptyFeatureDeclList(node);
      }
  
      public void inAFeatureDecl(AFeatureDecl node)
      {
          defaultIn(node);
      }
  
      public void outAFeatureDecl(AFeatureDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFeatureDecl(AFeatureDecl node)
      {
          inAFeatureDecl(node);
          if(node.getFeatureType() != null)
          {
              node.getFeatureType().apply(this);
          }
          if(node.getModifiers() != null)
          {
              node.getModifiers().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAFeatureDecl(node);
      }
  
      public void inAModifiers(AModifiers node)
      {
          defaultIn(node);
      }
  
      public void outAModifiers(AModifiers node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAModifiers(AModifiers node)
      {
          inAModifiers(node);
          if(node.getModifierList() != null)
          {
              node.getModifierList().apply(this);
          }
          outAModifiers(node);
      }
  
      public void inAModifierList(AModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAModifierList(AModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAModifierList(AModifierList node)
      {
          inAModifierList(node);
          if(node.getModifierList() != null)
          {
              node.getModifierList().apply(this);
          }
          if(node.getModifier() != null)
          {
              node.getModifier().apply(this);
          }
          outAModifierList(node);
      }
  
      public void inAEmptyModifierList(AEmptyModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyModifierList(AEmptyModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyModifierList(AEmptyModifierList node)
      {
          inAEmptyModifierList(node);
          outAEmptyModifierList(node);
      }
  
      public void inAVisibilityModifier(AVisibilityModifier node)
      {
          defaultIn(node);
      }
  
      public void outAVisibilityModifier(AVisibilityModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVisibilityModifier(AVisibilityModifier node)
      {
          inAVisibilityModifier(node);
          if(node.getVisibilityModifier() != null)
          {
              node.getVisibilityModifier().apply(this);
          }
          outAVisibilityModifier(node);
      }
  
      public void inAStaticModifier(AStaticModifier node)
      {
          defaultIn(node);
      }
  
      public void outAStaticModifier(AStaticModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStaticModifier(AStaticModifier node)
      {
          inAStaticModifier(node);
          if(node.getStatic() != null)
          {
              node.getStatic().apply(this);
          }
          outAStaticModifier(node);
      }
  
      public void inAAbstractModifier(AAbstractModifier node)
      {
          defaultIn(node);
      }
  
      public void outAAbstractModifier(AAbstractModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAbstractModifier(AAbstractModifier node)
      {
          inAAbstractModifier(node);
          if(node.getAbstract() != null)
          {
              node.getAbstract().apply(this);
          }
          outAAbstractModifier(node);
      }
  
      public void inADerivedModifier(ADerivedModifier node)
      {
          defaultIn(node);
      }
  
      public void outADerivedModifier(ADerivedModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADerivedModifier(ADerivedModifier node)
      {
          inADerivedModifier(node);
          if(node.getDerived() != null)
          {
              node.getDerived().apply(this);
          }
          outADerivedModifier(node);
      }
  
      public void inAReadonlyModifier(AReadonlyModifier node)
      {
          defaultIn(node);
      }
  
      public void outAReadonlyModifier(AReadonlyModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReadonlyModifier(AReadonlyModifier node)
      {
          inAReadonlyModifier(node);
          if(node.getReadonly() != null)
          {
              node.getReadonly().apply(this);
          }
          outAReadonlyModifier(node);
      }
  
      public void inAIdModifier(AIdModifier node)
      {
          defaultIn(node);
      }
  
      public void outAIdModifier(AIdModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIdModifier(AIdModifier node)
      {
          inAIdModifier(node);
          if(node.getId() != null)
          {
              node.getId().apply(this);
          }
          outAIdModifier(node);
      }
  
      public void inAPublicVisibilityModifier(APublicVisibilityModifier node)
      {
          defaultIn(node);
      }
  
      public void outAPublicVisibilityModifier(APublicVisibilityModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPublicVisibilityModifier(APublicVisibilityModifier node)
      {
          inAPublicVisibilityModifier(node);
          if(node.getPublic() != null)
          {
              node.getPublic().apply(this);
          }
          outAPublicVisibilityModifier(node);
      }
  
      public void inAPrivateVisibilityModifier(APrivateVisibilityModifier node)
      {
          defaultIn(node);
      }
  
      public void outAPrivateVisibilityModifier(APrivateVisibilityModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPrivateVisibilityModifier(APrivateVisibilityModifier node)
      {
          inAPrivateVisibilityModifier(node);
          if(node.getPrivate() != null)
          {
              node.getPrivate().apply(this);
          }
          outAPrivateVisibilityModifier(node);
      }
  
      public void inAPackageVisibilityModifier(APackageVisibilityModifier node)
      {
          defaultIn(node);
      }
  
      public void outAPackageVisibilityModifier(APackageVisibilityModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPackageVisibilityModifier(APackageVisibilityModifier node)
      {
          inAPackageVisibilityModifier(node);
          if(node.getPackage() != null)
          {
              node.getPackage().apply(this);
          }
          outAPackageVisibilityModifier(node);
      }
  
      public void inAProtectedVisibilityModifier(AProtectedVisibilityModifier node)
      {
          defaultIn(node);
      }
  
      public void outAProtectedVisibilityModifier(AProtectedVisibilityModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAProtectedVisibilityModifier(AProtectedVisibilityModifier node)
      {
          inAProtectedVisibilityModifier(node);
          if(node.getProtected() != null)
          {
              node.getProtected().apply(this);
          }
          outAProtectedVisibilityModifier(node);
      }
  
      public void inAStateMachineFeatureType(AStateMachineFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAStateMachineFeatureType(AStateMachineFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStateMachineFeatureType(AStateMachineFeatureType node)
      {
          inAStateMachineFeatureType(node);
          if(node.getStateMachineDecl() != null)
          {
              node.getStateMachineDecl().apply(this);
          }
          outAStateMachineFeatureType(node);
      }
  
      public void inAOperationFeatureType(AOperationFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAOperationFeatureType(AOperationFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationFeatureType(AOperationFeatureType node)
      {
          inAOperationFeatureType(node);
          if(node.getOperationDecl() != null)
          {
              node.getOperationDecl().apply(this);
          }
          outAOperationFeatureType(node);
      }
  
      public void inAAttributeFeatureType(AAttributeFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAAttributeFeatureType(AAttributeFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAttributeFeatureType(AAttributeFeatureType node)
      {
          inAAttributeFeatureType(node);
          if(node.getAttributeDecl() != null)
          {
              node.getAttributeDecl().apply(this);
          }
          outAAttributeFeatureType(node);
      }
  
      public void inALiteralFeatureType(ALiteralFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outALiteralFeatureType(ALiteralFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALiteralFeatureType(ALiteralFeatureType node)
      {
          inALiteralFeatureType(node);
          if(node.getEnumerationLiteralDecl() != null)
          {
              node.getEnumerationLiteralDecl().apply(this);
          }
          outALiteralFeatureType(node);
      }
  
      public void inAReferenceFeatureType(AReferenceFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAReferenceFeatureType(AReferenceFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReferenceFeatureType(AReferenceFeatureType node)
      {
          inAReferenceFeatureType(node);
          if(node.getReferenceDecl() != null)
          {
              node.getReferenceDecl().apply(this);
          }
          outAReferenceFeatureType(node);
      }
  
      public void inAReceptionFeatureType(AReceptionFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAReceptionFeatureType(AReceptionFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReceptionFeatureType(AReceptionFeatureType node)
      {
          inAReceptionFeatureType(node);
          if(node.getReceptionDecl() != null)
          {
              node.getReceptionDecl().apply(this);
          }
          outAReceptionFeatureType(node);
      }
  
      public void inAPortFeatureType(APortFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAPortFeatureType(APortFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPortFeatureType(APortFeatureType node)
      {
          inAPortFeatureType(node);
          if(node.getPortDecl() != null)
          {
              node.getPortDecl().apply(this);
          }
          outAPortFeatureType(node);
      }
  
      public void inADependencyFeatureType(ADependencyFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outADependencyFeatureType(ADependencyFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADependencyFeatureType(ADependencyFeatureType node)
      {
          inADependencyFeatureType(node);
          if(node.getDependencyDecl() != null)
          {
              node.getDependencyDecl().apply(this);
          }
          outADependencyFeatureType(node);
      }
  
      public void inAInvariantFeatureType(AInvariantFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAInvariantFeatureType(AInvariantFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInvariantFeatureType(AInvariantFeatureType node)
      {
          inAInvariantFeatureType(node);
          if(node.getClassInvariantDecl() != null)
          {
              node.getClassInvariantDecl().apply(this);
          }
          outAInvariantFeatureType(node);
      }
  
      public void inAConnectorFeatureType(AConnectorFeatureType node)
      {
          defaultIn(node);
      }
  
      public void outAConnectorFeatureType(AConnectorFeatureType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConnectorFeatureType(AConnectorFeatureType node)
      {
          inAConnectorFeatureType(node);
          if(node.getConnectorDecl() != null)
          {
              node.getConnectorDecl().apply(this);
          }
          outAConnectorFeatureType(node);
      }
  
      public void inAStateMachineDecl(AStateMachineDecl node)
      {
          defaultIn(node);
      }
  
      public void outAStateMachineDecl(AStateMachineDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStateMachineDecl(AStateMachineDecl node)
      {
          inAStateMachineDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          {
              List<PStateDecl> copy = new ArrayList<PStateDecl>(node.getStateDecl());
              Collections.reverse(copy);
              for(PStateDecl e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getStatemachine() != null)
          {
              node.getStatemachine().apply(this);
          }
          outAStateMachineDecl(node);
      }
  
      public void inAStateDecl(AStateDecl node)
      {
          defaultIn(node);
      }
  
      public void outAStateDecl(AStateDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStateDecl(AStateDecl node)
      {
          inAStateDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          {
              List<PTransitionDecl> copy = new ArrayList<PTransitionDecl>(node.getTransitionDecl());
              Collections.reverse(copy);
              for(PTransitionDecl e : copy)
              {
                  e.apply(this);
              }
          }
          {
              List<PStateBehavior> copy = new ArrayList<PStateBehavior>(node.getStateBehavior());
              Collections.reverse(copy);
              for(PStateBehavior e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getState() != null)
          {
              node.getState().apply(this);
          }
          if(node.getStateModifierList() != null)
          {
              node.getStateModifierList().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAStateDecl(node);
      }
  
      public void inAStateModifierList(AStateModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAStateModifierList(AStateModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStateModifierList(AStateModifierList node)
      {
          inAStateModifierList(node);
          {
              List<PStateModifier> copy = new ArrayList<PStateModifier>(node.getStateModifier());
              Collections.reverse(copy);
              for(PStateModifier e : copy)
              {
                  e.apply(this);
              }
          }
          outAStateModifierList(node);
      }
  
      public void inAInitialStateModifier(AInitialStateModifier node)
      {
          defaultIn(node);
      }
  
      public void outAInitialStateModifier(AInitialStateModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInitialStateModifier(AInitialStateModifier node)
      {
          inAInitialStateModifier(node);
          if(node.getInitial() != null)
          {
              node.getInitial().apply(this);
          }
          outAInitialStateModifier(node);
      }
  
      public void inATerminateStateModifier(ATerminateStateModifier node)
      {
          defaultIn(node);
      }
  
      public void outATerminateStateModifier(ATerminateStateModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATerminateStateModifier(ATerminateStateModifier node)
      {
          inATerminateStateModifier(node);
          if(node.getTerminate() != null)
          {
              node.getTerminate().apply(this);
          }
          outATerminateStateModifier(node);
      }
  
      public void inAFinalStateModifier(AFinalStateModifier node)
      {
          defaultIn(node);
      }
  
      public void outAFinalStateModifier(AFinalStateModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFinalStateModifier(AFinalStateModifier node)
      {
          inAFinalStateModifier(node);
          if(node.getFinal() != null)
          {
              node.getFinal().apply(this);
          }
          outAFinalStateModifier(node);
      }
  
      public void inAStateBehavior(AStateBehavior node)
      {
          defaultIn(node);
      }
  
      public void outAStateBehavior(AStateBehavior node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStateBehavior(AStateBehavior node)
      {
          inAStateBehavior(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getStateBehaviorDefinition() != null)
          {
              node.getStateBehaviorDefinition().apply(this);
          }
          if(node.getStateBehaviorModifier() != null)
          {
              node.getStateBehaviorModifier().apply(this);
          }
          outAStateBehavior(node);
      }
  
      public void inADoStateBehaviorModifier(ADoStateBehaviorModifier node)
      {
          defaultIn(node);
      }
  
      public void outADoStateBehaviorModifier(ADoStateBehaviorModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADoStateBehaviorModifier(ADoStateBehaviorModifier node)
      {
          inADoStateBehaviorModifier(node);
          if(node.getDo() != null)
          {
              node.getDo().apply(this);
          }
          outADoStateBehaviorModifier(node);
      }
  
      public void inAEntryStateBehaviorModifier(AEntryStateBehaviorModifier node)
      {
          defaultIn(node);
      }
  
      public void outAEntryStateBehaviorModifier(AEntryStateBehaviorModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEntryStateBehaviorModifier(AEntryStateBehaviorModifier node)
      {
          inAEntryStateBehaviorModifier(node);
          if(node.getEntry() != null)
          {
              node.getEntry().apply(this);
          }
          outAEntryStateBehaviorModifier(node);
      }
  
      public void inAExitStateBehaviorModifier(AExitStateBehaviorModifier node)
      {
          defaultIn(node);
      }
  
      public void outAExitStateBehaviorModifier(AExitStateBehaviorModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExitStateBehaviorModifier(AExitStateBehaviorModifier node)
      {
          inAExitStateBehaviorModifier(node);
          if(node.getExit() != null)
          {
              node.getExit().apply(this);
          }
          outAExitStateBehaviorModifier(node);
      }
  
      public void inANameStateBehaviorDefinition(ANameStateBehaviorDefinition node)
      {
          defaultIn(node);
      }
  
      public void outANameStateBehaviorDefinition(ANameStateBehaviorDefinition node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANameStateBehaviorDefinition(ANameStateBehaviorDefinition node)
      {
          inANameStateBehaviorDefinition(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outANameStateBehaviorDefinition(node);
      }
  
      public void inABehaviorStateBehaviorDefinition(ABehaviorStateBehaviorDefinition node)
      {
          defaultIn(node);
      }
  
      public void outABehaviorStateBehaviorDefinition(ABehaviorStateBehaviorDefinition node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABehaviorStateBehaviorDefinition(ABehaviorStateBehaviorDefinition node)
      {
          inABehaviorStateBehaviorDefinition(node);
          if(node.getSimpleBlock() != null)
          {
              node.getSimpleBlock().apply(this);
          }
          outABehaviorStateBehaviorDefinition(node);
      }
  
      public void inATransitionDecl(ATransitionDecl node)
      {
          defaultIn(node);
      }
  
      public void outATransitionDecl(ATransitionDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATransitionDecl(ATransitionDecl node)
      {
          inATransitionDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getTransitionEffect() != null)
          {
              node.getTransitionEffect().apply(this);
          }
          if(node.getTransitionGuard() != null)
          {
              node.getTransitionGuard().apply(this);
          }
          if(node.getDestination() != null)
          {
              node.getDestination().apply(this);
          }
          if(node.getTo() != null)
          {
              node.getTo().apply(this);
          }
          if(node.getTransitionTriggers() != null)
          {
              node.getTransitionTriggers().apply(this);
          }
          if(node.getTransition() != null)
          {
              node.getTransition().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outATransitionDecl(node);
      }
  
      public void inATransitionGuard(ATransitionGuard node)
      {
          defaultIn(node);
      }
  
      public void outATransitionGuard(ATransitionGuard node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATransitionGuard(ATransitionGuard node)
      {
          inATransitionGuard(node);
          if(node.getExpressionBlock() != null)
          {
              node.getExpressionBlock().apply(this);
          }
          if(node.getWhen() != null)
          {
              node.getWhen().apply(this);
          }
          outATransitionGuard(node);
      }
  
      public void inATransitionEffect(ATransitionEffect node)
      {
          defaultIn(node);
      }
  
      public void outATransitionEffect(ATransitionEffect node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATransitionEffect(ATransitionEffect node)
      {
          inATransitionEffect(node);
          if(node.getSimpleBlock() != null)
          {
              node.getSimpleBlock().apply(this);
          }
          if(node.getDo() != null)
          {
              node.getDo().apply(this);
          }
          outATransitionEffect(node);
      }
  
      public void inATransitionTriggers(ATransitionTriggers node)
      {
          defaultIn(node);
      }
  
      public void outATransitionTriggers(ATransitionTriggers node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATransitionTriggers(ATransitionTriggers node)
      {
          inATransitionTriggers(node);
          if(node.getTransitionTriggerTail() != null)
          {
              node.getTransitionTriggerTail().apply(this);
          }
          if(node.getTransitionTrigger() != null)
          {
              node.getTransitionTrigger().apply(this);
          }
          if(node.getOn() != null)
          {
              node.getOn().apply(this);
          }
          outATransitionTriggers(node);
      }
  
      public void inATransitionTriggerTail(ATransitionTriggerTail node)
      {
          defaultIn(node);
      }
  
      public void outATransitionTriggerTail(ATransitionTriggerTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATransitionTriggerTail(ATransitionTriggerTail node)
      {
          inATransitionTriggerTail(node);
          if(node.getTransitionTriggerTail() != null)
          {
              node.getTransitionTriggerTail().apply(this);
          }
          if(node.getTransitionTrigger() != null)
          {
              node.getTransitionTrigger().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outATransitionTriggerTail(node);
      }
  
      public void inAEmptyTransitionTriggerTail(AEmptyTransitionTriggerTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyTransitionTriggerTail(AEmptyTransitionTriggerTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyTransitionTriggerTail(AEmptyTransitionTriggerTail node)
      {
          inAEmptyTransitionTriggerTail(node);
          outAEmptyTransitionTriggerTail(node);
      }
  
      public void inACallTransitionTrigger(ACallTransitionTrigger node)
      {
          defaultIn(node);
      }
  
      public void outACallTransitionTrigger(ACallTransitionTrigger node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACallTransitionTrigger(ACallTransitionTrigger node)
      {
          inACallTransitionTrigger(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getCall() != null)
          {
              node.getCall().apply(this);
          }
          outACallTransitionTrigger(node);
      }
  
      public void inASignalTransitionTrigger(ASignalTransitionTrigger node)
      {
          defaultIn(node);
      }
  
      public void outASignalTransitionTrigger(ASignalTransitionTrigger node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASignalTransitionTrigger(ASignalTransitionTrigger node)
      {
          inASignalTransitionTrigger(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getSignal() != null)
          {
              node.getSignal().apply(this);
          }
          outASignalTransitionTrigger(node);
      }
  
      public void inAAnyTransitionTrigger(AAnyTransitionTrigger node)
      {
          defaultIn(node);
      }
  
      public void outAAnyTransitionTrigger(AAnyTransitionTrigger node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnyTransitionTrigger(AAnyTransitionTrigger node)
      {
          inAAnyTransitionTrigger(node);
          if(node.getAny() != null)
          {
              node.getAny().apply(this);
          }
          outAAnyTransitionTrigger(node);
      }
  
      public void inAReceptionDecl(AReceptionDecl node)
      {
          defaultIn(node);
      }
  
      public void outAReceptionDecl(AReceptionDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReceptionDecl(AReceptionDecl node)
      {
          inAReceptionDecl(node);
          if(node.getOptionalBehavioralFeatureBody() != null)
          {
              node.getOptionalBehavioralFeatureBody().apply(this);
          }
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getSimpleParamDecl() != null)
          {
              node.getSimpleParamDecl().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getReceptionName() != null)
          {
              node.getReceptionName().apply(this);
          }
          if(node.getReception() != null)
          {
              node.getReception().apply(this);
          }
          outAReceptionDecl(node);
      }
  
      public void inAOperationDecl(AOperationDecl node)
      {
          defaultIn(node);
      }
  
      public void outAOperationDecl(AOperationDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationDecl(AOperationDecl node)
      {
          inAOperationDecl(node);
          if(node.getOptionalBehavioralFeatureBody() != null)
          {
              node.getOptionalBehavioralFeatureBody().apply(this);
          }
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          {
              List<POperationConstraint> copy = new ArrayList<POperationConstraint>(node.getOperationConstraint());
              Collections.reverse(copy);
              for(POperationConstraint e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getOperationHeader() != null)
          {
              node.getOperationHeader().apply(this);
          }
          outAOperationDecl(node);
      }
  
      public void inAParametersetDecl(AParametersetDecl node)
      {
          defaultIn(node);
      }
  
      public void outAParametersetDecl(AParametersetDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParametersetDecl(AParametersetDecl node)
      {
          inAParametersetDecl(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getParameters() != null)
          {
              node.getParameters().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getName() != null)
          {
              node.getName().apply(this);
          }
          if(node.getParameterset() != null)
          {
              node.getParameterset().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAParametersetDecl(node);
      }
  
      public void inAOperationConstraint(AOperationConstraint node)
      {
          defaultIn(node);
      }
  
      public void outAOperationConstraint(AOperationConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationConstraint(AOperationConstraint node)
      {
          inAOperationConstraint(node);
          if(node.getOperationConstraintKernel() != null)
          {
              node.getOperationConstraintKernel().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAOperationConstraint(node);
      }
  
      public void inAPreconditionOperationConstraintKernel(APreconditionOperationConstraintKernel node)
      {
          defaultIn(node);
      }
  
      public void outAPreconditionOperationConstraintKernel(APreconditionOperationConstraintKernel node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPreconditionOperationConstraintKernel(APreconditionOperationConstraintKernel node)
      {
          inAPreconditionOperationConstraintKernel(node);
          if(node.getOperationPrecondition() != null)
          {
              node.getOperationPrecondition().apply(this);
          }
          outAPreconditionOperationConstraintKernel(node);
      }
  
      public void inAPermissionOperationConstraintKernel(APermissionOperationConstraintKernel node)
      {
          defaultIn(node);
      }
  
      public void outAPermissionOperationConstraintKernel(APermissionOperationConstraintKernel node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPermissionOperationConstraintKernel(APermissionOperationConstraintKernel node)
      {
          inAPermissionOperationConstraintKernel(node);
          if(node.getPermissionConstraint() != null)
          {
              node.getPermissionConstraint().apply(this);
          }
          outAPermissionOperationConstraintKernel(node);
      }
  
      public void inAOperationPrecondition(AOperationPrecondition node)
      {
          defaultIn(node);
      }
  
      public void outAOperationPrecondition(AOperationPrecondition node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationPrecondition(AOperationPrecondition node)
      {
          inAOperationPrecondition(node);
          if(node.getExpressionBlock() != null)
          {
              node.getExpressionBlock().apply(this);
          }
          if(node.getConstraintException() != null)
          {
              node.getConstraintException().apply(this);
          }
          if(node.getPreconditionSignature() != null)
          {
              node.getPreconditionSignature().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getPrecondition() != null)
          {
              node.getPrecondition().apply(this);
          }
          outAOperationPrecondition(node);
      }
  
      public void inAPermissionConstraint(APermissionConstraint node)
      {
          defaultIn(node);
      }
  
      public void outAPermissionConstraint(APermissionConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPermissionConstraint(APermissionConstraint node)
      {
          inAPermissionConstraint(node);
          if(node.getPermissionExpression() != null)
          {
              node.getPermissionExpression().apply(this);
          }
          if(node.getAccessCapabilities() != null)
          {
              node.getAccessCapabilities().apply(this);
          }
          if(node.getPermissionRoles() != null)
          {
              node.getPermissionRoles().apply(this);
          }
          if(node.getAllow() != null)
          {
              node.getAllow().apply(this);
          }
          outAPermissionConstraint(node);
      }
  
      public void inAPermissionExpression(APermissionExpression node)
      {
          defaultIn(node);
      }
  
      public void outAPermissionExpression(APermissionExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPermissionExpression(APermissionExpression node)
      {
          inAPermissionExpression(node);
          if(node.getExpressionBlock() != null)
          {
              node.getExpressionBlock().apply(this);
          }
          outAPermissionExpression(node);
      }
  
      public void inAPermissionRoles(APermissionRoles node)
      {
          defaultIn(node);
      }
  
      public void outAPermissionRoles(APermissionRoles node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPermissionRoles(APermissionRoles node)
      {
          inAPermissionRoles(node);
          if(node.getQualifiedIdentifierList() != null)
          {
              node.getQualifiedIdentifierList().apply(this);
          }
          outAPermissionRoles(node);
      }
  
      public void inAEmptyPermissionRoles(AEmptyPermissionRoles node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyPermissionRoles(AEmptyPermissionRoles node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyPermissionRoles(AEmptyPermissionRoles node)
      {
          inAEmptyPermissionRoles(node);
          outAEmptyPermissionRoles(node);
      }
  
      public void inAAccessCapabilities(AAccessCapabilities node)
      {
          defaultIn(node);
      }
  
      public void outAAccessCapabilities(AAccessCapabilities node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAccessCapabilities(AAccessCapabilities node)
      {
          inAAccessCapabilities(node);
          if(node.getAccessCapabilityList() != null)
          {
              node.getAccessCapabilityList().apply(this);
          }
          outAAccessCapabilities(node);
      }
  
      public void inAAllAccessCapabilities(AAllAccessCapabilities node)
      {
          defaultIn(node);
      }
  
      public void outAAllAccessCapabilities(AAllAccessCapabilities node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAllAccessCapabilities(AAllAccessCapabilities node)
      {
          inAAllAccessCapabilities(node);
          if(node.getAll() != null)
          {
              node.getAll().apply(this);
          }
          outAAllAccessCapabilities(node);
      }
  
      public void inANoneAccessCapabilities(ANoneAccessCapabilities node)
      {
          defaultIn(node);
      }
  
      public void outANoneAccessCapabilities(ANoneAccessCapabilities node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANoneAccessCapabilities(ANoneAccessCapabilities node)
      {
          inANoneAccessCapabilities(node);
          if(node.getNone() != null)
          {
              node.getNone().apply(this);
          }
          outANoneAccessCapabilities(node);
      }
  
      public void inAEmptyAccessCapabilities(AEmptyAccessCapabilities node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyAccessCapabilities(AEmptyAccessCapabilities node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyAccessCapabilities(AEmptyAccessCapabilities node)
      {
          inAEmptyAccessCapabilities(node);
          outAEmptyAccessCapabilities(node);
      }
  
      public void inAAccessCapabilityList(AAccessCapabilityList node)
      {
          defaultIn(node);
      }
  
      public void outAAccessCapabilityList(AAccessCapabilityList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAccessCapabilityList(AAccessCapabilityList node)
      {
          inAAccessCapabilityList(node);
          {
              List<PAccessCapabilityTail> copy = new ArrayList<PAccessCapabilityTail>(node.getAccessCapabilityTail());
              Collections.reverse(copy);
              for(PAccessCapabilityTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getAccessCapability() != null)
          {
              node.getAccessCapability().apply(this);
          }
          outAAccessCapabilityList(node);
      }
  
      public void inAAccessCapabilityTail(AAccessCapabilityTail node)
      {
          defaultIn(node);
      }
  
      public void outAAccessCapabilityTail(AAccessCapabilityTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAccessCapabilityTail(AAccessCapabilityTail node)
      {
          inAAccessCapabilityTail(node);
          if(node.getAccessCapability() != null)
          {
              node.getAccessCapability().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAAccessCapabilityTail(node);
      }
  
      public void inAReadAccessCapability(AReadAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outAReadAccessCapability(AReadAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReadAccessCapability(AReadAccessCapability node)
      {
          inAReadAccessCapability(node);
          if(node.getRead() != null)
          {
              node.getRead().apply(this);
          }
          outAReadAccessCapability(node);
      }
  
      public void inACreateAccessCapability(ACreateAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outACreateAccessCapability(ACreateAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACreateAccessCapability(ACreateAccessCapability node)
      {
          inACreateAccessCapability(node);
          if(node.getCreate() != null)
          {
              node.getCreate().apply(this);
          }
          outACreateAccessCapability(node);
      }
  
      public void inAUpdateAccessCapability(AUpdateAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outAUpdateAccessCapability(AUpdateAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAUpdateAccessCapability(AUpdateAccessCapability node)
      {
          inAUpdateAccessCapability(node);
          if(node.getUpdate() != null)
          {
              node.getUpdate().apply(this);
          }
          outAUpdateAccessCapability(node);
      }
  
      public void inADeleteAccessCapability(ADeleteAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outADeleteAccessCapability(ADeleteAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADeleteAccessCapability(ADeleteAccessCapability node)
      {
          inADeleteAccessCapability(node);
          if(node.getDelete() != null)
          {
              node.getDelete().apply(this);
          }
          outADeleteAccessCapability(node);
      }
  
      public void inACallAccessCapability(ACallAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outACallAccessCapability(ACallAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACallAccessCapability(ACallAccessCapability node)
      {
          inACallAccessCapability(node);
          if(node.getCall() != null)
          {
              node.getCall().apply(this);
          }
          outACallAccessCapability(node);
      }
  
      public void inAExtentAccessCapability(AExtentAccessCapability node)
      {
          defaultIn(node);
      }
  
      public void outAExtentAccessCapability(AExtentAccessCapability node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExtentAccessCapability(AExtentAccessCapability node)
      {
          inAExtentAccessCapability(node);
          if(node.getExtent() != null)
          {
              node.getExtent().apply(this);
          }
          outAExtentAccessCapability(node);
      }
  
      public void inAPreconditionSignature(APreconditionSignature node)
      {
          defaultIn(node);
      }
  
      public void outAPreconditionSignature(APreconditionSignature node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPreconditionSignature(APreconditionSignature node)
      {
          inAPreconditionSignature(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getIdentifierList() != null)
          {
              node.getIdentifierList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outAPreconditionSignature(node);
      }
  
      public void inAConstraintException(AConstraintException node)
      {
          defaultIn(node);
      }
  
      public void outAConstraintException(AConstraintException node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConstraintException(AConstraintException node)
      {
          inAConstraintException(node);
          if(node.getException() != null)
          {
              node.getException().apply(this);
          }
          if(node.getRaises() != null)
          {
              node.getRaises().apply(this);
          }
          outAConstraintException(node);
      }
  
      public void inAIdentifierList(AIdentifierList node)
      {
          defaultIn(node);
      }
  
      public void outAIdentifierList(AIdentifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIdentifierList(AIdentifierList node)
      {
          inAIdentifierList(node);
          {
              List<PIdentifierListTail> copy = new ArrayList<PIdentifierListTail>(node.getIdentifierListTail());
              Collections.reverse(copy);
              for(PIdentifierListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAIdentifierList(node);
      }
  
      public void inAIdentifierListTail(AIdentifierListTail node)
      {
          defaultIn(node);
      }
  
      public void outAIdentifierListTail(AIdentifierListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIdentifierListTail(AIdentifierListTail node)
      {
          inAIdentifierListTail(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAIdentifierListTail(node);
      }
  
      public void inAOperationHeader(AOperationHeader node)
      {
          defaultIn(node);
      }
  
      public void outAOperationHeader(AOperationHeader node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationHeader(AOperationHeader node)
      {
          inAOperationHeader(node);
          if(node.getSignature() != null)
          {
              node.getSignature().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getWildcardTypes() != null)
          {
              node.getWildcardTypes().apply(this);
          }
          if(node.getOperationKeyword() != null)
          {
              node.getOperationKeyword().apply(this);
          }
          outAOperationHeader(node);
      }
  
      public void inAOperationOperationKeyword(AOperationOperationKeyword node)
      {
          defaultIn(node);
      }
  
      public void outAOperationOperationKeyword(AOperationOperationKeyword node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationOperationKeyword(AOperationOperationKeyword node)
      {
          inAOperationOperationKeyword(node);
          if(node.getOperation() != null)
          {
              node.getOperation().apply(this);
          }
          outAOperationOperationKeyword(node);
      }
  
      public void inAQueryOperationKeyword(AQueryOperationKeyword node)
      {
          defaultIn(node);
      }
  
      public void outAQueryOperationKeyword(AQueryOperationKeyword node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQueryOperationKeyword(AQueryOperationKeyword node)
      {
          inAQueryOperationKeyword(node);
          if(node.getQuery() != null)
          {
              node.getQuery().apply(this);
          }
          outAQueryOperationKeyword(node);
      }
  
      public void inAConstructorOperationKeyword(AConstructorOperationKeyword node)
      {
          defaultIn(node);
      }
  
      public void outAConstructorOperationKeyword(AConstructorOperationKeyword node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConstructorOperationKeyword(AConstructorOperationKeyword node)
      {
          inAConstructorOperationKeyword(node);
          if(node.getConstructor() != null)
          {
              node.getConstructor().apply(this);
          }
          outAConstructorOperationKeyword(node);
      }
  
      public void inAWildcardTypes(AWildcardTypes node)
      {
          defaultIn(node);
      }
  
      public void outAWildcardTypes(AWildcardTypes node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWildcardTypes(AWildcardTypes node)
      {
          inAWildcardTypes(node);
          if(node.getRab() != null)
          {
              node.getRab().apply(this);
          }
          if(node.getWildcardTypeTail() != null)
          {
              node.getWildcardTypeTail().apply(this);
          }
          if(node.getWildcardType() != null)
          {
              node.getWildcardType().apply(this);
          }
          if(node.getLab() != null)
          {
              node.getLab().apply(this);
          }
          outAWildcardTypes(node);
      }
  
      public void inAEmptyWildcardTypeTail(AEmptyWildcardTypeTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyWildcardTypeTail(AEmptyWildcardTypeTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyWildcardTypeTail(AEmptyWildcardTypeTail node)
      {
          inAEmptyWildcardTypeTail(node);
          outAEmptyWildcardTypeTail(node);
      }
  
      public void inAWildcardTypeTail(AWildcardTypeTail node)
      {
          defaultIn(node);
      }
  
      public void outAWildcardTypeTail(AWildcardTypeTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWildcardTypeTail(AWildcardTypeTail node)
      {
          inAWildcardTypeTail(node);
          if(node.getWildcardTypeTail() != null)
          {
              node.getWildcardTypeTail().apply(this);
          }
          if(node.getWildcardType() != null)
          {
              node.getWildcardType().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAWildcardTypeTail(node);
      }
  
      public void inAWildcardType(AWildcardType node)
      {
          defaultIn(node);
      }
  
      public void outAWildcardType(AWildcardType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWildcardType(AWildcardType node)
      {
          inAWildcardType(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAWildcardType(node);
      }
  
      public void inAOptionalBehavioralFeatureBody(AOptionalBehavioralFeatureBody node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalBehavioralFeatureBody(AOptionalBehavioralFeatureBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalBehavioralFeatureBody(AOptionalBehavioralFeatureBody node)
      {
          inAOptionalBehavioralFeatureBody(node);
          if(node.getBehavioralFeatureBody() != null)
          {
              node.getBehavioralFeatureBody().apply(this);
          }
          outAOptionalBehavioralFeatureBody(node);
      }
  
      public void inAEmptyOptionalBehavioralFeatureBody(AEmptyOptionalBehavioralFeatureBody node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyOptionalBehavioralFeatureBody(AEmptyOptionalBehavioralFeatureBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyOptionalBehavioralFeatureBody(AEmptyOptionalBehavioralFeatureBody node)
      {
          inAEmptyOptionalBehavioralFeatureBody(node);
          outAEmptyOptionalBehavioralFeatureBody(node);
      }
  
      public void inABehavioralFeatureBody(ABehavioralFeatureBody node)
      {
          defaultIn(node);
      }
  
      public void outABehavioralFeatureBody(ABehavioralFeatureBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABehavioralFeatureBody(ABehavioralFeatureBody node)
      {
          inABehavioralFeatureBody(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getBlock() != null)
          {
              node.getBlock().apply(this);
          }
          outABehavioralFeatureBody(node);
      }
  
      public void inASimpleInitializationExpression(ASimpleInitializationExpression node)
      {
          defaultIn(node);
      }
  
      public void outASimpleInitializationExpression(ASimpleInitializationExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleInitializationExpression(ASimpleInitializationExpression node)
      {
          inASimpleInitializationExpression(node);
          if(node.getSimpleInitialization() != null)
          {
              node.getSimpleInitialization().apply(this);
          }
          outASimpleInitializationExpression(node);
      }
  
      public void inAComplexInitializationExpression(AComplexInitializationExpression node)
      {
          defaultIn(node);
      }
  
      public void outAComplexInitializationExpression(AComplexInitializationExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAComplexInitializationExpression(AComplexInitializationExpression node)
      {
          inAComplexInitializationExpression(node);
          if(node.getExpressionBlock() != null)
          {
              node.getExpressionBlock().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          outAComplexInitializationExpression(node);
      }
  
      public void inASimpleInitialization(ASimpleInitialization node)
      {
          defaultIn(node);
      }
  
      public void outASimpleInitialization(ASimpleInitialization node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleInitialization(ASimpleInitialization node)
      {
          inASimpleInitialization(node);
          if(node.getLiteralOrIdentifier() != null)
          {
              node.getLiteralOrIdentifier().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          outASimpleInitialization(node);
      }
  
      public void inAAttributeDecl(AAttributeDecl node)
      {
          defaultIn(node);
      }
  
      public void outAAttributeDecl(AAttributeDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAttributeDecl(AAttributeDecl node)
      {
          inAAttributeDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          {
              List<PAttributeInvariant> copy = new ArrayList<PAttributeInvariant>(node.getAttributeInvariant());
              Collections.reverse(copy);
              for(PAttributeInvariant e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getInitializationExpression() != null)
          {
              node.getInitializationExpression().apply(this);
          }
          if(node.getOptionalSubsetting() != null)
          {
              node.getOptionalSubsetting().apply(this);
          }
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getAttribute() != null)
          {
              node.getAttribute().apply(this);
          }
          outAAttributeDecl(node);
      }
  
      public void inAAttributeInvariant(AAttributeInvariant node)
      {
          defaultIn(node);
      }
  
      public void outAAttributeInvariant(AAttributeInvariant node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAttributeInvariant(AAttributeInvariant node)
      {
          inAAttributeInvariant(node);
          if(node.getInvariantKernel() != null)
          {
              node.getInvariantKernel().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAAttributeInvariant(node);
      }
  
      public void inAEnumerationLiteralDecl(AEnumerationLiteralDecl node)
      {
          defaultIn(node);
      }
  
      public void outAEnumerationLiteralDecl(AEnumerationLiteralDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEnumerationLiteralDecl(AEnumerationLiteralDecl node)
      {
          inAEnumerationLiteralDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnumerationLiteralSlotValues() != null)
          {
              node.getEnumerationLiteralSlotValues().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getEnumerationLiteral() != null)
          {
              node.getEnumerationLiteral().apply(this);
          }
          outAEnumerationLiteralDecl(node);
      }
  
      public void inAEnumerationLiteralSlotValues(AEnumerationLiteralSlotValues node)
      {
          defaultIn(node);
      }
  
      public void outAEnumerationLiteralSlotValues(AEnumerationLiteralSlotValues node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEnumerationLiteralSlotValues(AEnumerationLiteralSlotValues node)
      {
          inAEnumerationLiteralSlotValues(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getNamedSimpleValueList() != null)
          {
              node.getNamedSimpleValueList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outAEnumerationLiteralSlotValues(node);
      }
  
      public void inAPortDecl(APortDecl node)
      {
          defaultIn(node);
      }
  
      public void outAPortDecl(APortDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPortDecl(APortDecl node)
      {
          inAPortDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getPortConnector() != null)
          {
              node.getPortConnector().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getPort() != null)
          {
              node.getPort().apply(this);
          }
          if(node.getPortModifier() != null)
          {
              node.getPortModifier().apply(this);
          }
          outAPortDecl(node);
      }
  
      public void inAProvidedPortModifier(AProvidedPortModifier node)
      {
          defaultIn(node);
      }
  
      public void outAProvidedPortModifier(AProvidedPortModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAProvidedPortModifier(AProvidedPortModifier node)
      {
          inAProvidedPortModifier(node);
          if(node.getProvided() != null)
          {
              node.getProvided().apply(this);
          }
          outAProvidedPortModifier(node);
      }
  
      public void inARequiredPortModifier(ARequiredPortModifier node)
      {
          defaultIn(node);
      }
  
      public void outARequiredPortModifier(ARequiredPortModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARequiredPortModifier(ARequiredPortModifier node)
      {
          inARequiredPortModifier(node);
          if(node.getRequired() != null)
          {
              node.getRequired().apply(this);
          }
          outARequiredPortModifier(node);
      }
  
      public void inAPortConnector(APortConnector node)
      {
          defaultIn(node);
      }
  
      public void outAPortConnector(APortConnector node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPortConnector(APortConnector node)
      {
          inAPortConnector(node);
          if(node.getConnectorEndList() != null)
          {
              node.getConnectorEndList().apply(this);
          }
          if(node.getConnector() != null)
          {
              node.getConnector().apply(this);
          }
          outAPortConnector(node);
      }
  
      public void inAConnectorDecl(AConnectorDecl node)
      {
          defaultIn(node);
      }
  
      public void outAConnectorDecl(AConnectorDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConnectorDecl(AConnectorDecl node)
      {
          inAConnectorDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getConnectorEndList() != null)
          {
              node.getConnectorEndList().apply(this);
          }
          if(node.getConnector() != null)
          {
              node.getConnector().apply(this);
          }
          outAConnectorDecl(node);
      }
  
      public void inAConnectorEndList(AConnectorEndList node)
      {
          defaultIn(node);
      }
  
      public void outAConnectorEndList(AConnectorEndList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConnectorEndList(AConnectorEndList node)
      {
          inAConnectorEndList(node);
          if(node.getConnectorEndListTail() != null)
          {
              node.getConnectorEndListTail().apply(this);
          }
          if(node.getConnectorEnd() != null)
          {
              node.getConnectorEnd().apply(this);
          }
          outAConnectorEndList(node);
      }
  
      public void inAConnectorEndListTail(AConnectorEndListTail node)
      {
          defaultIn(node);
      }
  
      public void outAConnectorEndListTail(AConnectorEndListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAConnectorEndListTail(AConnectorEndListTail node)
      {
          inAConnectorEndListTail(node);
          if(node.getConnectorEndList() != null)
          {
              node.getConnectorEndList().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAConnectorEndListTail(node);
      }
  
      public void inAEmptyConnectorEndListTail(AEmptyConnectorEndListTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyConnectorEndListTail(AEmptyConnectorEndListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyConnectorEndListTail(AEmptyConnectorEndListTail node)
      {
          inAEmptyConnectorEndListTail(node);
          outAEmptyConnectorEndListTail(node);
      }
  
      public void inAPathConnectorEnd(APathConnectorEnd node)
      {
          defaultIn(node);
      }
  
      public void outAPathConnectorEnd(APathConnectorEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPathConnectorEnd(APathConnectorEnd node)
      {
          inAPathConnectorEnd(node);
          if(node.getPartOrPort() != null)
          {
              node.getPartOrPort().apply(this);
          }
          if(node.getDot() != null)
          {
              node.getDot().apply(this);
          }
          if(node.getPrefix() != null)
          {
              node.getPrefix().apply(this);
          }
          outAPathConnectorEnd(node);
      }
  
      public void inASimpleConnectorEnd(ASimpleConnectorEnd node)
      {
          defaultIn(node);
      }
  
      public void outASimpleConnectorEnd(ASimpleConnectorEnd node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleConnectorEnd(ASimpleConnectorEnd node)
      {
          inASimpleConnectorEnd(node);
          if(node.getPartOrPort() != null)
          {
              node.getPartOrPort().apply(this);
          }
          outASimpleConnectorEnd(node);
      }
  
      public void inAInvariantKernel(AInvariantKernel node)
      {
          defaultIn(node);
      }
  
      public void outAInvariantKernel(AInvariantKernel node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInvariantKernel(AInvariantKernel node)
      {
          inAInvariantKernel(node);
          if(node.getRegularInvariantConstraint() != null)
          {
              node.getRegularInvariantConstraint().apply(this);
          }
          outAInvariantKernel(node);
      }
  
      public void inAPermissionConstraintInvariantKernel(APermissionConstraintInvariantKernel node)
      {
          defaultIn(node);
      }
  
      public void outAPermissionConstraintInvariantKernel(APermissionConstraintInvariantKernel node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPermissionConstraintInvariantKernel(APermissionConstraintInvariantKernel node)
      {
          inAPermissionConstraintInvariantKernel(node);
          if(node.getPermissionConstraint() != null)
          {
              node.getPermissionConstraint().apply(this);
          }
          outAPermissionConstraintInvariantKernel(node);
      }
  
      public void inARegularInvariantConstraint(ARegularInvariantConstraint node)
      {
          defaultIn(node);
      }
  
      public void outARegularInvariantConstraint(ARegularInvariantConstraint node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARegularInvariantConstraint(ARegularInvariantConstraint node)
      {
          inARegularInvariantConstraint(node);
          if(node.getExpressionBlock() != null)
          {
              node.getExpressionBlock().apply(this);
          }
          if(node.getConstraintException() != null)
          {
              node.getConstraintException().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getInvariant() != null)
          {
              node.getInvariant().apply(this);
          }
          outARegularInvariantConstraint(node);
      }
  
      public void inAInvariantConstraintKeyword(AInvariantConstraintKeyword node)
      {
          defaultIn(node);
      }
  
      public void outAInvariantConstraintKeyword(AInvariantConstraintKeyword node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInvariantConstraintKeyword(AInvariantConstraintKeyword node)
      {
          inAInvariantConstraintKeyword(node);
          if(node.getInvariant() != null)
          {
              node.getInvariant().apply(this);
          }
          outAInvariantConstraintKeyword(node);
      }
  
      public void inAClassInvariantDecl(AClassInvariantDecl node)
      {
          defaultIn(node);
      }
  
      public void outAClassInvariantDecl(AClassInvariantDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassInvariantDecl(AClassInvariantDecl node)
      {
          inAClassInvariantDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getInvariantKernel() != null)
          {
              node.getInvariantKernel().apply(this);
          }
          outAClassInvariantDecl(node);
      }
  
      public void inAReferenceDecl(AReferenceDecl node)
      {
          defaultIn(node);
      }
  
      public void outAReferenceDecl(AReferenceDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReferenceDecl(AReferenceDecl node)
      {
          inAReferenceDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getOptionalOpposite() != null)
          {
              node.getOptionalOpposite().apply(this);
          }
          if(node.getOptionalSubsetting() != null)
          {
              node.getOptionalSubsetting().apply(this);
          }
          if(node.getOptionalQualifier() != null)
          {
              node.getOptionalQualifier().apply(this);
          }
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getReferenceType() != null)
          {
              node.getReferenceType().apply(this);
          }
          outAReferenceDecl(node);
      }
  
      public void inAOptionalOpposite(AOptionalOpposite node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalOpposite(AOptionalOpposite node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalOpposite(AOptionalOpposite node)
      {
          inAOptionalOpposite(node);
          if(node.getOtherEnd() != null)
          {
              node.getOtherEnd().apply(this);
          }
          if(node.getOpposite() != null)
          {
              node.getOpposite().apply(this);
          }
          outAOptionalOpposite(node);
      }
  
      public void inAEmptyOptionalOpposite(AEmptyOptionalOpposite node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyOptionalOpposite(AEmptyOptionalOpposite node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyOptionalOpposite(AEmptyOptionalOpposite node)
      {
          inAEmptyOptionalOpposite(node);
          outAEmptyOptionalOpposite(node);
      }
  
      public void inAAssociationReferenceType(AAssociationReferenceType node)
      {
          defaultIn(node);
      }
  
      public void outAAssociationReferenceType(AAssociationReferenceType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAssociationReferenceType(AAssociationReferenceType node)
      {
          inAAssociationReferenceType(node);
          if(node.getReference() != null)
          {
              node.getReference().apply(this);
          }
          outAAssociationReferenceType(node);
      }
  
      public void inACompositionReferenceType(ACompositionReferenceType node)
      {
          defaultIn(node);
      }
  
      public void outACompositionReferenceType(ACompositionReferenceType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACompositionReferenceType(ACompositionReferenceType node)
      {
          inACompositionReferenceType(node);
          if(node.getComposition() != null)
          {
              node.getComposition().apply(this);
          }
          outACompositionReferenceType(node);
      }
  
      public void inAAggregationReferenceType(AAggregationReferenceType node)
      {
          defaultIn(node);
      }
  
      public void outAAggregationReferenceType(AAggregationReferenceType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAggregationReferenceType(AAggregationReferenceType node)
      {
          inAAggregationReferenceType(node);
          if(node.getAggregation() != null)
          {
              node.getAggregation().apply(this);
          }
          outAAggregationReferenceType(node);
      }
  
      public void inADependencyDecl(ADependencyDecl node)
      {
          defaultIn(node);
      }
  
      public void outADependencyDecl(ADependencyDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADependencyDecl(ADependencyDecl node)
      {
          inADependencyDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getDependency() != null)
          {
              node.getDependency().apply(this);
          }
          outADependencyDecl(node);
      }
  
      public void inAOptionalSubsetting(AOptionalSubsetting node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalSubsetting(AOptionalSubsetting node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalSubsetting(AOptionalSubsetting node)
      {
          inAOptionalSubsetting(node);
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          if(node.getSubsets() != null)
          {
              node.getSubsets().apply(this);
          }
          outAOptionalSubsetting(node);
      }
  
      public void inAEmptyOptionalSubsetting(AEmptyOptionalSubsetting node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyOptionalSubsetting(AEmptyOptionalSubsetting node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyOptionalSubsetting(AEmptyOptionalSubsetting node)
      {
          inAEmptyOptionalSubsetting(node);
          outAEmptyOptionalSubsetting(node);
      }
  
      public void inAOptionalQualifier(AOptionalQualifier node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalQualifier(AOptionalQualifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalQualifier(AOptionalQualifier node)
      {
          inAOptionalQualifier(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getBy() != null)
          {
              node.getBy().apply(this);
          }
          outAOptionalQualifier(node);
      }
  
      public void inAFunctionDecl(AFunctionDecl node)
      {
          defaultIn(node);
      }
  
      public void outAFunctionDecl(AFunctionDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFunctionDecl(AFunctionDecl node)
      {
          inAFunctionDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getSimpleSignature() != null)
          {
              node.getSimpleSignature().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getFunction() != null)
          {
              node.getFunction().apply(this);
          }
          outAFunctionDecl(node);
      }
  
      public void inATupleType(ATupleType node)
      {
          defaultIn(node);
      }
  
      public void outATupleType(ATupleType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleType(ATupleType node)
      {
          inATupleType(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          if(node.getTupleTypeSlotTail() != null)
          {
              node.getTupleTypeSlotTail().apply(this);
          }
          if(node.getTupleTypeSlot() != null)
          {
              node.getTupleTypeSlot().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outATupleType(node);
      }
  
      public void inATupleTypeSlot(ATupleTypeSlot node)
      {
          defaultIn(node);
      }
  
      public void outATupleTypeSlot(ATupleTypeSlot node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleTypeSlot(ATupleTypeSlot node)
      {
          inATupleTypeSlot(node);
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outATupleTypeSlot(node);
      }
  
      public void inATupleTypeSlotTail(ATupleTypeSlotTail node)
      {
          defaultIn(node);
      }
  
      public void outATupleTypeSlotTail(ATupleTypeSlotTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleTypeSlotTail(ATupleTypeSlotTail node)
      {
          inATupleTypeSlotTail(node);
          if(node.getTupleTypeSlotTail() != null)
          {
              node.getTupleTypeSlotTail().apply(this);
          }
          if(node.getTupleTypeSlot() != null)
          {
              node.getTupleTypeSlot().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outATupleTypeSlotTail(node);
      }
  
      public void inAEmptyTupleTypeSlotTail(AEmptyTupleTypeSlotTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyTupleTypeSlotTail(AEmptyTupleTypeSlotTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyTupleTypeSlotTail(AEmptyTupleTypeSlotTail node)
      {
          inAEmptyTupleTypeSlotTail(node);
          outAEmptyTupleTypeSlotTail(node);
      }
  
      public void inAFunctionSignature(AFunctionSignature node)
      {
          defaultIn(node);
      }
  
      public void outAFunctionSignature(AFunctionSignature node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFunctionSignature(AFunctionSignature node)
      {
          inAFunctionSignature(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          if(node.getSimpleSignature() != null)
          {
              node.getSimpleSignature().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outAFunctionSignature(node);
      }
  
      public void inASignature(ASignature node)
      {
          defaultIn(node);
      }
  
      public void outASignature(ASignature node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASignature(ASignature node)
      {
          inASignature(node);
          {
              List<PParametersetDecl> copy = new ArrayList<PParametersetDecl>(node.getParametersetDecl());
              Collections.reverse(copy);
              for(PParametersetDecl e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getOptionalRaisesSection() != null)
          {
              node.getOptionalRaisesSection().apply(this);
          }
          if(node.getOptionalReturnType() != null)
          {
              node.getOptionalReturnType().apply(this);
          }
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getParamDeclList() != null)
          {
              node.getParamDeclList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outASignature(node);
      }
  
      public void inASimpleSignature(ASimpleSignature node)
      {
          defaultIn(node);
      }
  
      public void outASimpleSignature(ASimpleSignature node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleSignature(ASimpleSignature node)
      {
          inASimpleSignature(node);
          if(node.getSimpleOptionalReturnType() != null)
          {
              node.getSimpleOptionalReturnType().apply(this);
          }
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getSimpleParamDeclList() != null)
          {
              node.getSimpleParamDeclList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outASimpleSignature(node);
      }
  
      public void inAOptionalReturnType(AOptionalReturnType node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalReturnType(AOptionalReturnType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalReturnType(AOptionalReturnType node)
      {
          inAOptionalReturnType(node);
          if(node.getSimpleOptionalReturnType() != null)
          {
              node.getSimpleOptionalReturnType().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAOptionalReturnType(node);
      }
  
      public void inASimpleOptionalReturnType(ASimpleOptionalReturnType node)
      {
          defaultIn(node);
      }
  
      public void outASimpleOptionalReturnType(ASimpleOptionalReturnType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleOptionalReturnType(ASimpleOptionalReturnType node)
      {
          inASimpleOptionalReturnType(node);
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          outASimpleOptionalReturnType(node);
      }
  
      public void inAParamDeclList(AParamDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAParamDeclList(AParamDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParamDeclList(AParamDeclList node)
      {
          inAParamDeclList(node);
          if(node.getParamDeclListTail() != null)
          {
              node.getParamDeclListTail().apply(this);
          }
          if(node.getParamDecl() != null)
          {
              node.getParamDecl().apply(this);
          }
          outAParamDeclList(node);
      }
  
      public void inAEmptyParamDeclList(AEmptyParamDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyParamDeclList(AEmptyParamDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyParamDeclList(AEmptyParamDeclList node)
      {
          inAEmptyParamDeclList(node);
          outAEmptyParamDeclList(node);
      }
  
      public void inASimpleParamDeclList(ASimpleParamDeclList node)
      {
          defaultIn(node);
      }
  
      public void outASimpleParamDeclList(ASimpleParamDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleParamDeclList(ASimpleParamDeclList node)
      {
          inASimpleParamDeclList(node);
          if(node.getSimpleParamDeclListTail() != null)
          {
              node.getSimpleParamDeclListTail().apply(this);
          }
          if(node.getSimpleParamDecl() != null)
          {
              node.getSimpleParamDecl().apply(this);
          }
          outASimpleParamDeclList(node);
      }
  
      public void inAEmptySimpleParamDeclList(AEmptySimpleParamDeclList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptySimpleParamDeclList(AEmptySimpleParamDeclList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptySimpleParamDeclList(AEmptySimpleParamDeclList node)
      {
          inAEmptySimpleParamDeclList(node);
          outAEmptySimpleParamDeclList(node);
      }
  
      public void inAParamDeclListTail(AParamDeclListTail node)
      {
          defaultIn(node);
      }
  
      public void outAParamDeclListTail(AParamDeclListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParamDeclListTail(AParamDeclListTail node)
      {
          inAParamDeclListTail(node);
          if(node.getParamDeclListTail() != null)
          {
              node.getParamDeclListTail().apply(this);
          }
          if(node.getParamDecl() != null)
          {
              node.getParamDecl().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAParamDeclListTail(node);
      }
  
      public void inAEmptyParamDeclListTail(AEmptyParamDeclListTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyParamDeclListTail(AEmptyParamDeclListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyParamDeclListTail(AEmptyParamDeclListTail node)
      {
          inAEmptyParamDeclListTail(node);
          outAEmptyParamDeclListTail(node);
      }
  
      public void inASimpleParamDeclListTail(ASimpleParamDeclListTail node)
      {
          defaultIn(node);
      }
  
      public void outASimpleParamDeclListTail(ASimpleParamDeclListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleParamDeclListTail(ASimpleParamDeclListTail node)
      {
          inASimpleParamDeclListTail(node);
          if(node.getSimpleParamDeclListTail() != null)
          {
              node.getSimpleParamDeclListTail().apply(this);
          }
          if(node.getSimpleParamDecl() != null)
          {
              node.getSimpleParamDecl().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outASimpleParamDeclListTail(node);
      }
  
      public void inAEmptySimpleParamDeclListTail(AEmptySimpleParamDeclListTail node)
      {
          defaultIn(node);
      }
  
      public void outAEmptySimpleParamDeclListTail(AEmptySimpleParamDeclListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptySimpleParamDeclListTail(AEmptySimpleParamDeclListTail node)
      {
          inAEmptySimpleParamDeclListTail(node);
          outAEmptySimpleParamDeclListTail(node);
      }
  
      public void inAParamDecl(AParamDecl node)
      {
          defaultIn(node);
      }
  
      public void outAParamDecl(AParamDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParamDecl(AParamDecl node)
      {
          inAParamDecl(node);
          if(node.getSimpleParamDecl() != null)
          {
              node.getSimpleParamDecl().apply(this);
          }
          if(node.getParameterModifiers() != null)
          {
              node.getParameterModifiers().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAParamDecl(node);
      }
  
      public void inASimpleParamDecl(ASimpleParamDecl node)
      {
          defaultIn(node);
      }
  
      public void outASimpleParamDecl(ASimpleParamDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleParamDecl(ASimpleParamDecl node)
      {
          inASimpleParamDecl(node);
          if(node.getInitializationExpression() != null)
          {
              node.getInitializationExpression().apply(this);
          }
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getOptionalParameterName() != null)
          {
              node.getOptionalParameterName().apply(this);
          }
          outASimpleParamDecl(node);
      }
  
      public void inAOptionalParameterName(AOptionalParameterName node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalParameterName(AOptionalParameterName node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalParameterName(AOptionalParameterName node)
      {
          inAOptionalParameterName(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAOptionalParameterName(node);
      }
  
      public void inAParameterModifiers(AParameterModifiers node)
      {
          defaultIn(node);
      }
  
      public void outAParameterModifiers(AParameterModifiers node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParameterModifiers(AParameterModifiers node)
      {
          inAParameterModifiers(node);
          if(node.getParameterModifierList() != null)
          {
              node.getParameterModifierList().apply(this);
          }
          outAParameterModifiers(node);
      }
  
      public void inAParameterModifierList(AParameterModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAParameterModifierList(AParameterModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParameterModifierList(AParameterModifierList node)
      {
          inAParameterModifierList(node);
          if(node.getParameterModifierList() != null)
          {
              node.getParameterModifierList().apply(this);
          }
          if(node.getParameterModifier() != null)
          {
              node.getParameterModifier().apply(this);
          }
          outAParameterModifierList(node);
      }
  
      public void inAEmptyParameterModifierList(AEmptyParameterModifierList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyParameterModifierList(AEmptyParameterModifierList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyParameterModifierList(AEmptyParameterModifierList node)
      {
          inAEmptyParameterModifierList(node);
          outAEmptyParameterModifierList(node);
      }
  
      public void inAInParameterModifier(AInParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outAInParameterModifier(AInParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInParameterModifier(AInParameterModifier node)
      {
          inAInParameterModifier(node);
          if(node.getIn() != null)
          {
              node.getIn().apply(this);
          }
          outAInParameterModifier(node);
      }
  
      public void inAOutParameterModifier(AOutParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outAOutParameterModifier(AOutParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOutParameterModifier(AOutParameterModifier node)
      {
          inAOutParameterModifier(node);
          if(node.getOut() != null)
          {
              node.getOut().apply(this);
          }
          outAOutParameterModifier(node);
      }
  
      public void inAInoutParameterModifier(AInoutParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outAInoutParameterModifier(AInoutParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInoutParameterModifier(AInoutParameterModifier node)
      {
          inAInoutParameterModifier(node);
          if(node.getInout() != null)
          {
              node.getInout().apply(this);
          }
          outAInoutParameterModifier(node);
      }
  
      public void inAReadParameterModifier(AReadParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outAReadParameterModifier(AReadParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAReadParameterModifier(AReadParameterModifier node)
      {
          inAReadParameterModifier(node);
          if(node.getRead() != null)
          {
              node.getRead().apply(this);
          }
          outAReadParameterModifier(node);
      }
  
      public void inACreateParameterModifier(ACreateParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outACreateParameterModifier(ACreateParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACreateParameterModifier(ACreateParameterModifier node)
      {
          inACreateParameterModifier(node);
          if(node.getCreate() != null)
          {
              node.getCreate().apply(this);
          }
          outACreateParameterModifier(node);
      }
  
      public void inAUpdateParameterModifier(AUpdateParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outAUpdateParameterModifier(AUpdateParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAUpdateParameterModifier(AUpdateParameterModifier node)
      {
          inAUpdateParameterModifier(node);
          if(node.getUpdate() != null)
          {
              node.getUpdate().apply(this);
          }
          outAUpdateParameterModifier(node);
      }
  
      public void inADeleteParameterModifier(ADeleteParameterModifier node)
      {
          defaultIn(node);
      }
  
      public void outADeleteParameterModifier(ADeleteParameterModifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADeleteParameterModifier(ADeleteParameterModifier node)
      {
          inADeleteParameterModifier(node);
          if(node.getDelete() != null)
          {
              node.getDelete().apply(this);
          }
          outADeleteParameterModifier(node);
      }
  
      public void inAOptionalRaisesSection(AOptionalRaisesSection node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalRaisesSection(AOptionalRaisesSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalRaisesSection(AOptionalRaisesSection node)
      {
          inAOptionalRaisesSection(node);
          if(node.getRaisedExceptionList() != null)
          {
              node.getRaisedExceptionList().apply(this);
          }
          if(node.getRaises() != null)
          {
              node.getRaises().apply(this);
          }
          outAOptionalRaisesSection(node);
      }
  
      public void inARaisedExceptionList(ARaisedExceptionList node)
      {
          defaultIn(node);
      }
  
      public void outARaisedExceptionList(ARaisedExceptionList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARaisedExceptionList(ARaisedExceptionList node)
      {
          inARaisedExceptionList(node);
          {
              List<PRaisedExceptionListTail> copy = new ArrayList<PRaisedExceptionListTail>(node.getRaisedExceptionListTail());
              Collections.reverse(copy);
              for(PRaisedExceptionListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getRaisedExceptionItem() != null)
          {
              node.getRaisedExceptionItem().apply(this);
          }
          outARaisedExceptionList(node);
      }
  
      public void inARaisedExceptionListTail(ARaisedExceptionListTail node)
      {
          defaultIn(node);
      }
  
      public void outARaisedExceptionListTail(ARaisedExceptionListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARaisedExceptionListTail(ARaisedExceptionListTail node)
      {
          inARaisedExceptionListTail(node);
          if(node.getRaisedExceptionItem() != null)
          {
              node.getRaisedExceptionItem().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outARaisedExceptionListTail(node);
      }
  
      public void inARaisedExceptionItem(ARaisedExceptionItem node)
      {
          defaultIn(node);
      }
  
      public void outARaisedExceptionItem(ARaisedExceptionItem node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARaisedExceptionItem(ARaisedExceptionItem node)
      {
          inARaisedExceptionItem(node);
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outARaisedExceptionItem(node);
      }
  
      public void inAAnnotations(AAnnotations node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotations(AAnnotations node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotations(AAnnotations node)
      {
          inAAnnotations(node);
          if(node.getRBracket() != null)
          {
              node.getRBracket().apply(this);
          }
          if(node.getAnnotationList() != null)
          {
              node.getAnnotationList().apply(this);
          }
          if(node.getLBracket() != null)
          {
              node.getLBracket().apply(this);
          }
          outAAnnotations(node);
      }
  
      public void inAAnnotationsWithBrackets(AAnnotationsWithBrackets node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationsWithBrackets(AAnnotationsWithBrackets node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationsWithBrackets(AAnnotationsWithBrackets node)
      {
          inAAnnotationsWithBrackets(node);
          if(node.getRBracket() != null)
          {
              node.getRBracket().apply(this);
          }
          if(node.getAnnotationList() != null)
          {
              node.getAnnotationList().apply(this);
          }
          if(node.getLBracket() != null)
          {
              node.getLBracket().apply(this);
          }
          outAAnnotationsWithBrackets(node);
      }
  
      public void inAAnnotationsWithGuillemots(AAnnotationsWithGuillemots node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationsWithGuillemots(AAnnotationsWithGuillemots node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationsWithGuillemots(AAnnotationsWithGuillemots node)
      {
          inAAnnotationsWithGuillemots(node);
          if(node.getRGuillemot() != null)
          {
              node.getRGuillemot().apply(this);
          }
          if(node.getAnnotationList() != null)
          {
              node.getAnnotationList().apply(this);
          }
          if(node.getLGuillemot() != null)
          {
              node.getLGuillemot().apply(this);
          }
          outAAnnotationsWithGuillemots(node);
      }
  
      public void inAAnnotationList(AAnnotationList node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationList(AAnnotationList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationList(AAnnotationList node)
      {
          inAAnnotationList(node);
          {
              List<PAnnotationListTail> copy = new ArrayList<PAnnotationListTail>(node.getAnnotationListTail());
              Collections.reverse(copy);
              for(PAnnotationListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getAnnotation() != null)
          {
              node.getAnnotation().apply(this);
          }
          outAAnnotationList(node);
      }
  
      public void inAAnnotationListTail(AAnnotationListTail node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationListTail(AAnnotationListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationListTail(AAnnotationListTail node)
      {
          inAAnnotationListTail(node);
          if(node.getAnnotation() != null)
          {
              node.getAnnotation().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAAnnotationListTail(node);
      }
  
      public void inAAnnotation(AAnnotation node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotation(AAnnotation node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotation(AAnnotation node)
      {
          inAAnnotation(node);
          if(node.getAnnotationOptionalValueSpecs() != null)
          {
              node.getAnnotationOptionalValueSpecs().apply(this);
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          outAAnnotation(node);
      }
  
      public void inAAnnotationOptionalValueSpecs(AAnnotationOptionalValueSpecs node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationOptionalValueSpecs(AAnnotationOptionalValueSpecs node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationOptionalValueSpecs(AAnnotationOptionalValueSpecs node)
      {
          inAAnnotationOptionalValueSpecs(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getAnnotationValueSpecList() != null)
          {
              node.getAnnotationValueSpecList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outAAnnotationOptionalValueSpecs(node);
      }
  
      public void inAAnnotationValueSpecList(AAnnotationValueSpecList node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationValueSpecList(AAnnotationValueSpecList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationValueSpecList(AAnnotationValueSpecList node)
      {
          inAAnnotationValueSpecList(node);
          {
              List<PAnnotationValueSpecListTail> copy = new ArrayList<PAnnotationValueSpecListTail>(node.getAnnotationValueSpecListTail());
              Collections.reverse(copy);
              for(PAnnotationValueSpecListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getAnnotationValueSpec() != null)
          {
              node.getAnnotationValueSpec().apply(this);
          }
          outAAnnotationValueSpecList(node);
      }
  
      public void inAAnnotationValueSpecListTail(AAnnotationValueSpecListTail node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationValueSpecListTail(AAnnotationValueSpecListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationValueSpecListTail(AAnnotationValueSpecListTail node)
      {
          inAAnnotationValueSpecListTail(node);
          if(node.getAnnotationValueSpec() != null)
          {
              node.getAnnotationValueSpec().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAAnnotationValueSpecListTail(node);
      }
  
      public void inAAnnotationValueSpec(AAnnotationValueSpec node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationValueSpec(AAnnotationValueSpec node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationValueSpec(AAnnotationValueSpec node)
      {
          inAAnnotationValueSpec(node);
          if(node.getAnnotationValue() != null)
          {
              node.getAnnotationValue().apply(this);
          }
          if(node.getEquals() != null)
          {
              node.getEquals().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAAnnotationValueSpec(node);
      }
  
      public void inAAnnotationValue(AAnnotationValue node)
      {
          defaultIn(node);
      }
  
      public void outAAnnotationValue(AAnnotationValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAnnotationValue(AAnnotationValue node)
      {
          inAAnnotationValue(node);
          if(node.getLiteral() != null)
          {
              node.getLiteral().apply(this);
          }
          outAAnnotationValue(node);
      }
  
      public void inAEnumeratedAnnotationValue(AEnumeratedAnnotationValue node)
      {
          defaultIn(node);
      }
  
      public void outAEnumeratedAnnotationValue(AEnumeratedAnnotationValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEnumeratedAnnotationValue(AEnumeratedAnnotationValue node)
      {
          inAEnumeratedAnnotationValue(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAEnumeratedAnnotationValue(node);
      }
  
      public void inAStereotypeDef(AStereotypeDef node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeDef(AStereotypeDef node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeDef(AStereotypeDef node)
      {
          inAStereotypeDef(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          {
              List<PStereotypePropertyDecl> copy = new ArrayList<PStereotypePropertyDecl>(node.getStereotypePropertyDecl());
              Collections.reverse(copy);
              for(PStereotypePropertyDecl e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getStereotypeDefHeader() != null)
          {
              node.getStereotypeDefHeader().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAStereotypeDef(node);
      }
  
      public void inAStereotypeDefHeader(AStereotypeDefHeader node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeDefHeader(AStereotypeDefHeader node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeDefHeader(AStereotypeDefHeader node)
      {
          inAStereotypeDefHeader(node);
          if(node.getClassSpecializesSection() != null)
          {
              node.getClassSpecializesSection().apply(this);
          }
          if(node.getStereotypeExtendsSection() != null)
          {
              node.getStereotypeExtendsSection().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getStereotype() != null)
          {
              node.getStereotype().apply(this);
          }
          if(node.getAbstract() != null)
          {
              node.getAbstract().apply(this);
          }
          outAStereotypeDefHeader(node);
      }
  
      public void inAStereotypeExtendsSection(AStereotypeExtendsSection node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeExtendsSection(AStereotypeExtendsSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeExtendsSection(AStereotypeExtendsSection node)
      {
          inAStereotypeExtendsSection(node);
          if(node.getStereotypeExtensionList() != null)
          {
              node.getStereotypeExtensionList().apply(this);
          }
          if(node.getExtends() != null)
          {
              node.getExtends().apply(this);
          }
          outAStereotypeExtendsSection(node);
      }
  
      public void inAEmptyStereotypeExtendsSection(AEmptyStereotypeExtendsSection node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyStereotypeExtendsSection(AEmptyStereotypeExtendsSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyStereotypeExtendsSection(AEmptyStereotypeExtendsSection node)
      {
          inAEmptyStereotypeExtendsSection(node);
          outAEmptyStereotypeExtendsSection(node);
      }
  
      public void inAStereotypeExtensionList(AStereotypeExtensionList node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeExtensionList(AStereotypeExtensionList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeExtensionList(AStereotypeExtensionList node)
      {
          inAStereotypeExtensionList(node);
          {
              List<PStereotypeExtensionListTail> copy = new ArrayList<PStereotypeExtensionListTail>(node.getStereotypeExtensionListTail());
              Collections.reverse(copy);
              for(PStereotypeExtensionListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getStereotypeExtension() != null)
          {
              node.getStereotypeExtension().apply(this);
          }
          outAStereotypeExtensionList(node);
      }
  
      public void inAStereotypeExtensionListTail(AStereotypeExtensionListTail node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeExtensionListTail(AStereotypeExtensionListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeExtensionListTail(AStereotypeExtensionListTail node)
      {
          inAStereotypeExtensionListTail(node);
          if(node.getStereotypeExtension() != null)
          {
              node.getStereotypeExtension().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAStereotypeExtensionListTail(node);
      }
  
      public void inAStereotypeExtension(AStereotypeExtension node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypeExtension(AStereotypeExtension node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypeExtension(AStereotypeExtension node)
      {
          inAStereotypeExtension(node);
          if(node.getRequired() != null)
          {
              node.getRequired().apply(this);
          }
          if(node.getQualifiedIdentifier() != null)
          {
              node.getQualifiedIdentifier().apply(this);
          }
          outAStereotypeExtension(node);
      }
  
      public void inAStereotypePropertyDecl(AStereotypePropertyDecl node)
      {
          defaultIn(node);
      }
  
      public void outAStereotypePropertyDecl(AStereotypePropertyDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStereotypePropertyDecl(AStereotypePropertyDecl node)
      {
          inAStereotypePropertyDecl(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getOptionalDefault() != null)
          {
              node.getOptionalDefault().apply(this);
          }
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getProperty() != null)
          {
              node.getProperty().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outAStereotypePropertyDecl(node);
      }
  
      public void inAOptionalDefault(AOptionalDefault node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalDefault(AOptionalDefault node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalDefault(AOptionalDefault node)
      {
          inAOptionalDefault(node);
          if(node.getLiteral() != null)
          {
              node.getLiteral().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          outAOptionalDefault(node);
      }
  
      public void inAEmptyOptionalDefault(AEmptyOptionalDefault node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyOptionalDefault(AEmptyOptionalDefault node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyOptionalDefault(AEmptyOptionalDefault node)
      {
          inAEmptyOptionalDefault(node);
          outAEmptyOptionalDefault(node);
      }
  
      public void inAPrimitiveDef(APrimitiveDef node)
      {
          defaultIn(node);
      }
  
      public void outAPrimitiveDef(APrimitiveDef node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPrimitiveDef(APrimitiveDef node)
      {
          inAPrimitiveDef(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getPrimitive() != null)
          {
              node.getPrimitive().apply(this);
          }
          if(node.getVisibilityModifier() != null)
          {
              node.getVisibilityModifier().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAPrimitiveDef(node);
      }
  
      public void inADetachedOperationDef(ADetachedOperationDef node)
      {
          defaultIn(node);
      }
  
      public void outADetachedOperationDef(ADetachedOperationDef node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADetachedOperationDef(ADetachedOperationDef node)
      {
          inADetachedOperationDef(node);
          if(node.getBehavioralFeatureBody() != null)
          {
              node.getBehavioralFeatureBody().apply(this);
          }
          if(node.getDetachedOperationHeader() != null)
          {
              node.getDetachedOperationHeader().apply(this);
          }
          outADetachedOperationDef(node);
      }
  
      public void inADetachedOperationHeader(ADetachedOperationHeader node)
      {
          defaultIn(node);
      }
  
      public void outADetachedOperationHeader(ADetachedOperationHeader node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADetachedOperationHeader(ADetachedOperationHeader node)
      {
          inADetachedOperationHeader(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getDot() != null)
          {
              node.getDot().apply(this);
          }
          if(node.getType() != null)
          {
              node.getType().apply(this);
          }
          if(node.getOperation() != null)
          {
              node.getOperation().apply(this);
          }
          outADetachedOperationHeader(node);
      }
  
      public void inASimpleBlock(ASimpleBlock node)
      {
          defaultIn(node);
      }
  
      public void outASimpleBlock(ASimpleBlock node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleBlock(ASimpleBlock node)
      {
          inASimpleBlock(node);
          if(node.getSimpleBlockResolved() != null)
          {
              node.getSimpleBlockResolved().apply(this);
          }
          outASimpleBlock(node);
      }
  
      public void inAExpressionSimpleBlockResolved(AExpressionSimpleBlockResolved node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionSimpleBlockResolved(AExpressionSimpleBlockResolved node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionSimpleBlockResolved(AExpressionSimpleBlockResolved node)
      {
          inAExpressionSimpleBlockResolved(node);
          if(node.getSimpleExpressionBlock() != null)
          {
              node.getSimpleExpressionBlock().apply(this);
          }
          outAExpressionSimpleBlockResolved(node);
      }
  
      public void inAStatementSimpleBlockResolved(AStatementSimpleBlockResolved node)
      {
          defaultIn(node);
      }
  
      public void outAStatementSimpleBlockResolved(AStatementSimpleBlockResolved node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStatementSimpleBlockResolved(AStatementSimpleBlockResolved node)
      {
          inAStatementSimpleBlockResolved(node);
          if(node.getSimpleStatementBlock() != null)
          {
              node.getSimpleStatementBlock().apply(this);
          }
          outAStatementSimpleBlockResolved(node);
      }
  
      public void inASimpleExpressionBlock(ASimpleExpressionBlock node)
      {
          defaultIn(node);
      }
  
      public void outASimpleExpressionBlock(ASimpleExpressionBlock node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleExpressionBlock(ASimpleExpressionBlock node)
      {
          inASimpleExpressionBlock(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outASimpleExpressionBlock(node);
      }
  
      public void inASimpleStatementBlock(ASimpleStatementBlock node)
      {
          defaultIn(node);
      }
  
      public void outASimpleStatementBlock(ASimpleStatementBlock node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleStatementBlock(ASimpleStatementBlock node)
      {
          inASimpleStatementBlock(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          if(node.getBlockKernel() != null)
          {
              node.getBlockKernel().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outASimpleStatementBlock(node);
      }
  
      public void inAWordyBlock(AWordyBlock node)
      {
          defaultIn(node);
      }
  
      public void outAWordyBlock(AWordyBlock node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWordyBlock(AWordyBlock node)
      {
          inAWordyBlock(node);
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getBlockKernel() != null)
          {
              node.getBlockKernel().apply(this);
          }
          if(node.getBegin() != null)
          {
              node.getBegin().apply(this);
          }
          outAWordyBlock(node);
      }
  
      public void inAExpressionBlock(AExpressionBlock node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionBlock(AExpressionBlock node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionBlock(AExpressionBlock node)
      {
          inAExpressionBlock(node);
          if(node.getSimpleBlock() != null)
          {
              node.getSimpleBlock().apply(this);
          }
          outAExpressionBlock(node);
      }
  
      public void inABlockKernel(ABlockKernel node)
      {
          defaultIn(node);
      }
  
      public void outABlockKernel(ABlockKernel node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABlockKernel(ABlockKernel node)
      {
          inABlockKernel(node);
          if(node.getStatementSequence() != null)
          {
              node.getStatementSequence().apply(this);
          }
          if(node.getVarDeclSection() != null)
          {
              node.getVarDeclSection().apply(this);
          }
          if(node.getModelComment() != null)
          {
              node.getModelComment().apply(this);
          }
          outABlockKernel(node);
      }
  
      public void inAVarDeclSection(AVarDeclSection node)
      {
          defaultIn(node);
      }
  
      public void outAVarDeclSection(AVarDeclSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVarDeclSection(AVarDeclSection node)
      {
          inAVarDeclSection(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          {
              List<PVarListTail> copy = new ArrayList<PVarListTail>(node.getVarListTail());
              Collections.reverse(copy);
              for(PVarListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getVarDecl() != null)
          {
              node.getVarDecl().apply(this);
          }
          if(node.getVar() != null)
          {
              node.getVar().apply(this);
          }
          outAVarDeclSection(node);
      }
  
      public void inAEmptyVarDeclSection(AEmptyVarDeclSection node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyVarDeclSection(AEmptyVarDeclSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyVarDeclSection(AEmptyVarDeclSection node)
      {
          inAEmptyVarDeclSection(node);
          outAEmptyVarDeclSection(node);
      }
  
      public void inAVarDecl(AVarDecl node)
      {
          defaultIn(node);
      }
  
      public void outAVarDecl(AVarDecl node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVarDecl(AVarDecl node)
      {
          inAVarDecl(node);
          if(node.getOptionalType() != null)
          {
              node.getOptionalType().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAVarDecl(node);
      }
  
      public void inAOptionalType(AOptionalType node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalType(AOptionalType node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalType(AOptionalType node)
      {
          inAOptionalType(node);
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          outAOptionalType(node);
      }
  
      public void inAVarListTail(AVarListTail node)
      {
          defaultIn(node);
      }
  
      public void outAVarListTail(AVarListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVarListTail(AVarListTail node)
      {
          inAVarListTail(node);
          if(node.getVarDecl() != null)
          {
              node.getVarDecl().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAVarListTail(node);
      }
  
      public void inAStatementSequence(AStatementSequence node)
      {
          defaultIn(node);
      }
  
      public void outAStatementSequence(AStatementSequence node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStatementSequence(AStatementSequence node)
      {
          inAStatementSequence(node);
          {
              List<PStatement> copy = new ArrayList<PStatement>(node.getStatement());
              Collections.reverse(copy);
              for(PStatement e : copy)
              {
                  e.apply(this);
              }
          }
          outAStatementSequence(node);
      }
  
      public void inAStatement(AStatement node)
      {
          defaultIn(node);
      }
  
      public void outAStatement(AStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStatement(AStatement node)
      {
          inAStatement(node);
          if(node.getSemicolon() != null)
          {
              node.getSemicolon().apply(this);
          }
          if(node.getStatementResolved() != null)
          {
              node.getStatementResolved().apply(this);
          }
          if(node.getAnnotations() != null)
          {
              node.getAnnotations().apply(this);
          }
          outAStatement(node);
      }
  
      public void inANoIfStatementResolved(ANoIfStatementResolved node)
      {
          defaultIn(node);
      }
  
      public void outANoIfStatementResolved(ANoIfStatementResolved node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANoIfStatementResolved(ANoIfStatementResolved node)
      {
          inANoIfStatementResolved(node);
          if(node.getNonIfStatement() != null)
          {
              node.getNonIfStatement().apply(this);
          }
          outANoIfStatementResolved(node);
      }
  
      public void inAWithIfStatementResolved(AWithIfStatementResolved node)
      {
          defaultIn(node);
      }
  
      public void outAWithIfStatementResolved(AWithIfStatementResolved node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWithIfStatementResolved(AWithIfStatementResolved node)
      {
          inAWithIfStatementResolved(node);
          if(node.getIfStatement() != null)
          {
              node.getIfStatement().apply(this);
          }
          outAWithIfStatementResolved(node);
      }
  
      public void inABlockNonIfStatement(ABlockNonIfStatement node)
      {
          defaultIn(node);
      }
  
      public void outABlockNonIfStatement(ABlockNonIfStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABlockNonIfStatement(ABlockNonIfStatement node)
      {
          inABlockNonIfStatement(node);
          if(node.getWordyBlock() != null)
          {
              node.getWordyBlock().apply(this);
          }
          outABlockNonIfStatement(node);
      }
  
      public void inANonBlockNonIfStatement(ANonBlockNonIfStatement node)
      {
          defaultIn(node);
      }
  
      public void outANonBlockNonIfStatement(ANonBlockNonIfStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANonBlockNonIfStatement(ANonBlockNonIfStatement node)
      {
          inANonBlockNonIfStatement(node);
          if(node.getSpecificStatement() != null)
          {
              node.getSpecificStatement().apply(this);
          }
          outANonBlockNonIfStatement(node);
      }
  
      public void inAWriteClassAttributeSpecificStatement(AWriteClassAttributeSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAWriteClassAttributeSpecificStatement(AWriteClassAttributeSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWriteClassAttributeSpecificStatement(AWriteClassAttributeSpecificStatement node)
      {
          inAWriteClassAttributeSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getHash() != null)
          {
              node.getHash().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAWriteClassAttributeSpecificStatement(node);
      }
  
      public void inAWriteAttributeSpecificStatement(AWriteAttributeSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAWriteAttributeSpecificStatement(AWriteAttributeSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWriteAttributeSpecificStatement(AWriteAttributeSpecificStatement node)
      {
          inAWriteAttributeSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getTarget() != null)
          {
              node.getTarget().apply(this);
          }
          outAWriteAttributeSpecificStatement(node);
      }
  
      public void inAWriteVariableSpecificStatement(AWriteVariableSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAWriteVariableSpecificStatement(AWriteVariableSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWriteVariableSpecificStatement(AWriteVariableSpecificStatement node)
      {
          inAWriteVariableSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAWriteVariableSpecificStatement(node);
      }
  
      public void inAExpressionSpecificStatement(AExpressionSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionSpecificStatement(AExpressionSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionSpecificStatement(AExpressionSpecificStatement node)
      {
          inAExpressionSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          outAExpressionSpecificStatement(node);
      }
  
      public void inAEmptyReturnSpecificStatement(AEmptyReturnSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyReturnSpecificStatement(AEmptyReturnSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyReturnSpecificStatement(AEmptyReturnSpecificStatement node)
      {
          inAEmptyReturnSpecificStatement(node);
          if(node.getReturn() != null)
          {
              node.getReturn().apply(this);
          }
          outAEmptyReturnSpecificStatement(node);
      }
  
      public void inAValuedReturnSpecificStatement(AValuedReturnSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAValuedReturnSpecificStatement(AValuedReturnSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAValuedReturnSpecificStatement(AValuedReturnSpecificStatement node)
      {
          inAValuedReturnSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getReturn() != null)
          {
              node.getReturn().apply(this);
          }
          outAValuedReturnSpecificStatement(node);
      }
  
      public void inALoopSpecificStatement(ALoopSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outALoopSpecificStatement(ALoopSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALoopSpecificStatement(ALoopSpecificStatement node)
      {
          inALoopSpecificStatement(node);
          if(node.getLoopStatement() != null)
          {
              node.getLoopStatement().apply(this);
          }
          outALoopSpecificStatement(node);
      }
  
      public void inALinkSpecificStatement(ALinkSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outALinkSpecificStatement(ALinkSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALinkSpecificStatement(ALinkSpecificStatement node)
      {
          inALinkSpecificStatement(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getRole2() != null)
          {
              node.getRole2().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          if(node.getRole1() != null)
          {
              node.getRole1().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getLink() != null)
          {
              node.getLink().apply(this);
          }
          outALinkSpecificStatement(node);
      }
  
      public void inAUnlinkSpecificStatement(AUnlinkSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outAUnlinkSpecificStatement(AUnlinkSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAUnlinkSpecificStatement(AUnlinkSpecificStatement node)
      {
          inAUnlinkSpecificStatement(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getRole2() != null)
          {
              node.getRole2().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          if(node.getRole1() != null)
          {
              node.getRole1().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getUnlink() != null)
          {
              node.getUnlink().apply(this);
          }
          outAUnlinkSpecificStatement(node);
      }
  
      public void inASendSpecificStatement(ASendSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outASendSpecificStatement(ASendSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASendSpecificStatement(ASendSpecificStatement node)
      {
          inASendSpecificStatement(node);
          if(node.getTarget() != null)
          {
              node.getTarget().apply(this);
          }
          if(node.getTo() != null)
          {
              node.getTo().apply(this);
          }
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getNamedArgumentList() != null)
          {
              node.getNamedArgumentList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getSignal() != null)
          {
              node.getSignal().apply(this);
          }
          if(node.getSend() != null)
          {
              node.getSend().apply(this);
          }
          outASendSpecificStatement(node);
      }
  
      public void inABroadcastSpecificStatement(ABroadcastSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outABroadcastSpecificStatement(ABroadcastSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABroadcastSpecificStatement(ABroadcastSpecificStatement node)
      {
          inABroadcastSpecificStatement(node);
          if(node.getSignal() != null)
          {
              node.getSignal().apply(this);
          }
          if(node.getBroadcast() != null)
          {
              node.getBroadcast().apply(this);
          }
          outABroadcastSpecificStatement(node);
      }
  
      public void inADestroySpecificStatement(ADestroySpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outADestroySpecificStatement(ADestroySpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADestroySpecificStatement(ADestroySpecificStatement node)
      {
          inADestroySpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getDestroy() != null)
          {
              node.getDestroy().apply(this);
          }
          outADestroySpecificStatement(node);
      }
  
      public void inARaiseSpecificStatement(ARaiseSpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outARaiseSpecificStatement(ARaiseSpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARaiseSpecificStatement(ARaiseSpecificStatement node)
      {
          inARaiseSpecificStatement(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getRaise() != null)
          {
              node.getRaise().apply(this);
          }
          outARaiseSpecificStatement(node);
      }
  
      public void inATrySpecificStatement(ATrySpecificStatement node)
      {
          defaultIn(node);
      }
  
      public void outATrySpecificStatement(ATrySpecificStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATrySpecificStatement(ATrySpecificStatement node)
      {
          inATrySpecificStatement(node);
          if(node.getTryStatement() != null)
          {
              node.getTryStatement().apply(this);
          }
          outATrySpecificStatement(node);
      }
  
      public void inATryStatement(ATryStatement node)
      {
          defaultIn(node);
      }
  
      public void outATryStatement(ATryStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATryStatement(ATryStatement node)
      {
          inATryStatement(node);
          if(node.getEnd() != null)
          {
              node.getEnd().apply(this);
          }
          if(node.getFinallySection() != null)
          {
              node.getFinallySection().apply(this);
          }
          if(node.getCatchSection() != null)
          {
              node.getCatchSection().apply(this);
          }
          if(node.getProtectedBlock() != null)
          {
              node.getProtectedBlock().apply(this);
          }
          if(node.getTry() != null)
          {
              node.getTry().apply(this);
          }
          outATryStatement(node);
      }
  
      public void inACatchSection(ACatchSection node)
      {
          defaultIn(node);
      }
  
      public void outACatchSection(ACatchSection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACatchSection(ACatchSection node)
      {
          inACatchSection(node);
          if(node.getHandlerBlock() != null)
          {
              node.getHandlerBlock().apply(this);
          }
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getVarDecl() != null)
          {
              node.getVarDecl().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getCatch() != null)
          {
              node.getCatch().apply(this);
          }
          outACatchSection(node);
      }
  
      public void inAFinallySection(AFinallySection node)
      {
          defaultIn(node);
      }
  
      public void outAFinallySection(AFinallySection node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFinallySection(AFinallySection node)
      {
          inAFinallySection(node);
          if(node.getFinallyBlock() != null)
          {
              node.getFinallyBlock().apply(this);
          }
          if(node.getFinally() != null)
          {
              node.getFinally().apply(this);
          }
          outAFinallySection(node);
      }
  
      public void inAIfStatement(AIfStatement node)
      {
          defaultIn(node);
      }
  
      public void outAIfStatement(AIfStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIfStatement(AIfStatement node)
      {
          inAIfStatement(node);
          if(node.getRestIf() != null)
          {
              node.getRestIf().apply(this);
          }
          if(node.getIfClause() != null)
          {
              node.getIfClause().apply(this);
          }
          if(node.getIf() != null)
          {
              node.getIf().apply(this);
          }
          outAIfStatement(node);
      }
  
      public void inAIfClause(AIfClause node)
      {
          defaultIn(node);
      }
  
      public void outAIfClause(AIfClause node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIfClause(AIfClause node)
      {
          inAIfClause(node);
          if(node.getClauseBody() != null)
          {
              node.getClauseBody().apply(this);
          }
          if(node.getThen() != null)
          {
              node.getThen().apply(this);
          }
          if(node.getTest() != null)
          {
              node.getTest().apply(this);
          }
          outAIfClause(node);
      }
  
      public void inAElseifRestIf(AElseifRestIf node)
      {
          defaultIn(node);
      }
  
      public void outAElseifRestIf(AElseifRestIf node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAElseifRestIf(AElseifRestIf node)
      {
          inAElseifRestIf(node);
          if(node.getRestIf() != null)
          {
              node.getRestIf().apply(this);
          }
          if(node.getIfClause() != null)
          {
              node.getIfClause().apply(this);
          }
          if(node.getElseif() != null)
          {
              node.getElseif().apply(this);
          }
          outAElseifRestIf(node);
      }
  
      public void inAElseRestIf(AElseRestIf node)
      {
          defaultIn(node);
      }
  
      public void outAElseRestIf(AElseRestIf node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAElseRestIf(AElseRestIf node)
      {
          inAElseRestIf(node);
          if(node.getClauseBody() != null)
          {
              node.getClauseBody().apply(this);
          }
          if(node.getElse() != null)
          {
              node.getElse().apply(this);
          }
          outAElseRestIf(node);
      }
  
      public void inAEmptyRestIf(AEmptyRestIf node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyRestIf(AEmptyRestIf node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyRestIf(AEmptyRestIf node)
      {
          inAEmptyRestIf(node);
          outAEmptyRestIf(node);
      }
  
      public void inAClauseBody(AClauseBody node)
      {
          defaultIn(node);
      }
  
      public void outAClauseBody(AClauseBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClauseBody(AClauseBody node)
      {
          inAClauseBody(node);
          if(node.getNonIfStatement() != null)
          {
              node.getNonIfStatement().apply(this);
          }
          outAClauseBody(node);
      }
  
      public void inAWhileLoopStatement(AWhileLoopStatement node)
      {
          defaultIn(node);
      }
  
      public void outAWhileLoopStatement(AWhileLoopStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWhileLoopStatement(AWhileLoopStatement node)
      {
          inAWhileLoopStatement(node);
          if(node.getWhileStatement() != null)
          {
              node.getWhileStatement().apply(this);
          }
          outAWhileLoopStatement(node);
      }
  
      public void inARepeatLoopStatement(ARepeatLoopStatement node)
      {
          defaultIn(node);
      }
  
      public void outARepeatLoopStatement(ARepeatLoopStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARepeatLoopStatement(ARepeatLoopStatement node)
      {
          inARepeatLoopStatement(node);
          if(node.getRepeatStatement() != null)
          {
              node.getRepeatStatement().apply(this);
          }
          outARepeatLoopStatement(node);
      }
  
      public void inALoopTest(ALoopTest node)
      {
          defaultIn(node);
      }
  
      public void outALoopTest(ALoopTest node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALoopTest(ALoopTest node)
      {
          inALoopTest(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          outALoopTest(node);
      }
  
      public void inAWhileStatement(AWhileStatement node)
      {
          defaultIn(node);
      }
  
      public void outAWhileStatement(AWhileStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWhileStatement(AWhileStatement node)
      {
          inAWhileStatement(node);
          if(node.getWhileLoopBody() != null)
          {
              node.getWhileLoopBody().apply(this);
          }
          if(node.getDo() != null)
          {
              node.getDo().apply(this);
          }
          if(node.getLoopTest() != null)
          {
              node.getLoopTest().apply(this);
          }
          if(node.getWhile() != null)
          {
              node.getWhile().apply(this);
          }
          outAWhileStatement(node);
      }
  
      public void inAWhileLoopBody(AWhileLoopBody node)
      {
          defaultIn(node);
      }
  
      public void outAWhileLoopBody(AWhileLoopBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAWhileLoopBody(AWhileLoopBody node)
      {
          inAWhileLoopBody(node);
          if(node.getNonIfStatement() != null)
          {
              node.getNonIfStatement().apply(this);
          }
          outAWhileLoopBody(node);
      }
  
      public void inARepeatStatement(ARepeatStatement node)
      {
          defaultIn(node);
      }
  
      public void outARepeatStatement(ARepeatStatement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARepeatStatement(ARepeatStatement node)
      {
          inARepeatStatement(node);
          if(node.getLoopTest() != null)
          {
              node.getLoopTest().apply(this);
          }
          if(node.getUntil() != null)
          {
              node.getUntil().apply(this);
          }
          if(node.getRepeatLoopBody() != null)
          {
              node.getRepeatLoopBody().apply(this);
          }
          if(node.getRepeat() != null)
          {
              node.getRepeat().apply(this);
          }
          outARepeatStatement(node);
      }
  
      public void inARepeatLoopBody(ARepeatLoopBody node)
      {
          defaultIn(node);
      }
  
      public void outARepeatLoopBody(ARepeatLoopBody node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARepeatLoopBody(ARepeatLoopBody node)
      {
          inARepeatLoopBody(node);
          if(node.getStatementSequence() != null)
          {
              node.getStatementSequence().apply(this);
          }
          outARepeatLoopBody(node);
      }
  
      public void inAVariableIdentifierExpression(AVariableIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAVariableIdentifierExpression(AVariableIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVariableIdentifierExpression(AVariableIdentifierExpression node)
      {
          inAVariableIdentifierExpression(node);
          if(node.getVariableAccess() != null)
          {
              node.getVariableAccess().apply(this);
          }
          outAVariableIdentifierExpression(node);
      }
  
      public void inAClassAttributeIdentifierExpression(AClassAttributeIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAClassAttributeIdentifierExpression(AClassAttributeIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassAttributeIdentifierExpression(AClassAttributeIdentifierExpression node)
      {
          inAClassAttributeIdentifierExpression(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getHash() != null)
          {
              node.getHash().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAClassAttributeIdentifierExpression(node);
      }
  
      public void inAClassOperationIdentifierExpression(AClassOperationIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAClassOperationIdentifierExpression(AClassOperationIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClassOperationIdentifierExpression(AClassOperationIdentifierExpression node)
      {
          inAClassOperationIdentifierExpression(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getExpressionList() != null)
          {
              node.getExpressionList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getHash() != null)
          {
              node.getHash().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAClassOperationIdentifierExpression(node);
      }
  
      public void inANewIdentifierExpression(ANewIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outANewIdentifierExpression(ANewIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANewIdentifierExpression(ANewIdentifierExpression node)
      {
          inANewIdentifierExpression(node);
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getNew() != null)
          {
              node.getNew().apply(this);
          }
          outANewIdentifierExpression(node);
      }
  
      public void inASelfIdentifierExpression(ASelfIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outASelfIdentifierExpression(ASelfIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASelfIdentifierExpression(ASelfIdentifierExpression node)
      {
          inASelfIdentifierExpression(node);
          if(node.getSelf() != null)
          {
              node.getSelf().apply(this);
          }
          outASelfIdentifierExpression(node);
      }
  
      public void inALinkIdentifierExpression(ALinkIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outALinkIdentifierExpression(ALinkIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALinkIdentifierExpression(ALinkIdentifierExpression node)
      {
          inALinkIdentifierExpression(node);
          if(node.getAssociationTraversal() != null)
          {
              node.getAssociationTraversal().apply(this);
          }
          if(node.getIdentifierExpression() != null)
          {
              node.getIdentifierExpression().apply(this);
          }
          outALinkIdentifierExpression(node);
      }
  
      public void inAAttributeIdentifierExpression(AAttributeIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAAttributeIdentifierExpression(AAttributeIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAttributeIdentifierExpression(AAttributeIdentifierExpression node)
      {
          inAAttributeIdentifierExpression(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getTarget() != null)
          {
              node.getTarget().apply(this);
          }
          outAAttributeIdentifierExpression(node);
      }
  
      public void inAOperationIdentifierExpression(AOperationIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAOperationIdentifierExpression(AOperationIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOperationIdentifierExpression(AOperationIdentifierExpression node)
      {
          inAOperationIdentifierExpression(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getExpressionList() != null)
          {
              node.getExpressionList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getTarget() != null)
          {
              node.getTarget().apply(this);
          }
          outAOperationIdentifierExpression(node);
      }
  
      public void inAExtentIdentifierExpression(AExtentIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAExtentIdentifierExpression(AExtentIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExtentIdentifierExpression(AExtentIdentifierExpression node)
      {
          inAExtentIdentifierExpression(node);
          if(node.getExtent() != null)
          {
              node.getExtent().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAExtentIdentifierExpression(node);
      }
  
      public void inAFunctionIdentifierExpression(AFunctionIdentifierExpression node)
      {
          defaultIn(node);
      }
  
      public void outAFunctionIdentifierExpression(AFunctionIdentifierExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFunctionIdentifierExpression(AFunctionIdentifierExpression node)
      {
          inAFunctionIdentifierExpression(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getExpressionList() != null)
          {
              node.getExpressionList().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          if(node.getVariableAccess() != null)
          {
              node.getVariableAccess().apply(this);
          }
          outAFunctionIdentifierExpression(node);
      }
  
      public void inASimpleAssociationTraversal(ASimpleAssociationTraversal node)
      {
          defaultIn(node);
      }
  
      public void outASimpleAssociationTraversal(ASimpleAssociationTraversal node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASimpleAssociationTraversal(ASimpleAssociationTraversal node)
      {
          inASimpleAssociationTraversal(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getRightArrow() != null)
          {
              node.getRightArrow().apply(this);
          }
          outASimpleAssociationTraversal(node);
      }
  
      public void inAQualifiedAssociationTraversal(AQualifiedAssociationTraversal node)
      {
          defaultIn(node);
      }
  
      public void outAQualifiedAssociationTraversal(AQualifiedAssociationTraversal node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAQualifiedAssociationTraversal(AQualifiedAssociationTraversal node)
      {
          inAQualifiedAssociationTraversal(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          if(node.getRightArrow() != null)
          {
              node.getRightArrow().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          if(node.getLeftArrow() != null)
          {
              node.getLeftArrow().apply(this);
          }
          outAQualifiedAssociationTraversal(node);
      }
  
      public void inAVariableAccess(AVariableAccess node)
      {
          defaultIn(node);
      }
  
      public void outAVariableAccess(AVariableAccess node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAVariableAccess(AVariableAccess node)
      {
          inAVariableAccess(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAVariableAccess(node);
      }
  
      public void inALinkRole(ALinkRole node)
      {
          defaultIn(node);
      }
  
      public void outALinkRole(ALinkRole node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALinkRole(ALinkRole node)
      {
          inALinkRole(node);
          if(node.getRootExpression() != null)
          {
              node.getRootExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outALinkRole(node);
      }
  
      public void inATarget(ATarget node)
      {
          defaultIn(node);
      }
  
      public void outATarget(ATarget node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATarget(ATarget node)
      {
          inATarget(node);
          if(node.getObjectDot() != null)
          {
              node.getObjectDot().apply(this);
          }
          if(node.getOperand() != null)
          {
              node.getOperand().apply(this);
          }
          outATarget(node);
      }
  
      public void inARequiredTargetObjectDot(ARequiredTargetObjectDot node)
      {
          defaultIn(node);
      }
  
      public void outARequiredTargetObjectDot(ARequiredTargetObjectDot node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARequiredTargetObjectDot(ARequiredTargetObjectDot node)
      {
          inARequiredTargetObjectDot(node);
          if(node.getDot() != null)
          {
              node.getDot().apply(this);
          }
          outARequiredTargetObjectDot(node);
      }
  
      public void inAOptionalTargetObjectDot(AOptionalTargetObjectDot node)
      {
          defaultIn(node);
      }
  
      public void outAOptionalTargetObjectDot(AOptionalTargetObjectDot node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAOptionalTargetObjectDot(AOptionalTargetObjectDot node)
      {
          inAOptionalTargetObjectDot(node);
          if(node.getOptionalDot() != null)
          {
              node.getOptionalDot().apply(this);
          }
          outAOptionalTargetObjectDot(node);
      }
  
      public void inAClosure(AClosure node)
      {
          defaultIn(node);
      }
  
      public void outAClosure(AClosure node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClosure(AClosure node)
      {
          inAClosure(node);
          if(node.getBlock() != null)
          {
              node.getBlock().apply(this);
          }
          if(node.getSimpleSignature() != null)
          {
              node.getSimpleSignature().apply(this);
          }
          outAClosure(node);
      }
  
      public void inANamedArgumentList(ANamedArgumentList node)
      {
          defaultIn(node);
      }
  
      public void outANamedArgumentList(ANamedArgumentList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedArgumentList(ANamedArgumentList node)
      {
          inANamedArgumentList(node);
          {
              List<PNamedArgumentAdditional> copy = new ArrayList<PNamedArgumentAdditional>(node.getNamedArgumentAdditional());
              Collections.reverse(copy);
              for(PNamedArgumentAdditional e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getNamedArgument() != null)
          {
              node.getNamedArgument().apply(this);
          }
          outANamedArgumentList(node);
      }
  
      public void inAEmptyNamedArgumentList(AEmptyNamedArgumentList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyNamedArgumentList(AEmptyNamedArgumentList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyNamedArgumentList(AEmptyNamedArgumentList node)
      {
          inAEmptyNamedArgumentList(node);
          outAEmptyNamedArgumentList(node);
      }
  
      public void inANamedArgument(ANamedArgument node)
      {
          defaultIn(node);
      }
  
      public void outANamedArgument(ANamedArgument node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedArgument(ANamedArgument node)
      {
          inANamedArgument(node);
          if(node.getExpression() != null)
          {
              node.getExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outANamedArgument(node);
      }
  
      public void inANamedArgumentAdditional(ANamedArgumentAdditional node)
      {
          defaultIn(node);
      }
  
      public void outANamedArgumentAdditional(ANamedArgumentAdditional node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedArgumentAdditional(ANamedArgumentAdditional node)
      {
          inANamedArgumentAdditional(node);
          if(node.getNamedArgument() != null)
          {
              node.getNamedArgument().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outANamedArgumentAdditional(node);
      }
  
      public void inANamedSimpleValueList(ANamedSimpleValueList node)
      {
          defaultIn(node);
      }
  
      public void outANamedSimpleValueList(ANamedSimpleValueList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedSimpleValueList(ANamedSimpleValueList node)
      {
          inANamedSimpleValueList(node);
          {
              List<PNamedSimpleValueAdditional> copy = new ArrayList<PNamedSimpleValueAdditional>(node.getNamedSimpleValueAdditional());
              Collections.reverse(copy);
              for(PNamedSimpleValueAdditional e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getNamedSimpleValue() != null)
          {
              node.getNamedSimpleValue().apply(this);
          }
          outANamedSimpleValueList(node);
      }
  
      public void inAEmptyNamedSimpleValueList(AEmptyNamedSimpleValueList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyNamedSimpleValueList(AEmptyNamedSimpleValueList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyNamedSimpleValueList(AEmptyNamedSimpleValueList node)
      {
          inAEmptyNamedSimpleValueList(node);
          outAEmptyNamedSimpleValueList(node);
      }
  
      public void inANamedSimpleValue(ANamedSimpleValue node)
      {
          defaultIn(node);
      }
  
      public void outANamedSimpleValue(ANamedSimpleValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedSimpleValue(ANamedSimpleValue node)
      {
          inANamedSimpleValue(node);
          if(node.getLiteralOrIdentifier() != null)
          {
              node.getLiteralOrIdentifier().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outANamedSimpleValue(node);
      }
  
      public void inANamedSimpleValueAdditional(ANamedSimpleValueAdditional node)
      {
          defaultIn(node);
      }
  
      public void outANamedSimpleValueAdditional(ANamedSimpleValueAdditional node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANamedSimpleValueAdditional(ANamedSimpleValueAdditional node)
      {
          inANamedSimpleValueAdditional(node);
          if(node.getNamedSimpleValue() != null)
          {
              node.getNamedSimpleValue().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outANamedSimpleValueAdditional(node);
      }
  
      public void inAExpressionList(AExpressionList node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionList(AExpressionList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionList(AExpressionList node)
      {
          inAExpressionList(node);
          {
              List<PExpressionListTail> copy = new ArrayList<PExpressionListTail>(node.getExpressionListTail());
              Collections.reverse(copy);
              for(PExpressionListTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getExpressionListElement() != null)
          {
              node.getExpressionListElement().apply(this);
          }
          outAExpressionList(node);
      }
  
      public void inAEmptyExpressionList(AEmptyExpressionList node)
      {
          defaultIn(node);
      }
  
      public void outAEmptyExpressionList(AEmptyExpressionList node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptyExpressionList(AEmptyExpressionList node)
      {
          inAEmptyExpressionList(node);
          outAEmptyExpressionList(node);
      }
  
      public void inAExpressionListTail(AExpressionListTail node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionListTail(AExpressionListTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionListTail(AExpressionListTail node)
      {
          inAExpressionListTail(node);
          if(node.getExpressionListElement() != null)
          {
              node.getExpressionListElement().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outAExpressionListTail(node);
      }
  
      public void inAExpressionListElement(AExpressionListElement node)
      {
          defaultIn(node);
      }
  
      public void outAExpressionListElement(AExpressionListElement node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpressionListElement(AExpressionListElement node)
      {
          inAExpressionListElement(node);
          if(node.getExpression() != null)
          {
              node.getExpression().apply(this);
          }
          outAExpressionListElement(node);
      }
  
      public void inARootExpression(ARootExpression node)
      {
          defaultIn(node);
      }
  
      public void outARootExpression(ARootExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARootExpression(ARootExpression node)
      {
          inARootExpression(node);
          if(node.getExpression() != null)
          {
              node.getExpression().apply(this);
          }
          outARootExpression(node);
      }
  
      public void inAExpression(AExpression node)
      {
          defaultIn(node);
      }
  
      public void outAExpression(AExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAExpression(AExpression node)
      {
          inAExpression(node);
          if(node.getExpressionP5() != null)
          {
              node.getExpressionP5().apply(this);
          }
          outAExpression(node);
      }
  
      public void inAAltExpressionP0(AAltExpressionP0 node)
      {
          defaultIn(node);
      }
  
      public void outAAltExpressionP0(AAltExpressionP0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltExpressionP0(AAltExpressionP0 node)
      {
          inAAltExpressionP0(node);
          if(node.getOperand() != null)
          {
              node.getOperand().apply(this);
          }
          outAAltExpressionP0(node);
      }
  
      public void inAAltUnaryExpressionP0(AAltUnaryExpressionP0 node)
      {
          defaultIn(node);
      }
  
      public void outAAltUnaryExpressionP0(AAltUnaryExpressionP0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltUnaryExpressionP0(AAltUnaryExpressionP0 node)
      {
          inAAltUnaryExpressionP0(node);
          if(node.getOperand() != null)
          {
              node.getOperand().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          outAAltUnaryExpressionP0(node);
      }
  
      public void inAAltBinaryExpressionP1(AAltBinaryExpressionP1 node)
      {
          defaultIn(node);
      }
  
      public void outAAltBinaryExpressionP1(AAltBinaryExpressionP1 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltBinaryExpressionP1(AAltBinaryExpressionP1 node)
      {
          inAAltBinaryExpressionP1(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAAltBinaryExpressionP1(node);
      }
  
      public void inAAltNestedExpressionP1(AAltNestedExpressionP1 node)
      {
          defaultIn(node);
      }
  
      public void outAAltNestedExpressionP1(AAltNestedExpressionP1 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltNestedExpressionP1(AAltNestedExpressionP1 node)
      {
          inAAltNestedExpressionP1(node);
          if(node.getExpressionP0() != null)
          {
              node.getExpressionP0().apply(this);
          }
          outAAltNestedExpressionP1(node);
      }
  
      public void inAAltBinaryExpressionP2(AAltBinaryExpressionP2 node)
      {
          defaultIn(node);
      }
  
      public void outAAltBinaryExpressionP2(AAltBinaryExpressionP2 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltBinaryExpressionP2(AAltBinaryExpressionP2 node)
      {
          inAAltBinaryExpressionP2(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAAltBinaryExpressionP2(node);
      }
  
      public void inAAltNestedExpressionP2(AAltNestedExpressionP2 node)
      {
          defaultIn(node);
      }
  
      public void outAAltNestedExpressionP2(AAltNestedExpressionP2 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltNestedExpressionP2(AAltNestedExpressionP2 node)
      {
          inAAltNestedExpressionP2(node);
          if(node.getExpressionP1() != null)
          {
              node.getExpressionP1().apply(this);
          }
          outAAltNestedExpressionP2(node);
      }
  
      public void inAAltBinaryExpressionP3(AAltBinaryExpressionP3 node)
      {
          defaultIn(node);
      }
  
      public void outAAltBinaryExpressionP3(AAltBinaryExpressionP3 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltBinaryExpressionP3(AAltBinaryExpressionP3 node)
      {
          inAAltBinaryExpressionP3(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAAltBinaryExpressionP3(node);
      }
  
      public void inAAltNestedExpressionP3(AAltNestedExpressionP3 node)
      {
          defaultIn(node);
      }
  
      public void outAAltNestedExpressionP3(AAltNestedExpressionP3 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltNestedExpressionP3(AAltNestedExpressionP3 node)
      {
          inAAltNestedExpressionP3(node);
          if(node.getExpressionP2() != null)
          {
              node.getExpressionP2().apply(this);
          }
          outAAltNestedExpressionP3(node);
      }
  
      public void inAAltBinaryExpressionP4(AAltBinaryExpressionP4 node)
      {
          defaultIn(node);
      }
  
      public void outAAltBinaryExpressionP4(AAltBinaryExpressionP4 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltBinaryExpressionP4(AAltBinaryExpressionP4 node)
      {
          inAAltBinaryExpressionP4(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAAltBinaryExpressionP4(node);
      }
  
      public void inAAltNestedExpressionP4(AAltNestedExpressionP4 node)
      {
          defaultIn(node);
      }
  
      public void outAAltNestedExpressionP4(AAltNestedExpressionP4 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltNestedExpressionP4(AAltNestedExpressionP4 node)
      {
          inAAltNestedExpressionP4(node);
          if(node.getExpressionP3() != null)
          {
              node.getExpressionP3().apply(this);
          }
          outAAltNestedExpressionP4(node);
      }
  
      public void inAAltBinaryExpressionP5(AAltBinaryExpressionP5 node)
      {
          defaultIn(node);
      }
  
      public void outAAltBinaryExpressionP5(AAltBinaryExpressionP5 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltBinaryExpressionP5(AAltBinaryExpressionP5 node)
      {
          inAAltBinaryExpressionP5(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAAltBinaryExpressionP5(node);
      }
  
      public void inAAltTernaryExpressionP5(AAltTernaryExpressionP5 node)
      {
          defaultIn(node);
      }
  
      public void outAAltTernaryExpressionP5(AAltTernaryExpressionP5 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltTernaryExpressionP5(AAltTernaryExpressionP5 node)
      {
          inAAltTernaryExpressionP5(node);
          if(node.getTernaryExpression() != null)
          {
              node.getTernaryExpression().apply(this);
          }
          outAAltTernaryExpressionP5(node);
      }
  
      public void inAAltNestedExpressionP5(AAltNestedExpressionP5 node)
      {
          defaultIn(node);
      }
  
      public void outAAltNestedExpressionP5(AAltNestedExpressionP5 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAAltNestedExpressionP5(AAltNestedExpressionP5 node)
      {
          inAAltNestedExpressionP5(node);
          if(node.getExpressionP4() != null)
          {
              node.getExpressionP4().apply(this);
          }
          outAAltNestedExpressionP5(node);
      }
  
      public void inATernaryExpression(ATernaryExpression node)
      {
          defaultIn(node);
      }
  
      public void outATernaryExpression(ATernaryExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATernaryExpression(ATernaryExpression node)
      {
          inATernaryExpression(node);
          if(node.getFalseExpression() != null)
          {
              node.getFalseExpression().apply(this);
          }
          if(node.getColon() != null)
          {
              node.getColon().apply(this);
          }
          if(node.getTrueExpression() != null)
          {
              node.getTrueExpression().apply(this);
          }
          if(node.getQuestion() != null)
          {
              node.getQuestion().apply(this);
          }
          if(node.getCondition() != null)
          {
              node.getCondition().apply(this);
          }
          outATernaryExpression(node);
      }
  
      public void inANotUnaryOpLevel0(ANotUnaryOpLevel0 node)
      {
          defaultIn(node);
      }
  
      public void outANotUnaryOpLevel0(ANotUnaryOpLevel0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANotUnaryOpLevel0(ANotUnaryOpLevel0 node)
      {
          inANotUnaryOpLevel0(node);
          if(node.getNot() != null)
          {
              node.getNot().apply(this);
          }
          outANotUnaryOpLevel0(node);
      }
  
      public void inAMinusUnaryOpLevel0(AMinusUnaryOpLevel0 node)
      {
          defaultIn(node);
      }
  
      public void outAMinusUnaryOpLevel0(AMinusUnaryOpLevel0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMinusUnaryOpLevel0(AMinusUnaryOpLevel0 node)
      {
          inAMinusUnaryOpLevel0(node);
          if(node.getMinus() != null)
          {
              node.getMinus().apply(this);
          }
          outAMinusUnaryOpLevel0(node);
      }
  
      public void inANotNullUnaryOpLevel0(ANotNullUnaryOpLevel0 node)
      {
          defaultIn(node);
      }
  
      public void outANotNullUnaryOpLevel0(ANotNullUnaryOpLevel0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANotNullUnaryOpLevel0(ANotNullUnaryOpLevel0 node)
      {
          inANotNullUnaryOpLevel0(node);
          if(node.getQuestion() != null)
          {
              node.getQuestion().apply(this);
          }
          outANotNullUnaryOpLevel0(node);
      }
  
      public void inARequiredUnaryOpLevel0(ARequiredUnaryOpLevel0 node)
      {
          defaultIn(node);
      }
  
      public void outARequiredUnaryOpLevel0(ARequiredUnaryOpLevel0 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARequiredUnaryOpLevel0(ARequiredUnaryOpLevel0 node)
      {
          inARequiredUnaryOpLevel0(node);
          if(node.getBangs() != null)
          {
              node.getBangs().apply(this);
          }
          outARequiredUnaryOpLevel0(node);
      }
  
      public void inABinaryOpLevel1(ABinaryOpLevel1 node)
      {
          defaultIn(node);
      }
  
      public void outABinaryOpLevel1(ABinaryOpLevel1 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABinaryOpLevel1(ABinaryOpLevel1 node)
      {
          inABinaryOpLevel1(node);
          if(node.getPlusMinus() != null)
          {
              node.getPlusMinus().apply(this);
          }
          outABinaryOpLevel1(node);
      }
  
      public void inAMultDivBinaryOpLevel2(AMultDivBinaryOpLevel2 node)
      {
          defaultIn(node);
      }
  
      public void outAMultDivBinaryOpLevel2(AMultDivBinaryOpLevel2 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMultDivBinaryOpLevel2(AMultDivBinaryOpLevel2 node)
      {
          inAMultDivBinaryOpLevel2(node);
          if(node.getMultDiv() != null)
          {
              node.getMultDiv().apply(this);
          }
          outAMultDivBinaryOpLevel2(node);
      }
  
      public void inAElvisBinaryOpLevel2(AElvisBinaryOpLevel2 node)
      {
          defaultIn(node);
      }
  
      public void outAElvisBinaryOpLevel2(AElvisBinaryOpLevel2 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAElvisBinaryOpLevel2(AElvisBinaryOpLevel2 node)
      {
          inAElvisBinaryOpLevel2(node);
          if(node.getElvis() != null)
          {
              node.getElvis().apply(this);
          }
          outAElvisBinaryOpLevel2(node);
      }
  
      public void inABinaryOpLevel3(ABinaryOpLevel3 node)
      {
          defaultIn(node);
      }
  
      public void outABinaryOpLevel3(ABinaryOpLevel3 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABinaryOpLevel3(ABinaryOpLevel3 node)
      {
          inABinaryOpLevel3(node);
          if(node.getComparisonOperator() != null)
          {
              node.getComparisonOperator().apply(this);
          }
          outABinaryOpLevel3(node);
      }
  
      public void inABinaryOpLevel4(ABinaryOpLevel4 node)
      {
          defaultIn(node);
      }
  
      public void outABinaryOpLevel4(ABinaryOpLevel4 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABinaryOpLevel4(ABinaryOpLevel4 node)
      {
          inABinaryOpLevel4(node);
          if(node.getAnd() != null)
          {
              node.getAnd().apply(this);
          }
          outABinaryOpLevel4(node);
      }
  
      public void inABinaryOpLevel5(ABinaryOpLevel5 node)
      {
          defaultIn(node);
      }
  
      public void outABinaryOpLevel5(ABinaryOpLevel5 node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABinaryOpLevel5(ABinaryOpLevel5 node)
      {
          inABinaryOpLevel5(node);
          if(node.getOr() != null)
          {
              node.getOr().apply(this);
          }
          outABinaryOpLevel5(node);
      }
  
      public void inAIsClassExpression(AIsClassExpression node)
      {
          defaultIn(node);
      }
  
      public void outAIsClassExpression(AIsClassExpression node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIsClassExpression(AIsClassExpression node)
      {
          inAIsClassExpression(node);
          if(node.getOperand2() != null)
          {
              node.getOperand2().apply(this);
          }
          if(node.getOperator() != null)
          {
              node.getOperator().apply(this);
          }
          if(node.getOperand1() != null)
          {
              node.getOperand1().apply(this);
          }
          outAIsClassExpression(node);
      }
  
      public void inAIdentifierExpressionOperand(AIdentifierExpressionOperand node)
      {
          defaultIn(node);
      }
  
      public void outAIdentifierExpressionOperand(AIdentifierExpressionOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIdentifierExpressionOperand(AIdentifierExpressionOperand node)
      {
          inAIdentifierExpressionOperand(node);
          if(node.getIdentifierExpression() != null)
          {
              node.getIdentifierExpression().apply(this);
          }
          outAIdentifierExpressionOperand(node);
      }
  
      public void inALiteralOperand(ALiteralOperand node)
      {
          defaultIn(node);
      }
  
      public void outALiteralOperand(ALiteralOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALiteralOperand(ALiteralOperand node)
      {
          inALiteralOperand(node);
          if(node.getLiteral() != null)
          {
              node.getLiteral().apply(this);
          }
          outALiteralOperand(node);
      }
  
      public void inAEmptySetOperand(AEmptySetOperand node)
      {
          defaultIn(node);
      }
  
      public void outAEmptySetOperand(AEmptySetOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptySetOperand(AEmptySetOperand node)
      {
          inAEmptySetOperand(node);
          if(node.getEmptySet() != null)
          {
              node.getEmptySet().apply(this);
          }
          outAEmptySetOperand(node);
      }
  
      public void inATupleOperand(ATupleOperand node)
      {
          defaultIn(node);
      }
  
      public void outATupleOperand(ATupleOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleOperand(ATupleOperand node)
      {
          inATupleOperand(node);
          if(node.getTupleConstructor() != null)
          {
              node.getTupleConstructor().apply(this);
          }
          outATupleOperand(node);
      }
  
      public void inAParenthesisOperand(AParenthesisOperand node)
      {
          defaultIn(node);
      }
  
      public void outAParenthesisOperand(AParenthesisOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAParenthesisOperand(AParenthesisOperand node)
      {
          inAParenthesisOperand(node);
          if(node.getRParen() != null)
          {
              node.getRParen().apply(this);
          }
          if(node.getCast() != null)
          {
              node.getCast().apply(this);
          }
          if(node.getExpression() != null)
          {
              node.getExpression().apply(this);
          }
          if(node.getLParen() != null)
          {
              node.getLParen().apply(this);
          }
          outAParenthesisOperand(node);
      }
  
      public void inAIsClassOperand(AIsClassOperand node)
      {
          defaultIn(node);
      }
  
      public void outAIsClassOperand(AIsClassOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIsClassOperand(AIsClassOperand node)
      {
          inAIsClassOperand(node);
          if(node.getIsClassExpression() != null)
          {
              node.getIsClassExpression().apply(this);
          }
          outAIsClassOperand(node);
      }
  
      public void inAClosureOperand(AClosureOperand node)
      {
          defaultIn(node);
      }
  
      public void outAClosureOperand(AClosureOperand node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAClosureOperand(AClosureOperand node)
      {
          inAClosureOperand(node);
          if(node.getClosure() != null)
          {
              node.getClosure().apply(this);
          }
          outAClosureOperand(node);
      }
  
      public void inAEmptySet(AEmptySet node)
      {
          defaultIn(node);
      }
  
      public void outAEmptySet(AEmptySet node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEmptySet(AEmptySet node)
      {
          inAEmptySet(node);
          if(node.getRBracket() != null)
          {
              node.getRBracket().apply(this);
          }
          if(node.getLBracket() != null)
          {
              node.getLBracket().apply(this);
          }
          if(node.getMinimalTypeIdentifier() != null)
          {
              node.getMinimalTypeIdentifier().apply(this);
          }
          outAEmptySet(node);
      }
  
      public void inACast(ACast node)
      {
          defaultIn(node);
      }
  
      public void outACast(ACast node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseACast(ACast node)
      {
          inACast(node);
          if(node.getTypeIdentifier() != null)
          {
              node.getTypeIdentifier().apply(this);
          }
          if(node.getAs() != null)
          {
              node.getAs().apply(this);
          }
          outACast(node);
      }
  
      public void inAMultMultDiv(AMultMultDiv node)
      {
          defaultIn(node);
      }
  
      public void outAMultMultDiv(AMultMultDiv node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMultMultDiv(AMultMultDiv node)
      {
          inAMultMultDiv(node);
          if(node.getMult() != null)
          {
              node.getMult().apply(this);
          }
          outAMultMultDiv(node);
      }
  
      public void inADivMultDiv(ADivMultDiv node)
      {
          defaultIn(node);
      }
  
      public void outADivMultDiv(ADivMultDiv node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseADivMultDiv(ADivMultDiv node)
      {
          inADivMultDiv(node);
          if(node.getDiv() != null)
          {
              node.getDiv().apply(this);
          }
          outADivMultDiv(node);
      }
  
      public void inAPlusPlusMinus(APlusPlusMinus node)
      {
          defaultIn(node);
      }
  
      public void outAPlusPlusMinus(APlusPlusMinus node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAPlusPlusMinus(APlusPlusMinus node)
      {
          inAPlusPlusMinus(node);
          if(node.getPlus() != null)
          {
              node.getPlus().apply(this);
          }
          outAPlusPlusMinus(node);
      }
  
      public void inAMinusPlusMinus(AMinusPlusMinus node)
      {
          defaultIn(node);
      }
  
      public void outAMinusPlusMinus(AMinusPlusMinus node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAMinusPlusMinus(AMinusPlusMinus node)
      {
          inAMinusPlusMinus(node);
          if(node.getMinus() != null)
          {
              node.getMinus().apply(this);
          }
          outAMinusPlusMinus(node);
      }
  
      public void inASameComparisonOperator(ASameComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outASameComparisonOperator(ASameComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseASameComparisonOperator(ASameComparisonOperator node)
      {
          inASameComparisonOperator(node);
          if(node.getEqualsEquals() != null)
          {
              node.getEqualsEquals().apply(this);
          }
          outASameComparisonOperator(node);
      }
  
      public void inANotSameComparisonOperator(ANotSameComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outANotSameComparisonOperator(ANotSameComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANotSameComparisonOperator(ANotSameComparisonOperator node)
      {
          inANotSameComparisonOperator(node);
          if(node.getNotEqualsEquals() != null)
          {
              node.getNotEqualsEquals().apply(this);
          }
          outANotSameComparisonOperator(node);
      }
  
      public void inAEqualsComparisonOperator(AEqualsComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outAEqualsComparisonOperator(AEqualsComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAEqualsComparisonOperator(AEqualsComparisonOperator node)
      {
          inAEqualsComparisonOperator(node);
          if(node.getEquals() != null)
          {
              node.getEquals().apply(this);
          }
          outAEqualsComparisonOperator(node);
      }
  
      public void inANotEqualsComparisonOperator(ANotEqualsComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outANotEqualsComparisonOperator(ANotEqualsComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANotEqualsComparisonOperator(ANotEqualsComparisonOperator node)
      {
          inANotEqualsComparisonOperator(node);
          if(node.getNotEquals() != null)
          {
              node.getNotEquals().apply(this);
          }
          outANotEqualsComparisonOperator(node);
      }
  
      public void inALowerThanComparisonOperator(ALowerThanComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outALowerThanComparisonOperator(ALowerThanComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALowerThanComparisonOperator(ALowerThanComparisonOperator node)
      {
          inALowerThanComparisonOperator(node);
          if(node.getLab() != null)
          {
              node.getLab().apply(this);
          }
          outALowerThanComparisonOperator(node);
      }
  
      public void inAGreaterThanComparisonOperator(AGreaterThanComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outAGreaterThanComparisonOperator(AGreaterThanComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAGreaterThanComparisonOperator(AGreaterThanComparisonOperator node)
      {
          inAGreaterThanComparisonOperator(node);
          if(node.getRab() != null)
          {
              node.getRab().apply(this);
          }
          outAGreaterThanComparisonOperator(node);
      }
  
      public void inAGreaterOrEqualsComparisonOperator(AGreaterOrEqualsComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outAGreaterOrEqualsComparisonOperator(AGreaterOrEqualsComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAGreaterOrEqualsComparisonOperator(AGreaterOrEqualsComparisonOperator node)
      {
          inAGreaterOrEqualsComparisonOperator(node);
          if(node.getRabEquals() != null)
          {
              node.getRabEquals().apply(this);
          }
          outAGreaterOrEqualsComparisonOperator(node);
      }
  
      public void inALowerOrEqualsComparisonOperator(ALowerOrEqualsComparisonOperator node)
      {
          defaultIn(node);
      }
  
      public void outALowerOrEqualsComparisonOperator(ALowerOrEqualsComparisonOperator node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALowerOrEqualsComparisonOperator(ALowerOrEqualsComparisonOperator node)
      {
          inALowerOrEqualsComparisonOperator(node);
          if(node.getLabEquals() != null)
          {
              node.getLabEquals().apply(this);
          }
          outALowerOrEqualsComparisonOperator(node);
      }
  
      public void inABooleanLiteral(ABooleanLiteral node)
      {
          defaultIn(node);
      }
  
      public void outABooleanLiteral(ABooleanLiteral node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseABooleanLiteral(ABooleanLiteral node)
      {
          inABooleanLiteral(node);
          if(node.getBoolean() != null)
          {
              node.getBoolean().apply(this);
          }
          outABooleanLiteral(node);
      }
  
      public void inANumberLiteral(ANumberLiteral node)
      {
          defaultIn(node);
      }
  
      public void outANumberLiteral(ANumberLiteral node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANumberLiteral(ANumberLiteral node)
      {
          inANumberLiteral(node);
          if(node.getNumber() != null)
          {
              node.getNumber().apply(this);
          }
          outANumberLiteral(node);
      }
  
      public void inAStringLiteral(AStringLiteral node)
      {
          defaultIn(node);
      }
  
      public void outAStringLiteral(AStringLiteral node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAStringLiteral(AStringLiteral node)
      {
          inAStringLiteral(node);
          if(node.getString() != null)
          {
              node.getString().apply(this);
          }
          outAStringLiteral(node);
      }
  
      public void inANullLiteral(ANullLiteral node)
      {
          defaultIn(node);
      }
  
      public void outANullLiteral(ANullLiteral node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseANullLiteral(ANullLiteral node)
      {
          inANullLiteral(node);
          if(node.getNull() != null)
          {
              node.getNull().apply(this);
          }
          outANullLiteral(node);
      }
  
      public void inATupleConstructor(ATupleConstructor node)
      {
          defaultIn(node);
      }
  
      public void outATupleConstructor(ATupleConstructor node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleConstructor(ATupleConstructor node)
      {
          inATupleConstructor(node);
          if(node.getRCurlyBracket() != null)
          {
              node.getRCurlyBracket().apply(this);
          }
          {
              List<PTupleComponentValueTail> copy = new ArrayList<PTupleComponentValueTail>(node.getTupleComponentValueTail());
              Collections.reverse(copy);
              for(PTupleComponentValueTail e : copy)
              {
                  e.apply(this);
              }
          }
          if(node.getTupleComponentValue() != null)
          {
              node.getTupleComponentValue().apply(this);
          }
          if(node.getLCurlyBracket() != null)
          {
              node.getLCurlyBracket().apply(this);
          }
          outATupleConstructor(node);
      }
  
      public void inATupleComponentValue(ATupleComponentValue node)
      {
          defaultIn(node);
      }
  
      public void outATupleComponentValue(ATupleComponentValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleComponentValue(ATupleComponentValue node)
      {
          inATupleComponentValue(node);
          if(node.getExpression() != null)
          {
              node.getExpression().apply(this);
          }
          if(node.getAssignop() != null)
          {
              node.getAssignop().apply(this);
          }
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outATupleComponentValue(node);
      }
  
      public void inATupleComponentValueTail(ATupleComponentValueTail node)
      {
          defaultIn(node);
      }
  
      public void outATupleComponentValueTail(ATupleComponentValueTail node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATupleComponentValueTail(ATupleComponentValueTail node)
      {
          inATupleComponentValueTail(node);
          if(node.getTupleComponentValue() != null)
          {
              node.getTupleComponentValue().apply(this);
          }
          if(node.getComma() != null)
          {
              node.getComma().apply(this);
          }
          outATupleComponentValueTail(node);
      }
  
      public void inALiteralLiteralOrIdentifier(ALiteralLiteralOrIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outALiteralLiteralOrIdentifier(ALiteralLiteralOrIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseALiteralLiteralOrIdentifier(ALiteralLiteralOrIdentifier node)
      {
          inALiteralLiteralOrIdentifier(node);
          if(node.getLiteral() != null)
          {
              node.getLiteral().apply(this);
          }
          outALiteralLiteralOrIdentifier(node);
      }
  
      public void inAIdentifierLiteralOrIdentifier(AIdentifierLiteralOrIdentifier node)
      {
          defaultIn(node);
      }
  
      public void outAIdentifierLiteralOrIdentifier(AIdentifierLiteralOrIdentifier node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIdentifierLiteralOrIdentifier(AIdentifierLiteralOrIdentifier node)
      {
          inAIdentifierLiteralOrIdentifier(node);
          if(node.getIdentifier() != null)
          {
              node.getIdentifier().apply(this);
          }
          outAIdentifierLiteralOrIdentifier(node);
      }
  
      public void inATrueBoolean(ATrueBoolean node)
      {
          defaultIn(node);
      }
  
      public void outATrueBoolean(ATrueBoolean node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseATrueBoolean(ATrueBoolean node)
      {
          inATrueBoolean(node);
          if(node.getTrue() != null)
          {
              node.getTrue().apply(this);
          }
          outATrueBoolean(node);
      }
  
      public void inAFalseBoolean(AFalseBoolean node)
      {
          defaultIn(node);
      }
  
      public void outAFalseBoolean(AFalseBoolean node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAFalseBoolean(AFalseBoolean node)
      {
          inAFalseBoolean(node);
          if(node.getFalse() != null)
          {
              node.getFalse().apply(this);
          }
          outAFalseBoolean(node);
      }
  
      public void inAIntegerNumber(AIntegerNumber node)
      {
          defaultIn(node);
      }
  
      public void outAIntegerNumber(AIntegerNumber node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIntegerNumber(AIntegerNumber node)
      {
          inAIntegerNumber(node);
          if(node.getInteger() != null)
          {
              node.getInteger().apply(this);
          }
          outAIntegerNumber(node);
      }
  
      public void inARealNumber(ARealNumber node)
      {
          defaultIn(node);
      }
  
      public void outARealNumber(ARealNumber node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseARealNumber(ARealNumber node)
      {
          inARealNumber(node);
          if(node.getReal() != null)
          {
              node.getReal().apply(this);
          }
          outARealNumber(node);
      }
  
      public void inAIntegerMultiplicityValue(AIntegerMultiplicityValue node)
      {
          defaultIn(node);
      }
  
      public void outAIntegerMultiplicityValue(AIntegerMultiplicityValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAIntegerMultiplicityValue(AIntegerMultiplicityValue node)
      {
          inAIntegerMultiplicityValue(node);
          if(node.getInteger() != null)
          {
              node.getInteger().apply(this);
          }
          outAIntegerMultiplicityValue(node);
      }
  
      public void inAInfinityMultiplicityValue(AInfinityMultiplicityValue node)
      {
          defaultIn(node);
      }
  
      public void outAInfinityMultiplicityValue(AInfinityMultiplicityValue node)
      {
          defaultOut(node);
      }
  
      @Override
      public void caseAInfinityMultiplicityValue(AInfinityMultiplicityValue node)
      {
          inAInfinityMultiplicityValue(node);
          if(node.getMult() != null)
          {
              node.getMult().apply(this);
          }
          outAInfinityMultiplicityValue(node);
      }
  }
  