/*
 * Name: default_trav.cc
 *
 *=========================================================================
 * Copyright (c) 1992 Swedish Telecom, Sweden.
 * Copyright (c) 1994 TeleLOGIC AB, Sweden.
 * All rights reserved.
 *
 *=========================================================================
 *
 * Description:
 * The traverser functions for the DepthFirst order.
 * 
 * 
 * WARNING!
 * This file is generated, which means that 
 * any changes made to this file may be lost at any time.
 */




void default_trav_ASuite( const ASuite& Me )
{
  if ( pre_ASuite ) 
    pre_ASuite( Me );

  if ( Me.is_present_suiteId())
    {
      if ( pre_ASuite_suiteId ) 
        pre_ASuite_suiteId( Me );
      if ( trav_SuiteId ) 
        trav_SuiteId( Me.suiteId() );
      if ( post_ASuite_suiteId ) 
        post_ASuite_suiteId( Me );
    }

  if ( pre_ASuite_suiteOverviewPart ) 
    pre_ASuite_suiteOverviewPart( Me );
  if ( trav_SuiteOverviewPart ) 
    trav_SuiteOverviewPart( Me.suiteOverviewPart() );
  if ( post_ASuite_suiteOverviewPart ) 
    post_ASuite_suiteOverviewPart( Me );

  if ( pre_ASuite_declarationsPart ) 
    pre_ASuite_declarationsPart( Me );
  if ( trav_DeclarationsPart ) 
    trav_DeclarationsPart( Me.declarationsPart() );
  if ( post_ASuite_declarationsPart ) 
    post_ASuite_declarationsPart( Me );

  if ( pre_ASuite_constraintsPart ) 
    pre_ASuite_constraintsPart( Me );
  if ( trav_ConstraintsPart ) 
    trav_ConstraintsPart( Me.constraintsPart() );
  if ( post_ASuite_constraintsPart ) 
    post_ASuite_constraintsPart( Me );

  if ( pre_ASuite_dynamicPart ) 
    pre_ASuite_dynamicPart( Me );
  if ( trav_DynamicPart ) 
    trav_DynamicPart( Me.dynamicPart() );
  if ( post_ASuite_dynamicPart ) 
    post_ASuite_dynamicPart( Me );

  if ( post_ASuite ) 
    post_ASuite( Me );
}


void default_trav_SuiteId( const SuiteId& Me )
{
  if ( pre_SuiteId ) 
    pre_SuiteId( Me );

  if ( pre_SuiteId_suiteIdentifier ) 
    pre_SuiteId_suiteIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.suiteIdentifier() );
  if ( post_SuiteId_suiteIdentifier ) 
    post_SuiteId_suiteIdentifier( Me );

  if ( post_SuiteId ) 
    post_SuiteId( Me );
}


void default_trav_SO_SuiteId( const SO_SuiteId& Me )
{
  if ( pre_SO_SuiteId ) 
    pre_SO_SuiteId( Me );

  if ( pre_SO_SuiteId_suiteIdentifier ) 
    pre_SO_SuiteId_suiteIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.suiteIdentifier() );
  if ( post_SO_SuiteId_suiteIdentifier ) 
    post_SO_SuiteId_suiteIdentifier( Me );

  if ( post_SO_SuiteId ) 
    post_SO_SuiteId( Me );
}


void default_trav_SuiteOverviewPart( const SuiteOverviewPart& Me )
{
  if ( pre_SuiteOverviewPart ) 
    pre_SuiteOverviewPart( Me );

  if ( pre_SuiteOverviewPart_suiteStructure ) 
    pre_SuiteOverviewPart_suiteStructure( Me );
  if ( trav_SuiteStructure ) 
    trav_SuiteStructure( Me.suiteStructure() );
  if ( post_SuiteOverviewPart_suiteStructure ) 
    post_SuiteOverviewPart_suiteStructure( Me );

  if ( pre_SuiteOverviewPart_testCaseIndex ) 
    pre_SuiteOverviewPart_testCaseIndex( Me );
  if ( trav_TestCaseIndex ) 
    trav_TestCaseIndex( Me.testCaseIndex() );
  if ( post_SuiteOverviewPart_testCaseIndex ) 
    post_SuiteOverviewPart_testCaseIndex( Me );

  if ( pre_SuiteOverviewPart_testStepIndex ) 
    pre_SuiteOverviewPart_testStepIndex( Me );
  if ( trav_TestStepIndex ) 
    trav_TestStepIndex( Me.testStepIndex() );
  if ( post_SuiteOverviewPart_testStepIndex ) 
    post_SuiteOverviewPart_testStepIndex( Me );

  if ( pre_SuiteOverviewPart_defaultIndex ) 
    pre_SuiteOverviewPart_defaultIndex( Me );
  if ( trav_DefaultIndex ) 
    trav_DefaultIndex( Me.defaultIndex() );
  if ( post_SuiteOverviewPart_defaultIndex ) 
    post_SuiteOverviewPart_defaultIndex( Me );

  if ( post_SuiteOverviewPart ) 
    post_SuiteOverviewPart( Me );
}


void default_trav_SuiteStructure( const SuiteStructure& Me )
{
  if ( pre_SuiteStructure ) 
    pre_SuiteStructure( Me );

  if ( Me.is_present_SO_suiteId())
    {
      if ( pre_SuiteStructure_SO_suiteId ) 
        pre_SuiteStructure_SO_suiteId( Me );
      if ( trav_SO_SuiteId ) 
        trav_SO_SuiteId( Me.SO_suiteId() );
      if ( post_SuiteStructure_SO_suiteId ) 
        post_SuiteStructure_SO_suiteId( Me );
    }

  if ( Me.is_present_SO_standardsRef())
    {
      if ( pre_SuiteStructure_SO_standardsRef ) 
        pre_SuiteStructure_SO_standardsRef( Me );
      if ( trav_SO_StandardsRef ) 
        trav_SO_StandardsRef( Me.SO_standardsRef() );
      if ( post_SuiteStructure_SO_standardsRef ) 
        post_SuiteStructure_SO_standardsRef( Me );
    }

  if ( Me.is_present_SO_picsRef())
    {
      if ( pre_SuiteStructure_SO_picsRef ) 
        pre_SuiteStructure_SO_picsRef( Me );
      if ( trav_SO_PICSRef ) 
        trav_SO_PICSRef( Me.SO_picsRef() );
      if ( post_SuiteStructure_SO_picsRef ) 
        post_SuiteStructure_SO_picsRef( Me );
    }

  if ( Me.is_present_SO_pixitRef())
    {
      if ( pre_SuiteStructure_SO_pixitRef ) 
        pre_SuiteStructure_SO_pixitRef( Me );
      if ( trav_SO_PIXITRef ) 
        trav_SO_PIXITRef( Me.SO_pixitRef() );
      if ( post_SuiteStructure_SO_pixitRef ) 
        post_SuiteStructure_SO_pixitRef( Me );
    }

  if ( Me.is_present_SO_testMethods())
    {
      if ( pre_SuiteStructure_SO_testMethods ) 
        pre_SuiteStructure_SO_testMethods( Me );
      if ( trav_SO_TestMethods ) 
        trav_SO_TestMethods( Me.SO_testMethods() );
      if ( post_SuiteStructure_SO_testMethods ) 
        post_SuiteStructure_SO_testMethods( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_SuiteStructure_comment ) 
        pre_SuiteStructure_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_SuiteStructure_comment ) 
        post_SuiteStructure_comment( Me );
    }

  if ( pre_SuiteStructure_SO_structureAndObjectives ) 
    pre_SuiteStructure_SO_structureAndObjectives( Me );
  if ( trav_SO_StructureAndObjectives ) 
    trav_SO_StructureAndObjectives( Me.SO_structureAndObjectives() );
  if ( post_SuiteStructure_SO_structureAndObjectives ) 
    post_SuiteStructure_SO_structureAndObjectives( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_SuiteStructure_detailedComment ) 
        pre_SuiteStructure_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_SuiteStructure_detailedComment ) 
        post_SuiteStructure_detailedComment( Me );
    }

  if ( post_SuiteStructure ) 
    post_SuiteStructure( Me );
}


void default_trav_SO_StandardsRef( const SO_StandardsRef& Me )
{
  if ( pre_SO_StandardsRef ) 
    pre_SO_StandardsRef( Me );

  if ( post_SO_StandardsRef ) 
    post_SO_StandardsRef( Me );
}


void default_trav_SO_PICSRef( const SO_PICSRef& Me )
{
  if ( pre_SO_PICSRef ) 
    pre_SO_PICSRef( Me );

  if ( post_SO_PICSRef ) 
    post_SO_PICSRef( Me );
}


void default_trav_SO_PIXITRef( const SO_PIXITRef& Me )
{
  if ( pre_SO_PIXITRef ) 
    pre_SO_PIXITRef( Me );

  if ( post_SO_PIXITRef ) 
    post_SO_PIXITRef( Me );
}


void default_trav_SO_TestMethods( const SO_TestMethods& Me )
{
  if ( pre_SO_TestMethods ) 
    pre_SO_TestMethods( Me );

  if ( post_SO_TestMethods ) 
    post_SO_TestMethods( Me );
}


void default_trav_SO_SelExprId( const SO_SelExprId& Me )
{
  if ( pre_SO_SelExprId ) 
    pre_SO_SelExprId( Me );

  if ( post_SO_SelExprId ) 
    post_SO_SelExprId( Me );
}


void default_trav_SO_Objective( const SO_Objective& Me )
{
  if ( pre_SO_Objective ) 
    pre_SO_Objective( Me );

  if ( post_SO_Objective ) 
    post_SO_Objective( Me );
}


void default_trav_SO_DefaultRef( const SO_DefaultRef& Me )
{
  if ( pre_SO_DefaultRef ) 
    pre_SO_DefaultRef( Me );

  if ( post_SO_DefaultRef ) 
    post_SO_DefaultRef( Me );
}


void default_trav_SO_DefaultId( const SO_DefaultId& Me )
{
  if ( pre_SO_DefaultId ) 
    pre_SO_DefaultId( Me );

  if ( post_SO_DefaultId ) 
    post_SO_DefaultId( Me );
}


void default_trav_SO_Description( const SO_Description& Me )
{
  if ( pre_SO_Description ) 
    pre_SO_Description( Me );

  if ( post_SO_Description ) 
    post_SO_Description( Me );
}


void default_trav_SO_TestStepRef( const SO_TestStepRef& Me )
{
  if ( pre_SO_TestStepRef ) 
    pre_SO_TestStepRef( Me );

  if ( post_SO_TestStepRef ) 
    post_SO_TestStepRef( Me );
}


void default_trav_SO_TestStepId( const SO_TestStepId& Me )
{
  if ( pre_SO_TestStepId ) 
    pre_SO_TestStepId( Me );

  if ( post_SO_TestStepId ) 
    post_SO_TestStepId( Me );
}


void default_trav_SO_TestCaseId( const SO_TestCaseId& Me )
{
  if ( pre_SO_TestCaseId ) 
    pre_SO_TestCaseId( Me );

  if ( post_SO_TestCaseId ) 
    post_SO_TestCaseId( Me );
}


void default_trav_SO_TestGroupRef( const SO_TestGroupRef& Me )
{
  if ( pre_SO_TestGroupRef ) 
    pre_SO_TestGroupRef( Me );

  if ( post_SO_TestGroupRef ) 
    post_SO_TestGroupRef( Me );
}


void default_trav_SO_StructureAndObjectives( const SO_StructureAndObjectives& Me )
{
  if ( pre_SO_StructureAndObjectives ) 
    pre_SO_StructureAndObjectives( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SO_StructureAndObjectives_SO_structureAndObjective ) 
        pre_SO_StructureAndObjectives_SO_structureAndObjective( Me, i );
      if ( trav_SO_StructureAndObjective ) 
        trav_SO_StructureAndObjective( Me.SO_structureAndObjective( i ) );
      if ( post_SO_StructureAndObjectives_SO_structureAndObjective ) 
        post_SO_StructureAndObjectives_SO_structureAndObjective( Me, i );
  }

  if ( post_SO_StructureAndObjectives ) 
    post_SO_StructureAndObjectives( Me );
}


void default_trav_SO_StructureAndObjective( const SO_StructureAndObjective& Me )
{
  if ( pre_SO_StructureAndObjective ) 
    pre_SO_StructureAndObjective( Me );

  if ( Me.is_present_SO_testGroupRef())
    {
      if ( pre_SO_StructureAndObjective_SO_testGroupRef ) 
        pre_SO_StructureAndObjective_SO_testGroupRef( Me );
      if ( trav_SO_TestGroupRef ) 
        trav_SO_TestGroupRef( Me.SO_testGroupRef() );
      if ( post_SO_StructureAndObjective_SO_testGroupRef ) 
        post_SO_StructureAndObjective_SO_testGroupRef( Me );
    }

  if ( Me.is_present_SO_selExprId())
    {
      if ( pre_SO_StructureAndObjective_SO_selExprId ) 
        pre_SO_StructureAndObjective_SO_selExprId( Me );
      if ( trav_SO_SelExprId ) 
        trav_SO_SelExprId( Me.SO_selExprId() );
      if ( post_SO_StructureAndObjective_SO_selExprId ) 
        post_SO_StructureAndObjective_SO_selExprId( Me );
    }

  if ( Me.is_present_SO_objective())
    {
      if ( pre_SO_StructureAndObjective_SO_objective ) 
        pre_SO_StructureAndObjective_SO_objective( Me );
      if ( trav_SO_Objective ) 
        trav_SO_Objective( Me.SO_objective() );
      if ( post_SO_StructureAndObjective_SO_objective ) 
        post_SO_StructureAndObjective_SO_objective( Me );
    }

  if ( post_SO_StructureAndObjective ) 
    post_SO_StructureAndObjective( Me );
}


void default_trav_TestCaseIndex( const TestCaseIndex& Me )
{
  if ( pre_TestCaseIndex ) 
    pre_TestCaseIndex( Me );

  if ( pre_TestCaseIndex_SO_caseIndexList ) 
    pre_TestCaseIndex_SO_caseIndexList( Me );
  if ( trav_SO_CaseIndexList ) 
    trav_SO_CaseIndexList( Me.SO_caseIndexList() );
  if ( post_TestCaseIndex_SO_caseIndexList ) 
    post_TestCaseIndex_SO_caseIndexList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TestCaseIndex_detailedComment ) 
        pre_TestCaseIndex_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TestCaseIndex_detailedComment ) 
        post_TestCaseIndex_detailedComment( Me );
    }

  if ( post_TestCaseIndex ) 
    post_TestCaseIndex( Me );
}


void default_trav_SO_CaseIndexList( const SO_CaseIndexList& Me )
{
  if ( pre_SO_CaseIndexList ) 
    pre_SO_CaseIndexList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SO_CaseIndexList_SO_caseIndex ) 
        pre_SO_CaseIndexList_SO_caseIndex( Me, i );
      if ( trav_SO_CaseIndex ) 
        trav_SO_CaseIndex( Me.SO_caseIndex( i ) );
      if ( post_SO_CaseIndexList_SO_caseIndex ) 
        post_SO_CaseIndexList_SO_caseIndex( Me, i );
  }

  if ( post_SO_CaseIndexList ) 
    post_SO_CaseIndexList( Me );
}


void default_trav_SO_CaseIndex( const SO_CaseIndex& Me )
{
  if ( pre_SO_CaseIndex ) 
    pre_SO_CaseIndex( Me );

  if ( Me.is_present_SO_testGroupRef())
    {
      if ( pre_SO_CaseIndex_SO_testGroupRef ) 
        pre_SO_CaseIndex_SO_testGroupRef( Me );
      if ( trav_SO_TestGroupRef ) 
        trav_SO_TestGroupRef( Me.SO_testGroupRef() );
      if ( post_SO_CaseIndex_SO_testGroupRef ) 
        post_SO_CaseIndex_SO_testGroupRef( Me );
    }

  if ( Me.is_present_SO_testCaseId())
    {
      if ( pre_SO_CaseIndex_SO_testCaseId ) 
        pre_SO_CaseIndex_SO_testCaseId( Me );
      if ( trav_SO_TestCaseId ) 
        trav_SO_TestCaseId( Me.SO_testCaseId() );
      if ( post_SO_CaseIndex_SO_testCaseId ) 
        post_SO_CaseIndex_SO_testCaseId( Me );
    }

  if ( Me.is_present_SO_selExprId())
    {
      if ( pre_SO_CaseIndex_SO_selExprId ) 
        pre_SO_CaseIndex_SO_selExprId( Me );
      if ( trav_SO_SelExprId ) 
        trav_SO_SelExprId( Me.SO_selExprId() );
      if ( post_SO_CaseIndex_SO_selExprId ) 
        post_SO_CaseIndex_SO_selExprId( Me );
    }

  if ( Me.is_present_SO_description())
    {
      if ( pre_SO_CaseIndex_SO_description ) 
        pre_SO_CaseIndex_SO_description( Me );
      if ( trav_SO_Description ) 
        trav_SO_Description( Me.SO_description() );
      if ( post_SO_CaseIndex_SO_description ) 
        post_SO_CaseIndex_SO_description( Me );
    }

  if ( post_SO_CaseIndex ) 
    post_SO_CaseIndex( Me );
}


void default_trav_TestStepIndex( const TestStepIndex& Me )
{
  if ( pre_TestStepIndex ) 
    pre_TestStepIndex( Me );

  if ( pre_TestStepIndex_SO_stepIndexList ) 
    pre_TestStepIndex_SO_stepIndexList( Me );
  if ( trav_SO_StepIndexList ) 
    trav_SO_StepIndexList( Me.SO_stepIndexList() );
  if ( post_TestStepIndex_SO_stepIndexList ) 
    post_TestStepIndex_SO_stepIndexList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TestStepIndex_detailedComment ) 
        pre_TestStepIndex_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TestStepIndex_detailedComment ) 
        post_TestStepIndex_detailedComment( Me );
    }

  if ( post_TestStepIndex ) 
    post_TestStepIndex( Me );
}


void default_trav_SO_StepIndexList( const SO_StepIndexList& Me )
{
  if ( pre_SO_StepIndexList ) 
    pre_SO_StepIndexList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SO_StepIndexList_SO_stepIndex ) 
        pre_SO_StepIndexList_SO_stepIndex( Me, i );
      if ( trav_SO_StepIndex ) 
        trav_SO_StepIndex( Me.SO_stepIndex( i ) );
      if ( post_SO_StepIndexList_SO_stepIndex ) 
        post_SO_StepIndexList_SO_stepIndex( Me, i );
  }

  if ( post_SO_StepIndexList ) 
    post_SO_StepIndexList( Me );
}


void default_trav_SO_StepIndex( const SO_StepIndex& Me )
{
  if ( pre_SO_StepIndex ) 
    pre_SO_StepIndex( Me );

  if ( Me.is_present_SO_testStepRef())
    {
      if ( pre_SO_StepIndex_SO_testStepRef ) 
        pre_SO_StepIndex_SO_testStepRef( Me );
      if ( trav_SO_TestStepRef ) 
        trav_SO_TestStepRef( Me.SO_testStepRef() );
      if ( post_SO_StepIndex_SO_testStepRef ) 
        post_SO_StepIndex_SO_testStepRef( Me );
    }

  if ( Me.is_present_SO_testStepId())
    {
      if ( pre_SO_StepIndex_SO_testStepId ) 
        pre_SO_StepIndex_SO_testStepId( Me );
      if ( trav_SO_TestStepId ) 
        trav_SO_TestStepId( Me.SO_testStepId() );
      if ( post_SO_StepIndex_SO_testStepId ) 
        post_SO_StepIndex_SO_testStepId( Me );
    }

  if ( Me.is_present_SO_description())
    {
      if ( pre_SO_StepIndex_SO_description ) 
        pre_SO_StepIndex_SO_description( Me );
      if ( trav_SO_Description ) 
        trav_SO_Description( Me.SO_description() );
      if ( post_SO_StepIndex_SO_description ) 
        post_SO_StepIndex_SO_description( Me );
    }

  if ( post_SO_StepIndex ) 
    post_SO_StepIndex( Me );
}


void default_trav_DefaultIndex( const DefaultIndex& Me )
{
  if ( pre_DefaultIndex ) 
    pre_DefaultIndex( Me );

  if ( pre_DefaultIndex_SO_defIndexList ) 
    pre_DefaultIndex_SO_defIndexList( Me );
  if ( trav_SO_DefIndexList ) 
    trav_SO_DefIndexList( Me.SO_defIndexList() );
  if ( post_DefaultIndex_SO_defIndexList ) 
    post_DefaultIndex_SO_defIndexList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_DefaultIndex_detailedComment ) 
        pre_DefaultIndex_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_DefaultIndex_detailedComment ) 
        post_DefaultIndex_detailedComment( Me );
    }

  if ( post_DefaultIndex ) 
    post_DefaultIndex( Me );
}


void default_trav_SO_DefIndexList( const SO_DefIndexList& Me )
{
  if ( pre_SO_DefIndexList ) 
    pre_SO_DefIndexList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SO_DefIndexList_SO_defIndex ) 
        pre_SO_DefIndexList_SO_defIndex( Me, i );
      if ( trav_SO_DefIndex ) 
        trav_SO_DefIndex( Me.SO_defIndex( i ) );
      if ( post_SO_DefIndexList_SO_defIndex ) 
        post_SO_DefIndexList_SO_defIndex( Me, i );
  }

  if ( post_SO_DefIndexList ) 
    post_SO_DefIndexList( Me );
}


void default_trav_SO_DefIndex( const SO_DefIndex& Me )
{
  if ( pre_SO_DefIndex ) 
    pre_SO_DefIndex( Me );

  if ( Me.is_present_SO_defaultRef())
    {
      if ( pre_SO_DefIndex_SO_defaultRef ) 
        pre_SO_DefIndex_SO_defaultRef( Me );
      if ( trav_SO_DefaultRef ) 
        trav_SO_DefaultRef( Me.SO_defaultRef() );
      if ( post_SO_DefIndex_SO_defaultRef ) 
        post_SO_DefIndex_SO_defaultRef( Me );
    }

  if ( Me.is_present_SO_defaultId())
    {
      if ( pre_SO_DefIndex_SO_defaultId ) 
        pre_SO_DefIndex_SO_defaultId( Me );
      if ( trav_SO_DefaultId ) 
        trav_SO_DefaultId( Me.SO_defaultId() );
      if ( post_SO_DefIndex_SO_defaultId ) 
        post_SO_DefIndex_SO_defaultId( Me );
    }

  if ( Me.is_present_SO_description())
    {
      if ( pre_SO_DefIndex_SO_description ) 
        pre_SO_DefIndex_SO_description( Me );
      if ( trav_SO_Description ) 
        trav_SO_Description( Me.SO_description() );
      if ( post_SO_DefIndex_SO_description ) 
        post_SO_DefIndex_SO_description( Me );
    }

  if ( post_SO_DefIndex ) 
    post_SO_DefIndex( Me );
}


void default_trav_ImportPart( const ImportPart& Me )
{
  if ( pre_ImportPart ) 
    pre_ImportPart( Me );

  if ( pre_ImportPart_importDeclarations ) 
    pre_ImportPart_importDeclarations( Me );
  if ( trav_ImportDeclarations ) 
    trav_ImportDeclarations( Me.importDeclarations() );
  if ( post_ImportPart_importDeclarations ) 
    post_ImportPart_importDeclarations( Me );

  if ( post_ImportPart ) 
    post_ImportPart( Me );
}


void default_trav_ImportDeclarations( const ImportDeclarations& Me )
{
  if ( pre_ImportDeclarations ) 
    pre_ImportDeclarations( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ImportDeclarations_imports ) 
        pre_ImportDeclarations_imports( Me, i );
      if ( trav_Imports ) 
        trav_Imports( Me.imports( i ) );
      if ( post_ImportDeclarations_imports ) 
        post_ImportDeclarations_imports( Me, i );
  }

  if ( post_ImportDeclarations ) 
    post_ImportDeclarations( Me );
}


void default_trav_Imports( const Imports& Me )
{
  if ( pre_Imports ) 
    pre_Imports( Me );

  if ( Me.is_present_sourceName())
    {
      if ( pre_Imports_sourceName ) 
        pre_Imports_sourceName( Me );
      if ( trav_SourceName ) 
        trav_SourceName( Me.sourceName() );
      if ( post_Imports_sourceName ) 
        post_Imports_sourceName( Me );
    }

  if ( Me.is_present_sourceRef())
    {
      if ( pre_Imports_sourceRef ) 
        pre_Imports_sourceRef( Me );
      if ( trav_SourceRef ) 
        trav_SourceRef( Me.sourceRef() );
      if ( post_Imports_sourceRef ) 
        post_Imports_sourceRef( Me );
    }

  if ( Me.is_present_objective())
    {
      if ( pre_Imports_objective ) 
        pre_Imports_objective( Me );
      if ( trav_Objective ) 
        trav_Objective( Me.objective() );
      if ( post_Imports_objective ) 
        post_Imports_objective( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_Imports_comment ) 
        pre_Imports_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_Imports_comment ) 
        post_Imports_comment( Me );
    }

  if ( pre_Imports_importedObjectList ) 
    pre_Imports_importedObjectList( Me );
  if ( trav_ImportedObjectList ) 
    trav_ImportedObjectList( Me.importedObjectList() );
  if ( post_Imports_importedObjectList ) 
    post_Imports_importedObjectList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_Imports_detailedComment ) 
        pre_Imports_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_Imports_detailedComment ) 
        post_Imports_detailedComment( Me );
    }

  if ( post_Imports ) 
    post_Imports( Me );
}


void default_trav_SourceName( const SourceName& Me )
{
  if ( pre_SourceName ) 
    pre_SourceName( Me );

  if ( pre_SourceName_sourceIdentifier ) 
    pre_SourceName_sourceIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.sourceIdentifier() );
  if ( post_SourceName_sourceIdentifier ) 
    post_SourceName_sourceIdentifier( Me );

  if ( post_SourceName ) 
    post_SourceName( Me );
}


void default_trav_SourceRef( const SourceRef& Me )
{
  if ( pre_SourceRef ) 
    pre_SourceRef( Me );

  if ( post_SourceRef ) 
    post_SourceRef( Me );
}


void default_trav_ImportedObjectList( const ImportedObjectList& Me )
{
  if ( pre_ImportedObjectList ) 
    pre_ImportedObjectList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ImportedObjectList_importedObject ) 
        pre_ImportedObjectList_importedObject( Me, i );
      if ( trav_ImportedObject ) 
        trav_ImportedObject( Me.importedObject( i ) );
      if ( post_ImportedObjectList_importedObject ) 
        post_ImportedObjectList_importedObject( Me, i );
  }

  if ( post_ImportedObjectList ) 
    post_ImportedObjectList( Me );
}


void default_trav_ImportedObject( const ImportedObject& Me )
{
  if ( pre_ImportedObject ) 
    pre_ImportedObject( Me );

  if ( Me.is_present_objectName())
    {
      if ( pre_ImportedObject_objectName ) 
        pre_ImportedObject_objectName( Me );
      if ( trav_ObjectName ) 
        trav_ObjectName( Me.objectName() );
      if ( post_ImportedObject_objectName ) 
        post_ImportedObject_objectName( Me );
    }

  if ( Me.is_present_objectType())
    {
      if ( pre_ImportedObject_objectType ) 
        pre_ImportedObject_objectType( Me );
      if ( trav_ObjectType ) 
        trav_ObjectType( Me.objectType() );
      if ( post_ImportedObject_objectType ) 
        post_ImportedObject_objectType( Me );
    }

  if ( Me.is_present_sourceName())
    {
      if ( pre_ImportedObject_sourceName ) 
        pre_ImportedObject_sourceName( Me );
      if ( trav_SourceName ) 
        trav_SourceName( Me.sourceName() );
      if ( post_ImportedObject_sourceName ) 
        post_ImportedObject_sourceName( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ImportedObject_comment ) 
        pre_ImportedObject_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ImportedObject_comment ) 
        post_ImportedObject_comment( Me );
    }

  if ( Me.is_present_testGroupRef())
    {
      if ( pre_ImportedObject_testGroupRef ) 
        pre_ImportedObject_testGroupRef( Me );
      if ( trav_TestGroupRef ) 
        trav_TestGroupRef( Me.testGroupRef() );
      if ( post_ImportedObject_testGroupRef ) 
        post_ImportedObject_testGroupRef( Me );
    }

  if ( Me.is_present_selExprId())
    {
      if ( pre_ImportedObject_selExprId ) 
        pre_ImportedObject_selExprId( Me );
      if ( trav_SelExprId ) 
        trav_SelExprId( Me.selExprId() );
      if ( post_ImportedObject_selExprId ) 
        post_ImportedObject_selExprId( Me );
    }

  if ( Me.is_present_description())
    {
      if ( pre_ImportedObject_description ) 
        pre_ImportedObject_description( Me );
      if ( trav_Description ) 
        trav_Description( Me.description() );
      if ( post_ImportedObject_description ) 
        post_ImportedObject_description( Me );
    }

  if ( post_ImportedObject ) 
    post_ImportedObject( Me );
}


void default_trav_ObjectName( const ObjectName& Me )
{
  if ( pre_ObjectName ) 
    pre_ObjectName( Me );

  if ( pre_ObjectName_objectIdentifier ) 
    pre_ObjectName_objectIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.objectIdentifier() );
  if ( post_ObjectName_objectIdentifier ) 
    post_ObjectName_objectIdentifier( Me );

  if ( post_ObjectName ) 
    post_ObjectName( Me );
}


void default_trav_ObjectType( const ObjectType& Me )
{
  if ( pre_ObjectType ) 
    pre_ObjectType( Me );

  if ( pre_ObjectType_objectIdentifier ) 
    pre_ObjectType_objectIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.objectIdentifier() );
  if ( post_ObjectType_objectIdentifier ) 
    post_ObjectType_objectIdentifier( Me );

  if ( post_ObjectType ) 
    post_ObjectType( Me );
}


void default_trav_DeclarationsPart( const DeclarationsPart& Me )
{
  if ( pre_DeclarationsPart ) 
    pre_DeclarationsPart( Me );

  if ( pre_DeclarationsPart_definitions ) 
    pre_DeclarationsPart_definitions( Me );
  if ( trav_Definitions ) 
    trav_Definitions( Me.definitions() );
  if ( post_DeclarationsPart_definitions ) 
    post_DeclarationsPart_definitions( Me );

  if ( pre_DeclarationsPart_paramAndSelection ) 
    pre_DeclarationsPart_paramAndSelection( Me );
  if ( trav_ParamAndSelection ) 
    trav_ParamAndSelection( Me.paramAndSelection() );
  if ( post_DeclarationsPart_paramAndSelection ) 
    post_DeclarationsPart_paramAndSelection( Me );

  if ( pre_DeclarationsPart_declarations ) 
    pre_DeclarationsPart_declarations( Me );
  if ( trav_Declarations ) 
    trav_Declarations( Me.declarations() );
  if ( post_DeclarationsPart_declarations ) 
    post_DeclarationsPart_declarations( Me );

  if ( pre_DeclarationsPart_complexDefinitions ) 
    pre_DeclarationsPart_complexDefinitions( Me );
  if ( trav_ComplexDefinitions ) 
    trav_ComplexDefinitions( Me.complexDefinitions() );
  if ( post_DeclarationsPart_complexDefinitions ) 
    post_DeclarationsPart_complexDefinitions( Me );

  if ( post_DeclarationsPart ) 
    post_DeclarationsPart( Me );
}


void default_trav_Definitions( const Definitions& Me )
{
  if ( pre_Definitions ) 
    pre_Definitions( Me );

  if ( pre_Definitions_ts_TypeDefs ) 
    pre_Definitions_ts_TypeDefs( Me );
  if ( trav_TS_TypeDefs ) 
    trav_TS_TypeDefs( Me.ts_TypeDefs() );
  if ( post_Definitions_ts_TypeDefs ) 
    post_Definitions_ts_TypeDefs( Me );

  if ( pre_Definitions_encodingDefs ) 
    pre_Definitions_encodingDefs( Me );
  if ( trav_EncodingDefs ) 
    trav_EncodingDefs( Me.encodingDefs() );
  if ( post_Definitions_encodingDefs ) 
    post_Definitions_encodingDefs( Me );

  if ( pre_Definitions_ts_OpDefs ) 
    pre_Definitions_ts_OpDefs( Me );
  if ( trav_TS_OpDefs ) 
    trav_TS_OpDefs( Me.ts_OpDefs() );
  if ( post_Definitions_ts_OpDefs ) 
    post_Definitions_ts_OpDefs( Me );

  if ( pre_Definitions_ts_ProcDefs ) 
    pre_Definitions_ts_ProcDefs( Me );
  if ( trav_TS_ProcDefs ) 
    trav_TS_ProcDefs( Me.ts_ProcDefs() );
  if ( post_Definitions_ts_ProcDefs ) 
    post_Definitions_ts_ProcDefs( Me );

  if ( post_Definitions ) 
    post_Definitions( Me );
}


void default_trav_TS_TypeDefs( const TS_TypeDefs& Me )
{
  if ( pre_TS_TypeDefs ) 
    pre_TS_TypeDefs( Me );

  if ( pre_TS_TypeDefs_simpleTypeDefs ) 
    pre_TS_TypeDefs_simpleTypeDefs( Me );
  if ( trav_SimpleTypeDefs ) 
    trav_SimpleTypeDefs( Me.simpleTypeDefs() );
  if ( post_TS_TypeDefs_simpleTypeDefs ) 
    post_TS_TypeDefs_simpleTypeDefs( Me );

  if ( pre_TS_TypeDefs_structTypeDefs ) 
    pre_TS_TypeDefs_structTypeDefs( Me );
  if ( trav_StructTypeDefs ) 
    trav_StructTypeDefs( Me.structTypeDefs() );
  if ( post_TS_TypeDefs_structTypeDefs ) 
    post_TS_TypeDefs_structTypeDefs( Me );

  if ( pre_TS_TypeDefs_asn1_TypeDefs ) 
    pre_TS_TypeDefs_asn1_TypeDefs( Me );
  if ( trav_ASN1_TypeDefs ) 
    trav_ASN1_TypeDefs( Me.asn1_TypeDefs() );
  if ( post_TS_TypeDefs_asn1_TypeDefs ) 
    post_TS_TypeDefs_asn1_TypeDefs( Me );

  if ( pre_TS_TypeDefs_asn1_TypeRefs ) 
    pre_TS_TypeDefs_asn1_TypeRefs( Me );
  if ( trav_ASN1_TypeRefs ) 
    trav_ASN1_TypeRefs( Me.asn1_TypeRefs() );
  if ( post_TS_TypeDefs_asn1_TypeRefs ) 
    post_TS_TypeDefs_asn1_TypeRefs( Me );

  if ( post_TS_TypeDefs ) 
    post_TS_TypeDefs( Me );
}


void default_trav_EncodingDefs( const EncodingDefs& Me )
{
  if ( pre_EncodingDefs ) 
    pre_EncodingDefs( Me );

  if ( pre_EncodingDefs_encodingDefinitions ) 
    pre_EncodingDefs_encodingDefinitions( Me );
  if ( trav_EncodingDefinitions ) 
    trav_EncodingDefinitions( Me.encodingDefinitions() );
  if ( post_EncodingDefs_encodingDefinitions ) 
    post_EncodingDefs_encodingDefinitions( Me );

  if ( pre_EncodingDefs_encodingVariations ) 
    pre_EncodingDefs_encodingVariations( Me );
  if ( trav_EncodingVariations ) 
    trav_EncodingVariations( Me.encodingVariations() );
  if ( post_EncodingDefs_encodingVariations ) 
    post_EncodingDefs_encodingVariations( Me );

  if ( pre_EncodingDefs_invalidFieldEncodingDefs ) 
    pre_EncodingDefs_invalidFieldEncodingDefs( Me );
  if ( trav_InvalidFieldEncodingDefs ) 
    trav_InvalidFieldEncodingDefs( Me.invalidFieldEncodingDefs() );
  if ( post_EncodingDefs_invalidFieldEncodingDefs ) 
    post_EncodingDefs_invalidFieldEncodingDefs( Me );

  if ( post_EncodingDefs ) 
    post_EncodingDefs( Me );
}


void default_trav_EncodingDefinitions( const EncodingDefinitions& Me )
{
  if ( pre_EncodingDefinitions ) 
    pre_EncodingDefinitions( Me );

  if ( pre_EncodingDefinitions_encodingDefList ) 
    pre_EncodingDefinitions_encodingDefList( Me );
  if ( trav_EncodingDefList ) 
    trav_EncodingDefList( Me.encodingDefList() );
  if ( post_EncodingDefinitions_encodingDefList ) 
    post_EncodingDefinitions_encodingDefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_EncodingDefinitions_detailedComment ) 
        pre_EncodingDefinitions_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_EncodingDefinitions_detailedComment ) 
        post_EncodingDefinitions_detailedComment( Me );
    }

  if ( post_EncodingDefinitions ) 
    post_EncodingDefinitions( Me );
}


void default_trav_EncodingDefList( const EncodingDefList& Me )
{
  if ( pre_EncodingDefList ) 
    pre_EncodingDefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_EncodingDefList_encodingDefinition ) 
        pre_EncodingDefList_encodingDefinition( Me, i );
      if ( trav_EncodingDefinition ) 
        trav_EncodingDefinition( Me.encodingDefinition( i ) );
      if ( post_EncodingDefList_encodingDefinition ) 
        post_EncodingDefList_encodingDefinition( Me, i );
  }

  if ( post_EncodingDefList ) 
    post_EncodingDefList( Me );
}


void default_trav_EncodingDefinition( const EncodingDefinition& Me )
{
  if ( pre_EncodingDefinition ) 
    pre_EncodingDefinition( Me );

  if ( Me.is_present_encodingRuleId())
    {
      if ( pre_EncodingDefinition_encodingRuleId ) 
        pre_EncodingDefinition_encodingRuleId( Me );
      if ( trav_EncodingRuleId ) 
        trav_EncodingRuleId( Me.encodingRuleId() );
      if ( post_EncodingDefinition_encodingRuleId ) 
        post_EncodingDefinition_encodingRuleId( Me );
    }

  if ( Me.is_present_encodingRef())
    {
      if ( pre_EncodingDefinition_encodingRef ) 
        pre_EncodingDefinition_encodingRef( Me );
      if ( trav_EncodingRef ) 
        trav_EncodingRef( Me.encodingRef() );
      if ( post_EncodingDefinition_encodingRef ) 
        post_EncodingDefinition_encodingRef( Me );
    }

  if ( Me.is_present_encodingDefault())
    {
      if ( pre_EncodingDefinition_encodingDefault ) 
        pre_EncodingDefinition_encodingDefault( Me );
      if ( trav_EncodingDefault ) 
        trav_EncodingDefault( Me.encodingDefault() );
      if ( post_EncodingDefinition_encodingDefault ) 
        post_EncodingDefinition_encodingDefault( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_EncodingDefinition_comment ) 
        pre_EncodingDefinition_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_EncodingDefinition_comment ) 
        post_EncodingDefinition_comment( Me );
    }

  if ( post_EncodingDefinition ) 
    post_EncodingDefinition( Me );
}


void default_trav_EncodingDefault( const EncodingDefault& Me )
{
  if ( pre_EncodingDefault ) 
    pre_EncodingDefault( Me );

  if ( pre_EncodingDefault_defaultExpression ) 
    pre_EncodingDefault_defaultExpression( Me );
  if ( trav_DefaultExpression ) 
    trav_DefaultExpression( Me.defaultExpression() );
  if ( post_EncodingDefault_defaultExpression ) 
    post_EncodingDefault_defaultExpression( Me );

  if ( post_EncodingDefault ) 
    post_EncodingDefault( Me );
}


void default_trav_EncodingVariations( const EncodingVariations& Me )
{
  if ( pre_EncodingVariations ) 
    pre_EncodingVariations( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_EncodingVariations_encodingVariationSet ) 
        pre_EncodingVariations_encodingVariationSet( Me, i );
      if ( trav_EncodingVariationSet ) 
        trav_EncodingVariationSet( Me.encodingVariationSet( i ) );
      if ( post_EncodingVariations_encodingVariationSet ) 
        post_EncodingVariations_encodingVariationSet( Me, i );
  }

  if ( post_EncodingVariations ) 
    post_EncodingVariations( Me );
}


void default_trav_EncodingVariationSet( const EncodingVariationSet& Me )
{
  if ( pre_EncodingVariationSet ) 
    pre_EncodingVariationSet( Me );

  if ( Me.is_present_encodingRuleId())
    {
      if ( pre_EncodingVariationSet_encodingRuleId ) 
        pre_EncodingVariationSet_encodingRuleId( Me );
      if ( trav_EncodingRuleId ) 
        trav_EncodingRuleId( Me.encodingRuleId() );
      if ( post_EncodingVariationSet_encodingRuleId ) 
        post_EncodingVariationSet_encodingRuleId( Me );
    }

  if ( Me.is_present_encoding_TypeList())
    {
      if ( pre_EncodingVariationSet_encoding_TypeList ) 
        pre_EncodingVariationSet_encoding_TypeList( Me );
      if ( trav_Encoding_TypeList ) 
        trav_Encoding_TypeList( Me.encoding_TypeList() );
      if ( post_EncodingVariationSet_encoding_TypeList ) 
        post_EncodingVariationSet_encoding_TypeList( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_EncodingVariationSet_comment ) 
        pre_EncodingVariationSet_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_EncodingVariationSet_comment ) 
        post_EncodingVariationSet_comment( Me );
    }

  if ( pre_EncodingVariationSet_encodingVariationList ) 
    pre_EncodingVariationSet_encodingVariationList( Me );
  if ( trav_EncodingVariationList ) 
    trav_EncodingVariationList( Me.encodingVariationList() );
  if ( post_EncodingVariationSet_encodingVariationList ) 
    post_EncodingVariationSet_encodingVariationList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_EncodingVariationSet_detailedComment ) 
        pre_EncodingVariationSet_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_EncodingVariationSet_detailedComment ) 
        post_EncodingVariationSet_detailedComment( Me );
    }

  if ( post_EncodingVariationSet ) 
    post_EncodingVariationSet( Me );
}


void default_trav_EncodingVariationList( const EncodingVariationList& Me )
{
  if ( pre_EncodingVariationList ) 
    pre_EncodingVariationList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_EncodingVariationList_encodingVariation ) 
        pre_EncodingVariationList_encodingVariation( Me, i );
      if ( trav_EncodingVariation ) 
        trav_EncodingVariation( Me.encodingVariation( i ) );
      if ( post_EncodingVariationList_encodingVariation ) 
        post_EncodingVariationList_encodingVariation( Me, i );
  }

  if ( post_EncodingVariationList ) 
    post_EncodingVariationList( Me );
}


void default_trav_EncodingVariation( const EncodingVariation& Me )
{
  if ( pre_EncodingVariation ) 
    pre_EncodingVariation( Me );

  if ( Me.is_present_encodingVariationId())
    {
      if ( pre_EncodingVariation_encodingVariationId ) 
        pre_EncodingVariation_encodingVariationId( Me );
      if ( trav_EncodingVariationId ) 
        trav_EncodingVariationId( Me.encodingVariationId() );
      if ( post_EncodingVariation_encodingVariationId ) 
        post_EncodingVariation_encodingVariationId( Me );
    }

  if ( Me.is_present_variationRef())
    {
      if ( pre_EncodingVariation_variationRef ) 
        pre_EncodingVariation_variationRef( Me );
      if ( trav_VariationRef ) 
        trav_VariationRef( Me.variationRef() );
      if ( post_EncodingVariation_variationRef ) 
        post_EncodingVariation_variationRef( Me );
    }

  if ( Me.is_present_variationDefault())
    {
      if ( pre_EncodingVariation_variationDefault ) 
        pre_EncodingVariation_variationDefault( Me );
      if ( trav_VariationDefault ) 
        trav_VariationDefault( Me.variationDefault() );
      if ( post_EncodingVariation_variationDefault ) 
        post_EncodingVariation_variationDefault( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_EncodingVariation_comment ) 
        pre_EncodingVariation_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_EncodingVariation_comment ) 
        post_EncodingVariation_comment( Me );
    }

  if ( post_EncodingVariation ) 
    post_EncodingVariation( Me );
}


void default_trav_VariationDefault( const VariationDefault& Me )
{
  if ( pre_VariationDefault ) 
    pre_VariationDefault( Me );

  if ( pre_VariationDefault_expression ) 
    pre_VariationDefault_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_VariationDefault_expression ) 
    post_VariationDefault_expression( Me );

  if ( post_VariationDefault ) 
    post_VariationDefault( Me );
}


void default_trav_EncodingVariationId( const EncodingVariationId& Me )
{
  if ( pre_EncodingVariationId ) 
    pre_EncodingVariationId( Me );

  if ( pre_EncodingVariationId_encVariationIdAndParList ) 
    pre_EncodingVariationId_encVariationIdAndParList( Me );
  if ( trav_EncVariationIdAndParList ) 
    trav_EncVariationIdAndParList( Me.encVariationIdAndParList() );
  if ( post_EncodingVariationId_encVariationIdAndParList ) 
    post_EncodingVariationId_encVariationIdAndParList( Me );

  if ( post_EncodingVariationId ) 
    post_EncodingVariationId( Me );
}


void default_trav_EncVariationIdAndParList( const EncVariationIdAndParList& Me )
{
  if ( pre_EncVariationIdAndParList ) 
    pre_EncVariationIdAndParList( Me );

  if ( pre_EncVariationIdAndParList_encVariationIdentifier ) 
    pre_EncVariationIdAndParList_encVariationIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.encVariationIdentifier() );
  if ( post_EncVariationIdAndParList_encVariationIdentifier ) 
    post_EncVariationIdAndParList_encVariationIdentifier( Me );

  if ( pre_EncVariationIdAndParList_formalParList ) 
    pre_EncVariationIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_EncVariationIdAndParList_formalParList ) 
    post_EncVariationIdAndParList_formalParList( Me );

  if ( post_EncVariationIdAndParList ) 
    post_EncVariationIdAndParList( Me );
}


void default_trav_InvalidFieldEncodingDefs( const InvalidFieldEncodingDefs& Me )
{
  if ( pre_InvalidFieldEncodingDefs ) 
    pre_InvalidFieldEncodingDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_InvalidFieldEncodingDefs_invalidFieldEncodingDef ) 
        pre_InvalidFieldEncodingDefs_invalidFieldEncodingDef( Me, i );
      if ( trav_InvalidFieldEncodingDef ) 
        trav_InvalidFieldEncodingDef( Me.invalidFieldEncodingDef( i ) );
      if ( post_InvalidFieldEncodingDefs_invalidFieldEncodingDef ) 
        post_InvalidFieldEncodingDefs_invalidFieldEncodingDef( Me, i );
  }

  if ( post_InvalidFieldEncodingDefs ) 
    post_InvalidFieldEncodingDefs( Me );
}


void default_trav_InvalidFieldEncodingDef( const InvalidFieldEncodingDef& Me )
{
  if ( pre_InvalidFieldEncodingDef ) 
    pre_InvalidFieldEncodingDef( Me );

  if ( Me.is_present_invalidFieldEncodingId())
    {
      if ( pre_InvalidFieldEncodingDef_invalidFieldEncodingId ) 
        pre_InvalidFieldEncodingDef_invalidFieldEncodingId( Me );
      if ( trav_InvalidFieldEncodingId ) 
        trav_InvalidFieldEncodingId( Me.invalidFieldEncodingId() );
      if ( post_InvalidFieldEncodingDef_invalidFieldEncodingId ) 
        post_InvalidFieldEncodingDef_invalidFieldEncodingId( Me );
    }

  if ( Me.is_present_encoding_TypeList())
    {
      if ( pre_InvalidFieldEncodingDef_encoding_TypeList ) 
        pre_InvalidFieldEncodingDef_encoding_TypeList( Me );
      if ( trav_Encoding_TypeList ) 
        trav_Encoding_TypeList( Me.encoding_TypeList() );
      if ( post_InvalidFieldEncodingDef_encoding_TypeList ) 
        post_InvalidFieldEncodingDef_encoding_TypeList( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_InvalidFieldEncodingDef_comment ) 
        pre_InvalidFieldEncodingDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_InvalidFieldEncodingDef_comment ) 
        post_InvalidFieldEncodingDef_comment( Me );
    }

  if ( Me.is_present_invalidFieldEncodingDefinition())
    {
      if ( pre_InvalidFieldEncodingDef_invalidFieldEncodingDefinition ) 
        pre_InvalidFieldEncodingDef_invalidFieldEncodingDefinition( Me );
      if ( trav_InvalidFieldEncodingDefinition ) 
        trav_InvalidFieldEncodingDefinition( Me.invalidFieldEncodingDefinition() );
      if ( post_InvalidFieldEncodingDef_invalidFieldEncodingDefinition ) 
        post_InvalidFieldEncodingDef_invalidFieldEncodingDefinition( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_InvalidFieldEncodingDef_detailedComment ) 
        pre_InvalidFieldEncodingDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_InvalidFieldEncodingDef_detailedComment ) 
        post_InvalidFieldEncodingDef_detailedComment( Me );
    }

  if ( post_InvalidFieldEncodingDef ) 
    post_InvalidFieldEncodingDef( Me );
}


void default_trav_InvalidFieldEncodingDefinition( const InvalidFieldEncodingDefinition& Me )
{
  if ( pre_InvalidFieldEncodingDefinition ) 
    pre_InvalidFieldEncodingDefinition( Me );

  if ( post_InvalidFieldEncodingDefinition ) 
    post_InvalidFieldEncodingDefinition( Me );
}


void default_trav_InvalidFieldEncodingId( const InvalidFieldEncodingId& Me )
{
  if ( pre_InvalidFieldEncodingId ) 
    pre_InvalidFieldEncodingId( Me );

  if ( pre_InvalidFieldEncodingId_invalidFieldEncodingIdAndParList ) 
    pre_InvalidFieldEncodingId_invalidFieldEncodingIdAndParList( Me );
  if ( trav_InvalidFieldEncodingIdAndParList ) 
    trav_InvalidFieldEncodingIdAndParList( Me.invalidFieldEncodingIdAndParList() );
  if ( post_InvalidFieldEncodingId_invalidFieldEncodingIdAndParList ) 
    post_InvalidFieldEncodingId_invalidFieldEncodingIdAndParList( Me );

  if ( post_InvalidFieldEncodingId ) 
    post_InvalidFieldEncodingId( Me );
}


void default_trav_InvalidFieldEncodingIdAndParList( const InvalidFieldEncodingIdAndParList& Me )
{
  if ( pre_InvalidFieldEncodingIdAndParList ) 
    pre_InvalidFieldEncodingIdAndParList( Me );

  if ( pre_InvalidFieldEncodingIdAndParList_invalidFieldEncodingIdentifier ) 
    pre_InvalidFieldEncodingIdAndParList_invalidFieldEncodingIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.invalidFieldEncodingIdentifier() );
  if ( post_InvalidFieldEncodingIdAndParList_invalidFieldEncodingIdentifier ) 
    post_InvalidFieldEncodingIdAndParList_invalidFieldEncodingIdentifier( Me );

  if ( pre_InvalidFieldEncodingIdAndParList_formalParList ) 
    pre_InvalidFieldEncodingIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_InvalidFieldEncodingIdAndParList_formalParList ) 
    post_InvalidFieldEncodingIdAndParList_formalParList( Me );

  if ( post_InvalidFieldEncodingIdAndParList ) 
    post_InvalidFieldEncodingIdAndParList( Me );
}


void default_trav_SimpleTypeDefs( const SimpleTypeDefs& Me )
{
  if ( pre_SimpleTypeDefs ) 
    pre_SimpleTypeDefs( Me );

  if ( pre_SimpleTypeDefs_simpleTypeDefList ) 
    pre_SimpleTypeDefs_simpleTypeDefList( Me );
  if ( trav_SimpleTypeDefList ) 
    trav_SimpleTypeDefList( Me.simpleTypeDefList() );
  if ( post_SimpleTypeDefs_simpleTypeDefList ) 
    post_SimpleTypeDefs_simpleTypeDefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_SimpleTypeDefs_detailedComment ) 
        pre_SimpleTypeDefs_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_SimpleTypeDefs_detailedComment ) 
        post_SimpleTypeDefs_detailedComment( Me );
    }

  if ( post_SimpleTypeDefs ) 
    post_SimpleTypeDefs( Me );
}


void default_trav_SimpleTypeDefList( const SimpleTypeDefList& Me )
{
  if ( pre_SimpleTypeDefList ) 
    pre_SimpleTypeDefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SimpleTypeDefList_simpleTypeDef ) 
        pre_SimpleTypeDefList_simpleTypeDef( Me, i );
      if ( trav_SimpleTypeDef ) 
        trav_SimpleTypeDef( Me.simpleTypeDef( i ) );
      if ( post_SimpleTypeDefList_simpleTypeDef ) 
        post_SimpleTypeDefList_simpleTypeDef( Me, i );
  }

  if ( post_SimpleTypeDefList ) 
    post_SimpleTypeDefList( Me );
}


void default_trav_SimpleTypeDef( const SimpleTypeDef& Me )
{
  if ( pre_SimpleTypeDef ) 
    pre_SimpleTypeDef( Me );

  if ( Me.is_present_simpleTypeId())
    {
      if ( pre_SimpleTypeDef_simpleTypeId ) 
        pre_SimpleTypeDef_simpleTypeId( Me );
      if ( trav_SimpleTypeId ) 
        trav_SimpleTypeId( Me.simpleTypeId() );
      if ( post_SimpleTypeDef_simpleTypeId ) 
        post_SimpleTypeDef_simpleTypeId( Me );
    }

  if ( Me.is_present_simpleTypeDefinition())
    {
      if ( pre_SimpleTypeDef_simpleTypeDefinition ) 
        pre_SimpleTypeDef_simpleTypeDefinition( Me );
      if ( trav_SimpleTypeDefinition ) 
        trav_SimpleTypeDefinition( Me.simpleTypeDefinition() );
      if ( post_SimpleTypeDef_simpleTypeDefinition ) 
        post_SimpleTypeDef_simpleTypeDefinition( Me );
    }

  if ( Me.is_present_pdu_FieldEncoding())
    {
      if ( pre_SimpleTypeDef_pdu_FieldEncoding ) 
        pre_SimpleTypeDef_pdu_FieldEncoding( Me );
      if ( trav_PDU_FieldEncoding ) 
        trav_PDU_FieldEncoding( Me.pdu_FieldEncoding() );
      if ( post_SimpleTypeDef_pdu_FieldEncoding ) 
        post_SimpleTypeDef_pdu_FieldEncoding( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_SimpleTypeDef_comment ) 
        pre_SimpleTypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_SimpleTypeDef_comment ) 
        post_SimpleTypeDef_comment( Me );
    }

  if ( post_SimpleTypeDef ) 
    post_SimpleTypeDef( Me );
}


void default_trav_SimpleTypeId( const SimpleTypeId& Me )
{
  if ( pre_SimpleTypeId ) 
    pre_SimpleTypeId( Me );

  if ( pre_SimpleTypeId_simpleTypeIdentifier ) 
    pre_SimpleTypeId_simpleTypeIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.simpleTypeIdentifier() );
  if ( post_SimpleTypeId_simpleTypeIdentifier ) 
    post_SimpleTypeId_simpleTypeIdentifier( Me );

  if ( post_SimpleTypeId ) 
    post_SimpleTypeId( Me );
}


void default_trav_SimpleTypeDefinition( const SimpleTypeDefinition& Me )
{
  if ( pre_SimpleTypeDefinition ) 
    pre_SimpleTypeDefinition( Me );

  if ( pre_SimpleTypeDefinition_typeAndRestriction ) 
    pre_SimpleTypeDefinition_typeAndRestriction( Me );
  if ( trav_TypeAndRestriction ) 
    trav_TypeAndRestriction( Me.typeAndRestriction() );
  if ( post_SimpleTypeDefinition_typeAndRestriction ) 
    post_SimpleTypeDefinition_typeAndRestriction( Me );

  if ( post_SimpleTypeDefinition ) 
    post_SimpleTypeDefinition( Me );
}


void default_trav_TypeAndRestriction( const TypeAndRestriction& Me )
{
  if ( pre_TypeAndRestriction ) 
    pre_TypeAndRestriction( Me );

  if ( pre_TypeAndRestriction_ttcn_Type ) 
    pre_TypeAndRestriction_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TypeAndRestriction_ttcn_Type ) 
    post_TypeAndRestriction_ttcn_Type( Me );

  if ( Me.is_present_restriction())
    {
      if ( pre_TypeAndRestriction_restriction ) 
        pre_TypeAndRestriction_restriction( Me );
      if ( trav_Restriction ) 
        trav_Restriction( Me.restriction() );
      if ( post_TypeAndRestriction_restriction ) 
        post_TypeAndRestriction_restriction( Me );
    }

  if ( post_TypeAndRestriction ) 
    post_TypeAndRestriction( Me );
}


void default_trav_TTCN_Type( const TTCN_Type& Me )
{
  if ( pre_TTCN_Type ) 
    pre_TTCN_Type( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PredefinedType:
      if ( pre_TTCN_Type_predefinedType ) 
        pre_TTCN_Type_predefinedType( Me );
      if ( trav_PredefinedType ) 
        trav_PredefinedType( Me.predefinedType() );
      if ( post_TTCN_Type_predefinedType ) 
        post_TTCN_Type_predefinedType( Me );
      break;

    case Choices::c_ReferenceType:
      if ( pre_TTCN_Type_referenceType ) 
        pre_TTCN_Type_referenceType( Me );
      if ( trav_ReferenceType ) 
        trav_ReferenceType( Me.referenceType() );
      if ( post_TTCN_Type_referenceType ) 
        post_TTCN_Type_referenceType( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TTCN_Type: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TTCN_Type ) 
    post_TTCN_Type( Me );
}


void default_trav_TypeOrPDU( const TypeOrPDU& Me )
{
  if ( pre_TypeOrPDU ) 
    pre_TypeOrPDU( Me );

  switch ( Me.choice() )
    {
    case Choices::c_TTCN_Type:
      if ( pre_TypeOrPDU_ttcn_Type ) 
        pre_TypeOrPDU_ttcn_Type( Me );
      if ( trav_TTCN_Type ) 
        trav_TTCN_Type( Me.ttcn_Type() );
      if ( post_TypeOrPDU_ttcn_Type ) 
        post_TypeOrPDU_ttcn_Type( Me );
      break;

    case Choices::c_PDU:
      if ( pre_TypeOrPDU_pdu ) 
        pre_TypeOrPDU_pdu( Me );
      if ( trav_PDU ) 
        trav_PDU( Me.pdu() );
      if ( post_TypeOrPDU_pdu ) 
        post_TypeOrPDU_pdu( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TypeOrPDU: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TypeOrPDU ) 
    post_TypeOrPDU( Me );
}


void default_trav_PredefinedType( const PredefinedType& Me )
{
  if ( pre_PredefinedType ) 
    pre_PredefinedType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_INTEGER:
      if ( pre_PredefinedType_integer ) 
        pre_PredefinedType_integer( Me );
      if ( trav_INTEGER ) 
        trav_INTEGER( Me.integer() );
      if ( post_PredefinedType_integer ) 
        post_PredefinedType_integer( Me );
      break;

    case Choices::c_BOOLEAN:
      if ( pre_PredefinedType_boolean ) 
        pre_PredefinedType_boolean( Me );
      if ( trav_BOOLEAN ) 
        trav_BOOLEAN( Me.boolean() );
      if ( post_PredefinedType_boolean ) 
        post_PredefinedType_boolean( Me );
      break;

    case Choices::c_BITSTRING:
      if ( pre_PredefinedType_bitstring ) 
        pre_PredefinedType_bitstring( Me );
      if ( trav_BITSTRING ) 
        trav_BITSTRING( Me.bitstring() );
      if ( post_PredefinedType_bitstring ) 
        post_PredefinedType_bitstring( Me );
      break;

    case Choices::c_HEXSTRING:
      if ( pre_PredefinedType_hexstring ) 
        pre_PredefinedType_hexstring( Me );
      if ( trav_HEXSTRING ) 
        trav_HEXSTRING( Me.hexstring() );
      if ( post_PredefinedType_hexstring ) 
        post_PredefinedType_hexstring( Me );
      break;

    case Choices::c_OCTETSTRING:
      if ( pre_PredefinedType_octetstring ) 
        pre_PredefinedType_octetstring( Me );
      if ( trav_OCTETSTRING ) 
        trav_OCTETSTRING( Me.octetstring() );
      if ( post_PredefinedType_octetstring ) 
        post_PredefinedType_octetstring( Me );
      break;

    case Choices::c_R_TYPE:
      if ( pre_PredefinedType_r_Type ) 
        pre_PredefinedType_r_Type( Me );
      if ( trav_R_TYPE ) 
        trav_R_TYPE( Me.r_Type() );
      if ( post_PredefinedType_r_Type ) 
        post_PredefinedType_r_Type( Me );
      break;

    case Choices::c_CharacterString:
      if ( pre_PredefinedType_characterString ) 
        pre_PredefinedType_characterString( Me );
      if ( trav_CharacterString ) 
        trav_CharacterString( Me.characterString() );
      if ( post_PredefinedType_characterString ) 
        post_PredefinedType_characterString( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node PredefinedType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_PredefinedType ) 
    post_PredefinedType( Me );
}


void default_trav_ReferenceType( const ReferenceType& Me )
{
  if ( pre_ReferenceType ) 
    pre_ReferenceType( Me );

  if ( pre_ReferenceType_identifier ) 
    pre_ReferenceType_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_ReferenceType_identifier ) 
    post_ReferenceType_identifier( Me );

  if ( post_ReferenceType ) 
    post_ReferenceType( Me );
}


void default_trav_CharacterString( const CharacterString& Me )
{
  if ( pre_CharacterString ) 
    pre_CharacterString( Me );

  switch ( Me.choice() )
    {
    case Choices::c_NumericString:
      if ( pre_CharacterString_numericString ) 
        pre_CharacterString_numericString( Me );
      if ( trav_NumericString ) 
        trav_NumericString( Me.numericString() );
      if ( post_CharacterString_numericString ) 
        post_CharacterString_numericString( Me );
      break;

    case Choices::c_PrintableString:
      if ( pre_CharacterString_printableString ) 
        pre_CharacterString_printableString( Me );
      if ( trav_PrintableString ) 
        trav_PrintableString( Me.printableString() );
      if ( post_CharacterString_printableString ) 
        post_CharacterString_printableString( Me );
      break;

    case Choices::c_TeletexString:
      if ( pre_CharacterString_teletexString ) 
        pre_CharacterString_teletexString( Me );
      if ( trav_TeletexString ) 
        trav_TeletexString( Me.teletexString() );
      if ( post_CharacterString_teletexString ) 
        post_CharacterString_teletexString( Me );
      break;

    case Choices::c_VideotexString:
      if ( pre_CharacterString_videotexString ) 
        pre_CharacterString_videotexString( Me );
      if ( trav_VideotexString ) 
        trav_VideotexString( Me.videotexString() );
      if ( post_CharacterString_videotexString ) 
        post_CharacterString_videotexString( Me );
      break;

    case Choices::c_VisibleString:
      if ( pre_CharacterString_visibleString ) 
        pre_CharacterString_visibleString( Me );
      if ( trav_VisibleString ) 
        trav_VisibleString( Me.visibleString() );
      if ( post_CharacterString_visibleString ) 
        post_CharacterString_visibleString( Me );
      break;

    case Choices::c_IA5String:
      if ( pre_CharacterString_ia5String ) 
        pre_CharacterString_ia5String( Me );
      if ( trav_IA5String ) 
        trav_IA5String( Me.ia5String() );
      if ( post_CharacterString_ia5String ) 
        post_CharacterString_ia5String( Me );
      break;

    case Choices::c_GraphicString:
      if ( pre_CharacterString_graphicString ) 
        pre_CharacterString_graphicString( Me );
      if ( trav_GraphicString ) 
        trav_GraphicString( Me.graphicString() );
      if ( post_CharacterString_graphicString ) 
        post_CharacterString_graphicString( Me );
      break;

    case Choices::c_GeneralString:
      if ( pre_CharacterString_generalString ) 
        pre_CharacterString_generalString( Me );
      if ( trav_GeneralString ) 
        trav_GeneralString( Me.generalString() );
      if ( post_CharacterString_generalString ) 
        post_CharacterString_generalString( Me );
      break;

    case Choices::c_T61String:
      if ( pre_CharacterString_t61String ) 
        pre_CharacterString_t61String( Me );
      if ( trav_T61String ) 
        trav_T61String( Me.t61String() );
      if ( post_CharacterString_t61String ) 
        post_CharacterString_t61String( Me );
      break;

    case Choices::c_ISO646String:
      if ( pre_CharacterString_iso646String ) 
        pre_CharacterString_iso646String( Me );
      if ( trav_ISO646String ) 
        trav_ISO646String( Me.iso646String() );
      if ( post_CharacterString_iso646String ) 
        post_CharacterString_iso646String( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node CharacterString: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_CharacterString ) 
    post_CharacterString( Me );
}


void default_trav_Restriction( const Restriction& Me )
{
  if ( pre_Restriction ) 
    pre_Restriction( Me );

  switch ( Me.choice() )
    {
    case Choices::c_LengthRestriction:
      if ( pre_Restriction_lengthRestriction ) 
        pre_Restriction_lengthRestriction( Me );
      if ( trav_LengthRestriction ) 
        trav_LengthRestriction( Me.lengthRestriction() );
      if ( post_Restriction_lengthRestriction ) 
        post_Restriction_lengthRestriction( Me );
      break;

    case Choices::c_IntegerRange:
      if ( pre_Restriction_integerRange ) 
        pre_Restriction_integerRange( Me );
      if ( trav_IntegerRange ) 
        trav_IntegerRange( Me.integerRange() );
      if ( post_Restriction_integerRange ) 
        post_Restriction_integerRange( Me );
      break;

    case Choices::c_SimpleValueList:
      if ( pre_Restriction_simpleValueList ) 
        pre_Restriction_simpleValueList( Me );
      if ( trav_SimpleValueList ) 
        trav_SimpleValueList( Me.simpleValueList() );
      if ( post_Restriction_simpleValueList ) 
        post_Restriction_simpleValueList( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Restriction: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Restriction ) 
    post_Restriction( Me );
}


void default_trav_LengthRestriction( const LengthRestriction& Me )
{
  if ( pre_LengthRestriction ) 
    pre_LengthRestriction( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SingleTypeLength:
      if ( pre_LengthRestriction_singleTypeLength ) 
        pre_LengthRestriction_singleTypeLength( Me );
      if ( trav_SingleTypeLength ) 
        trav_SingleTypeLength( Me.singleTypeLength() );
      if ( post_LengthRestriction_singleTypeLength ) 
        post_LengthRestriction_singleTypeLength( Me );
      break;

    case Choices::c_RangeTypeLength:
      if ( pre_LengthRestriction_rangeTypeLength ) 
        pre_LengthRestriction_rangeTypeLength( Me );
      if ( trav_RangeTypeLength ) 
        trav_RangeTypeLength( Me.rangeTypeLength() );
      if ( post_LengthRestriction_rangeTypeLength ) 
        post_LengthRestriction_rangeTypeLength( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LengthRestriction: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LengthRestriction ) 
    post_LengthRestriction( Me );
}


void default_trav_SingleTypeLength( const SingleTypeLength& Me )
{
  if ( pre_SingleTypeLength ) 
    pre_SingleTypeLength( Me );

  if ( pre_SingleTypeLength_number ) 
    pre_SingleTypeLength_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_SingleTypeLength_number ) 
    post_SingleTypeLength_number( Me );

  if ( post_SingleTypeLength ) 
    post_SingleTypeLength( Me );
}


void default_trav_Comment( const Comment& Me )
{
  if ( pre_Comment ) 
    pre_Comment( Me );

  if ( post_Comment ) 
    post_Comment( Me );
}


void default_trav_VariationRef( const VariationRef& Me )
{
  if ( pre_VariationRef ) 
    pre_VariationRef( Me );

  if ( pre_VariationRef_variationReference ) 
    pre_VariationRef_variationReference( Me );
  if ( trav_VariationReference ) 
    trav_VariationReference( Me.variationReference() );
  if ( post_VariationRef_variationReference ) 
    post_VariationRef_variationReference( Me );

  if ( post_VariationRef ) 
    post_VariationRef( Me );
}


void default_trav_VariationReference( const VariationReference& Me )
{
  if ( pre_VariationReference ) 
    pre_VariationReference( Me );

  if ( post_VariationReference ) 
    post_VariationReference( Me );
}


void default_trav_PDU_FieldEncoding( const PDU_FieldEncoding& Me )
{
  if ( pre_PDU_FieldEncoding ) 
    pre_PDU_FieldEncoding( Me );

  if ( pre_PDU_FieldEncoding_pdu_FieldEncodingCall ) 
    pre_PDU_FieldEncoding_pdu_FieldEncodingCall( Me );
  if ( trav_PDU_FieldEncodingCall ) 
    trav_PDU_FieldEncodingCall( Me.pdu_FieldEncodingCall() );
  if ( post_PDU_FieldEncoding_pdu_FieldEncodingCall ) 
    post_PDU_FieldEncoding_pdu_FieldEncodingCall( Me );

  if ( post_PDU_FieldEncoding ) 
    post_PDU_FieldEncoding( Me );
}


void default_trav_PDU_FieldEncodingCall( const PDU_FieldEncodingCall& Me )
{
  if ( pre_PDU_FieldEncodingCall ) 
    pre_PDU_FieldEncodingCall( Me );

  switch ( Me.choice() )
    {
    case Choices::c_EncVariationCall:
      if ( pre_PDU_FieldEncodingCall_encVariationCall ) 
        pre_PDU_FieldEncodingCall_encVariationCall( Me );
      if ( trav_EncVariationCall ) 
        trav_EncVariationCall( Me.encVariationCall() );
      if ( post_PDU_FieldEncodingCall_encVariationCall ) 
        post_PDU_FieldEncodingCall_encVariationCall( Me );
      break;

    case Choices::c_InvalidFieldEncodingCall:
      if ( pre_PDU_FieldEncodingCall_invalidFieldEncodingCall ) 
        pre_PDU_FieldEncodingCall_invalidFieldEncodingCall( Me );
      if ( trav_InvalidFieldEncodingCall ) 
        trav_InvalidFieldEncodingCall( Me.invalidFieldEncodingCall() );
      if ( post_PDU_FieldEncodingCall_invalidFieldEncodingCall ) 
        post_PDU_FieldEncodingCall_invalidFieldEncodingCall( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node PDU_FieldEncodingCall: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_PDU_FieldEncodingCall ) 
    post_PDU_FieldEncodingCall( Me );
}


void default_trav_EncVariationId( const EncVariationId& Me )
{
  if ( pre_EncVariationId ) 
    pre_EncVariationId( Me );

  if ( pre_EncVariationId_encVariationCall ) 
    pre_EncVariationId_encVariationCall( Me );
  if ( trav_EncVariationCall ) 
    trav_EncVariationCall( Me.encVariationCall() );
  if ( post_EncVariationId_encVariationCall ) 
    post_EncVariationId_encVariationCall( Me );

  if ( post_EncVariationId ) 
    post_EncVariationId( Me );
}


void default_trav_EncVariationCall( const EncVariationCall& Me )
{
  if ( pre_EncVariationCall ) 
    pre_EncVariationCall( Me );

  if ( pre_EncVariationCall_encVariationIdentifier ) 
    pre_EncVariationCall_encVariationIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.encVariationIdentifier() );
  if ( post_EncVariationCall_encVariationIdentifier ) 
    post_EncVariationCall_encVariationIdentifier( Me );

  if ( pre_EncVariationCall_actualParList ) 
    pre_EncVariationCall_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_EncVariationCall_actualParList ) 
    post_EncVariationCall_actualParList( Me );

  if ( post_EncVariationCall ) 
    post_EncVariationCall( Me );
}


void default_trav_InvalidFieldEncodingCall( const InvalidFieldEncodingCall& Me )
{
  if ( pre_InvalidFieldEncodingCall ) 
    pre_InvalidFieldEncodingCall( Me );

  if ( pre_InvalidFieldEncodingCall_invalidFieldEncodingIdentifier ) 
    pre_InvalidFieldEncodingCall_invalidFieldEncodingIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.invalidFieldEncodingIdentifier() );
  if ( post_InvalidFieldEncodingCall_invalidFieldEncodingIdentifier ) 
    post_InvalidFieldEncodingCall_invalidFieldEncodingIdentifier( Me );

  if ( pre_InvalidFieldEncodingCall_actualParList ) 
    pre_InvalidFieldEncodingCall_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_InvalidFieldEncodingCall_actualParList ) 
    post_InvalidFieldEncodingCall_actualParList( Me );

  if ( post_InvalidFieldEncodingCall ) 
    post_InvalidFieldEncodingCall( Me );
}


void default_trav_EncodingRuleId( const EncodingRuleId& Me )
{
  if ( pre_EncodingRuleId ) 
    pre_EncodingRuleId( Me );

  if ( pre_EncodingRuleId_encodingRuleIdentifier ) 
    pre_EncodingRuleId_encodingRuleIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.encodingRuleIdentifier() );
  if ( post_EncodingRuleId_encodingRuleIdentifier ) 
    post_EncodingRuleId_encodingRuleIdentifier( Me );

  if ( post_EncodingRuleId ) 
    post_EncodingRuleId( Me );
}


void default_trav_EncRuleId( const EncRuleId& Me )
{
  if ( pre_EncRuleId ) 
    pre_EncRuleId( Me );

  if ( pre_EncRuleId_encodingRuleIdentifier ) 
    pre_EncRuleId_encodingRuleIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.encodingRuleIdentifier() );
  if ( post_EncRuleId_encodingRuleIdentifier ) 
    post_EncRuleId_encodingRuleIdentifier( Me );

  if ( post_EncRuleId ) 
    post_EncRuleId( Me );
}


void default_trav_PDU_EncodingId( const PDU_EncodingId& Me )
{
  if ( pre_PDU_EncodingId ) 
    pre_PDU_EncodingId( Me );

  if ( pre_PDU_EncodingId_encodingRuleIdentifier ) 
    pre_PDU_EncodingId_encodingRuleIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.encodingRuleIdentifier() );
  if ( post_PDU_EncodingId_encodingRuleIdentifier ) 
    post_PDU_EncodingId_encodingRuleIdentifier( Me );

  if ( post_PDU_EncodingId ) 
    post_PDU_EncodingId( Me );
}


void default_trav_EncodingRef( const EncodingRef& Me )
{
  if ( pre_EncodingRef ) 
    pre_EncodingRef( Me );

  if ( pre_EncodingRef_encodingReference ) 
    pre_EncodingRef_encodingReference( Me );
  if ( trav_EncodingReference ) 
    trav_EncodingReference( Me.encodingReference() );
  if ( post_EncodingRef_encodingReference ) 
    post_EncodingRef_encodingReference( Me );

  if ( post_EncodingRef ) 
    post_EncodingRef( Me );
}


void default_trav_EncodingReference( const EncodingReference& Me )
{
  if ( pre_EncodingReference ) 
    pre_EncodingReference( Me );

  if ( post_EncodingReference ) 
    post_EncodingReference( Me );
}


void default_trav_Encoding_TypeList( const Encoding_TypeList& Me )
{
  if ( pre_Encoding_TypeList ) 
    pre_Encoding_TypeList( Me );

  if ( post_Encoding_TypeList ) 
    post_Encoding_TypeList( Me );
}


void default_trav_DetailedComment( const DetailedComment& Me )
{
  if ( pre_DetailedComment ) 
    pre_DetailedComment( Me );

  if ( post_DetailedComment ) 
    post_DetailedComment( Me );
}


void default_trav_Number( const Number& Me )
{
  if ( pre_Number ) 
    pre_Number( Me );

  if ( post_Number ) 
    post_Number( Me );
}


void default_trav_RangeTypeLength( const RangeTypeLength& Me )
{
  if ( pre_RangeTypeLength ) 
    pre_RangeTypeLength( Me );

  if ( pre_RangeTypeLength_lowerTypeBound ) 
    pre_RangeTypeLength_lowerTypeBound( Me );
  if ( trav_LowerTypeBound ) 
    trav_LowerTypeBound( Me.lowerTypeBound() );
  if ( post_RangeTypeLength_lowerTypeBound ) 
    post_RangeTypeLength_lowerTypeBound( Me );

  if ( pre_RangeTypeLength_upperTypeBound ) 
    pre_RangeTypeLength_upperTypeBound( Me );
  if ( trav_UpperTypeBound ) 
    trav_UpperTypeBound( Me.upperTypeBound() );
  if ( post_RangeTypeLength_upperTypeBound ) 
    post_RangeTypeLength_upperTypeBound( Me );

  if ( post_RangeTypeLength ) 
    post_RangeTypeLength( Me );
}


void default_trav_LowerTypeBound( const LowerTypeBound& Me )
{
  if ( pre_LowerTypeBound ) 
    pre_LowerTypeBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SignedNumber:
      if ( pre_LowerTypeBound_signedNumber ) 
        pre_LowerTypeBound_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_LowerTypeBound_signedNumber ) 
        post_LowerTypeBound_signedNumber( Me );
      break;

    case Choices::c_Number:
      if ( pre_LowerTypeBound_number ) 
        pre_LowerTypeBound_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_LowerTypeBound_number ) 
        post_LowerTypeBound_number( Me );
      break;

    case Choices::c_MinusINFINITY:
      if ( pre_LowerTypeBound_minusINFINITY ) 
        pre_LowerTypeBound_minusINFINITY( Me );
      if ( trav_MinusINFINITY ) 
        trav_MinusINFINITY( Me.minusINFINITY() );
      if ( post_LowerTypeBound_minusINFINITY ) 
        post_LowerTypeBound_minusINFINITY( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LowerTypeBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LowerTypeBound ) 
    post_LowerTypeBound( Me );
}


void default_trav_UpperTypeBound( const UpperTypeBound& Me )
{
  if ( pre_UpperTypeBound ) 
    pre_UpperTypeBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SignedNumber:
      if ( pre_UpperTypeBound_signedNumber ) 
        pre_UpperTypeBound_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_UpperTypeBound_signedNumber ) 
        post_UpperTypeBound_signedNumber( Me );
      break;

    case Choices::c_Number:
      if ( pre_UpperTypeBound_number ) 
        pre_UpperTypeBound_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_UpperTypeBound_number ) 
        post_UpperTypeBound_number( Me );
      break;

    case Choices::c_INFINITY:
      if ( pre_UpperTypeBound_infinity ) 
        pre_UpperTypeBound_infinity( Me );
      if ( trav_INFINITY ) 
        trav_INFINITY( Me.infinity() );
      if ( post_UpperTypeBound_infinity ) 
        post_UpperTypeBound_infinity( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UpperTypeBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UpperTypeBound ) 
    post_UpperTypeBound( Me );
}


void default_trav_IntegerRange( const IntegerRange& Me )
{
  if ( pre_IntegerRange ) 
    pre_IntegerRange( Me );

  if ( pre_IntegerRange_lowerTypeBound ) 
    pre_IntegerRange_lowerTypeBound( Me );
  if ( trav_LowerTypeBound ) 
    trav_LowerTypeBound( Me.lowerTypeBound() );
  if ( post_IntegerRange_lowerTypeBound ) 
    post_IntegerRange_lowerTypeBound( Me );

  if ( pre_IntegerRange_upperTypeBound ) 
    pre_IntegerRange_upperTypeBound( Me );
  if ( trav_UpperTypeBound ) 
    trav_UpperTypeBound( Me.upperTypeBound() );
  if ( post_IntegerRange_upperTypeBound ) 
    post_IntegerRange_upperTypeBound( Me );

  if ( post_IntegerRange ) 
    post_IntegerRange( Me );
}


void default_trav_SimpleValueList( const SimpleValueList& Me )
{
  if ( pre_SimpleValueList ) 
    pre_SimpleValueList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SimpleValueList_simpleValue ) 
        pre_SimpleValueList_simpleValue( Me, i );
      if ( trav_SimpleValue ) 
        trav_SimpleValue( Me.simpleValue( i ) );
      if ( post_SimpleValueList_simpleValue ) 
        post_SimpleValueList_simpleValue( Me, i );
  }

  if ( post_SimpleValueList ) 
    post_SimpleValueList( Me );
}


void default_trav_SimpleValue( const SimpleValue& Me )
{
  if ( pre_SimpleValue ) 
    pre_SimpleValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_LiteralValue:
      if ( pre_SimpleValue_literalValue ) 
        pre_SimpleValue_literalValue( Me );
      if ( trav_LiteralValue ) 
        trav_LiteralValue( Me.literalValue() );
      if ( post_SimpleValue_literalValue ) 
        post_SimpleValue_literalValue( Me );
      break;

    case Choices::c_SignedNumber:
      if ( pre_SimpleValue_signedNumber ) 
        pre_SimpleValue_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_SimpleValue_signedNumber ) 
        post_SimpleValue_signedNumber( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node SimpleValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_SimpleValue ) 
    post_SimpleValue( Me );
}


void default_trav_StructTypeDefs( const StructTypeDefs& Me )
{
  if ( pre_StructTypeDefs ) 
    pre_StructTypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_StructTypeDefs_structTypeDef ) 
        pre_StructTypeDefs_structTypeDef( Me, i );
      if ( trav_StructTypeDef ) 
        trav_StructTypeDef( Me.structTypeDef( i ) );
      if ( post_StructTypeDefs_structTypeDef ) 
        post_StructTypeDefs_structTypeDef( Me, i );
  }

  if ( post_StructTypeDefs ) 
    post_StructTypeDefs( Me );
}


void default_trav_StructTypeDef( const StructTypeDef& Me )
{
  if ( pre_StructTypeDef ) 
    pre_StructTypeDef( Me );

  if ( Me.is_present_structId())
    {
      if ( pre_StructTypeDef_structId ) 
        pre_StructTypeDef_structId( Me );
      if ( trav_StructId ) 
        trav_StructId( Me.structId() );
      if ( post_StructTypeDef_structId ) 
        post_StructTypeDef_structId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_StructTypeDef_encVariationId ) 
        pre_StructTypeDef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_StructTypeDef_encVariationId ) 
        post_StructTypeDef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_StructTypeDef_comment ) 
        pre_StructTypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_StructTypeDef_comment ) 
        post_StructTypeDef_comment( Me );
    }

  if ( pre_StructTypeDef_elemDcls ) 
    pre_StructTypeDef_elemDcls( Me );
  if ( trav_ElemDcls ) 
    trav_ElemDcls( Me.elemDcls() );
  if ( post_StructTypeDef_elemDcls ) 
    post_StructTypeDef_elemDcls( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_StructTypeDef_detailedComment ) 
        pre_StructTypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_StructTypeDef_detailedComment ) 
        post_StructTypeDef_detailedComment( Me );
    }

  if ( post_StructTypeDef ) 
    post_StructTypeDef( Me );
}


void default_trav_StructId( const StructId& Me )
{
  if ( pre_StructId ) 
    pre_StructId( Me );

  if ( pre_StructId_structIdAndFullId ) 
    pre_StructId_structIdAndFullId( Me );
  if ( trav_StructIdAndFullId ) 
    trav_StructIdAndFullId( Me.structIdAndFullId() );
  if ( post_StructId_structIdAndFullId ) 
    post_StructId_structIdAndFullId( Me );

  if ( post_StructId ) 
    post_StructId( Me );
}


void default_trav_StructIdAndFullId( const StructIdAndFullId& Me )
{
  if ( pre_StructIdAndFullId ) 
    pre_StructIdAndFullId( Me );

  if ( pre_StructIdAndFullId_structIdentifier ) 
    pre_StructIdAndFullId_structIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.structIdentifier() );
  if ( post_StructIdAndFullId_structIdentifier ) 
    post_StructIdAndFullId_structIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_StructIdAndFullId_fullIdentifier ) 
        pre_StructIdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_StructIdAndFullId_fullIdentifier ) 
        post_StructIdAndFullId_fullIdentifier( Me );
    }

  if ( post_StructIdAndFullId ) 
    post_StructIdAndFullId( Me );
}


void default_trav_FullIdentifier( const FullIdentifier& Me )
{
  if ( pre_FullIdentifier ) 
    pre_FullIdentifier( Me );

  if ( post_FullIdentifier ) 
    post_FullIdentifier( Me );
}


void default_trav_ElemDcls( const ElemDcls& Me )
{
  if ( pre_ElemDcls ) 
    pre_ElemDcls( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ElemDcls_elemDcl ) 
        pre_ElemDcls_elemDcl( Me, i );
      if ( trav_ElemDcl ) 
        trav_ElemDcl( Me.elemDcl( i ) );
      if ( post_ElemDcls_elemDcl ) 
        post_ElemDcls_elemDcl( Me, i );
  }

  if ( post_ElemDcls ) 
    post_ElemDcls( Me );
}


void default_trav_ElemDcl( const ElemDcl& Me )
{
  if ( pre_ElemDcl ) 
    pre_ElemDcl( Me );

  if ( Me.is_present_elemId())
    {
      if ( pre_ElemDcl_elemId ) 
        pre_ElemDcl_elemId( Me );
      if ( trav_ElemId ) 
        trav_ElemId( Me.elemId() );
      if ( post_ElemDcl_elemId ) 
        post_ElemDcl_elemId( Me );
    }

  if ( Me.is_present_elemType())
    {
      if ( pre_ElemDcl_elemType ) 
        pre_ElemDcl_elemType( Me );
      if ( trav_ElemType ) 
        trav_ElemType( Me.elemType() );
      if ( post_ElemDcl_elemType ) 
        post_ElemDcl_elemType( Me );
    }

  if ( Me.is_present_pdu_FieldEncoding())
    {
      if ( pre_ElemDcl_pdu_FieldEncoding ) 
        pre_ElemDcl_pdu_FieldEncoding( Me );
      if ( trav_PDU_FieldEncoding ) 
        trav_PDU_FieldEncoding( Me.pdu_FieldEncoding() );
      if ( post_ElemDcl_pdu_FieldEncoding ) 
        post_ElemDcl_pdu_FieldEncoding( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ElemDcl_comment ) 
        pre_ElemDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ElemDcl_comment ) 
        post_ElemDcl_comment( Me );
    }

  if ( post_ElemDcl ) 
    post_ElemDcl( Me );
}


void default_trav_ElemId( const ElemId& Me )
{
  if ( pre_ElemId ) 
    pre_ElemId( Me );

  if ( pre_ElemId_elemIdAndFullId ) 
    pre_ElemId_elemIdAndFullId( Me );
  if ( trav_ElemIdAndFullId ) 
    trav_ElemIdAndFullId( Me.elemIdAndFullId() );
  if ( post_ElemId_elemIdAndFullId ) 
    post_ElemId_elemIdAndFullId( Me );

  if ( post_ElemId ) 
    post_ElemId( Me );
}


void default_trav_ElemType( const ElemType& Me )
{
  if ( pre_ElemType ) 
    pre_ElemType( Me );

  if ( pre_ElemType_typeAndAttributes ) 
    pre_ElemType_typeAndAttributes( Me );
  if ( trav_TypeAndAttributes ) 
    trav_TypeAndAttributes( Me.typeAndAttributes() );
  if ( post_ElemType_typeAndAttributes ) 
    post_ElemType_typeAndAttributes( Me );

  if ( post_ElemType ) 
    post_ElemType( Me );
}


void default_trav_ElemIdAndFullId( const ElemIdAndFullId& Me )
{
  if ( pre_ElemIdAndFullId ) 
    pre_ElemIdAndFullId( Me );

  if ( pre_ElemIdAndFullId_elemIdentifier ) 
    pre_ElemIdAndFullId_elemIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.elemIdentifier() );
  if ( post_ElemIdAndFullId_elemIdentifier ) 
    post_ElemIdAndFullId_elemIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_ElemIdAndFullId_fullIdentifier ) 
        pre_ElemIdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_ElemIdAndFullId_fullIdentifier ) 
        post_ElemIdAndFullId_fullIdentifier( Me );
    }

  if ( post_ElemIdAndFullId ) 
    post_ElemIdAndFullId( Me );
}


void default_trav_TypeAndAttributes( const TypeAndAttributes& Me )
{
  if ( pre_TypeAndAttributes ) 
    pre_TypeAndAttributes( Me );

  switch ( Me.choice() )
    {
    case Choices::c_TypeAndLengthAttribute:
      if ( pre_TypeAndAttributes_typeAndLengthAttribute ) 
        pre_TypeAndAttributes_typeAndLengthAttribute( Me );
      if ( trav_TypeAndLengthAttribute ) 
        trav_TypeAndLengthAttribute( Me.typeAndLengthAttribute() );
      if ( post_TypeAndAttributes_typeAndLengthAttribute ) 
        post_TypeAndAttributes_typeAndLengthAttribute( Me );
      break;

    case Choices::c_PDU:
      if ( pre_TypeAndAttributes_pdu ) 
        pre_TypeAndAttributes_pdu( Me );
      if ( trav_PDU ) 
        trav_PDU( Me.pdu() );
      if ( post_TypeAndAttributes_pdu ) 
        post_TypeAndAttributes_pdu( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TypeAndAttributes: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TypeAndAttributes ) 
    post_TypeAndAttributes( Me );
}


void default_trav_TypeAndLengthAttribute( const TypeAndLengthAttribute& Me )
{
  if ( pre_TypeAndLengthAttribute ) 
    pre_TypeAndLengthAttribute( Me );

  if ( pre_TypeAndLengthAttribute_ttcn_Type ) 
    pre_TypeAndLengthAttribute_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TypeAndLengthAttribute_ttcn_Type ) 
    post_TypeAndLengthAttribute_ttcn_Type( Me );

  if ( Me.is_present_lengthAttribute())
    {
      if ( pre_TypeAndLengthAttribute_lengthAttribute ) 
        pre_TypeAndLengthAttribute_lengthAttribute( Me );
      if ( trav_LengthAttribute ) 
        trav_LengthAttribute( Me.lengthAttribute() );
      if ( post_TypeAndLengthAttribute_lengthAttribute ) 
        post_TypeAndLengthAttribute_lengthAttribute( Me );
    }

  if ( post_TypeAndLengthAttribute ) 
    post_TypeAndLengthAttribute( Me );
}


void default_trav_LengthAttribute( const LengthAttribute& Me )
{
  if ( pre_LengthAttribute ) 
    pre_LengthAttribute( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SingleLength:
      if ( pre_LengthAttribute_singleLength ) 
        pre_LengthAttribute_singleLength( Me );
      if ( trav_SingleLength ) 
        trav_SingleLength( Me.singleLength() );
      if ( post_LengthAttribute_singleLength ) 
        post_LengthAttribute_singleLength( Me );
      break;

    case Choices::c_RangeLength:
      if ( pre_LengthAttribute_rangeLength ) 
        pre_LengthAttribute_rangeLength( Me );
      if ( trav_RangeLength ) 
        trav_RangeLength( Me.rangeLength() );
      if ( post_LengthAttribute_rangeLength ) 
        post_LengthAttribute_rangeLength( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LengthAttribute: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LengthAttribute ) 
    post_LengthAttribute( Me );
}


void default_trav_SingleLength( const SingleLength& Me )
{
  if ( pre_SingleLength ) 
    pre_SingleLength( Me );

  if ( pre_SingleLength_bound ) 
    pre_SingleLength_bound( Me );
  if ( trav_Bound ) 
    trav_Bound( Me.bound() );
  if ( post_SingleLength_bound ) 
    post_SingleLength_bound( Me );

  if ( post_SingleLength ) 
    post_SingleLength( Me );
}


void default_trav_Bound( const Bound& Me )
{
  if ( pre_Bound ) 
    pre_Bound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Number:
      if ( pre_Bound_number ) 
        pre_Bound_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_Bound_number ) 
        post_Bound_number( Me );
      break;

    case Choices::c_Identifier:
      if ( pre_Bound_identifier ) 
        pre_Bound_identifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier() );
      if ( post_Bound_identifier ) 
        post_Bound_identifier( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Bound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Bound ) 
    post_Bound( Me );
}


void default_trav_RangeLength( const RangeLength& Me )
{
  if ( pre_RangeLength ) 
    pre_RangeLength( Me );

  if ( pre_RangeLength_lowerBound ) 
    pre_RangeLength_lowerBound( Me );
  if ( trav_LowerBound ) 
    trav_LowerBound( Me.lowerBound() );
  if ( post_RangeLength_lowerBound ) 
    post_RangeLength_lowerBound( Me );

  if ( pre_RangeLength_upperBound ) 
    pre_RangeLength_upperBound( Me );
  if ( trav_UpperBound ) 
    trav_UpperBound( Me.upperBound() );
  if ( post_RangeLength_upperBound ) 
    post_RangeLength_upperBound( Me );

  if ( post_RangeLength ) 
    post_RangeLength( Me );
}


void default_trav_LowerBound( const LowerBound& Me )
{
  if ( pre_LowerBound ) 
    pre_LowerBound( Me );

  if ( pre_LowerBound_bound ) 
    pre_LowerBound_bound( Me );
  if ( trav_Bound ) 
    trav_Bound( Me.bound() );
  if ( post_LowerBound_bound ) 
    post_LowerBound_bound( Me );

  if ( post_LowerBound ) 
    post_LowerBound( Me );
}


void default_trav_UpperBound( const UpperBound& Me )
{
  if ( pre_UpperBound ) 
    pre_UpperBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Bound:
      if ( pre_UpperBound_bound ) 
        pre_UpperBound_bound( Me );
      if ( trav_Bound ) 
        trav_Bound( Me.bound() );
      if ( post_UpperBound_bound ) 
        post_UpperBound_bound( Me );
      break;

    case Choices::c_INFINITY:
      if ( pre_UpperBound_infinity ) 
        pre_UpperBound_infinity( Me );
      if ( trav_INFINITY ) 
        trav_INFINITY( Me.infinity() );
      if ( post_UpperBound_infinity ) 
        post_UpperBound_infinity( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UpperBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UpperBound ) 
    post_UpperBound( Me );
}


void default_trav_ASN1_TypeDefs( const ASN1_TypeDefs& Me )
{
  if ( pre_ASN1_TypeDefs ) 
    pre_ASN1_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_TypeDefs_asn1_TypeDef ) 
        pre_ASN1_TypeDefs_asn1_TypeDef( Me, i );
      if ( trav_ASN1_TypeDef ) 
        trav_ASN1_TypeDef( Me.asn1_TypeDef( i ) );
      if ( post_ASN1_TypeDefs_asn1_TypeDef ) 
        post_ASN1_TypeDefs_asn1_TypeDef( Me, i );
  }

  if ( post_ASN1_TypeDefs ) 
    post_ASN1_TypeDefs( Me );
}


void default_trav_ASN1_TypeDef( const ASN1_TypeDef& Me )
{
  if ( pre_ASN1_TypeDef ) 
    pre_ASN1_TypeDef( Me );

  if ( Me.is_present_asn1_TypeId())
    {
      if ( pre_ASN1_TypeDef_asn1_TypeId ) 
        pre_ASN1_TypeDef_asn1_TypeId( Me );
      if ( trav_ASN1_TypeId ) 
        trav_ASN1_TypeId( Me.asn1_TypeId() );
      if ( post_ASN1_TypeDef_asn1_TypeId ) 
        post_ASN1_TypeDef_asn1_TypeId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_TypeDef_encVariationId ) 
        pre_ASN1_TypeDef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_TypeDef_encVariationId ) 
        post_ASN1_TypeDef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_TypeDef_comment ) 
        pre_ASN1_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_TypeDef_comment ) 
        post_ASN1_TypeDef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_TypeDef_asn1_TypeDefinition ) 
        pre_ASN1_TypeDef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_TypeDef_asn1_TypeDefinition ) 
        post_ASN1_TypeDef_asn1_TypeDefinition( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_TypeDef_detailedComment ) 
        pre_ASN1_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_TypeDef_detailedComment ) 
        post_ASN1_TypeDef_detailedComment( Me );
    }

  if ( post_ASN1_TypeDef ) 
    post_ASN1_TypeDef( Me );
}


void default_trav_ASN1_TypeId( const ASN1_TypeId& Me )
{
  if ( pre_ASN1_TypeId ) 
    pre_ASN1_TypeId( Me );

  if ( pre_ASN1_TypeId_asn1_TypeIdentifier ) 
    pre_ASN1_TypeId_asn1_TypeIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.asn1_TypeIdentifier() );
  if ( post_ASN1_TypeId_asn1_TypeIdentifier ) 
    post_ASN1_TypeId_asn1_TypeIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_ASN1_TypeId_fullIdentifier ) 
        pre_ASN1_TypeId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_ASN1_TypeId_fullIdentifier ) 
        post_ASN1_TypeId_fullIdentifier( Me );
    }

  if ( post_ASN1_TypeId ) 
    post_ASN1_TypeId( Me );
}


void default_trav_ASN1_TypeDefinition( const ASN1_TypeDefinition& Me )
{
  if ( pre_ASN1_TypeDefinition ) 
    pre_ASN1_TypeDefinition( Me );

  if ( pre_ASN1_TypeDefinition_asn1_TypeAndLocalTypes ) 
    pre_ASN1_TypeDefinition_asn1_TypeAndLocalTypes( Me );
  if ( trav_ASN1_TypeAndLocalTypes ) 
    trav_ASN1_TypeAndLocalTypes( Me.asn1_TypeAndLocalTypes() );
  if ( post_ASN1_TypeDefinition_asn1_TypeAndLocalTypes ) 
    post_ASN1_TypeDefinition_asn1_TypeAndLocalTypes( Me );

  if ( post_ASN1_TypeDefinition ) 
    post_ASN1_TypeDefinition( Me );
}


void default_trav_ASN1_TypeRefs( const ASN1_TypeRefs& Me )
{
  if ( pre_ASN1_TypeRefs ) 
    pre_ASN1_TypeRefs( Me );

  if ( pre_ASN1_TypeRefs_asn1_TypeRefList ) 
    pre_ASN1_TypeRefs_asn1_TypeRefList( Me );
  if ( trav_ASN1_TypeRefList ) 
    trav_ASN1_TypeRefList( Me.asn1_TypeRefList() );
  if ( post_ASN1_TypeRefs_asn1_TypeRefList ) 
    post_ASN1_TypeRefs_asn1_TypeRefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_TypeRefs_detailedComment ) 
        pre_ASN1_TypeRefs_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_TypeRefs_detailedComment ) 
        post_ASN1_TypeRefs_detailedComment( Me );
    }

  if ( post_ASN1_TypeRefs ) 
    post_ASN1_TypeRefs( Me );
}


void default_trav_ASN1_TypeRefList( const ASN1_TypeRefList& Me )
{
  if ( pre_ASN1_TypeRefList ) 
    pre_ASN1_TypeRefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_TypeRefList_asn1_TypeRef ) 
        pre_ASN1_TypeRefList_asn1_TypeRef( Me, i );
      if ( trav_ASN1_TypeRef ) 
        trav_ASN1_TypeRef( Me.asn1_TypeRef( i ) );
      if ( post_ASN1_TypeRefList_asn1_TypeRef ) 
        post_ASN1_TypeRefList_asn1_TypeRef( Me, i );
  }

  if ( post_ASN1_TypeRefList ) 
    post_ASN1_TypeRefList( Me );
}


void default_trav_ASN1_TypeRef( const ASN1_TypeRef& Me )
{
  if ( pre_ASN1_TypeRef ) 
    pre_ASN1_TypeRef( Me );

  if ( Me.is_present_asn1_TypeId())
    {
      if ( pre_ASN1_TypeRef_asn1_TypeId ) 
        pre_ASN1_TypeRef_asn1_TypeId( Me );
      if ( trav_ASN1_TypeId ) 
        trav_ASN1_TypeId( Me.asn1_TypeId() );
      if ( post_ASN1_TypeRef_asn1_TypeId ) 
        post_ASN1_TypeRef_asn1_TypeId( Me );
    }

  if ( Me.is_present_asn1_TypeReference())
    {
      if ( pre_ASN1_TypeRef_asn1_TypeReference ) 
        pre_ASN1_TypeRef_asn1_TypeReference( Me );
      if ( trav_ASN1_TypeReference ) 
        trav_ASN1_TypeReference( Me.asn1_TypeReference() );
      if ( post_ASN1_TypeRef_asn1_TypeReference ) 
        post_ASN1_TypeRef_asn1_TypeReference( Me );
    }

  if ( Me.is_present_asn1_ModuleId())
    {
      if ( pre_ASN1_TypeRef_asn1_ModuleId ) 
        pre_ASN1_TypeRef_asn1_ModuleId( Me );
      if ( trav_ASN1_ModuleId ) 
        trav_ASN1_ModuleId( Me.asn1_ModuleId() );
      if ( post_ASN1_TypeRef_asn1_ModuleId ) 
        post_ASN1_TypeRef_asn1_ModuleId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_TypeRef_encVariationId ) 
        pre_ASN1_TypeRef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_TypeRef_encVariationId ) 
        post_ASN1_TypeRef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_TypeRef_comment ) 
        pre_ASN1_TypeRef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_TypeRef_comment ) 
        post_ASN1_TypeRef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_TypeRef_asn1_TypeDefinition ) 
        pre_ASN1_TypeRef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_TypeRef_asn1_TypeDefinition ) 
        post_ASN1_TypeRef_asn1_TypeDefinition( Me );
    }

  if ( post_ASN1_TypeRef ) 
    post_ASN1_TypeRef( Me );
}


void default_trav_ASN1_TypeReference( const ASN1_TypeReference& Me )
{
  if ( pre_ASN1_TypeReference ) 
    pre_ASN1_TypeReference( Me );

  if ( post_ASN1_TypeReference ) 
    post_ASN1_TypeReference( Me );
}


void default_trav_ASN1_ModuleId( const ASN1_ModuleId& Me )
{
  if ( pre_ASN1_ModuleId ) 
    pre_ASN1_ModuleId( Me );

  if ( post_ASN1_ModuleId ) 
    post_ASN1_ModuleId( Me );
}


void default_trav_TS_ProcDefs( const TS_ProcDefs& Me )
{
  if ( pre_TS_ProcDefs ) 
    pre_TS_ProcDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_ProcDefs_ts_ProcDef ) 
        pre_TS_ProcDefs_ts_ProcDef( Me, i );
      if ( trav_TS_ProcDef ) 
        trav_TS_ProcDef( Me.ts_ProcDef( i ) );
      if ( post_TS_ProcDefs_ts_ProcDef ) 
        post_TS_ProcDefs_ts_ProcDef( Me, i );
  }

  if ( post_TS_ProcDefs ) 
    post_TS_ProcDefs( Me );
}


void default_trav_TS_OpDefs( const TS_OpDefs& Me )
{
  if ( pre_TS_OpDefs ) 
    pre_TS_OpDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_OpDefs_ts_OpDef ) 
        pre_TS_OpDefs_ts_OpDef( Me, i );
      if ( trav_TS_OpDef ) 
        trav_TS_OpDef( Me.ts_OpDef( i ) );
      if ( post_TS_OpDefs_ts_OpDef ) 
        post_TS_OpDefs_ts_OpDef( Me, i );
  }

  if ( post_TS_OpDefs ) 
    post_TS_OpDefs( Me );
}


void default_trav_TS_OpDef( const TS_OpDef& Me )
{
  if ( pre_TS_OpDef ) 
    pre_TS_OpDef( Me );

  if ( Me.is_present_ts_OpId())
    {
      if ( pre_TS_OpDef_ts_OpId ) 
        pre_TS_OpDef_ts_OpId( Me );
      if ( trav_TS_OpId ) 
        trav_TS_OpId( Me.ts_OpId() );
      if ( post_TS_OpDef_ts_OpId ) 
        post_TS_OpDef_ts_OpId( Me );
    }

  if ( Me.is_present_ts_OpResult())
    {
      if ( pre_TS_OpDef_ts_OpResult ) 
        pre_TS_OpDef_ts_OpResult( Me );
      if ( trav_TS_OpResult ) 
        trav_TS_OpResult( Me.ts_OpResult() );
      if ( post_TS_OpDef_ts_OpResult ) 
        post_TS_OpDef_ts_OpResult( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_OpDef_comment ) 
        pre_TS_OpDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_OpDef_comment ) 
        post_TS_OpDef_comment( Me );
    }

  if ( Me.is_present_ts_OpDescription())
    {
      if ( pre_TS_OpDef_ts_OpDescription ) 
        pre_TS_OpDef_ts_OpDescription( Me );
      if ( trav_TS_OpDescription ) 
        trav_TS_OpDescription( Me.ts_OpDescription() );
      if ( post_TS_OpDef_ts_OpDescription ) 
        post_TS_OpDef_ts_OpDescription( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_OpDef_detailedComment ) 
        pre_TS_OpDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_OpDef_detailedComment ) 
        post_TS_OpDef_detailedComment( Me );
    }

  if ( post_TS_OpDef ) 
    post_TS_OpDef( Me );
}


void default_trav_TS_ProcDef( const TS_ProcDef& Me )
{
  if ( pre_TS_ProcDef ) 
    pre_TS_ProcDef( Me );

  if ( Me.is_present_ts_ProcId())
    {
      if ( pre_TS_ProcDef_ts_ProcId ) 
        pre_TS_ProcDef_ts_ProcId( Me );
      if ( trav_TS_ProcId ) 
        trav_TS_ProcId( Me.ts_ProcId() );
      if ( post_TS_ProcDef_ts_ProcId ) 
        post_TS_ProcDef_ts_ProcId( Me );
    }

  if ( Me.is_present_ts_ProcResult())
    {
      if ( pre_TS_ProcDef_ts_ProcResult ) 
        pre_TS_ProcDef_ts_ProcResult( Me );
      if ( trav_TS_ProcResult ) 
        trav_TS_ProcResult( Me.ts_ProcResult() );
      if ( post_TS_ProcDef_ts_ProcResult ) 
        post_TS_ProcDef_ts_ProcResult( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_ProcDef_comment ) 
        pre_TS_ProcDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_ProcDef_comment ) 
        post_TS_ProcDef_comment( Me );
    }

  if ( Me.is_present_ts_ProcDescription())
    {
      if ( pre_TS_ProcDef_ts_ProcDescription ) 
        pre_TS_ProcDef_ts_ProcDescription( Me );
      if ( trav_TS_ProcDescription ) 
        trav_TS_ProcDescription( Me.ts_ProcDescription() );
      if ( post_TS_ProcDef_ts_ProcDescription ) 
        post_TS_ProcDef_ts_ProcDescription( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_ProcDef_detailedComment ) 
        pre_TS_ProcDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_ProcDef_detailedComment ) 
        post_TS_ProcDef_detailedComment( Me );
    }

  if ( post_TS_ProcDef ) 
    post_TS_ProcDef( Me );
}


void default_trav_TS_OpId( const TS_OpId& Me )
{
  if ( pre_TS_OpId ) 
    pre_TS_OpId( Me );

  if ( pre_TS_OpId_ts_OpIdAndParList ) 
    pre_TS_OpId_ts_OpIdAndParList( Me );
  if ( trav_TS_OpIdAndParList ) 
    trav_TS_OpIdAndParList( Me.ts_OpIdAndParList() );
  if ( post_TS_OpId_ts_OpIdAndParList ) 
    post_TS_OpId_ts_OpIdAndParList( Me );

  if ( post_TS_OpId ) 
    post_TS_OpId( Me );
}


void default_trav_TS_ProcId( const TS_ProcId& Me )
{
  if ( pre_TS_ProcId ) 
    pre_TS_ProcId( Me );

  if ( pre_TS_ProcId_ts_ProcIdAndParList ) 
    pre_TS_ProcId_ts_ProcIdAndParList( Me );
  if ( trav_TS_ProcIdAndParList ) 
    trav_TS_ProcIdAndParList( Me.ts_ProcIdAndParList() );
  if ( post_TS_ProcId_ts_ProcIdAndParList ) 
    post_TS_ProcId_ts_ProcIdAndParList( Me );

  if ( post_TS_ProcId ) 
    post_TS_ProcId( Me );
}


void default_trav_TS_OpIdAndParList( const TS_OpIdAndParList& Me )
{
  if ( pre_TS_OpIdAndParList ) 
    pre_TS_OpIdAndParList( Me );

  if ( pre_TS_OpIdAndParList_ts_OpIdentifier ) 
    pre_TS_OpIdAndParList_ts_OpIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_OpIdentifier() );
  if ( post_TS_OpIdAndParList_ts_OpIdentifier ) 
    post_TS_OpIdAndParList_ts_OpIdentifier( Me );

  if ( pre_TS_OpIdAndParList_formalParList ) 
    pre_TS_OpIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_TS_OpIdAndParList_formalParList ) 
    post_TS_OpIdAndParList_formalParList( Me );

  if ( post_TS_OpIdAndParList ) 
    post_TS_OpIdAndParList( Me );
}


void default_trav_TS_ProcIdAndParList( const TS_ProcIdAndParList& Me )
{
  if ( pre_TS_ProcIdAndParList ) 
    pre_TS_ProcIdAndParList( Me );

  if ( pre_TS_ProcIdAndParList_ts_ProcIdentifier ) 
    pre_TS_ProcIdAndParList_ts_ProcIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_ProcIdentifier() );
  if ( post_TS_ProcIdAndParList_ts_ProcIdentifier ) 
    post_TS_ProcIdAndParList_ts_ProcIdentifier( Me );

  if ( pre_TS_ProcIdAndParList_formalParList ) 
    pre_TS_ProcIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_TS_ProcIdAndParList_formalParList ) 
    post_TS_ProcIdAndParList_formalParList( Me );

  if ( post_TS_ProcIdAndParList ) 
    post_TS_ProcIdAndParList( Me );
}


void default_trav_TS_OpResult( const TS_OpResult& Me )
{
  if ( pre_TS_OpResult ) 
    pre_TS_OpResult( Me );

  if ( pre_TS_OpResult_ttcn_Type ) 
    pre_TS_OpResult_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TS_OpResult_ttcn_Type ) 
    post_TS_OpResult_ttcn_Type( Me );

  if ( post_TS_OpResult ) 
    post_TS_OpResult( Me );
}


void default_trav_TS_ProcResult( const TS_ProcResult& Me )
{
  if ( pre_TS_ProcResult ) 
    pre_TS_ProcResult( Me );

  if ( pre_TS_ProcResult_ttcn_Type ) 
    pre_TS_ProcResult_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TS_ProcResult_ttcn_Type ) 
    post_TS_ProcResult_ttcn_Type( Me );

  if ( post_TS_ProcResult ) 
    post_TS_ProcResult( Me );
}


void default_trav_TS_OpDescription( const TS_OpDescription& Me )
{
  if ( pre_TS_OpDescription ) 
    pre_TS_OpDescription( Me );

  if ( post_TS_OpDescription ) 
    post_TS_OpDescription( Me );
}


void default_trav_TS_ProcDescription( const TS_ProcDescription& Me )
{
  if ( pre_TS_ProcDescription ) 
    pre_TS_ProcDescription( Me );

  if ( post_TS_ProcDescription ) 
    post_TS_ProcDescription( Me );
}


void default_trav_ParamAndSelection( const ParamAndSelection& Me )
{
  if ( pre_ParamAndSelection ) 
    pre_ParamAndSelection( Me );

  if ( pre_ParamAndSelection_ts_ParDcls ) 
    pre_ParamAndSelection_ts_ParDcls( Me );
  if ( trav_TS_ParDcls ) 
    trav_TS_ParDcls( Me.ts_ParDcls() );
  if ( post_ParamAndSelection_ts_ParDcls ) 
    post_ParamAndSelection_ts_ParDcls( Me );

  if ( pre_ParamAndSelection_selectExprDefs ) 
    pre_ParamAndSelection_selectExprDefs( Me );
  if ( trav_SelectExprDefs ) 
    trav_SelectExprDefs( Me.selectExprDefs() );
  if ( post_ParamAndSelection_selectExprDefs ) 
    post_ParamAndSelection_selectExprDefs( Me );

  if ( post_ParamAndSelection ) 
    post_ParamAndSelection( Me );
}


void default_trav_TS_ParDcls( const TS_ParDcls& Me )
{
  if ( pre_TS_ParDcls ) 
    pre_TS_ParDcls( Me );

  if ( pre_TS_ParDcls_ts_ParDclList ) 
    pre_TS_ParDcls_ts_ParDclList( Me );
  if ( trav_TS_ParDclList ) 
    trav_TS_ParDclList( Me.ts_ParDclList() );
  if ( post_TS_ParDcls_ts_ParDclList ) 
    post_TS_ParDcls_ts_ParDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_ParDcls_detailedComment ) 
        pre_TS_ParDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_ParDcls_detailedComment ) 
        post_TS_ParDcls_detailedComment( Me );
    }

  if ( post_TS_ParDcls ) 
    post_TS_ParDcls( Me );
}


void default_trav_TS_ParDclList( const TS_ParDclList& Me )
{
  if ( pre_TS_ParDclList ) 
    pre_TS_ParDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_ParDclList_ts_ParDcl ) 
        pre_TS_ParDclList_ts_ParDcl( Me, i );
      if ( trav_TS_ParDcl ) 
        trav_TS_ParDcl( Me.ts_ParDcl( i ) );
      if ( post_TS_ParDclList_ts_ParDcl ) 
        post_TS_ParDclList_ts_ParDcl( Me, i );
  }

  if ( post_TS_ParDclList ) 
    post_TS_ParDclList( Me );
}


void default_trav_TS_ParDcl( const TS_ParDcl& Me )
{
  if ( pre_TS_ParDcl ) 
    pre_TS_ParDcl( Me );

  if ( Me.is_present_ts_ParId())
    {
      if ( pre_TS_ParDcl_ts_ParId ) 
        pre_TS_ParDcl_ts_ParId( Me );
      if ( trav_TS_ParId ) 
        trav_TS_ParId( Me.ts_ParId() );
      if ( post_TS_ParDcl_ts_ParId ) 
        post_TS_ParDcl_ts_ParId( Me );
    }

  if ( Me.is_present_ts_ParType())
    {
      if ( pre_TS_ParDcl_ts_ParType ) 
        pre_TS_ParDcl_ts_ParType( Me );
      if ( trav_TS_ParType ) 
        trav_TS_ParType( Me.ts_ParType() );
      if ( post_TS_ParDcl_ts_ParType ) 
        post_TS_ParDcl_ts_ParType( Me );
    }

  if ( Me.is_present_pics_PIXITref())
    {
      if ( pre_TS_ParDcl_pics_PIXITref ) 
        pre_TS_ParDcl_pics_PIXITref( Me );
      if ( trav_PICS_PIXITref ) 
        trav_PICS_PIXITref( Me.pics_PIXITref() );
      if ( post_TS_ParDcl_pics_PIXITref ) 
        post_TS_ParDcl_pics_PIXITref( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_ParDcl_comment ) 
        pre_TS_ParDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_ParDcl_comment ) 
        post_TS_ParDcl_comment( Me );
    }

  if ( post_TS_ParDcl ) 
    post_TS_ParDcl( Me );
}


void default_trav_TS_ParId( const TS_ParId& Me )
{
  if ( pre_TS_ParId ) 
    pre_TS_ParId( Me );

  if ( pre_TS_ParId_ts_ParIdentifier ) 
    pre_TS_ParId_ts_ParIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_ParIdentifier() );
  if ( post_TS_ParId_ts_ParIdentifier ) 
    post_TS_ParId_ts_ParIdentifier( Me );

  if ( post_TS_ParId ) 
    post_TS_ParId( Me );
}


void default_trav_PICS_PIXITref( const PICS_PIXITref& Me )
{
  if ( pre_PICS_PIXITref ) 
    pre_PICS_PIXITref( Me );

  if ( post_PICS_PIXITref ) 
    post_PICS_PIXITref( Me );
}


void default_trav_TS_ParType( const TS_ParType& Me )
{
  if ( pre_TS_ParType ) 
    pre_TS_ParType( Me );

  if ( pre_TS_ParType_ttcn_Type ) 
    pre_TS_ParType_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TS_ParType_ttcn_Type ) 
    post_TS_ParType_ttcn_Type( Me );

  if ( post_TS_ParType ) 
    post_TS_ParType( Me );
}


void default_trav_SelectExprDefs( const SelectExprDefs& Me )
{
  if ( pre_SelectExprDefs ) 
    pre_SelectExprDefs( Me );

  if ( pre_SelectExprDefs_selectExprDefList ) 
    pre_SelectExprDefs_selectExprDefList( Me );
  if ( trav_SelectExprDefList ) 
    trav_SelectExprDefList( Me.selectExprDefList() );
  if ( post_SelectExprDefs_selectExprDefList ) 
    post_SelectExprDefs_selectExprDefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_SelectExprDefs_detailedComment ) 
        pre_SelectExprDefs_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_SelectExprDefs_detailedComment ) 
        post_SelectExprDefs_detailedComment( Me );
    }

  if ( post_SelectExprDefs ) 
    post_SelectExprDefs( Me );
}


void default_trav_SelectExprDefList( const SelectExprDefList& Me )
{
  if ( pre_SelectExprDefList ) 
    pre_SelectExprDefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SelectExprDefList_selectExprDef ) 
        pre_SelectExprDefList_selectExprDef( Me, i );
      if ( trav_SelectExprDef ) 
        trav_SelectExprDef( Me.selectExprDef( i ) );
      if ( post_SelectExprDefList_selectExprDef ) 
        post_SelectExprDefList_selectExprDef( Me, i );
  }

  if ( post_SelectExprDefList ) 
    post_SelectExprDefList( Me );
}


void default_trav_SelectExprDef( const SelectExprDef& Me )
{
  if ( pre_SelectExprDef ) 
    pre_SelectExprDef( Me );

  if ( Me.is_present_selectExprId())
    {
      if ( pre_SelectExprDef_selectExprId ) 
        pre_SelectExprDef_selectExprId( Me );
      if ( trav_SelectExprId ) 
        trav_SelectExprId( Me.selectExprId() );
      if ( post_SelectExprDef_selectExprId ) 
        post_SelectExprDef_selectExprId( Me );
    }

  if ( Me.is_present_selectExpr())
    {
      if ( pre_SelectExprDef_selectExpr ) 
        pre_SelectExprDef_selectExpr( Me );
      if ( trav_SelectExpr ) 
        trav_SelectExpr( Me.selectExpr() );
      if ( post_SelectExprDef_selectExpr ) 
        post_SelectExprDef_selectExpr( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_SelectExprDef_comment ) 
        pre_SelectExprDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_SelectExprDef_comment ) 
        post_SelectExprDef_comment( Me );
    }

  if ( post_SelectExprDef ) 
    post_SelectExprDef( Me );
}


void default_trav_SelectExprId( const SelectExprId& Me )
{
  if ( pre_SelectExprId ) 
    pre_SelectExprId( Me );

  if ( pre_SelectExprId_selectExprIdentifier ) 
    pre_SelectExprId_selectExprIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.selectExprIdentifier() );
  if ( post_SelectExprId_selectExprIdentifier ) 
    post_SelectExprId_selectExprIdentifier( Me );

  if ( post_SelectExprId ) 
    post_SelectExprId( Me );
}


void default_trav_SelectExpr( const SelectExpr& Me )
{
  if ( pre_SelectExpr ) 
    pre_SelectExpr( Me );

  if ( pre_SelectExpr_selectionExpression ) 
    pre_SelectExpr_selectionExpression( Me );
  if ( trav_SelectionExpression ) 
    trav_SelectionExpression( Me.selectionExpression() );
  if ( post_SelectExpr_selectionExpression ) 
    post_SelectExpr_selectionExpression( Me );

  if ( post_SelectExpr ) 
    post_SelectExpr( Me );
}


void default_trav_SelectionExpression( const SelectionExpression& Me )
{
  if ( pre_SelectionExpression ) 
    pre_SelectionExpression( Me );

  if ( pre_SelectionExpression_expression ) 
    pre_SelectionExpression_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_SelectionExpression_expression ) 
    post_SelectionExpression_expression( Me );

  if ( post_SelectionExpression ) 
    post_SelectionExpression( Me );
}


void default_trav_Declarations( const Declarations& Me )
{
  if ( pre_Declarations ) 
    pre_Declarations( Me );

  if ( pre_Declarations_ts_ConstDcls ) 
    pre_Declarations_ts_ConstDcls( Me );
  if ( trav_TS_ConstDcls ) 
    trav_TS_ConstDcls( Me.ts_ConstDcls() );
  if ( post_Declarations_ts_ConstDcls ) 
    post_Declarations_ts_ConstDcls( Me );

  if ( pre_Declarations_ts_ConstRefs ) 
    pre_Declarations_ts_ConstRefs( Me );
  if ( trav_TS_ConstRefs ) 
    trav_TS_ConstRefs( Me.ts_ConstRefs() );
  if ( post_Declarations_ts_ConstRefs ) 
    post_Declarations_ts_ConstRefs( Me );

  if ( pre_Declarations_ts_VarDcls ) 
    pre_Declarations_ts_VarDcls( Me );
  if ( trav_TS_VarDcls ) 
    trav_TS_VarDcls( Me.ts_VarDcls() );
  if ( post_Declarations_ts_VarDcls ) 
    post_Declarations_ts_VarDcls( Me );

  if ( pre_Declarations_tc_VarDcls ) 
    pre_Declarations_tc_VarDcls( Me );
  if ( trav_TC_VarDcls ) 
    trav_TC_VarDcls( Me.tc_VarDcls() );
  if ( post_Declarations_tc_VarDcls ) 
    post_Declarations_tc_VarDcls( Me );

  if ( pre_Declarations_pco_TypeDcls ) 
    pre_Declarations_pco_TypeDcls( Me );
  if ( trav_PCO_TypeDcls ) 
    trav_PCO_TypeDcls( Me.pco_TypeDcls() );
  if ( post_Declarations_pco_TypeDcls ) 
    post_Declarations_pco_TypeDcls( Me );

  if ( pre_Declarations_pco_Dcls ) 
    pre_Declarations_pco_Dcls( Me );
  if ( trav_PCO_Dcls ) 
    trav_PCO_Dcls( Me.pco_Dcls() );
  if ( post_Declarations_pco_Dcls ) 
    post_Declarations_pco_Dcls( Me );

  if ( pre_Declarations_cp_Dcls ) 
    pre_Declarations_cp_Dcls( Me );
  if ( trav_CP_Dcls ) 
    trav_CP_Dcls( Me.cp_Dcls() );
  if ( post_Declarations_cp_Dcls ) 
    post_Declarations_cp_Dcls( Me );

  if ( pre_Declarations_timerDcls ) 
    pre_Declarations_timerDcls( Me );
  if ( trav_TimerDcls ) 
    trav_TimerDcls( Me.timerDcls() );
  if ( post_Declarations_timerDcls ) 
    post_Declarations_timerDcls( Me );

  if ( pre_Declarations_tcompDcls ) 
    pre_Declarations_tcompDcls( Me );
  if ( trav_TCompDcls ) 
    trav_TCompDcls( Me.tcompDcls() );
  if ( post_Declarations_tcompDcls ) 
    post_Declarations_tcompDcls( Me );

  if ( pre_Declarations_tcompConfigDcls ) 
    pre_Declarations_tcompConfigDcls( Me );
  if ( trav_TCompConfigDcls ) 
    trav_TCompConfigDcls( Me.tcompConfigDcls() );
  if ( post_Declarations_tcompConfigDcls ) 
    post_Declarations_tcompConfigDcls( Me );

  if ( post_Declarations ) 
    post_Declarations( Me );
}


void default_trav_TS_ConstDcls( const TS_ConstDcls& Me )
{
  if ( pre_TS_ConstDcls ) 
    pre_TS_ConstDcls( Me );

  if ( pre_TS_ConstDcls_ts_ConstDclList ) 
    pre_TS_ConstDcls_ts_ConstDclList( Me );
  if ( trav_TS_ConstDclList ) 
    trav_TS_ConstDclList( Me.ts_ConstDclList() );
  if ( post_TS_ConstDcls_ts_ConstDclList ) 
    post_TS_ConstDcls_ts_ConstDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_ConstDcls_detailedComment ) 
        pre_TS_ConstDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_ConstDcls_detailedComment ) 
        post_TS_ConstDcls_detailedComment( Me );
    }

  if ( post_TS_ConstDcls ) 
    post_TS_ConstDcls( Me );
}


void default_trav_TS_ConstRefs( const TS_ConstRefs& Me )
{
  if ( pre_TS_ConstRefs ) 
    pre_TS_ConstRefs( Me );

  if ( pre_TS_ConstRefs_ts_ConstRefList ) 
    pre_TS_ConstRefs_ts_ConstRefList( Me );
  if ( trav_TS_ConstRefList ) 
    trav_TS_ConstRefList( Me.ts_ConstRefList() );
  if ( post_TS_ConstRefs_ts_ConstRefList ) 
    post_TS_ConstRefs_ts_ConstRefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_ConstRefs_detailedComment ) 
        pre_TS_ConstRefs_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_ConstRefs_detailedComment ) 
        post_TS_ConstRefs_detailedComment( Me );
    }

  if ( post_TS_ConstRefs ) 
    post_TS_ConstRefs( Me );
}


void default_trav_TS_ConstDclList( const TS_ConstDclList& Me )
{
  if ( pre_TS_ConstDclList ) 
    pre_TS_ConstDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_ConstDclList_ts_ConstDcl ) 
        pre_TS_ConstDclList_ts_ConstDcl( Me, i );
      if ( trav_TS_ConstDcl ) 
        trav_TS_ConstDcl( Me.ts_ConstDcl( i ) );
      if ( post_TS_ConstDclList_ts_ConstDcl ) 
        post_TS_ConstDclList_ts_ConstDcl( Me, i );
  }

  if ( post_TS_ConstDclList ) 
    post_TS_ConstDclList( Me );
}


void default_trav_TS_ConstRefList( const TS_ConstRefList& Me )
{
  if ( pre_TS_ConstRefList ) 
    pre_TS_ConstRefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_ConstRefList_ts_ConstRef ) 
        pre_TS_ConstRefList_ts_ConstRef( Me, i );
      if ( trav_TS_ConstRef ) 
        trav_TS_ConstRef( Me.ts_ConstRef( i ) );
      if ( post_TS_ConstRefList_ts_ConstRef ) 
        post_TS_ConstRefList_ts_ConstRef( Me, i );
  }

  if ( post_TS_ConstRefList ) 
    post_TS_ConstRefList( Me );
}


void default_trav_TS_ConstDcl( const TS_ConstDcl& Me )
{
  if ( pre_TS_ConstDcl ) 
    pre_TS_ConstDcl( Me );

  if ( Me.is_present_ts_ConstId())
    {
      if ( pre_TS_ConstDcl_ts_ConstId ) 
        pre_TS_ConstDcl_ts_ConstId( Me );
      if ( trav_TS_ConstId ) 
        trav_TS_ConstId( Me.ts_ConstId() );
      if ( post_TS_ConstDcl_ts_ConstId ) 
        post_TS_ConstDcl_ts_ConstId( Me );
    }

  if ( Me.is_present_ts_ConstType())
    {
      if ( pre_TS_ConstDcl_ts_ConstType ) 
        pre_TS_ConstDcl_ts_ConstType( Me );
      if ( trav_TS_ConstType ) 
        trav_TS_ConstType( Me.ts_ConstType() );
      if ( post_TS_ConstDcl_ts_ConstType ) 
        post_TS_ConstDcl_ts_ConstType( Me );
    }

  if ( Me.is_present_ts_ConstValue())
    {
      if ( pre_TS_ConstDcl_ts_ConstValue ) 
        pre_TS_ConstDcl_ts_ConstValue( Me );
      if ( trav_TS_ConstValue ) 
        trav_TS_ConstValue( Me.ts_ConstValue() );
      if ( post_TS_ConstDcl_ts_ConstValue ) 
        post_TS_ConstDcl_ts_ConstValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_ConstDcl_comment ) 
        pre_TS_ConstDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_ConstDcl_comment ) 
        post_TS_ConstDcl_comment( Me );
    }

  if ( post_TS_ConstDcl ) 
    post_TS_ConstDcl( Me );
}


void default_trav_TS_ConstRef( const TS_ConstRef& Me )
{
  if ( pre_TS_ConstRef ) 
    pre_TS_ConstRef( Me );

  if ( Me.is_present_ts_ConstId())
    {
      if ( pre_TS_ConstRef_ts_ConstId ) 
        pre_TS_ConstRef_ts_ConstId( Me );
      if ( trav_TS_ConstId ) 
        trav_TS_ConstId( Me.ts_ConstId() );
      if ( post_TS_ConstRef_ts_ConstId ) 
        post_TS_ConstRef_ts_ConstId( Me );
    }

  if ( Me.is_present_ts_ConstType())
    {
      if ( pre_TS_ConstRef_ts_ConstType ) 
        pre_TS_ConstRef_ts_ConstType( Me );
      if ( trav_TS_ConstType ) 
        trav_TS_ConstType( Me.ts_ConstType() );
      if ( post_TS_ConstRef_ts_ConstType ) 
        post_TS_ConstRef_ts_ConstType( Me );
    }

  if ( Me.is_present_asn1_ValueReference())
    {
      if ( pre_TS_ConstRef_asn1_ValueReference ) 
        pre_TS_ConstRef_asn1_ValueReference( Me );
      if ( trav_ASN1_ValueReference ) 
        trav_ASN1_ValueReference( Me.asn1_ValueReference() );
      if ( post_TS_ConstRef_asn1_ValueReference ) 
        post_TS_ConstRef_asn1_ValueReference( Me );
    }

  if ( Me.is_present_asn1_ModuleId())
    {
      if ( pre_TS_ConstRef_asn1_ModuleId ) 
        pre_TS_ConstRef_asn1_ModuleId( Me );
      if ( trav_ASN1_ModuleId ) 
        trav_ASN1_ModuleId( Me.asn1_ModuleId() );
      if ( post_TS_ConstRef_asn1_ModuleId ) 
        post_TS_ConstRef_asn1_ModuleId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_ConstRef_comment ) 
        pre_TS_ConstRef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_ConstRef_comment ) 
        post_TS_ConstRef_comment( Me );
    }

  if ( Me.is_present_ts_ConstValue())
    {
      if ( pre_TS_ConstRef_ts_ConstValue ) 
        pre_TS_ConstRef_ts_ConstValue( Me );
      if ( trav_TS_ConstValue ) 
        trav_TS_ConstValue( Me.ts_ConstValue() );
      if ( post_TS_ConstRef_ts_ConstValue ) 
        post_TS_ConstRef_ts_ConstValue( Me );
    }

  if ( post_TS_ConstRef ) 
    post_TS_ConstRef( Me );
}


void default_trav_ASN1_ValueReference( const ASN1_ValueReference& Me )
{
  if ( pre_ASN1_ValueReference ) 
    pre_ASN1_ValueReference( Me );

  if ( post_ASN1_ValueReference ) 
    post_ASN1_ValueReference( Me );
}


void default_trav_TS_ConstId( const TS_ConstId& Me )
{
  if ( pre_TS_ConstId ) 
    pre_TS_ConstId( Me );

  if ( pre_TS_ConstId_ts_ConstIdentifier ) 
    pre_TS_ConstId_ts_ConstIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_ConstIdentifier() );
  if ( post_TS_ConstId_ts_ConstIdentifier ) 
    post_TS_ConstId_ts_ConstIdentifier( Me );

  if ( post_TS_ConstId ) 
    post_TS_ConstId( Me );
}


void default_trav_TS_ConstType( const TS_ConstType& Me )
{
  if ( pre_TS_ConstType ) 
    pre_TS_ConstType( Me );

  if ( pre_TS_ConstType_ttcn_Type ) 
    pre_TS_ConstType_ttcn_Type( Me );
  if ( trav_TTCN_Type ) 
    trav_TTCN_Type( Me.ttcn_Type() );
  if ( post_TS_ConstType_ttcn_Type ) 
    post_TS_ConstType_ttcn_Type( Me );

  if ( post_TS_ConstType ) 
    post_TS_ConstType( Me );
}


void default_trav_TS_ConstValue( const TS_ConstValue& Me )
{
  if ( pre_TS_ConstValue ) 
    pre_TS_ConstValue( Me );

  if ( pre_TS_ConstValue_declarationValue ) 
    pre_TS_ConstValue_declarationValue( Me );
  if ( trav_DeclarationValue ) 
    trav_DeclarationValue( Me.declarationValue() );
  if ( post_TS_ConstValue_declarationValue ) 
    post_TS_ConstValue_declarationValue( Me );

  if ( post_TS_ConstValue ) 
    post_TS_ConstValue( Me );
}


void default_trav_DeclarationValue( const DeclarationValue& Me )
{
  if ( pre_DeclarationValue ) 
    pre_DeclarationValue( Me );

  if ( pre_DeclarationValue_expression ) 
    pre_DeclarationValue_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_DeclarationValue_expression ) 
    post_DeclarationValue_expression( Me );

  if ( post_DeclarationValue ) 
    post_DeclarationValue( Me );
}


void default_trav_TS_VarDcls( const TS_VarDcls& Me )
{
  if ( pre_TS_VarDcls ) 
    pre_TS_VarDcls( Me );

  if ( pre_TS_VarDcls_ts_VarDclList ) 
    pre_TS_VarDcls_ts_VarDclList( Me );
  if ( trav_TS_VarDclList ) 
    trav_TS_VarDclList( Me.ts_VarDclList() );
  if ( post_TS_VarDcls_ts_VarDclList ) 
    post_TS_VarDcls_ts_VarDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TS_VarDcls_detailedComment ) 
        pre_TS_VarDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TS_VarDcls_detailedComment ) 
        post_TS_VarDcls_detailedComment( Me );
    }

  if ( post_TS_VarDcls ) 
    post_TS_VarDcls( Me );
}


void default_trav_TS_VarDclList( const TS_VarDclList& Me )
{
  if ( pre_TS_VarDclList ) 
    pre_TS_VarDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TS_VarDclList_ts_VarDcl ) 
        pre_TS_VarDclList_ts_VarDcl( Me, i );
      if ( trav_TS_VarDcl ) 
        trav_TS_VarDcl( Me.ts_VarDcl( i ) );
      if ( post_TS_VarDclList_ts_VarDcl ) 
        post_TS_VarDclList_ts_VarDcl( Me, i );
  }

  if ( post_TS_VarDclList ) 
    post_TS_VarDclList( Me );
}


void default_trav_TS_VarDcl( const TS_VarDcl& Me )
{
  if ( pre_TS_VarDcl ) 
    pre_TS_VarDcl( Me );

  if ( Me.is_present_ts_VarId())
    {
      if ( pre_TS_VarDcl_ts_VarId ) 
        pre_TS_VarDcl_ts_VarId( Me );
      if ( trav_TS_VarId ) 
        trav_TS_VarId( Me.ts_VarId() );
      if ( post_TS_VarDcl_ts_VarId ) 
        post_TS_VarDcl_ts_VarId( Me );
    }

  if ( Me.is_present_ts_VarType())
    {
      if ( pre_TS_VarDcl_ts_VarType ) 
        pre_TS_VarDcl_ts_VarType( Me );
      if ( trav_TS_VarType ) 
        trav_TS_VarType( Me.ts_VarType() );
      if ( post_TS_VarDcl_ts_VarType ) 
        post_TS_VarDcl_ts_VarType( Me );
    }

  if ( Me.is_present_ts_VarValue())
    {
      if ( pre_TS_VarDcl_ts_VarValue ) 
        pre_TS_VarDcl_ts_VarValue( Me );
      if ( trav_TS_VarValue ) 
        trav_TS_VarValue( Me.ts_VarValue() );
      if ( post_TS_VarDcl_ts_VarValue ) 
        post_TS_VarDcl_ts_VarValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TS_VarDcl_comment ) 
        pre_TS_VarDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TS_VarDcl_comment ) 
        post_TS_VarDcl_comment( Me );
    }

  if ( post_TS_VarDcl ) 
    post_TS_VarDcl( Me );
}


void default_trav_TS_VarId( const TS_VarId& Me )
{
  if ( pre_TS_VarId ) 
    pre_TS_VarId( Me );

  if ( pre_TS_VarId_ts_VarIdentifier ) 
    pre_TS_VarId_ts_VarIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_VarIdentifier() );
  if ( post_TS_VarId_ts_VarIdentifier ) 
    post_TS_VarId_ts_VarIdentifier( Me );

  if ( post_TS_VarId ) 
    post_TS_VarId( Me );
}


void default_trav_TS_VarType( const TS_VarType& Me )
{
  if ( pre_TS_VarType ) 
    pre_TS_VarType( Me );

  if ( pre_TS_VarType_typeOrPDU ) 
    pre_TS_VarType_typeOrPDU( Me );
  if ( trav_TypeOrPDU ) 
    trav_TypeOrPDU( Me.typeOrPDU() );
  if ( post_TS_VarType_typeOrPDU ) 
    post_TS_VarType_typeOrPDU( Me );

  if ( post_TS_VarType ) 
    post_TS_VarType( Me );
}


void default_trav_TS_VarValue( const TS_VarValue& Me )
{
  if ( pre_TS_VarValue ) 
    pre_TS_VarValue( Me );

  if ( pre_TS_VarValue_declarationValue ) 
    pre_TS_VarValue_declarationValue( Me );
  if ( trav_DeclarationValue ) 
    trav_DeclarationValue( Me.declarationValue() );
  if ( post_TS_VarValue_declarationValue ) 
    post_TS_VarValue_declarationValue( Me );

  if ( post_TS_VarValue ) 
    post_TS_VarValue( Me );
}


void default_trav_TC_VarDcls( const TC_VarDcls& Me )
{
  if ( pre_TC_VarDcls ) 
    pre_TC_VarDcls( Me );

  if ( pre_TC_VarDcls_tc_VarDclList ) 
    pre_TC_VarDcls_tc_VarDclList( Me );
  if ( trav_TC_VarDclList ) 
    trav_TC_VarDclList( Me.tc_VarDclList() );
  if ( post_TC_VarDcls_tc_VarDclList ) 
    post_TC_VarDcls_tc_VarDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TC_VarDcls_detailedComment ) 
        pre_TC_VarDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TC_VarDcls_detailedComment ) 
        post_TC_VarDcls_detailedComment( Me );
    }

  if ( post_TC_VarDcls ) 
    post_TC_VarDcls( Me );
}


void default_trav_TC_VarDclList( const TC_VarDclList& Me )
{
  if ( pre_TC_VarDclList ) 
    pre_TC_VarDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TC_VarDclList_tc_VarDcl ) 
        pre_TC_VarDclList_tc_VarDcl( Me, i );
      if ( trav_TC_VarDcl ) 
        trav_TC_VarDcl( Me.tc_VarDcl( i ) );
      if ( post_TC_VarDclList_tc_VarDcl ) 
        post_TC_VarDclList_tc_VarDcl( Me, i );
  }

  if ( post_TC_VarDclList ) 
    post_TC_VarDclList( Me );
}


void default_trav_TC_VarDcl( const TC_VarDcl& Me )
{
  if ( pre_TC_VarDcl ) 
    pre_TC_VarDcl( Me );

  if ( Me.is_present_tc_VarId())
    {
      if ( pre_TC_VarDcl_tc_VarId ) 
        pre_TC_VarDcl_tc_VarId( Me );
      if ( trav_TC_VarId ) 
        trav_TC_VarId( Me.tc_VarId() );
      if ( post_TC_VarDcl_tc_VarId ) 
        post_TC_VarDcl_tc_VarId( Me );
    }

  if ( Me.is_present_tc_VarType())
    {
      if ( pre_TC_VarDcl_tc_VarType ) 
        pre_TC_VarDcl_tc_VarType( Me );
      if ( trav_TC_VarType ) 
        trav_TC_VarType( Me.tc_VarType() );
      if ( post_TC_VarDcl_tc_VarType ) 
        post_TC_VarDcl_tc_VarType( Me );
    }

  if ( Me.is_present_tc_VarValue())
    {
      if ( pre_TC_VarDcl_tc_VarValue ) 
        pre_TC_VarDcl_tc_VarValue( Me );
      if ( trav_TC_VarValue ) 
        trav_TC_VarValue( Me.tc_VarValue() );
      if ( post_TC_VarDcl_tc_VarValue ) 
        post_TC_VarDcl_tc_VarValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TC_VarDcl_comment ) 
        pre_TC_VarDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TC_VarDcl_comment ) 
        post_TC_VarDcl_comment( Me );
    }

  if ( post_TC_VarDcl ) 
    post_TC_VarDcl( Me );
}


void default_trav_TC_VarId( const TC_VarId& Me )
{
  if ( pre_TC_VarId ) 
    pre_TC_VarId( Me );

  if ( pre_TC_VarId_tc_VarIdentifier ) 
    pre_TC_VarId_tc_VarIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tc_VarIdentifier() );
  if ( post_TC_VarId_tc_VarIdentifier ) 
    post_TC_VarId_tc_VarIdentifier( Me );

  if ( post_TC_VarId ) 
    post_TC_VarId( Me );
}


void default_trav_TC_VarType( const TC_VarType& Me )
{
  if ( pre_TC_VarType ) 
    pre_TC_VarType( Me );

  if ( pre_TC_VarType_typeOrPDU ) 
    pre_TC_VarType_typeOrPDU( Me );
  if ( trav_TypeOrPDU ) 
    trav_TypeOrPDU( Me.typeOrPDU() );
  if ( post_TC_VarType_typeOrPDU ) 
    post_TC_VarType_typeOrPDU( Me );

  if ( post_TC_VarType ) 
    post_TC_VarType( Me );
}


void default_trav_TC_VarValue( const TC_VarValue& Me )
{
  if ( pre_TC_VarValue ) 
    pre_TC_VarValue( Me );

  if ( pre_TC_VarValue_declarationValue ) 
    pre_TC_VarValue_declarationValue( Me );
  if ( trav_DeclarationValue ) 
    trav_DeclarationValue( Me.declarationValue() );
  if ( post_TC_VarValue_declarationValue ) 
    post_TC_VarValue_declarationValue( Me );

  if ( post_TC_VarValue ) 
    post_TC_VarValue( Me );
}


void default_trav_TCompDcls( const TCompDcls& Me )
{
  if ( pre_TCompDcls ) 
    pre_TCompDcls( Me );

  if ( pre_TCompDcls_tcompDclList ) 
    pre_TCompDcls_tcompDclList( Me );
  if ( trav_TCompDclList ) 
    trav_TCompDclList( Me.tcompDclList() );
  if ( post_TCompDcls_tcompDclList ) 
    post_TCompDcls_tcompDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TCompDcls_detailedComment ) 
        pre_TCompDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TCompDcls_detailedComment ) 
        post_TCompDcls_detailedComment( Me );
    }

  if ( post_TCompDcls ) 
    post_TCompDcls( Me );
}


void default_trav_TCompDclList( const TCompDclList& Me )
{
  if ( pre_TCompDclList ) 
    pre_TCompDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TCompDclList_tcompDcl ) 
        pre_TCompDclList_tcompDcl( Me, i );
      if ( trav_TCompDcl ) 
        trav_TCompDcl( Me.tcompDcl( i ) );
      if ( post_TCompDclList_tcompDcl ) 
        post_TCompDclList_tcompDcl( Me, i );
  }

  if ( post_TCompDclList ) 
    post_TCompDclList( Me );
}


void default_trav_TCompDcl( const TCompDcl& Me )
{
  if ( pre_TCompDcl ) 
    pre_TCompDcl( Me );

  if ( Me.is_present_tcompId())
    {
      if ( pre_TCompDcl_tcompId ) 
        pre_TCompDcl_tcompId( Me );
      if ( trav_TCompId ) 
        trav_TCompId( Me.tcompId() );
      if ( post_TCompDcl_tcompId ) 
        post_TCompDcl_tcompId( Me );
    }

  if ( Me.is_present_tc_Role())
    {
      if ( pre_TCompDcl_tc_Role ) 
        pre_TCompDcl_tc_Role( Me );
      if ( trav_TC_Role ) 
        trav_TC_Role( Me.tc_Role() );
      if ( post_TCompDcl_tc_Role ) 
        post_TCompDcl_tc_Role( Me );
    }

  if ( Me.is_present_numOf_PCOs())
    {
      if ( pre_TCompDcl_numOf_PCOs ) 
        pre_TCompDcl_numOf_PCOs( Me );
      if ( trav_NumOf_PCOs ) 
        trav_NumOf_PCOs( Me.numOf_PCOs() );
      if ( post_TCompDcl_numOf_PCOs ) 
        post_TCompDcl_numOf_PCOs( Me );
    }

  if ( Me.is_present_numOf_CPs())
    {
      if ( pre_TCompDcl_numOf_CPs ) 
        pre_TCompDcl_numOf_CPs( Me );
      if ( trav_NumOf_CPs ) 
        trav_NumOf_CPs( Me.numOf_CPs() );
      if ( post_TCompDcl_numOf_CPs ) 
        post_TCompDcl_numOf_CPs( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TCompDcl_comment ) 
        pre_TCompDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TCompDcl_comment ) 
        post_TCompDcl_comment( Me );
    }

  if ( post_TCompDcl ) 
    post_TCompDcl( Me );
}


void default_trav_TCompId( const TCompId& Me )
{
  if ( pre_TCompId ) 
    pre_TCompId( Me );

  if ( pre_TCompId_tcompIdentifier ) 
    pre_TCompId_tcompIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tcompIdentifier() );
  if ( post_TCompId_tcompIdentifier ) 
    post_TCompId_tcompIdentifier( Me );

  if ( post_TCompId ) 
    post_TCompId( Me );
}


void default_trav_TC_Role( const TC_Role& Me )
{
  if ( pre_TC_Role ) 
    pre_TC_Role( Me );

  if ( pre_TC_Role_tcomp_Role ) 
    pre_TC_Role_tcomp_Role( Me );
  if ( trav_TComp_Role ) 
    trav_TComp_Role( Me.tcomp_Role() );
  if ( post_TC_Role_tcomp_Role ) 
    post_TC_Role_tcomp_Role( Me );

  if ( post_TC_Role ) 
    post_TC_Role( Me );
}


void default_trav_TComp_Role( const TComp_Role& Me )
{
  if ( pre_TComp_Role ) 
    pre_TComp_Role( Me );

  switch ( Me.choice() )
    {
    case Choices::c_MTC:
      if ( pre_TComp_Role_mtc ) 
        pre_TComp_Role_mtc( Me );
      if ( trav_MTC ) 
        trav_MTC( Me.mtc() );
      if ( post_TComp_Role_mtc ) 
        post_TComp_Role_mtc( Me );
      break;

    case Choices::c_PTC:
      if ( pre_TComp_Role_ptc ) 
        pre_TComp_Role_ptc( Me );
      if ( trav_PTC ) 
        trav_PTC( Me.ptc() );
      if ( post_TComp_Role_ptc ) 
        post_TComp_Role_ptc( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TComp_Role: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TComp_Role ) 
    post_TComp_Role( Me );
}


void default_trav_NumOf_PCOs( const NumOf_PCOs& Me )
{
  if ( pre_NumOf_PCOs ) 
    pre_NumOf_PCOs( Me );

  if ( pre_NumOf_PCOs_num_PCOs ) 
    pre_NumOf_PCOs_num_PCOs( Me );
  if ( trav_Num_PCOs ) 
    trav_Num_PCOs( Me.num_PCOs() );
  if ( post_NumOf_PCOs_num_PCOs ) 
    post_NumOf_PCOs_num_PCOs( Me );

  if ( post_NumOf_PCOs ) 
    post_NumOf_PCOs( Me );
}


void default_trav_NumOf_CPs( const NumOf_CPs& Me )
{
  if ( pre_NumOf_CPs ) 
    pre_NumOf_CPs( Me );

  if ( pre_NumOf_CPs_num_CPs ) 
    pre_NumOf_CPs_num_CPs( Me );
  if ( trav_Num_CPs ) 
    trav_Num_CPs( Me.num_CPs() );
  if ( post_NumOf_CPs_num_CPs ) 
    post_NumOf_CPs_num_CPs( Me );

  if ( post_NumOf_CPs ) 
    post_NumOf_CPs( Me );
}


void default_trav_Num_PCOs( const Num_PCOs& Me )
{
  if ( pre_Num_PCOs ) 
    pre_Num_PCOs( Me );

  if ( pre_Num_PCOs_number ) 
    pre_Num_PCOs_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_Num_PCOs_number ) 
    post_Num_PCOs_number( Me );

  if ( post_Num_PCOs ) 
    post_Num_PCOs( Me );
}


void default_trav_Num_CPs( const Num_CPs& Me )
{
  if ( pre_Num_CPs ) 
    pre_Num_CPs( Me );

  if ( pre_Num_CPs_number ) 
    pre_Num_CPs_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_Num_CPs_number ) 
    post_Num_CPs_number( Me );

  if ( post_Num_CPs ) 
    post_Num_CPs( Me );
}


void default_trav_TCompConfigDcls( const TCompConfigDcls& Me )
{
  if ( pre_TCompConfigDcls ) 
    pre_TCompConfigDcls( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TCompConfigDcls_tcompConfigDcl ) 
        pre_TCompConfigDcls_tcompConfigDcl( Me, i );
      if ( trav_TCompConfigDcl ) 
        trav_TCompConfigDcl( Me.tcompConfigDcl( i ) );
      if ( post_TCompConfigDcls_tcompConfigDcl ) 
        post_TCompConfigDcls_tcompConfigDcl( Me, i );
  }

  if ( post_TCompConfigDcls ) 
    post_TCompConfigDcls( Me );
}


void default_trav_TCompConfigDcl( const TCompConfigDcl& Me )
{
  if ( pre_TCompConfigDcl ) 
    pre_TCompConfigDcl( Me );

  if ( Me.is_present_tcompConfigId())
    {
      if ( pre_TCompConfigDcl_tcompConfigId ) 
        pre_TCompConfigDcl_tcompConfigId( Me );
      if ( trav_TCompConfigId ) 
        trav_TCompConfigId( Me.tcompConfigId() );
      if ( post_TCompConfigDcl_tcompConfigId ) 
        post_TCompConfigDcl_tcompConfigId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TCompConfigDcl_comment ) 
        pre_TCompConfigDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TCompConfigDcl_comment ) 
        post_TCompConfigDcl_comment( Me );
    }

  if ( pre_TCompConfigDcl_tcompConfigInfoList ) 
    pre_TCompConfigDcl_tcompConfigInfoList( Me );
  if ( trav_TCompConfigInfoList ) 
    trav_TCompConfigInfoList( Me.tcompConfigInfoList() );
  if ( post_TCompConfigDcl_tcompConfigInfoList ) 
    post_TCompConfigDcl_tcompConfigInfoList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TCompConfigDcl_detailedComment ) 
        pre_TCompConfigDcl_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TCompConfigDcl_detailedComment ) 
        post_TCompConfigDcl_detailedComment( Me );
    }

  if ( post_TCompConfigDcl ) 
    post_TCompConfigDcl( Me );
}


void default_trav_TCompConfigInfoList( const TCompConfigInfoList& Me )
{
  if ( pre_TCompConfigInfoList ) 
    pre_TCompConfigInfoList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TCompConfigInfoList_tcompConfigInfo ) 
        pre_TCompConfigInfoList_tcompConfigInfo( Me, i );
      if ( trav_TCompConfigInfo ) 
        trav_TCompConfigInfo( Me.tcompConfigInfo( i ) );
      if ( post_TCompConfigInfoList_tcompConfigInfo ) 
        post_TCompConfigInfoList_tcompConfigInfo( Me, i );
  }

  if ( post_TCompConfigInfoList ) 
    post_TCompConfigInfoList( Me );
}


void default_trav_TCompConfigId( const TCompConfigId& Me )
{
  if ( pre_TCompConfigId ) 
    pre_TCompConfigId( Me );

  if ( pre_TCompConfigId_tcompConfigIdentifier ) 
    pre_TCompConfigId_tcompConfigIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tcompConfigIdentifier() );
  if ( post_TCompConfigId_tcompConfigIdentifier ) 
    post_TCompConfigId_tcompConfigIdentifier( Me );

  if ( post_TCompConfigId ) 
    post_TCompConfigId( Me );
}


void default_trav_TCompConfigInfo( const TCompConfigInfo& Me )
{
  if ( pre_TCompConfigInfo ) 
    pre_TCompConfigInfo( Me );

  if ( Me.is_present_tcompUsed())
    {
      if ( pre_TCompConfigInfo_tcompUsed ) 
        pre_TCompConfigInfo_tcompUsed( Me );
      if ( trav_TCompUsed ) 
        trav_TCompUsed( Me.tcompUsed() );
      if ( post_TCompConfigInfo_tcompUsed ) 
        post_TCompConfigInfo_tcompUsed( Me );
    }

  if ( Me.is_present_pcos_Used())
    {
      if ( pre_TCompConfigInfo_pcos_Used ) 
        pre_TCompConfigInfo_pcos_Used( Me );
      if ( trav_PCOs_Used ) 
        trav_PCOs_Used( Me.pcos_Used() );
      if ( post_TCompConfigInfo_pcos_Used ) 
        post_TCompConfigInfo_pcos_Used( Me );
    }

  if ( Me.is_present_cps_Used())
    {
      if ( pre_TCompConfigInfo_cps_Used ) 
        pre_TCompConfigInfo_cps_Used( Me );
      if ( trav_CPs_Used ) 
        trav_CPs_Used( Me.cps_Used() );
      if ( post_TCompConfigInfo_cps_Used ) 
        post_TCompConfigInfo_cps_Used( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TCompConfigInfo_comment ) 
        pre_TCompConfigInfo_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TCompConfigInfo_comment ) 
        post_TCompConfigInfo_comment( Me );
    }

  if ( post_TCompConfigInfo ) 
    post_TCompConfigInfo( Me );
}


void default_trav_TCompUsed( const TCompUsed& Me )
{
  if ( pre_TCompUsed ) 
    pre_TCompUsed( Me );

  if ( pre_TCompUsed_tcompIdentifier ) 
    pre_TCompUsed_tcompIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tcompIdentifier() );
  if ( post_TCompUsed_tcompIdentifier ) 
    post_TCompUsed_tcompIdentifier( Me );

  if ( post_TCompUsed ) 
    post_TCompUsed( Me );
}


void default_trav_PCOs_Used( const PCOs_Used& Me )
{
  if ( pre_PCOs_Used ) 
    pre_PCOs_Used( Me );

  if ( pre_PCOs_Used_pco_List ) 
    pre_PCOs_Used_pco_List( Me );
  if ( trav_PCO_List ) 
    trav_PCO_List( Me.pco_List() );
  if ( post_PCOs_Used_pco_List ) 
    post_PCOs_Used_pco_List( Me );

  if ( post_PCOs_Used ) 
    post_PCOs_Used( Me );
}


void default_trav_PCO_List( const PCO_List& Me )
{
  if ( pre_PCO_List ) 
    pre_PCO_List( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_PCO_List_pco_Identifier ) 
        pre_PCO_List_pco_Identifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.pco_Identifier( i ) );
      if ( post_PCO_List_pco_Identifier ) 
        post_PCO_List_pco_Identifier( Me, i );
  }

  if ( post_PCO_List ) 
    post_PCO_List( Me );
}


void default_trav_CPs_Used( const CPs_Used& Me )
{
  if ( pre_CPs_Used ) 
    pre_CPs_Used( Me );

  if ( pre_CPs_Used_cp_List ) 
    pre_CPs_Used_cp_List( Me );
  if ( trav_CP_List ) 
    trav_CP_List( Me.cp_List() );
  if ( post_CPs_Used_cp_List ) 
    post_CPs_Used_cp_List( Me );

  if ( post_CPs_Used ) 
    post_CPs_Used( Me );
}


void default_trav_CP_List( const CP_List& Me )
{
  if ( pre_CP_List ) 
    pre_CP_List( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CP_List_cp_Identifier ) 
        pre_CP_List_cp_Identifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.cp_Identifier( i ) );
      if ( post_CP_List_cp_Identifier ) 
        post_CP_List_cp_Identifier( Me, i );
  }

  if ( post_CP_List ) 
    post_CP_List( Me );
}


void default_trav_PCO_TypeDcls( const PCO_TypeDcls& Me )
{
  if ( pre_PCO_TypeDcls ) 
    pre_PCO_TypeDcls( Me );

  if ( pre_PCO_TypeDcls_pco_TypeDclList ) 
    pre_PCO_TypeDcls_pco_TypeDclList( Me );
  if ( trav_PCO_TypeDclList ) 
    trav_PCO_TypeDclList( Me.pco_TypeDclList() );
  if ( post_PCO_TypeDcls_pco_TypeDclList ) 
    post_PCO_TypeDcls_pco_TypeDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_PCO_TypeDcls_detailedComment ) 
        pre_PCO_TypeDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_PCO_TypeDcls_detailedComment ) 
        post_PCO_TypeDcls_detailedComment( Me );
    }

  if ( post_PCO_TypeDcls ) 
    post_PCO_TypeDcls( Me );
}


void default_trav_PCO_TypeDclList( const PCO_TypeDclList& Me )
{
  if ( pre_PCO_TypeDclList ) 
    pre_PCO_TypeDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_PCO_TypeDclList_pco_TypeDcl ) 
        pre_PCO_TypeDclList_pco_TypeDcl( Me, i );
      if ( trav_PCO_TypeDcl ) 
        trav_PCO_TypeDcl( Me.pco_TypeDcl( i ) );
      if ( post_PCO_TypeDclList_pco_TypeDcl ) 
        post_PCO_TypeDclList_pco_TypeDcl( Me, i );
  }

  if ( post_PCO_TypeDclList ) 
    post_PCO_TypeDclList( Me );
}


void default_trav_PCO_TypeDcl( const PCO_TypeDcl& Me )
{
  if ( pre_PCO_TypeDcl ) 
    pre_PCO_TypeDcl( Me );

  if ( Me.is_present_pco_TypeId())
    {
      if ( pre_PCO_TypeDcl_pco_TypeId ) 
        pre_PCO_TypeDcl_pco_TypeId( Me );
      if ( trav_PCO_TypeId ) 
        trav_PCO_TypeId( Me.pco_TypeId() );
      if ( post_PCO_TypeDcl_pco_TypeId ) 
        post_PCO_TypeDcl_pco_TypeId( Me );
    }

  if ( Me.is_present_p_Role())
    {
      if ( pre_PCO_TypeDcl_p_Role ) 
        pre_PCO_TypeDcl_p_Role( Me );
      if ( trav_P_Role ) 
        trav_P_Role( Me.p_Role() );
      if ( post_PCO_TypeDcl_p_Role ) 
        post_PCO_TypeDcl_p_Role( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_PCO_TypeDcl_comment ) 
        pre_PCO_TypeDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_PCO_TypeDcl_comment ) 
        post_PCO_TypeDcl_comment( Me );
    }

  if ( post_PCO_TypeDcl ) 
    post_PCO_TypeDcl( Me );
}


void default_trav_PCO_Dcls( const PCO_Dcls& Me )
{
  if ( pre_PCO_Dcls ) 
    pre_PCO_Dcls( Me );

  if ( pre_PCO_Dcls_pco_DclList ) 
    pre_PCO_Dcls_pco_DclList( Me );
  if ( trav_PCO_DclList ) 
    trav_PCO_DclList( Me.pco_DclList() );
  if ( post_PCO_Dcls_pco_DclList ) 
    post_PCO_Dcls_pco_DclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_PCO_Dcls_detailedComment ) 
        pre_PCO_Dcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_PCO_Dcls_detailedComment ) 
        post_PCO_Dcls_detailedComment( Me );
    }

  if ( post_PCO_Dcls ) 
    post_PCO_Dcls( Me );
}


void default_trav_PCO_DclList( const PCO_DclList& Me )
{
  if ( pre_PCO_DclList ) 
    pre_PCO_DclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_PCO_DclList_pco_Dcl ) 
        pre_PCO_DclList_pco_Dcl( Me, i );
      if ( trav_PCO_Dcl ) 
        trav_PCO_Dcl( Me.pco_Dcl( i ) );
      if ( post_PCO_DclList_pco_Dcl ) 
        post_PCO_DclList_pco_Dcl( Me, i );
  }

  if ( post_PCO_DclList ) 
    post_PCO_DclList( Me );
}


void default_trav_PCO_Dcl( const PCO_Dcl& Me )
{
  if ( pre_PCO_Dcl ) 
    pre_PCO_Dcl( Me );

  if ( Me.is_present_pco_Id())
    {
      if ( pre_PCO_Dcl_pco_Id ) 
        pre_PCO_Dcl_pco_Id( Me );
      if ( trav_PCO_Id ) 
        trav_PCO_Id( Me.pco_Id() );
      if ( post_PCO_Dcl_pco_Id ) 
        post_PCO_Dcl_pco_Id( Me );
    }

  if ( Me.is_present_pco_TypeId())
    {
      if ( pre_PCO_Dcl_pco_TypeId ) 
        pre_PCO_Dcl_pco_TypeId( Me );
      if ( trav_PCO_TypeId ) 
        trav_PCO_TypeId( Me.pco_TypeId() );
      if ( post_PCO_Dcl_pco_TypeId ) 
        post_PCO_Dcl_pco_TypeId( Me );
    }

  if ( Me.is_present_p_Role())
    {
      if ( pre_PCO_Dcl_p_Role ) 
        pre_PCO_Dcl_p_Role( Me );
      if ( trav_P_Role ) 
        trav_P_Role( Me.p_Role() );
      if ( post_PCO_Dcl_p_Role ) 
        post_PCO_Dcl_p_Role( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_PCO_Dcl_comment ) 
        pre_PCO_Dcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_PCO_Dcl_comment ) 
        post_PCO_Dcl_comment( Me );
    }

  if ( post_PCO_Dcl ) 
    post_PCO_Dcl( Me );
}


void default_trav_PCO_Id( const PCO_Id& Me )
{
  if ( pre_PCO_Id ) 
    pre_PCO_Id( Me );

  if ( pre_PCO_Id_pco_Identifier ) 
    pre_PCO_Id_pco_Identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.pco_Identifier() );
  if ( post_PCO_Id_pco_Identifier ) 
    post_PCO_Id_pco_Identifier( Me );

  if ( post_PCO_Id ) 
    post_PCO_Id( Me );
}


void default_trav_PCO_TypeId( const PCO_TypeId& Me )
{
  if ( pre_PCO_TypeId ) 
    pre_PCO_TypeId( Me );

  if ( pre_PCO_TypeId_pco_TypeIdentifier ) 
    pre_PCO_TypeId_pco_TypeIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.pco_TypeIdentifier() );
  if ( post_PCO_TypeId_pco_TypeIdentifier ) 
    post_PCO_TypeId_pco_TypeIdentifier( Me );

  if ( post_PCO_TypeId ) 
    post_PCO_TypeId( Me );
}


void default_trav_P_Role( const P_Role& Me )
{
  if ( pre_P_Role ) 
    pre_P_Role( Me );

  if ( pre_P_Role_pco_Role ) 
    pre_P_Role_pco_Role( Me );
  if ( trav_PCO_Role ) 
    trav_PCO_Role( Me.pco_Role() );
  if ( post_P_Role_pco_Role ) 
    post_P_Role_pco_Role( Me );

  if ( post_P_Role ) 
    post_P_Role( Me );
}


void default_trav_PCO_Role( const PCO_Role& Me )
{
  if ( pre_PCO_Role ) 
    pre_PCO_Role( Me );

  switch ( Me.choice() )
    {
    case Choices::c_UT:
      if ( pre_PCO_Role_ut ) 
        pre_PCO_Role_ut( Me );
      if ( trav_UT ) 
        trav_UT( Me.ut() );
      if ( post_PCO_Role_ut ) 
        post_PCO_Role_ut( Me );
      break;

    case Choices::c_LT:
      if ( pre_PCO_Role_lt ) 
        pre_PCO_Role_lt( Me );
      if ( trav_LT ) 
        trav_LT( Me.lt() );
      if ( post_PCO_Role_lt ) 
        post_PCO_Role_lt( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node PCO_Role: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_PCO_Role ) 
    post_PCO_Role( Me );
}


void default_trav_CP_Dcls( const CP_Dcls& Me )
{
  if ( pre_CP_Dcls ) 
    pre_CP_Dcls( Me );

  if ( pre_CP_Dcls_cp_DclList ) 
    pre_CP_Dcls_cp_DclList( Me );
  if ( trav_CP_DclList ) 
    trav_CP_DclList( Me.cp_DclList() );
  if ( post_CP_Dcls_cp_DclList ) 
    post_CP_Dcls_cp_DclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_CP_Dcls_detailedComment ) 
        pre_CP_Dcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_CP_Dcls_detailedComment ) 
        post_CP_Dcls_detailedComment( Me );
    }

  if ( post_CP_Dcls ) 
    post_CP_Dcls( Me );
}


void default_trav_CP_DclList( const CP_DclList& Me )
{
  if ( pre_CP_DclList ) 
    pre_CP_DclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CP_DclList_cp_Dcl ) 
        pre_CP_DclList_cp_Dcl( Me, i );
      if ( trav_CP_Dcl ) 
        trav_CP_Dcl( Me.cp_Dcl( i ) );
      if ( post_CP_DclList_cp_Dcl ) 
        post_CP_DclList_cp_Dcl( Me, i );
  }

  if ( post_CP_DclList ) 
    post_CP_DclList( Me );
}


void default_trav_CP_Dcl( const CP_Dcl& Me )
{
  if ( pre_CP_Dcl ) 
    pre_CP_Dcl( Me );

  if ( Me.is_present_cp_Id())
    {
      if ( pre_CP_Dcl_cp_Id ) 
        pre_CP_Dcl_cp_Id( Me );
      if ( trav_CP_Id ) 
        trav_CP_Id( Me.cp_Id() );
      if ( post_CP_Dcl_cp_Id ) 
        post_CP_Dcl_cp_Id( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_CP_Dcl_comment ) 
        pre_CP_Dcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_CP_Dcl_comment ) 
        post_CP_Dcl_comment( Me );
    }

  if ( post_CP_Dcl ) 
    post_CP_Dcl( Me );
}


void default_trav_CP_Id( const CP_Id& Me )
{
  if ( pre_CP_Id ) 
    pre_CP_Id( Me );

  if ( pre_CP_Id_cp_Identifier ) 
    pre_CP_Id_cp_Identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.cp_Identifier() );
  if ( post_CP_Id_cp_Identifier ) 
    post_CP_Id_cp_Identifier( Me );

  if ( post_CP_Id ) 
    post_CP_Id( Me );
}


void default_trav_TimerDcls( const TimerDcls& Me )
{
  if ( pre_TimerDcls ) 
    pre_TimerDcls( Me );

  if ( pre_TimerDcls_timerDclList ) 
    pre_TimerDcls_timerDclList( Me );
  if ( trav_TimerDclList ) 
    trav_TimerDclList( Me.timerDclList() );
  if ( post_TimerDcls_timerDclList ) 
    post_TimerDcls_timerDclList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TimerDcls_detailedComment ) 
        pre_TimerDcls_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TimerDcls_detailedComment ) 
        post_TimerDcls_detailedComment( Me );
    }

  if ( post_TimerDcls ) 
    post_TimerDcls( Me );
}


void default_trav_TimerDclList( const TimerDclList& Me )
{
  if ( pre_TimerDclList ) 
    pre_TimerDclList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TimerDclList_timerDcl ) 
        pre_TimerDclList_timerDcl( Me, i );
      if ( trav_TimerDcl ) 
        trav_TimerDcl( Me.timerDcl( i ) );
      if ( post_TimerDclList_timerDcl ) 
        post_TimerDclList_timerDcl( Me, i );
  }

  if ( post_TimerDclList ) 
    post_TimerDclList( Me );
}


void default_trav_TimerDcl( const TimerDcl& Me )
{
  if ( pre_TimerDcl ) 
    pre_TimerDcl( Me );

  if ( Me.is_present_timerId())
    {
      if ( pre_TimerDcl_timerId ) 
        pre_TimerDcl_timerId( Me );
      if ( trav_TimerId ) 
        trav_TimerId( Me.timerId() );
      if ( post_TimerDcl_timerId ) 
        post_TimerDcl_timerId( Me );
    }

  if ( Me.is_present_duration())
    {
      if ( pre_TimerDcl_duration ) 
        pre_TimerDcl_duration( Me );
      if ( trav_Duration ) 
        trav_Duration( Me.duration() );
      if ( post_TimerDcl_duration ) 
        post_TimerDcl_duration( Me );
    }

  if ( Me.is_present_unit())
    {
      if ( pre_TimerDcl_unit ) 
        pre_TimerDcl_unit( Me );
      if ( trav_Unit ) 
        trav_Unit( Me.unit() );
      if ( post_TimerDcl_unit ) 
        post_TimerDcl_unit( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TimerDcl_comment ) 
        pre_TimerDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TimerDcl_comment ) 
        post_TimerDcl_comment( Me );
    }

  if ( post_TimerDcl ) 
    post_TimerDcl( Me );
}


void default_trav_TimerId( const TimerId& Me )
{
  if ( pre_TimerId ) 
    pre_TimerId( Me );

  if ( pre_TimerId_timerIdentifier ) 
    pre_TimerId_timerIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.timerIdentifier() );
  if ( post_TimerId_timerIdentifier ) 
    post_TimerId_timerIdentifier( Me );

  if ( post_TimerId ) 
    post_TimerId( Me );
}


void default_trav_Duration( const Duration& Me )
{
  if ( pre_Duration ) 
    pre_Duration( Me );

  if ( pre_Duration_declarationValue ) 
    pre_Duration_declarationValue( Me );
  if ( trav_DeclarationValue ) 
    trav_DeclarationValue( Me.declarationValue() );
  if ( post_Duration_declarationValue ) 
    post_Duration_declarationValue( Me );

  if ( post_Duration ) 
    post_Duration( Me );
}


void default_trav_Unit( const Unit& Me )
{
  if ( pre_Unit ) 
    pre_Unit( Me );

  if ( pre_Unit_timeUnit ) 
    pre_Unit_timeUnit( Me );
  if ( trav_TimeUnit ) 
    trav_TimeUnit( Me.timeUnit() );
  if ( post_Unit_timeUnit ) 
    post_Unit_timeUnit( Me );

  if ( post_Unit ) 
    post_Unit( Me );
}


void default_trav_TimeUnit( const TimeUnit& Me )
{
  if ( pre_TimeUnit ) 
    pre_TimeUnit( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PicoSeconds:
      if ( pre_TimeUnit_picoSeconds ) 
        pre_TimeUnit_picoSeconds( Me );
      if ( trav_PicoSeconds ) 
        trav_PicoSeconds( Me.picoSeconds() );
      if ( post_TimeUnit_picoSeconds ) 
        post_TimeUnit_picoSeconds( Me );
      break;

    case Choices::c_NanoSeconds:
      if ( pre_TimeUnit_nanoSeconds ) 
        pre_TimeUnit_nanoSeconds( Me );
      if ( trav_NanoSeconds ) 
        trav_NanoSeconds( Me.nanoSeconds() );
      if ( post_TimeUnit_nanoSeconds ) 
        post_TimeUnit_nanoSeconds( Me );
      break;

    case Choices::c_MicroSeconds:
      if ( pre_TimeUnit_microSeconds ) 
        pre_TimeUnit_microSeconds( Me );
      if ( trav_MicroSeconds ) 
        trav_MicroSeconds( Me.microSeconds() );
      if ( post_TimeUnit_microSeconds ) 
        post_TimeUnit_microSeconds( Me );
      break;

    case Choices::c_MilliSeconds:
      if ( pre_TimeUnit_milliSeconds ) 
        pre_TimeUnit_milliSeconds( Me );
      if ( trav_MilliSeconds ) 
        trav_MilliSeconds( Me.milliSeconds() );
      if ( post_TimeUnit_milliSeconds ) 
        post_TimeUnit_milliSeconds( Me );
      break;

    case Choices::c_Seconds:
      if ( pre_TimeUnit_seconds ) 
        pre_TimeUnit_seconds( Me );
      if ( trav_Seconds ) 
        trav_Seconds( Me.seconds() );
      if ( post_TimeUnit_seconds ) 
        post_TimeUnit_seconds( Me );
      break;

    case Choices::c_Minutes:
      if ( pre_TimeUnit_minutes ) 
        pre_TimeUnit_minutes( Me );
      if ( trav_Minutes ) 
        trav_Minutes( Me.minutes() );
      if ( post_TimeUnit_minutes ) 
        post_TimeUnit_minutes( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TimeUnit: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TimeUnit ) 
    post_TimeUnit( Me );
}


void default_trav_ComplexDefinitions( const ComplexDefinitions& Me )
{
  if ( pre_ComplexDefinitions ) 
    pre_ComplexDefinitions( Me );

  if ( pre_ComplexDefinitions_asp_TypeDefs ) 
    pre_ComplexDefinitions_asp_TypeDefs( Me );
  if ( trav_ASP_TypeDefs ) 
    trav_ASP_TypeDefs( Me.asp_TypeDefs() );
  if ( post_ComplexDefinitions_asp_TypeDefs ) 
    post_ComplexDefinitions_asp_TypeDefs( Me );

  if ( pre_ComplexDefinitions_pdu_TypeDefs ) 
    pre_ComplexDefinitions_pdu_TypeDefs( Me );
  if ( trav_PDU_TypeDefs ) 
    trav_PDU_TypeDefs( Me.pdu_TypeDefs() );
  if ( post_ComplexDefinitions_pdu_TypeDefs ) 
    post_ComplexDefinitions_pdu_TypeDefs( Me );

  if ( pre_ComplexDefinitions_cm_TypeDefs ) 
    pre_ComplexDefinitions_cm_TypeDefs( Me );
  if ( trav_CM_TypeDefs ) 
    trav_CM_TypeDefs( Me.cm_TypeDefs() );
  if ( post_ComplexDefinitions_cm_TypeDefs ) 
    post_ComplexDefinitions_cm_TypeDefs( Me );

  if ( pre_ComplexDefinitions_aliasDefs ) 
    pre_ComplexDefinitions_aliasDefs( Me );
  if ( trav_AliasDefs ) 
    trav_AliasDefs( Me.aliasDefs() );
  if ( post_ComplexDefinitions_aliasDefs ) 
    post_ComplexDefinitions_aliasDefs( Me );

  if ( post_ComplexDefinitions ) 
    post_ComplexDefinitions( Me );
}


void default_trav_ASP_TypeDefs( const ASP_TypeDefs& Me )
{
  if ( pre_ASP_TypeDefs ) 
    pre_ASP_TypeDefs( Me );

  if ( pre_ASP_TypeDefs_ttcn_ASP_TypeDefs ) 
    pre_ASP_TypeDefs_ttcn_ASP_TypeDefs( Me );
  if ( trav_TTCN_ASP_TypeDefs ) 
    trav_TTCN_ASP_TypeDefs( Me.ttcn_ASP_TypeDefs() );
  if ( post_ASP_TypeDefs_ttcn_ASP_TypeDefs ) 
    post_ASP_TypeDefs_ttcn_ASP_TypeDefs( Me );

  if ( pre_ASP_TypeDefs_asn1_ASP_TypeDefs ) 
    pre_ASP_TypeDefs_asn1_ASP_TypeDefs( Me );
  if ( trav_ASN1_ASP_TypeDefs ) 
    trav_ASN1_ASP_TypeDefs( Me.asn1_ASP_TypeDefs() );
  if ( post_ASP_TypeDefs_asn1_ASP_TypeDefs ) 
    post_ASP_TypeDefs_asn1_ASP_TypeDefs( Me );

  if ( pre_ASP_TypeDefs_asn1_ASP_TypeDefsByRef ) 
    pre_ASP_TypeDefs_asn1_ASP_TypeDefsByRef( Me );
  if ( trav_ASN1_ASP_TypeDefsByRef ) 
    trav_ASN1_ASP_TypeDefsByRef( Me.asn1_ASP_TypeDefsByRef() );
  if ( post_ASP_TypeDefs_asn1_ASP_TypeDefsByRef ) 
    post_ASP_TypeDefs_asn1_ASP_TypeDefsByRef( Me );

  if ( post_ASP_TypeDefs ) 
    post_ASP_TypeDefs( Me );
}


void default_trav_TTCN_ASP_TypeDefs( const TTCN_ASP_TypeDefs& Me )
{
  if ( pre_TTCN_ASP_TypeDefs ) 
    pre_TTCN_ASP_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_ASP_TypeDefs_ttcn_ASP_TypeDef ) 
        pre_TTCN_ASP_TypeDefs_ttcn_ASP_TypeDef( Me, i );
      if ( trav_TTCN_ASP_TypeDef ) 
        trav_TTCN_ASP_TypeDef( Me.ttcn_ASP_TypeDef( i ) );
      if ( post_TTCN_ASP_TypeDefs_ttcn_ASP_TypeDef ) 
        post_TTCN_ASP_TypeDefs_ttcn_ASP_TypeDef( Me, i );
  }

  if ( post_TTCN_ASP_TypeDefs ) 
    post_TTCN_ASP_TypeDefs( Me );
}


void default_trav_TTCN_ASP_TypeDef( const TTCN_ASP_TypeDef& Me )
{
  if ( pre_TTCN_ASP_TypeDef ) 
    pre_TTCN_ASP_TypeDef( Me );

  if ( Me.is_present_asp_Id())
    {
      if ( pre_TTCN_ASP_TypeDef_asp_Id ) 
        pre_TTCN_ASP_TypeDef_asp_Id( Me );
      if ( trav_ASP_Id ) 
        trav_ASP_Id( Me.asp_Id() );
      if ( post_TTCN_ASP_TypeDef_asp_Id ) 
        post_TTCN_ASP_TypeDef_asp_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_TTCN_ASP_TypeDef_pco_Type ) 
        pre_TTCN_ASP_TypeDef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_TTCN_ASP_TypeDef_pco_Type ) 
        post_TTCN_ASP_TypeDef_pco_Type( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_ASP_TypeDef_comment ) 
        pre_TTCN_ASP_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_ASP_TypeDef_comment ) 
        post_TTCN_ASP_TypeDef_comment( Me );
    }

  if ( pre_TTCN_ASP_TypeDef_asp_ParDcls ) 
    pre_TTCN_ASP_TypeDef_asp_ParDcls( Me );
  if ( trav_ASP_ParDcls ) 
    trav_ASP_ParDcls( Me.asp_ParDcls() );
  if ( post_TTCN_ASP_TypeDef_asp_ParDcls ) 
    post_TTCN_ASP_TypeDef_asp_ParDcls( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_ASP_TypeDef_detailedComment ) 
        pre_TTCN_ASP_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_ASP_TypeDef_detailedComment ) 
        post_TTCN_ASP_TypeDef_detailedComment( Me );
    }

  if ( post_TTCN_ASP_TypeDef ) 
    post_TTCN_ASP_TypeDef( Me );
}


void default_trav_ASP_Id( const ASP_Id& Me )
{
  if ( pre_ASP_Id ) 
    pre_ASP_Id( Me );

  if ( pre_ASP_Id_asp_IdAndFullId ) 
    pre_ASP_Id_asp_IdAndFullId( Me );
  if ( trav_ASP_IdAndFullId ) 
    trav_ASP_IdAndFullId( Me.asp_IdAndFullId() );
  if ( post_ASP_Id_asp_IdAndFullId ) 
    post_ASP_Id_asp_IdAndFullId( Me );

  if ( post_ASP_Id ) 
    post_ASP_Id( Me );
}


void default_trav_ASP_IdAndFullId( const ASP_IdAndFullId& Me )
{
  if ( pre_ASP_IdAndFullId ) 
    pre_ASP_IdAndFullId( Me );

  if ( pre_ASP_IdAndFullId_asp_Identifier ) 
    pre_ASP_IdAndFullId_asp_Identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.asp_Identifier() );
  if ( post_ASP_IdAndFullId_asp_Identifier ) 
    post_ASP_IdAndFullId_asp_Identifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_ASP_IdAndFullId_fullIdentifier ) 
        pre_ASP_IdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_ASP_IdAndFullId_fullIdentifier ) 
        post_ASP_IdAndFullId_fullIdentifier( Me );
    }

  if ( post_ASP_IdAndFullId ) 
    post_ASP_IdAndFullId( Me );
}


void default_trav_PCO_Type( const PCO_Type& Me )
{
  if ( pre_PCO_Type ) 
    pre_PCO_Type( Me );

  if ( pre_PCO_Type_pco_TypeIdentifier ) 
    pre_PCO_Type_pco_TypeIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.pco_TypeIdentifier() );
  if ( post_PCO_Type_pco_TypeIdentifier ) 
    post_PCO_Type_pco_TypeIdentifier( Me );

  if ( post_PCO_Type ) 
    post_PCO_Type( Me );
}


void default_trav_ASP_ParDcls( const ASP_ParDcls& Me )
{
  if ( pre_ASP_ParDcls ) 
    pre_ASP_ParDcls( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASP_ParDcls_asp_ParDcl ) 
        pre_ASP_ParDcls_asp_ParDcl( Me, i );
      if ( trav_ASP_ParDcl ) 
        trav_ASP_ParDcl( Me.asp_ParDcl( i ) );
      if ( post_ASP_ParDcls_asp_ParDcl ) 
        post_ASP_ParDcls_asp_ParDcl( Me, i );
  }

  if ( post_ASP_ParDcls ) 
    post_ASP_ParDcls( Me );
}


void default_trav_ASP_ParDcl( const ASP_ParDcl& Me )
{
  if ( pre_ASP_ParDcl ) 
    pre_ASP_ParDcl( Me );

  if ( Me.is_present_asp_ParId())
    {
      if ( pre_ASP_ParDcl_asp_ParId ) 
        pre_ASP_ParDcl_asp_ParId( Me );
      if ( trav_ASP_ParId ) 
        trav_ASP_ParId( Me.asp_ParId() );
      if ( post_ASP_ParDcl_asp_ParId ) 
        post_ASP_ParDcl_asp_ParId( Me );
    }

  if ( Me.is_present_asp_ParType())
    {
      if ( pre_ASP_ParDcl_asp_ParType ) 
        pre_ASP_ParDcl_asp_ParType( Me );
      if ( trav_ASP_ParType ) 
        trav_ASP_ParType( Me.asp_ParType() );
      if ( post_ASP_ParDcl_asp_ParType ) 
        post_ASP_ParDcl_asp_ParType( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASP_ParDcl_comment ) 
        pre_ASP_ParDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASP_ParDcl_comment ) 
        post_ASP_ParDcl_comment( Me );
    }

  if ( post_ASP_ParDcl ) 
    post_ASP_ParDcl( Me );
}


void default_trav_ASP_ParId( const ASP_ParId& Me )
{
  if ( pre_ASP_ParId ) 
    pre_ASP_ParId( Me );

  if ( pre_ASP_ParId_asp_ParIdOrMacro ) 
    pre_ASP_ParId_asp_ParIdOrMacro( Me );
  if ( trav_ASP_ParIdOrMacro ) 
    trav_ASP_ParIdOrMacro( Me.asp_ParIdOrMacro() );
  if ( post_ASP_ParId_asp_ParIdOrMacro ) 
    post_ASP_ParId_asp_ParIdOrMacro( Me );

  if ( post_ASP_ParId ) 
    post_ASP_ParId( Me );
}


void default_trav_ASP_ParIdOrMacro( const ASP_ParIdOrMacro& Me )
{
  if ( pre_ASP_ParIdOrMacro ) 
    pre_ASP_ParIdOrMacro( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ASP_ParIdAndFullId:
      if ( pre_ASP_ParIdOrMacro_asp_ParIdAndFullId ) 
        pre_ASP_ParIdOrMacro_asp_ParIdAndFullId( Me );
      if ( trav_ASP_ParIdAndFullId ) 
        trav_ASP_ParIdAndFullId( Me.asp_ParIdAndFullId() );
      if ( post_ASP_ParIdOrMacro_asp_ParIdAndFullId ) 
        post_ASP_ParIdOrMacro_asp_ParIdAndFullId( Me );
      break;

    case Choices::c_MacroSymbol:
      if ( pre_ASP_ParIdOrMacro_macroSymbol ) 
        pre_ASP_ParIdOrMacro_macroSymbol( Me );
      if ( trav_MacroSymbol ) 
        trav_MacroSymbol( Me.macroSymbol() );
      if ( post_ASP_ParIdOrMacro_macroSymbol ) 
        post_ASP_ParIdOrMacro_macroSymbol( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ASP_ParIdOrMacro: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ASP_ParIdOrMacro ) 
    post_ASP_ParIdOrMacro( Me );
}


void default_trav_ASP_ParIdAndFullId( const ASP_ParIdAndFullId& Me )
{
  if ( pre_ASP_ParIdAndFullId ) 
    pre_ASP_ParIdAndFullId( Me );

  if ( pre_ASP_ParIdAndFullId_asp_ParIdentifier ) 
    pre_ASP_ParIdAndFullId_asp_ParIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.asp_ParIdentifier() );
  if ( post_ASP_ParIdAndFullId_asp_ParIdentifier ) 
    post_ASP_ParIdAndFullId_asp_ParIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_ASP_ParIdAndFullId_fullIdentifier ) 
        pre_ASP_ParIdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_ASP_ParIdAndFullId_fullIdentifier ) 
        post_ASP_ParIdAndFullId_fullIdentifier( Me );
    }

  if ( post_ASP_ParIdAndFullId ) 
    post_ASP_ParIdAndFullId( Me );
}


void default_trav_ASP_ParType( const ASP_ParType& Me )
{
  if ( pre_ASP_ParType ) 
    pre_ASP_ParType( Me );

  if ( pre_ASP_ParType_typeAndAttributes ) 
    pre_ASP_ParType_typeAndAttributes( Me );
  if ( trav_TypeAndAttributes ) 
    trav_TypeAndAttributes( Me.typeAndAttributes() );
  if ( post_ASP_ParType_typeAndAttributes ) 
    post_ASP_ParType_typeAndAttributes( Me );

  if ( post_ASP_ParType ) 
    post_ASP_ParType( Me );
}


void default_trav_ASN1_ASP_TypeDefs( const ASN1_ASP_TypeDefs& Me )
{
  if ( pre_ASN1_ASP_TypeDefs ) 
    pre_ASN1_ASP_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_ASP_TypeDefs_asn1_ASP_TypeDef ) 
        pre_ASN1_ASP_TypeDefs_asn1_ASP_TypeDef( Me, i );
      if ( trav_ASN1_ASP_TypeDef ) 
        trav_ASN1_ASP_TypeDef( Me.asn1_ASP_TypeDef( i ) );
      if ( post_ASN1_ASP_TypeDefs_asn1_ASP_TypeDef ) 
        post_ASN1_ASP_TypeDefs_asn1_ASP_TypeDef( Me, i );
  }

  if ( post_ASN1_ASP_TypeDefs ) 
    post_ASN1_ASP_TypeDefs( Me );
}


void default_trav_ASN1_ASP_TypeDef( const ASN1_ASP_TypeDef& Me )
{
  if ( pre_ASN1_ASP_TypeDef ) 
    pre_ASN1_ASP_TypeDef( Me );

  if ( Me.is_present_asp_Id())
    {
      if ( pre_ASN1_ASP_TypeDef_asp_Id ) 
        pre_ASN1_ASP_TypeDef_asp_Id( Me );
      if ( trav_ASP_Id ) 
        trav_ASP_Id( Me.asp_Id() );
      if ( post_ASN1_ASP_TypeDef_asp_Id ) 
        post_ASN1_ASP_TypeDef_asp_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_ASN1_ASP_TypeDef_pco_Type ) 
        pre_ASN1_ASP_TypeDef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_ASN1_ASP_TypeDef_pco_Type ) 
        post_ASN1_ASP_TypeDef_pco_Type( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_ASP_TypeDef_comment ) 
        pre_ASN1_ASP_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_ASP_TypeDef_comment ) 
        post_ASN1_ASP_TypeDef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_ASP_TypeDef_asn1_TypeDefinition ) 
        pre_ASN1_ASP_TypeDef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_ASP_TypeDef_asn1_TypeDefinition ) 
        post_ASN1_ASP_TypeDef_asn1_TypeDefinition( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_ASP_TypeDef_detailedComment ) 
        pre_ASN1_ASP_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_ASP_TypeDef_detailedComment ) 
        post_ASN1_ASP_TypeDef_detailedComment( Me );
    }

  if ( post_ASN1_ASP_TypeDef ) 
    post_ASN1_ASP_TypeDef( Me );
}


void default_trav_ASN1_ASP_TypeDefsByRef( const ASN1_ASP_TypeDefsByRef& Me )
{
  if ( pre_ASN1_ASP_TypeDefsByRef ) 
    pre_ASN1_ASP_TypeDefsByRef( Me );

  if ( pre_ASN1_ASP_TypeDefsByRef_asn1_ASP_TypeDefByRefList ) 
    pre_ASN1_ASP_TypeDefsByRef_asn1_ASP_TypeDefByRefList( Me );
  if ( trav_ASN1_ASP_TypeDefByRefList ) 
    trav_ASN1_ASP_TypeDefByRefList( Me.asn1_ASP_TypeDefByRefList() );
  if ( post_ASN1_ASP_TypeDefsByRef_asn1_ASP_TypeDefByRefList ) 
    post_ASN1_ASP_TypeDefsByRef_asn1_ASP_TypeDefByRefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_ASP_TypeDefsByRef_detailedComment ) 
        pre_ASN1_ASP_TypeDefsByRef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_ASP_TypeDefsByRef_detailedComment ) 
        post_ASN1_ASP_TypeDefsByRef_detailedComment( Me );
    }

  if ( post_ASN1_ASP_TypeDefsByRef ) 
    post_ASN1_ASP_TypeDefsByRef( Me );
}


void default_trav_ASN1_ASP_TypeDefByRefList( const ASN1_ASP_TypeDefByRefList& Me )
{
  if ( pre_ASN1_ASP_TypeDefByRefList ) 
    pre_ASN1_ASP_TypeDefByRefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_ASP_TypeDefByRefList_asn1_ASP_TypeDefByRef ) 
        pre_ASN1_ASP_TypeDefByRefList_asn1_ASP_TypeDefByRef( Me, i );
      if ( trav_ASN1_ASP_TypeDefByRef ) 
        trav_ASN1_ASP_TypeDefByRef( Me.asn1_ASP_TypeDefByRef( i ) );
      if ( post_ASN1_ASP_TypeDefByRefList_asn1_ASP_TypeDefByRef ) 
        post_ASN1_ASP_TypeDefByRefList_asn1_ASP_TypeDefByRef( Me, i );
  }

  if ( post_ASN1_ASP_TypeDefByRefList ) 
    post_ASN1_ASP_TypeDefByRefList( Me );
}


void default_trav_ASN1_ASP_TypeDefByRef( const ASN1_ASP_TypeDefByRef& Me )
{
  if ( pre_ASN1_ASP_TypeDefByRef ) 
    pre_ASN1_ASP_TypeDefByRef( Me );

  if ( Me.is_present_asp_Id())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_asp_Id ) 
        pre_ASN1_ASP_TypeDefByRef_asp_Id( Me );
      if ( trav_ASP_Id ) 
        trav_ASP_Id( Me.asp_Id() );
      if ( post_ASN1_ASP_TypeDefByRef_asp_Id ) 
        post_ASN1_ASP_TypeDefByRef_asp_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_pco_Type ) 
        pre_ASN1_ASP_TypeDefByRef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_ASN1_ASP_TypeDefByRef_pco_Type ) 
        post_ASN1_ASP_TypeDefByRef_pco_Type( Me );
    }

  if ( Me.is_present_asn1_TypeReference())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_asn1_TypeReference ) 
        pre_ASN1_ASP_TypeDefByRef_asn1_TypeReference( Me );
      if ( trav_ASN1_TypeReference ) 
        trav_ASN1_TypeReference( Me.asn1_TypeReference() );
      if ( post_ASN1_ASP_TypeDefByRef_asn1_TypeReference ) 
        post_ASN1_ASP_TypeDefByRef_asn1_TypeReference( Me );
    }

  if ( Me.is_present_asn1_ModuleId())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_asn1_ModuleId ) 
        pre_ASN1_ASP_TypeDefByRef_asn1_ModuleId( Me );
      if ( trav_ASN1_ModuleId ) 
        trav_ASN1_ModuleId( Me.asn1_ModuleId() );
      if ( post_ASN1_ASP_TypeDefByRef_asn1_ModuleId ) 
        post_ASN1_ASP_TypeDefByRef_asn1_ModuleId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_comment ) 
        pre_ASN1_ASP_TypeDefByRef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_ASP_TypeDefByRef_comment ) 
        post_ASN1_ASP_TypeDefByRef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_ASP_TypeDefByRef_asn1_TypeDefinition ) 
        pre_ASN1_ASP_TypeDefByRef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_ASP_TypeDefByRef_asn1_TypeDefinition ) 
        post_ASN1_ASP_TypeDefByRef_asn1_TypeDefinition( Me );
    }

  if ( post_ASN1_ASP_TypeDefByRef ) 
    post_ASN1_ASP_TypeDefByRef( Me );
}


void default_trav_PDU_TypeDefs( const PDU_TypeDefs& Me )
{
  if ( pre_PDU_TypeDefs ) 
    pre_PDU_TypeDefs( Me );

  if ( pre_PDU_TypeDefs_ttcn_PDU_TypeDefs ) 
    pre_PDU_TypeDefs_ttcn_PDU_TypeDefs( Me );
  if ( trav_TTCN_PDU_TypeDefs ) 
    trav_TTCN_PDU_TypeDefs( Me.ttcn_PDU_TypeDefs() );
  if ( post_PDU_TypeDefs_ttcn_PDU_TypeDefs ) 
    post_PDU_TypeDefs_ttcn_PDU_TypeDefs( Me );

  if ( pre_PDU_TypeDefs_asn1_PDU_TypeDefs ) 
    pre_PDU_TypeDefs_asn1_PDU_TypeDefs( Me );
  if ( trav_ASN1_PDU_TypeDefs ) 
    trav_ASN1_PDU_TypeDefs( Me.asn1_PDU_TypeDefs() );
  if ( post_PDU_TypeDefs_asn1_PDU_TypeDefs ) 
    post_PDU_TypeDefs_asn1_PDU_TypeDefs( Me );

  if ( pre_PDU_TypeDefs_asn1_PDU_TypeDefsByRef ) 
    pre_PDU_TypeDefs_asn1_PDU_TypeDefsByRef( Me );
  if ( trav_ASN1_PDU_TypeDefsByRef ) 
    trav_ASN1_PDU_TypeDefsByRef( Me.asn1_PDU_TypeDefsByRef() );
  if ( post_PDU_TypeDefs_asn1_PDU_TypeDefsByRef ) 
    post_PDU_TypeDefs_asn1_PDU_TypeDefsByRef( Me );

  if ( post_PDU_TypeDefs ) 
    post_PDU_TypeDefs( Me );
}


void default_trav_TTCN_PDU_TypeDefs( const TTCN_PDU_TypeDefs& Me )
{
  if ( pre_TTCN_PDU_TypeDefs ) 
    pre_TTCN_PDU_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_PDU_TypeDefs_ttcn_PDU_TypeDef ) 
        pre_TTCN_PDU_TypeDefs_ttcn_PDU_TypeDef( Me, i );
      if ( trav_TTCN_PDU_TypeDef ) 
        trav_TTCN_PDU_TypeDef( Me.ttcn_PDU_TypeDef( i ) );
      if ( post_TTCN_PDU_TypeDefs_ttcn_PDU_TypeDef ) 
        post_TTCN_PDU_TypeDefs_ttcn_PDU_TypeDef( Me, i );
  }

  if ( post_TTCN_PDU_TypeDefs ) 
    post_TTCN_PDU_TypeDefs( Me );
}


void default_trav_TTCN_PDU_TypeDef( const TTCN_PDU_TypeDef& Me )
{
  if ( pre_TTCN_PDU_TypeDef ) 
    pre_TTCN_PDU_TypeDef( Me );

  if ( Me.is_present_pdu_Id())
    {
      if ( pre_TTCN_PDU_TypeDef_pdu_Id ) 
        pre_TTCN_PDU_TypeDef_pdu_Id( Me );
      if ( trav_PDU_Id ) 
        trav_PDU_Id( Me.pdu_Id() );
      if ( post_TTCN_PDU_TypeDef_pdu_Id ) 
        post_TTCN_PDU_TypeDef_pdu_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_TTCN_PDU_TypeDef_pco_Type ) 
        pre_TTCN_PDU_TypeDef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_TTCN_PDU_TypeDef_pco_Type ) 
        post_TTCN_PDU_TypeDef_pco_Type( Me );
    }

  if ( Me.is_present_pdu_EncodingId())
    {
      if ( pre_TTCN_PDU_TypeDef_pdu_EncodingId ) 
        pre_TTCN_PDU_TypeDef_pdu_EncodingId( Me );
      if ( trav_PDU_EncodingId ) 
        trav_PDU_EncodingId( Me.pdu_EncodingId() );
      if ( post_TTCN_PDU_TypeDef_pdu_EncodingId ) 
        post_TTCN_PDU_TypeDef_pdu_EncodingId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_TTCN_PDU_TypeDef_encVariationId ) 
        pre_TTCN_PDU_TypeDef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_TTCN_PDU_TypeDef_encVariationId ) 
        post_TTCN_PDU_TypeDef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_PDU_TypeDef_comment ) 
        pre_TTCN_PDU_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_PDU_TypeDef_comment ) 
        post_TTCN_PDU_TypeDef_comment( Me );
    }

  if ( pre_TTCN_PDU_TypeDef_pdu_FieldDcls ) 
    pre_TTCN_PDU_TypeDef_pdu_FieldDcls( Me );
  if ( trav_PDU_FieldDcls ) 
    trav_PDU_FieldDcls( Me.pdu_FieldDcls() );
  if ( post_TTCN_PDU_TypeDef_pdu_FieldDcls ) 
    post_TTCN_PDU_TypeDef_pdu_FieldDcls( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_PDU_TypeDef_detailedComment ) 
        pre_TTCN_PDU_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_PDU_TypeDef_detailedComment ) 
        post_TTCN_PDU_TypeDef_detailedComment( Me );
    }

  if ( post_TTCN_PDU_TypeDef ) 
    post_TTCN_PDU_TypeDef( Me );
}


void default_trav_PDU_Id( const PDU_Id& Me )
{
  if ( pre_PDU_Id ) 
    pre_PDU_Id( Me );

  if ( pre_PDU_Id_pdu_IdAndFullId ) 
    pre_PDU_Id_pdu_IdAndFullId( Me );
  if ( trav_PDU_IdAndFullId ) 
    trav_PDU_IdAndFullId( Me.pdu_IdAndFullId() );
  if ( post_PDU_Id_pdu_IdAndFullId ) 
    post_PDU_Id_pdu_IdAndFullId( Me );

  if ( post_PDU_Id ) 
    post_PDU_Id( Me );
}


void default_trav_PDU_IdAndFullId( const PDU_IdAndFullId& Me )
{
  if ( pre_PDU_IdAndFullId ) 
    pre_PDU_IdAndFullId( Me );

  if ( pre_PDU_IdAndFullId_pdu_Identifier ) 
    pre_PDU_IdAndFullId_pdu_Identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.pdu_Identifier() );
  if ( post_PDU_IdAndFullId_pdu_Identifier ) 
    post_PDU_IdAndFullId_pdu_Identifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_PDU_IdAndFullId_fullIdentifier ) 
        pre_PDU_IdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_PDU_IdAndFullId_fullIdentifier ) 
        post_PDU_IdAndFullId_fullIdentifier( Me );
    }

  if ( post_PDU_IdAndFullId ) 
    post_PDU_IdAndFullId( Me );
}


void default_trav_PDU_FieldDcls( const PDU_FieldDcls& Me )
{
  if ( pre_PDU_FieldDcls ) 
    pre_PDU_FieldDcls( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_PDU_FieldDcls_pdu_FieldDcl ) 
        pre_PDU_FieldDcls_pdu_FieldDcl( Me, i );
      if ( trav_PDU_FieldDcl ) 
        trav_PDU_FieldDcl( Me.pdu_FieldDcl( i ) );
      if ( post_PDU_FieldDcls_pdu_FieldDcl ) 
        post_PDU_FieldDcls_pdu_FieldDcl( Me, i );
  }

  if ( post_PDU_FieldDcls ) 
    post_PDU_FieldDcls( Me );
}


void default_trav_PDU_FieldDcl( const PDU_FieldDcl& Me )
{
  if ( pre_PDU_FieldDcl ) 
    pre_PDU_FieldDcl( Me );

  if ( Me.is_present_pdu_FieldId())
    {
      if ( pre_PDU_FieldDcl_pdu_FieldId ) 
        pre_PDU_FieldDcl_pdu_FieldId( Me );
      if ( trav_PDU_FieldId ) 
        trav_PDU_FieldId( Me.pdu_FieldId() );
      if ( post_PDU_FieldDcl_pdu_FieldId ) 
        post_PDU_FieldDcl_pdu_FieldId( Me );
    }

  if ( Me.is_present_pdu_FieldType())
    {
      if ( pre_PDU_FieldDcl_pdu_FieldType ) 
        pre_PDU_FieldDcl_pdu_FieldType( Me );
      if ( trav_PDU_FieldType ) 
        trav_PDU_FieldType( Me.pdu_FieldType() );
      if ( post_PDU_FieldDcl_pdu_FieldType ) 
        post_PDU_FieldDcl_pdu_FieldType( Me );
    }

  if ( Me.is_present_pdu_FieldEncoding())
    {
      if ( pre_PDU_FieldDcl_pdu_FieldEncoding ) 
        pre_PDU_FieldDcl_pdu_FieldEncoding( Me );
      if ( trav_PDU_FieldEncoding ) 
        trav_PDU_FieldEncoding( Me.pdu_FieldEncoding() );
      if ( post_PDU_FieldDcl_pdu_FieldEncoding ) 
        post_PDU_FieldDcl_pdu_FieldEncoding( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_PDU_FieldDcl_comment ) 
        pre_PDU_FieldDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_PDU_FieldDcl_comment ) 
        post_PDU_FieldDcl_comment( Me );
    }

  if ( post_PDU_FieldDcl ) 
    post_PDU_FieldDcl( Me );
}


void default_trav_PDU_FieldId( const PDU_FieldId& Me )
{
  if ( pre_PDU_FieldId ) 
    pre_PDU_FieldId( Me );

  if ( pre_PDU_FieldId_pdu_FieldIdOrMacro ) 
    pre_PDU_FieldId_pdu_FieldIdOrMacro( Me );
  if ( trav_PDU_FieldIdOrMacro ) 
    trav_PDU_FieldIdOrMacro( Me.pdu_FieldIdOrMacro() );
  if ( post_PDU_FieldId_pdu_FieldIdOrMacro ) 
    post_PDU_FieldId_pdu_FieldIdOrMacro( Me );

  if ( post_PDU_FieldId ) 
    post_PDU_FieldId( Me );
}


void default_trav_PDU_FieldIdOrMacro( const PDU_FieldIdOrMacro& Me )
{
  if ( pre_PDU_FieldIdOrMacro ) 
    pre_PDU_FieldIdOrMacro( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PDU_FieldIdAndFullId:
      if ( pre_PDU_FieldIdOrMacro_pdu_FieldIdAndFullId ) 
        pre_PDU_FieldIdOrMacro_pdu_FieldIdAndFullId( Me );
      if ( trav_PDU_FieldIdAndFullId ) 
        trav_PDU_FieldIdAndFullId( Me.pdu_FieldIdAndFullId() );
      if ( post_PDU_FieldIdOrMacro_pdu_FieldIdAndFullId ) 
        post_PDU_FieldIdOrMacro_pdu_FieldIdAndFullId( Me );
      break;

    case Choices::c_MacroSymbol:
      if ( pre_PDU_FieldIdOrMacro_macroSymbol ) 
        pre_PDU_FieldIdOrMacro_macroSymbol( Me );
      if ( trav_MacroSymbol ) 
        trav_MacroSymbol( Me.macroSymbol() );
      if ( post_PDU_FieldIdOrMacro_macroSymbol ) 
        post_PDU_FieldIdOrMacro_macroSymbol( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node PDU_FieldIdOrMacro: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_PDU_FieldIdOrMacro ) 
    post_PDU_FieldIdOrMacro( Me );
}


void default_trav_PDU_FieldIdAndFullId( const PDU_FieldIdAndFullId& Me )
{
  if ( pre_PDU_FieldIdAndFullId ) 
    pre_PDU_FieldIdAndFullId( Me );

  if ( pre_PDU_FieldIdAndFullId_pdu_FieldIdentifier ) 
    pre_PDU_FieldIdAndFullId_pdu_FieldIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.pdu_FieldIdentifier() );
  if ( post_PDU_FieldIdAndFullId_pdu_FieldIdentifier ) 
    post_PDU_FieldIdAndFullId_pdu_FieldIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_PDU_FieldIdAndFullId_fullIdentifier ) 
        pre_PDU_FieldIdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_PDU_FieldIdAndFullId_fullIdentifier ) 
        post_PDU_FieldIdAndFullId_fullIdentifier( Me );
    }

  if ( post_PDU_FieldIdAndFullId ) 
    post_PDU_FieldIdAndFullId( Me );
}


void default_trav_PDU_FieldType( const PDU_FieldType& Me )
{
  if ( pre_PDU_FieldType ) 
    pre_PDU_FieldType( Me );

  if ( pre_PDU_FieldType_typeAndAttributes ) 
    pre_PDU_FieldType_typeAndAttributes( Me );
  if ( trav_TypeAndAttributes ) 
    trav_TypeAndAttributes( Me.typeAndAttributes() );
  if ( post_PDU_FieldType_typeAndAttributes ) 
    post_PDU_FieldType_typeAndAttributes( Me );

  if ( post_PDU_FieldType ) 
    post_PDU_FieldType( Me );
}


void default_trav_ASN1_PDU_TypeDefs( const ASN1_PDU_TypeDefs& Me )
{
  if ( pre_ASN1_PDU_TypeDefs ) 
    pre_ASN1_PDU_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_PDU_TypeDefs_asn1_PDU_TypeDef ) 
        pre_ASN1_PDU_TypeDefs_asn1_PDU_TypeDef( Me, i );
      if ( trav_ASN1_PDU_TypeDef ) 
        trav_ASN1_PDU_TypeDef( Me.asn1_PDU_TypeDef( i ) );
      if ( post_ASN1_PDU_TypeDefs_asn1_PDU_TypeDef ) 
        post_ASN1_PDU_TypeDefs_asn1_PDU_TypeDef( Me, i );
  }

  if ( post_ASN1_PDU_TypeDefs ) 
    post_ASN1_PDU_TypeDefs( Me );
}


void default_trav_ASN1_PDU_TypeDef( const ASN1_PDU_TypeDef& Me )
{
  if ( pre_ASN1_PDU_TypeDef ) 
    pre_ASN1_PDU_TypeDef( Me );

  if ( Me.is_present_pdu_Id())
    {
      if ( pre_ASN1_PDU_TypeDef_pdu_Id ) 
        pre_ASN1_PDU_TypeDef_pdu_Id( Me );
      if ( trav_PDU_Id ) 
        trav_PDU_Id( Me.pdu_Id() );
      if ( post_ASN1_PDU_TypeDef_pdu_Id ) 
        post_ASN1_PDU_TypeDef_pdu_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_ASN1_PDU_TypeDef_pco_Type ) 
        pre_ASN1_PDU_TypeDef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_ASN1_PDU_TypeDef_pco_Type ) 
        post_ASN1_PDU_TypeDef_pco_Type( Me );
    }

  if ( Me.is_present_pdu_EncodingId())
    {
      if ( pre_ASN1_PDU_TypeDef_pdu_EncodingId ) 
        pre_ASN1_PDU_TypeDef_pdu_EncodingId( Me );
      if ( trav_PDU_EncodingId ) 
        trav_PDU_EncodingId( Me.pdu_EncodingId() );
      if ( post_ASN1_PDU_TypeDef_pdu_EncodingId ) 
        post_ASN1_PDU_TypeDef_pdu_EncodingId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_PDU_TypeDef_encVariationId ) 
        pre_ASN1_PDU_TypeDef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_PDU_TypeDef_encVariationId ) 
        post_ASN1_PDU_TypeDef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_PDU_TypeDef_comment ) 
        pre_ASN1_PDU_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_PDU_TypeDef_comment ) 
        post_ASN1_PDU_TypeDef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_PDU_TypeDef_asn1_TypeDefinition ) 
        pre_ASN1_PDU_TypeDef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_PDU_TypeDef_asn1_TypeDefinition ) 
        post_ASN1_PDU_TypeDef_asn1_TypeDefinition( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_PDU_TypeDef_detailedComment ) 
        pre_ASN1_PDU_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_PDU_TypeDef_detailedComment ) 
        post_ASN1_PDU_TypeDef_detailedComment( Me );
    }

  if ( post_ASN1_PDU_TypeDef ) 
    post_ASN1_PDU_TypeDef( Me );
}


void default_trav_ASN1_PDU_TypeDefsByRef( const ASN1_PDU_TypeDefsByRef& Me )
{
  if ( pre_ASN1_PDU_TypeDefsByRef ) 
    pre_ASN1_PDU_TypeDefsByRef( Me );

  if ( pre_ASN1_PDU_TypeDefsByRef_asn1_PDU_TypeDefByRefList ) 
    pre_ASN1_PDU_TypeDefsByRef_asn1_PDU_TypeDefByRefList( Me );
  if ( trav_ASN1_PDU_TypeDefByRefList ) 
    trav_ASN1_PDU_TypeDefByRefList( Me.asn1_PDU_TypeDefByRefList() );
  if ( post_ASN1_PDU_TypeDefsByRef_asn1_PDU_TypeDefByRefList ) 
    post_ASN1_PDU_TypeDefsByRef_asn1_PDU_TypeDefByRefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_PDU_TypeDefsByRef_detailedComment ) 
        pre_ASN1_PDU_TypeDefsByRef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_PDU_TypeDefsByRef_detailedComment ) 
        post_ASN1_PDU_TypeDefsByRef_detailedComment( Me );
    }

  if ( post_ASN1_PDU_TypeDefsByRef ) 
    post_ASN1_PDU_TypeDefsByRef( Me );
}


void default_trav_ASN1_PDU_TypeDefByRefList( const ASN1_PDU_TypeDefByRefList& Me )
{
  if ( pre_ASN1_PDU_TypeDefByRefList ) 
    pre_ASN1_PDU_TypeDefByRefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_PDU_TypeDefByRefList_asn1_PDU_TypeDefByRef ) 
        pre_ASN1_PDU_TypeDefByRefList_asn1_PDU_TypeDefByRef( Me, i );
      if ( trav_ASN1_PDU_TypeDefByRef ) 
        trav_ASN1_PDU_TypeDefByRef( Me.asn1_PDU_TypeDefByRef( i ) );
      if ( post_ASN1_PDU_TypeDefByRefList_asn1_PDU_TypeDefByRef ) 
        post_ASN1_PDU_TypeDefByRefList_asn1_PDU_TypeDefByRef( Me, i );
  }

  if ( post_ASN1_PDU_TypeDefByRefList ) 
    post_ASN1_PDU_TypeDefByRefList( Me );
}


void default_trav_ASN1_PDU_TypeDefByRef( const ASN1_PDU_TypeDefByRef& Me )
{
  if ( pre_ASN1_PDU_TypeDefByRef ) 
    pre_ASN1_PDU_TypeDefByRef( Me );

  if ( Me.is_present_pdu_Id())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_pdu_Id ) 
        pre_ASN1_PDU_TypeDefByRef_pdu_Id( Me );
      if ( trav_PDU_Id ) 
        trav_PDU_Id( Me.pdu_Id() );
      if ( post_ASN1_PDU_TypeDefByRef_pdu_Id ) 
        post_ASN1_PDU_TypeDefByRef_pdu_Id( Me );
    }

  if ( Me.is_present_pco_Type())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_pco_Type ) 
        pre_ASN1_PDU_TypeDefByRef_pco_Type( Me );
      if ( trav_PCO_Type ) 
        trav_PCO_Type( Me.pco_Type() );
      if ( post_ASN1_PDU_TypeDefByRef_pco_Type ) 
        post_ASN1_PDU_TypeDefByRef_pco_Type( Me );
    }

  if ( Me.is_present_asn1_TypeReference())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_asn1_TypeReference ) 
        pre_ASN1_PDU_TypeDefByRef_asn1_TypeReference( Me );
      if ( trav_ASN1_TypeReference ) 
        trav_ASN1_TypeReference( Me.asn1_TypeReference() );
      if ( post_ASN1_PDU_TypeDefByRef_asn1_TypeReference ) 
        post_ASN1_PDU_TypeDefByRef_asn1_TypeReference( Me );
    }

  if ( Me.is_present_asn1_ModuleId())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_asn1_ModuleId ) 
        pre_ASN1_PDU_TypeDefByRef_asn1_ModuleId( Me );
      if ( trav_ASN1_ModuleId ) 
        trav_ASN1_ModuleId( Me.asn1_ModuleId() );
      if ( post_ASN1_PDU_TypeDefByRef_asn1_ModuleId ) 
        post_ASN1_PDU_TypeDefByRef_asn1_ModuleId( Me );
    }

  if ( Me.is_present_pdu_EncodingId())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_pdu_EncodingId ) 
        pre_ASN1_PDU_TypeDefByRef_pdu_EncodingId( Me );
      if ( trav_PDU_EncodingId ) 
        trav_PDU_EncodingId( Me.pdu_EncodingId() );
      if ( post_ASN1_PDU_TypeDefByRef_pdu_EncodingId ) 
        post_ASN1_PDU_TypeDefByRef_pdu_EncodingId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_encVariationId ) 
        pre_ASN1_PDU_TypeDefByRef_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_PDU_TypeDefByRef_encVariationId ) 
        post_ASN1_PDU_TypeDefByRef_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_comment ) 
        pre_ASN1_PDU_TypeDefByRef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_PDU_TypeDefByRef_comment ) 
        post_ASN1_PDU_TypeDefByRef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_PDU_TypeDefByRef_asn1_TypeDefinition ) 
        pre_ASN1_PDU_TypeDefByRef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_PDU_TypeDefByRef_asn1_TypeDefinition ) 
        post_ASN1_PDU_TypeDefByRef_asn1_TypeDefinition( Me );
    }

  if ( post_ASN1_PDU_TypeDefByRef ) 
    post_ASN1_PDU_TypeDefByRef( Me );
}


void default_trav_CM_TypeDefs( const CM_TypeDefs& Me )
{
  if ( pre_CM_TypeDefs ) 
    pre_CM_TypeDefs( Me );

  if ( pre_CM_TypeDefs_ttcn_CM_TypeDefs ) 
    pre_CM_TypeDefs_ttcn_CM_TypeDefs( Me );
  if ( trav_TTCN_CM_TypeDefs ) 
    trav_TTCN_CM_TypeDefs( Me.ttcn_CM_TypeDefs() );
  if ( post_CM_TypeDefs_ttcn_CM_TypeDefs ) 
    post_CM_TypeDefs_ttcn_CM_TypeDefs( Me );

  if ( pre_CM_TypeDefs_asn1_CM_TypeDefs ) 
    pre_CM_TypeDefs_asn1_CM_TypeDefs( Me );
  if ( trav_ASN1_CM_TypeDefs ) 
    trav_ASN1_CM_TypeDefs( Me.asn1_CM_TypeDefs() );
  if ( post_CM_TypeDefs_asn1_CM_TypeDefs ) 
    post_CM_TypeDefs_asn1_CM_TypeDefs( Me );

  if ( post_CM_TypeDefs ) 
    post_CM_TypeDefs( Me );
}


void default_trav_TTCN_CM_TypeDefs( const TTCN_CM_TypeDefs& Me )
{
  if ( pre_TTCN_CM_TypeDefs ) 
    pre_TTCN_CM_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_CM_TypeDefs_ttcn_CM_TypeDef ) 
        pre_TTCN_CM_TypeDefs_ttcn_CM_TypeDef( Me, i );
      if ( trav_TTCN_CM_TypeDef ) 
        trav_TTCN_CM_TypeDef( Me.ttcn_CM_TypeDef( i ) );
      if ( post_TTCN_CM_TypeDefs_ttcn_CM_TypeDef ) 
        post_TTCN_CM_TypeDefs_ttcn_CM_TypeDef( Me, i );
  }

  if ( post_TTCN_CM_TypeDefs ) 
    post_TTCN_CM_TypeDefs( Me );
}


void default_trav_TTCN_CM_TypeDef( const TTCN_CM_TypeDef& Me )
{
  if ( pre_TTCN_CM_TypeDef ) 
    pre_TTCN_CM_TypeDef( Me );

  if ( Me.is_present_cm_Id())
    {
      if ( pre_TTCN_CM_TypeDef_cm_Id ) 
        pre_TTCN_CM_TypeDef_cm_Id( Me );
      if ( trav_CM_Id ) 
        trav_CM_Id( Me.cm_Id() );
      if ( post_TTCN_CM_TypeDef_cm_Id ) 
        post_TTCN_CM_TypeDef_cm_Id( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_CM_TypeDef_comment ) 
        pre_TTCN_CM_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_CM_TypeDef_comment ) 
        post_TTCN_CM_TypeDef_comment( Me );
    }

  if ( pre_TTCN_CM_TypeDef_cm_ParDcls ) 
    pre_TTCN_CM_TypeDef_cm_ParDcls( Me );
  if ( trav_CM_ParDcls ) 
    trav_CM_ParDcls( Me.cm_ParDcls() );
  if ( post_TTCN_CM_TypeDef_cm_ParDcls ) 
    post_TTCN_CM_TypeDef_cm_ParDcls( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_CM_TypeDef_detailedComment ) 
        pre_TTCN_CM_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_CM_TypeDef_detailedComment ) 
        post_TTCN_CM_TypeDef_detailedComment( Me );
    }

  if ( post_TTCN_CM_TypeDef ) 
    post_TTCN_CM_TypeDef( Me );
}


void default_trav_CM_Id( const CM_Id& Me )
{
  if ( pre_CM_Id ) 
    pre_CM_Id( Me );

  if ( pre_CM_Id_cm_Identifier ) 
    pre_CM_Id_cm_Identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.cm_Identifier() );
  if ( post_CM_Id_cm_Identifier ) 
    post_CM_Id_cm_Identifier( Me );

  if ( post_CM_Id ) 
    post_CM_Id( Me );
}


void default_trav_CM_ParDcls( const CM_ParDcls& Me )
{
  if ( pre_CM_ParDcls ) 
    pre_CM_ParDcls( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CM_ParDcls_cm_ParDcl ) 
        pre_CM_ParDcls_cm_ParDcl( Me, i );
      if ( trav_CM_ParDcl ) 
        trav_CM_ParDcl( Me.cm_ParDcl( i ) );
      if ( post_CM_ParDcls_cm_ParDcl ) 
        post_CM_ParDcls_cm_ParDcl( Me, i );
  }

  if ( post_CM_ParDcls ) 
    post_CM_ParDcls( Me );
}


void default_trav_CM_ParDcl( const CM_ParDcl& Me )
{
  if ( pre_CM_ParDcl ) 
    pre_CM_ParDcl( Me );

  if ( Me.is_present_cm_ParId())
    {
      if ( pre_CM_ParDcl_cm_ParId ) 
        pre_CM_ParDcl_cm_ParId( Me );
      if ( trav_CM_ParId ) 
        trav_CM_ParId( Me.cm_ParId() );
      if ( post_CM_ParDcl_cm_ParId ) 
        post_CM_ParDcl_cm_ParId( Me );
    }

  if ( Me.is_present_cm_ParType())
    {
      if ( pre_CM_ParDcl_cm_ParType ) 
        pre_CM_ParDcl_cm_ParType( Me );
      if ( trav_CM_ParType ) 
        trav_CM_ParType( Me.cm_ParType() );
      if ( post_CM_ParDcl_cm_ParType ) 
        post_CM_ParDcl_cm_ParType( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_CM_ParDcl_comment ) 
        pre_CM_ParDcl_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_CM_ParDcl_comment ) 
        post_CM_ParDcl_comment( Me );
    }

  if ( post_CM_ParDcl ) 
    post_CM_ParDcl( Me );
}


void default_trav_CM_ParId( const CM_ParId& Me )
{
  if ( pre_CM_ParId ) 
    pre_CM_ParId( Me );

  if ( pre_CM_ParId_cm_ParIdOrMacro ) 
    pre_CM_ParId_cm_ParIdOrMacro( Me );
  if ( trav_CM_ParIdOrMacro ) 
    trav_CM_ParIdOrMacro( Me.cm_ParIdOrMacro() );
  if ( post_CM_ParId_cm_ParIdOrMacro ) 
    post_CM_ParId_cm_ParIdOrMacro( Me );

  if ( post_CM_ParId ) 
    post_CM_ParId( Me );
}


void default_trav_CM_ParIdOrMacro( const CM_ParIdOrMacro& Me )
{
  if ( pre_CM_ParIdOrMacro ) 
    pre_CM_ParIdOrMacro( Me );

  switch ( Me.choice() )
    {
    case Choices::c_CM_ParIdAndFullId:
      if ( pre_CM_ParIdOrMacro_cm_ParIdAndFullId ) 
        pre_CM_ParIdOrMacro_cm_ParIdAndFullId( Me );
      if ( trav_CM_ParIdAndFullId ) 
        trav_CM_ParIdAndFullId( Me.cm_ParIdAndFullId() );
      if ( post_CM_ParIdOrMacro_cm_ParIdAndFullId ) 
        post_CM_ParIdOrMacro_cm_ParIdAndFullId( Me );
      break;

    case Choices::c_MacroSymbol:
      if ( pre_CM_ParIdOrMacro_macroSymbol ) 
        pre_CM_ParIdOrMacro_macroSymbol( Me );
      if ( trav_MacroSymbol ) 
        trav_MacroSymbol( Me.macroSymbol() );
      if ( post_CM_ParIdOrMacro_macroSymbol ) 
        post_CM_ParIdOrMacro_macroSymbol( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node CM_ParIdOrMacro: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_CM_ParIdOrMacro ) 
    post_CM_ParIdOrMacro( Me );
}


void default_trav_CM_ParIdAndFullId( const CM_ParIdAndFullId& Me )
{
  if ( pre_CM_ParIdAndFullId ) 
    pre_CM_ParIdAndFullId( Me );

  if ( pre_CM_ParIdAndFullId_cm_ParIdentifier ) 
    pre_CM_ParIdAndFullId_cm_ParIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.cm_ParIdentifier() );
  if ( post_CM_ParIdAndFullId_cm_ParIdentifier ) 
    post_CM_ParIdAndFullId_cm_ParIdentifier( Me );

  if ( Me.is_present_fullIdentifier())
    {
      if ( pre_CM_ParIdAndFullId_fullIdentifier ) 
        pre_CM_ParIdAndFullId_fullIdentifier( Me );
      if ( trav_FullIdentifier ) 
        trav_FullIdentifier( Me.fullIdentifier() );
      if ( post_CM_ParIdAndFullId_fullIdentifier ) 
        post_CM_ParIdAndFullId_fullIdentifier( Me );
    }

  if ( post_CM_ParIdAndFullId ) 
    post_CM_ParIdAndFullId( Me );
}


void default_trav_CM_ParType( const CM_ParType& Me )
{
  if ( pre_CM_ParType ) 
    pre_CM_ParType( Me );

  if ( pre_CM_ParType_typeAndAttributes ) 
    pre_CM_ParType_typeAndAttributes( Me );
  if ( trav_TypeAndAttributes ) 
    trav_TypeAndAttributes( Me.typeAndAttributes() );
  if ( post_CM_ParType_typeAndAttributes ) 
    post_CM_ParType_typeAndAttributes( Me );

  if ( post_CM_ParType ) 
    post_CM_ParType( Me );
}


void default_trav_ASN1_CM_TypeDefs( const ASN1_CM_TypeDefs& Me )
{
  if ( pre_ASN1_CM_TypeDefs ) 
    pre_ASN1_CM_TypeDefs( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_CM_TypeDefs_asn1_CM_TypeDef ) 
        pre_ASN1_CM_TypeDefs_asn1_CM_TypeDef( Me, i );
      if ( trav_ASN1_CM_TypeDef ) 
        trav_ASN1_CM_TypeDef( Me.asn1_CM_TypeDef( i ) );
      if ( post_ASN1_CM_TypeDefs_asn1_CM_TypeDef ) 
        post_ASN1_CM_TypeDefs_asn1_CM_TypeDef( Me, i );
  }

  if ( post_ASN1_CM_TypeDefs ) 
    post_ASN1_CM_TypeDefs( Me );
}


void default_trav_ASN1_CM_TypeDef( const ASN1_CM_TypeDef& Me )
{
  if ( pre_ASN1_CM_TypeDef ) 
    pre_ASN1_CM_TypeDef( Me );

  if ( Me.is_present_cm_Id())
    {
      if ( pre_ASN1_CM_TypeDef_cm_Id ) 
        pre_ASN1_CM_TypeDef_cm_Id( Me );
      if ( trav_CM_Id ) 
        trav_CM_Id( Me.cm_Id() );
      if ( post_ASN1_CM_TypeDef_cm_Id ) 
        post_ASN1_CM_TypeDef_cm_Id( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_CM_TypeDef_comment ) 
        pre_ASN1_CM_TypeDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_CM_TypeDef_comment ) 
        post_ASN1_CM_TypeDef_comment( Me );
    }

  if ( Me.is_present_asn1_TypeDefinition())
    {
      if ( pre_ASN1_CM_TypeDef_asn1_TypeDefinition ) 
        pre_ASN1_CM_TypeDef_asn1_TypeDefinition( Me );
      if ( trav_ASN1_TypeDefinition ) 
        trav_ASN1_TypeDefinition( Me.asn1_TypeDefinition() );
      if ( post_ASN1_CM_TypeDef_asn1_TypeDefinition ) 
        post_ASN1_CM_TypeDef_asn1_TypeDefinition( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_CM_TypeDef_detailedComment ) 
        pre_ASN1_CM_TypeDef_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_CM_TypeDef_detailedComment ) 
        post_ASN1_CM_TypeDef_detailedComment( Me );
    }

  if ( post_ASN1_CM_TypeDef ) 
    post_ASN1_CM_TypeDef( Me );
}


void default_trav_AliasDefs( const AliasDefs& Me )
{
  if ( pre_AliasDefs ) 
    pre_AliasDefs( Me );

  if ( pre_AliasDefs_aliasDefList ) 
    pre_AliasDefs_aliasDefList( Me );
  if ( trav_AliasDefList ) 
    trav_AliasDefList( Me.aliasDefList() );
  if ( post_AliasDefs_aliasDefList ) 
    post_AliasDefs_aliasDefList( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_AliasDefs_detailedComment ) 
        pre_AliasDefs_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_AliasDefs_detailedComment ) 
        post_AliasDefs_detailedComment( Me );
    }

  if ( post_AliasDefs ) 
    post_AliasDefs( Me );
}


void default_trav_AliasDefList( const AliasDefList& Me )
{
  if ( pre_AliasDefList ) 
    pre_AliasDefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_AliasDefList_aliasDef ) 
        pre_AliasDefList_aliasDef( Me, i );
      if ( trav_AliasDef ) 
        trav_AliasDef( Me.aliasDef( i ) );
      if ( post_AliasDefList_aliasDef ) 
        post_AliasDefList_aliasDef( Me, i );
  }

  if ( post_AliasDefList ) 
    post_AliasDefList( Me );
}


void default_trav_AliasDef( const AliasDef& Me )
{
  if ( pre_AliasDef ) 
    pre_AliasDef( Me );

  if ( Me.is_present_aliasId())
    {
      if ( pre_AliasDef_aliasId ) 
        pre_AliasDef_aliasId( Me );
      if ( trav_AliasId ) 
        trav_AliasId( Me.aliasId() );
      if ( post_AliasDef_aliasId ) 
        post_AliasDef_aliasId( Me );
    }

  if ( Me.is_present_expandedId())
    {
      if ( pre_AliasDef_expandedId ) 
        pre_AliasDef_expandedId( Me );
      if ( trav_ExpandedId ) 
        trav_ExpandedId( Me.expandedId() );
      if ( post_AliasDef_expandedId ) 
        post_AliasDef_expandedId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_AliasDef_comment ) 
        pre_AliasDef_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_AliasDef_comment ) 
        post_AliasDef_comment( Me );
    }

  if ( post_AliasDef ) 
    post_AliasDef( Me );
}


void default_trav_AliasId( const AliasId& Me )
{
  if ( pre_AliasId ) 
    pre_AliasId( Me );

  if ( pre_AliasId_aliasIdentifier ) 
    pre_AliasId_aliasIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.aliasIdentifier() );
  if ( post_AliasId_aliasIdentifier ) 
    post_AliasId_aliasIdentifier( Me );

  if ( post_AliasId ) 
    post_AliasId( Me );
}


void default_trav_ExpandedId( const ExpandedId& Me )
{
  if ( pre_ExpandedId ) 
    pre_ExpandedId( Me );

  if ( pre_ExpandedId_expansion ) 
    pre_ExpandedId_expansion( Me );
  if ( trav_Expansion ) 
    trav_Expansion( Me.expansion() );
  if ( post_ExpandedId_expansion ) 
    post_ExpandedId_expansion( Me );

  if ( post_ExpandedId ) 
    post_ExpandedId( Me );
}


void default_trav_Expansion( const Expansion& Me )
{
  if ( pre_Expansion ) 
    pre_Expansion( Me );

  if ( pre_Expansion_identifier ) 
    pre_Expansion_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_Expansion_identifier ) 
    post_Expansion_identifier( Me );

  if ( post_Expansion ) 
    post_Expansion( Me );
}


void default_trav_ConstraintsPart( const ConstraintsPart& Me )
{
  if ( pre_ConstraintsPart ) 
    pre_ConstraintsPart( Me );

  if ( pre_ConstraintsPart_ts_TypeConstraints ) 
    pre_ConstraintsPart_ts_TypeConstraints( Me );
  if ( trav_TS_TypeConstraints ) 
    trav_TS_TypeConstraints( Me.ts_TypeConstraints() );
  if ( post_ConstraintsPart_ts_TypeConstraints ) 
    post_ConstraintsPart_ts_TypeConstraints( Me );

  if ( pre_ConstraintsPart_asp_Constraints ) 
    pre_ConstraintsPart_asp_Constraints( Me );
  if ( trav_ASP_Constraints ) 
    trav_ASP_Constraints( Me.asp_Constraints() );
  if ( post_ConstraintsPart_asp_Constraints ) 
    post_ConstraintsPart_asp_Constraints( Me );

  if ( pre_ConstraintsPart_pdu_Constraints ) 
    pre_ConstraintsPart_pdu_Constraints( Me );
  if ( trav_PDU_Constraints ) 
    trav_PDU_Constraints( Me.pdu_Constraints() );
  if ( post_ConstraintsPart_pdu_Constraints ) 
    post_ConstraintsPart_pdu_Constraints( Me );

  if ( pre_ConstraintsPart_cm_Constraints ) 
    pre_ConstraintsPart_cm_Constraints( Me );
  if ( trav_CM_Constraints ) 
    trav_CM_Constraints( Me.cm_Constraints() );
  if ( post_ConstraintsPart_cm_Constraints ) 
    post_ConstraintsPart_cm_Constraints( Me );

  if ( post_ConstraintsPart ) 
    post_ConstraintsPart( Me );
}


void default_trav_TS_TypeConstraints( const TS_TypeConstraints& Me )
{
  if ( pre_TS_TypeConstraints ) 
    pre_TS_TypeConstraints( Me );

  if ( pre_TS_TypeConstraints_structTypeConstraints ) 
    pre_TS_TypeConstraints_structTypeConstraints( Me );
  if ( trav_StructTypeConstraints ) 
    trav_StructTypeConstraints( Me.structTypeConstraints() );
  if ( post_TS_TypeConstraints_structTypeConstraints ) 
    post_TS_TypeConstraints_structTypeConstraints( Me );

  if ( pre_TS_TypeConstraints_asn1_TypeConstraints ) 
    pre_TS_TypeConstraints_asn1_TypeConstraints( Me );
  if ( trav_ASN1_TypeConstraints ) 
    trav_ASN1_TypeConstraints( Me.asn1_TypeConstraints() );
  if ( post_TS_TypeConstraints_asn1_TypeConstraints ) 
    post_TS_TypeConstraints_asn1_TypeConstraints( Me );

  if ( post_TS_TypeConstraints ) 
    post_TS_TypeConstraints( Me );
}


void default_trav_ASP_Constraints( const ASP_Constraints& Me )
{
  if ( pre_ASP_Constraints ) 
    pre_ASP_Constraints( Me );

  if ( pre_ASP_Constraints_ttcn_ASP_Constraints ) 
    pre_ASP_Constraints_ttcn_ASP_Constraints( Me );
  if ( trav_TTCN_ASP_Constraints ) 
    trav_TTCN_ASP_Constraints( Me.ttcn_ASP_Constraints() );
  if ( post_ASP_Constraints_ttcn_ASP_Constraints ) 
    post_ASP_Constraints_ttcn_ASP_Constraints( Me );

  if ( pre_ASP_Constraints_asn1_ASP_Constraints ) 
    pre_ASP_Constraints_asn1_ASP_Constraints( Me );
  if ( trav_ASN1_ASP_Constraints ) 
    trav_ASN1_ASP_Constraints( Me.asn1_ASP_Constraints() );
  if ( post_ASP_Constraints_asn1_ASP_Constraints ) 
    post_ASP_Constraints_asn1_ASP_Constraints( Me );

  if ( post_ASP_Constraints ) 
    post_ASP_Constraints( Me );
}


void default_trav_PDU_Constraints( const PDU_Constraints& Me )
{
  if ( pre_PDU_Constraints ) 
    pre_PDU_Constraints( Me );

  if ( pre_PDU_Constraints_ttcn_PDU_Constraints ) 
    pre_PDU_Constraints_ttcn_PDU_Constraints( Me );
  if ( trav_TTCN_PDU_Constraints ) 
    trav_TTCN_PDU_Constraints( Me.ttcn_PDU_Constraints() );
  if ( post_PDU_Constraints_ttcn_PDU_Constraints ) 
    post_PDU_Constraints_ttcn_PDU_Constraints( Me );

  if ( pre_PDU_Constraints_asn1_PDU_Constraints ) 
    pre_PDU_Constraints_asn1_PDU_Constraints( Me );
  if ( trav_ASN1_PDU_Constraints ) 
    trav_ASN1_PDU_Constraints( Me.asn1_PDU_Constraints() );
  if ( post_PDU_Constraints_asn1_PDU_Constraints ) 
    post_PDU_Constraints_asn1_PDU_Constraints( Me );

  if ( post_PDU_Constraints ) 
    post_PDU_Constraints( Me );
}


void default_trav_CM_Constraints( const CM_Constraints& Me )
{
  if ( pre_CM_Constraints ) 
    pre_CM_Constraints( Me );

  if ( pre_CM_Constraints_ttcn_CM_Constraints ) 
    pre_CM_Constraints_ttcn_CM_Constraints( Me );
  if ( trav_TTCN_CM_Constraints ) 
    trav_TTCN_CM_Constraints( Me.ttcn_CM_Constraints() );
  if ( post_CM_Constraints_ttcn_CM_Constraints ) 
    post_CM_Constraints_ttcn_CM_Constraints( Me );

  if ( pre_CM_Constraints_asn1_CM_Constraints ) 
    pre_CM_Constraints_asn1_CM_Constraints( Me );
  if ( trav_ASN1_CM_Constraints ) 
    trav_ASN1_CM_Constraints( Me.asn1_CM_Constraints() );
  if ( post_CM_Constraints_asn1_CM_Constraints ) 
    post_CM_Constraints_asn1_CM_Constraints( Me );

  if ( post_CM_Constraints ) 
    post_CM_Constraints( Me );
}


void default_trav_StructTypeConstraints( const StructTypeConstraints& Me )
{
  if ( pre_StructTypeConstraints ) 
    pre_StructTypeConstraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_StructTypeConstraints_structTypeConstraint ) 
        pre_StructTypeConstraints_structTypeConstraint( Me, i );
      if ( trav_StructTypeConstraint ) 
        trav_StructTypeConstraint( Me.structTypeConstraint( i ) );
      if ( post_StructTypeConstraints_structTypeConstraint ) 
        post_StructTypeConstraints_structTypeConstraint( Me, i );
  }

  if ( post_StructTypeConstraints ) 
    post_StructTypeConstraints( Me );
}


void default_trav_StructTypeConstraint( const StructTypeConstraint& Me )
{
  if ( pre_StructTypeConstraint ) 
    pre_StructTypeConstraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_StructTypeConstraint_consId ) 
        pre_StructTypeConstraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_StructTypeConstraint_consId ) 
        post_StructTypeConstraint_consId( Me );
    }

  if ( Me.is_present_structId())
    {
      if ( pre_StructTypeConstraint_structId ) 
        pre_StructTypeConstraint_structId( Me );
      if ( trav_StructId ) 
        trav_StructId( Me.structId() );
      if ( post_StructTypeConstraint_structId ) 
        post_StructTypeConstraint_structId( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_StructTypeConstraint_derivPath ) 
        pre_StructTypeConstraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_StructTypeConstraint_derivPath ) 
        post_StructTypeConstraint_derivPath( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_StructTypeConstraint_encVariationId ) 
        pre_StructTypeConstraint_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_StructTypeConstraint_encVariationId ) 
        post_StructTypeConstraint_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_StructTypeConstraint_comment ) 
        pre_StructTypeConstraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_StructTypeConstraint_comment ) 
        post_StructTypeConstraint_comment( Me );
    }

  if ( pre_StructTypeConstraint_elemValues ) 
    pre_StructTypeConstraint_elemValues( Me );
  if ( trav_ElemValues ) 
    trav_ElemValues( Me.elemValues() );
  if ( post_StructTypeConstraint_elemValues ) 
    post_StructTypeConstraint_elemValues( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_StructTypeConstraint_detailedComment ) 
        pre_StructTypeConstraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_StructTypeConstraint_detailedComment ) 
        post_StructTypeConstraint_detailedComment( Me );
    }

  if ( post_StructTypeConstraint ) 
    post_StructTypeConstraint( Me );
}


void default_trav_ConsId( const ConsId& Me )
{
  if ( pre_ConsId ) 
    pre_ConsId( Me );

  if ( pre_ConsId_consIdAndParList ) 
    pre_ConsId_consIdAndParList( Me );
  if ( trav_ConsIdAndParList ) 
    trav_ConsIdAndParList( Me.consIdAndParList() );
  if ( post_ConsId_consIdAndParList ) 
    post_ConsId_consIdAndParList( Me );

  if ( post_ConsId ) 
    post_ConsId( Me );
}


void default_trav_ConsIdAndParList( const ConsIdAndParList& Me )
{
  if ( pre_ConsIdAndParList ) 
    pre_ConsIdAndParList( Me );

  if ( pre_ConsIdAndParList_constraintIdentifier ) 
    pre_ConsIdAndParList_constraintIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.constraintIdentifier() );
  if ( post_ConsIdAndParList_constraintIdentifier ) 
    post_ConsIdAndParList_constraintIdentifier( Me );

  if ( pre_ConsIdAndParList_formalParList ) 
    pre_ConsIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_ConsIdAndParList_formalParList ) 
    post_ConsIdAndParList_formalParList( Me );

  if ( post_ConsIdAndParList ) 
    post_ConsIdAndParList( Me );
}


void default_trav_DerivPath( const DerivPath& Me )
{
  if ( pre_DerivPath ) 
    pre_DerivPath( Me );

  if ( pre_DerivPath_derivationPath ) 
    pre_DerivPath_derivationPath( Me );
  if ( trav_DerivationPath ) 
    trav_DerivationPath( Me.derivationPath() );
  if ( post_DerivPath_derivationPath ) 
    post_DerivPath_derivationPath( Me );

  if ( post_DerivPath ) 
    post_DerivPath( Me );
}


void default_trav_DerivationPath( const DerivationPath& Me )
{
  if ( pre_DerivationPath ) 
    pre_DerivationPath( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_DerivationPath_constraintIdentifier ) 
        pre_DerivationPath_constraintIdentifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.constraintIdentifier( i ) );
      if ( post_DerivationPath_constraintIdentifier ) 
        post_DerivationPath_constraintIdentifier( Me, i );
  }

  if ( post_DerivationPath ) 
    post_DerivationPath( Me );
}


void default_trav_ElemValues( const ElemValues& Me )
{
  if ( pre_ElemValues ) 
    pre_ElemValues( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ElemValues_elemValue ) 
        pre_ElemValues_elemValue( Me, i );
      if ( trav_ElemValue ) 
        trav_ElemValue( Me.elemValue( i ) );
      if ( post_ElemValues_elemValue ) 
        post_ElemValues_elemValue( Me, i );
  }

  if ( post_ElemValues ) 
    post_ElemValues( Me );
}


void default_trav_ElemValue( const ElemValue& Me )
{
  if ( pre_ElemValue ) 
    pre_ElemValue( Me );

  if ( Me.is_present_elemId())
    {
      if ( pre_ElemValue_elemId ) 
        pre_ElemValue_elemId( Me );
      if ( trav_ElemId ) 
        trav_ElemId( Me.elemId() );
      if ( post_ElemValue_elemId ) 
        post_ElemValue_elemId( Me );
    }

  if ( Me.is_present_consValue())
    {
      if ( pre_ElemValue_consValue ) 
        pre_ElemValue_consValue( Me );
      if ( trav_ConsValue ) 
        trav_ConsValue( Me.consValue() );
      if ( post_ElemValue_consValue ) 
        post_ElemValue_consValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ElemValue_comment ) 
        pre_ElemValue_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ElemValue_comment ) 
        post_ElemValue_comment( Me );
    }

  if ( post_ElemValue ) 
    post_ElemValue( Me );
}


void default_trav_ASN1_TypeConstraints( const ASN1_TypeConstraints& Me )
{
  if ( pre_ASN1_TypeConstraints ) 
    pre_ASN1_TypeConstraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_TypeConstraints_asn1_TypeConstraint ) 
        pre_ASN1_TypeConstraints_asn1_TypeConstraint( Me, i );
      if ( trav_ASN1_TypeConstraint ) 
        trav_ASN1_TypeConstraint( Me.asn1_TypeConstraint( i ) );
      if ( post_ASN1_TypeConstraints_asn1_TypeConstraint ) 
        post_ASN1_TypeConstraints_asn1_TypeConstraint( Me, i );
  }

  if ( post_ASN1_TypeConstraints ) 
    post_ASN1_TypeConstraints( Me );
}


void default_trav_ASN1_TypeConstraint( const ASN1_TypeConstraint& Me )
{
  if ( pre_ASN1_TypeConstraint ) 
    pre_ASN1_TypeConstraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_ASN1_TypeConstraint_consId ) 
        pre_ASN1_TypeConstraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_ASN1_TypeConstraint_consId ) 
        post_ASN1_TypeConstraint_consId( Me );
    }

  if ( Me.is_present_asn1_TypeId())
    {
      if ( pre_ASN1_TypeConstraint_asn1_TypeId ) 
        pre_ASN1_TypeConstraint_asn1_TypeId( Me );
      if ( trav_ASN1_TypeId ) 
        trav_ASN1_TypeId( Me.asn1_TypeId() );
      if ( post_ASN1_TypeConstraint_asn1_TypeId ) 
        post_ASN1_TypeConstraint_asn1_TypeId( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_ASN1_TypeConstraint_derivPath ) 
        pre_ASN1_TypeConstraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_ASN1_TypeConstraint_derivPath ) 
        post_ASN1_TypeConstraint_derivPath( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_TypeConstraint_encVariationId ) 
        pre_ASN1_TypeConstraint_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_TypeConstraint_encVariationId ) 
        post_ASN1_TypeConstraint_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_TypeConstraint_comment ) 
        pre_ASN1_TypeConstraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_TypeConstraint_comment ) 
        post_ASN1_TypeConstraint_comment( Me );
    }

  if ( Me.is_present_asn1_ConsValue())
    {
      if ( pre_ASN1_TypeConstraint_asn1_ConsValue ) 
        pre_ASN1_TypeConstraint_asn1_ConsValue( Me );
      if ( trav_ASN1_ConsValue ) 
        trav_ASN1_ConsValue( Me.asn1_ConsValue() );
      if ( post_ASN1_TypeConstraint_asn1_ConsValue ) 
        post_ASN1_TypeConstraint_asn1_ConsValue( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_TypeConstraint_detailedComment ) 
        pre_ASN1_TypeConstraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_TypeConstraint_detailedComment ) 
        post_ASN1_TypeConstraint_detailedComment( Me );
    }

  if ( post_ASN1_TypeConstraint ) 
    post_ASN1_TypeConstraint( Me );
}


void default_trav_TTCN_ASP_Constraints( const TTCN_ASP_Constraints& Me )
{
  if ( pre_TTCN_ASP_Constraints ) 
    pre_TTCN_ASP_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_ASP_Constraints_ttcn_ASP_Constraint ) 
        pre_TTCN_ASP_Constraints_ttcn_ASP_Constraint( Me, i );
      if ( trav_TTCN_ASP_Constraint ) 
        trav_TTCN_ASP_Constraint( Me.ttcn_ASP_Constraint( i ) );
      if ( post_TTCN_ASP_Constraints_ttcn_ASP_Constraint ) 
        post_TTCN_ASP_Constraints_ttcn_ASP_Constraint( Me, i );
  }

  if ( post_TTCN_ASP_Constraints ) 
    post_TTCN_ASP_Constraints( Me );
}


void default_trav_TTCN_ASP_Constraint( const TTCN_ASP_Constraint& Me )
{
  if ( pre_TTCN_ASP_Constraint ) 
    pre_TTCN_ASP_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_TTCN_ASP_Constraint_consId ) 
        pre_TTCN_ASP_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_TTCN_ASP_Constraint_consId ) 
        post_TTCN_ASP_Constraint_consId( Me );
    }

  if ( Me.is_present_asp_Id())
    {
      if ( pre_TTCN_ASP_Constraint_asp_Id ) 
        pre_TTCN_ASP_Constraint_asp_Id( Me );
      if ( trav_ASP_Id ) 
        trav_ASP_Id( Me.asp_Id() );
      if ( post_TTCN_ASP_Constraint_asp_Id ) 
        post_TTCN_ASP_Constraint_asp_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_TTCN_ASP_Constraint_derivPath ) 
        pre_TTCN_ASP_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_TTCN_ASP_Constraint_derivPath ) 
        post_TTCN_ASP_Constraint_derivPath( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_ASP_Constraint_comment ) 
        pre_TTCN_ASP_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_ASP_Constraint_comment ) 
        post_TTCN_ASP_Constraint_comment( Me );
    }

  if ( pre_TTCN_ASP_Constraint_asp_ParValues ) 
    pre_TTCN_ASP_Constraint_asp_ParValues( Me );
  if ( trav_ASP_ParValues ) 
    trav_ASP_ParValues( Me.asp_ParValues() );
  if ( post_TTCN_ASP_Constraint_asp_ParValues ) 
    post_TTCN_ASP_Constraint_asp_ParValues( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_ASP_Constraint_detailedComment ) 
        pre_TTCN_ASP_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_ASP_Constraint_detailedComment ) 
        post_TTCN_ASP_Constraint_detailedComment( Me );
    }

  if ( post_TTCN_ASP_Constraint ) 
    post_TTCN_ASP_Constraint( Me );
}


void default_trav_ASP_ParValues( const ASP_ParValues& Me )
{
  if ( pre_ASP_ParValues ) 
    pre_ASP_ParValues( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASP_ParValues_asp_ParValue ) 
        pre_ASP_ParValues_asp_ParValue( Me, i );
      if ( trav_ASP_ParValue ) 
        trav_ASP_ParValue( Me.asp_ParValue( i ) );
      if ( post_ASP_ParValues_asp_ParValue ) 
        post_ASP_ParValues_asp_ParValue( Me, i );
  }

  if ( post_ASP_ParValues ) 
    post_ASP_ParValues( Me );
}


void default_trav_ASP_ParValue( const ASP_ParValue& Me )
{
  if ( pre_ASP_ParValue ) 
    pre_ASP_ParValue( Me );

  if ( Me.is_present_asp_ParId())
    {
      if ( pre_ASP_ParValue_asp_ParId ) 
        pre_ASP_ParValue_asp_ParId( Me );
      if ( trav_ASP_ParId ) 
        trav_ASP_ParId( Me.asp_ParId() );
      if ( post_ASP_ParValue_asp_ParId ) 
        post_ASP_ParValue_asp_ParId( Me );
    }

  if ( Me.is_present_consValue())
    {
      if ( pre_ASP_ParValue_consValue ) 
        pre_ASP_ParValue_consValue( Me );
      if ( trav_ConsValue ) 
        trav_ConsValue( Me.consValue() );
      if ( post_ASP_ParValue_consValue ) 
        post_ASP_ParValue_consValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASP_ParValue_comment ) 
        pre_ASP_ParValue_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASP_ParValue_comment ) 
        post_ASP_ParValue_comment( Me );
    }

  if ( post_ASP_ParValue ) 
    post_ASP_ParValue( Me );
}


void default_trav_TTCN_PDU_Constraints( const TTCN_PDU_Constraints& Me )
{
  if ( pre_TTCN_PDU_Constraints ) 
    pre_TTCN_PDU_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_PDU_Constraints_ttcn_PDU_Constraint ) 
        pre_TTCN_PDU_Constraints_ttcn_PDU_Constraint( Me, i );
      if ( trav_TTCN_PDU_Constraint ) 
        trav_TTCN_PDU_Constraint( Me.ttcn_PDU_Constraint( i ) );
      if ( post_TTCN_PDU_Constraints_ttcn_PDU_Constraint ) 
        post_TTCN_PDU_Constraints_ttcn_PDU_Constraint( Me, i );
  }

  if ( post_TTCN_PDU_Constraints ) 
    post_TTCN_PDU_Constraints( Me );
}


void default_trav_TTCN_PDU_Constraint( const TTCN_PDU_Constraint& Me )
{
  if ( pre_TTCN_PDU_Constraint ) 
    pre_TTCN_PDU_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_TTCN_PDU_Constraint_consId ) 
        pre_TTCN_PDU_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_TTCN_PDU_Constraint_consId ) 
        post_TTCN_PDU_Constraint_consId( Me );
    }

  if ( Me.is_present_pdu_Id())
    {
      if ( pre_TTCN_PDU_Constraint_pdu_Id ) 
        pre_TTCN_PDU_Constraint_pdu_Id( Me );
      if ( trav_PDU_Id ) 
        trav_PDU_Id( Me.pdu_Id() );
      if ( post_TTCN_PDU_Constraint_pdu_Id ) 
        post_TTCN_PDU_Constraint_pdu_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_TTCN_PDU_Constraint_derivPath ) 
        pre_TTCN_PDU_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_TTCN_PDU_Constraint_derivPath ) 
        post_TTCN_PDU_Constraint_derivPath( Me );
    }

  if ( Me.is_present_encRuleId())
    {
      if ( pre_TTCN_PDU_Constraint_encRuleId ) 
        pre_TTCN_PDU_Constraint_encRuleId( Me );
      if ( trav_EncRuleId ) 
        trav_EncRuleId( Me.encRuleId() );
      if ( post_TTCN_PDU_Constraint_encRuleId ) 
        post_TTCN_PDU_Constraint_encRuleId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_TTCN_PDU_Constraint_encVariationId ) 
        pre_TTCN_PDU_Constraint_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_TTCN_PDU_Constraint_encVariationId ) 
        post_TTCN_PDU_Constraint_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_PDU_Constraint_comment ) 
        pre_TTCN_PDU_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_PDU_Constraint_comment ) 
        post_TTCN_PDU_Constraint_comment( Me );
    }

  if ( pre_TTCN_PDU_Constraint_pdu_FieldValues ) 
    pre_TTCN_PDU_Constraint_pdu_FieldValues( Me );
  if ( trav_PDU_FieldValues ) 
    trav_PDU_FieldValues( Me.pdu_FieldValues() );
  if ( post_TTCN_PDU_Constraint_pdu_FieldValues ) 
    post_TTCN_PDU_Constraint_pdu_FieldValues( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_PDU_Constraint_detailedComment ) 
        pre_TTCN_PDU_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_PDU_Constraint_detailedComment ) 
        post_TTCN_PDU_Constraint_detailedComment( Me );
    }

  if ( post_TTCN_PDU_Constraint ) 
    post_TTCN_PDU_Constraint( Me );
}


void default_trav_PDU_FieldValues( const PDU_FieldValues& Me )
{
  if ( pre_PDU_FieldValues ) 
    pre_PDU_FieldValues( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_PDU_FieldValues_pdu_FieldValue ) 
        pre_PDU_FieldValues_pdu_FieldValue( Me, i );
      if ( trav_PDU_FieldValue ) 
        trav_PDU_FieldValue( Me.pdu_FieldValue( i ) );
      if ( post_PDU_FieldValues_pdu_FieldValue ) 
        post_PDU_FieldValues_pdu_FieldValue( Me, i );
  }

  if ( post_PDU_FieldValues ) 
    post_PDU_FieldValues( Me );
}


void default_trav_PDU_FieldValue( const PDU_FieldValue& Me )
{
  if ( pre_PDU_FieldValue ) 
    pre_PDU_FieldValue( Me );

  if ( Me.is_present_pdu_FieldId())
    {
      if ( pre_PDU_FieldValue_pdu_FieldId ) 
        pre_PDU_FieldValue_pdu_FieldId( Me );
      if ( trav_PDU_FieldId ) 
        trav_PDU_FieldId( Me.pdu_FieldId() );
      if ( post_PDU_FieldValue_pdu_FieldId ) 
        post_PDU_FieldValue_pdu_FieldId( Me );
    }

  if ( Me.is_present_consValue())
    {
      if ( pre_PDU_FieldValue_consValue ) 
        pre_PDU_FieldValue_consValue( Me );
      if ( trav_ConsValue ) 
        trav_ConsValue( Me.consValue() );
      if ( post_PDU_FieldValue_consValue ) 
        post_PDU_FieldValue_consValue( Me );
    }

  if ( Me.is_present_pdu_FieldEncoding())
    {
      if ( pre_PDU_FieldValue_pdu_FieldEncoding ) 
        pre_PDU_FieldValue_pdu_FieldEncoding( Me );
      if ( trav_PDU_FieldEncoding ) 
        trav_PDU_FieldEncoding( Me.pdu_FieldEncoding() );
      if ( post_PDU_FieldValue_pdu_FieldEncoding ) 
        post_PDU_FieldValue_pdu_FieldEncoding( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_PDU_FieldValue_comment ) 
        pre_PDU_FieldValue_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_PDU_FieldValue_comment ) 
        post_PDU_FieldValue_comment( Me );
    }

  if ( post_PDU_FieldValue ) 
    post_PDU_FieldValue( Me );
}


void default_trav_ConsValue( const ConsValue& Me )
{
  if ( pre_ConsValue ) 
    pre_ConsValue( Me );

  if ( pre_ConsValue_constraintValueAndAttributes ) 
    pre_ConsValue_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_ConsValue_constraintValueAndAttributes ) 
    post_ConsValue_constraintValueAndAttributes( Me );

  if ( post_ConsValue ) 
    post_ConsValue( Me );
}


void default_trav_ASN1_ASP_Constraints( const ASN1_ASP_Constraints& Me )
{
  if ( pre_ASN1_ASP_Constraints ) 
    pre_ASN1_ASP_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_ASP_Constraints_asn1_ASP_Constraint ) 
        pre_ASN1_ASP_Constraints_asn1_ASP_Constraint( Me, i );
      if ( trav_ASN1_ASP_Constraint ) 
        trav_ASN1_ASP_Constraint( Me.asn1_ASP_Constraint( i ) );
      if ( post_ASN1_ASP_Constraints_asn1_ASP_Constraint ) 
        post_ASN1_ASP_Constraints_asn1_ASP_Constraint( Me, i );
  }

  if ( post_ASN1_ASP_Constraints ) 
    post_ASN1_ASP_Constraints( Me );
}


void default_trav_ASN1_ASP_Constraint( const ASN1_ASP_Constraint& Me )
{
  if ( pre_ASN1_ASP_Constraint ) 
    pre_ASN1_ASP_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_ASN1_ASP_Constraint_consId ) 
        pre_ASN1_ASP_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_ASN1_ASP_Constraint_consId ) 
        post_ASN1_ASP_Constraint_consId( Me );
    }

  if ( Me.is_present_asp_Id())
    {
      if ( pre_ASN1_ASP_Constraint_asp_Id ) 
        pre_ASN1_ASP_Constraint_asp_Id( Me );
      if ( trav_ASP_Id ) 
        trav_ASP_Id( Me.asp_Id() );
      if ( post_ASN1_ASP_Constraint_asp_Id ) 
        post_ASN1_ASP_Constraint_asp_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_ASN1_ASP_Constraint_derivPath ) 
        pre_ASN1_ASP_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_ASN1_ASP_Constraint_derivPath ) 
        post_ASN1_ASP_Constraint_derivPath( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_ASP_Constraint_comment ) 
        pre_ASN1_ASP_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_ASP_Constraint_comment ) 
        post_ASN1_ASP_Constraint_comment( Me );
    }

  if ( Me.is_present_asn1_ConsValue())
    {
      if ( pre_ASN1_ASP_Constraint_asn1_ConsValue ) 
        pre_ASN1_ASP_Constraint_asn1_ConsValue( Me );
      if ( trav_ASN1_ConsValue ) 
        trav_ASN1_ConsValue( Me.asn1_ConsValue() );
      if ( post_ASN1_ASP_Constraint_asn1_ConsValue ) 
        post_ASN1_ASP_Constraint_asn1_ConsValue( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_ASP_Constraint_detailedComment ) 
        pre_ASN1_ASP_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_ASP_Constraint_detailedComment ) 
        post_ASN1_ASP_Constraint_detailedComment( Me );
    }

  if ( post_ASN1_ASP_Constraint ) 
    post_ASN1_ASP_Constraint( Me );
}


void default_trav_ASN1_PDU_Constraints( const ASN1_PDU_Constraints& Me )
{
  if ( pre_ASN1_PDU_Constraints ) 
    pre_ASN1_PDU_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_PDU_Constraints_asn1_PDU_Constraint ) 
        pre_ASN1_PDU_Constraints_asn1_PDU_Constraint( Me, i );
      if ( trav_ASN1_PDU_Constraint ) 
        trav_ASN1_PDU_Constraint( Me.asn1_PDU_Constraint( i ) );
      if ( post_ASN1_PDU_Constraints_asn1_PDU_Constraint ) 
        post_ASN1_PDU_Constraints_asn1_PDU_Constraint( Me, i );
  }

  if ( post_ASN1_PDU_Constraints ) 
    post_ASN1_PDU_Constraints( Me );
}


void default_trav_ASN1_PDU_Constraint( const ASN1_PDU_Constraint& Me )
{
  if ( pre_ASN1_PDU_Constraint ) 
    pre_ASN1_PDU_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_ASN1_PDU_Constraint_consId ) 
        pre_ASN1_PDU_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_ASN1_PDU_Constraint_consId ) 
        post_ASN1_PDU_Constraint_consId( Me );
    }

  if ( Me.is_present_pdu_Id())
    {
      if ( pre_ASN1_PDU_Constraint_pdu_Id ) 
        pre_ASN1_PDU_Constraint_pdu_Id( Me );
      if ( trav_PDU_Id ) 
        trav_PDU_Id( Me.pdu_Id() );
      if ( post_ASN1_PDU_Constraint_pdu_Id ) 
        post_ASN1_PDU_Constraint_pdu_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_ASN1_PDU_Constraint_derivPath ) 
        pre_ASN1_PDU_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_ASN1_PDU_Constraint_derivPath ) 
        post_ASN1_PDU_Constraint_derivPath( Me );
    }

  if ( Me.is_present_encRuleId())
    {
      if ( pre_ASN1_PDU_Constraint_encRuleId ) 
        pre_ASN1_PDU_Constraint_encRuleId( Me );
      if ( trav_EncRuleId ) 
        trav_EncRuleId( Me.encRuleId() );
      if ( post_ASN1_PDU_Constraint_encRuleId ) 
        post_ASN1_PDU_Constraint_encRuleId( Me );
    }

  if ( Me.is_present_encVariationId())
    {
      if ( pre_ASN1_PDU_Constraint_encVariationId ) 
        pre_ASN1_PDU_Constraint_encVariationId( Me );
      if ( trav_EncVariationId ) 
        trav_EncVariationId( Me.encVariationId() );
      if ( post_ASN1_PDU_Constraint_encVariationId ) 
        post_ASN1_PDU_Constraint_encVariationId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_PDU_Constraint_comment ) 
        pre_ASN1_PDU_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_PDU_Constraint_comment ) 
        post_ASN1_PDU_Constraint_comment( Me );
    }

  if ( Me.is_present_asn1_ConsValue())
    {
      if ( pre_ASN1_PDU_Constraint_asn1_ConsValue ) 
        pre_ASN1_PDU_Constraint_asn1_ConsValue( Me );
      if ( trav_ASN1_ConsValue ) 
        trav_ASN1_ConsValue( Me.asn1_ConsValue() );
      if ( post_ASN1_PDU_Constraint_asn1_ConsValue ) 
        post_ASN1_PDU_Constraint_asn1_ConsValue( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_PDU_Constraint_detailedComment ) 
        pre_ASN1_PDU_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_PDU_Constraint_detailedComment ) 
        post_ASN1_PDU_Constraint_detailedComment( Me );
    }

  if ( post_ASN1_PDU_Constraint ) 
    post_ASN1_PDU_Constraint( Me );
}


void default_trav_ASN1_ConsValue( const ASN1_ConsValue& Me )
{
  if ( pre_ASN1_ConsValue ) 
    pre_ASN1_ConsValue( Me );

  if ( pre_ASN1_ConsValue_constraintValueAndAttributesOrReplace ) 
    pre_ASN1_ConsValue_constraintValueAndAttributesOrReplace( Me );
  if ( trav_ConstraintValueAndAttributesOrReplace ) 
    trav_ConstraintValueAndAttributesOrReplace( Me.constraintValueAndAttributesOrReplace() );
  if ( post_ASN1_ConsValue_constraintValueAndAttributesOrReplace ) 
    post_ASN1_ConsValue_constraintValueAndAttributesOrReplace( Me );

  if ( post_ASN1_ConsValue ) 
    post_ASN1_ConsValue( Me );
}


void default_trav_ConstraintValueAndAttributesOrReplace( const ConstraintValueAndAttributesOrReplace& Me )
{
  if ( pre_ConstraintValueAndAttributesOrReplace ) 
    pre_ConstraintValueAndAttributesOrReplace( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintValueAndAttributes:
      if ( pre_ConstraintValueAndAttributesOrReplace_constraintValueAndAttributes ) 
        pre_ConstraintValueAndAttributesOrReplace_constraintValueAndAttributes( Me );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
      if ( post_ConstraintValueAndAttributesOrReplace_constraintValueAndAttributes ) 
        post_ConstraintValueAndAttributesOrReplace_constraintValueAndAttributes( Me );
      break;

    case Choices::c_ReplacementList:
      if ( pre_ConstraintValueAndAttributesOrReplace_replacementList ) 
        pre_ConstraintValueAndAttributesOrReplace_replacementList( Me );
      if ( trav_ReplacementList ) 
        trav_ReplacementList( Me.replacementList() );
      if ( post_ConstraintValueAndAttributesOrReplace_replacementList ) 
        post_ConstraintValueAndAttributesOrReplace_replacementList( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ConstraintValueAndAttributesOrReplace: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ConstraintValueAndAttributesOrReplace ) 
    post_ConstraintValueAndAttributesOrReplace( Me );
}


void default_trav_ReplacementList( const ReplacementList& Me )
{
  if ( pre_ReplacementList ) 
    pre_ReplacementList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ReplacementList_replacement ) 
        pre_ReplacementList_replacement( Me, i );
      if ( trav_Replacement ) 
        trav_Replacement( Me.replacement( i ) );
      if ( post_ReplacementList_replacement ) 
        post_ReplacementList_replacement( Me, i );
  }

  if ( post_ReplacementList ) 
    post_ReplacementList( Me );
}


void default_trav_Replacement( const Replacement& Me )
{
  if ( pre_Replacement ) 
    pre_Replacement( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Replace:
      if ( pre_Replacement_replace ) 
        pre_Replacement_replace( Me );
      if ( trav_Replace ) 
        trav_Replace( Me.replace() );
      if ( post_Replacement_replace ) 
        post_Replacement_replace( Me );
      break;

    case Choices::c_OmitReference:
      if ( pre_Replacement_omitReference ) 
        pre_Replacement_omitReference( Me );
      if ( trav_OmitReference ) 
        trav_OmitReference( Me.omitReference() );
      if ( post_Replacement_omitReference ) 
        post_Replacement_omitReference( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Replacement: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Replacement ) 
    post_Replacement( Me );
}


void default_trav_Replace( const Replace& Me )
{
  if ( pre_Replace ) 
    pre_Replace( Me );

  if ( pre_Replace_referenceList ) 
    pre_Replace_referenceList( Me );
  if ( trav_ReferenceList ) 
    trav_ReferenceList( Me.referenceList() );
  if ( post_Replace_referenceList ) 
    post_Replace_referenceList( Me );

  if ( pre_Replace_constraintValueAndAttributes ) 
    pre_Replace_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_Replace_constraintValueAndAttributes ) 
    post_Replace_constraintValueAndAttributes( Me );

  if ( post_Replace ) 
    post_Replace( Me );
}


void default_trav_ReferenceList( const ReferenceList& Me )
{
  if ( pre_ReferenceList ) 
    pre_ReferenceList( Me );

  if ( pre_ReferenceList_arrayRefOrComp ) 
    pre_ReferenceList_arrayRefOrComp( Me );
  if ( trav_ArrayRefOrComp ) 
    trav_ArrayRefOrComp( Me.arrayRefOrComp() );
  if ( post_ReferenceList_arrayRefOrComp ) 
    post_ReferenceList_arrayRefOrComp( Me );

  if ( pre_ReferenceList_componentReferenceList ) 
    pre_ReferenceList_componentReferenceList( Me );
  if ( trav_ComponentReferenceList ) 
    trav_ComponentReferenceList( Me.componentReferenceList() );
  if ( post_ReferenceList_componentReferenceList ) 
    post_ReferenceList_componentReferenceList( Me );

  if ( post_ReferenceList ) 
    post_ReferenceList( Me );
}


void default_trav_OmitReference( const OmitReference& Me )
{
  if ( pre_OmitReference ) 
    pre_OmitReference( Me );

  if ( pre_OmitReference_referenceList ) 
    pre_OmitReference_referenceList( Me );
  if ( trav_ReferenceList ) 
    trav_ReferenceList( Me.referenceList() );
  if ( post_OmitReference_referenceList ) 
    post_OmitReference_referenceList( Me );

  if ( post_OmitReference ) 
    post_OmitReference( Me );
}


void default_trav_ArrayRefOrComp( const ArrayRefOrComp& Me )
{
  if ( pre_ArrayRefOrComp ) 
    pre_ArrayRefOrComp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ComponentIdentifier:
      if ( pre_ArrayRefOrComp_componentIdentifier ) 
        pre_ArrayRefOrComp_componentIdentifier( Me );
      if ( trav_ComponentIdentifier ) 
        trav_ComponentIdentifier( Me.componentIdentifier() );
      if ( post_ArrayRefOrComp_componentIdentifier ) 
        post_ArrayRefOrComp_componentIdentifier( Me );
      break;

    case Choices::c_BitRef:
      if ( pre_ArrayRefOrComp_bitRef ) 
        pre_ArrayRefOrComp_bitRef( Me );
      if ( trav_BitRef ) 
        trav_BitRef( Me.bitRef() );
      if ( post_ArrayRefOrComp_bitRef ) 
        post_ArrayRefOrComp_bitRef( Me );
      break;

    case Choices::c_ComponentPosition:
      if ( pre_ArrayRefOrComp_componentPosition ) 
        pre_ArrayRefOrComp_componentPosition( Me );
      if ( trav_ComponentPosition ) 
        trav_ComponentPosition( Me.componentPosition() );
      if ( post_ArrayRefOrComp_componentPosition ) 
        post_ArrayRefOrComp_componentPosition( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ArrayRefOrComp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ArrayRefOrComp ) 
    post_ArrayRefOrComp( Me );
}


void default_trav_TTCN_CM_Constraints( const TTCN_CM_Constraints& Me )
{
  if ( pre_TTCN_CM_Constraints ) 
    pre_TTCN_CM_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TTCN_CM_Constraints_ttcn_CM_Constraint ) 
        pre_TTCN_CM_Constraints_ttcn_CM_Constraint( Me, i );
      if ( trav_TTCN_CM_Constraint ) 
        trav_TTCN_CM_Constraint( Me.ttcn_CM_Constraint( i ) );
      if ( post_TTCN_CM_Constraints_ttcn_CM_Constraint ) 
        post_TTCN_CM_Constraints_ttcn_CM_Constraint( Me, i );
  }

  if ( post_TTCN_CM_Constraints ) 
    post_TTCN_CM_Constraints( Me );
}


void default_trav_TTCN_CM_Constraint( const TTCN_CM_Constraint& Me )
{
  if ( pre_TTCN_CM_Constraint ) 
    pre_TTCN_CM_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_TTCN_CM_Constraint_consId ) 
        pre_TTCN_CM_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_TTCN_CM_Constraint_consId ) 
        post_TTCN_CM_Constraint_consId( Me );
    }

  if ( Me.is_present_cm_Id())
    {
      if ( pre_TTCN_CM_Constraint_cm_Id ) 
        pre_TTCN_CM_Constraint_cm_Id( Me );
      if ( trav_CM_Id ) 
        trav_CM_Id( Me.cm_Id() );
      if ( post_TTCN_CM_Constraint_cm_Id ) 
        post_TTCN_CM_Constraint_cm_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_TTCN_CM_Constraint_derivPath ) 
        pre_TTCN_CM_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_TTCN_CM_Constraint_derivPath ) 
        post_TTCN_CM_Constraint_derivPath( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TTCN_CM_Constraint_comment ) 
        pre_TTCN_CM_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TTCN_CM_Constraint_comment ) 
        post_TTCN_CM_Constraint_comment( Me );
    }

  if ( pre_TTCN_CM_Constraint_cm_ParValues ) 
    pre_TTCN_CM_Constraint_cm_ParValues( Me );
  if ( trav_CM_ParValues ) 
    trav_CM_ParValues( Me.cm_ParValues() );
  if ( post_TTCN_CM_Constraint_cm_ParValues ) 
    post_TTCN_CM_Constraint_cm_ParValues( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TTCN_CM_Constraint_detailedComment ) 
        pre_TTCN_CM_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TTCN_CM_Constraint_detailedComment ) 
        post_TTCN_CM_Constraint_detailedComment( Me );
    }

  if ( post_TTCN_CM_Constraint ) 
    post_TTCN_CM_Constraint( Me );
}


void default_trav_CM_ParValues( const CM_ParValues& Me )
{
  if ( pre_CM_ParValues ) 
    pre_CM_ParValues( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CM_ParValues_cm_ParValue ) 
        pre_CM_ParValues_cm_ParValue( Me, i );
      if ( trav_CM_ParValue ) 
        trav_CM_ParValue( Me.cm_ParValue( i ) );
      if ( post_CM_ParValues_cm_ParValue ) 
        post_CM_ParValues_cm_ParValue( Me, i );
  }

  if ( post_CM_ParValues ) 
    post_CM_ParValues( Me );
}


void default_trav_CM_ParValue( const CM_ParValue& Me )
{
  if ( pre_CM_ParValue ) 
    pre_CM_ParValue( Me );

  if ( Me.is_present_cm_ParId())
    {
      if ( pre_CM_ParValue_cm_ParId ) 
        pre_CM_ParValue_cm_ParId( Me );
      if ( trav_CM_ParId ) 
        trav_CM_ParId( Me.cm_ParId() );
      if ( post_CM_ParValue_cm_ParId ) 
        post_CM_ParValue_cm_ParId( Me );
    }

  if ( Me.is_present_consValue())
    {
      if ( pre_CM_ParValue_consValue ) 
        pre_CM_ParValue_consValue( Me );
      if ( trav_ConsValue ) 
        trav_ConsValue( Me.consValue() );
      if ( post_CM_ParValue_consValue ) 
        post_CM_ParValue_consValue( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_CM_ParValue_comment ) 
        pre_CM_ParValue_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_CM_ParValue_comment ) 
        post_CM_ParValue_comment( Me );
    }

  if ( post_CM_ParValue ) 
    post_CM_ParValue( Me );
}


void default_trav_ASN1_CM_Constraints( const ASN1_CM_Constraints& Me )
{
  if ( pre_ASN1_CM_Constraints ) 
    pre_ASN1_CM_Constraints( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_CM_Constraints_asn1_CM_Constraint ) 
        pre_ASN1_CM_Constraints_asn1_CM_Constraint( Me, i );
      if ( trav_ASN1_CM_Constraint ) 
        trav_ASN1_CM_Constraint( Me.asn1_CM_Constraint( i ) );
      if ( post_ASN1_CM_Constraints_asn1_CM_Constraint ) 
        post_ASN1_CM_Constraints_asn1_CM_Constraint( Me, i );
  }

  if ( post_ASN1_CM_Constraints ) 
    post_ASN1_CM_Constraints( Me );
}


void default_trav_ASN1_CM_Constraint( const ASN1_CM_Constraint& Me )
{
  if ( pre_ASN1_CM_Constraint ) 
    pre_ASN1_CM_Constraint( Me );

  if ( Me.is_present_consId())
    {
      if ( pre_ASN1_CM_Constraint_consId ) 
        pre_ASN1_CM_Constraint_consId( Me );
      if ( trav_ConsId ) 
        trav_ConsId( Me.consId() );
      if ( post_ASN1_CM_Constraint_consId ) 
        post_ASN1_CM_Constraint_consId( Me );
    }

  if ( Me.is_present_cm_Id())
    {
      if ( pre_ASN1_CM_Constraint_cm_Id ) 
        pre_ASN1_CM_Constraint_cm_Id( Me );
      if ( trav_CM_Id ) 
        trav_CM_Id( Me.cm_Id() );
      if ( post_ASN1_CM_Constraint_cm_Id ) 
        post_ASN1_CM_Constraint_cm_Id( Me );
    }

  if ( Me.is_present_derivPath())
    {
      if ( pre_ASN1_CM_Constraint_derivPath ) 
        pre_ASN1_CM_Constraint_derivPath( Me );
      if ( trav_DerivPath ) 
        trav_DerivPath( Me.derivPath() );
      if ( post_ASN1_CM_Constraint_derivPath ) 
        post_ASN1_CM_Constraint_derivPath( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_ASN1_CM_Constraint_comment ) 
        pre_ASN1_CM_Constraint_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_ASN1_CM_Constraint_comment ) 
        post_ASN1_CM_Constraint_comment( Me );
    }

  if ( Me.is_present_asn1_ConsValue())
    {
      if ( pre_ASN1_CM_Constraint_asn1_ConsValue ) 
        pre_ASN1_CM_Constraint_asn1_ConsValue( Me );
      if ( trav_ASN1_ConsValue ) 
        trav_ASN1_ConsValue( Me.asn1_ConsValue() );
      if ( post_ASN1_CM_Constraint_asn1_ConsValue ) 
        post_ASN1_CM_Constraint_asn1_ConsValue( Me );
    }

  if ( Me.is_present_detailedComment())
    {
      if ( pre_ASN1_CM_Constraint_detailedComment ) 
        pre_ASN1_CM_Constraint_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_ASN1_CM_Constraint_detailedComment ) 
        post_ASN1_CM_Constraint_detailedComment( Me );
    }

  if ( post_ASN1_CM_Constraint ) 
    post_ASN1_CM_Constraint( Me );
}


void default_trav_DynamicPart( const DynamicPart& Me )
{
  if ( pre_DynamicPart ) 
    pre_DynamicPart( Me );

  if ( pre_DynamicPart_testCases ) 
    pre_DynamicPart_testCases( Me );
  if ( trav_TestCases ) 
    trav_TestCases( Me.testCases() );
  if ( post_DynamicPart_testCases ) 
    post_DynamicPart_testCases( Me );

  if ( pre_DynamicPart_testStepLibrary ) 
    pre_DynamicPart_testStepLibrary( Me );
  if ( trav_TestStepLibrary ) 
    trav_TestStepLibrary( Me.testStepLibrary() );
  if ( post_DynamicPart_testStepLibrary ) 
    post_DynamicPart_testStepLibrary( Me );

  if ( pre_DynamicPart_defaultsLibrary ) 
    pre_DynamicPart_defaultsLibrary( Me );
  if ( trav_DefaultsLibrary ) 
    trav_DefaultsLibrary( Me.defaultsLibrary() );
  if ( post_DynamicPart_defaultsLibrary ) 
    post_DynamicPart_defaultsLibrary( Me );

  if ( post_DynamicPart ) 
    post_DynamicPart( Me );
}


void default_trav_TestCases( const TestCases& Me )
{
  if ( pre_TestCases ) 
    pre_TestCases( Me );

  if ( pre_TestCases_testGroupOrTestCaseList ) 
    pre_TestCases_testGroupOrTestCaseList( Me );
  if ( trav_TestGroupOrTestCaseList ) 
    trav_TestGroupOrTestCaseList( Me.testGroupOrTestCaseList() );
  if ( post_TestCases_testGroupOrTestCaseList ) 
    post_TestCases_testGroupOrTestCaseList( Me );

  if ( post_TestCases ) 
    post_TestCases( Me );
}


void default_trav_TestGroupOrTestCaseList( const TestGroupOrTestCaseList& Me )
{
  if ( pre_TestGroupOrTestCaseList ) 
    pre_TestGroupOrTestCaseList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TestGroupOrTestCaseList_testGroupOrTestCase ) 
        pre_TestGroupOrTestCaseList_testGroupOrTestCase( Me, i );
      if ( trav_TestGroupOrTestCase ) 
        trav_TestGroupOrTestCase( Me.testGroupOrTestCase( i ) );
      if ( post_TestGroupOrTestCaseList_testGroupOrTestCase ) 
        post_TestGroupOrTestCaseList_testGroupOrTestCase( Me, i );
  }

  if ( post_TestGroupOrTestCaseList ) 
    post_TestGroupOrTestCaseList( Me );
}


void default_trav_TestGroupOrTestCase( const TestGroupOrTestCase& Me )
{
  if ( pre_TestGroupOrTestCase ) 
    pre_TestGroupOrTestCase( Me );

  switch ( Me.choice() )
    {
    case Choices::c_TestGroup:
      if ( pre_TestGroupOrTestCase_testGroup ) 
        pre_TestGroupOrTestCase_testGroup( Me );
      if ( trav_TestGroup ) 
        trav_TestGroup( Me.testGroup() );
      if ( post_TestGroupOrTestCase_testGroup ) 
        post_TestGroupOrTestCase_testGroup( Me );
      break;

    case Choices::c_TestCase:
      if ( pre_TestGroupOrTestCase_testCase ) 
        pre_TestGroupOrTestCase_testCase( Me );
      if ( trav_TestCase ) 
        trav_TestCase( Me.testCase() );
      if ( post_TestGroupOrTestCase_testCase ) 
        post_TestGroupOrTestCase_testCase( Me );
      break;

    case Choices::c_CompactTestGroup:
      if ( pre_TestGroupOrTestCase_compactTestGroup ) 
        pre_TestGroupOrTestCase_compactTestGroup( Me );
      if ( trav_CompactTestGroup ) 
        trav_CompactTestGroup( Me.compactTestGroup() );
      if ( post_TestGroupOrTestCase_compactTestGroup ) 
        post_TestGroupOrTestCase_compactTestGroup( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TestGroupOrTestCase: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TestGroupOrTestCase ) 
    post_TestGroupOrTestCase( Me );
}


void default_trav_TestGroup( const TestGroup& Me )
{
  if ( pre_TestGroup ) 
    pre_TestGroup( Me );

  if ( Me.is_present_testGroupId())
    {
      if ( pre_TestGroup_testGroupId ) 
        pre_TestGroup_testGroupId( Me );
      if ( trav_TestGroupId ) 
        trav_TestGroupId( Me.testGroupId() );
      if ( post_TestGroup_testGroupId ) 
        post_TestGroup_testGroupId( Me );
    }

  if ( Me.is_present_selExprId())
    {
      if ( pre_TestGroup_selExprId ) 
        pre_TestGroup_selExprId( Me );
      if ( trav_SelExprId ) 
        trav_SelExprId( Me.selExprId() );
      if ( post_TestGroup_selExprId ) 
        post_TestGroup_selExprId( Me );
    }

  if ( Me.is_present_objective())
    {
      if ( pre_TestGroup_objective ) 
        pre_TestGroup_objective( Me );
      if ( trav_Objective ) 
        trav_Objective( Me.objective() );
      if ( post_TestGroup_objective ) 
        post_TestGroup_objective( Me );
    }

  if ( pre_TestGroup_testGroupOrTestCaseList ) 
    pre_TestGroup_testGroupOrTestCaseList( Me );
  if ( trav_TestGroupOrTestCaseList ) 
    trav_TestGroupOrTestCaseList( Me.testGroupOrTestCaseList() );
  if ( post_TestGroup_testGroupOrTestCaseList ) 
    post_TestGroup_testGroupOrTestCaseList( Me );

  if ( post_TestGroup ) 
    post_TestGroup( Me );
}


void default_trav_CompactTestGroup( const CompactTestGroup& Me )
{
  if ( pre_CompactTestGroup ) 
    pre_CompactTestGroup( Me );

  if ( Me.is_present_testGroupId())
    {
      if ( pre_CompactTestGroup_testGroupId ) 
        pre_CompactTestGroup_testGroupId( Me );
      if ( trav_TestGroupId ) 
        trav_TestGroupId( Me.testGroupId() );
      if ( post_CompactTestGroup_testGroupId ) 
        post_CompactTestGroup_testGroupId( Me );
    }

  if ( Me.is_present_defaultsRef())
    {
      if ( pre_CompactTestGroup_defaultsRef ) 
        pre_CompactTestGroup_defaultsRef( Me );
      if ( trav_DefaultsRef ) 
        trav_DefaultsRef( Me.defaultsRef() );
      if ( post_CompactTestGroup_defaultsRef ) 
        post_CompactTestGroup_defaultsRef( Me );
    }

  if ( Me.is_present_selExprId())
    {
      if ( pre_CompactTestGroup_selExprId ) 
        pre_CompactTestGroup_selExprId( Me );
      if ( trav_SelExprId ) 
        trav_SelExprId( Me.selExprId() );
      if ( post_CompactTestGroup_selExprId ) 
        post_CompactTestGroup_selExprId( Me );
    }

  if ( Me.is_present_objective())
    {
      if ( pre_CompactTestGroup_objective ) 
        pre_CompactTestGroup_objective( Me );
      if ( trav_Objective ) 
        trav_Objective( Me.objective() );
      if ( post_CompactTestGroup_objective ) 
        post_CompactTestGroup_objective( Me );
    }

  if ( pre_CompactTestGroup_compactTestCaseList ) 
    pre_CompactTestGroup_compactTestCaseList( Me );
  if ( trav_CompactTestCaseList ) 
    trav_CompactTestCaseList( Me.compactTestCaseList() );
  if ( post_CompactTestGroup_compactTestCaseList ) 
    post_CompactTestGroup_compactTestCaseList( Me );

  if ( post_CompactTestGroup ) 
    post_CompactTestGroup( Me );
}


void default_trav_CompactTestCaseList( const CompactTestCaseList& Me )
{
  if ( pre_CompactTestCaseList ) 
    pre_CompactTestCaseList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CompactTestCaseList_compactTestCase ) 
        pre_CompactTestCaseList_compactTestCase( Me, i );
      if ( trav_CompactTestCase ) 
        trav_CompactTestCase( Me.compactTestCase( i ) );
      if ( post_CompactTestCaseList_compactTestCase ) 
        post_CompactTestCaseList_compactTestCase( Me, i );
  }

  if ( post_CompactTestCaseList ) 
    post_CompactTestCaseList( Me );
}


void default_trav_CompactTestCase( const CompactTestCase& Me )
{
  if ( pre_CompactTestCase ) 
    pre_CompactTestCase( Me );

  if ( Me.is_present_testCaseId())
    {
      if ( pre_CompactTestCase_testCaseId ) 
        pre_CompactTestCase_testCaseId( Me );
      if ( trav_TestCaseId ) 
        trav_TestCaseId( Me.testCaseId() );
      if ( post_CompactTestCase_testCaseId ) 
        post_CompactTestCase_testCaseId( Me );
    }

  if ( Me.is_present_testPurpose())
    {
      if ( pre_CompactTestCase_testPurpose ) 
        pre_CompactTestCase_testPurpose( Me );
      if ( trav_TestPurpose ) 
        trav_TestPurpose( Me.testPurpose() );
      if ( post_CompactTestCase_testPurpose ) 
        post_CompactTestCase_testPurpose( Me );
    }

  if ( Me.is_present_testStepAttachment())
    {
      if ( pre_CompactTestCase_testStepAttachment ) 
        pre_CompactTestCase_testStepAttachment( Me );
      if ( trav_TestStepAttachment ) 
        trav_TestStepAttachment( Me.testStepAttachment() );
      if ( post_CompactTestCase_testStepAttachment ) 
        post_CompactTestCase_testStepAttachment( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_CompactTestCase_comment ) 
        pre_CompactTestCase_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_CompactTestCase_comment ) 
        post_CompactTestCase_comment( Me );
    }

  if ( Me.is_present_selExprId())
    {
      if ( pre_CompactTestCase_selExprId ) 
        pre_CompactTestCase_selExprId( Me );
      if ( trav_SelExprId ) 
        trav_SelExprId( Me.selExprId() );
      if ( post_CompactTestCase_selExprId ) 
        post_CompactTestCase_selExprId( Me );
    }

  if ( Me.is_present_description())
    {
      if ( pre_CompactTestCase_description ) 
        pre_CompactTestCase_description( Me );
      if ( trav_Description ) 
        trav_Description( Me.description() );
      if ( post_CompactTestCase_description ) 
        post_CompactTestCase_description( Me );
    }

  if ( post_CompactTestCase ) 
    post_CompactTestCase( Me );
}


void default_trav_TestStepAttachment( const TestStepAttachment& Me )
{
  if ( pre_TestStepAttachment ) 
    pre_TestStepAttachment( Me );

  if ( pre_TestStepAttachment_attach ) 
    pre_TestStepAttachment_attach( Me );
  if ( trav_Attach ) 
    trav_Attach( Me.attach() );
  if ( post_TestStepAttachment_attach ) 
    post_TestStepAttachment_attach( Me );

  if ( post_TestStepAttachment ) 
    post_TestStepAttachment( Me );
}


void default_trav_TestCase( const TestCase& Me )
{
  if ( pre_TestCase ) 
    pre_TestCase( Me );

  if ( Me.is_present_testCaseId())
    {
      if ( pre_TestCase_testCaseId ) 
        pre_TestCase_testCaseId( Me );
      if ( trav_TestCaseId ) 
        trav_TestCaseId( Me.testCaseId() );
      if ( post_TestCase_testCaseId ) 
        post_TestCase_testCaseId( Me );
    }

  if ( Me.is_present_testGroupRef())
    {
      if ( pre_TestCase_testGroupRef ) 
        pre_TestCase_testGroupRef( Me );
      if ( trav_TestGroupRef ) 
        trav_TestGroupRef( Me.testGroupRef() );
      if ( post_TestCase_testGroupRef ) 
        post_TestCase_testGroupRef( Me );
    }

  if ( Me.is_present_testPurpose())
    {
      if ( pre_TestCase_testPurpose ) 
        pre_TestCase_testPurpose( Me );
      if ( trav_TestPurpose ) 
        trav_TestPurpose( Me.testPurpose() );
      if ( post_TestCase_testPurpose ) 
        post_TestCase_testPurpose( Me );
    }

  if ( Me.is_present_configuration())
    {
      if ( pre_TestCase_configuration ) 
        pre_TestCase_configuration( Me );
      if ( trav_Configuration ) 
        trav_Configuration( Me.configuration() );
      if ( post_TestCase_configuration ) 
        post_TestCase_configuration( Me );
    }

  if ( Me.is_present_defaultsRef())
    {
      if ( pre_TestCase_defaultsRef ) 
        pre_TestCase_defaultsRef( Me );
      if ( trav_DefaultsRef ) 
        trav_DefaultsRef( Me.defaultsRef() );
      if ( post_TestCase_defaultsRef ) 
        post_TestCase_defaultsRef( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TestCase_comment ) 
        pre_TestCase_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TestCase_comment ) 
        post_TestCase_comment( Me );
    }

  if ( Me.is_present_selExprId())
    {
      if ( pre_TestCase_selExprId ) 
        pre_TestCase_selExprId( Me );
      if ( trav_SelExprId ) 
        trav_SelExprId( Me.selExprId() );
      if ( post_TestCase_selExprId ) 
        post_TestCase_selExprId( Me );
    }

  if ( Me.is_present_description())
    {
      if ( pre_TestCase_description ) 
        pre_TestCase_description( Me );
      if ( trav_Description ) 
        trav_Description( Me.description() );
      if ( post_TestCase_description ) 
        post_TestCase_description( Me );
    }

  if ( pre_TestCase_behaviourDescription ) 
    pre_TestCase_behaviourDescription( Me );
  if ( trav_BehaviourDescription ) 
    trav_BehaviourDescription( Me.behaviourDescription() );
  if ( post_TestCase_behaviourDescription ) 
    post_TestCase_behaviourDescription( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TestCase_detailedComment ) 
        pre_TestCase_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TestCase_detailedComment ) 
        post_TestCase_detailedComment( Me );
    }

  if ( post_TestCase ) 
    post_TestCase( Me );
}


void default_trav_TestCaseId( const TestCaseId& Me )
{
  if ( pre_TestCaseId ) 
    pre_TestCaseId( Me );

  if ( pre_TestCaseId_testCaseIdentifier ) 
    pre_TestCaseId_testCaseIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.testCaseIdentifier() );
  if ( post_TestCaseId_testCaseIdentifier ) 
    post_TestCaseId_testCaseIdentifier( Me );

  if ( post_TestCaseId ) 
    post_TestCaseId( Me );
}


void default_trav_TestGroupRef( const TestGroupRef& Me )
{
  if ( pre_TestGroupRef ) 
    pre_TestGroupRef( Me );

  if ( pre_TestGroupRef_testGroupReference ) 
    pre_TestGroupRef_testGroupReference( Me );
  if ( trav_TestGroupReference ) 
    trav_TestGroupReference( Me.testGroupReference() );
  if ( post_TestGroupRef_testGroupReference ) 
    post_TestGroupRef_testGroupReference( Me );

  if ( post_TestGroupRef ) 
    post_TestGroupRef( Me );
}


void default_trav_TestPurpose( const TestPurpose& Me )
{
  if ( pre_TestPurpose ) 
    pre_TestPurpose( Me );

  if ( post_TestPurpose ) 
    post_TestPurpose( Me );
}


void default_trav_Objective( const Objective& Me )
{
  if ( pre_Objective ) 
    pre_Objective( Me );

  if ( post_Objective ) 
    post_Objective( Me );
}


void default_trav_Description( const Description& Me )
{
  if ( pre_Description ) 
    pre_Description( Me );

  if ( post_Description ) 
    post_Description( Me );
}


void default_trav_Configuration( const Configuration& Me )
{
  if ( pre_Configuration ) 
    pre_Configuration( Me );

  if ( pre_Configuration_tcompConfigIdentifier ) 
    pre_Configuration_tcompConfigIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tcompConfigIdentifier() );
  if ( post_Configuration_tcompConfigIdentifier ) 
    post_Configuration_tcompConfigIdentifier( Me );

  if ( post_Configuration ) 
    post_Configuration( Me );
}


void default_trav_SelExprId( const SelExprId& Me )
{
  if ( pre_SelExprId ) 
    pre_SelExprId( Me );

  if ( pre_SelExprId_selectExprIdentifier ) 
    pre_SelExprId_selectExprIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.selectExprIdentifier() );
  if ( post_SelExprId_selectExprIdentifier ) 
    post_SelExprId_selectExprIdentifier( Me );

  if ( post_SelExprId ) 
    post_SelExprId( Me );
}


void default_trav_DefaultsRef( const DefaultsRef& Me )
{
  if ( pre_DefaultsRef ) 
    pre_DefaultsRef( Me );

  if ( pre_DefaultsRef_defaultRefList ) 
    pre_DefaultsRef_defaultRefList( Me );
  if ( trav_DefaultRefList ) 
    trav_DefaultRefList( Me.defaultRefList() );
  if ( post_DefaultsRef_defaultRefList ) 
    post_DefaultsRef_defaultRefList( Me );

  if ( post_DefaultsRef ) 
    post_DefaultsRef( Me );
}


void default_trav_DefaultRefList( const DefaultRefList& Me )
{
  if ( pre_DefaultRefList ) 
    pre_DefaultRefList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_DefaultRefList_defaultReference ) 
        pre_DefaultRefList_defaultReference( Me, i );
      if ( trav_DefaultReference ) 
        trav_DefaultReference( Me.defaultReference( i ) );
      if ( post_DefaultRefList_defaultReference ) 
        post_DefaultRefList_defaultReference( Me, i );
  }

  if ( post_DefaultRefList ) 
    post_DefaultRefList( Me );
}


void default_trav_DefaultReference( const DefaultReference& Me )
{
  if ( pre_DefaultReference ) 
    pre_DefaultReference( Me );

  if ( pre_DefaultReference_defaultIdentifier ) 
    pre_DefaultReference_defaultIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.defaultIdentifier() );
  if ( post_DefaultReference_defaultIdentifier ) 
    post_DefaultReference_defaultIdentifier( Me );

  if ( pre_DefaultReference_actualParList ) 
    pre_DefaultReference_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_DefaultReference_actualParList ) 
    post_DefaultReference_actualParList( Me );

  if ( post_DefaultReference ) 
    post_DefaultReference( Me );
}


void default_trav_BehaviourDescription( const BehaviourDescription& Me )
{
  if ( pre_BehaviourDescription ) 
    pre_BehaviourDescription( Me );

  if ( pre_BehaviourDescription_rootTree ) 
    pre_BehaviourDescription_rootTree( Me );
  if ( trav_RootTree ) 
    trav_RootTree( Me.rootTree() );
  if ( post_BehaviourDescription_rootTree ) 
    post_BehaviourDescription_rootTree( Me );

  if ( pre_BehaviourDescription_localTreeList ) 
    pre_BehaviourDescription_localTreeList( Me );
  if ( trav_LocalTreeList ) 
    trav_LocalTreeList( Me.localTreeList() );
  if ( post_BehaviourDescription_localTreeList ) 
    post_BehaviourDescription_localTreeList( Me );

  if ( post_BehaviourDescription ) 
    post_BehaviourDescription( Me );
}


void default_trav_RootTree( const RootTree& Me )
{
  if ( pre_RootTree ) 
    pre_RootTree( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_RootTree_behaviourLine ) 
        pre_RootTree_behaviourLine( Me, i );
      if ( trav_BehaviourLine ) 
        trav_BehaviourLine( Me.behaviourLine( i ) );
      if ( post_RootTree_behaviourLine ) 
        post_RootTree_behaviourLine( Me, i );
  }

  if ( post_RootTree ) 
    post_RootTree( Me );
}


void default_trav_BehaviourLineList( const BehaviourLineList& Me )
{
  if ( pre_BehaviourLineList ) 
    pre_BehaviourLineList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_BehaviourLineList_behaviourLine ) 
        pre_BehaviourLineList_behaviourLine( Me, i );
      if ( trav_BehaviourLine ) 
        trav_BehaviourLine( Me.behaviourLine( i ) );
      if ( post_BehaviourLineList_behaviourLine ) 
        post_BehaviourLineList_behaviourLine( Me, i );
  }

  if ( post_BehaviourLineList ) 
    post_BehaviourLineList( Me );
}


void default_trav_Children( const Children& Me )
{
  if ( pre_Children ) 
    pre_Children( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_Children_behaviourLine ) 
        pre_Children_behaviourLine( Me, i );
      if ( trav_BehaviourLine ) 
        trav_BehaviourLine( Me.behaviourLine( i ) );
      if ( post_Children_behaviourLine ) 
        post_Children_behaviourLine( Me, i );
  }

  if ( post_Children ) 
    post_Children( Me );
}


void default_trav_BehaviourLine( const BehaviourLine& Me )
{
  if ( pre_BehaviourLine ) 
    pre_BehaviourLine( Me );

  if ( Me.is_present_lineNumber())
    {
      if ( pre_BehaviourLine_lineNumber ) 
        pre_BehaviourLine_lineNumber( Me );
      if ( trav_LineNumber ) 
        trav_LineNumber( Me.lineNumber() );
      if ( post_BehaviourLine_lineNumber ) 
        post_BehaviourLine_lineNumber( Me );
    }

  if ( Me.is_present_labelId())
    {
      if ( pre_BehaviourLine_labelId ) 
        pre_BehaviourLine_labelId( Me );
      if ( trav_LabelId ) 
        trav_LabelId( Me.labelId() );
      if ( post_BehaviourLine_labelId ) 
        post_BehaviourLine_labelId( Me );
    }

  if ( Me.is_present_line())
    {
      if ( pre_BehaviourLine_line ) 
        pre_BehaviourLine_line( Me );
      if ( trav_Line ) 
        trav_Line( Me.line() );
      if ( post_BehaviourLine_line ) 
        post_BehaviourLine_line( Me );
    }

  if ( Me.is_present_cref())
    {
      if ( pre_BehaviourLine_cref ) 
        pre_BehaviourLine_cref( Me );
      if ( trav_Cref ) 
        trav_Cref( Me.cref() );
      if ( post_BehaviourLine_cref ) 
        post_BehaviourLine_cref( Me );
    }

  if ( Me.is_present_verdictId())
    {
      if ( pre_BehaviourLine_verdictId ) 
        pre_BehaviourLine_verdictId( Me );
      if ( trav_VerdictId ) 
        trav_VerdictId( Me.verdictId() );
      if ( post_BehaviourLine_verdictId ) 
        post_BehaviourLine_verdictId( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_BehaviourLine_comment ) 
        pre_BehaviourLine_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_BehaviourLine_comment ) 
        post_BehaviourLine_comment( Me );
    }

  if ( pre_BehaviourLine_children ) 
    pre_BehaviourLine_children( Me );
  if ( trav_Children ) 
    trav_Children( Me.children() );
  if ( post_BehaviourLine_children ) 
    post_BehaviourLine_children( Me );

  if ( post_BehaviourLine ) 
    post_BehaviourLine( Me );
}


void default_trav_LineNumber( const LineNumber& Me )
{
  if ( pre_LineNumber ) 
    pre_LineNumber( Me );

  if ( pre_LineNumber_number ) 
    pre_LineNumber_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_LineNumber_number ) 
    post_LineNumber_number( Me );

  if ( post_LineNumber ) 
    post_LineNumber( Me );
}


void default_trav_LabelId( const LabelId& Me )
{
  if ( pre_LabelId ) 
    pre_LabelId( Me );

  if ( pre_LabelId_label ) 
    pre_LabelId_label( Me );
  if ( trav_Label ) 
    trav_Label( Me.label() );
  if ( post_LabelId_label ) 
    post_LabelId_label( Me );

  if ( post_LabelId ) 
    post_LabelId( Me );
}


void default_trav_Label( const Label& Me )
{
  if ( pre_Label ) 
    pre_Label( Me );

  if ( pre_Label_identifier ) 
    pre_Label_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_Label_identifier ) 
    post_Label_identifier( Me );

  if ( post_Label ) 
    post_Label( Me );
}


void default_trav_Line( const Line& Me )
{
  if ( pre_Line ) 
    pre_Line( Me );

  if ( pre_Line_indentation ) 
    pre_Line_indentation( Me );
  if ( trav_Indentation ) 
    trav_Indentation( Me.indentation() );
  if ( post_Line_indentation ) 
    post_Line_indentation( Me );

  if ( pre_Line_statementLine ) 
    pre_Line_statementLine( Me );
  if ( trav_StatementLine ) 
    trav_StatementLine( Me.statementLine() );
  if ( post_Line_statementLine ) 
    post_Line_statementLine( Me );

  if ( post_Line ) 
    post_Line( Me );
}


void default_trav_Indentation( const Indentation& Me )
{
  if ( pre_Indentation ) 
    pre_Indentation( Me );

  if ( pre_Indentation_number ) 
    pre_Indentation_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_Indentation_number ) 
    post_Indentation_number( Me );

  if ( post_Indentation ) 
    post_Indentation( Me );
}


void default_trav_VerdictId( const VerdictId& Me )
{
  if ( pre_VerdictId ) 
    pre_VerdictId( Me );

  if ( pre_VerdictId_verdict ) 
    pre_VerdictId_verdict( Me );
  if ( trav_Verdict ) 
    trav_Verdict( Me.verdict() );
  if ( post_VerdictId_verdict ) 
    post_VerdictId_verdict( Me );

  if ( post_VerdictId ) 
    post_VerdictId( Me );
}


void default_trav_Verdict( const Verdict& Me )
{
  if ( pre_Verdict ) 
    pre_Verdict( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Pass:
      if ( pre_Verdict_pass ) 
        pre_Verdict_pass( Me );
      if ( trav_Pass ) 
        trav_Pass( Me.pass() );
      if ( post_Verdict_pass ) 
        post_Verdict_pass( Me );
      break;

    case Choices::c_Fail:
      if ( pre_Verdict_fail ) 
        pre_Verdict_fail( Me );
      if ( trav_Fail ) 
        trav_Fail( Me.fail() );
      if ( post_Verdict_fail ) 
        post_Verdict_fail( Me );
      break;

    case Choices::c_Inconclusive:
      if ( pre_Verdict_inconclusive ) 
        pre_Verdict_inconclusive( Me );
      if ( trav_Inconclusive ) 
        trav_Inconclusive( Me.inconclusive() );
      if ( post_Verdict_inconclusive ) 
        post_Verdict_inconclusive( Me );
      break;

    case Choices::c_Result:
      if ( pre_Verdict_result ) 
        pre_Verdict_result( Me );
      if ( trav_Result ) 
        trav_Result( Me.result() );
      if ( post_Verdict_result ) 
        post_Verdict_result( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Verdict: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Verdict ) 
    post_Verdict( Me );
}


void default_trav_Pass( const Pass& Me )
{
  if ( pre_Pass ) 
    pre_Pass( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PASS:
      if ( pre_Pass_pass ) 
        pre_Pass_pass( Me );
      if ( trav_PASS ) 
        trav_PASS( Me.pass() );
      if ( post_Pass_pass ) 
        post_Pass_pass( Me );
      break;

    case Choices::c_PreliminaryPASS:
      if ( pre_Pass_preliminaryPASS ) 
        pre_Pass_preliminaryPASS( Me );
      if ( trav_PreliminaryPASS ) 
        trav_PreliminaryPASS( Me.preliminaryPASS() );
      if ( post_Pass_preliminaryPASS ) 
        post_Pass_preliminaryPASS( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Pass: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Pass ) 
    post_Pass( Me );
}


void default_trav_Fail( const Fail& Me )
{
  if ( pre_Fail ) 
    pre_Fail( Me );

  switch ( Me.choice() )
    {
    case Choices::c_FAIL:
      if ( pre_Fail_fail ) 
        pre_Fail_fail( Me );
      if ( trav_FAIL ) 
        trav_FAIL( Me.fail() );
      if ( post_Fail_fail ) 
        post_Fail_fail( Me );
      break;

    case Choices::c_PreliminaryFAIL:
      if ( pre_Fail_preliminaryFAIL ) 
        pre_Fail_preliminaryFAIL( Me );
      if ( trav_PreliminaryFAIL ) 
        trav_PreliminaryFAIL( Me.preliminaryFAIL() );
      if ( post_Fail_preliminaryFAIL ) 
        post_Fail_preliminaryFAIL( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Fail: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Fail ) 
    post_Fail( Me );
}


void default_trav_Inconclusive( const Inconclusive& Me )
{
  if ( pre_Inconclusive ) 
    pre_Inconclusive( Me );

  switch ( Me.choice() )
    {
    case Choices::c_INCONC:
      if ( pre_Inconclusive_inconc ) 
        pre_Inconclusive_inconc( Me );
      if ( trav_INCONC ) 
        trav_INCONC( Me.inconc() );
      if ( post_Inconclusive_inconc ) 
        post_Inconclusive_inconc( Me );
      break;

    case Choices::c_PreliminaryINCONC:
      if ( pre_Inconclusive_preliminaryINCONC ) 
        pre_Inconclusive_preliminaryINCONC( Me );
      if ( trav_PreliminaryINCONC ) 
        trav_PreliminaryINCONC( Me.preliminaryINCONC() );
      if ( post_Inconclusive_preliminaryINCONC ) 
        post_Inconclusive_preliminaryINCONC( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Inconclusive: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Inconclusive ) 
    post_Inconclusive( Me );
}


void default_trav_Result( const Result& Me )
{
  if ( pre_Result ) 
    pre_Result( Me );

  if ( pre_Result_r ) 
    pre_Result_r( Me );
  if ( trav_R ) 
    trav_R( Me.r() );
  if ( post_Result_r ) 
    post_Result_r( Me );

  if ( post_Result ) 
    post_Result( Me );
}


void default_trav_StatementLine( const StatementLine& Me )
{
  if ( pre_StatementLine ) 
    pre_StatementLine( Me );

  switch ( Me.choice() )
    {
    case Choices::c_EventStatement:
      if ( pre_StatementLine_eventStatement ) 
        pre_StatementLine_eventStatement( Me );
      if ( trav_EventStatement ) 
        trav_EventStatement( Me.eventStatement() );
      if ( post_StatementLine_eventStatement ) 
        post_StatementLine_eventStatement( Me );
      break;

    case Choices::c_Construct:
      if ( pre_StatementLine_construct ) 
        pre_StatementLine_construct( Me );
      if ( trav_Construct ) 
        trav_Construct( Me.construct() );
      if ( post_StatementLine_construct ) 
        post_StatementLine_construct( Me );
      break;

    case Choices::c_ImplicitSend:
      if ( pre_StatementLine_implicitSend ) 
        pre_StatementLine_implicitSend( Me );
      if ( trav_ImplicitSend ) 
        trav_ImplicitSend( Me.implicitSend() );
      if ( post_StatementLine_implicitSend ) 
        post_StatementLine_implicitSend( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node StatementLine: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_StatementLine ) 
    post_StatementLine( Me );
}


void default_trav_EventStatement( const EventStatement& Me )
{
  if ( pre_EventStatement ) 
    pre_EventStatement( Me );

  if ( Me.is_present_event())
    {
      if ( pre_EventStatement_event ) 
        pre_EventStatement_event( Me );
      if ( trav_Event ) 
        trav_Event( Me.event() );
      if ( post_EventStatement_event ) 
        post_EventStatement_event( Me );
    }

  if ( Me.is_present_qualifier())
    {
      if ( pre_EventStatement_qualifier ) 
        pre_EventStatement_qualifier( Me );
      if ( trav_Qualifier ) 
        trav_Qualifier( Me.qualifier() );
      if ( post_EventStatement_qualifier ) 
        post_EventStatement_qualifier( Me );
    }

  if ( pre_EventStatement_assignmentList ) 
    pre_EventStatement_assignmentList( Me );
  if ( trav_AssignmentList ) 
    trav_AssignmentList( Me.assignmentList() );
  if ( post_EventStatement_assignmentList ) 
    post_EventStatement_assignmentList( Me );

  if ( pre_EventStatement_timerOps ) 
    pre_EventStatement_timerOps( Me );
  if ( trav_TimerOps ) 
    trav_TimerOps( Me.timerOps() );
  if ( post_EventStatement_timerOps ) 
    post_EventStatement_timerOps( Me );

  if ( post_EventStatement ) 
    post_EventStatement( Me );
}


void default_trav_Event( const Event& Me )
{
  if ( pre_Event ) 
    pre_Event( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Send:
      if ( pre_Event_send ) 
        pre_Event_send( Me );
      if ( trav_Send ) 
        trav_Send( Me.send() );
      if ( post_Event_send ) 
        post_Event_send( Me );
      break;

    case Choices::c_Receive:
      if ( pre_Event_receive ) 
        pre_Event_receive( Me );
      if ( trav_Receive ) 
        trav_Receive( Me.receive() );
      if ( post_Event_receive ) 
        post_Event_receive( Me );
      break;

    case Choices::c_Otherwise:
      if ( pre_Event_otherwise ) 
        pre_Event_otherwise( Me );
      if ( trav_Otherwise ) 
        trav_Otherwise( Me.otherwise() );
      if ( post_Event_otherwise ) 
        post_Event_otherwise( Me );
      break;

    case Choices::c_Timeout:
      if ( pre_Event_timeout ) 
        pre_Event_timeout( Me );
      if ( trav_Timeout ) 
        trav_Timeout( Me.timeout() );
      if ( post_Event_timeout ) 
        post_Event_timeout( Me );
      break;

    case Choices::c_Done:
      if ( pre_Event_done ) 
        pre_Event_done( Me );
      if ( trav_Done ) 
        trav_Done( Me.done() );
      if ( post_Event_done ) 
        post_Event_done( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Event: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Event ) 
    post_Event( Me );
}


void default_trav_Send( const Send& Me )
{
  if ( pre_Send ) 
    pre_Send( Me );

  if ( Me.is_present_identifier1())
    {
      if ( pre_Send_identifier1 ) 
        pre_Send_identifier1( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier1() );
      if ( post_Send_identifier1 ) 
        post_Send_identifier1( Me );
    }

  if ( pre_Send_identifier2 ) 
    pre_Send_identifier2( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier2() );
  if ( post_Send_identifier2 ) 
    post_Send_identifier2( Me );

  if ( post_Send ) 
    post_Send( Me );
}


void default_trav_ImplicitSend( const ImplicitSend& Me )
{
  if ( pre_ImplicitSend ) 
    pre_ImplicitSend( Me );

  if ( pre_ImplicitSend_identifier ) 
    pre_ImplicitSend_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_ImplicitSend_identifier ) 
    post_ImplicitSend_identifier( Me );

  if ( post_ImplicitSend ) 
    post_ImplicitSend( Me );
}


void default_trav_Receive( const Receive& Me )
{
  if ( pre_Receive ) 
    pre_Receive( Me );

  if ( Me.is_present_identifier1())
    {
      if ( pre_Receive_identifier1 ) 
        pre_Receive_identifier1( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier1() );
      if ( post_Receive_identifier1 ) 
        post_Receive_identifier1( Me );
    }

  if ( pre_Receive_identifier2 ) 
    pre_Receive_identifier2( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier2() );
  if ( post_Receive_identifier2 ) 
    post_Receive_identifier2( Me );

  if ( post_Receive ) 
    post_Receive( Me );
}


void default_trav_Otherwise( const Otherwise& Me )
{
  if ( pre_Otherwise ) 
    pre_Otherwise( Me );

  if ( Me.is_present_identifier())
    {
      if ( pre_Otherwise_identifier ) 
        pre_Otherwise_identifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier() );
      if ( post_Otherwise_identifier ) 
        post_Otherwise_identifier( Me );
    }

  if ( post_Otherwise ) 
    post_Otherwise( Me );
}


void default_trav_Timeout( const Timeout& Me )
{
  if ( pre_Timeout ) 
    pre_Timeout( Me );

  if ( Me.is_present_timerIdentifier())
    {
      if ( pre_Timeout_timerIdentifier ) 
        pre_Timeout_timerIdentifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.timerIdentifier() );
      if ( post_Timeout_timerIdentifier ) 
        post_Timeout_timerIdentifier( Me );
    }

  if ( post_Timeout ) 
    post_Timeout( Me );
}


void default_trav_Done( const Done& Me )
{
  if ( pre_Done ) 
    pre_Done( Me );

  if ( pre_Done_tcompIdList ) 
    pre_Done_tcompIdList( Me );
  if ( trav_TCompIdList ) 
    trav_TCompIdList( Me.tcompIdList() );
  if ( post_Done_tcompIdList ) 
    post_Done_tcompIdList( Me );

  if ( post_Done ) 
    post_Done( Me );
}


void default_trav_TCompIdList( const TCompIdList& Me )
{
  if ( pre_TCompIdList ) 
    pre_TCompIdList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TCompIdList_tCompIdentifier ) 
        pre_TCompIdList_tCompIdentifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.tCompIdentifier( i ) );
      if ( post_TCompIdList_tCompIdentifier ) 
        post_TCompIdList_tCompIdentifier( Me, i );
  }

  if ( post_TCompIdList ) 
    post_TCompIdList( Me );
}


void default_trav_AssignmentList( const AssignmentList& Me )
{
  if ( pre_AssignmentList ) 
    pre_AssignmentList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_AssignmentList_assignment ) 
        pre_AssignmentList_assignment( Me, i );
      if ( trav_Assignment ) 
        trav_Assignment( Me.assignment( i ) );
      if ( post_AssignmentList_assignment ) 
        post_AssignmentList_assignment( Me, i );
  }

  if ( post_AssignmentList ) 
    post_AssignmentList( Me );
}


void default_trav_Assignment( const Assignment& Me )
{
  if ( pre_Assignment ) 
    pre_Assignment( Me );

  if ( pre_Assignment_dataObjectReference ) 
    pre_Assignment_dataObjectReference( Me );
  if ( trav_DataObjectReference ) 
    trav_DataObjectReference( Me.dataObjectReference() );
  if ( post_Assignment_dataObjectReference ) 
    post_Assignment_dataObjectReference( Me );

  if ( pre_Assignment_expression ) 
    pre_Assignment_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_Assignment_expression ) 
    post_Assignment_expression( Me );

  if ( post_Assignment ) 
    post_Assignment( Me );
}


void default_trav_Qualifier( const Qualifier& Me )
{
  if ( pre_Qualifier ) 
    pre_Qualifier( Me );

  if ( pre_Qualifier_expression ) 
    pre_Qualifier_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_Qualifier_expression ) 
    post_Qualifier_expression( Me );

  if ( post_Qualifier ) 
    post_Qualifier( Me );
}


void default_trav_TimerOps( const TimerOps& Me )
{
  if ( pre_TimerOps ) 
    pre_TimerOps( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TimerOps_timerOp ) 
        pre_TimerOps_timerOp( Me, i );
      if ( trav_TimerOp ) 
        trav_TimerOp( Me.timerOp( i ) );
      if ( post_TimerOps_timerOp ) 
        post_TimerOps_timerOp( Me, i );
  }

  if ( post_TimerOps ) 
    post_TimerOps( Me );
}


void default_trav_TimerOp( const TimerOp& Me )
{
  if ( pre_TimerOp ) 
    pre_TimerOp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_StartTimer:
      if ( pre_TimerOp_startTimer ) 
        pre_TimerOp_startTimer( Me );
      if ( trav_StartTimer ) 
        trav_StartTimer( Me.startTimer() );
      if ( post_TimerOp_startTimer ) 
        post_TimerOp_startTimer( Me );
      break;

    case Choices::c_CancelTimer:
      if ( pre_TimerOp_cancelTimer ) 
        pre_TimerOp_cancelTimer( Me );
      if ( trav_CancelTimer ) 
        trav_CancelTimer( Me.cancelTimer() );
      if ( post_TimerOp_cancelTimer ) 
        post_TimerOp_cancelTimer( Me );
      break;

    case Choices::c_ReadTimer:
      if ( pre_TimerOp_readTimer ) 
        pre_TimerOp_readTimer( Me );
      if ( trav_ReadTimer ) 
        trav_ReadTimer( Me.readTimer() );
      if ( post_TimerOp_readTimer ) 
        post_TimerOp_readTimer( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TimerOp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TimerOp ) 
    post_TimerOp( Me );
}


void default_trav_StartTimer( const StartTimer& Me )
{
  if ( pre_StartTimer ) 
    pre_StartTimer( Me );

  if ( pre_StartTimer_timerIdentifier ) 
    pre_StartTimer_timerIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.timerIdentifier() );
  if ( post_StartTimer_timerIdentifier ) 
    post_StartTimer_timerIdentifier( Me );

  if ( Me.is_present_timerValue())
    {
      if ( pre_StartTimer_timerValue ) 
        pre_StartTimer_timerValue( Me );
      if ( trav_TimerValue ) 
        trav_TimerValue( Me.timerValue() );
      if ( post_StartTimer_timerValue ) 
        post_StartTimer_timerValue( Me );
    }

  if ( post_StartTimer ) 
    post_StartTimer( Me );
}


void default_trav_CancelTimer( const CancelTimer& Me )
{
  if ( pre_CancelTimer ) 
    pre_CancelTimer( Me );

  if ( Me.is_present_timerIdentifier())
    {
      if ( pre_CancelTimer_timerIdentifier ) 
        pre_CancelTimer_timerIdentifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.timerIdentifier() );
      if ( post_CancelTimer_timerIdentifier ) 
        post_CancelTimer_timerIdentifier( Me );
    }

  if ( post_CancelTimer ) 
    post_CancelTimer( Me );
}


void default_trav_ReadTimer( const ReadTimer& Me )
{
  if ( pre_ReadTimer ) 
    pre_ReadTimer( Me );

  if ( pre_ReadTimer_timerIdentifier ) 
    pre_ReadTimer_timerIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.timerIdentifier() );
  if ( post_ReadTimer_timerIdentifier ) 
    post_ReadTimer_timerIdentifier( Me );

  if ( pre_ReadTimer_dataObjectReference ) 
    pre_ReadTimer_dataObjectReference( Me );
  if ( trav_DataObjectReference ) 
    trav_DataObjectReference( Me.dataObjectReference() );
  if ( post_ReadTimer_dataObjectReference ) 
    post_ReadTimer_dataObjectReference( Me );

  if ( post_ReadTimer ) 
    post_ReadTimer( Me );
}


void default_trav_TimerValue( const TimerValue& Me )
{
  if ( pre_TimerValue ) 
    pre_TimerValue( Me );

  if ( pre_TimerValue_expression ) 
    pre_TimerValue_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_TimerValue_expression ) 
    post_TimerValue_expression( Me );

  if ( post_TimerValue ) 
    post_TimerValue( Me );
}


void default_trav_Construct( const Construct& Me )
{
  if ( pre_Construct ) 
    pre_Construct( Me );

  switch ( Me.choice() )
    {
    case Choices::c_GoTo:
      if ( pre_Construct_goTo ) 
        pre_Construct_goTo( Me );
      if ( trav_GoTo ) 
        trav_GoTo( Me.goTo() );
      if ( post_Construct_goTo ) 
        post_Construct_goTo( Me );
      break;

    case Choices::c_Attach:
      if ( pre_Construct_attach ) 
        pre_Construct_attach( Me );
      if ( trav_Attach ) 
        trav_Attach( Me.attach() );
      if ( post_Construct_attach ) 
        post_Construct_attach( Me );
      break;

    case Choices::c_Repeat:
      if ( pre_Construct_repeat ) 
        pre_Construct_repeat( Me );
      if ( trav_Repeat ) 
        trav_Repeat( Me.repeat() );
      if ( post_Construct_repeat ) 
        post_Construct_repeat( Me );
      break;

    case Choices::c_RETURN_:
      if ( pre_Construct_return_ ) 
        pre_Construct_return_( Me );
      if ( trav_RETURN_ ) 
        trav_RETURN_( Me.return_() );
      if ( post_Construct_return_ ) 
        post_Construct_return_( Me );
      break;

    case Choices::c_Activate:
      if ( pre_Construct_activate ) 
        pre_Construct_activate( Me );
      if ( trav_Activate ) 
        trav_Activate( Me.activate() );
      if ( post_Construct_activate ) 
        post_Construct_activate( Me );
      break;

    case Choices::c_Create:
      if ( pre_Construct_create ) 
        pre_Construct_create( Me );
      if ( trav_Create ) 
        trav_Create( Me.create() );
      if ( post_Construct_create ) 
        post_Construct_create( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Construct: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Construct ) 
    post_Construct( Me );
}


void default_trav_GoTo( const GoTo& Me )
{
  if ( pre_GoTo ) 
    pre_GoTo( Me );

  if ( pre_GoTo_label ) 
    pre_GoTo_label( Me );
  if ( trav_Label ) 
    trav_Label( Me.label() );
  if ( post_GoTo_label ) 
    post_GoTo_label( Me );

  if ( post_GoTo ) 
    post_GoTo( Me );
}


void default_trav_Attach( const Attach& Me )
{
  if ( pre_Attach ) 
    pre_Attach( Me );

  if ( pre_Attach_treeReference ) 
    pre_Attach_treeReference( Me );
  if ( trav_TreeReference ) 
    trav_TreeReference( Me.treeReference() );
  if ( post_Attach_treeReference ) 
    post_Attach_treeReference( Me );

  if ( pre_Attach_actualParList ) 
    pre_Attach_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_Attach_actualParList ) 
    post_Attach_actualParList( Me );

  if ( post_Attach ) 
    post_Attach( Me );
}


void default_trav_TreeReference( const TreeReference& Me )
{
  if ( pre_TreeReference ) 
    pre_TreeReference( Me );

  if ( pre_TreeReference_identifier ) 
    pre_TreeReference_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_TreeReference_identifier ) 
    post_TreeReference_identifier( Me );

  if ( post_TreeReference ) 
    post_TreeReference( Me );
}


void default_trav_Repeat( const Repeat& Me )
{
  if ( pre_Repeat ) 
    pre_Repeat( Me );

  if ( pre_Repeat_attach ) 
    pre_Repeat_attach( Me );
  if ( trav_Attach ) 
    trav_Attach( Me.attach() );
  if ( post_Repeat_attach ) 
    post_Repeat_attach( Me );

  if ( pre_Repeat_qualifier ) 
    pre_Repeat_qualifier( Me );
  if ( trav_Qualifier ) 
    trav_Qualifier( Me.qualifier() );
  if ( post_Repeat_qualifier ) 
    post_Repeat_qualifier( Me );

  if ( post_Repeat ) 
    post_Repeat( Me );
}


void default_trav_Activate( const Activate& Me )
{
  if ( pre_Activate ) 
    pre_Activate( Me );

  if ( pre_Activate_defaultRefList ) 
    pre_Activate_defaultRefList( Me );
  if ( trav_DefaultRefList ) 
    trav_DefaultRefList( Me.defaultRefList() );
  if ( post_Activate_defaultRefList ) 
    post_Activate_defaultRefList( Me );

  if ( post_Activate ) 
    post_Activate( Me );
}


void default_trav_Create( const Create& Me )
{
  if ( pre_Create ) 
    pre_Create( Me );

  if ( pre_Create_createList ) 
    pre_Create_createList( Me );
  if ( trav_CreateList ) 
    trav_CreateList( Me.createList() );
  if ( post_Create_createList ) 
    post_Create_createList( Me );

  if ( post_Create ) 
    post_Create( Me );
}


void default_trav_CreateList( const CreateList& Me )
{
  if ( pre_CreateList ) 
    pre_CreateList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_CreateList_createTComp ) 
        pre_CreateList_createTComp( Me, i );
      if ( trav_CreateTComp ) 
        trav_CreateTComp( Me.createTComp( i ) );
      if ( post_CreateList_createTComp ) 
        post_CreateList_createTComp( Me, i );
  }

  if ( post_CreateList ) 
    post_CreateList( Me );
}


void default_trav_CreateTComp( const CreateTComp& Me )
{
  if ( pre_CreateTComp ) 
    pre_CreateTComp( Me );

  if ( pre_CreateTComp_tcompIdentifier ) 
    pre_CreateTComp_tcompIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.tcompIdentifier() );
  if ( post_CreateTComp_tcompIdentifier ) 
    post_CreateTComp_tcompIdentifier( Me );

  if ( pre_CreateTComp_createAttach ) 
    pre_CreateTComp_createAttach( Me );
  if ( trav_CreateAttach ) 
    trav_CreateAttach( Me.createAttach() );
  if ( post_CreateTComp_createAttach ) 
    post_CreateTComp_createAttach( Me );

  if ( post_CreateTComp ) 
    post_CreateTComp( Me );
}


void default_trav_CreateAttach( const CreateAttach& Me )
{
  if ( pre_CreateAttach ) 
    pre_CreateAttach( Me );

  if ( pre_CreateAttach_treeReference ) 
    pre_CreateAttach_treeReference( Me );
  if ( trav_TreeReference ) 
    trav_TreeReference( Me.treeReference() );
  if ( post_CreateAttach_treeReference ) 
    post_CreateAttach_treeReference( Me );

  if ( pre_CreateAttach_actualParList ) 
    pre_CreateAttach_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_CreateAttach_actualParList ) 
    post_CreateAttach_actualParList( Me );

  if ( post_CreateAttach ) 
    post_CreateAttach( Me );
}


void default_trav_Cref( const Cref& Me )
{
  if ( pre_Cref ) 
    pre_Cref( Me );

  if ( pre_Cref_constraintReference ) 
    pre_Cref_constraintReference( Me );
  if ( trav_ConstraintReference ) 
    trav_ConstraintReference( Me.constraintReference() );
  if ( post_Cref_constraintReference ) 
    post_Cref_constraintReference( Me );

  if ( post_Cref ) 
    post_Cref( Me );
}


void default_trav_ConstraintReference( const ConstraintReference& Me )
{
  if ( pre_ConstraintReference ) 
    pre_ConstraintReference( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConsRef:
      if ( pre_ConstraintReference_consRef ) 
        pre_ConstraintReference_consRef( Me );
      if ( trav_ConsRef ) 
        trav_ConsRef( Me.consRef() );
      if ( post_ConstraintReference_consRef ) 
        post_ConstraintReference_consRef( Me );
      break;

    case Choices::c_Identifier:
      if ( pre_ConstraintReference_formalParIdentifier ) 
        pre_ConstraintReference_formalParIdentifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.formalParIdentifier() );
      if ( post_ConstraintReference_formalParIdentifier ) 
        post_ConstraintReference_formalParIdentifier( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ConstraintReference: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ConstraintReference ) 
    post_ConstraintReference( Me );
}


void default_trav_ConsRef( const ConsRef& Me )
{
  if ( pre_ConsRef ) 
    pre_ConsRef( Me );

  if ( pre_ConsRef_constraintIdentifier ) 
    pre_ConsRef_constraintIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.constraintIdentifier() );
  if ( post_ConsRef_constraintIdentifier ) 
    post_ConsRef_constraintIdentifier( Me );

  if ( pre_ConsRef_actualCrefParList ) 
    pre_ConsRef_actualCrefParList( Me );
  if ( trav_ActualCrefParList ) 
    trav_ActualCrefParList( Me.actualCrefParList() );
  if ( post_ConsRef_actualCrefParList ) 
    post_ConsRef_actualCrefParList( Me );

  if ( post_ConsRef ) 
    post_ConsRef( Me );
}


void default_trav_ActualCrefParList( const ActualCrefParList& Me )
{
  if ( pre_ActualCrefParList ) 
    pre_ActualCrefParList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ActualCrefParList_constraintValueAndAttributes ) 
        pre_ActualCrefParList_constraintValueAndAttributes( Me, i );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes( i ) );
      if ( post_ActualCrefParList_constraintValueAndAttributes ) 
        post_ActualCrefParList_constraintValueAndAttributes( Me, i );
  }

  if ( post_ActualCrefParList ) 
    post_ActualCrefParList( Me );
}


void default_trav_LocalTreeList( const LocalTreeList& Me )
{
  if ( pre_LocalTreeList ) 
    pre_LocalTreeList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_LocalTreeList_localTree ) 
        pre_LocalTreeList_localTree( Me, i );
      if ( trav_LocalTree ) 
        trav_LocalTree( Me.localTree( i ) );
      if ( post_LocalTreeList_localTree ) 
        post_LocalTreeList_localTree( Me, i );
  }

  if ( post_LocalTreeList ) 
    post_LocalTreeList( Me );
}


void default_trav_LocalTree( const LocalTree& Me )
{
  if ( pre_LocalTree ) 
    pre_LocalTree( Me );

  if ( Me.is_present_header())
    {
      if ( pre_LocalTree_header ) 
        pre_LocalTree_header( Me );
      if ( trav_Header ) 
        trav_Header( Me.header() );
      if ( post_LocalTree_header ) 
        post_LocalTree_header( Me );
    }

  if ( pre_LocalTree_behaviourLineList ) 
    pre_LocalTree_behaviourLineList( Me );
  if ( trav_BehaviourLineList ) 
    trav_BehaviourLineList( Me.behaviourLineList() );
  if ( post_LocalTree_behaviourLineList ) 
    post_LocalTree_behaviourLineList( Me );

  if ( post_LocalTree ) 
    post_LocalTree( Me );
}


void default_trav_Header( const Header& Me )
{
  if ( pre_Header ) 
    pre_Header( Me );

  if ( pre_Header_treeHeader ) 
    pre_Header_treeHeader( Me );
  if ( trav_TreeHeader ) 
    trav_TreeHeader( Me.treeHeader() );
  if ( post_Header_treeHeader ) 
    post_Header_treeHeader( Me );

  if ( post_Header ) 
    post_Header( Me );
}


void default_trav_TreeHeader( const TreeHeader& Me )
{
  if ( pre_TreeHeader ) 
    pre_TreeHeader( Me );

  if ( pre_TreeHeader_treeIdentifier ) 
    pre_TreeHeader_treeIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.treeIdentifier() );
  if ( post_TreeHeader_treeIdentifier ) 
    post_TreeHeader_treeIdentifier( Me );

  if ( pre_TreeHeader_formalParList ) 
    pre_TreeHeader_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_TreeHeader_formalParList ) 
    post_TreeHeader_formalParList( Me );

  if ( post_TreeHeader ) 
    post_TreeHeader( Me );
}


void default_trav_TestStepLibrary( const TestStepLibrary& Me )
{
  if ( pre_TestStepLibrary ) 
    pre_TestStepLibrary( Me );

  if ( pre_TestStepLibrary_testStepGroupOrTestStepList ) 
    pre_TestStepLibrary_testStepGroupOrTestStepList( Me );
  if ( trav_TestStepGroupOrTestStepList ) 
    trav_TestStepGroupOrTestStepList( Me.testStepGroupOrTestStepList() );
  if ( post_TestStepLibrary_testStepGroupOrTestStepList ) 
    post_TestStepLibrary_testStepGroupOrTestStepList( Me );

  if ( post_TestStepLibrary ) 
    post_TestStepLibrary( Me );
}


void default_trav_TestStepGroupOrTestStepList( const TestStepGroupOrTestStepList& Me )
{
  if ( pre_TestStepGroupOrTestStepList ) 
    pre_TestStepGroupOrTestStepList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TestStepGroupOrTestStepList_testStepGroupOrTestStep ) 
        pre_TestStepGroupOrTestStepList_testStepGroupOrTestStep( Me, i );
      if ( trav_TestStepGroupOrTestStep ) 
        trav_TestStepGroupOrTestStep( Me.testStepGroupOrTestStep( i ) );
      if ( post_TestStepGroupOrTestStepList_testStepGroupOrTestStep ) 
        post_TestStepGroupOrTestStepList_testStepGroupOrTestStep( Me, i );
  }

  if ( post_TestStepGroupOrTestStepList ) 
    post_TestStepGroupOrTestStepList( Me );
}


void default_trav_TestStepGroupOrTestStep( const TestStepGroupOrTestStep& Me )
{
  if ( pre_TestStepGroupOrTestStep ) 
    pre_TestStepGroupOrTestStep( Me );

  switch ( Me.choice() )
    {
    case Choices::c_TestStepGroup:
      if ( pre_TestStepGroupOrTestStep_testStepGroup ) 
        pre_TestStepGroupOrTestStep_testStepGroup( Me );
      if ( trav_TestStepGroup ) 
        trav_TestStepGroup( Me.testStepGroup() );
      if ( post_TestStepGroupOrTestStep_testStepGroup ) 
        post_TestStepGroupOrTestStep_testStepGroup( Me );
      break;

    case Choices::c_TestStep:
      if ( pre_TestStepGroupOrTestStep_testStep ) 
        pre_TestStepGroupOrTestStep_testStep( Me );
      if ( trav_TestStep ) 
        trav_TestStep( Me.testStep() );
      if ( post_TestStepGroupOrTestStep_testStep ) 
        post_TestStepGroupOrTestStep_testStep( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TestStepGroupOrTestStep: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TestStepGroupOrTestStep ) 
    post_TestStepGroupOrTestStep( Me );
}


void default_trav_TestStepGroup( const TestStepGroup& Me )
{
  if ( pre_TestStepGroup ) 
    pre_TestStepGroup( Me );

  if ( Me.is_present_testStepGroupId())
    {
      if ( pre_TestStepGroup_testStepGroupId ) 
        pre_TestStepGroup_testStepGroupId( Me );
      if ( trav_TestStepGroupId ) 
        trav_TestStepGroupId( Me.testStepGroupId() );
      if ( post_TestStepGroup_testStepGroupId ) 
        post_TestStepGroup_testStepGroupId( Me );
    }

  if ( pre_TestStepGroup_testStepGroupOrTestStepList ) 
    pre_TestStepGroup_testStepGroupOrTestStepList( Me );
  if ( trav_TestStepGroupOrTestStepList ) 
    trav_TestStepGroupOrTestStepList( Me.testStepGroupOrTestStepList() );
  if ( post_TestStepGroup_testStepGroupOrTestStepList ) 
    post_TestStepGroup_testStepGroupOrTestStepList( Me );

  if ( post_TestStepGroup ) 
    post_TestStepGroup( Me );
}


void default_trav_TestGroupId( const TestGroupId& Me )
{
  if ( pre_TestGroupId ) 
    pre_TestGroupId( Me );

  if ( pre_TestGroupId_testGroupIdentifier ) 
    pre_TestGroupId_testGroupIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.testGroupIdentifier() );
  if ( post_TestGroupId_testGroupIdentifier ) 
    post_TestGroupId_testGroupIdentifier( Me );

  if ( post_TestGroupId ) 
    post_TestGroupId( Me );
}


void default_trav_TestStepGroupId( const TestStepGroupId& Me )
{
  if ( pre_TestStepGroupId ) 
    pre_TestStepGroupId( Me );

  if ( pre_TestStepGroupId_testStepGroupIdentifier ) 
    pre_TestStepGroupId_testStepGroupIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.testStepGroupIdentifier() );
  if ( post_TestStepGroupId_testStepGroupIdentifier ) 
    post_TestStepGroupId_testStepGroupIdentifier( Me );

  if ( post_TestStepGroupId ) 
    post_TestStepGroupId( Me );
}


void default_trav_TestStep( const TestStep& Me )
{
  if ( pre_TestStep ) 
    pre_TestStep( Me );

  if ( Me.is_present_testStepId())
    {
      if ( pre_TestStep_testStepId ) 
        pre_TestStep_testStepId( Me );
      if ( trav_TestStepId ) 
        trav_TestStepId( Me.testStepId() );
      if ( post_TestStep_testStepId ) 
        post_TestStep_testStepId( Me );
    }

  if ( Me.is_present_testStepRef())
    {
      if ( pre_TestStep_testStepRef ) 
        pre_TestStep_testStepRef( Me );
      if ( trav_TestStepRef ) 
        trav_TestStepRef( Me.testStepRef() );
      if ( post_TestStep_testStepRef ) 
        post_TestStep_testStepRef( Me );
    }

  if ( Me.is_present_objective())
    {
      if ( pre_TestStep_objective ) 
        pre_TestStep_objective( Me );
      if ( trav_Objective ) 
        trav_Objective( Me.objective() );
      if ( post_TestStep_objective ) 
        post_TestStep_objective( Me );
    }

  if ( Me.is_present_defaultsRef())
    {
      if ( pre_TestStep_defaultsRef ) 
        pre_TestStep_defaultsRef( Me );
      if ( trav_DefaultsRef ) 
        trav_DefaultsRef( Me.defaultsRef() );
      if ( post_TestStep_defaultsRef ) 
        post_TestStep_defaultsRef( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_TestStep_comment ) 
        pre_TestStep_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_TestStep_comment ) 
        post_TestStep_comment( Me );
    }

  if ( Me.is_present_description())
    {
      if ( pre_TestStep_description ) 
        pre_TestStep_description( Me );
      if ( trav_Description ) 
        trav_Description( Me.description() );
      if ( post_TestStep_description ) 
        post_TestStep_description( Me );
    }

  if ( pre_TestStep_behaviourDescription ) 
    pre_TestStep_behaviourDescription( Me );
  if ( trav_BehaviourDescription ) 
    trav_BehaviourDescription( Me.behaviourDescription() );
  if ( post_TestStep_behaviourDescription ) 
    post_TestStep_behaviourDescription( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_TestStep_detailedComment ) 
        pre_TestStep_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_TestStep_detailedComment ) 
        post_TestStep_detailedComment( Me );
    }

  if ( post_TestStep ) 
    post_TestStep( Me );
}


void default_trav_TestStepId( const TestStepId& Me )
{
  if ( pre_TestStepId ) 
    pre_TestStepId( Me );

  if ( pre_TestStepId_testStepIdAndParList ) 
    pre_TestStepId_testStepIdAndParList( Me );
  if ( trav_TestStepIdAndParList ) 
    trav_TestStepIdAndParList( Me.testStepIdAndParList() );
  if ( post_TestStepId_testStepIdAndParList ) 
    post_TestStepId_testStepIdAndParList( Me );

  if ( post_TestStepId ) 
    post_TestStepId( Me );
}


void default_trav_TestStepIdAndParList( const TestStepIdAndParList& Me )
{
  if ( pre_TestStepIdAndParList ) 
    pre_TestStepIdAndParList( Me );

  if ( pre_TestStepIdAndParList_testStepIdentifier ) 
    pre_TestStepIdAndParList_testStepIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.testStepIdentifier() );
  if ( post_TestStepIdAndParList_testStepIdentifier ) 
    post_TestStepIdAndParList_testStepIdentifier( Me );

  if ( pre_TestStepIdAndParList_formalParList ) 
    pre_TestStepIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_TestStepIdAndParList_formalParList ) 
    post_TestStepIdAndParList_formalParList( Me );

  if ( post_TestStepIdAndParList ) 
    post_TestStepIdAndParList( Me );
}


void default_trav_TestStepRef( const TestStepRef& Me )
{
  if ( pre_TestStepRef ) 
    pre_TestStepRef( Me );

  if ( pre_TestStepRef_testStepGroupReference ) 
    pre_TestStepRef_testStepGroupReference( Me );
  if ( trav_TestStepGroupReference ) 
    trav_TestStepGroupReference( Me.testStepGroupReference() );
  if ( post_TestStepRef_testStepGroupReference ) 
    post_TestStepRef_testStepGroupReference( Me );

  if ( post_TestStepRef ) 
    post_TestStepRef( Me );
}


void default_trav_DefaultsLibrary( const DefaultsLibrary& Me )
{
  if ( pre_DefaultsLibrary ) 
    pre_DefaultsLibrary( Me );

  if ( pre_DefaultsLibrary_defaultGroupOrDefaultList ) 
    pre_DefaultsLibrary_defaultGroupOrDefaultList( Me );
  if ( trav_DefaultGroupOrDefaultList ) 
    trav_DefaultGroupOrDefaultList( Me.defaultGroupOrDefaultList() );
  if ( post_DefaultsLibrary_defaultGroupOrDefaultList ) 
    post_DefaultsLibrary_defaultGroupOrDefaultList( Me );

  if ( post_DefaultsLibrary ) 
    post_DefaultsLibrary( Me );
}


void default_trav_DefaultGroupOrDefaultList( const DefaultGroupOrDefaultList& Me )
{
  if ( pre_DefaultGroupOrDefaultList ) 
    pre_DefaultGroupOrDefaultList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_DefaultGroupOrDefaultList_defaultGroupOrDefault ) 
        pre_DefaultGroupOrDefaultList_defaultGroupOrDefault( Me, i );
      if ( trav_DefaultGroupOrDefault ) 
        trav_DefaultGroupOrDefault( Me.defaultGroupOrDefault( i ) );
      if ( post_DefaultGroupOrDefaultList_defaultGroupOrDefault ) 
        post_DefaultGroupOrDefaultList_defaultGroupOrDefault( Me, i );
  }

  if ( post_DefaultGroupOrDefaultList ) 
    post_DefaultGroupOrDefaultList( Me );
}


void default_trav_DefaultGroupOrDefault( const DefaultGroupOrDefault& Me )
{
  if ( pre_DefaultGroupOrDefault ) 
    pre_DefaultGroupOrDefault( Me );

  switch ( Me.choice() )
    {
    case Choices::c_DefaultGroup:
      if ( pre_DefaultGroupOrDefault_defaultGroup ) 
        pre_DefaultGroupOrDefault_defaultGroup( Me );
      if ( trav_DefaultGroup ) 
        trav_DefaultGroup( Me.defaultGroup() );
      if ( post_DefaultGroupOrDefault_defaultGroup ) 
        post_DefaultGroupOrDefault_defaultGroup( Me );
      break;

    case Choices::c_DefaultCase:
      if ( pre_DefaultGroupOrDefault_defaultCase ) 
        pre_DefaultGroupOrDefault_defaultCase( Me );
      if ( trav_DefaultCase ) 
        trav_DefaultCase( Me.defaultCase() );
      if ( post_DefaultGroupOrDefault_defaultCase ) 
        post_DefaultGroupOrDefault_defaultCase( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node DefaultGroupOrDefault: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_DefaultGroupOrDefault ) 
    post_DefaultGroupOrDefault( Me );
}


void default_trav_DefaultGroup( const DefaultGroup& Me )
{
  if ( pre_DefaultGroup ) 
    pre_DefaultGroup( Me );

  if ( Me.is_present_defaultGroupId())
    {
      if ( pre_DefaultGroup_defaultGroupId ) 
        pre_DefaultGroup_defaultGroupId( Me );
      if ( trav_DefaultGroupId ) 
        trav_DefaultGroupId( Me.defaultGroupId() );
      if ( post_DefaultGroup_defaultGroupId ) 
        post_DefaultGroup_defaultGroupId( Me );
    }

  if ( pre_DefaultGroup_defaultGroupOrDefaultList ) 
    pre_DefaultGroup_defaultGroupOrDefaultList( Me );
  if ( trav_DefaultGroupOrDefaultList ) 
    trav_DefaultGroupOrDefaultList( Me.defaultGroupOrDefaultList() );
  if ( post_DefaultGroup_defaultGroupOrDefaultList ) 
    post_DefaultGroup_defaultGroupOrDefaultList( Me );

  if ( post_DefaultGroup ) 
    post_DefaultGroup( Me );
}


void default_trav_DefaultCase( const DefaultCase& Me )
{
  if ( pre_DefaultCase ) 
    pre_DefaultCase( Me );

  if ( Me.is_present_defaultId())
    {
      if ( pre_DefaultCase_defaultId ) 
        pre_DefaultCase_defaultId( Me );
      if ( trav_DefaultId ) 
        trav_DefaultId( Me.defaultId() );
      if ( post_DefaultCase_defaultId ) 
        post_DefaultCase_defaultId( Me );
    }

  if ( Me.is_present_defaultRef())
    {
      if ( pre_DefaultCase_defaultRef ) 
        pre_DefaultCase_defaultRef( Me );
      if ( trav_DefaultRef ) 
        trav_DefaultRef( Me.defaultRef() );
      if ( post_DefaultCase_defaultRef ) 
        post_DefaultCase_defaultRef( Me );
    }

  if ( Me.is_present_objective())
    {
      if ( pre_DefaultCase_objective ) 
        pre_DefaultCase_objective( Me );
      if ( trav_Objective ) 
        trav_Objective( Me.objective() );
      if ( post_DefaultCase_objective ) 
        post_DefaultCase_objective( Me );
    }

  if ( Me.is_present_comment())
    {
      if ( pre_DefaultCase_comment ) 
        pre_DefaultCase_comment( Me );
      if ( trav_Comment ) 
        trav_Comment( Me.comment() );
      if ( post_DefaultCase_comment ) 
        post_DefaultCase_comment( Me );
    }

  if ( Me.is_present_description())
    {
      if ( pre_DefaultCase_description ) 
        pre_DefaultCase_description( Me );
      if ( trav_Description ) 
        trav_Description( Me.description() );
      if ( post_DefaultCase_description ) 
        post_DefaultCase_description( Me );
    }

  if ( pre_DefaultCase_behaviourDescription ) 
    pre_DefaultCase_behaviourDescription( Me );
  if ( trav_BehaviourDescription ) 
    trav_BehaviourDescription( Me.behaviourDescription() );
  if ( post_DefaultCase_behaviourDescription ) 
    post_DefaultCase_behaviourDescription( Me );

  if ( Me.is_present_detailedComment())
    {
      if ( pre_DefaultCase_detailedComment ) 
        pre_DefaultCase_detailedComment( Me );
      if ( trav_DetailedComment ) 
        trav_DetailedComment( Me.detailedComment() );
      if ( post_DefaultCase_detailedComment ) 
        post_DefaultCase_detailedComment( Me );
    }

  if ( post_DefaultCase ) 
    post_DefaultCase( Me );
}


void default_trav_DefaultGroupId( const DefaultGroupId& Me )
{
  if ( pre_DefaultGroupId ) 
    pre_DefaultGroupId( Me );

  if ( pre_DefaultGroupId_defaultGroupIdentifier ) 
    pre_DefaultGroupId_defaultGroupIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.defaultGroupIdentifier() );
  if ( post_DefaultGroupId_defaultGroupIdentifier ) 
    post_DefaultGroupId_defaultGroupIdentifier( Me );

  if ( post_DefaultGroupId ) 
    post_DefaultGroupId( Me );
}


void default_trav_DefaultId( const DefaultId& Me )
{
  if ( pre_DefaultId ) 
    pre_DefaultId( Me );

  if ( pre_DefaultId_defaultIdAndParList ) 
    pre_DefaultId_defaultIdAndParList( Me );
  if ( trav_DefaultIdAndParList ) 
    trav_DefaultIdAndParList( Me.defaultIdAndParList() );
  if ( post_DefaultId_defaultIdAndParList ) 
    post_DefaultId_defaultIdAndParList( Me );

  if ( post_DefaultId ) 
    post_DefaultId( Me );
}


void default_trav_DefaultIdAndParList( const DefaultIdAndParList& Me )
{
  if ( pre_DefaultIdAndParList ) 
    pre_DefaultIdAndParList( Me );

  if ( pre_DefaultIdAndParList_defaultIdentifier ) 
    pre_DefaultIdAndParList_defaultIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.defaultIdentifier() );
  if ( post_DefaultIdAndParList_defaultIdentifier ) 
    post_DefaultIdAndParList_defaultIdentifier( Me );

  if ( pre_DefaultIdAndParList_formalParList ) 
    pre_DefaultIdAndParList_formalParList( Me );
  if ( trav_FormalParList ) 
    trav_FormalParList( Me.formalParList() );
  if ( post_DefaultIdAndParList_formalParList ) 
    post_DefaultIdAndParList_formalParList( Me );

  if ( post_DefaultIdAndParList ) 
    post_DefaultIdAndParList( Me );
}


void default_trav_DefaultRef( const DefaultRef& Me )
{
  if ( pre_DefaultRef ) 
    pre_DefaultRef( Me );

  if ( pre_DefaultRef_defaultGroupReference ) 
    pre_DefaultRef_defaultGroupReference( Me );
  if ( trav_DefaultGroupReference ) 
    trav_DefaultGroupReference( Me.defaultGroupReference() );
  if ( post_DefaultRef_defaultGroupReference ) 
    post_DefaultRef_defaultGroupReference( Me );

  if ( post_DefaultRef ) 
    post_DefaultRef( Me );
}


void default_trav_ConstraintValueAndAttributes( const ConstraintValueAndAttributes& Me )
{
  if ( pre_ConstraintValueAndAttributes ) 
    pre_ConstraintValueAndAttributes( Me );

  if ( pre_ConstraintValueAndAttributes_constraintValue ) 
    pre_ConstraintValueAndAttributes_constraintValue( Me );
  if ( trav_ConstraintValue ) 
    trav_ConstraintValue( Me.constraintValue() );
  if ( post_ConstraintValueAndAttributes_constraintValue ) 
    post_ConstraintValueAndAttributes_constraintValue( Me );

  if ( Me.is_present_valueAttributes())
    {
      if ( pre_ConstraintValueAndAttributes_valueAttributes ) 
        pre_ConstraintValueAndAttributes_valueAttributes( Me );
      if ( trav_ValueAttributes ) 
        trav_ValueAttributes( Me.valueAttributes() );
      if ( post_ConstraintValueAndAttributes_valueAttributes ) 
        post_ConstraintValueAndAttributes_valueAttributes( Me );
    }

  if ( post_ConstraintValueAndAttributes ) 
    post_ConstraintValueAndAttributes( Me );
}


void default_trav_ConstraintValue( const ConstraintValue& Me )
{
  if ( pre_ConstraintValue ) 
    pre_ConstraintValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintExpression:
      if ( pre_ConstraintValue_constraintExpression ) 
        pre_ConstraintValue_constraintExpression( Me );
      if ( trav_ConstraintExpression ) 
        trav_ConstraintExpression( Me.constraintExpression() );
      if ( post_ConstraintValue_constraintExpression ) 
        post_ConstraintValue_constraintExpression( Me );
      break;

    case Choices::c_MatchingSymbol:
      if ( pre_ConstraintValue_matchingSymbol ) 
        pre_ConstraintValue_matchingSymbol( Me );
      if ( trav_MatchingSymbol ) 
        trav_MatchingSymbol( Me.matchingSymbol() );
      if ( post_ConstraintValue_matchingSymbol ) 
        post_ConstraintValue_matchingSymbol( Me );
      break;

    case Choices::c_ConsRef:
      if ( pre_ConstraintValue_consRef ) 
        pre_ConstraintValue_consRef( Me );
      if ( trav_ConsRef ) 
        trav_ConsRef( Me.consRef() );
      if ( post_ConstraintValue_consRef ) 
        post_ConstraintValue_consRef( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ConstraintValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ConstraintValue ) 
    post_ConstraintValue( Me );
}


void default_trav_ConstraintExpression( const ConstraintExpression& Me )
{
  if ( pre_ConstraintExpression ) 
    pre_ConstraintExpression( Me );

  if ( pre_ConstraintExpression_expression ) 
    pre_ConstraintExpression_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_ConstraintExpression_expression ) 
    post_ConstraintExpression_expression( Me );

  if ( post_ConstraintExpression ) 
    post_ConstraintExpression( Me );
}


void default_trav_DefaultExpression( const DefaultExpression& Me )
{
  if ( pre_DefaultExpression ) 
    pre_DefaultExpression( Me );

  if ( pre_DefaultExpression_expression ) 
    pre_DefaultExpression_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_DefaultExpression_expression ) 
    post_DefaultExpression_expression( Me );

  if ( post_DefaultExpression ) 
    post_DefaultExpression( Me );
}


void default_trav_MatchingSymbol( const MatchingSymbol& Me )
{
  if ( pre_MatchingSymbol ) 
    pre_MatchingSymbol( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Complement:
      if ( pre_MatchingSymbol_complement ) 
        pre_MatchingSymbol_complement( Me );
      if ( trav_Complement ) 
        trav_Complement( Me.complement() );
      if ( post_MatchingSymbol_complement ) 
        post_MatchingSymbol_complement( Me );
      break;

    case Choices::c_Omit:
      if ( pre_MatchingSymbol_omit ) 
        pre_MatchingSymbol_omit( Me );
      if ( trav_Omit ) 
        trav_Omit( Me.omit() );
      if ( post_MatchingSymbol_omit ) 
        post_MatchingSymbol_omit( Me );
      break;

    case Choices::c_ANYValue:
      if ( pre_MatchingSymbol_anyValue ) 
        pre_MatchingSymbol_anyValue( Me );
      if ( trav_ANYValue ) 
        trav_ANYValue( Me.anyValue() );
      if ( post_MatchingSymbol_anyValue ) 
        post_MatchingSymbol_anyValue( Me );
      break;

    case Choices::c_AnyOrOmit:
      if ( pre_MatchingSymbol_anyOrOmit ) 
        pre_MatchingSymbol_anyOrOmit( Me );
      if ( trav_AnyOrOmit ) 
        trav_AnyOrOmit( Me.anyOrOmit() );
      if ( post_MatchingSymbol_anyOrOmit ) 
        post_MatchingSymbol_anyOrOmit( Me );
      break;

    case Choices::c_ValueList:
      if ( pre_MatchingSymbol_valueList ) 
        pre_MatchingSymbol_valueList( Me );
      if ( trav_ValueList ) 
        trav_ValueList( Me.valueList() );
      if ( post_MatchingSymbol_valueList ) 
        post_MatchingSymbol_valueList( Me );
      break;

    case Choices::c_ValRange:
      if ( pre_MatchingSymbol_valRange ) 
        pre_MatchingSymbol_valRange( Me );
      if ( trav_ValRange ) 
        trav_ValRange( Me.valRange() );
      if ( post_MatchingSymbol_valRange ) 
        post_MatchingSymbol_valRange( Me );
      break;

    case Choices::c_SuperSet:
      if ( pre_MatchingSymbol_superSet ) 
        pre_MatchingSymbol_superSet( Me );
      if ( trav_SuperSet ) 
        trav_SuperSet( Me.superSet() );
      if ( post_MatchingSymbol_superSet ) 
        post_MatchingSymbol_superSet( Me );
      break;

    case Choices::c_SubSet:
      if ( pre_MatchingSymbol_subSet ) 
        pre_MatchingSymbol_subSet( Me );
      if ( trav_SubSet ) 
        trav_SubSet( Me.subSet() );
      if ( post_MatchingSymbol_subSet ) 
        post_MatchingSymbol_subSet( Me );
      break;

    case Choices::c_Permutation:
      if ( pre_MatchingSymbol_permutation ) 
        pre_MatchingSymbol_permutation( Me );
      if ( trav_Permutation ) 
        trav_Permutation( Me.permutation() );
      if ( post_MatchingSymbol_permutation ) 
        post_MatchingSymbol_permutation( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node MatchingSymbol: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_MatchingSymbol ) 
    post_MatchingSymbol( Me );
}


void default_trav_Complement( const Complement& Me )
{
  if ( pre_Complement ) 
    pre_Complement( Me );

  if ( pre_Complement_valueList ) 
    pre_Complement_valueList( Me );
  if ( trav_ValueList ) 
    trav_ValueList( Me.valueList() );
  if ( post_Complement_valueList ) 
    post_Complement_valueList( Me );

  if ( post_Complement ) 
    post_Complement( Me );
}


void default_trav_Omit( const Omit& Me )
{
  if ( pre_Omit ) 
    pre_Omit( Me );

  if ( pre_Omit_omit ) 
    pre_Omit_omit( Me );
  if ( trav_OMIT ) 
    trav_OMIT( Me.omit() );
  if ( post_Omit_omit ) 
    post_Omit_omit( Me );

  if ( post_Omit ) 
    post_Omit( Me );
}


void default_trav_ValueList( const ValueList& Me )
{
  if ( pre_ValueList ) 
    pre_ValueList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ValueList_constraintValueAndAttributes ) 
        pre_ValueList_constraintValueAndAttributes( Me, i );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes( i ) );
      if ( post_ValueList_constraintValueAndAttributes ) 
        post_ValueList_constraintValueAndAttributes( Me, i );
  }

  if ( post_ValueList ) 
    post_ValueList( Me );
}


void default_trav_ValRange( const ValRange& Me )
{
  if ( pre_ValRange ) 
    pre_ValRange( Me );

  if ( pre_ValRange_lowerRangeBound ) 
    pre_ValRange_lowerRangeBound( Me );
  if ( trav_LowerRangeBound ) 
    trav_LowerRangeBound( Me.lowerRangeBound() );
  if ( post_ValRange_lowerRangeBound ) 
    post_ValRange_lowerRangeBound( Me );

  if ( pre_ValRange_upperRangeBound ) 
    pre_ValRange_upperRangeBound( Me );
  if ( trav_UpperRangeBound ) 
    trav_UpperRangeBound( Me.upperRangeBound() );
  if ( post_ValRange_upperRangeBound ) 
    post_ValRange_upperRangeBound( Me );

  if ( post_ValRange ) 
    post_ValRange( Me );
}


void default_trav_LowerRangeBound( const LowerRangeBound& Me )
{
  if ( pre_LowerRangeBound ) 
    pre_LowerRangeBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintExpression:
      if ( pre_LowerRangeBound_constraintExpression ) 
        pre_LowerRangeBound_constraintExpression( Me );
      if ( trav_ConstraintExpression ) 
        trav_ConstraintExpression( Me.constraintExpression() );
      if ( post_LowerRangeBound_constraintExpression ) 
        post_LowerRangeBound_constraintExpression( Me );
      break;

    case Choices::c_MinusINFINITY:
      if ( pre_LowerRangeBound_minusINFINITY ) 
        pre_LowerRangeBound_minusINFINITY( Me );
      if ( trav_MinusINFINITY ) 
        trav_MinusINFINITY( Me.minusINFINITY() );
      if ( post_LowerRangeBound_minusINFINITY ) 
        post_LowerRangeBound_minusINFINITY( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LowerRangeBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LowerRangeBound ) 
    post_LowerRangeBound( Me );
}


void default_trav_UpperRangeBound( const UpperRangeBound& Me )
{
  if ( pre_UpperRangeBound ) 
    pre_UpperRangeBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintExpression:
      if ( pre_UpperRangeBound_constraintExpression ) 
        pre_UpperRangeBound_constraintExpression( Me );
      if ( trav_ConstraintExpression ) 
        trav_ConstraintExpression( Me.constraintExpression() );
      if ( post_UpperRangeBound_constraintExpression ) 
        post_UpperRangeBound_constraintExpression( Me );
      break;

    case Choices::c_INFINITY:
      if ( pre_UpperRangeBound_infinity ) 
        pre_UpperRangeBound_infinity( Me );
      if ( trav_INFINITY ) 
        trav_INFINITY( Me.infinity() );
      if ( post_UpperRangeBound_infinity ) 
        post_UpperRangeBound_infinity( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UpperRangeBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UpperRangeBound ) 
    post_UpperRangeBound( Me );
}


void default_trav_SuperSet( const SuperSet& Me )
{
  if ( pre_SuperSet ) 
    pre_SuperSet( Me );

  if ( pre_SuperSet_constraintValueAndAttributes ) 
    pre_SuperSet_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_SuperSet_constraintValueAndAttributes ) 
    post_SuperSet_constraintValueAndAttributes( Me );

  if ( post_SuperSet ) 
    post_SuperSet( Me );
}


void default_trav_SubSet( const SubSet& Me )
{
  if ( pre_SubSet ) 
    pre_SubSet( Me );

  if ( pre_SubSet_constraintValueAndAttributes ) 
    pre_SubSet_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_SubSet_constraintValueAndAttributes ) 
    post_SubSet_constraintValueAndAttributes( Me );

  if ( post_SubSet ) 
    post_SubSet( Me );
}


void default_trav_Permutation( const Permutation& Me )
{
  if ( pre_Permutation ) 
    pre_Permutation( Me );

  if ( pre_Permutation_valueList ) 
    pre_Permutation_valueList( Me );
  if ( trav_ValueList ) 
    trav_ValueList( Me.valueList() );
  if ( post_Permutation_valueList ) 
    post_Permutation_valueList( Me );

  if ( post_Permutation ) 
    post_Permutation( Me );
}


void default_trav_ValueAttributes( const ValueAttributes& Me )
{
  if ( pre_ValueAttributes ) 
    pre_ValueAttributes( Me );

  if ( Me.is_present_valueLength())
    {
      if ( pre_ValueAttributes_valueLength ) 
        pre_ValueAttributes_valueLength( Me );
      if ( trav_ValueLength ) 
        trav_ValueLength( Me.valueLength() );
      if ( post_ValueAttributes_valueLength ) 
        post_ValueAttributes_valueLength( Me );
    }

  if ( Me.is_present_if_PRESENT())
    {
      if ( pre_ValueAttributes_if_PRESENT ) 
        pre_ValueAttributes_if_PRESENT( Me );
      if ( trav_IF_PRESENT ) 
        trav_IF_PRESENT( Me.if_PRESENT() );
      if ( post_ValueAttributes_if_PRESENT ) 
        post_ValueAttributes_if_PRESENT( Me );
    }

  if ( post_ValueAttributes ) 
    post_ValueAttributes( Me );
}


void default_trav_ValueLength( const ValueLength& Me )
{
  if ( pre_ValueLength ) 
    pre_ValueLength( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SingleValueLength:
      if ( pre_ValueLength_singleValueLength ) 
        pre_ValueLength_singleValueLength( Me );
      if ( trav_SingleValueLength ) 
        trav_SingleValueLength( Me.singleValueLength() );
      if ( post_ValueLength_singleValueLength ) 
        post_ValueLength_singleValueLength( Me );
      break;

    case Choices::c_RangeValueLength:
      if ( pre_ValueLength_rangeValueLength ) 
        pre_ValueLength_rangeValueLength( Me );
      if ( trav_RangeValueLength ) 
        trav_RangeValueLength( Me.rangeValueLength() );
      if ( post_ValueLength_rangeValueLength ) 
        post_ValueLength_rangeValueLength( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ValueLength: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ValueLength ) 
    post_ValueLength( Me );
}


void default_trav_SingleValueLength( const SingleValueLength& Me )
{
  if ( pre_SingleValueLength ) 
    pre_SingleValueLength( Me );

  if ( pre_SingleValueLength_valueBound ) 
    pre_SingleValueLength_valueBound( Me );
  if ( trav_ValueBound ) 
    trav_ValueBound( Me.valueBound() );
  if ( post_SingleValueLength_valueBound ) 
    post_SingleValueLength_valueBound( Me );

  if ( post_SingleValueLength ) 
    post_SingleValueLength( Me );
}


void default_trav_ValueBound( const ValueBound& Me )
{
  if ( pre_ValueBound ) 
    pre_ValueBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Number:
      if ( pre_ValueBound_number ) 
        pre_ValueBound_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_ValueBound_number ) 
        post_ValueBound_number( Me );
      break;

    case Choices::c_Identifier:
      if ( pre_ValueBound_identifier ) 
        pre_ValueBound_identifier( Me );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier() );
      if ( post_ValueBound_identifier ) 
        post_ValueBound_identifier( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ValueBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ValueBound ) 
    post_ValueBound( Me );
}


void default_trav_RangeValueLength( const RangeValueLength& Me )
{
  if ( pre_RangeValueLength ) 
    pre_RangeValueLength( Me );

  if ( pre_RangeValueLength_lowerValueBound ) 
    pre_RangeValueLength_lowerValueBound( Me );
  if ( trav_LowerValueBound ) 
    trav_LowerValueBound( Me.lowerValueBound() );
  if ( post_RangeValueLength_lowerValueBound ) 
    post_RangeValueLength_lowerValueBound( Me );

  if ( pre_RangeValueLength_upperValueBound ) 
    pre_RangeValueLength_upperValueBound( Me );
  if ( trav_UpperValueBound ) 
    trav_UpperValueBound( Me.upperValueBound() );
  if ( post_RangeValueLength_upperValueBound ) 
    post_RangeValueLength_upperValueBound( Me );

  if ( post_RangeValueLength ) 
    post_RangeValueLength( Me );
}


void default_trav_LowerValueBound( const LowerValueBound& Me )
{
  if ( pre_LowerValueBound ) 
    pre_LowerValueBound( Me );

  if ( pre_LowerValueBound_valueBound ) 
    pre_LowerValueBound_valueBound( Me );
  if ( trav_ValueBound ) 
    trav_ValueBound( Me.valueBound() );
  if ( post_LowerValueBound_valueBound ) 
    post_LowerValueBound_valueBound( Me );

  if ( post_LowerValueBound ) 
    post_LowerValueBound( Me );
}


void default_trav_UpperValueBound( const UpperValueBound& Me )
{
  if ( pre_UpperValueBound ) 
    pre_UpperValueBound( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ValueBound:
      if ( pre_UpperValueBound_valueBound ) 
        pre_UpperValueBound_valueBound( Me );
      if ( trav_ValueBound ) 
        trav_ValueBound( Me.valueBound() );
      if ( post_UpperValueBound_valueBound ) 
        post_UpperValueBound_valueBound( Me );
      break;

    case Choices::c_INFINITY:
      if ( pre_UpperValueBound_infinity ) 
        pre_UpperValueBound_infinity( Me );
      if ( trav_INFINITY ) 
        trav_INFINITY( Me.infinity() );
      if ( post_UpperValueBound_infinity ) 
        post_UpperValueBound_infinity( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UpperValueBound: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UpperValueBound ) 
    post_UpperValueBound( Me );
}


void default_trav_Expression( const Expression& Me )
{
  if ( pre_Expression ) 
    pre_Expression( Me );

  switch ( Me.choice() )
    {
    case Choices::c_RelExpression:
      if ( pre_Expression_relExpression ) 
        pre_Expression_relExpression( Me );
      if ( trav_RelExpression ) 
        trav_RelExpression( Me.relExpression() );
      if ( post_Expression_relExpression ) 
        post_Expression_relExpression( Me );
      break;

    case Choices::c_SimpleExpression:
      if ( pre_Expression_simpleExpression ) 
        pre_Expression_simpleExpression( Me );
      if ( trav_SimpleExpression ) 
        trav_SimpleExpression( Me.simpleExpression() );
      if ( post_Expression_simpleExpression ) 
        post_Expression_simpleExpression( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Expression: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Expression ) 
    post_Expression( Me );
}


void default_trav_SimpleExpression( const SimpleExpression& Me )
{
  if ( pre_SimpleExpression ) 
    pre_SimpleExpression( Me );

  switch ( Me.choice() )
    {
    case Choices::c_AddExpression:
      if ( pre_SimpleExpression_addExpression ) 
        pre_SimpleExpression_addExpression( Me );
      if ( trav_AddExpression ) 
        trav_AddExpression( Me.addExpression() );
      if ( post_SimpleExpression_addExpression ) 
        post_SimpleExpression_addExpression( Me );
      break;

    case Choices::c_Term:
      if ( pre_SimpleExpression_term ) 
        pre_SimpleExpression_term( Me );
      if ( trav_Term ) 
        trav_Term( Me.term() );
      if ( post_SimpleExpression_term ) 
        post_SimpleExpression_term( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node SimpleExpression: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_SimpleExpression ) 
    post_SimpleExpression( Me );
}


void default_trav_Term( const Term& Me )
{
  if ( pre_Term ) 
    pre_Term( Me );

  switch ( Me.choice() )
    {
    case Choices::c_MultExpression:
      if ( pre_Term_multExpression ) 
        pre_Term_multExpression( Me );
      if ( trav_MultExpression ) 
        trav_MultExpression( Me.multExpression() );
      if ( post_Term_multExpression ) 
        post_Term_multExpression( Me );
      break;

    case Choices::c_Factor:
      if ( pre_Term_factor ) 
        pre_Term_factor( Me );
      if ( trav_Factor ) 
        trav_Factor( Me.factor() );
      if ( post_Term_factor ) 
        post_Term_factor( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Term: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Term ) 
    post_Term( Me );
}


void default_trav_Factor( const Factor& Me )
{
  if ( pre_Factor ) 
    pre_Factor( Me );

  switch ( Me.choice() )
    {
    case Choices::c_UnaryExpression:
      if ( pre_Factor_unaryExpression ) 
        pre_Factor_unaryExpression( Me );
      if ( trav_UnaryExpression ) 
        trav_UnaryExpression( Me.unaryExpression() );
      if ( post_Factor_unaryExpression ) 
        post_Factor_unaryExpression( Me );
      break;

    case Choices::c_Primary:
      if ( pre_Factor_primary ) 
        pre_Factor_primary( Me );
      if ( trav_Primary ) 
        trav_Primary( Me.primary() );
      if ( post_Factor_primary ) 
        post_Factor_primary( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Factor: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Factor ) 
    post_Factor( Me );
}


void default_trav_Primary( const Primary& Me )
{
  if ( pre_Primary ) 
    pre_Primary( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Value:
      if ( pre_Primary_value ) 
        pre_Primary_value( Me );
      if ( trav_Value ) 
        trav_Value( Me.value() );
      if ( post_Primary_value ) 
        post_Primary_value( Me );
      break;

    case Choices::c_DataObjectReference:
      if ( pre_Primary_dataObjectReference ) 
        pre_Primary_dataObjectReference( Me );
      if ( trav_DataObjectReference ) 
        trav_DataObjectReference( Me.dataObjectReference() );
      if ( post_Primary_dataObjectReference ) 
        post_Primary_dataObjectReference( Me );
      break;

    case Choices::c_OpCall:
      if ( pre_Primary_opCall ) 
        pre_Primary_opCall( Me );
      if ( trav_OpCall ) 
        trav_OpCall( Me.opCall() );
      if ( post_Primary_opCall ) 
        post_Primary_opCall( Me );
      break;

    case Choices::c_ConsRef:
      if ( pre_Primary_consRef ) 
        pre_Primary_consRef( Me );
      if ( trav_ConsRef ) 
        trav_ConsRef( Me.consRef() );
      if ( post_Primary_consRef ) 
        post_Primary_consRef( Me );
      break;

    case Choices::c_SelectExprId:
      if ( pre_Primary_selectExprId ) 
        pre_Primary_selectExprId( Me );
      if ( trav_SelectExprId ) 
        trav_SelectExprId( Me.selectExprId() );
      if ( post_Primary_selectExprId ) 
        post_Primary_selectExprId( Me );
      break;

    case Choices::c_ParenExpression:
      if ( pre_Primary_parenExpression ) 
        pre_Primary_parenExpression( Me );
      if ( trav_ParenExpression ) 
        trav_ParenExpression( Me.parenExpression() );
      if ( post_Primary_parenExpression ) 
        post_Primary_parenExpression( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Primary: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Primary ) 
    post_Primary( Me );
}


void default_trav_ParenExpression( const ParenExpression& Me )
{
  if ( pre_ParenExpression ) 
    pre_ParenExpression( Me );

  if ( pre_ParenExpression_expression ) 
    pre_ParenExpression_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_ParenExpression_expression ) 
    post_ParenExpression_expression( Me );

  if ( post_ParenExpression ) 
    post_ParenExpression( Me );
}


void default_trav_RelExpression( const RelExpression& Me )
{
  if ( pre_RelExpression ) 
    pre_RelExpression( Me );

  if ( pre_RelExpression_simpleExpression1 ) 
    pre_RelExpression_simpleExpression1( Me );
  if ( trav_SimpleExpression ) 
    trav_SimpleExpression( Me.simpleExpression1() );
  if ( post_RelExpression_simpleExpression1 ) 
    post_RelExpression_simpleExpression1( Me );

  if ( pre_RelExpression_relOp ) 
    pre_RelExpression_relOp( Me );
  if ( trav_RelOp ) 
    trav_RelOp( Me.relOp() );
  if ( post_RelExpression_relOp ) 
    post_RelExpression_relOp( Me );

  if ( pre_RelExpression_simpleExpression2 ) 
    pre_RelExpression_simpleExpression2( Me );
  if ( trav_SimpleExpression ) 
    trav_SimpleExpression( Me.simpleExpression2() );
  if ( post_RelExpression_simpleExpression2 ) 
    post_RelExpression_simpleExpression2( Me );

  if ( post_RelExpression ) 
    post_RelExpression( Me );
}


void default_trav_AddExpression( const AddExpression& Me )
{
  if ( pre_AddExpression ) 
    pre_AddExpression( Me );

  if ( pre_AddExpression_simpleExpression ) 
    pre_AddExpression_simpleExpression( Me );
  if ( trav_SimpleExpression ) 
    trav_SimpleExpression( Me.simpleExpression() );
  if ( post_AddExpression_simpleExpression ) 
    post_AddExpression_simpleExpression( Me );

  if ( pre_AddExpression_addOp ) 
    pre_AddExpression_addOp( Me );
  if ( trav_AddOp ) 
    trav_AddOp( Me.addOp() );
  if ( post_AddExpression_addOp ) 
    post_AddExpression_addOp( Me );

  if ( pre_AddExpression_term ) 
    pre_AddExpression_term( Me );
  if ( trav_Term ) 
    trav_Term( Me.term() );
  if ( post_AddExpression_term ) 
    post_AddExpression_term( Me );

  if ( post_AddExpression ) 
    post_AddExpression( Me );
}


void default_trav_MultExpression( const MultExpression& Me )
{
  if ( pre_MultExpression ) 
    pre_MultExpression( Me );

  if ( pre_MultExpression_term ) 
    pre_MultExpression_term( Me );
  if ( trav_Term ) 
    trav_Term( Me.term() );
  if ( post_MultExpression_term ) 
    post_MultExpression_term( Me );

  if ( pre_MultExpression_multOp ) 
    pre_MultExpression_multOp( Me );
  if ( trav_MultOp ) 
    trav_MultOp( Me.multOp() );
  if ( post_MultExpression_multOp ) 
    post_MultExpression_multOp( Me );

  if ( pre_MultExpression_factor ) 
    pre_MultExpression_factor( Me );
  if ( trav_Factor ) 
    trav_Factor( Me.factor() );
  if ( post_MultExpression_factor ) 
    post_MultExpression_factor( Me );

  if ( post_MultExpression ) 
    post_MultExpression( Me );
}


void default_trav_UnaryExpression( const UnaryExpression& Me )
{
  if ( pre_UnaryExpression ) 
    pre_UnaryExpression( Me );

  if ( pre_UnaryExpression_unaryOp ) 
    pre_UnaryExpression_unaryOp( Me );
  if ( trav_UnaryOp ) 
    trav_UnaryOp( Me.unaryOp() );
  if ( post_UnaryExpression_unaryOp ) 
    post_UnaryExpression_unaryOp( Me );

  if ( pre_UnaryExpression_primary ) 
    pre_UnaryExpression_primary( Me );
  if ( trav_Primary ) 
    trav_Primary( Me.primary() );
  if ( post_UnaryExpression_primary ) 
    post_UnaryExpression_primary( Me );

  if ( post_UnaryExpression ) 
    post_UnaryExpression( Me );
}


void default_trav_RelOp( const RelOp& Me )
{
  if ( pre_RelOp ) 
    pre_RelOp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Equal:
      if ( pre_RelOp_equal ) 
        pre_RelOp_equal( Me );
      if ( trav_Equal ) 
        trav_Equal( Me.equal() );
      if ( post_RelOp_equal ) 
        post_RelOp_equal( Me );
      break;

    case Choices::c_Less:
      if ( pre_RelOp_less ) 
        pre_RelOp_less( Me );
      if ( trav_Less ) 
        trav_Less( Me.less() );
      if ( post_RelOp_less ) 
        post_RelOp_less( Me );
      break;

    case Choices::c_Greater:
      if ( pre_RelOp_greater ) 
        pre_RelOp_greater( Me );
      if ( trav_Greater ) 
        trav_Greater( Me.greater() );
      if ( post_RelOp_greater ) 
        post_RelOp_greater( Me );
      break;

    case Choices::c_NotEqual:
      if ( pre_RelOp_notEqual ) 
        pre_RelOp_notEqual( Me );
      if ( trav_NotEqual ) 
        trav_NotEqual( Me.notEqual() );
      if ( post_RelOp_notEqual ) 
        post_RelOp_notEqual( Me );
      break;

    case Choices::c_GreaterOrEqual:
      if ( pre_RelOp_greaterOrEqual ) 
        pre_RelOp_greaterOrEqual( Me );
      if ( trav_GreaterOrEqual ) 
        trav_GreaterOrEqual( Me.greaterOrEqual() );
      if ( post_RelOp_greaterOrEqual ) 
        post_RelOp_greaterOrEqual( Me );
      break;

    case Choices::c_LessOrEqual:
      if ( pre_RelOp_lessOrEqual ) 
        pre_RelOp_lessOrEqual( Me );
      if ( trav_LessOrEqual ) 
        trav_LessOrEqual( Me.lessOrEqual() );
      if ( post_RelOp_lessOrEqual ) 
        post_RelOp_lessOrEqual( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node RelOp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_RelOp ) 
    post_RelOp( Me );
}


void default_trav_AddOp( const AddOp& Me )
{
  if ( pre_AddOp ) 
    pre_AddOp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Plus:
      if ( pre_AddOp_plus ) 
        pre_AddOp_plus( Me );
      if ( trav_Plus ) 
        trav_Plus( Me.plus() );
      if ( post_AddOp_plus ) 
        post_AddOp_plus( Me );
      break;

    case Choices::c_Minus:
      if ( pre_AddOp_minus ) 
        pre_AddOp_minus( Me );
      if ( trav_Minus ) 
        trav_Minus( Me.minus() );
      if ( post_AddOp_minus ) 
        post_AddOp_minus( Me );
      break;

    case Choices::c_Or:
      if ( pre_AddOp_or1 ) 
        pre_AddOp_or1( Me );
      if ( trav_Or ) 
        trav_Or( Me.or1() );
      if ( post_AddOp_or1 ) 
        post_AddOp_or1( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node AddOp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_AddOp ) 
    post_AddOp( Me );
}


void default_trav_MultOp( const MultOp& Me )
{
  if ( pre_MultOp ) 
    pre_MultOp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Mult:
      if ( pre_MultOp_mult ) 
        pre_MultOp_mult( Me );
      if ( trav_Mult ) 
        trav_Mult( Me.mult() );
      if ( post_MultOp_mult ) 
        post_MultOp_mult( Me );
      break;

    case Choices::c_Div:
      if ( pre_MultOp_div ) 
        pre_MultOp_div( Me );
      if ( trav_Div ) 
        trav_Div( Me.div() );
      if ( post_MultOp_div ) 
        post_MultOp_div( Me );
      break;

    case Choices::c_Mod:
      if ( pre_MultOp_mod ) 
        pre_MultOp_mod( Me );
      if ( trav_Mod ) 
        trav_Mod( Me.mod() );
      if ( post_MultOp_mod ) 
        post_MultOp_mod( Me );
      break;

    case Choices::c_And:
      if ( pre_MultOp_and1 ) 
        pre_MultOp_and1( Me );
      if ( trav_And ) 
        trav_And( Me.and1() );
      if ( post_MultOp_and1 ) 
        post_MultOp_and1( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node MultOp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_MultOp ) 
    post_MultOp( Me );
}


void default_trav_UnaryOp( const UnaryOp& Me )
{
  if ( pre_UnaryOp ) 
    pre_UnaryOp( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Plus:
      if ( pre_UnaryOp_plus ) 
        pre_UnaryOp_plus( Me );
      if ( trav_Plus ) 
        trav_Plus( Me.plus() );
      if ( post_UnaryOp_plus ) 
        post_UnaryOp_plus( Me );
      break;

    case Choices::c_Minus:
      if ( pre_UnaryOp_minus ) 
        pre_UnaryOp_minus( Me );
      if ( trav_Minus ) 
        trav_Minus( Me.minus() );
      if ( post_UnaryOp_minus ) 
        post_UnaryOp_minus( Me );
      break;

    case Choices::c_Not:
      if ( pre_UnaryOp_not1 ) 
        pre_UnaryOp_not1( Me );
      if ( trav_Not ) 
        trav_Not( Me.not1() );
      if ( post_UnaryOp_not1 ) 
        post_UnaryOp_not1( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UnaryOp: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UnaryOp ) 
    post_UnaryOp( Me );
}


void default_trav_DataObjectReference( const DataObjectReference& Me )
{
  if ( pre_DataObjectReference ) 
    pre_DataObjectReference( Me );

  if ( pre_DataObjectReference_dataObjectIdentifier ) 
    pre_DataObjectReference_dataObjectIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.dataObjectIdentifier() );
  if ( post_DataObjectReference_dataObjectIdentifier ) 
    post_DataObjectReference_dataObjectIdentifier( Me );

  if ( pre_DataObjectReference_componentReferenceList ) 
    pre_DataObjectReference_componentReferenceList( Me );
  if ( trav_ComponentReferenceList ) 
    trav_ComponentReferenceList( Me.componentReferenceList() );
  if ( post_DataObjectReference_componentReferenceList ) 
    post_DataObjectReference_componentReferenceList( Me );

  if ( post_DataObjectReference ) 
    post_DataObjectReference( Me );
}


void default_trav_ComponentReferenceList( const ComponentReferenceList& Me )
{
  if ( pre_ComponentReferenceList ) 
    pre_ComponentReferenceList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ComponentReferenceList_componentReference ) 
        pre_ComponentReferenceList_componentReference( Me, i );
      if ( trav_ComponentReference ) 
        trav_ComponentReference( Me.componentReference( i ) );
      if ( post_ComponentReferenceList_componentReference ) 
        post_ComponentReferenceList_componentReference( Me, i );
  }

  if ( post_ComponentReferenceList ) 
    post_ComponentReferenceList( Me );
}


void default_trav_ComponentReference( const ComponentReference& Me )
{
  if ( pre_ComponentReference ) 
    pre_ComponentReference( Me );

  switch ( Me.choice() )
    {
    case Choices::c_RecordRef:
      if ( pre_ComponentReference_recordRef ) 
        pre_ComponentReference_recordRef( Me );
      if ( trav_RecordRef ) 
        trav_RecordRef( Me.recordRef() );
      if ( post_ComponentReference_recordRef ) 
        post_ComponentReference_recordRef( Me );
      break;

    case Choices::c_ArrayRef:
      if ( pre_ComponentReference_arrayRef ) 
        pre_ComponentReference_arrayRef( Me );
      if ( trav_ArrayRef ) 
        trav_ArrayRef( Me.arrayRef() );
      if ( post_ComponentReference_arrayRef ) 
        post_ComponentReference_arrayRef( Me );
      break;

    case Choices::c_BitRef:
      if ( pre_ComponentReference_bitRef ) 
        pre_ComponentReference_bitRef( Me );
      if ( trav_BitRef ) 
        trav_BitRef( Me.bitRef() );
      if ( post_ComponentReference_bitRef ) 
        post_ComponentReference_bitRef( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ComponentReference: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ComponentReference ) 
    post_ComponentReference( Me );
}


void default_trav_RecordRef( const RecordRef& Me )
{
  if ( pre_RecordRef ) 
    pre_RecordRef( Me );

  if ( pre_RecordRef_componentIdentifier ) 
    pre_RecordRef_componentIdentifier( Me );
  if ( trav_ComponentIdentifier ) 
    trav_ComponentIdentifier( Me.componentIdentifier() );
  if ( post_RecordRef_componentIdentifier ) 
    post_RecordRef_componentIdentifier( Me );

  if ( post_RecordRef ) 
    post_RecordRef( Me );
}


void default_trav_ComponentIdentifier( const ComponentIdentifier& Me )
{
  if ( pre_ComponentIdentifier ) 
    pre_ComponentIdentifier( Me );

  if ( pre_ComponentIdentifier_identifier ) 
    pre_ComponentIdentifier_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_ComponentIdentifier_identifier ) 
    post_ComponentIdentifier_identifier( Me );

  if ( post_ComponentIdentifier ) 
    post_ComponentIdentifier( Me );
}


void default_trav_ComponentPosition( const ComponentPosition& Me )
{
  if ( pre_ComponentPosition ) 
    pre_ComponentPosition( Me );

  if ( pre_ComponentPosition_number ) 
    pre_ComponentPosition_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_ComponentPosition_number ) 
    post_ComponentPosition_number( Me );

  if ( post_ComponentPosition ) 
    post_ComponentPosition( Me );
}


void default_trav_ArrayRef( const ArrayRef& Me )
{
  if ( pre_ArrayRef ) 
    pre_ArrayRef( Me );

  if ( pre_ArrayRef_componentNumber ) 
    pre_ArrayRef_componentNumber( Me );
  if ( trav_ComponentNumber ) 
    trav_ComponentNumber( Me.componentNumber() );
  if ( post_ArrayRef_componentNumber ) 
    post_ArrayRef_componentNumber( Me );

  if ( post_ArrayRef ) 
    post_ArrayRef( Me );
}


void default_trav_ComponentNumber( const ComponentNumber& Me )
{
  if ( pre_ComponentNumber ) 
    pre_ComponentNumber( Me );

  if ( pre_ComponentNumber_expression ) 
    pre_ComponentNumber_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_ComponentNumber_expression ) 
    post_ComponentNumber_expression( Me );

  if ( post_ComponentNumber ) 
    post_ComponentNumber( Me );
}


void default_trav_BitRef( const BitRef& Me )
{
  if ( pre_BitRef ) 
    pre_BitRef( Me );

  switch ( Me.choice() )
    {
    case Choices::c_BitIdentifier:
      if ( pre_BitRef_bitIdentifier ) 
        pre_BitRef_bitIdentifier( Me );
      if ( trav_BitIdentifier ) 
        trav_BitIdentifier( Me.bitIdentifier() );
      if ( post_BitRef_bitIdentifier ) 
        post_BitRef_bitIdentifier( Me );
      break;

    case Choices::c_BitNumber:
      if ( pre_BitRef_bitNumber ) 
        pre_BitRef_bitNumber( Me );
      if ( trav_BitNumber ) 
        trav_BitNumber( Me.bitNumber() );
      if ( post_BitRef_bitNumber ) 
        post_BitRef_bitNumber( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node BitRef: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_BitRef ) 
    post_BitRef( Me );
}


void default_trav_BitIdentifier( const BitIdentifier& Me )
{
  if ( pre_BitIdentifier ) 
    pre_BitIdentifier( Me );

  if ( pre_BitIdentifier_identifier ) 
    pre_BitIdentifier_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_BitIdentifier_identifier ) 
    post_BitIdentifier_identifier( Me );

  if ( post_BitIdentifier ) 
    post_BitIdentifier( Me );
}


void default_trav_BitNumber( const BitNumber& Me )
{
  if ( pre_BitNumber ) 
    pre_BitNumber( Me );

  if ( pre_BitNumber_expression ) 
    pre_BitNumber_expression( Me );
  if ( trav_Expression ) 
    trav_Expression( Me.expression() );
  if ( post_BitNumber_expression ) 
    post_BitNumber_expression( Me );

  if ( post_BitNumber ) 
    post_BitNumber( Me );
}


void default_trav_OpCall( const OpCall& Me )
{
  if ( pre_OpCall ) 
    pre_OpCall( Me );

  if ( pre_OpCall_ts_OpIdentifier ) 
    pre_OpCall_ts_OpIdentifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.ts_OpIdentifier() );
  if ( post_OpCall_ts_OpIdentifier ) 
    post_OpCall_ts_OpIdentifier( Me );

  if ( pre_OpCall_actualParList ) 
    pre_OpCall_actualParList( Me );
  if ( trav_ActualParList ) 
    trav_ActualParList( Me.actualParList() );
  if ( post_OpCall_actualParList ) 
    post_OpCall_actualParList( Me );

  if ( post_OpCall ) 
    post_OpCall( Me );
}


void default_trav_ActualParList( const ActualParList& Me )
{
  if ( pre_ActualParList ) 
    pre_ActualParList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ActualParList_constraintValueAndAttributes ) 
        pre_ActualParList_constraintValueAndAttributes( Me, i );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes( i ) );
      if ( post_ActualParList_constraintValueAndAttributes ) 
        post_ActualParList_constraintValueAndAttributes( Me, i );
  }

  if ( post_ActualParList ) 
    post_ActualParList( Me );
}


void default_trav_Value( const Value& Me )
{
  if ( pre_Value ) 
    pre_Value( Me );

  switch ( Me.choice() )
    {
    case Choices::c_LiteralValue:
      if ( pre_Value_literalValue ) 
        pre_Value_literalValue( Me );
      if ( trav_LiteralValue ) 
        trav_LiteralValue( Me.literalValue() );
      if ( post_Value_literalValue ) 
        post_Value_literalValue( Me );
      break;

    case Choices::c_ASN1_Value:
      if ( pre_Value_asn1_Value ) 
        pre_Value_asn1_Value( Me );
      if ( trav_ASN1_Value ) 
        trav_ASN1_Value( Me.asn1_Value() );
      if ( post_Value_asn1_Value ) 
        post_Value_asn1_Value( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Value: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Value ) 
    post_Value( Me );
}


void default_trav_LiteralValue( const LiteralValue& Me )
{
  if ( pre_LiteralValue ) 
    pre_LiteralValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Number:
      if ( pre_LiteralValue_number ) 
        pre_LiteralValue_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_LiteralValue_number ) 
        post_LiteralValue_number( Me );
      break;

    case Choices::c_BooleanValue:
      if ( pre_LiteralValue_booleanValue ) 
        pre_LiteralValue_booleanValue( Me );
      if ( trav_BooleanValue ) 
        trav_BooleanValue( Me.booleanValue() );
      if ( post_LiteralValue_booleanValue ) 
        post_LiteralValue_booleanValue( Me );
      break;

    case Choices::c_Bstring:
      if ( pre_LiteralValue_bstring ) 
        pre_LiteralValue_bstring( Me );
      if ( trav_Bstring ) 
        trav_Bstring( Me.bstring() );
      if ( post_LiteralValue_bstring ) 
        post_LiteralValue_bstring( Me );
      break;

    case Choices::c_Hstring:
      if ( pre_LiteralValue_hstring ) 
        pre_LiteralValue_hstring( Me );
      if ( trav_Hstring ) 
        trav_Hstring( Me.hstring() );
      if ( post_LiteralValue_hstring ) 
        post_LiteralValue_hstring( Me );
      break;

    case Choices::c_Ostring:
      if ( pre_LiteralValue_ostring ) 
        pre_LiteralValue_ostring( Me );
      if ( trav_Ostring ) 
        trav_Ostring( Me.ostring() );
      if ( post_LiteralValue_ostring ) 
        post_LiteralValue_ostring( Me );
      break;

    case Choices::c_Cstring:
      if ( pre_LiteralValue_cstring ) 
        pre_LiteralValue_cstring( Me );
      if ( trav_Cstring ) 
        trav_Cstring( Me.cstring() );
      if ( post_LiteralValue_cstring ) 
        post_LiteralValue_cstring( Me );
      break;

    case Choices::c_R_Value:
      if ( pre_LiteralValue_r_Value ) 
        pre_LiteralValue_r_Value( Me );
      if ( trav_R_Value ) 
        trav_R_Value( Me.r_Value() );
      if ( post_LiteralValue_r_Value ) 
        post_LiteralValue_r_Value( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LiteralValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LiteralValue ) 
    post_LiteralValue( Me );
}


void default_trav_BooleanValue( const BooleanValue& Me )
{
  if ( pre_BooleanValue ) 
    pre_BooleanValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ATrue:
      if ( pre_BooleanValue_Atrue ) 
        pre_BooleanValue_Atrue( Me );
      if ( trav_ATrue ) 
        trav_ATrue( Me.Atrue() );
      if ( post_BooleanValue_Atrue ) 
        post_BooleanValue_Atrue( Me );
      break;

    case Choices::c_AFalse:
      if ( pre_BooleanValue_Afalse ) 
        pre_BooleanValue_Afalse( Me );
      if ( trav_AFalse ) 
        trav_AFalse( Me.Afalse() );
      if ( post_BooleanValue_Afalse ) 
        post_BooleanValue_Afalse( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node BooleanValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_BooleanValue ) 
    post_BooleanValue( Me );
}


void default_trav_R_Value( const R_Value& Me )
{
  if ( pre_R_Value ) 
    pre_R_Value( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PASS:
      if ( pre_R_Value_pass ) 
        pre_R_Value_pass( Me );
      if ( trav_PASS ) 
        trav_PASS( Me.pass() );
      if ( post_R_Value_pass ) 
        post_R_Value_pass( Me );
      break;

    case Choices::c_FAIL:
      if ( pre_R_Value_fail ) 
        pre_R_Value_fail( Me );
      if ( trav_FAIL ) 
        trav_FAIL( Me.fail() );
      if ( post_R_Value_fail ) 
        post_R_Value_fail( Me );
      break;

    case Choices::c_INCONC:
      if ( pre_R_Value_inconc ) 
        pre_R_Value_inconc( Me );
      if ( trav_INCONC ) 
        trav_INCONC( Me.inconc() );
      if ( post_R_Value_inconc ) 
        post_R_Value_inconc( Me );
      break;

    case Choices::c_NONE:
      if ( pre_R_Value_none ) 
        pre_R_Value_none( Me );
      if ( trav_NONE ) 
        trav_NONE( Me.none() );
      if ( post_R_Value_none ) 
        post_R_Value_none( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node R_Value: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_R_Value ) 
    post_R_Value( Me );
}


void default_trav_ASN1_TypeAndLocalTypes( const ASN1_TypeAndLocalTypes& Me )
{
  if ( pre_ASN1_TypeAndLocalTypes ) 
    pre_ASN1_TypeAndLocalTypes( Me );

  if ( pre_ASN1_TypeAndLocalTypes_asn1_Type ) 
    pre_ASN1_TypeAndLocalTypes_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_ASN1_TypeAndLocalTypes_asn1_Type ) 
    post_ASN1_TypeAndLocalTypes_asn1_Type( Me );

  if ( pre_ASN1_TypeAndLocalTypes_asn1_LocalTypes ) 
    pre_ASN1_TypeAndLocalTypes_asn1_LocalTypes( Me );
  if ( trav_ASN1_LocalTypes ) 
    trav_ASN1_LocalTypes( Me.asn1_LocalTypes() );
  if ( post_ASN1_TypeAndLocalTypes_asn1_LocalTypes ) 
    post_ASN1_TypeAndLocalTypes_asn1_LocalTypes( Me );

  if ( post_ASN1_TypeAndLocalTypes ) 
    post_ASN1_TypeAndLocalTypes( Me );
}


void default_trav_ASN1_Type( const ASN1_Type& Me )
{
  if ( pre_ASN1_Type ) 
    pre_ASN1_Type( Me );

  switch ( Me.choice() )
    {
    case Choices::c_BuiltinType:
      if ( pre_ASN1_Type_builtinType ) 
        pre_ASN1_Type_builtinType( Me );
      if ( trav_BuiltinType ) 
        trav_BuiltinType( Me.builtinType() );
      if ( post_ASN1_Type_builtinType ) 
        post_ASN1_Type_builtinType( Me );
      break;

    case Choices::c_DefinedType:
      if ( pre_ASN1_Type_definedType ) 
        pre_ASN1_Type_definedType( Me );
      if ( trav_DefinedType ) 
        trav_DefinedType( Me.definedType() );
      if ( post_ASN1_Type_definedType ) 
        post_ASN1_Type_definedType( Me );
      break;

    case Choices::c_SubType:
      if ( pre_ASN1_Type_subType ) 
        pre_ASN1_Type_subType( Me );
      if ( trav_SubType ) 
        trav_SubType( Me.subType() );
      if ( post_ASN1_Type_subType ) 
        post_ASN1_Type_subType( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ASN1_Type: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ASN1_Type ) 
    post_ASN1_Type( Me );
}


void default_trav_TypeReference( const TypeReference& Me )
{
  if ( pre_TypeReference ) 
    pre_TypeReference( Me );

  if ( pre_TypeReference_identifier ) 
    pre_TypeReference_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_TypeReference_identifier ) 
    post_TypeReference_identifier( Me );

  if ( post_TypeReference ) 
    post_TypeReference( Me );
}


void default_trav_DefinedType( const DefinedType& Me )
{
  if ( pre_DefinedType ) 
    pre_DefinedType( Me );

  if ( pre_DefinedType_identifier ) 
    pre_DefinedType_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_DefinedType_identifier ) 
    post_DefinedType_identifier( Me );

  if ( post_DefinedType ) 
    post_DefinedType( Me );
}


void default_trav_BuiltinType( const BuiltinType& Me )
{
  if ( pre_BuiltinType ) 
    pre_BuiltinType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_BooleanType:
      if ( pre_BuiltinType_booleanType ) 
        pre_BuiltinType_booleanType( Me );
      if ( trav_BooleanType ) 
        trav_BooleanType( Me.booleanType() );
      if ( post_BuiltinType_booleanType ) 
        post_BuiltinType_booleanType( Me );
      break;

    case Choices::c_IntegerType:
      if ( pre_BuiltinType_integerType ) 
        pre_BuiltinType_integerType( Me );
      if ( trav_IntegerType ) 
        trav_IntegerType( Me.integerType() );
      if ( post_BuiltinType_integerType ) 
        post_BuiltinType_integerType( Me );
      break;

    case Choices::c_BitStringType:
      if ( pre_BuiltinType_bitStringType ) 
        pre_BuiltinType_bitStringType( Me );
      if ( trav_BitStringType ) 
        trav_BitStringType( Me.bitStringType() );
      if ( post_BuiltinType_bitStringType ) 
        post_BuiltinType_bitStringType( Me );
      break;

    case Choices::c_OctetStringType:
      if ( pre_BuiltinType_octetStringType ) 
        pre_BuiltinType_octetStringType( Me );
      if ( trav_OctetStringType ) 
        trav_OctetStringType( Me.octetStringType() );
      if ( post_BuiltinType_octetStringType ) 
        post_BuiltinType_octetStringType( Me );
      break;

    case Choices::c_NullType:
      if ( pre_BuiltinType_nullType ) 
        pre_BuiltinType_nullType( Me );
      if ( trav_NullType ) 
        trav_NullType( Me.nullType() );
      if ( post_BuiltinType_nullType ) 
        post_BuiltinType_nullType( Me );
      break;

    case Choices::c_SequenceType:
      if ( pre_BuiltinType_sequenceType ) 
        pre_BuiltinType_sequenceType( Me );
      if ( trav_SequenceType ) 
        trav_SequenceType( Me.sequenceType() );
      if ( post_BuiltinType_sequenceType ) 
        post_BuiltinType_sequenceType( Me );
      break;

    case Choices::c_SequenceOfType:
      if ( pre_BuiltinType_sequenceOfType ) 
        pre_BuiltinType_sequenceOfType( Me );
      if ( trav_SequenceOfType ) 
        trav_SequenceOfType( Me.sequenceOfType() );
      if ( post_BuiltinType_sequenceOfType ) 
        post_BuiltinType_sequenceOfType( Me );
      break;

    case Choices::c_SetType:
      if ( pre_BuiltinType_setType ) 
        pre_BuiltinType_setType( Me );
      if ( trav_SetType ) 
        trav_SetType( Me.setType() );
      if ( post_BuiltinType_setType ) 
        post_BuiltinType_setType( Me );
      break;

    case Choices::c_SetOfType:
      if ( pre_BuiltinType_setOfType ) 
        pre_BuiltinType_setOfType( Me );
      if ( trav_SetOfType ) 
        trav_SetOfType( Me.setOfType() );
      if ( post_BuiltinType_setOfType ) 
        post_BuiltinType_setOfType( Me );
      break;

    case Choices::c_ChoiceType:
      if ( pre_BuiltinType_choiceType ) 
        pre_BuiltinType_choiceType( Me );
      if ( trav_ChoiceType ) 
        trav_ChoiceType( Me.choiceType() );
      if ( post_BuiltinType_choiceType ) 
        post_BuiltinType_choiceType( Me );
      break;

    case Choices::c_SelectionType:
      if ( pre_BuiltinType_selectionType ) 
        pre_BuiltinType_selectionType( Me );
      if ( trav_SelectionType ) 
        trav_SelectionType( Me.selectionType() );
      if ( post_BuiltinType_selectionType ) 
        post_BuiltinType_selectionType( Me );
      break;

    case Choices::c_TaggedType:
      if ( pre_BuiltinType_taggedType ) 
        pre_BuiltinType_taggedType( Me );
      if ( trav_TaggedType ) 
        trav_TaggedType( Me.taggedType() );
      if ( post_BuiltinType_taggedType ) 
        post_BuiltinType_taggedType( Me );
      break;

    case Choices::c_AnyType:
      if ( pre_BuiltinType_anyType ) 
        pre_BuiltinType_anyType( Me );
      if ( trav_AnyType ) 
        trav_AnyType( Me.anyType() );
      if ( post_BuiltinType_anyType ) 
        post_BuiltinType_anyType( Me );
      break;

    case Choices::c_ObjectIdentifierType:
      if ( pre_BuiltinType_objectIdentifierType ) 
        pre_BuiltinType_objectIdentifierType( Me );
      if ( trav_ObjectIdentifierType ) 
        trav_ObjectIdentifierType( Me.objectIdentifierType() );
      if ( post_BuiltinType_objectIdentifierType ) 
        post_BuiltinType_objectIdentifierType( Me );
      break;

    case Choices::c_CharacterString:
      if ( pre_BuiltinType_characterString ) 
        pre_BuiltinType_characterString( Me );
      if ( trav_CharacterString ) 
        trav_CharacterString( Me.characterString() );
      if ( post_BuiltinType_characterString ) 
        post_BuiltinType_characterString( Me );
      break;

    case Choices::c_UsefulType:
      if ( pre_BuiltinType_usefulType ) 
        pre_BuiltinType_usefulType( Me );
      if ( trav_UsefulType ) 
        trav_UsefulType( Me.usefulType() );
      if ( post_BuiltinType_usefulType ) 
        post_BuiltinType_usefulType( Me );
      break;

    case Choices::c_EnumeratedType:
      if ( pre_BuiltinType_enumeratedType ) 
        pre_BuiltinType_enumeratedType( Me );
      if ( trav_EnumeratedType ) 
        trav_EnumeratedType( Me.enumeratedType() );
      if ( post_BuiltinType_enumeratedType ) 
        post_BuiltinType_enumeratedType( Me );
      break;

    case Choices::c_RealType:
      if ( pre_BuiltinType_realType ) 
        pre_BuiltinType_realType( Me );
      if ( trav_RealType ) 
        trav_RealType( Me.realType() );
      if ( post_BuiltinType_realType ) 
        post_BuiltinType_realType( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node BuiltinType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_BuiltinType ) 
    post_BuiltinType( Me );
}


void default_trav_NamedNumberList( const NamedNumberList& Me )
{
  if ( pre_NamedNumberList ) 
    pre_NamedNumberList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_NamedNumberList_namedNumber ) 
        pre_NamedNumberList_namedNumber( Me, i );
      if ( trav_NamedNumber ) 
        trav_NamedNumber( Me.namedNumber( i ) );
      if ( post_NamedNumberList_namedNumber ) 
        post_NamedNumberList_namedNumber( Me, i );
  }

  if ( post_NamedNumberList ) 
    post_NamedNumberList( Me );
}


void default_trav_NamedNumber( const NamedNumber& Me )
{
  if ( pre_NamedNumber ) 
    pre_NamedNumber( Me );

  if ( pre_NamedNumber_identifier ) 
    pre_NamedNumber_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_NamedNumber_identifier ) 
    post_NamedNumber_identifier( Me );

  if ( pre_NamedNumber_idOrNum ) 
    pre_NamedNumber_idOrNum( Me );
  if ( trav_IdOrNum ) 
    trav_IdOrNum( Me.idOrNum() );
  if ( post_NamedNumber_idOrNum ) 
    post_NamedNumber_idOrNum( Me );

  if ( post_NamedNumber ) 
    post_NamedNumber( Me );
}


void default_trav_IdOrNum( const IdOrNum& Me )
{
  if ( pre_IdOrNum ) 
    pre_IdOrNum( Me );

  switch ( Me.choice() )
    {
    case Choices::c_DataObjectReference:
      if ( pre_IdOrNum_dataObjectReference ) 
        pre_IdOrNum_dataObjectReference( Me );
      if ( trav_DataObjectReference ) 
        trav_DataObjectReference( Me.dataObjectReference() );
      if ( post_IdOrNum_dataObjectReference ) 
        post_IdOrNum_dataObjectReference( Me );
      break;

    case Choices::c_Number:
      if ( pre_IdOrNum_number ) 
        pre_IdOrNum_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_IdOrNum_number ) 
        post_IdOrNum_number( Me );
      break;

    case Choices::c_SignedNumber:
      if ( pre_IdOrNum_signedNumber ) 
        pre_IdOrNum_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_IdOrNum_signedNumber ) 
        post_IdOrNum_signedNumber( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node IdOrNum: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_IdOrNum ) 
    post_IdOrNum( Me );
}


void default_trav_AlternativeTypeList( const AlternativeTypeList& Me )
{
  if ( pre_AlternativeTypeList ) 
    pre_AlternativeTypeList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_AlternativeTypeList_namedType ) 
        pre_AlternativeTypeList_namedType( Me, i );
      if ( trav_NamedType ) 
        trav_NamedType( Me.namedType( i ) );
      if ( post_AlternativeTypeList_namedType ) 
        post_AlternativeTypeList_namedType( Me, i );
  }

  if ( post_AlternativeTypeList ) 
    post_AlternativeTypeList( Me );
}


void default_trav_ElementTypeList( const ElementTypeList& Me )
{
  if ( pre_ElementTypeList ) 
    pre_ElementTypeList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ElementTypeList_elementType ) 
        pre_ElementTypeList_elementType( Me, i );
      if ( trav_ElementType ) 
        trav_ElementType( Me.elementType( i ) );
      if ( post_ElementTypeList_elementType ) 
        post_ElementTypeList_elementType( Me, i );
  }

  if ( post_ElementTypeList ) 
    post_ElementTypeList( Me );
}


void default_trav_ElementType( const ElementType& Me )
{
  if ( pre_ElementType ) 
    pre_ElementType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_NamedTypeAndAttributes:
      if ( pre_ElementType_namedTypeAndAttributes ) 
        pre_ElementType_namedTypeAndAttributes( Me );
      if ( trav_NamedTypeAndAttributes ) 
        trav_NamedTypeAndAttributes( Me.namedTypeAndAttributes() );
      if ( post_ElementType_namedTypeAndAttributes ) 
        post_ElementType_namedTypeAndAttributes( Me );
      break;

    case Choices::c_ComponentsOf:
      if ( pre_ElementType_componentsOf ) 
        pre_ElementType_componentsOf( Me );
      if ( trav_ComponentsOf ) 
        trav_ComponentsOf( Me.componentsOf() );
      if ( post_ElementType_componentsOf ) 
        post_ElementType_componentsOf( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ElementType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ElementType ) 
    post_ElementType( Me );
}


void default_trav_ComponentsOf( const ComponentsOf& Me )
{
  if ( pre_ComponentsOf ) 
    pre_ComponentsOf( Me );

  if ( pre_ComponentsOf_asn1_Type ) 
    pre_ComponentsOf_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_ComponentsOf_asn1_Type ) 
    post_ComponentsOf_asn1_Type( Me );

  if ( post_ComponentsOf ) 
    post_ComponentsOf( Me );
}


void default_trav_NamedTypeAndAttributes( const NamedTypeAndAttributes& Me )
{
  if ( pre_NamedTypeAndAttributes ) 
    pre_NamedTypeAndAttributes( Me );

  if ( pre_NamedTypeAndAttributes_namedTypeOrSelection ) 
    pre_NamedTypeAndAttributes_namedTypeOrSelection( Me );
  if ( trav_NamedTypeOrSelection ) 
    trav_NamedTypeOrSelection( Me.namedTypeOrSelection() );
  if ( post_NamedTypeAndAttributes_namedTypeOrSelection ) 
    post_NamedTypeAndAttributes_namedTypeOrSelection( Me );

  if ( Me.is_present_namedTypeAttribute())
    {
      if ( pre_NamedTypeAndAttributes_namedTypeAttribute ) 
        pre_NamedTypeAndAttributes_namedTypeAttribute( Me );
      if ( trav_NamedTypeAttribute ) 
        trav_NamedTypeAttribute( Me.namedTypeAttribute() );
      if ( post_NamedTypeAndAttributes_namedTypeAttribute ) 
        post_NamedTypeAndAttributes_namedTypeAttribute( Me );
    }

  if ( post_NamedTypeAndAttributes ) 
    post_NamedTypeAndAttributes( Me );
}


void default_trav_NamedTypeAttribute( const NamedTypeAttribute& Me )
{
  if ( pre_NamedTypeAttribute ) 
    pre_NamedTypeAttribute( Me );

  switch ( Me.choice() )
    {
    case Choices::c_OPTIONAL:
      if ( pre_NamedTypeAttribute_optional ) 
        pre_NamedTypeAttribute_optional( Me );
      if ( trav_OPTIONAL ) 
        trav_OPTIONAL( Me.optional() );
      if ( post_NamedTypeAttribute_optional ) 
        post_NamedTypeAttribute_optional( Me );
      break;

    case Choices::c_DefaultValue:
      if ( pre_NamedTypeAttribute_defaultValue ) 
        pre_NamedTypeAttribute_defaultValue( Me );
      if ( trav_DefaultValue ) 
        trav_DefaultValue( Me.defaultValue() );
      if ( post_NamedTypeAttribute_defaultValue ) 
        post_NamedTypeAttribute_defaultValue( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node NamedTypeAttribute: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_NamedTypeAttribute ) 
    post_NamedTypeAttribute( Me );
}


void default_trav_NamedTypeOrSelection( const NamedTypeOrSelection& Me )
{
  if ( pre_NamedTypeOrSelection ) 
    pre_NamedTypeOrSelection( Me );

  switch ( Me.choice() )
    {
    case Choices::c_NamedType:
      if ( pre_NamedTypeOrSelection_namedType ) 
        pre_NamedTypeOrSelection_namedType( Me );
      if ( trav_NamedType ) 
        trav_NamedType( Me.namedType() );
      if ( post_NamedTypeOrSelection_namedType ) 
        post_NamedTypeOrSelection_namedType( Me );
      break;

    case Choices::c_SelectionType:
      if ( pre_NamedTypeOrSelection_selectionType ) 
        pre_NamedTypeOrSelection_selectionType( Me );
      if ( trav_SelectionType ) 
        trav_SelectionType( Me.selectionType() );
      if ( post_NamedTypeOrSelection_selectionType ) 
        post_NamedTypeOrSelection_selectionType( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node NamedTypeOrSelection: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_NamedTypeOrSelection ) 
    post_NamedTypeOrSelection( Me );
}


void default_trav_NamedType( const NamedType& Me )
{
  if ( pre_NamedType ) 
    pre_NamedType( Me );

  if ( pre_NamedType_identifier ) 
    pre_NamedType_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_NamedType_identifier ) 
    post_NamedType_identifier( Me );

  if ( pre_NamedType_asn1_Type ) 
    pre_NamedType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_NamedType_asn1_Type ) 
    post_NamedType_asn1_Type( Me );

  if ( post_NamedType ) 
    post_NamedType( Me );
}


void default_trav_IntegerType( const IntegerType& Me )
{
  if ( pre_IntegerType ) 
    pre_IntegerType( Me );

  if ( pre_IntegerType_namedNumberList ) 
    pre_IntegerType_namedNumberList( Me );
  if ( trav_NamedNumberList ) 
    trav_NamedNumberList( Me.namedNumberList() );
  if ( post_IntegerType_namedNumberList ) 
    post_IntegerType_namedNumberList( Me );

  if ( post_IntegerType ) 
    post_IntegerType( Me );
}


void default_trav_BitStringType( const BitStringType& Me )
{
  if ( pre_BitStringType ) 
    pre_BitStringType( Me );

  if ( pre_BitStringType_namedBitList ) 
    pre_BitStringType_namedBitList( Me );
  if ( trav_NamedBitList ) 
    trav_NamedBitList( Me.namedBitList() );
  if ( post_BitStringType_namedBitList ) 
    post_BitStringType_namedBitList( Me );

  if ( post_BitStringType ) 
    post_BitStringType( Me );
}


void default_trav_SequenceType( const SequenceType& Me )
{
  if ( pre_SequenceType ) 
    pre_SequenceType( Me );

  if ( pre_SequenceType_elementTypeList ) 
    pre_SequenceType_elementTypeList( Me );
  if ( trav_ElementTypeList ) 
    trav_ElementTypeList( Me.elementTypeList() );
  if ( post_SequenceType_elementTypeList ) 
    post_SequenceType_elementTypeList( Me );

  if ( post_SequenceType ) 
    post_SequenceType( Me );
}


void default_trav_SequenceOfType( const SequenceOfType& Me )
{
  if ( pre_SequenceOfType ) 
    pre_SequenceOfType( Me );

  if ( Me.is_present_asn1_Type())
    {
      if ( pre_SequenceOfType_asn1_Type ) 
        pre_SequenceOfType_asn1_Type( Me );
      if ( trav_ASN1_Type ) 
        trav_ASN1_Type( Me.asn1_Type() );
      if ( post_SequenceOfType_asn1_Type ) 
        post_SequenceOfType_asn1_Type( Me );
    }

  if ( post_SequenceOfType ) 
    post_SequenceOfType( Me );
}


void default_trav_SetType( const SetType& Me )
{
  if ( pre_SetType ) 
    pre_SetType( Me );

  if ( pre_SetType_elementTypeList ) 
    pre_SetType_elementTypeList( Me );
  if ( trav_ElementTypeList ) 
    trav_ElementTypeList( Me.elementTypeList() );
  if ( post_SetType_elementTypeList ) 
    post_SetType_elementTypeList( Me );

  if ( post_SetType ) 
    post_SetType( Me );
}


void default_trav_SetOfType( const SetOfType& Me )
{
  if ( pre_SetOfType ) 
    pre_SetOfType( Me );

  if ( Me.is_present_asn1_Type())
    {
      if ( pre_SetOfType_asn1_Type ) 
        pre_SetOfType_asn1_Type( Me );
      if ( trav_ASN1_Type ) 
        trav_ASN1_Type( Me.asn1_Type() );
      if ( post_SetOfType_asn1_Type ) 
        post_SetOfType_asn1_Type( Me );
    }

  if ( post_SetOfType ) 
    post_SetOfType( Me );
}


void default_trav_ChoiceType( const ChoiceType& Me )
{
  if ( pre_ChoiceType ) 
    pre_ChoiceType( Me );

  if ( pre_ChoiceType_alternativeTypeList ) 
    pre_ChoiceType_alternativeTypeList( Me );
  if ( trav_AlternativeTypeList ) 
    trav_AlternativeTypeList( Me.alternativeTypeList() );
  if ( post_ChoiceType_alternativeTypeList ) 
    post_ChoiceType_alternativeTypeList( Me );

  if ( post_ChoiceType ) 
    post_ChoiceType( Me );
}


void default_trav_SelectionType( const SelectionType& Me )
{
  if ( pre_SelectionType ) 
    pre_SelectionType( Me );

  if ( pre_SelectionType_identifier ) 
    pre_SelectionType_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_SelectionType_identifier ) 
    post_SelectionType_identifier( Me );

  if ( pre_SelectionType_asn1_Type ) 
    pre_SelectionType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_SelectionType_asn1_Type ) 
    post_SelectionType_asn1_Type( Me );

  if ( post_SelectionType ) 
    post_SelectionType( Me );
}


void default_trav_TaggedType( const TaggedType& Me )
{
  if ( pre_TaggedType ) 
    pre_TaggedType( Me );

  if ( pre_TaggedType_tag ) 
    pre_TaggedType_tag( Me );
  if ( trav_Tag ) 
    trav_Tag( Me.tag() );
  if ( post_TaggedType_tag ) 
    post_TaggedType_tag( Me );

  if ( Me.is_present_tagAttributes())
    {
      if ( pre_TaggedType_tagAttributes ) 
        pre_TaggedType_tagAttributes( Me );
      if ( trav_TagAttributes ) 
        trav_TagAttributes( Me.tagAttributes() );
      if ( post_TaggedType_tagAttributes ) 
        post_TaggedType_tagAttributes( Me );
    }

  if ( pre_TaggedType_asn1_Type ) 
    pre_TaggedType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_TaggedType_asn1_Type ) 
    post_TaggedType_asn1_Type( Me );

  if ( post_TaggedType ) 
    post_TaggedType( Me );
}


void default_trav_TagAttributes( const TagAttributes& Me )
{
  if ( pre_TagAttributes ) 
    pre_TagAttributes( Me );

  switch ( Me.choice() )
    {
    case Choices::c_AIMPLICIT:
      if ( pre_TagAttributes_Aimplicit ) 
        pre_TagAttributes_Aimplicit( Me );
      if ( trav_AIMPLICIT ) 
        trav_AIMPLICIT( Me.Aimplicit() );
      if ( post_TagAttributes_Aimplicit ) 
        post_TagAttributes_Aimplicit( Me );
      break;

    case Choices::c_AEXPLICIT:
      if ( pre_TagAttributes_Aexplicit ) 
        pre_TagAttributes_Aexplicit( Me );
      if ( trav_AEXPLICIT ) 
        trav_AEXPLICIT( Me.Aexplicit() );
      if ( post_TagAttributes_Aexplicit ) 
        post_TagAttributes_Aexplicit( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node TagAttributes: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_TagAttributes ) 
    post_TagAttributes( Me );
}


void default_trav_AnyType( const AnyType& Me )
{
  if ( pre_AnyType ) 
    pre_AnyType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ANY:
      if ( pre_AnyType_any ) 
        pre_AnyType_any( Me );
      if ( trav_ANY ) 
        trav_ANY( Me.any() );
      if ( post_AnyType_any ) 
        post_AnyType_any( Me );
      break;

    case Choices::c_AnyDefinedBy:
      if ( pre_AnyType_anyDefinedBy ) 
        pre_AnyType_anyDefinedBy( Me );
      if ( trav_AnyDefinedBy ) 
        trav_AnyDefinedBy( Me.anyDefinedBy() );
      if ( post_AnyType_anyDefinedBy ) 
        post_AnyType_anyDefinedBy( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node AnyType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_AnyType ) 
    post_AnyType( Me );
}


void default_trav_AnyDefinedBy( const AnyDefinedBy& Me )
{
  if ( pre_AnyDefinedBy ) 
    pre_AnyDefinedBy( Me );

  if ( pre_AnyDefinedBy_identifier ) 
    pre_AnyDefinedBy_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_AnyDefinedBy_identifier ) 
    post_AnyDefinedBy_identifier( Me );

  if ( post_AnyDefinedBy ) 
    post_AnyDefinedBy( Me );
}


void default_trav_UsefulType( const UsefulType& Me )
{
  if ( pre_UsefulType ) 
    pre_UsefulType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_GeneralizedTime:
      if ( pre_UsefulType_generalizedTime ) 
        pre_UsefulType_generalizedTime( Me );
      if ( trav_GeneralizedTime ) 
        trav_GeneralizedTime( Me.generalizedTime() );
      if ( post_UsefulType_generalizedTime ) 
        post_UsefulType_generalizedTime( Me );
      break;

    case Choices::c_UTCTime:
      if ( pre_UsefulType_utcTime ) 
        pre_UsefulType_utcTime( Me );
      if ( trav_UTCTime ) 
        trav_UTCTime( Me.utcTime() );
      if ( post_UsefulType_utcTime ) 
        post_UsefulType_utcTime( Me );
      break;

    case Choices::c_EXTERNAL:
      if ( pre_UsefulType_external ) 
        pre_UsefulType_external( Me );
      if ( trav_EXTERNAL ) 
        trav_EXTERNAL( Me.external() );
      if ( post_UsefulType_external ) 
        post_UsefulType_external( Me );
      break;

    case Choices::c_ObjectDescriptor:
      if ( pre_UsefulType_objectDescriptor ) 
        pre_UsefulType_objectDescriptor( Me );
      if ( trav_ObjectDescriptor ) 
        trav_ObjectDescriptor( Me.objectDescriptor() );
      if ( post_UsefulType_objectDescriptor ) 
        post_UsefulType_objectDescriptor( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UsefulType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UsefulType ) 
    post_UsefulType( Me );
}


void default_trav_EnumeratedType( const EnumeratedType& Me )
{
  if ( pre_EnumeratedType ) 
    pre_EnumeratedType( Me );

  if ( pre_EnumeratedType_enumeration ) 
    pre_EnumeratedType_enumeration( Me );
  if ( trav_Enumeration ) 
    trav_Enumeration( Me.enumeration() );
  if ( post_EnumeratedType_enumeration ) 
    post_EnumeratedType_enumeration( Me );

  if ( post_EnumeratedType ) 
    post_EnumeratedType( Me );
}


void default_trav_Enumeration( const Enumeration& Me )
{
  if ( pre_Enumeration ) 
    pre_Enumeration( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_Enumeration_namedNumber ) 
        pre_Enumeration_namedNumber( Me, i );
      if ( trav_NamedNumber ) 
        trav_NamedNumber( Me.namedNumber( i ) );
      if ( post_Enumeration_namedNumber ) 
        post_Enumeration_namedNumber( Me, i );
  }

  if ( post_Enumeration ) 
    post_Enumeration( Me );
}


void default_trav_NamedBitList( const NamedBitList& Me )
{
  if ( pre_NamedBitList ) 
    pre_NamedBitList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_NamedBitList_namedNumber ) 
        pre_NamedBitList_namedNumber( Me, i );
      if ( trav_NamedNumber ) 
        trav_NamedNumber( Me.namedNumber( i ) );
      if ( post_NamedBitList_namedNumber ) 
        post_NamedBitList_namedNumber( Me, i );
  }

  if ( post_NamedBitList ) 
    post_NamedBitList( Me );
}


void default_trav_Tag( const Tag& Me )
{
  if ( pre_Tag ) 
    pre_Tag( Me );

  if ( Me.is_present_classType())
    {
      if ( pre_Tag_classType ) 
        pre_Tag_classType( Me );
      if ( trav_ClassType ) 
        trav_ClassType( Me.classType() );
      if ( post_Tag_classType ) 
        post_Tag_classType( Me );
    }

  if ( pre_Tag_classNumber ) 
    pre_Tag_classNumber( Me );
  if ( trav_ClassNumber ) 
    trav_ClassNumber( Me.classNumber() );
  if ( post_Tag_classNumber ) 
    post_Tag_classNumber( Me );

  if ( post_Tag ) 
    post_Tag( Me );
}


void default_trav_ClassType( const ClassType& Me )
{
  if ( pre_ClassType ) 
    pre_ClassType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_UNIVERSAL:
      if ( pre_ClassType_universal ) 
        pre_ClassType_universal( Me );
      if ( trav_UNIVERSAL ) 
        trav_UNIVERSAL( Me.universal() );
      if ( post_ClassType_universal ) 
        post_ClassType_universal( Me );
      break;

    case Choices::c_APPLICATION:
      if ( pre_ClassType_application ) 
        pre_ClassType_application( Me );
      if ( trav_APPLICATION ) 
        trav_APPLICATION( Me.application() );
      if ( post_ClassType_application ) 
        post_ClassType_application( Me );
      break;

    case Choices::c_PRIVATE_:
      if ( pre_ClassType_private_ ) 
        pre_ClassType_private_( Me );
      if ( trav_PRIVATE_ ) 
        trav_PRIVATE_( Me.private_() );
      if ( post_ClassType_private_ ) 
        post_ClassType_private_( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ClassType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ClassType ) 
    post_ClassType( Me );
}


void default_trav_ClassNumber( const ClassNumber& Me )
{
  if ( pre_ClassNumber ) 
    pre_ClassNumber( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Number:
      if ( pre_ClassNumber_number ) 
        pre_ClassNumber_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_ClassNumber_number ) 
        post_ClassNumber_number( Me );
      break;

    case Choices::c_DefinedValue:
      if ( pre_ClassNumber_definedValue ) 
        pre_ClassNumber_definedValue( Me );
      if ( trav_DefinedValue ) 
        trav_DefinedValue( Me.definedValue() );
      if ( post_ClassNumber_definedValue ) 
        post_ClassNumber_definedValue( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ClassNumber: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ClassNumber ) 
    post_ClassNumber( Me );
}


void default_trav_SubType( const SubType& Me )
{
  if ( pre_SubType ) 
    pre_SubType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ParentSubType:
      if ( pre_SubType_parentSubType ) 
        pre_SubType_parentSubType( Me );
      if ( trav_ParentSubType ) 
        trav_ParentSubType( Me.parentSubType() );
      if ( post_SubType_parentSubType ) 
        post_SubType_parentSubType( Me );
      break;

    case Choices::c_SetSubType:
      if ( pre_SubType_setSubType ) 
        pre_SubType_setSubType( Me );
      if ( trav_SetSubType ) 
        trav_SetSubType( Me.setSubType() );
      if ( post_SubType_setSubType ) 
        post_SubType_setSubType( Me );
      break;

    case Choices::c_SequenceSubType:
      if ( pre_SubType_sequenceSubType ) 
        pre_SubType_sequenceSubType( Me );
      if ( trav_SequenceSubType ) 
        trav_SequenceSubType( Me.sequenceSubType() );
      if ( post_SubType_sequenceSubType ) 
        post_SubType_sequenceSubType( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node SubType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_SubType ) 
    post_SubType( Me );
}


void default_trav_PermittedAlphabet( const PermittedAlphabet& Me )
{
  if ( pre_PermittedAlphabet ) 
    pre_PermittedAlphabet( Me );

  if ( pre_PermittedAlphabet_subTypeSpec ) 
    pre_PermittedAlphabet_subTypeSpec( Me );
  if ( trav_SubTypeSpec ) 
    trav_SubTypeSpec( Me.subTypeSpec() );
  if ( post_PermittedAlphabet_subTypeSpec ) 
    post_PermittedAlphabet_subTypeSpec( Me );

  if ( post_PermittedAlphabet ) 
    post_PermittedAlphabet( Me );
}


void default_trav_SizeConstraint( const SizeConstraint& Me )
{
  if ( pre_SizeConstraint ) 
    pre_SizeConstraint( Me );

  if ( pre_SizeConstraint_subTypeSpec ) 
    pre_SizeConstraint_subTypeSpec( Me );
  if ( trav_SubTypeSpec ) 
    trav_SubTypeSpec( Me.subTypeSpec() );
  if ( post_SizeConstraint_subTypeSpec ) 
    post_SizeConstraint_subTypeSpec( Me );

  if ( post_SizeConstraint ) 
    post_SizeConstraint( Me );
}


void default_trav_ContainedSubType( const ContainedSubType& Me )
{
  if ( pre_ContainedSubType ) 
    pre_ContainedSubType( Me );

  if ( pre_ContainedSubType_asn1_Type ) 
    pre_ContainedSubType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_ContainedSubType_asn1_Type ) 
    post_ContainedSubType_asn1_Type( Me );

  if ( post_ContainedSubType ) 
    post_ContainedSubType( Me );
}


void default_trav_SingleValue( const SingleValue& Me )
{
  if ( pre_SingleValue ) 
    pre_SingleValue( Me );

  if ( pre_SingleValue_constraintValueAndAttributes ) 
    pre_SingleValue_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_SingleValue_constraintValueAndAttributes ) 
    post_SingleValue_constraintValueAndAttributes( Me );

  if ( post_SingleValue ) 
    post_SingleValue( Me );
}


void default_trav_SubTypeSpec( const SubTypeSpec& Me )
{
  if ( pre_SubTypeSpec ) 
    pre_SubTypeSpec( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_SubTypeSpec_subtypeValueSet ) 
        pre_SubTypeSpec_subtypeValueSet( Me, i );
      if ( trav_SubtypeValueSet ) 
        trav_SubtypeValueSet( Me.subtypeValueSet( i ) );
      if ( post_SubTypeSpec_subtypeValueSet ) 
        post_SubTypeSpec_subtypeValueSet( Me, i );
  }

  if ( post_SubTypeSpec ) 
    post_SubTypeSpec( Me );
}


void default_trav_ParentSubType( const ParentSubType& Me )
{
  if ( pre_ParentSubType ) 
    pre_ParentSubType( Me );

  if ( pre_ParentSubType_parentType ) 
    pre_ParentSubType_parentType( Me );
  if ( trav_ParentType ) 
    trav_ParentType( Me.parentType() );
  if ( post_ParentSubType_parentType ) 
    post_ParentSubType_parentType( Me );

  if ( pre_ParentSubType_subTypeSpec ) 
    pre_ParentSubType_subTypeSpec( Me );
  if ( trav_SubTypeSpec ) 
    trav_SubTypeSpec( Me.subTypeSpec() );
  if ( post_ParentSubType_subTypeSpec ) 
    post_ParentSubType_subTypeSpec( Me );

  if ( post_ParentSubType ) 
    post_ParentSubType( Me );
}


void default_trav_ParentType( const ParentType& Me )
{
  if ( pre_ParentType ) 
    pre_ParentType( Me );

  if ( pre_ParentType_asn1_Type ) 
    pre_ParentType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_ParentType_asn1_Type ) 
    post_ParentType_asn1_Type( Me );

  if ( post_ParentType ) 
    post_ParentType( Me );
}


void default_trav_SetSubType( const SetSubType& Me )
{
  if ( pre_SetSubType ) 
    pre_SetSubType( Me );

  if ( pre_SetSubType_sizeConstraint ) 
    pre_SetSubType_sizeConstraint( Me );
  if ( trav_SizeConstraint ) 
    trav_SizeConstraint( Me.sizeConstraint() );
  if ( post_SetSubType_sizeConstraint ) 
    post_SetSubType_sizeConstraint( Me );

  if ( pre_SetSubType_asn1_Type ) 
    pre_SetSubType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_SetSubType_asn1_Type ) 
    post_SetSubType_asn1_Type( Me );

  if ( post_SetSubType ) 
    post_SetSubType( Me );
}


void default_trav_SequenceSubType( const SequenceSubType& Me )
{
  if ( pre_SequenceSubType ) 
    pre_SequenceSubType( Me );

  if ( pre_SequenceSubType_sizeConstraint ) 
    pre_SequenceSubType_sizeConstraint( Me );
  if ( trav_SizeConstraint ) 
    trav_SizeConstraint( Me.sizeConstraint() );
  if ( post_SequenceSubType_sizeConstraint ) 
    post_SequenceSubType_sizeConstraint( Me );

  if ( pre_SequenceSubType_asn1_Type ) 
    pre_SequenceSubType_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_SequenceSubType_asn1_Type ) 
    post_SequenceSubType_asn1_Type( Me );

  if ( post_SequenceSubType ) 
    post_SequenceSubType( Me );
}


void default_trav_SubtypeValueSet( const SubtypeValueSet& Me )
{
  if ( pre_SubtypeValueSet ) 
    pre_SubtypeValueSet( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SingleValue:
      if ( pre_SubtypeValueSet_singleValue ) 
        pre_SubtypeValueSet_singleValue( Me );
      if ( trav_SingleValue ) 
        trav_SingleValue( Me.singleValue() );
      if ( post_SubtypeValueSet_singleValue ) 
        post_SubtypeValueSet_singleValue( Me );
      break;

    case Choices::c_ContainedSubType:
      if ( pre_SubtypeValueSet_containedSubType ) 
        pre_SubtypeValueSet_containedSubType( Me );
      if ( trav_ContainedSubType ) 
        trav_ContainedSubType( Me.containedSubType() );
      if ( post_SubtypeValueSet_containedSubType ) 
        post_SubtypeValueSet_containedSubType( Me );
      break;

    case Choices::c_ValueRange:
      if ( pre_SubtypeValueSet_valueRange ) 
        pre_SubtypeValueSet_valueRange( Me );
      if ( trav_ValueRange ) 
        trav_ValueRange( Me.valueRange() );
      if ( post_SubtypeValueSet_valueRange ) 
        post_SubtypeValueSet_valueRange( Me );
      break;

    case Choices::c_PermittedAlphabet:
      if ( pre_SubtypeValueSet_permittedAlphabet ) 
        pre_SubtypeValueSet_permittedAlphabet( Me );
      if ( trav_PermittedAlphabet ) 
        trav_PermittedAlphabet( Me.permittedAlphabet() );
      if ( post_SubtypeValueSet_permittedAlphabet ) 
        post_SubtypeValueSet_permittedAlphabet( Me );
      break;

    case Choices::c_SizeConstraint:
      if ( pre_SubtypeValueSet_sizeConstraint ) 
        pre_SubtypeValueSet_sizeConstraint( Me );
      if ( trav_SizeConstraint ) 
        trav_SizeConstraint( Me.sizeConstraint() );
      if ( post_SubtypeValueSet_sizeConstraint ) 
        post_SubtypeValueSet_sizeConstraint( Me );
      break;

    case Choices::c_InnerTypeConstraints:
      if ( pre_SubtypeValueSet_innerTypeConstraints ) 
        pre_SubtypeValueSet_innerTypeConstraints( Me );
      if ( trav_InnerTypeConstraints ) 
        trav_InnerTypeConstraints( Me.innerTypeConstraints() );
      if ( post_SubtypeValueSet_innerTypeConstraints ) 
        post_SubtypeValueSet_innerTypeConstraints( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node SubtypeValueSet: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_SubtypeValueSet ) 
    post_SubtypeValueSet( Me );
}


void default_trav_ValueRange( const ValueRange& Me )
{
  if ( pre_ValueRange ) 
    pre_ValueRange( Me );

  if ( pre_ValueRange_lowerEndpoint ) 
    pre_ValueRange_lowerEndpoint( Me );
  if ( trav_LowerEndpoint ) 
    trav_LowerEndpoint( Me.lowerEndpoint() );
  if ( post_ValueRange_lowerEndpoint ) 
    post_ValueRange_lowerEndpoint( Me );

  if ( pre_ValueRange_upperEndpoint ) 
    pre_ValueRange_upperEndpoint( Me );
  if ( trav_UpperEndpoint ) 
    trav_UpperEndpoint( Me.upperEndpoint() );
  if ( post_ValueRange_upperEndpoint ) 
    post_ValueRange_upperEndpoint( Me );

  if ( post_ValueRange ) 
    post_ValueRange( Me );
}


void default_trav_LowerEndpoint( const LowerEndpoint& Me )
{
  if ( pre_LowerEndpoint ) 
    pre_LowerEndpoint( Me );

  if ( pre_LowerEndpoint_lowerEndValue ) 
    pre_LowerEndpoint_lowerEndValue( Me );
  if ( trav_LowerEndValue ) 
    trav_LowerEndValue( Me.lowerEndValue() );
  if ( post_LowerEndpoint_lowerEndValue ) 
    post_LowerEndpoint_lowerEndValue( Me );

  if ( Me.is_present_inclusive())
    {
      if ( pre_LowerEndpoint_inclusive ) 
        pre_LowerEndpoint_inclusive( Me );
      if ( trav_INCLUSIVE ) 
        trav_INCLUSIVE( Me.inclusive() );
      if ( post_LowerEndpoint_inclusive ) 
        post_LowerEndpoint_inclusive( Me );
    }

  if ( post_LowerEndpoint ) 
    post_LowerEndpoint( Me );
}


void default_trav_UpperEndpoint( const UpperEndpoint& Me )
{
  if ( pre_UpperEndpoint ) 
    pre_UpperEndpoint( Me );

  if ( pre_UpperEndpoint_upperEndValue ) 
    pre_UpperEndpoint_upperEndValue( Me );
  if ( trav_UpperEndValue ) 
    trav_UpperEndValue( Me.upperEndValue() );
  if ( post_UpperEndpoint_upperEndValue ) 
    post_UpperEndpoint_upperEndValue( Me );

  if ( Me.is_present_inclusive())
    {
      if ( pre_UpperEndpoint_inclusive ) 
        pre_UpperEndpoint_inclusive( Me );
      if ( trav_INCLUSIVE ) 
        trav_INCLUSIVE( Me.inclusive() );
      if ( post_UpperEndpoint_inclusive ) 
        post_UpperEndpoint_inclusive( Me );
    }

  if ( post_UpperEndpoint ) 
    post_UpperEndpoint( Me );
}


void default_trav_UpperEndValue( const UpperEndValue& Me )
{
  if ( pre_UpperEndValue ) 
    pre_UpperEndValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintValueAndAttributes:
      if ( pre_UpperEndValue_constraintValueAndAttributes ) 
        pre_UpperEndValue_constraintValueAndAttributes( Me );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
      if ( post_UpperEndValue_constraintValueAndAttributes ) 
        post_UpperEndValue_constraintValueAndAttributes( Me );
      break;

    case Choices::c_Max:
      if ( pre_UpperEndValue_max ) 
        pre_UpperEndValue_max( Me );
      if ( trav_Max ) 
        trav_Max( Me.max() );
      if ( post_UpperEndValue_max ) 
        post_UpperEndValue_max( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node UpperEndValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_UpperEndValue ) 
    post_UpperEndValue( Me );
}


void default_trav_LowerEndValue( const LowerEndValue& Me )
{
  if ( pre_LowerEndValue ) 
    pre_LowerEndValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_ConstraintValueAndAttributes:
      if ( pre_LowerEndValue_constraintValueAndAttributes ) 
        pre_LowerEndValue_constraintValueAndAttributes( Me );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
      if ( post_LowerEndValue_constraintValueAndAttributes ) 
        post_LowerEndValue_constraintValueAndAttributes( Me );
      break;

    case Choices::c_Min:
      if ( pre_LowerEndValue_min ) 
        pre_LowerEndValue_min( Me );
      if ( trav_Min ) 
        trav_Min( Me.min() );
      if ( post_LowerEndValue_min ) 
        post_LowerEndValue_min( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node LowerEndValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_LowerEndValue ) 
    post_LowerEndValue( Me );
}


void default_trav_InnerTypeConstraints( const InnerTypeConstraints& Me )
{
  if ( pre_InnerTypeConstraints ) 
    pre_InnerTypeConstraints( Me );

  switch ( Me.choice() )
    {
    case Choices::c_WithComponent:
      if ( pre_InnerTypeConstraints_withComponent ) 
        pre_InnerTypeConstraints_withComponent( Me );
      if ( trav_WithComponent ) 
        trav_WithComponent( Me.withComponent() );
      if ( post_InnerTypeConstraints_withComponent ) 
        post_InnerTypeConstraints_withComponent( Me );
      break;

    case Choices::c_WithComponents:
      if ( pre_InnerTypeConstraints_withComponents ) 
        pre_InnerTypeConstraints_withComponents( Me );
      if ( trav_WithComponents ) 
        trav_WithComponents( Me.withComponents() );
      if ( post_InnerTypeConstraints_withComponents ) 
        post_InnerTypeConstraints_withComponents( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node InnerTypeConstraints: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_InnerTypeConstraints ) 
    post_InnerTypeConstraints( Me );
}


void default_trav_WithComponent( const WithComponent& Me )
{
  if ( pre_WithComponent ) 
    pre_WithComponent( Me );

  if ( pre_WithComponent_singleTypeConstraint ) 
    pre_WithComponent_singleTypeConstraint( Me );
  if ( trav_SingleTypeConstraint ) 
    trav_SingleTypeConstraint( Me.singleTypeConstraint() );
  if ( post_WithComponent_singleTypeConstraint ) 
    post_WithComponent_singleTypeConstraint( Me );

  if ( post_WithComponent ) 
    post_WithComponent( Me );
}


void default_trav_WithComponents( const WithComponents& Me )
{
  if ( pre_WithComponents ) 
    pre_WithComponents( Me );

  if ( pre_WithComponents_multipleTypeConstraints ) 
    pre_WithComponents_multipleTypeConstraints( Me );
  if ( trav_MultipleTypeConstraints ) 
    trav_MultipleTypeConstraints( Me.multipleTypeConstraints() );
  if ( post_WithComponents_multipleTypeConstraints ) 
    post_WithComponents_multipleTypeConstraints( Me );

  if ( post_WithComponents ) 
    post_WithComponents( Me );
}


void default_trav_FullSpecification( const FullSpecification& Me )
{
  if ( pre_FullSpecification ) 
    pre_FullSpecification( Me );

  if ( pre_FullSpecification_typeConstraints ) 
    pre_FullSpecification_typeConstraints( Me );
  if ( trav_TypeConstraints ) 
    trav_TypeConstraints( Me.typeConstraints() );
  if ( post_FullSpecification_typeConstraints ) 
    post_FullSpecification_typeConstraints( Me );

  if ( post_FullSpecification ) 
    post_FullSpecification( Me );
}


void default_trav_PartialSpecification( const PartialSpecification& Me )
{
  if ( pre_PartialSpecification ) 
    pre_PartialSpecification( Me );

  if ( pre_PartialSpecification_typeConstraints ) 
    pre_PartialSpecification_typeConstraints( Me );
  if ( trav_TypeConstraints ) 
    trav_TypeConstraints( Me.typeConstraints() );
  if ( post_PartialSpecification_typeConstraints ) 
    post_PartialSpecification_typeConstraints( Me );

  if ( post_PartialSpecification ) 
    post_PartialSpecification( Me );
}


void default_trav_SingleTypeConstraint( const SingleTypeConstraint& Me )
{
  if ( pre_SingleTypeConstraint ) 
    pre_SingleTypeConstraint( Me );

  if ( pre_SingleTypeConstraint_subTypeSpec ) 
    pre_SingleTypeConstraint_subTypeSpec( Me );
  if ( trav_SubTypeSpec ) 
    trav_SubTypeSpec( Me.subTypeSpec() );
  if ( post_SingleTypeConstraint_subTypeSpec ) 
    post_SingleTypeConstraint_subTypeSpec( Me );

  if ( post_SingleTypeConstraint ) 
    post_SingleTypeConstraint( Me );
}


void default_trav_MultipleTypeConstraints( const MultipleTypeConstraints& Me )
{
  if ( pre_MultipleTypeConstraints ) 
    pre_MultipleTypeConstraints( Me );

  switch ( Me.choice() )
    {
    case Choices::c_FullSpecification:
      if ( pre_MultipleTypeConstraints_fullSpecification ) 
        pre_MultipleTypeConstraints_fullSpecification( Me );
      if ( trav_FullSpecification ) 
        trav_FullSpecification( Me.fullSpecification() );
      if ( post_MultipleTypeConstraints_fullSpecification ) 
        post_MultipleTypeConstraints_fullSpecification( Me );
      break;

    case Choices::c_PartialSpecification:
      if ( pre_MultipleTypeConstraints_partialSpecification ) 
        pre_MultipleTypeConstraints_partialSpecification( Me );
      if ( trav_PartialSpecification ) 
        trav_PartialSpecification( Me.partialSpecification() );
      if ( post_MultipleTypeConstraints_partialSpecification ) 
        post_MultipleTypeConstraints_partialSpecification( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node MultipleTypeConstraints: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_MultipleTypeConstraints ) 
    post_MultipleTypeConstraints( Me );
}


void default_trav_TypeConstraints( const TypeConstraints& Me )
{
  if ( pre_TypeConstraints ) 
    pre_TypeConstraints( Me );

  if ( pre_TypeConstraints_namedConstraintList ) 
    pre_TypeConstraints_namedConstraintList( Me );
  if ( trav_NamedConstraintList ) 
    trav_NamedConstraintList( Me.namedConstraintList() );
  if ( post_TypeConstraints_namedConstraintList ) 
    post_TypeConstraints_namedConstraintList( Me );

  if ( post_TypeConstraints ) 
    post_TypeConstraints( Me );
}


void default_trav_NamedConstraintList( const NamedConstraintList& Me )
{
  if ( pre_NamedConstraintList ) 
    pre_NamedConstraintList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_NamedConstraintList_namedConstraint ) 
        pre_NamedConstraintList_namedConstraint( Me, i );
      if ( trav_NamedConstraint ) 
        trav_NamedConstraint( Me.namedConstraint( i ) );
      if ( post_NamedConstraintList_namedConstraint ) 
        post_NamedConstraintList_namedConstraint( Me, i );
  }

  if ( post_NamedConstraintList ) 
    post_NamedConstraintList( Me );
}


void default_trav_NamedConstraint( const NamedConstraint& Me )
{
  if ( pre_NamedConstraint ) 
    pre_NamedConstraint( Me );

  if ( pre_NamedConstraint_identifier ) 
    pre_NamedConstraint_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_NamedConstraint_identifier ) 
    post_NamedConstraint_identifier( Me );

  if ( pre_NamedConstraint_constraint ) 
    pre_NamedConstraint_constraint( Me );
  if ( trav_Constraint ) 
    trav_Constraint( Me.constraint() );
  if ( post_NamedConstraint_constraint ) 
    post_NamedConstraint_constraint( Me );

  if ( post_NamedConstraint ) 
    post_NamedConstraint( Me );
}


void default_trav_ValueConstraint( const ValueConstraint& Me )
{
  if ( pre_ValueConstraint ) 
    pre_ValueConstraint( Me );

  if ( pre_ValueConstraint_subTypeSpec ) 
    pre_ValueConstraint_subTypeSpec( Me );
  if ( trav_SubTypeSpec ) 
    trav_SubTypeSpec( Me.subTypeSpec() );
  if ( post_ValueConstraint_subTypeSpec ) 
    post_ValueConstraint_subTypeSpec( Me );

  if ( post_ValueConstraint ) 
    post_ValueConstraint( Me );
}


void default_trav_PresenceConstraint( const PresenceConstraint& Me )
{
  if ( pre_PresenceConstraint ) 
    pre_PresenceConstraint( Me );

  switch ( Me.choice() )
    {
    case Choices::c_PRESENT:
      if ( pre_PresenceConstraint_present ) 
        pre_PresenceConstraint_present( Me );
      if ( trav_PRESENT ) 
        trav_PRESENT( Me.present() );
      if ( post_PresenceConstraint_present ) 
        post_PresenceConstraint_present( Me );
      break;

    case Choices::c_ABSENT:
      if ( pre_PresenceConstraint_absent ) 
        pre_PresenceConstraint_absent( Me );
      if ( trav_ABSENT ) 
        trav_ABSENT( Me.absent() );
      if ( post_PresenceConstraint_absent ) 
        post_PresenceConstraint_absent( Me );
      break;

    case Choices::c_OPTIONAL:
      if ( pre_PresenceConstraint_optional ) 
        pre_PresenceConstraint_optional( Me );
      if ( trav_OPTIONAL ) 
        trav_OPTIONAL( Me.optional() );
      if ( post_PresenceConstraint_optional ) 
        post_PresenceConstraint_optional( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node PresenceConstraint: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_PresenceConstraint ) 
    post_PresenceConstraint( Me );
}


void default_trav_Constraint( const Constraint& Me )
{
  if ( pre_Constraint ) 
    pre_Constraint( Me );

  if ( Me.is_present_valueConstraint())
    {
      if ( pre_Constraint_valueConstraint ) 
        pre_Constraint_valueConstraint( Me );
      if ( trav_ValueConstraint ) 
        trav_ValueConstraint( Me.valueConstraint() );
      if ( post_Constraint_valueConstraint ) 
        post_Constraint_valueConstraint( Me );
    }

  if ( Me.is_present_presenceConstraint())
    {
      if ( pre_Constraint_presenceConstraint ) 
        pre_Constraint_presenceConstraint( Me );
      if ( trav_PresenceConstraint ) 
        trav_PresenceConstraint( Me.presenceConstraint() );
      if ( post_Constraint_presenceConstraint ) 
        post_Constraint_presenceConstraint( Me );
    }

  if ( post_Constraint ) 
    post_Constraint( Me );
}


void default_trav_ASN1_LocalTypes( const ASN1_LocalTypes& Me )
{
  if ( pre_ASN1_LocalTypes ) 
    pre_ASN1_LocalTypes( Me );

  if ( pre_ASN1_LocalTypes_typeAssignmentList ) 
    pre_ASN1_LocalTypes_typeAssignmentList( Me );
  if ( trav_TypeAssignmentList ) 
    trav_TypeAssignmentList( Me.typeAssignmentList() );
  if ( post_ASN1_LocalTypes_typeAssignmentList ) 
    post_ASN1_LocalTypes_typeAssignmentList( Me );

  if ( post_ASN1_LocalTypes ) 
    post_ASN1_LocalTypes( Me );
}


void default_trav_TypeAssignmentList( const TypeAssignmentList& Me )
{
  if ( pre_TypeAssignmentList ) 
    pre_TypeAssignmentList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_TypeAssignmentList_typeAssignment ) 
        pre_TypeAssignmentList_typeAssignment( Me, i );
      if ( trav_TypeAssignment ) 
        trav_TypeAssignment( Me.typeAssignment( i ) );
      if ( post_TypeAssignmentList_typeAssignment ) 
        post_TypeAssignmentList_typeAssignment( Me, i );
  }

  if ( post_TypeAssignmentList ) 
    post_TypeAssignmentList( Me );
}


void default_trav_TypeAssignment( const TypeAssignment& Me )
{
  if ( pre_TypeAssignment ) 
    pre_TypeAssignment( Me );

  if ( pre_TypeAssignment_typeReference ) 
    pre_TypeAssignment_typeReference( Me );
  if ( trav_TypeReference ) 
    trav_TypeReference( Me.typeReference() );
  if ( post_TypeAssignment_typeReference ) 
    post_TypeAssignment_typeReference( Me );

  if ( pre_TypeAssignment_asn1_Type ) 
    pre_TypeAssignment_asn1_Type( Me );
  if ( trav_ASN1_Type ) 
    trav_ASN1_Type( Me.asn1_Type() );
  if ( post_TypeAssignment_asn1_Type ) 
    post_TypeAssignment_asn1_Type( Me );

  if ( post_TypeAssignment ) 
    post_TypeAssignment( Me );
}


void default_trav_ASN1_Value( const ASN1_Value& Me )
{
  if ( pre_ASN1_Value ) 
    pre_ASN1_Value( Me );

  switch ( Me.choice() )
    {
    case Choices::c_BitStringValue:
      if ( pre_ASN1_Value_bitStringValue ) 
        pre_ASN1_Value_bitStringValue( Me );
      if ( trav_BitStringValue ) 
        trav_BitStringValue( Me.bitStringValue() );
      if ( post_ASN1_Value_bitStringValue ) 
        post_ASN1_Value_bitStringValue( Me );
      break;

    case Choices::c_NullValue:
      if ( pre_ASN1_Value_nullValue ) 
        pre_ASN1_Value_nullValue( Me );
      if ( trav_NullValue ) 
        trav_NullValue( Me.nullValue() );
      if ( post_ASN1_Value_nullValue ) 
        post_ASN1_Value_nullValue( Me );
      break;

    case Choices::c_SequenceValue:
      if ( pre_ASN1_Value_sequenceValue ) 
        pre_ASN1_Value_sequenceValue( Me );
      if ( trav_SequenceValue ) 
        trav_SequenceValue( Me.sequenceValue() );
      if ( post_ASN1_Value_sequenceValue ) 
        post_ASN1_Value_sequenceValue( Me );
      break;

    case Choices::c_SequenceOfValue:
      if ( pre_ASN1_Value_sequenceOfValue ) 
        pre_ASN1_Value_sequenceOfValue( Me );
      if ( trav_SequenceOfValue ) 
        trav_SequenceOfValue( Me.sequenceOfValue() );
      if ( post_ASN1_Value_sequenceOfValue ) 
        post_ASN1_Value_sequenceOfValue( Me );
      break;

    case Choices::c_SetValue:
      if ( pre_ASN1_Value_setValue ) 
        pre_ASN1_Value_setValue( Me );
      if ( trav_SetValue ) 
        trav_SetValue( Me.setValue() );
      if ( post_ASN1_Value_setValue ) 
        post_ASN1_Value_setValue( Me );
      break;

    case Choices::c_SetOfValue:
      if ( pre_ASN1_Value_setOfValue ) 
        pre_ASN1_Value_setOfValue( Me );
      if ( trav_SetOfValue ) 
        trav_SetOfValue( Me.setOfValue() );
      if ( post_ASN1_Value_setOfValue ) 
        post_ASN1_Value_setOfValue( Me );
      break;

    case Choices::c_ChoiceValue:
      if ( pre_ASN1_Value_choiceValue ) 
        pre_ASN1_Value_choiceValue( Me );
      if ( trav_ChoiceValue ) 
        trav_ChoiceValue( Me.choiceValue() );
      if ( post_ASN1_Value_choiceValue ) 
        post_ASN1_Value_choiceValue( Me );
      break;

    case Choices::c_SelectionValue:
      if ( pre_ASN1_Value_selectionValue ) 
        pre_ASN1_Value_selectionValue( Me );
      if ( trav_SelectionValue ) 
        trav_SelectionValue( Me.selectionValue() );
      if ( post_ASN1_Value_selectionValue ) 
        post_ASN1_Value_selectionValue( Me );
      break;

    case Choices::c_AnyValue:
      if ( pre_ASN1_Value_anyValue ) 
        pre_ASN1_Value_anyValue( Me );
      if ( trav_AnyValue ) 
        trav_AnyValue( Me.anyValue() );
      if ( post_ASN1_Value_anyValue ) 
        post_ASN1_Value_anyValue( Me );
      break;

    case Choices::c_ObjectIdentifierValue:
      if ( pre_ASN1_Value_objectIdentifierValue ) 
        pre_ASN1_Value_objectIdentifierValue( Me );
      if ( trav_ObjectIdentifierValue ) 
        trav_ObjectIdentifierValue( Me.objectIdentifierValue() );
      if ( post_ASN1_Value_objectIdentifierValue ) 
        post_ASN1_Value_objectIdentifierValue( Me );
      break;

    case Choices::c_RealValue:
      if ( pre_ASN1_Value_realValue ) 
        pre_ASN1_Value_realValue( Me );
      if ( trav_RealValue ) 
        trav_RealValue( Me.realValue() );
      if ( post_ASN1_Value_realValue ) 
        post_ASN1_Value_realValue( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ASN1_Value: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ASN1_Value ) 
    post_ASN1_Value( Me );
}


void default_trav_BitStringValue( const BitStringValue& Me )
{
  if ( pre_BitStringValue ) 
    pre_BitStringValue( Me );

  if ( pre_BitStringValue_identifierList ) 
    pre_BitStringValue_identifierList( Me );
  if ( trav_IdentifierList ) 
    trav_IdentifierList( Me.identifierList() );
  if ( post_BitStringValue_identifierList ) 
    post_BitStringValue_identifierList( Me );

  if ( post_BitStringValue ) 
    post_BitStringValue( Me );
}


void default_trav_IdentifierList( const IdentifierList& Me )
{
  if ( pre_IdentifierList ) 
    pre_IdentifierList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_IdentifierList_identifier ) 
        pre_IdentifierList_identifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.identifier( i ) );
      if ( post_IdentifierList_identifier ) 
        post_IdentifierList_identifier( Me, i );
  }

  if ( post_IdentifierList ) 
    post_IdentifierList( Me );
}


void default_trav_SequenceValue( const SequenceValue& Me )
{
  if ( pre_SequenceValue ) 
    pre_SequenceValue( Me );

  if ( pre_SequenceValue_elementValueList ) 
    pre_SequenceValue_elementValueList( Me );
  if ( trav_ElementValueList ) 
    trav_ElementValueList( Me.elementValueList() );
  if ( post_SequenceValue_elementValueList ) 
    post_SequenceValue_elementValueList( Me );

  if ( post_SequenceValue ) 
    post_SequenceValue( Me );
}


void default_trav_ElementValueList( const ElementValueList& Me )
{
  if ( pre_ElementValueList ) 
    pre_ElementValueList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ElementValueList_namedValue ) 
        pre_ElementValueList_namedValue( Me, i );
      if ( trav_NamedValue ) 
        trav_NamedValue( Me.namedValue( i ) );
      if ( post_ElementValueList_namedValue ) 
        post_ElementValueList_namedValue( Me, i );
  }

  if ( post_ElementValueList ) 
    post_ElementValueList( Me );
}


void default_trav_SequenceOfValue( const SequenceOfValue& Me )
{
  if ( pre_SequenceOfValue ) 
    pre_SequenceOfValue( Me );

  if ( pre_SequenceOfValue_asn1_ValueList ) 
    pre_SequenceOfValue_asn1_ValueList( Me );
  if ( trav_ASN1_ValueList ) 
    trav_ASN1_ValueList( Me.asn1_ValueList() );
  if ( post_SequenceOfValue_asn1_ValueList ) 
    post_SequenceOfValue_asn1_ValueList( Me );

  if ( post_SequenceOfValue ) 
    post_SequenceOfValue( Me );
}


void default_trav_ASN1_ValueList( const ASN1_ValueList& Me )
{
  if ( pre_ASN1_ValueList ) 
    pre_ASN1_ValueList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ASN1_ValueList_constraintValueAndAttributes ) 
        pre_ASN1_ValueList_constraintValueAndAttributes( Me, i );
      if ( trav_ConstraintValueAndAttributes ) 
        trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes( i ) );
      if ( post_ASN1_ValueList_constraintValueAndAttributes ) 
        post_ASN1_ValueList_constraintValueAndAttributes( Me, i );
  }

  if ( post_ASN1_ValueList ) 
    post_ASN1_ValueList( Me );
}


void default_trav_SetValue( const SetValue& Me )
{
  if ( pre_SetValue ) 
    pre_SetValue( Me );

  if ( pre_SetValue_elementValueList ) 
    pre_SetValue_elementValueList( Me );
  if ( trav_ElementValueList ) 
    trav_ElementValueList( Me.elementValueList() );
  if ( post_SetValue_elementValueList ) 
    post_SetValue_elementValueList( Me );

  if ( post_SetValue ) 
    post_SetValue( Me );
}


void default_trav_SetOfValue( const SetOfValue& Me )
{
  if ( pre_SetOfValue ) 
    pre_SetOfValue( Me );

  if ( pre_SetOfValue_asn1_ValueList ) 
    pre_SetOfValue_asn1_ValueList( Me );
  if ( trav_ASN1_ValueList ) 
    trav_ASN1_ValueList( Me.asn1_ValueList() );
  if ( post_SetOfValue_asn1_ValueList ) 
    post_SetOfValue_asn1_ValueList( Me );

  if ( post_SetOfValue ) 
    post_SetOfValue( Me );
}


void default_trav_ChoiceValue( const ChoiceValue& Me )
{
  if ( pre_ChoiceValue ) 
    pre_ChoiceValue( Me );

  if ( pre_ChoiceValue_namedValue ) 
    pre_ChoiceValue_namedValue( Me );
  if ( trav_NamedValue ) 
    trav_NamedValue( Me.namedValue() );
  if ( post_ChoiceValue_namedValue ) 
    post_ChoiceValue_namedValue( Me );

  if ( post_ChoiceValue ) 
    post_ChoiceValue( Me );
}


void default_trav_SelectionValue( const SelectionValue& Me )
{
  if ( pre_SelectionValue ) 
    pre_SelectionValue( Me );

  if ( pre_SelectionValue_namedValue ) 
    pre_SelectionValue_namedValue( Me );
  if ( trav_NamedValue ) 
    trav_NamedValue( Me.namedValue() );
  if ( post_SelectionValue_namedValue ) 
    post_SelectionValue_namedValue( Me );

  if ( post_SelectionValue ) 
    post_SelectionValue( Me );
}


void default_trav_AnyValue( const AnyValue& Me )
{
  if ( pre_AnyValue ) 
    pre_AnyValue( Me );

  if ( pre_AnyValue_referenceType ) 
    pre_AnyValue_referenceType( Me );
  if ( trav_ReferenceType ) 
    trav_ReferenceType( Me.referenceType() );
  if ( post_AnyValue_referenceType ) 
    post_AnyValue_referenceType( Me );

  if ( pre_AnyValue_constraintValueAndAttributes ) 
    pre_AnyValue_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_AnyValue_constraintValueAndAttributes ) 
    post_AnyValue_constraintValueAndAttributes( Me );

  if ( post_AnyValue ) 
    post_AnyValue( Me );
}


void default_trav_NamedValue( const NamedValue& Me )
{
  if ( pre_NamedValue ) 
    pre_NamedValue( Me );

  if ( pre_NamedValue_identifier ) 
    pre_NamedValue_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_NamedValue_identifier ) 
    post_NamedValue_identifier( Me );

  if ( pre_NamedValue_constraintValueAndAttributes ) 
    pre_NamedValue_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_NamedValue_constraintValueAndAttributes ) 
    post_NamedValue_constraintValueAndAttributes( Me );

  if ( post_NamedValue ) 
    post_NamedValue( Me );
}


void default_trav_ObjectIdentifierValue( const ObjectIdentifierValue& Me )
{
  if ( pre_ObjectIdentifierValue ) 
    pre_ObjectIdentifierValue( Me );

  if ( pre_ObjectIdentifierValue_objIdComponentList ) 
    pre_ObjectIdentifierValue_objIdComponentList( Me );
  if ( trav_ObjIdComponentList ) 
    trav_ObjIdComponentList( Me.objIdComponentList() );
  if ( post_ObjectIdentifierValue_objIdComponentList ) 
    post_ObjectIdentifierValue_objIdComponentList( Me );

  if ( post_ObjectIdentifierValue ) 
    post_ObjectIdentifierValue( Me );
}


void default_trav_ObjIdComponentList( const ObjIdComponentList& Me )
{
  if ( pre_ObjIdComponentList ) 
    pre_ObjIdComponentList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_ObjIdComponentList_objIdComponent ) 
        pre_ObjIdComponentList_objIdComponent( Me, i );
      if ( trav_ObjIdComponent ) 
        trav_ObjIdComponent( Me.objIdComponent( i ) );
      if ( post_ObjIdComponentList_objIdComponent ) 
        post_ObjIdComponentList_objIdComponent( Me, i );
  }

  if ( post_ObjIdComponentList ) 
    post_ObjIdComponentList( Me );
}


void default_trav_ObjIdComponent( const ObjIdComponent& Me )
{
  if ( pre_ObjIdComponent ) 
    pre_ObjIdComponent( Me );

  switch ( Me.choice() )
    {
    case Choices::c_NameForm:
      if ( pre_ObjIdComponent_nameForm ) 
        pre_ObjIdComponent_nameForm( Me );
      if ( trav_NameForm ) 
        trav_NameForm( Me.nameForm() );
      if ( post_ObjIdComponent_nameForm ) 
        post_ObjIdComponent_nameForm( Me );
      break;

    case Choices::c_NumberForm:
      if ( pre_ObjIdComponent_numberForm ) 
        pre_ObjIdComponent_numberForm( Me );
      if ( trav_NumberForm ) 
        trav_NumberForm( Me.numberForm() );
      if ( post_ObjIdComponent_numberForm ) 
        post_ObjIdComponent_numberForm( Me );
      break;

    case Choices::c_NameAndNumberForm:
      if ( pre_ObjIdComponent_nameAndNumberForm ) 
        pre_ObjIdComponent_nameAndNumberForm( Me );
      if ( trav_NameAndNumberForm ) 
        trav_NameAndNumberForm( Me.nameAndNumberForm() );
      if ( post_ObjIdComponent_nameAndNumberForm ) 
        post_ObjIdComponent_nameAndNumberForm( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node ObjIdComponent: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_ObjIdComponent ) 
    post_ObjIdComponent( Me );
}


void default_trav_NameForm( const NameForm& Me )
{
  if ( pre_NameForm ) 
    pre_NameForm( Me );

  if ( pre_NameForm_identifier ) 
    pre_NameForm_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_NameForm_identifier ) 
    post_NameForm_identifier( Me );

  if ( post_NameForm ) 
    post_NameForm( Me );
}


void default_trav_NumberForm( const NumberForm& Me )
{
  if ( pre_NumberForm ) 
    pre_NumberForm( Me );

  if ( pre_NumberForm_number ) 
    pre_NumberForm_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_NumberForm_number ) 
    post_NumberForm_number( Me );

  if ( post_NumberForm ) 
    post_NumberForm( Me );
}


void default_trav_NameAndNumberForm( const NameAndNumberForm& Me )
{
  if ( pre_NameAndNumberForm ) 
    pre_NameAndNumberForm( Me );

  if ( pre_NameAndNumberForm_nameForm ) 
    pre_NameAndNumberForm_nameForm( Me );
  if ( trav_NameForm ) 
    trav_NameForm( Me.nameForm() );
  if ( post_NameAndNumberForm_nameForm ) 
    post_NameAndNumberForm_nameForm( Me );

  if ( pre_NameAndNumberForm_numberForm ) 
    pre_NameAndNumberForm_numberForm( Me );
  if ( trav_NumberForm ) 
    trav_NumberForm( Me.numberForm() );
  if ( post_NameAndNumberForm_numberForm ) 
    post_NameAndNumberForm_numberForm( Me );

  if ( post_NameAndNumberForm ) 
    post_NameAndNumberForm( Me );
}


void default_trav_RealValue( const RealValue& Me )
{
  if ( pre_RealValue ) 
    pre_RealValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_NumericRealValue:
      if ( pre_RealValue_numericRealValue ) 
        pre_RealValue_numericRealValue( Me );
      if ( trav_NumericRealValue ) 
        trav_NumericRealValue( Me.numericRealValue() );
      if ( post_RealValue_numericRealValue ) 
        post_RealValue_numericRealValue( Me );
      break;

    case Choices::c_SpecialRealValue:
      if ( pre_RealValue_specialRealValue ) 
        pre_RealValue_specialRealValue( Me );
      if ( trav_SpecialRealValue ) 
        trav_SpecialRealValue( Me.specialRealValue() );
      if ( post_RealValue_specialRealValue ) 
        post_RealValue_specialRealValue( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node RealValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_RealValue ) 
    post_RealValue( Me );
}


void default_trav_NumericRealValue( const NumericRealValue& Me )
{
  if ( pre_NumericRealValue ) 
    pre_NumericRealValue( Me );

  if ( pre_NumericRealValue_mantissa ) 
    pre_NumericRealValue_mantissa( Me );
  if ( trav_Mantissa ) 
    trav_Mantissa( Me.mantissa() );
  if ( post_NumericRealValue_mantissa ) 
    post_NumericRealValue_mantissa( Me );

  if ( pre_NumericRealValue_base ) 
    pre_NumericRealValue_base( Me );
  if ( trav_Base ) 
    trav_Base( Me.base() );
  if ( post_NumericRealValue_base ) 
    post_NumericRealValue_base( Me );

  if ( pre_NumericRealValue_exponent ) 
    pre_NumericRealValue_exponent( Me );
  if ( trav_Exponent ) 
    trav_Exponent( Me.exponent() );
  if ( post_NumericRealValue_exponent ) 
    post_NumericRealValue_exponent( Me );

  if ( post_NumericRealValue ) 
    post_NumericRealValue( Me );
}


void default_trav_Mantissa( const Mantissa& Me )
{
  if ( pre_Mantissa ) 
    pre_Mantissa( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SignedNumber:
      if ( pre_Mantissa_signedNumber ) 
        pre_Mantissa_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_Mantissa_signedNumber ) 
        post_Mantissa_signedNumber( Me );
      break;

    case Choices::c_Number:
      if ( pre_Mantissa_number ) 
        pre_Mantissa_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_Mantissa_number ) 
        post_Mantissa_number( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Mantissa: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Mantissa ) 
    post_Mantissa( Me );
}


void default_trav_Base( const Base& Me )
{
  if ( pre_Base ) 
    pre_Base( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Two:
      if ( pre_Base_two ) 
        pre_Base_two( Me );
      if ( trav_Two ) 
        trav_Two( Me.two() );
      if ( post_Base_two ) 
        post_Base_two( Me );
      break;

    case Choices::c_Ten:
      if ( pre_Base_ten ) 
        pre_Base_ten( Me );
      if ( trav_Ten ) 
        trav_Ten( Me.ten() );
      if ( post_Base_ten ) 
        post_Base_ten( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Base: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Base ) 
    post_Base( Me );
}


void default_trav_Exponent( const Exponent& Me )
{
  if ( pre_Exponent ) 
    pre_Exponent( Me );

  switch ( Me.choice() )
    {
    case Choices::c_SignedNumber:
      if ( pre_Exponent_signedNumber ) 
        pre_Exponent_signedNumber( Me );
      if ( trav_SignedNumber ) 
        trav_SignedNumber( Me.signedNumber() );
      if ( post_Exponent_signedNumber ) 
        post_Exponent_signedNumber( Me );
      break;

    case Choices::c_Number:
      if ( pre_Exponent_number ) 
        pre_Exponent_number( Me );
      if ( trav_Number ) 
        trav_Number( Me.number() );
      if ( post_Exponent_number ) 
        post_Exponent_number( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node Exponent: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_Exponent ) 
    post_Exponent( Me );
}


void default_trav_SpecialRealValue( const SpecialRealValue& Me )
{
  if ( pre_SpecialRealValue ) 
    pre_SpecialRealValue( Me );

  switch ( Me.choice() )
    {
    case Choices::c_Plus_INFINITY:
      if ( pre_SpecialRealValue_plus_INFINITY ) 
        pre_SpecialRealValue_plus_INFINITY( Me );
      if ( trav_Plus_INFINITY ) 
        trav_Plus_INFINITY( Me.plus_INFINITY() );
      if ( post_SpecialRealValue_plus_INFINITY ) 
        post_SpecialRealValue_plus_INFINITY( Me );
      break;

    case Choices::c_Minus_INFINITY:
      if ( pre_SpecialRealValue_minus_INFINITY ) 
        pre_SpecialRealValue_minus_INFINITY( Me );
      if ( trav_Minus_INFINITY ) 
        trav_Minus_INFINITY( Me.minus_INFINITY() );
      if ( post_SpecialRealValue_minus_INFINITY ) 
        post_SpecialRealValue_minus_INFINITY( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node SpecialRealValue: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_SpecialRealValue ) 
    post_SpecialRealValue( Me );
}


void default_trav_DefinedValue( const DefinedValue& Me )
{
  if ( pre_DefinedValue ) 
    pre_DefinedValue( Me );

  if ( pre_DefinedValue_identifier ) 
    pre_DefinedValue_identifier( Me );
  if ( trav_Identifier ) 
    trav_Identifier( Me.identifier() );
  if ( post_DefinedValue_identifier ) 
    post_DefinedValue_identifier( Me );

  if ( post_DefinedValue ) 
    post_DefinedValue( Me );
}


void default_trav_SignedNumber( const SignedNumber& Me )
{
  if ( pre_SignedNumber ) 
    pre_SignedNumber( Me );

  if ( pre_SignedNumber_minus ) 
    pre_SignedNumber_minus( Me );
  if ( trav_Minus ) 
    trav_Minus( Me.minus() );
  if ( post_SignedNumber_minus ) 
    post_SignedNumber_minus( Me );

  if ( pre_SignedNumber_number ) 
    pre_SignedNumber_number( Me );
  if ( trav_Number ) 
    trav_Number( Me.number() );
  if ( post_SignedNumber_number ) 
    post_SignedNumber_number( Me );

  if ( post_SignedNumber ) 
    post_SignedNumber( Me );
}


void default_trav_DefaultValue( const DefaultValue& Me )
{
  if ( pre_DefaultValue ) 
    pre_DefaultValue( Me );

  if ( pre_DefaultValue_constraintValueAndAttributes ) 
    pre_DefaultValue_constraintValueAndAttributes( Me );
  if ( trav_ConstraintValueAndAttributes ) 
    trav_ConstraintValueAndAttributes( Me.constraintValueAndAttributes() );
  if ( post_DefaultValue_constraintValueAndAttributes ) 
    post_DefaultValue_constraintValueAndAttributes( Me );

  if ( post_DefaultValue ) 
    post_DefaultValue( Me );
}


void default_trav_Identifier( const Identifier& Me )
{
  if ( pre_Identifier ) 
    pre_Identifier( Me );

  if ( post_Identifier ) 
    post_Identifier( Me );
}


void default_trav_FormalParList( const FormalParList& Me )
{
  if ( pre_FormalParList ) 
    pre_FormalParList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_FormalParList_formalParAndType ) 
        pre_FormalParList_formalParAndType( Me, i );
      if ( trav_FormalParAndType ) 
        trav_FormalParAndType( Me.formalParAndType( i ) );
      if ( post_FormalParList_formalParAndType ) 
        post_FormalParList_formalParAndType( Me, i );
  }

  if ( post_FormalParList ) 
    post_FormalParList( Me );
}


void default_trav_FormalParAndType( const FormalParAndType& Me )
{
  if ( pre_FormalParAndType ) 
    pre_FormalParAndType( Me );

  if ( pre_FormalParAndType_formalParIdList ) 
    pre_FormalParAndType_formalParIdList( Me );
  if ( trav_FormalParIdList ) 
    trav_FormalParIdList( Me.formalParIdList() );
  if ( post_FormalParAndType_formalParIdList ) 
    post_FormalParAndType_formalParIdList( Me );

  if ( pre_FormalParAndType_formalParType ) 
    pre_FormalParAndType_formalParType( Me );
  if ( trav_FormalParType ) 
    trav_FormalParType( Me.formalParType() );
  if ( post_FormalParAndType_formalParType ) 
    post_FormalParAndType_formalParType( Me );

  if ( post_FormalParAndType ) 
    post_FormalParAndType( Me );
}


void default_trav_FormalParIdList( const FormalParIdList& Me )
{
  if ( pre_FormalParIdList ) 
    pre_FormalParIdList( Me );

  int i;
  for ( i = 0 ; i < Me.nr_of_items() ; i++ )
    {
      if ( pre_FormalParIdList_formalParIdentifier ) 
        pre_FormalParIdList_formalParIdentifier( Me, i );
      if ( trav_Identifier ) 
        trav_Identifier( Me.formalParIdentifier( i ) );
      if ( post_FormalParIdList_formalParIdentifier ) 
        post_FormalParIdList_formalParIdentifier( Me, i );
  }

  if ( post_FormalParIdList ) 
    post_FormalParIdList( Me );
}


void default_trav_FormalParType( const FormalParType& Me )
{
  if ( pre_FormalParType ) 
    pre_FormalParType( Me );

  switch ( Me.choice() )
    {
    case Choices::c_TTCN_Type:
      if ( pre_FormalParType_ttcn_Type ) 
        pre_FormalParType_ttcn_Type( Me );
      if ( trav_TTCN_Type ) 
        trav_TTCN_Type( Me.ttcn_Type() );
      if ( post_FormalParType_ttcn_Type ) 
        post_FormalParType_ttcn_Type( Me );
      break;

    case Choices::c_PDU:
      if ( pre_FormalParType_pdu ) 
        pre_FormalParType_pdu( Me );
      if ( trav_PDU ) 
        trav_PDU( Me.pdu() );
      if ( post_FormalParType_pdu ) 
        post_FormalParType_pdu( Me );
      break;

    case Choices::c_CP:
      if ( pre_FormalParType_cp ) 
        pre_FormalParType_cp( Me );
      if ( trav_CP ) 
        trav_CP( Me.cp() );
      if ( post_FormalParType_cp ) 
        post_FormalParType_cp( Me );
      break;

    case Choices::c_TIMER:
      if ( pre_FormalParType_timer ) 
        pre_FormalParType_timer( Me );
      if ( trav_TIMER ) 
        trav_TIMER( Me.timer() );
      if ( post_FormalParType_timer ) 
        post_FormalParType_timer( Me );
      break;

    default:
      {
        trav_error( "Unknown child for node FormalParType: %s",
                    Choices::to_char( Me.choice() ) );
      }
      break;
    }
  if ( post_FormalParType ) 
    post_FormalParType( Me );
}


void default_trav_TestGroupReference( const TestGroupReference& Me )
{
  if ( pre_TestGroupReference ) 
    pre_TestGroupReference( Me );

  if ( post_TestGroupReference ) 
    post_TestGroupReference( Me );
}


void default_trav_TestStepGroupReference( const TestStepGroupReference& Me )
{
  if ( pre_TestStepGroupReference ) 
    pre_TestStepGroupReference( Me );

  if ( post_TestStepGroupReference ) 
    post_TestStepGroupReference( Me );
}


void default_trav_DefaultGroupReference( const DefaultGroupReference& Me )
{
  if ( pre_DefaultGroupReference ) 
    pre_DefaultGroupReference( Me );

  if ( post_DefaultGroupReference ) 
    post_DefaultGroupReference( Me );
}


void default_trav_Ostring( const Ostring& Me )
{
  if ( pre_Ostring ) 
    pre_Ostring( Me );

  if ( post_Ostring ) 
    post_Ostring( Me );
}


void default_trav_Cstring( const Cstring& Me )
{
  if ( pre_Cstring ) 
    pre_Cstring( Me );

  if ( post_Cstring ) 
    post_Cstring( Me );
}


void default_trav_Bstring( const Bstring& Me )
{
  if ( pre_Bstring ) 
    pre_Bstring( Me );

  if ( post_Bstring ) 
    post_Bstring( Me );
}


void default_trav_Hstring( const Hstring& Me )
{
  if ( pre_Hstring ) 
    pre_Hstring( Me );

  if ( post_Hstring ) 
    post_Hstring( Me );
}


void default_trav_INTEGER( const INTEGER& Me )
{
  if ( pre_INTEGER ) 
    pre_INTEGER( Me );

  if ( post_INTEGER ) 
    post_INTEGER( Me );
}


void default_trav_BOOLEAN( const BOOLEAN& Me )
{
  if ( pre_BOOLEAN ) 
    pre_BOOLEAN( Me );

  if ( post_BOOLEAN ) 
    post_BOOLEAN( Me );
}


void default_trav_BITSTRING( const BITSTRING& Me )
{
  if ( pre_BITSTRING ) 
    pre_BITSTRING( Me );

  if ( post_BITSTRING ) 
    post_BITSTRING( Me );
}


void default_trav_HEXSTRING( const HEXSTRING& Me )
{
  if ( pre_HEXSTRING ) 
    pre_HEXSTRING( Me );

  if ( post_HEXSTRING ) 
    post_HEXSTRING( Me );
}


void default_trav_OCTETSTRING( const OCTETSTRING& Me )
{
  if ( pre_OCTETSTRING ) 
    pre_OCTETSTRING( Me );

  if ( post_OCTETSTRING ) 
    post_OCTETSTRING( Me );
}


void default_trav_BooleanType( const BooleanType& Me )
{
  if ( pre_BooleanType ) 
    pre_BooleanType( Me );

  if ( post_BooleanType ) 
    post_BooleanType( Me );
}


void default_trav_OctetStringType( const OctetStringType& Me )
{
  if ( pre_OctetStringType ) 
    pre_OctetStringType( Me );

  if ( post_OctetStringType ) 
    post_OctetStringType( Me );
}


void default_trav_ObjectIdentifierType( const ObjectIdentifierType& Me )
{
  if ( pre_ObjectIdentifierType ) 
    pre_ObjectIdentifierType( Me );

  if ( post_ObjectIdentifierType ) 
    post_ObjectIdentifierType( Me );
}


void default_trav_NumericString( const NumericString& Me )
{
  if ( pre_NumericString ) 
    pre_NumericString( Me );

  if ( post_NumericString ) 
    post_NumericString( Me );
}


void default_trav_PrintableString( const PrintableString& Me )
{
  if ( pre_PrintableString ) 
    pre_PrintableString( Me );

  if ( post_PrintableString ) 
    post_PrintableString( Me );
}


void default_trav_TeletexString( const TeletexString& Me )
{
  if ( pre_TeletexString ) 
    pre_TeletexString( Me );

  if ( post_TeletexString ) 
    post_TeletexString( Me );
}


void default_trav_VideotexString( const VideotexString& Me )
{
  if ( pre_VideotexString ) 
    pre_VideotexString( Me );

  if ( post_VideotexString ) 
    post_VideotexString( Me );
}


void default_trav_VisibleString( const VisibleString& Me )
{
  if ( pre_VisibleString ) 
    pre_VisibleString( Me );

  if ( post_VisibleString ) 
    post_VisibleString( Me );
}


void default_trav_IA5String( const IA5String& Me )
{
  if ( pre_IA5String ) 
    pre_IA5String( Me );

  if ( post_IA5String ) 
    post_IA5String( Me );
}


void default_trav_GraphicString( const GraphicString& Me )
{
  if ( pre_GraphicString ) 
    pre_GraphicString( Me );

  if ( post_GraphicString ) 
    post_GraphicString( Me );
}


void default_trav_GeneralString( const GeneralString& Me )
{
  if ( pre_GeneralString ) 
    pre_GeneralString( Me );

  if ( post_GeneralString ) 
    post_GeneralString( Me );
}


void default_trav_T61String( const T61String& Me )
{
  if ( pre_T61String ) 
    pre_T61String( Me );

  if ( post_T61String ) 
    post_T61String( Me );
}


void default_trav_ISO646String( const ISO646String& Me )
{
  if ( pre_ISO646String ) 
    pre_ISO646String( Me );

  if ( post_ISO646String ) 
    post_ISO646String( Me );
}


void default_trav_GeneralizedTime( const GeneralizedTime& Me )
{
  if ( pre_GeneralizedTime ) 
    pre_GeneralizedTime( Me );

  if ( post_GeneralizedTime ) 
    post_GeneralizedTime( Me );
}


void default_trav_UTCTime( const UTCTime& Me )
{
  if ( pre_UTCTime ) 
    pre_UTCTime( Me );

  if ( post_UTCTime ) 
    post_UTCTime( Me );
}


void default_trav_EXTERNAL( const EXTERNAL& Me )
{
  if ( pre_EXTERNAL ) 
    pre_EXTERNAL( Me );

  if ( post_EXTERNAL ) 
    post_EXTERNAL( Me );
}


void default_trav_ObjectDescriptor( const ObjectDescriptor& Me )
{
  if ( pre_ObjectDescriptor ) 
    pre_ObjectDescriptor( Me );

  if ( post_ObjectDescriptor ) 
    post_ObjectDescriptor( Me );
}


void default_trav_RealType( const RealType& Me )
{
  if ( pre_RealType ) 
    pre_RealType( Me );

  if ( post_RealType ) 
    post_RealType( Me );
}


void default_trav_UNIVERSAL( const UNIVERSAL& Me )
{
  if ( pre_UNIVERSAL ) 
    pre_UNIVERSAL( Me );

  if ( post_UNIVERSAL ) 
    post_UNIVERSAL( Me );
}


void default_trav_APPLICATION( const APPLICATION& Me )
{
  if ( pre_APPLICATION ) 
    pre_APPLICATION( Me );

  if ( post_APPLICATION ) 
    post_APPLICATION( Me );
}


void default_trav_PRIVATE_( const PRIVATE_& Me )
{
  if ( pre_PRIVATE_ ) 
    pre_PRIVATE_( Me );

  if ( post_PRIVATE_ ) 
    post_PRIVATE_( Me );
}


void default_trav_ANY( const ANY& Me )
{
  if ( pre_ANY ) 
    pre_ANY( Me );

  if ( post_ANY ) 
    post_ANY( Me );
}


void default_trav_Max( const Max& Me )
{
  if ( pre_Max ) 
    pre_Max( Me );

  if ( post_Max ) 
    post_Max( Me );
}


void default_trav_Min( const Min& Me )
{
  if ( pre_Min ) 
    pre_Min( Me );

  if ( post_Min ) 
    post_Min( Me );
}


void default_trav_INCLUSIVE( const INCLUSIVE& Me )
{
  if ( pre_INCLUSIVE ) 
    pre_INCLUSIVE( Me );

  if ( post_INCLUSIVE ) 
    post_INCLUSIVE( Me );
}


void default_trav_PRESENT( const PRESENT& Me )
{
  if ( pre_PRESENT ) 
    pre_PRESENT( Me );

  if ( post_PRESENT ) 
    post_PRESENT( Me );
}


void default_trav_IF_PRESENT( const IF_PRESENT& Me )
{
  if ( pre_IF_PRESENT ) 
    pre_IF_PRESENT( Me );

  if ( post_IF_PRESENT ) 
    post_IF_PRESENT( Me );
}


void default_trav_ABSENT( const ABSENT& Me )
{
  if ( pre_ABSENT ) 
    pre_ABSENT( Me );

  if ( post_ABSENT ) 
    post_ABSENT( Me );
}


void default_trav_OPTIONAL( const OPTIONAL& Me )
{
  if ( pre_OPTIONAL ) 
    pre_OPTIONAL( Me );

  if ( post_OPTIONAL ) 
    post_OPTIONAL( Me );
}


void default_trav_NullType( const NullType& Me )
{
  if ( pre_NullType ) 
    pre_NullType( Me );

  if ( post_NullType ) 
    post_NullType( Me );
}


void default_trav_NullValue( const NullValue& Me )
{
  if ( pre_NullValue ) 
    pre_NullValue( Me );

  if ( post_NullValue ) 
    post_NullValue( Me );
}


void default_trav_Plus_INFINITY( const Plus_INFINITY& Me )
{
  if ( pre_Plus_INFINITY ) 
    pre_Plus_INFINITY( Me );

  if ( post_Plus_INFINITY ) 
    post_Plus_INFINITY( Me );
}


void default_trav_MinusINFINITY( const MinusINFINITY& Me )
{
  if ( pre_MinusINFINITY ) 
    pre_MinusINFINITY( Me );

  if ( post_MinusINFINITY ) 
    post_MinusINFINITY( Me );
}


void default_trav_Minus_INFINITY( const Minus_INFINITY& Me )
{
  if ( pre_Minus_INFINITY ) 
    pre_Minus_INFINITY( Me );

  if ( post_Minus_INFINITY ) 
    post_Minus_INFINITY( Me );
}


void default_trav_INFINITY( const INFINITY& Me )
{
  if ( pre_INFINITY ) 
    pre_INFINITY( Me );

  if ( post_INFINITY ) 
    post_INFINITY( Me );
}


void default_trav_PDU( const PDU& Me )
{
  if ( pre_PDU ) 
    pre_PDU( Me );

  if ( post_PDU ) 
    post_PDU( Me );
}


void default_trav_CP( const CP& Me )
{
  if ( pre_CP ) 
    pre_CP( Me );

  if ( post_CP ) 
    post_CP( Me );
}


void default_trav_TIMER( const TIMER& Me )
{
  if ( pre_TIMER ) 
    pre_TIMER( Me );

  if ( post_TIMER ) 
    post_TIMER( Me );
}


void default_trav_UT( const UT& Me )
{
  if ( pre_UT ) 
    pre_UT( Me );

  if ( post_UT ) 
    post_UT( Me );
}


void default_trav_LT( const LT& Me )
{
  if ( pre_LT ) 
    pre_LT( Me );

  if ( post_LT ) 
    post_LT( Me );
}


void default_trav_MTC( const MTC& Me )
{
  if ( pre_MTC ) 
    pre_MTC( Me );

  if ( post_MTC ) 
    post_MTC( Me );
}


void default_trav_PTC( const PTC& Me )
{
  if ( pre_PTC ) 
    pre_PTC( Me );

  if ( post_PTC ) 
    post_PTC( Me );
}


void default_trav_PicoSeconds( const PicoSeconds& Me )
{
  if ( pre_PicoSeconds ) 
    pre_PicoSeconds( Me );

  if ( post_PicoSeconds ) 
    post_PicoSeconds( Me );
}


void default_trav_NanoSeconds( const NanoSeconds& Me )
{
  if ( pre_NanoSeconds ) 
    pre_NanoSeconds( Me );

  if ( post_NanoSeconds ) 
    post_NanoSeconds( Me );
}


void default_trav_MicroSeconds( const MicroSeconds& Me )
{
  if ( pre_MicroSeconds ) 
    pre_MicroSeconds( Me );

  if ( post_MicroSeconds ) 
    post_MicroSeconds( Me );
}


void default_trav_MilliSeconds( const MilliSeconds& Me )
{
  if ( pre_MilliSeconds ) 
    pre_MilliSeconds( Me );

  if ( post_MilliSeconds ) 
    post_MilliSeconds( Me );
}


void default_trav_Seconds( const Seconds& Me )
{
  if ( pre_Seconds ) 
    pre_Seconds( Me );

  if ( post_Seconds ) 
    post_Seconds( Me );
}


void default_trav_Minutes( const Minutes& Me )
{
  if ( pre_Minutes ) 
    pre_Minutes( Me );

  if ( post_Minutes ) 
    post_Minutes( Me );
}


void default_trav_AIMPLICIT( const AIMPLICIT& Me )
{
  if ( pre_AIMPLICIT ) 
    pre_AIMPLICIT( Me );

  if ( post_AIMPLICIT ) 
    post_AIMPLICIT( Me );
}


void default_trav_AEXPLICIT( const AEXPLICIT& Me )
{
  if ( pre_AEXPLICIT ) 
    pre_AEXPLICIT( Me );

  if ( post_AEXPLICIT ) 
    post_AEXPLICIT( Me );
}


void default_trav_RETURN_( const RETURN_& Me )
{
  if ( pre_RETURN_ ) 
    pre_RETURN_( Me );

  if ( post_RETURN_ ) 
    post_RETURN_( Me );
}


void default_trav_PASS( const PASS& Me )
{
  if ( pre_PASS ) 
    pre_PASS( Me );

  if ( post_PASS ) 
    post_PASS( Me );
}


void default_trav_PreliminaryPASS( const PreliminaryPASS& Me )
{
  if ( pre_PreliminaryPASS ) 
    pre_PreliminaryPASS( Me );

  if ( post_PreliminaryPASS ) 
    post_PreliminaryPASS( Me );
}


void default_trav_FAIL( const FAIL& Me )
{
  if ( pre_FAIL ) 
    pre_FAIL( Me );

  if ( post_FAIL ) 
    post_FAIL( Me );
}


void default_trav_PreliminaryFAIL( const PreliminaryFAIL& Me )
{
  if ( pre_PreliminaryFAIL ) 
    pre_PreliminaryFAIL( Me );

  if ( post_PreliminaryFAIL ) 
    post_PreliminaryFAIL( Me );
}


void default_trav_INCONC( const INCONC& Me )
{
  if ( pre_INCONC ) 
    pre_INCONC( Me );

  if ( post_INCONC ) 
    post_INCONC( Me );
}


void default_trav_PreliminaryINCONC( const PreliminaryINCONC& Me )
{
  if ( pre_PreliminaryINCONC ) 
    pre_PreliminaryINCONC( Me );

  if ( post_PreliminaryINCONC ) 
    post_PreliminaryINCONC( Me );
}


void default_trav_R( const R& Me )
{
  if ( pre_R ) 
    pre_R( Me );

  if ( post_R ) 
    post_R( Me );
}


void default_trav_NONE( const NONE& Me )
{
  if ( pre_NONE ) 
    pre_NONE( Me );

  if ( post_NONE ) 
    post_NONE( Me );
}


void default_trav_R_TYPE( const R_TYPE& Me )
{
  if ( pre_R_TYPE ) 
    pre_R_TYPE( Me );

  if ( post_R_TYPE ) 
    post_R_TYPE( Me );
}


void default_trav_OMIT( const OMIT& Me )
{
  if ( pre_OMIT ) 
    pre_OMIT( Me );

  if ( post_OMIT ) 
    post_OMIT( Me );
}


void default_trav_ANYValue( const ANYValue& Me )
{
  if ( pre_ANYValue ) 
    pre_ANYValue( Me );

  if ( post_ANYValue ) 
    post_ANYValue( Me );
}


void default_trav_AnyOrOmit( const AnyOrOmit& Me )
{
  if ( pre_AnyOrOmit ) 
    pre_AnyOrOmit( Me );

  if ( post_AnyOrOmit ) 
    post_AnyOrOmit( Me );
}


void default_trav_Equal( const Equal& Me )
{
  if ( pre_Equal ) 
    pre_Equal( Me );

  if ( post_Equal ) 
    post_Equal( Me );
}


void default_trav_Less( const Less& Me )
{
  if ( pre_Less ) 
    pre_Less( Me );

  if ( post_Less ) 
    post_Less( Me );
}


void default_trav_Greater( const Greater& Me )
{
  if ( pre_Greater ) 
    pre_Greater( Me );

  if ( post_Greater ) 
    post_Greater( Me );
}


void default_trav_NotEqual( const NotEqual& Me )
{
  if ( pre_NotEqual ) 
    pre_NotEqual( Me );

  if ( post_NotEqual ) 
    post_NotEqual( Me );
}


void default_trav_GreaterOrEqual( const GreaterOrEqual& Me )
{
  if ( pre_GreaterOrEqual ) 
    pre_GreaterOrEqual( Me );

  if ( post_GreaterOrEqual ) 
    post_GreaterOrEqual( Me );
}


void default_trav_LessOrEqual( const LessOrEqual& Me )
{
  if ( pre_LessOrEqual ) 
    pre_LessOrEqual( Me );

  if ( post_LessOrEqual ) 
    post_LessOrEqual( Me );
}


void default_trav_Two( const Two& Me )
{
  if ( pre_Two ) 
    pre_Two( Me );

  if ( post_Two ) 
    post_Two( Me );
}


void default_trav_Ten( const Ten& Me )
{
  if ( pre_Ten ) 
    pre_Ten( Me );

  if ( post_Ten ) 
    post_Ten( Me );
}


void default_trav_Mult( const Mult& Me )
{
  if ( pre_Mult ) 
    pre_Mult( Me );

  if ( post_Mult ) 
    post_Mult( Me );
}


void default_trav_Div( const Div& Me )
{
  if ( pre_Div ) 
    pre_Div( Me );

  if ( post_Div ) 
    post_Div( Me );
}


void default_trav_Mod( const Mod& Me )
{
  if ( pre_Mod ) 
    pre_Mod( Me );

  if ( post_Mod ) 
    post_Mod( Me );
}


void default_trav_And( const And& Me )
{
  if ( pre_And ) 
    pre_And( Me );

  if ( post_And ) 
    post_And( Me );
}


void default_trav_Or( const Or& Me )
{
  if ( pre_Or ) 
    pre_Or( Me );

  if ( post_Or ) 
    post_Or( Me );
}


void default_trav_Minus( const Minus& Me )
{
  if ( pre_Minus ) 
    pre_Minus( Me );

  if ( post_Minus ) 
    post_Minus( Me );
}


void default_trav_Not( const Not& Me )
{
  if ( pre_Not ) 
    pre_Not( Me );

  if ( post_Not ) 
    post_Not( Me );
}


void default_trav_Plus( const Plus& Me )
{
  if ( pre_Plus ) 
    pre_Plus( Me );

  if ( post_Plus ) 
    post_Plus( Me );
}


void default_trav_ATrue( const ATrue& Me )
{
  if ( pre_ATrue ) 
    pre_ATrue( Me );

  if ( post_ATrue ) 
    post_ATrue( Me );
}


void default_trav_AFalse( const AFalse& Me )
{
  if ( pre_AFalse ) 
    pre_AFalse( Me );

  if ( post_AFalse ) 
    post_AFalse( Me );
}


void default_trav_MacroSymbol( const MacroSymbol& Me )
{
  if ( pre_MacroSymbol ) 
    pre_MacroSymbol( Me );

  if ( post_MacroSymbol ) 
    post_MacroSymbol( Me );
}


void default_trav_AccessNode( const AccessNode& Me )
{
  switch( Me.choice() ) {
  case Choices::c_invalid_choice:
    trav_error("Bad Access Node for trav"); break;
  case Choices::c_ASuite:
    if ( trav_ASuite ) 
      trav_ASuite( *Me.ASuite() );
    break;
  case Choices::c_SuiteId:
    if ( trav_SuiteId ) 
      trav_SuiteId( *Me.SuiteId() );
    break;
  case Choices::c_SO_SuiteId:
    if ( trav_SO_SuiteId ) 
      trav_SO_SuiteId( *Me.SO_SuiteId() );
    break;
  case Choices::c_SuiteOverviewPart:
    if ( trav_SuiteOverviewPart ) 
      trav_SuiteOverviewPart( *Me.SuiteOverviewPart() );
    break;
  case Choices::c_SuiteStructure:
    if ( trav_SuiteStructure ) 
      trav_SuiteStructure( *Me.SuiteStructure() );
    break;
  case Choices::c_SO_StandardsRef:
    if ( trav_SO_StandardsRef ) 
      trav_SO_StandardsRef( *Me.SO_StandardsRef() );
    break;
  case Choices::c_SO_PICSRef:
    if ( trav_SO_PICSRef ) 
      trav_SO_PICSRef( *Me.SO_PICSRef() );
    break;
  case Choices::c_SO_PIXITRef:
    if ( trav_SO_PIXITRef ) 
      trav_SO_PIXITRef( *Me.SO_PIXITRef() );
    break;
  case Choices::c_SO_TestMethods:
    if ( trav_SO_TestMethods ) 
      trav_SO_TestMethods( *Me.SO_TestMethods() );
    break;
  case Choices::c_SO_SelExprId:
    if ( trav_SO_SelExprId ) 
      trav_SO_SelExprId( *Me.SO_SelExprId() );
    break;
  case Choices::c_SO_Objective:
    if ( trav_SO_Objective ) 
      trav_SO_Objective( *Me.SO_Objective() );
    break;
  case Choices::c_SO_DefaultRef:
    if ( trav_SO_DefaultRef ) 
      trav_SO_DefaultRef( *Me.SO_DefaultRef() );
    break;
  case Choices::c_SO_DefaultId:
    if ( trav_SO_DefaultId ) 
      trav_SO_DefaultId( *Me.SO_DefaultId() );
    break;
  case Choices::c_SO_Description:
    if ( trav_SO_Description ) 
      trav_SO_Description( *Me.SO_Description() );
    break;
  case Choices::c_SO_TestStepRef:
    if ( trav_SO_TestStepRef ) 
      trav_SO_TestStepRef( *Me.SO_TestStepRef() );
    break;
  case Choices::c_SO_TestStepId:
    if ( trav_SO_TestStepId ) 
      trav_SO_TestStepId( *Me.SO_TestStepId() );
    break;
  case Choices::c_SO_TestCaseId:
    if ( trav_SO_TestCaseId ) 
      trav_SO_TestCaseId( *Me.SO_TestCaseId() );
    break;
  case Choices::c_SO_TestGroupRef:
    if ( trav_SO_TestGroupRef ) 
      trav_SO_TestGroupRef( *Me.SO_TestGroupRef() );
    break;
  case Choices::c_SO_StructureAndObjectives:
    if ( trav_SO_StructureAndObjectives ) 
      trav_SO_StructureAndObjectives( *Me.SO_StructureAndObjectives() );
    break;
  case Choices::c_SO_StructureAndObjective:
    if ( trav_SO_StructureAndObjective ) 
      trav_SO_StructureAndObjective( *Me.SO_StructureAndObjective() );
    break;
  case Choices::c_TestCaseIndex:
    if ( trav_TestCaseIndex ) 
      trav_TestCaseIndex( *Me.TestCaseIndex() );
    break;
  case Choices::c_SO_CaseIndexList:
    if ( trav_SO_CaseIndexList ) 
      trav_SO_CaseIndexList( *Me.SO_CaseIndexList() );
    break;
  case Choices::c_SO_CaseIndex:
    if ( trav_SO_CaseIndex ) 
      trav_SO_CaseIndex( *Me.SO_CaseIndex() );
    break;
  case Choices::c_TestStepIndex:
    if ( trav_TestStepIndex ) 
      trav_TestStepIndex( *Me.TestStepIndex() );
    break;
  case Choices::c_SO_StepIndexList:
    if ( trav_SO_StepIndexList ) 
      trav_SO_StepIndexList( *Me.SO_StepIndexList() );
    break;
  case Choices::c_SO_StepIndex:
    if ( trav_SO_StepIndex ) 
      trav_SO_StepIndex( *Me.SO_StepIndex() );
    break;
  case Choices::c_DefaultIndex:
    if ( trav_DefaultIndex ) 
      trav_DefaultIndex( *Me.DefaultIndex() );
    break;
  case Choices::c_SO_DefIndexList:
    if ( trav_SO_DefIndexList ) 
      trav_SO_DefIndexList( *Me.SO_DefIndexList() );
    break;
  case Choices::c_SO_DefIndex:
    if ( trav_SO_DefIndex ) 
      trav_SO_DefIndex( *Me.SO_DefIndex() );
    break;
  case Choices::c_ImportPart:
    if ( trav_ImportPart ) 
      trav_ImportPart( *Me.ImportPart() );
    break;
  case Choices::c_ImportDeclarations:
    if ( trav_ImportDeclarations ) 
      trav_ImportDeclarations( *Me.ImportDeclarations() );
    break;
  case Choices::c_Imports:
    if ( trav_Imports ) 
      trav_Imports( *Me.Imports() );
    break;
  case Choices::c_SourceName:
    if ( trav_SourceName ) 
      trav_SourceName( *Me.SourceName() );
    break;
  case Choices::c_SourceRef:
    if ( trav_SourceRef ) 
      trav_SourceRef( *Me.SourceRef() );
    break;
  case Choices::c_ImportedObjectList:
    if ( trav_ImportedObjectList ) 
      trav_ImportedObjectList( *Me.ImportedObjectList() );
    break;
  case Choices::c_ImportedObject:
    if ( trav_ImportedObject ) 
      trav_ImportedObject( *Me.ImportedObject() );
    break;
  case Choices::c_ObjectName:
    if ( trav_ObjectName ) 
      trav_ObjectName( *Me.ObjectName() );
    break;
  case Choices::c_ObjectType:
    if ( trav_ObjectType ) 
      trav_ObjectType( *Me.ObjectType() );
    break;
  case Choices::c_DeclarationsPart:
    if ( trav_DeclarationsPart ) 
      trav_DeclarationsPart( *Me.DeclarationsPart() );
    break;
  case Choices::c_Definitions:
    if ( trav_Definitions ) 
      trav_Definitions( *Me.Definitions() );
    break;
  case Choices::c_TS_TypeDefs:
    if ( trav_TS_TypeDefs ) 
      trav_TS_TypeDefs( *Me.TS_TypeDefs() );
    break;
  case Choices::c_EncodingDefs:
    if ( trav_EncodingDefs ) 
      trav_EncodingDefs( *Me.EncodingDefs() );
    break;
  case Choices::c_EncodingDefinitions:
    if ( trav_EncodingDefinitions ) 
      trav_EncodingDefinitions( *Me.EncodingDefinitions() );
    break;
  case Choices::c_EncodingDefList:
    if ( trav_EncodingDefList ) 
      trav_EncodingDefList( *Me.EncodingDefList() );
    break;
  case Choices::c_EncodingDefinition:
    if ( trav_EncodingDefinition ) 
      trav_EncodingDefinition( *Me.EncodingDefinition() );
    break;
  case Choices::c_EncodingDefault:
    if ( trav_EncodingDefault ) 
      trav_EncodingDefault( *Me.EncodingDefault() );
    break;
  case Choices::c_EncodingVariations:
    if ( trav_EncodingVariations ) 
      trav_EncodingVariations( *Me.EncodingVariations() );
    break;
  case Choices::c_EncodingVariationSet:
    if ( trav_EncodingVariationSet ) 
      trav_EncodingVariationSet( *Me.EncodingVariationSet() );
    break;
  case Choices::c_EncodingVariationList:
    if ( trav_EncodingVariationList ) 
      trav_EncodingVariationList( *Me.EncodingVariationList() );
    break;
  case Choices::c_EncodingVariation:
    if ( trav_EncodingVariation ) 
      trav_EncodingVariation( *Me.EncodingVariation() );
    break;
  case Choices::c_VariationDefault:
    if ( trav_VariationDefault ) 
      trav_VariationDefault( *Me.VariationDefault() );
    break;
  case Choices::c_EncodingVariationId:
    if ( trav_EncodingVariationId ) 
      trav_EncodingVariationId( *Me.EncodingVariationId() );
    break;
  case Choices::c_EncVariationIdAndParList:
    if ( trav_EncVariationIdAndParList ) 
      trav_EncVariationIdAndParList( *Me.EncVariationIdAndParList() );
    break;
  case Choices::c_InvalidFieldEncodingDefs:
    if ( trav_InvalidFieldEncodingDefs ) 
      trav_InvalidFieldEncodingDefs( *Me.InvalidFieldEncodingDefs() );
    break;
  case Choices::c_InvalidFieldEncodingDef:
    if ( trav_InvalidFieldEncodingDef ) 
      trav_InvalidFieldEncodingDef( *Me.InvalidFieldEncodingDef() );
    break;
  case Choices::c_InvalidFieldEncodingDefinition:
    if ( trav_InvalidFieldEncodingDefinition ) 
      trav_InvalidFieldEncodingDefinition( *Me.InvalidFieldEncodingDefinition() );
    break;
  case Choices::c_InvalidFieldEncodingId:
    if ( trav_InvalidFieldEncodingId ) 
      trav_InvalidFieldEncodingId( *Me.InvalidFieldEncodingId() );
    break;
  case Choices::c_InvalidFieldEncodingIdAndParList:
    if ( trav_InvalidFieldEncodingIdAndParList ) 
      trav_InvalidFieldEncodingIdAndParList( *Me.InvalidFieldEncodingIdAndParList() );
    break;
  case Choices::c_SimpleTypeDefs:
    if ( trav_SimpleTypeDefs ) 
      trav_SimpleTypeDefs( *Me.SimpleTypeDefs() );
    break;
  case Choices::c_SimpleTypeDefList:
    if ( trav_SimpleTypeDefList ) 
      trav_SimpleTypeDefList( *Me.SimpleTypeDefList() );
    break;
  case Choices::c_SimpleTypeDef:
    if ( trav_SimpleTypeDef ) 
      trav_SimpleTypeDef( *Me.SimpleTypeDef() );
    break;
  case Choices::c_SimpleTypeId:
    if ( trav_SimpleTypeId ) 
      trav_SimpleTypeId( *Me.SimpleTypeId() );
    break;
  case Choices::c_SimpleTypeDefinition:
    if ( trav_SimpleTypeDefinition ) 
      trav_SimpleTypeDefinition( *Me.SimpleTypeDefinition() );
    break;
  case Choices::c_TypeAndRestriction:
    if ( trav_TypeAndRestriction ) 
      trav_TypeAndRestriction( *Me.TypeAndRestriction() );
    break;
  case Choices::c_TTCN_Type:
    if ( trav_TTCN_Type ) 
      trav_TTCN_Type( *Me.TTCN_Type() );
    break;
  case Choices::c_TypeOrPDU:
    if ( trav_TypeOrPDU ) 
      trav_TypeOrPDU( *Me.TypeOrPDU() );
    break;
  case Choices::c_PredefinedType:
    if ( trav_PredefinedType ) 
      trav_PredefinedType( *Me.PredefinedType() );
    break;
  case Choices::c_ReferenceType:
    if ( trav_ReferenceType ) 
      trav_ReferenceType( *Me.ReferenceType() );
    break;
  case Choices::c_CharacterString:
    if ( trav_CharacterString ) 
      trav_CharacterString( *Me.CharacterString() );
    break;
  case Choices::c_Restriction:
    if ( trav_Restriction ) 
      trav_Restriction( *Me.Restriction() );
    break;
  case Choices::c_LengthRestriction:
    if ( trav_LengthRestriction ) 
      trav_LengthRestriction( *Me.LengthRestriction() );
    break;
  case Choices::c_SingleTypeLength:
    if ( trav_SingleTypeLength ) 
      trav_SingleTypeLength( *Me.SingleTypeLength() );
    break;
  case Choices::c_Comment:
    if ( trav_Comment ) 
      trav_Comment( *Me.Comment() );
    break;
  case Choices::c_VariationRef:
    if ( trav_VariationRef ) 
      trav_VariationRef( *Me.VariationRef() );
    break;
  case Choices::c_VariationReference:
    if ( trav_VariationReference ) 
      trav_VariationReference( *Me.VariationReference() );
    break;
  case Choices::c_PDU_FieldEncoding:
    if ( trav_PDU_FieldEncoding ) 
      trav_PDU_FieldEncoding( *Me.PDU_FieldEncoding() );
    break;
  case Choices::c_PDU_FieldEncodingCall:
    if ( trav_PDU_FieldEncodingCall ) 
      trav_PDU_FieldEncodingCall( *Me.PDU_FieldEncodingCall() );
    break;
  case Choices::c_EncVariationId:
    if ( trav_EncVariationId ) 
      trav_EncVariationId( *Me.EncVariationId() );
    break;
  case Choices::c_EncVariationCall:
    if ( trav_EncVariationCall ) 
      trav_EncVariationCall( *Me.EncVariationCall() );
    break;
  case Choices::c_InvalidFieldEncodingCall:
    if ( trav_InvalidFieldEncodingCall ) 
      trav_InvalidFieldEncodingCall( *Me.InvalidFieldEncodingCall() );
    break;
  case Choices::c_EncodingRuleId:
    if ( trav_EncodingRuleId ) 
      trav_EncodingRuleId( *Me.EncodingRuleId() );
    break;
  case Choices::c_EncRuleId:
    if ( trav_EncRuleId ) 
      trav_EncRuleId( *Me.EncRuleId() );
    break;
  case Choices::c_PDU_EncodingId:
    if ( trav_PDU_EncodingId ) 
      trav_PDU_EncodingId( *Me.PDU_EncodingId() );
    break;
  case Choices::c_EncodingRef:
    if ( trav_EncodingRef ) 
      trav_EncodingRef( *Me.EncodingRef() );
    break;
  case Choices::c_EncodingReference:
    if ( trav_EncodingReference ) 
      trav_EncodingReference( *Me.EncodingReference() );
    break;
  case Choices::c_Encoding_TypeList:
    if ( trav_Encoding_TypeList ) 
      trav_Encoding_TypeList( *Me.Encoding_TypeList() );
    break;
  case Choices::c_DetailedComment:
    if ( trav_DetailedComment ) 
      trav_DetailedComment( *Me.DetailedComment() );
    break;
  case Choices::c_Number:
    if ( trav_Number ) 
      trav_Number( *Me.Number() );
    break;
  case Choices::c_RangeTypeLength:
    if ( trav_RangeTypeLength ) 
      trav_RangeTypeLength( *Me.RangeTypeLength() );
    break;
  case Choices::c_LowerTypeBound:
    if ( trav_LowerTypeBound ) 
      trav_LowerTypeBound( *Me.LowerTypeBound() );
    break;
  case Choices::c_UpperTypeBound:
    if ( trav_UpperTypeBound ) 
      trav_UpperTypeBound( *Me.UpperTypeBound() );
    break;
  case Choices::c_IntegerRange:
    if ( trav_IntegerRange ) 
      trav_IntegerRange( *Me.IntegerRange() );
    break;
  case Choices::c_SimpleValueList:
    if ( trav_SimpleValueList ) 
      trav_SimpleValueList( *Me.SimpleValueList() );
    break;
  case Choices::c_SimpleValue:
    if ( trav_SimpleValue ) 
      trav_SimpleValue( *Me.SimpleValue() );
    break;
  case Choices::c_StructTypeDefs:
    if ( trav_StructTypeDefs ) 
      trav_StructTypeDefs( *Me.StructTypeDefs() );
    break;
  case Choices::c_StructTypeDef:
    if ( trav_StructTypeDef ) 
      trav_StructTypeDef( *Me.StructTypeDef() );
    break;
  case Choices::c_StructId:
    if ( trav_StructId ) 
      trav_StructId( *Me.StructId() );
    break;
  case Choices::c_StructIdAndFullId:
    if ( trav_StructIdAndFullId ) 
      trav_StructIdAndFullId( *Me.StructIdAndFullId() );
    break;
  case Choices::c_FullIdentifier:
    if ( trav_FullIdentifier ) 
      trav_FullIdentifier( *Me.FullIdentifier() );
    break;
  case Choices::c_ElemDcls:
    if ( trav_ElemDcls ) 
      trav_ElemDcls( *Me.ElemDcls() );
    break;
  case Choices::c_ElemDcl:
    if ( trav_ElemDcl ) 
      trav_ElemDcl( *Me.ElemDcl() );
    break;
  case Choices::c_ElemId:
    if ( trav_ElemId ) 
      trav_ElemId( *Me.ElemId() );
    break;
  case Choices::c_ElemType:
    if ( trav_ElemType ) 
      trav_ElemType( *Me.ElemType() );
    break;
  case Choices::c_ElemIdAndFullId:
    if ( trav_ElemIdAndFullId ) 
      trav_ElemIdAndFullId( *Me.ElemIdAndFullId() );
    break;
  case Choices::c_TypeAndAttributes:
    if ( trav_TypeAndAttributes ) 
      trav_TypeAndAttributes( *Me.TypeAndAttributes() );
    break;
  case Choices::c_TypeAndLengthAttribute:
    if ( trav_TypeAndLengthAttribute ) 
      trav_TypeAndLengthAttribute( *Me.TypeAndLengthAttribute() );
    break;
  case Choices::c_LengthAttribute:
    if ( trav_LengthAttribute ) 
      trav_LengthAttribute( *Me.LengthAttribute() );
    break;
  case Choices::c_SingleLength:
    if ( trav_SingleLength ) 
      trav_SingleLength( *Me.SingleLength() );
    break;
  case Choices::c_Bound:
    if ( trav_Bound ) 
      trav_Bound( *Me.Bound() );
    break;
  case Choices::c_RangeLength:
    if ( trav_RangeLength ) 
      trav_RangeLength( *Me.RangeLength() );
    break;
  case Choices::c_LowerBound:
    if ( trav_LowerBound ) 
      trav_LowerBound( *Me.LowerBound() );
    break;
  case Choices::c_UpperBound:
    if ( trav_UpperBound ) 
      trav_UpperBound( *Me.UpperBound() );
    break;
  case Choices::c_ASN1_TypeDefs:
    if ( trav_ASN1_TypeDefs ) 
      trav_ASN1_TypeDefs( *Me.ASN1_TypeDefs() );
    break;
  case Choices::c_ASN1_TypeDef:
    if ( trav_ASN1_TypeDef ) 
      trav_ASN1_TypeDef( *Me.ASN1_TypeDef() );
    break;
  case Choices::c_ASN1_TypeId:
    if ( trav_ASN1_TypeId ) 
      trav_ASN1_TypeId( *Me.ASN1_TypeId() );
    break;
  case Choices::c_ASN1_TypeDefinition:
    if ( trav_ASN1_TypeDefinition ) 
      trav_ASN1_TypeDefinition( *Me.ASN1_TypeDefinition() );
    break;
  case Choices::c_ASN1_TypeRefs:
    if ( trav_ASN1_TypeRefs ) 
      trav_ASN1_TypeRefs( *Me.ASN1_TypeRefs() );
    break;
  case Choices::c_ASN1_TypeRefList:
    if ( trav_ASN1_TypeRefList ) 
      trav_ASN1_TypeRefList( *Me.ASN1_TypeRefList() );
    break;
  case Choices::c_ASN1_TypeRef:
    if ( trav_ASN1_TypeRef ) 
      trav_ASN1_TypeRef( *Me.ASN1_TypeRef() );
    break;
  case Choices::c_ASN1_TypeReference:
    if ( trav_ASN1_TypeReference ) 
      trav_ASN1_TypeReference( *Me.ASN1_TypeReference() );
    break;
  case Choices::c_ASN1_ModuleId:
    if ( trav_ASN1_ModuleId ) 
      trav_ASN1_ModuleId( *Me.ASN1_ModuleId() );
    break;
  case Choices::c_TS_ProcDefs:
    if ( trav_TS_ProcDefs ) 
      trav_TS_ProcDefs( *Me.TS_ProcDefs() );
    break;
  case Choices::c_TS_OpDefs:
    if ( trav_TS_OpDefs ) 
      trav_TS_OpDefs( *Me.TS_OpDefs() );
    break;
  case Choices::c_TS_OpDef:
    if ( trav_TS_OpDef ) 
      trav_TS_OpDef( *Me.TS_OpDef() );
    break;
  case Choices::c_TS_ProcDef:
    if ( trav_TS_ProcDef ) 
      trav_TS_ProcDef( *Me.TS_ProcDef() );
    break;
  case Choices::c_TS_OpId:
    if ( trav_TS_OpId ) 
      trav_TS_OpId( *Me.TS_OpId() );
    break;
  case Choices::c_TS_ProcId:
    if ( trav_TS_ProcId ) 
      trav_TS_ProcId( *Me.TS_ProcId() );
    break;
  case Choices::c_TS_OpIdAndParList:
    if ( trav_TS_OpIdAndParList ) 
      trav_TS_OpIdAndParList( *Me.TS_OpIdAndParList() );
    break;
  case Choices::c_TS_ProcIdAndParList:
    if ( trav_TS_ProcIdAndParList ) 
      trav_TS_ProcIdAndParList( *Me.TS_ProcIdAndParList() );
    break;
  case Choices::c_TS_OpResult:
    if ( trav_TS_OpResult ) 
      trav_TS_OpResult( *Me.TS_OpResult() );
    break;
  case Choices::c_TS_ProcResult:
    if ( trav_TS_ProcResult ) 
      trav_TS_ProcResult( *Me.TS_ProcResult() );
    break;
  case Choices::c_TS_OpDescription:
    if ( trav_TS_OpDescription ) 
      trav_TS_OpDescription( *Me.TS_OpDescription() );
    break;
  case Choices::c_TS_ProcDescription:
    if ( trav_TS_ProcDescription ) 
      trav_TS_ProcDescription( *Me.TS_ProcDescription() );
    break;
  case Choices::c_ParamAndSelection:
    if ( trav_ParamAndSelection ) 
      trav_ParamAndSelection( *Me.ParamAndSelection() );
    break;
  case Choices::c_TS_ParDcls:
    if ( trav_TS_ParDcls ) 
      trav_TS_ParDcls( *Me.TS_ParDcls() );
    break;
  case Choices::c_TS_ParDclList:
    if ( trav_TS_ParDclList ) 
      trav_TS_ParDclList( *Me.TS_ParDclList() );
    break;
  case Choices::c_TS_ParDcl:
    if ( trav_TS_ParDcl ) 
      trav_TS_ParDcl( *Me.TS_ParDcl() );
    break;
  case Choices::c_TS_ParId:
    if ( trav_TS_ParId ) 
      trav_TS_ParId( *Me.TS_ParId() );
    break;
  case Choices::c_PICS_PIXITref:
    if ( trav_PICS_PIXITref ) 
      trav_PICS_PIXITref( *Me.PICS_PIXITref() );
    break;
  case Choices::c_TS_ParType:
    if ( trav_TS_ParType ) 
      trav_TS_ParType( *Me.TS_ParType() );
    break;
  case Choices::c_SelectExprDefs:
    if ( trav_SelectExprDefs ) 
      trav_SelectExprDefs( *Me.SelectExprDefs() );
    break;
  case Choices::c_SelectExprDefList:
    if ( trav_SelectExprDefList ) 
      trav_SelectExprDefList( *Me.SelectExprDefList() );
    break;
  case Choices::c_SelectExprDef:
    if ( trav_SelectExprDef ) 
      trav_SelectExprDef( *Me.SelectExprDef() );
    break;
  case Choices::c_SelectExprId:
    if ( trav_SelectExprId ) 
      trav_SelectExprId( *Me.SelectExprId() );
    break;
  case Choices::c_SelectExpr:
    if ( trav_SelectExpr ) 
      trav_SelectExpr( *Me.SelectExpr() );
    break;
  case Choices::c_SelectionExpression:
    if ( trav_SelectionExpression ) 
      trav_SelectionExpression( *Me.SelectionExpression() );
    break;
  case Choices::c_Declarations:
    if ( trav_Declarations ) 
      trav_Declarations( *Me.Declarations() );
    break;
  case Choices::c_TS_ConstDcls:
    if ( trav_TS_ConstDcls ) 
      trav_TS_ConstDcls( *Me.TS_ConstDcls() );
    break;
  case Choices::c_TS_ConstRefs:
    if ( trav_TS_ConstRefs ) 
      trav_TS_ConstRefs( *Me.TS_ConstRefs() );
    break;
  case Choices::c_TS_ConstDclList:
    if ( trav_TS_ConstDclList ) 
      trav_TS_ConstDclList( *Me.TS_ConstDclList() );
    break;
  case Choices::c_TS_ConstRefList:
    if ( trav_TS_ConstRefList ) 
      trav_TS_ConstRefList( *Me.TS_ConstRefList() );
    break;
  case Choices::c_TS_ConstDcl:
    if ( trav_TS_ConstDcl ) 
      trav_TS_ConstDcl( *Me.TS_ConstDcl() );
    break;
  case Choices::c_TS_ConstRef:
    if ( trav_TS_ConstRef ) 
      trav_TS_ConstRef( *Me.TS_ConstRef() );
    break;
  case Choices::c_ASN1_ValueReference:
    if ( trav_ASN1_ValueReference ) 
      trav_ASN1_ValueReference( *Me.ASN1_ValueReference() );
    break;
  case Choices::c_TS_ConstId:
    if ( trav_TS_ConstId ) 
      trav_TS_ConstId( *Me.TS_ConstId() );
    break;
  case Choices::c_TS_ConstType:
    if ( trav_TS_ConstType ) 
      trav_TS_ConstType( *Me.TS_ConstType() );
    break;
  case Choices::c_TS_ConstValue:
    if ( trav_TS_ConstValue ) 
      trav_TS_ConstValue( *Me.TS_ConstValue() );
    break;
  case Choices::c_DeclarationValue:
    if ( trav_DeclarationValue ) 
      trav_DeclarationValue( *Me.DeclarationValue() );
    break;
  case Choices::c_TS_VarDcls:
    if ( trav_TS_VarDcls ) 
      trav_TS_VarDcls( *Me.TS_VarDcls() );
    break;
  case Choices::c_TS_VarDclList:
    if ( trav_TS_VarDclList ) 
      trav_TS_VarDclList( *Me.TS_VarDclList() );
    break;
  case Choices::c_TS_VarDcl:
    if ( trav_TS_VarDcl ) 
      trav_TS_VarDcl( *Me.TS_VarDcl() );
    break;
  case Choices::c_TS_VarId:
    if ( trav_TS_VarId ) 
      trav_TS_VarId( *Me.TS_VarId() );
    break;
  case Choices::c_TS_VarType:
    if ( trav_TS_VarType ) 
      trav_TS_VarType( *Me.TS_VarType() );
    break;
  case Choices::c_TS_VarValue:
    if ( trav_TS_VarValue ) 
      trav_TS_VarValue( *Me.TS_VarValue() );
    break;
  case Choices::c_TC_VarDcls:
    if ( trav_TC_VarDcls ) 
      trav_TC_VarDcls( *Me.TC_VarDcls() );
    break;
  case Choices::c_TC_VarDclList:
    if ( trav_TC_VarDclList ) 
      trav_TC_VarDclList( *Me.TC_VarDclList() );
    break;
  case Choices::c_TC_VarDcl:
    if ( trav_TC_VarDcl ) 
      trav_TC_VarDcl( *Me.TC_VarDcl() );
    break;
  case Choices::c_TC_VarId:
    if ( trav_TC_VarId ) 
      trav_TC_VarId( *Me.TC_VarId() );
    break;
  case Choices::c_TC_VarType:
    if ( trav_TC_VarType ) 
      trav_TC_VarType( *Me.TC_VarType() );
    break;
  case Choices::c_TC_VarValue:
    if ( trav_TC_VarValue ) 
      trav_TC_VarValue( *Me.TC_VarValue() );
    break;
  case Choices::c_TCompDcls:
    if ( trav_TCompDcls ) 
      trav_TCompDcls( *Me.TCompDcls() );
    break;
  case Choices::c_TCompDclList:
    if ( trav_TCompDclList ) 
      trav_TCompDclList( *Me.TCompDclList() );
    break;
  case Choices::c_TCompDcl:
    if ( trav_TCompDcl ) 
      trav_TCompDcl( *Me.TCompDcl() );
    break;
  case Choices::c_TCompId:
    if ( trav_TCompId ) 
      trav_TCompId( *Me.TCompId() );
    break;
  case Choices::c_TC_Role:
    if ( trav_TC_Role ) 
      trav_TC_Role( *Me.TC_Role() );
    break;
  case Choices::c_TComp_Role:
    if ( trav_TComp_Role ) 
      trav_TComp_Role( *Me.TComp_Role() );
    break;
  case Choices::c_NumOf_PCOs:
    if ( trav_NumOf_PCOs ) 
      trav_NumOf_PCOs( *Me.NumOf_PCOs() );
    break;
  case Choices::c_NumOf_CPs:
    if ( trav_NumOf_CPs ) 
      trav_NumOf_CPs( *Me.NumOf_CPs() );
    break;
  case Choices::c_Num_PCOs:
    if ( trav_Num_PCOs ) 
      trav_Num_PCOs( *Me.Num_PCOs() );
    break;
  case Choices::c_Num_CPs:
    if ( trav_Num_CPs ) 
      trav_Num_CPs( *Me.Num_CPs() );
    break;
  case Choices::c_TCompConfigDcls:
    if ( trav_TCompConfigDcls ) 
      trav_TCompConfigDcls( *Me.TCompConfigDcls() );
    break;
  case Choices::c_TCompConfigDcl:
    if ( trav_TCompConfigDcl ) 
      trav_TCompConfigDcl( *Me.TCompConfigDcl() );
    break;
  case Choices::c_TCompConfigInfoList:
    if ( trav_TCompConfigInfoList ) 
      trav_TCompConfigInfoList( *Me.TCompConfigInfoList() );
    break;
  case Choices::c_TCompConfigId:
    if ( trav_TCompConfigId ) 
      trav_TCompConfigId( *Me.TCompConfigId() );
    break;
  case Choices::c_TCompConfigInfo:
    if ( trav_TCompConfigInfo ) 
      trav_TCompConfigInfo( *Me.TCompConfigInfo() );
    break;
  case Choices::c_TCompUsed:
    if ( trav_TCompUsed ) 
      trav_TCompUsed( *Me.TCompUsed() );
    break;
  case Choices::c_PCOs_Used:
    if ( trav_PCOs_Used ) 
      trav_PCOs_Used( *Me.PCOs_Used() );
    break;
  case Choices::c_PCO_List:
    if ( trav_PCO_List ) 
      trav_PCO_List( *Me.PCO_List() );
    break;
  case Choices::c_CPs_Used:
    if ( trav_CPs_Used ) 
      trav_CPs_Used( *Me.CPs_Used() );
    break;
  case Choices::c_CP_List:
    if ( trav_CP_List ) 
      trav_CP_List( *Me.CP_List() );
    break;
  case Choices::c_PCO_TypeDcls:
    if ( trav_PCO_TypeDcls ) 
      trav_PCO_TypeDcls( *Me.PCO_TypeDcls() );
    break;
  case Choices::c_PCO_TypeDclList:
    if ( trav_PCO_TypeDclList ) 
      trav_PCO_TypeDclList( *Me.PCO_TypeDclList() );
    break;
  case Choices::c_PCO_TypeDcl:
    if ( trav_PCO_TypeDcl ) 
      trav_PCO_TypeDcl( *Me.PCO_TypeDcl() );
    break;
  case Choices::c_PCO_Dcls:
    if ( trav_PCO_Dcls ) 
      trav_PCO_Dcls( *Me.PCO_Dcls() );
    break;
  case Choices::c_PCO_DclList:
    if ( trav_PCO_DclList ) 
      trav_PCO_DclList( *Me.PCO_DclList() );
    break;
  case Choices::c_PCO_Dcl:
    if ( trav_PCO_Dcl ) 
      trav_PCO_Dcl( *Me.PCO_Dcl() );
    break;
  case Choices::c_PCO_Id:
    if ( trav_PCO_Id ) 
      trav_PCO_Id( *Me.PCO_Id() );
    break;
  case Choices::c_PCO_TypeId:
    if ( trav_PCO_TypeId ) 
      trav_PCO_TypeId( *Me.PCO_TypeId() );
    break;
  case Choices::c_P_Role:
    if ( trav_P_Role ) 
      trav_P_Role( *Me.P_Role() );
    break;
  case Choices::c_PCO_Role:
    if ( trav_PCO_Role ) 
      trav_PCO_Role( *Me.PCO_Role() );
    break;
  case Choices::c_CP_Dcls:
    if ( trav_CP_Dcls ) 
      trav_CP_Dcls( *Me.CP_Dcls() );
    break;
  case Choices::c_CP_DclList:
    if ( trav_CP_DclList ) 
      trav_CP_DclList( *Me.CP_DclList() );
    break;
  case Choices::c_CP_Dcl:
    if ( trav_CP_Dcl ) 
      trav_CP_Dcl( *Me.CP_Dcl() );
    break;
  case Choices::c_CP_Id:
    if ( trav_CP_Id ) 
      trav_CP_Id( *Me.CP_Id() );
    break;
  case Choices::c_TimerDcls:
    if ( trav_TimerDcls ) 
      trav_TimerDcls( *Me.TimerDcls() );
    break;
  case Choices::c_TimerDclList:
    if ( trav_TimerDclList ) 
      trav_TimerDclList( *Me.TimerDclList() );
    break;
  case Choices::c_TimerDcl:
    if ( trav_TimerDcl ) 
      trav_TimerDcl( *Me.TimerDcl() );
    break;
  case Choices::c_TimerId:
    if ( trav_TimerId ) 
      trav_TimerId( *Me.TimerId() );
    break;
  case Choices::c_Duration:
    if ( trav_Duration ) 
      trav_Duration( *Me.Duration() );
    break;
  case Choices::c_Unit:
    if ( trav_Unit ) 
      trav_Unit( *Me.Unit() );
    break;
  case Choices::c_TimeUnit:
    if ( trav_TimeUnit ) 
      trav_TimeUnit( *Me.TimeUnit() );
    break;
  case Choices::c_ComplexDefinitions:
    if ( trav_ComplexDefinitions ) 
      trav_ComplexDefinitions( *Me.ComplexDefinitions() );
    break;
  case Choices::c_ASP_TypeDefs:
    if ( trav_ASP_TypeDefs ) 
      trav_ASP_TypeDefs( *Me.ASP_TypeDefs() );
    break;
  case Choices::c_TTCN_ASP_TypeDefs:
    if ( trav_TTCN_ASP_TypeDefs ) 
      trav_TTCN_ASP_TypeDefs( *Me.TTCN_ASP_TypeDefs() );
    break;
  case Choices::c_TTCN_ASP_TypeDef:
    if ( trav_TTCN_ASP_TypeDef ) 
      trav_TTCN_ASP_TypeDef( *Me.TTCN_ASP_TypeDef() );
    break;
  case Choices::c_ASP_Id:
    if ( trav_ASP_Id ) 
      trav_ASP_Id( *Me.ASP_Id() );
    break;
  case Choices::c_ASP_IdAndFullId:
    if ( trav_ASP_IdAndFullId ) 
      trav_ASP_IdAndFullId( *Me.ASP_IdAndFullId() );
    break;
  case Choices::c_PCO_Type:
    if ( trav_PCO_Type ) 
      trav_PCO_Type( *Me.PCO_Type() );
    break;
  case Choices::c_ASP_ParDcls:
    if ( trav_ASP_ParDcls ) 
      trav_ASP_ParDcls( *Me.ASP_ParDcls() );
    break;
  case Choices::c_ASP_ParDcl:
    if ( trav_ASP_ParDcl ) 
      trav_ASP_ParDcl( *Me.ASP_ParDcl() );
    break;
  case Choices::c_ASP_ParId:
    if ( trav_ASP_ParId ) 
      trav_ASP_ParId( *Me.ASP_ParId() );
    break;
  case Choices::c_ASP_ParIdOrMacro:
    if ( trav_ASP_ParIdOrMacro ) 
      trav_ASP_ParIdOrMacro( *Me.ASP_ParIdOrMacro() );
    break;
  case Choices::c_ASP_ParIdAndFullId:
    if ( trav_ASP_ParIdAndFullId ) 
      trav_ASP_ParIdAndFullId( *Me.ASP_ParIdAndFullId() );
    break;
  case Choices::c_ASP_ParType:
    if ( trav_ASP_ParType ) 
      trav_ASP_ParType( *Me.ASP_ParType() );
    break;
  case Choices::c_ASN1_ASP_TypeDefs:
    if ( trav_ASN1_ASP_TypeDefs ) 
      trav_ASN1_ASP_TypeDefs( *Me.ASN1_ASP_TypeDefs() );
    break;
  case Choices::c_ASN1_ASP_TypeDef:
    if ( trav_ASN1_ASP_TypeDef ) 
      trav_ASN1_ASP_TypeDef( *Me.ASN1_ASP_TypeDef() );
    break;
  case Choices::c_ASN1_ASP_TypeDefsByRef:
    if ( trav_ASN1_ASP_TypeDefsByRef ) 
      trav_ASN1_ASP_TypeDefsByRef( *Me.ASN1_ASP_TypeDefsByRef() );
    break;
  case Choices::c_ASN1_ASP_TypeDefByRefList:
    if ( trav_ASN1_ASP_TypeDefByRefList ) 
      trav_ASN1_ASP_TypeDefByRefList( *Me.ASN1_ASP_TypeDefByRefList() );
    break;
  case Choices::c_ASN1_ASP_TypeDefByRef:
    if ( trav_ASN1_ASP_TypeDefByRef ) 
      trav_ASN1_ASP_TypeDefByRef( *Me.ASN1_ASP_TypeDefByRef() );
    break;
  case Choices::c_PDU_TypeDefs:
    if ( trav_PDU_TypeDefs ) 
      trav_PDU_TypeDefs( *Me.PDU_TypeDefs() );
    break;
  case Choices::c_TTCN_PDU_TypeDefs:
    if ( trav_TTCN_PDU_TypeDefs ) 
      trav_TTCN_PDU_TypeDefs( *Me.TTCN_PDU_TypeDefs() );
    break;
  case Choices::c_TTCN_PDU_TypeDef:
    if ( trav_TTCN_PDU_TypeDef ) 
      trav_TTCN_PDU_TypeDef( *Me.TTCN_PDU_TypeDef() );
    break;
  case Choices::c_PDU_Id:
    if ( trav_PDU_Id ) 
      trav_PDU_Id( *Me.PDU_Id() );
    break;
  case Choices::c_PDU_IdAndFullId:
    if ( trav_PDU_IdAndFullId ) 
      trav_PDU_IdAndFullId( *Me.PDU_IdAndFullId() );
    break;
  case Choices::c_PDU_FieldDcls:
    if ( trav_PDU_FieldDcls ) 
      trav_PDU_FieldDcls( *Me.PDU_FieldDcls() );
    break;
  case Choices::c_PDU_FieldDcl:
    if ( trav_PDU_FieldDcl ) 
      trav_PDU_FieldDcl( *Me.PDU_FieldDcl() );
    break;
  case Choices::c_PDU_FieldId:
    if ( trav_PDU_FieldId ) 
      trav_PDU_FieldId( *Me.PDU_FieldId() );
    break;
  case Choices::c_PDU_FieldIdOrMacro:
    if ( trav_PDU_FieldIdOrMacro ) 
      trav_PDU_FieldIdOrMacro( *Me.PDU_FieldIdOrMacro() );
    break;
  case Choices::c_PDU_FieldIdAndFullId:
    if ( trav_PDU_FieldIdAndFullId ) 
      trav_PDU_FieldIdAndFullId( *Me.PDU_FieldIdAndFullId() );
    break;
  case Choices::c_PDU_FieldType:
    if ( trav_PDU_FieldType ) 
      trav_PDU_FieldType( *Me.PDU_FieldType() );
    break;
  case Choices::c_ASN1_PDU_TypeDefs:
    if ( trav_ASN1_PDU_TypeDefs ) 
      trav_ASN1_PDU_TypeDefs( *Me.ASN1_PDU_TypeDefs() );
    break;
  case Choices::c_ASN1_PDU_TypeDef:
    if ( trav_ASN1_PDU_TypeDef ) 
      trav_ASN1_PDU_TypeDef( *Me.ASN1_PDU_TypeDef() );
    break;
  case Choices::c_ASN1_PDU_TypeDefsByRef:
    if ( trav_ASN1_PDU_TypeDefsByRef ) 
      trav_ASN1_PDU_TypeDefsByRef( *Me.ASN1_PDU_TypeDefsByRef() );
    break;
  case Choices::c_ASN1_PDU_TypeDefByRefList:
    if ( trav_ASN1_PDU_TypeDefByRefList ) 
      trav_ASN1_PDU_TypeDefByRefList( *Me.ASN1_PDU_TypeDefByRefList() );
    break;
  case Choices::c_ASN1_PDU_TypeDefByRef:
    if ( trav_ASN1_PDU_TypeDefByRef ) 
      trav_ASN1_PDU_TypeDefByRef( *Me.ASN1_PDU_TypeDefByRef() );
    break;
  case Choices::c_CM_TypeDefs:
    if ( trav_CM_TypeDefs ) 
      trav_CM_TypeDefs( *Me.CM_TypeDefs() );
    break;
  case Choices::c_TTCN_CM_TypeDefs:
    if ( trav_TTCN_CM_TypeDefs ) 
      trav_TTCN_CM_TypeDefs( *Me.TTCN_CM_TypeDefs() );
    break;
  case Choices::c_TTCN_CM_TypeDef:
    if ( trav_TTCN_CM_TypeDef ) 
      trav_TTCN_CM_TypeDef( *Me.TTCN_CM_TypeDef() );
    break;
  case Choices::c_CM_Id:
    if ( trav_CM_Id ) 
      trav_CM_Id( *Me.CM_Id() );
    break;
  case Choices::c_CM_ParDcls:
    if ( trav_CM_ParDcls ) 
      trav_CM_ParDcls( *Me.CM_ParDcls() );
    break;
  case Choices::c_CM_ParDcl:
    if ( trav_CM_ParDcl ) 
      trav_CM_ParDcl( *Me.CM_ParDcl() );
    break;
  case Choices::c_CM_ParId:
    if ( trav_CM_ParId ) 
      trav_CM_ParId( *Me.CM_ParId() );
    break;
  case Choices::c_CM_ParIdOrMacro:
    if ( trav_CM_ParIdOrMacro ) 
      trav_CM_ParIdOrMacro( *Me.CM_ParIdOrMacro() );
    break;
  case Choices::c_CM_ParIdAndFullId:
    if ( trav_CM_ParIdAndFullId ) 
      trav_CM_ParIdAndFullId( *Me.CM_ParIdAndFullId() );
    break;
  case Choices::c_CM_ParType:
    if ( trav_CM_ParType ) 
      trav_CM_ParType( *Me.CM_ParType() );
    break;
  case Choices::c_ASN1_CM_TypeDefs:
    if ( trav_ASN1_CM_TypeDefs ) 
      trav_ASN1_CM_TypeDefs( *Me.ASN1_CM_TypeDefs() );
    break;
  case Choices::c_ASN1_CM_TypeDef:
    if ( trav_ASN1_CM_TypeDef ) 
      trav_ASN1_CM_TypeDef( *Me.ASN1_CM_TypeDef() );
    break;
  case Choices::c_AliasDefs:
    if ( trav_AliasDefs ) 
      trav_AliasDefs( *Me.AliasDefs() );
    break;
  case Choices::c_AliasDefList:
    if ( trav_AliasDefList ) 
      trav_AliasDefList( *Me.AliasDefList() );
    break;
  case Choices::c_AliasDef:
    if ( trav_AliasDef ) 
      trav_AliasDef( *Me.AliasDef() );
    break;
  case Choices::c_AliasId:
    if ( trav_AliasId ) 
      trav_AliasId( *Me.AliasId() );
    break;
  case Choices::c_ExpandedId:
    if ( trav_ExpandedId ) 
      trav_ExpandedId( *Me.ExpandedId() );
    break;
  case Choices::c_Expansion:
    if ( trav_Expansion ) 
      trav_Expansion( *Me.Expansion() );
    break;
  case Choices::c_ConstraintsPart:
    if ( trav_ConstraintsPart ) 
      trav_ConstraintsPart( *Me.ConstraintsPart() );
    break;
  case Choices::c_TS_TypeConstraints:
    if ( trav_TS_TypeConstraints ) 
      trav_TS_TypeConstraints( *Me.TS_TypeConstraints() );
    break;
  case Choices::c_ASP_Constraints:
    if ( trav_ASP_Constraints ) 
      trav_ASP_Constraints( *Me.ASP_Constraints() );
    break;
  case Choices::c_PDU_Constraints:
    if ( trav_PDU_Constraints ) 
      trav_PDU_Constraints( *Me.PDU_Constraints() );
    break;
  case Choices::c_CM_Constraints:
    if ( trav_CM_Constraints ) 
      trav_CM_Constraints( *Me.CM_Constraints() );
    break;
  case Choices::c_StructTypeConstraints:
    if ( trav_StructTypeConstraints ) 
      trav_StructTypeConstraints( *Me.StructTypeConstraints() );
    break;
  case Choices::c_StructTypeConstraint:
    if ( trav_StructTypeConstraint ) 
      trav_StructTypeConstraint( *Me.StructTypeConstraint() );
    break;
  case Choices::c_ConsId:
    if ( trav_ConsId ) 
      trav_ConsId( *Me.ConsId() );
    break;
  case Choices::c_ConsIdAndParList:
    if ( trav_ConsIdAndParList ) 
      trav_ConsIdAndParList( *Me.ConsIdAndParList() );
    break;
  case Choices::c_DerivPath:
    if ( trav_DerivPath ) 
      trav_DerivPath( *Me.DerivPath() );
    break;
  case Choices::c_DerivationPath:
    if ( trav_DerivationPath ) 
      trav_DerivationPath( *Me.DerivationPath() );
    break;
  case Choices::c_ElemValues:
    if ( trav_ElemValues ) 
      trav_ElemValues( *Me.ElemValues() );
    break;
  case Choices::c_ElemValue:
    if ( trav_ElemValue ) 
      trav_ElemValue( *Me.ElemValue() );
    break;
  case Choices::c_ASN1_TypeConstraints:
    if ( trav_ASN1_TypeConstraints ) 
      trav_ASN1_TypeConstraints( *Me.ASN1_TypeConstraints() );
    break;
  case Choices::c_ASN1_TypeConstraint:
    if ( trav_ASN1_TypeConstraint ) 
      trav_ASN1_TypeConstraint( *Me.ASN1_TypeConstraint() );
    break;
  case Choices::c_TTCN_ASP_Constraints:
    if ( trav_TTCN_ASP_Constraints ) 
      trav_TTCN_ASP_Constraints( *Me.TTCN_ASP_Constraints() );
    break;
  case Choices::c_TTCN_ASP_Constraint:
    if ( trav_TTCN_ASP_Constraint ) 
      trav_TTCN_ASP_Constraint( *Me.TTCN_ASP_Constraint() );
    break;
  case Choices::c_ASP_ParValues:
    if ( trav_ASP_ParValues ) 
      trav_ASP_ParValues( *Me.ASP_ParValues() );
    break;
  case Choices::c_ASP_ParValue:
    if ( trav_ASP_ParValue ) 
      trav_ASP_ParValue( *Me.ASP_ParValue() );
    break;
  case Choices::c_TTCN_PDU_Constraints:
    if ( trav_TTCN_PDU_Constraints ) 
      trav_TTCN_PDU_Constraints( *Me.TTCN_PDU_Constraints() );
    break;
  case Choices::c_TTCN_PDU_Constraint:
    if ( trav_TTCN_PDU_Constraint ) 
      trav_TTCN_PDU_Constraint( *Me.TTCN_PDU_Constraint() );
    break;
  case Choices::c_PDU_FieldValues:
    if ( trav_PDU_FieldValues ) 
      trav_PDU_FieldValues( *Me.PDU_FieldValues() );
    break;
  case Choices::c_PDU_FieldValue:
    if ( trav_PDU_FieldValue ) 
      trav_PDU_FieldValue( *Me.PDU_FieldValue() );
    break;
  case Choices::c_ConsValue:
    if ( trav_ConsValue ) 
      trav_ConsValue( *Me.ConsValue() );
    break;
  case Choices::c_ASN1_ASP_Constraints:
    if ( trav_ASN1_ASP_Constraints ) 
      trav_ASN1_ASP_Constraints( *Me.ASN1_ASP_Constraints() );
    break;
  case Choices::c_ASN1_ASP_Constraint:
    if ( trav_ASN1_ASP_Constraint ) 
      trav_ASN1_ASP_Constraint( *Me.ASN1_ASP_Constraint() );
    break;
  case Choices::c_ASN1_PDU_Constraints:
    if ( trav_ASN1_PDU_Constraints ) 
      trav_ASN1_PDU_Constraints( *Me.ASN1_PDU_Constraints() );
    break;
  case Choices::c_ASN1_PDU_Constraint:
    if ( trav_ASN1_PDU_Constraint ) 
      trav_ASN1_PDU_Constraint( *Me.ASN1_PDU_Constraint() );
    break;
  case Choices::c_ASN1_ConsValue:
    if ( trav_ASN1_ConsValue ) 
      trav_ASN1_ConsValue( *Me.ASN1_ConsValue() );
    break;
  case Choices::c_ConstraintValueAndAttributesOrReplace:
    if ( trav_ConstraintValueAndAttributesOrReplace ) 
      trav_ConstraintValueAndAttributesOrReplace( *Me.ConstraintValueAndAttributesOrReplace() );
    break;
  case Choices::c_ReplacementList:
    if ( trav_ReplacementList ) 
      trav_ReplacementList( *Me.ReplacementList() );
    break;
  case Choices::c_Replacement:
    if ( trav_Replacement ) 
      trav_Replacement( *Me.Replacement() );
    break;
  case Choices::c_Replace:
    if ( trav_Replace ) 
      trav_Replace( *Me.Replace() );
    break;
  case Choices::c_ReferenceList:
    if ( trav_ReferenceList ) 
      trav_ReferenceList( *Me.ReferenceList() );
    break;
  case Choices::c_OmitReference:
    if ( trav_OmitReference ) 
      trav_OmitReference( *Me.OmitReference() );
    break;
  case Choices::c_ArrayRefOrComp:
    if ( trav_ArrayRefOrComp ) 
      trav_ArrayRefOrComp( *Me.ArrayRefOrComp() );
    break;
  case Choices::c_TTCN_CM_Constraints:
    if ( trav_TTCN_CM_Constraints ) 
      trav_TTCN_CM_Constraints( *Me.TTCN_CM_Constraints() );
    break;
  case Choices::c_TTCN_CM_Constraint:
    if ( trav_TTCN_CM_Constraint ) 
      trav_TTCN_CM_Constraint( *Me.TTCN_CM_Constraint() );
    break;
  case Choices::c_CM_ParValues:
    if ( trav_CM_ParValues ) 
      trav_CM_ParValues( *Me.CM_ParValues() );
    break;
  case Choices::c_CM_ParValue:
    if ( trav_CM_ParValue ) 
      trav_CM_ParValue( *Me.CM_ParValue() );
    break;
  case Choices::c_ASN1_CM_Constraints:
    if ( trav_ASN1_CM_Constraints ) 
      trav_ASN1_CM_Constraints( *Me.ASN1_CM_Constraints() );
    break;
  case Choices::c_ASN1_CM_Constraint:
    if ( trav_ASN1_CM_Constraint ) 
      trav_ASN1_CM_Constraint( *Me.ASN1_CM_Constraint() );
    break;
  case Choices::c_DynamicPart:
    if ( trav_DynamicPart ) 
      trav_DynamicPart( *Me.DynamicPart() );
    break;
  case Choices::c_TestCases:
    if ( trav_TestCases ) 
      trav_TestCases( *Me.TestCases() );
    break;
  case Choices::c_TestGroupOrTestCaseList:
    if ( trav_TestGroupOrTestCaseList ) 
      trav_TestGroupOrTestCaseList( *Me.TestGroupOrTestCaseList() );
    break;
  case Choices::c_TestGroupOrTestCase:
    if ( trav_TestGroupOrTestCase ) 
      trav_TestGroupOrTestCase( *Me.TestGroupOrTestCase() );
    break;
  case Choices::c_TestGroup:
    if ( trav_TestGroup ) 
      trav_TestGroup( *Me.TestGroup() );
    break;
  case Choices::c_CompactTestGroup:
    if ( trav_CompactTestGroup ) 
      trav_CompactTestGroup( *Me.CompactTestGroup() );
    break;
  case Choices::c_CompactTestCaseList:
    if ( trav_CompactTestCaseList ) 
      trav_CompactTestCaseList( *Me.CompactTestCaseList() );
    break;
  case Choices::c_CompactTestCase:
    if ( trav_CompactTestCase ) 
      trav_CompactTestCase( *Me.CompactTestCase() );
    break;
  case Choices::c_TestStepAttachment:
    if ( trav_TestStepAttachment ) 
      trav_TestStepAttachment( *Me.TestStepAttachment() );
    break;
  case Choices::c_TestCase:
    if ( trav_TestCase ) 
      trav_TestCase( *Me.TestCase() );
    break;
  case Choices::c_TestCaseId:
    if ( trav_TestCaseId ) 
      trav_TestCaseId( *Me.TestCaseId() );
    break;
  case Choices::c_TestGroupRef:
    if ( trav_TestGroupRef ) 
      trav_TestGroupRef( *Me.TestGroupRef() );
    break;
  case Choices::c_TestPurpose:
    if ( trav_TestPurpose ) 
      trav_TestPurpose( *Me.TestPurpose() );
    break;
  case Choices::c_Objective:
    if ( trav_Objective ) 
      trav_Objective( *Me.Objective() );
    break;
  case Choices::c_Description:
    if ( trav_Description ) 
      trav_Description( *Me.Description() );
    break;
  case Choices::c_Configuration:
    if ( trav_Configuration ) 
      trav_Configuration( *Me.Configuration() );
    break;
  case Choices::c_SelExprId:
    if ( trav_SelExprId ) 
      trav_SelExprId( *Me.SelExprId() );
    break;
  case Choices::c_DefaultsRef:
    if ( trav_DefaultsRef ) 
      trav_DefaultsRef( *Me.DefaultsRef() );
    break;
  case Choices::c_DefaultRefList:
    if ( trav_DefaultRefList ) 
      trav_DefaultRefList( *Me.DefaultRefList() );
    break;
  case Choices::c_DefaultReference:
    if ( trav_DefaultReference ) 
      trav_DefaultReference( *Me.DefaultReference() );
    break;
  case Choices::c_BehaviourDescription:
    if ( trav_BehaviourDescription ) 
      trav_BehaviourDescription( *Me.BehaviourDescription() );
    break;
  case Choices::c_RootTree:
    if ( trav_RootTree ) 
      trav_RootTree( *Me.RootTree() );
    break;
  case Choices::c_BehaviourLineList:
    if ( trav_BehaviourLineList ) 
      trav_BehaviourLineList( *Me.BehaviourLineList() );
    break;
  case Choices::c_Children:
    if ( trav_Children ) 
      trav_Children( *Me.Children() );
    break;
  case Choices::c_BehaviourLine:
    if ( trav_BehaviourLine ) 
      trav_BehaviourLine( *Me.BehaviourLine() );
    break;
  case Choices::c_LineNumber:
    if ( trav_LineNumber ) 
      trav_LineNumber( *Me.LineNumber() );
    break;
  case Choices::c_LabelId:
    if ( trav_LabelId ) 
      trav_LabelId( *Me.LabelId() );
    break;
  case Choices::c_Label:
    if ( trav_Label ) 
      trav_Label( *Me.Label() );
    break;
  case Choices::c_Line:
    if ( trav_Line ) 
      trav_Line( *Me.Line() );
    break;
  case Choices::c_Indentation:
    if ( trav_Indentation ) 
      trav_Indentation( *Me.Indentation() );
    break;
  case Choices::c_VerdictId:
    if ( trav_VerdictId ) 
      trav_VerdictId( *Me.VerdictId() );
    break;
  case Choices::c_Verdict:
    if ( trav_Verdict ) 
      trav_Verdict( *Me.Verdict() );
    break;
  case Choices::c_Pass:
    if ( trav_Pass ) 
      trav_Pass( *Me.Pass() );
    break;
  case Choices::c_Fail:
    if ( trav_Fail ) 
      trav_Fail( *Me.Fail() );
    break;
  case Choices::c_Inconclusive:
    if ( trav_Inconclusive ) 
      trav_Inconclusive( *Me.Inconclusive() );
    break;
  case Choices::c_Result:
    if ( trav_Result ) 
      trav_Result( *Me.Result() );
    break;
  case Choices::c_StatementLine:
    if ( trav_StatementLine ) 
      trav_StatementLine( *Me.StatementLine() );
    break;
  case Choices::c_EventStatement:
    if ( trav_EventStatement ) 
      trav_EventStatement( *Me.EventStatement() );
    break;
  case Choices::c_Event:
    if ( trav_Event ) 
      trav_Event( *Me.Event() );
    break;
  case Choices::c_Send:
    if ( trav_Send ) 
      trav_Send( *Me.Send() );
    break;
  case Choices::c_ImplicitSend:
    if ( trav_ImplicitSend ) 
      trav_ImplicitSend( *Me.ImplicitSend() );
    break;
  case Choices::c_Receive:
    if ( trav_Receive ) 
      trav_Receive( *Me.Receive() );
    break;
  case Choices::c_Otherwise:
    if ( trav_Otherwise ) 
      trav_Otherwise( *Me.Otherwise() );
    break;
  case Choices::c_Timeout:
    if ( trav_Timeout ) 
      trav_Timeout( *Me.Timeout() );
    break;
  case Choices::c_Done:
    if ( trav_Done ) 
      trav_Done( *Me.Done() );
    break;
  case Choices::c_TCompIdList:
    if ( trav_TCompIdList ) 
      trav_TCompIdList( *Me.TCompIdList() );
    break;
  case Choices::c_AssignmentList:
    if ( trav_AssignmentList ) 
      trav_AssignmentList( *Me.AssignmentList() );
    break;
  case Choices::c_Assignment:
    if ( trav_Assignment ) 
      trav_Assignment( *Me.Assignment() );
    break;
  case Choices::c_Qualifier:
    if ( trav_Qualifier ) 
      trav_Qualifier( *Me.Qualifier() );
    break;
  case Choices::c_TimerOps:
    if ( trav_TimerOps ) 
      trav_TimerOps( *Me.TimerOps() );
    break;
  case Choices::c_TimerOp:
    if ( trav_TimerOp ) 
      trav_TimerOp( *Me.TimerOp() );
    break;
  case Choices::c_StartTimer:
    if ( trav_StartTimer ) 
      trav_StartTimer( *Me.StartTimer() );
    break;
  case Choices::c_CancelTimer:
    if ( trav_CancelTimer ) 
      trav_CancelTimer( *Me.CancelTimer() );
    break;
  case Choices::c_ReadTimer:
    if ( trav_ReadTimer ) 
      trav_ReadTimer( *Me.ReadTimer() );
    break;
  case Choices::c_TimerValue:
    if ( trav_TimerValue ) 
      trav_TimerValue( *Me.TimerValue() );
    break;
  case Choices::c_Construct:
    if ( trav_Construct ) 
      trav_Construct( *Me.Construct() );
    break;
  case Choices::c_GoTo:
    if ( trav_GoTo ) 
      trav_GoTo( *Me.GoTo() );
    break;
  case Choices::c_Attach:
    if ( trav_Attach ) 
      trav_Attach( *Me.Attach() );
    break;
  case Choices::c_TreeReference:
    if ( trav_TreeReference ) 
      trav_TreeReference( *Me.TreeReference() );
    break;
  case Choices::c_Repeat:
    if ( trav_Repeat ) 
      trav_Repeat( *Me.Repeat() );
    break;
  case Choices::c_Activate:
    if ( trav_Activate ) 
      trav_Activate( *Me.Activate() );
    break;
  case Choices::c_Create:
    if ( trav_Create ) 
      trav_Create( *Me.Create() );
    break;
  case Choices::c_CreateList:
    if ( trav_CreateList ) 
      trav_CreateList( *Me.CreateList() );
    break;
  case Choices::c_CreateTComp:
    if ( trav_CreateTComp ) 
      trav_CreateTComp( *Me.CreateTComp() );
    break;
  case Choices::c_CreateAttach:
    if ( trav_CreateAttach ) 
      trav_CreateAttach( *Me.CreateAttach() );
    break;
  case Choices::c_Cref:
    if ( trav_Cref ) 
      trav_Cref( *Me.Cref() );
    break;
  case Choices::c_ConstraintReference:
    if ( trav_ConstraintReference ) 
      trav_ConstraintReference( *Me.ConstraintReference() );
    break;
  case Choices::c_ConsRef:
    if ( trav_ConsRef ) 
      trav_ConsRef( *Me.ConsRef() );
    break;
  case Choices::c_ActualCrefParList:
    if ( trav_ActualCrefParList ) 
      trav_ActualCrefParList( *Me.ActualCrefParList() );
    break;
  case Choices::c_LocalTreeList:
    if ( trav_LocalTreeList ) 
      trav_LocalTreeList( *Me.LocalTreeList() );
    break;
  case Choices::c_LocalTree:
    if ( trav_LocalTree ) 
      trav_LocalTree( *Me.LocalTree() );
    break;
  case Choices::c_Header:
    if ( trav_Header ) 
      trav_Header( *Me.Header() );
    break;
  case Choices::c_TreeHeader:
    if ( trav_TreeHeader ) 
      trav_TreeHeader( *Me.TreeHeader() );
    break;
  case Choices::c_TestStepLibrary:
    if ( trav_TestStepLibrary ) 
      trav_TestStepLibrary( *Me.TestStepLibrary() );
    break;
  case Choices::c_TestStepGroupOrTestStepList:
    if ( trav_TestStepGroupOrTestStepList ) 
      trav_TestStepGroupOrTestStepList( *Me.TestStepGroupOrTestStepList() );
    break;
  case Choices::c_TestStepGroupOrTestStep:
    if ( trav_TestStepGroupOrTestStep ) 
      trav_TestStepGroupOrTestStep( *Me.TestStepGroupOrTestStep() );
    break;
  case Choices::c_TestStepGroup:
    if ( trav_TestStepGroup ) 
      trav_TestStepGroup( *Me.TestStepGroup() );
    break;
  case Choices::c_TestGroupId:
    if ( trav_TestGroupId ) 
      trav_TestGroupId( *Me.TestGroupId() );
    break;
  case Choices::c_TestStepGroupId:
    if ( trav_TestStepGroupId ) 
      trav_TestStepGroupId( *Me.TestStepGroupId() );
    break;
  case Choices::c_TestStep:
    if ( trav_TestStep ) 
      trav_TestStep( *Me.TestStep() );
    break;
  case Choices::c_TestStepId:
    if ( trav_TestStepId ) 
      trav_TestStepId( *Me.TestStepId() );
    break;
  case Choices::c_TestStepIdAndParList:
    if ( trav_TestStepIdAndParList ) 
      trav_TestStepIdAndParList( *Me.TestStepIdAndParList() );
    break;
  case Choices::c_TestStepRef:
    if ( trav_TestStepRef ) 
      trav_TestStepRef( *Me.TestStepRef() );
    break;
  case Choices::c_DefaultsLibrary:
    if ( trav_DefaultsLibrary ) 
      trav_DefaultsLibrary( *Me.DefaultsLibrary() );
    break;
  case Choices::c_DefaultGroupOrDefaultList:
    if ( trav_DefaultGroupOrDefaultList ) 
      trav_DefaultGroupOrDefaultList( *Me.DefaultGroupOrDefaultList() );
    break;
  case Choices::c_DefaultGroupOrDefault:
    if ( trav_DefaultGroupOrDefault ) 
      trav_DefaultGroupOrDefault( *Me.DefaultGroupOrDefault() );
    break;
  case Choices::c_DefaultGroup:
    if ( trav_DefaultGroup ) 
      trav_DefaultGroup( *Me.DefaultGroup() );
    break;
  case Choices::c_DefaultCase:
    if ( trav_DefaultCase ) 
      trav_DefaultCase( *Me.DefaultCase() );
    break;
  case Choices::c_DefaultGroupId:
    if ( trav_DefaultGroupId ) 
      trav_DefaultGroupId( *Me.DefaultGroupId() );
    break;
  case Choices::c_DefaultId:
    if ( trav_DefaultId ) 
      trav_DefaultId( *Me.DefaultId() );
    break;
  case Choices::c_DefaultIdAndParList:
    if ( trav_DefaultIdAndParList ) 
      trav_DefaultIdAndParList( *Me.DefaultIdAndParList() );
    break;
  case Choices::c_DefaultRef:
    if ( trav_DefaultRef ) 
      trav_DefaultRef( *Me.DefaultRef() );
    break;
  case Choices::c_ConstraintValueAndAttributes:
    if ( trav_ConstraintValueAndAttributes ) 
      trav_ConstraintValueAndAttributes( *Me.ConstraintValueAndAttributes() );
    break;
  case Choices::c_ConstraintValue:
    if ( trav_ConstraintValue ) 
      trav_ConstraintValue( *Me.ConstraintValue() );
    break;
  case Choices::c_ConstraintExpression:
    if ( trav_ConstraintExpression ) 
      trav_ConstraintExpression( *Me.ConstraintExpression() );
    break;
  case Choices::c_DefaultExpression:
    if ( trav_DefaultExpression ) 
      trav_DefaultExpression( *Me.DefaultExpression() );
    break;
  case Choices::c_MatchingSymbol:
    if ( trav_MatchingSymbol ) 
      trav_MatchingSymbol( *Me.MatchingSymbol() );
    break;
  case Choices::c_Complement:
    if ( trav_Complement ) 
      trav_Complement( *Me.Complement() );
    break;
  case Choices::c_Omit:
    if ( trav_Omit ) 
      trav_Omit( *Me.Omit() );
    break;
  case Choices::c_ValueList:
    if ( trav_ValueList ) 
      trav_ValueList( *Me.ValueList() );
    break;
  case Choices::c_ValRange:
    if ( trav_ValRange ) 
      trav_ValRange( *Me.ValRange() );
    break;
  case Choices::c_LowerRangeBound:
    if ( trav_LowerRangeBound ) 
      trav_LowerRangeBound( *Me.LowerRangeBound() );
    break;
  case Choices::c_UpperRangeBound:
    if ( trav_UpperRangeBound ) 
      trav_UpperRangeBound( *Me.UpperRangeBound() );
    break;
  case Choices::c_SuperSet:
    if ( trav_SuperSet ) 
      trav_SuperSet( *Me.SuperSet() );
    break;
  case Choices::c_SubSet:
    if ( trav_SubSet ) 
      trav_SubSet( *Me.SubSet() );
    break;
  case Choices::c_Permutation:
    if ( trav_Permutation ) 
      trav_Permutation( *Me.Permutation() );
    break;
  case Choices::c_ValueAttributes:
    if ( trav_ValueAttributes ) 
      trav_ValueAttributes( *Me.ValueAttributes() );
    break;
  case Choices::c_ValueLength:
    if ( trav_ValueLength ) 
      trav_ValueLength( *Me.ValueLength() );
    break;
  case Choices::c_SingleValueLength:
    if ( trav_SingleValueLength ) 
      trav_SingleValueLength( *Me.SingleValueLength() );
    break;
  case Choices::c_ValueBound:
    if ( trav_ValueBound ) 
      trav_ValueBound( *Me.ValueBound() );
    break;
  case Choices::c_RangeValueLength:
    if ( trav_RangeValueLength ) 
      trav_RangeValueLength( *Me.RangeValueLength() );
    break;
  case Choices::c_LowerValueBound:
    if ( trav_LowerValueBound ) 
      trav_LowerValueBound( *Me.LowerValueBound() );
    break;
  case Choices::c_UpperValueBound:
    if ( trav_UpperValueBound ) 
      trav_UpperValueBound( *Me.UpperValueBound() );
    break;
  case Choices::c_Expression:
    if ( trav_Expression ) 
      trav_Expression( *Me.Expression() );
    break;
  case Choices::c_SimpleExpression:
    if ( trav_SimpleExpression ) 
      trav_SimpleExpression( *Me.SimpleExpression() );
    break;
  case Choices::c_Term:
    if ( trav_Term ) 
      trav_Term( *Me.Term() );
    break;
  case Choices::c_Factor:
    if ( trav_Factor ) 
      trav_Factor( *Me.Factor() );
    break;
  case Choices::c_Primary:
    if ( trav_Primary ) 
      trav_Primary( *Me.Primary() );
    break;
  case Choices::c_ParenExpression:
    if ( trav_ParenExpression ) 
      trav_ParenExpression( *Me.ParenExpression() );
    break;
  case Choices::c_RelExpression:
    if ( trav_RelExpression ) 
      trav_RelExpression( *Me.RelExpression() );
    break;
  case Choices::c_AddExpression:
    if ( trav_AddExpression ) 
      trav_AddExpression( *Me.AddExpression() );
    break;
  case Choices::c_MultExpression:
    if ( trav_MultExpression ) 
      trav_MultExpression( *Me.MultExpression() );
    break;
  case Choices::c_UnaryExpression:
    if ( trav_UnaryExpression ) 
      trav_UnaryExpression( *Me.UnaryExpression() );
    break;
  case Choices::c_RelOp:
    if ( trav_RelOp ) 
      trav_RelOp( *Me.RelOp() );
    break;
  case Choices::c_AddOp:
    if ( trav_AddOp ) 
      trav_AddOp( *Me.AddOp() );
    break;
  case Choices::c_MultOp:
    if ( trav_MultOp ) 
      trav_MultOp( *Me.MultOp() );
    break;
  case Choices::c_UnaryOp:
    if ( trav_UnaryOp ) 
      trav_UnaryOp( *Me.UnaryOp() );
    break;
  case Choices::c_DataObjectReference:
    if ( trav_DataObjectReference ) 
      trav_DataObjectReference( *Me.DataObjectReference() );
    break;
  case Choices::c_ComponentReferenceList:
    if ( trav_ComponentReferenceList ) 
      trav_ComponentReferenceList( *Me.ComponentReferenceList() );
    break;
  case Choices::c_ComponentReference:
    if ( trav_ComponentReference ) 
      trav_ComponentReference( *Me.ComponentReference() );
    break;
  case Choices::c_RecordRef:
    if ( trav_RecordRef ) 
      trav_RecordRef( *Me.RecordRef() );
    break;
  case Choices::c_ComponentIdentifier:
    if ( trav_ComponentIdentifier ) 
      trav_ComponentIdentifier( *Me.ComponentIdentifier() );
    break;
  case Choices::c_ComponentPosition:
    if ( trav_ComponentPosition ) 
      trav_ComponentPosition( *Me.ComponentPosition() );
    break;
  case Choices::c_ArrayRef:
    if ( trav_ArrayRef ) 
      trav_ArrayRef( *Me.ArrayRef() );
    break;
  case Choices::c_ComponentNumber:
    if ( trav_ComponentNumber ) 
      trav_ComponentNumber( *Me.ComponentNumber() );
    break;
  case Choices::c_BitRef:
    if ( trav_BitRef ) 
      trav_BitRef( *Me.BitRef() );
    break;
  case Choices::c_BitIdentifier:
    if ( trav_BitIdentifier ) 
      trav_BitIdentifier( *Me.BitIdentifier() );
    break;
  case Choices::c_BitNumber:
    if ( trav_BitNumber ) 
      trav_BitNumber( *Me.BitNumber() );
    break;
  case Choices::c_OpCall:
    if ( trav_OpCall ) 
      trav_OpCall( *Me.OpCall() );
    break;
  case Choices::c_ActualParList:
    if ( trav_ActualParList ) 
      trav_ActualParList( *Me.ActualParList() );
    break;
  case Choices::c_Value:
    if ( trav_Value ) 
      trav_Value( *Me.Value() );
    break;
  case Choices::c_LiteralValue:
    if ( trav_LiteralValue ) 
      trav_LiteralValue( *Me.LiteralValue() );
    break;
  case Choices::c_BooleanValue:
    if ( trav_BooleanValue ) 
      trav_BooleanValue( *Me.BooleanValue() );
    break;
  case Choices::c_R_Value:
    if ( trav_R_Value ) 
      trav_R_Value( *Me.R_Value() );
    break;
  case Choices::c_ASN1_TypeAndLocalTypes:
    if ( trav_ASN1_TypeAndLocalTypes ) 
      trav_ASN1_TypeAndLocalTypes( *Me.ASN1_TypeAndLocalTypes() );
    break;
  case Choices::c_ASN1_Type:
    if ( trav_ASN1_Type ) 
      trav_ASN1_Type( *Me.ASN1_Type() );
    break;
  case Choices::c_TypeReference:
    if ( trav_TypeReference ) 
      trav_TypeReference( *Me.TypeReference() );
    break;
  case Choices::c_DefinedType:
    if ( trav_DefinedType ) 
      trav_DefinedType( *Me.DefinedType() );
    break;
  case Choices::c_BuiltinType:
    if ( trav_BuiltinType ) 
      trav_BuiltinType( *Me.BuiltinType() );
    break;
  case Choices::c_NamedNumberList:
    if ( trav_NamedNumberList ) 
      trav_NamedNumberList( *Me.NamedNumberList() );
    break;
  case Choices::c_NamedNumber:
    if ( trav_NamedNumber ) 
      trav_NamedNumber( *Me.NamedNumber() );
    break;
  case Choices::c_IdOrNum:
    if ( trav_IdOrNum ) 
      trav_IdOrNum( *Me.IdOrNum() );
    break;
  case Choices::c_AlternativeTypeList:
    if ( trav_AlternativeTypeList ) 
      trav_AlternativeTypeList( *Me.AlternativeTypeList() );
    break;
  case Choices::c_ElementTypeList:
    if ( trav_ElementTypeList ) 
      trav_ElementTypeList( *Me.ElementTypeList() );
    break;
  case Choices::c_ElementType:
    if ( trav_ElementType ) 
      trav_ElementType( *Me.ElementType() );
    break;
  case Choices::c_ComponentsOf:
    if ( trav_ComponentsOf ) 
      trav_ComponentsOf( *Me.ComponentsOf() );
    break;
  case Choices::c_NamedTypeAndAttributes:
    if ( trav_NamedTypeAndAttributes ) 
      trav_NamedTypeAndAttributes( *Me.NamedTypeAndAttributes() );
    break;
  case Choices::c_NamedTypeAttribute:
    if ( trav_NamedTypeAttribute ) 
      trav_NamedTypeAttribute( *Me.NamedTypeAttribute() );
    break;
  case Choices::c_NamedTypeOrSelection:
    if ( trav_NamedTypeOrSelection ) 
      trav_NamedTypeOrSelection( *Me.NamedTypeOrSelection() );
    break;
  case Choices::c_NamedType:
    if ( trav_NamedType ) 
      trav_NamedType( *Me.NamedType() );
    break;
  case Choices::c_IntegerType:
    if ( trav_IntegerType ) 
      trav_IntegerType( *Me.IntegerType() );
    break;
  case Choices::c_BitStringType:
    if ( trav_BitStringType ) 
      trav_BitStringType( *Me.BitStringType() );
    break;
  case Choices::c_SequenceType:
    if ( trav_SequenceType ) 
      trav_SequenceType( *Me.SequenceType() );
    break;
  case Choices::c_SequenceOfType:
    if ( trav_SequenceOfType ) 
      trav_SequenceOfType( *Me.SequenceOfType() );
    break;
  case Choices::c_SetType:
    if ( trav_SetType ) 
      trav_SetType( *Me.SetType() );
    break;
  case Choices::c_SetOfType:
    if ( trav_SetOfType ) 
      trav_SetOfType( *Me.SetOfType() );
    break;
  case Choices::c_ChoiceType:
    if ( trav_ChoiceType ) 
      trav_ChoiceType( *Me.ChoiceType() );
    break;
  case Choices::c_SelectionType:
    if ( trav_SelectionType ) 
      trav_SelectionType( *Me.SelectionType() );
    break;
  case Choices::c_TaggedType:
    if ( trav_TaggedType ) 
      trav_TaggedType( *Me.TaggedType() );
    break;
  case Choices::c_TagAttributes:
    if ( trav_TagAttributes ) 
      trav_TagAttributes( *Me.TagAttributes() );
    break;
  case Choices::c_AnyType:
    if ( trav_AnyType ) 
      trav_AnyType( *Me.AnyType() );
    break;
  case Choices::c_AnyDefinedBy:
    if ( trav_AnyDefinedBy ) 
      trav_AnyDefinedBy( *Me.AnyDefinedBy() );
    break;
  case Choices::c_UsefulType:
    if ( trav_UsefulType ) 
      trav_UsefulType( *Me.UsefulType() );
    break;
  case Choices::c_EnumeratedType:
    if ( trav_EnumeratedType ) 
      trav_EnumeratedType( *Me.EnumeratedType() );
    break;
  case Choices::c_Enumeration:
    if ( trav_Enumeration ) 
      trav_Enumeration( *Me.Enumeration() );
    break;
  case Choices::c_NamedBitList:
    if ( trav_NamedBitList ) 
      trav_NamedBitList( *Me.NamedBitList() );
    break;
  case Choices::c_Tag:
    if ( trav_Tag ) 
      trav_Tag( *Me.Tag() );
    break;
  case Choices::c_ClassType:
    if ( trav_ClassType ) 
      trav_ClassType( *Me.ClassType() );
    break;
  case Choices::c_ClassNumber:
    if ( trav_ClassNumber ) 
      trav_ClassNumber( *Me.ClassNumber() );
    break;
  case Choices::c_SubType:
    if ( trav_SubType ) 
      trav_SubType( *Me.SubType() );
    break;
  case Choices::c_PermittedAlphabet:
    if ( trav_PermittedAlphabet ) 
      trav_PermittedAlphabet( *Me.PermittedAlphabet() );
    break;
  case Choices::c_SizeConstraint:
    if ( trav_SizeConstraint ) 
      trav_SizeConstraint( *Me.SizeConstraint() );
    break;
  case Choices::c_ContainedSubType:
    if ( trav_ContainedSubType ) 
      trav_ContainedSubType( *Me.ContainedSubType() );
    break;
  case Choices::c_SingleValue:
    if ( trav_SingleValue ) 
      trav_SingleValue( *Me.SingleValue() );
    break;
  case Choices::c_SubTypeSpec:
    if ( trav_SubTypeSpec ) 
      trav_SubTypeSpec( *Me.SubTypeSpec() );
    break;
  case Choices::c_ParentSubType:
    if ( trav_ParentSubType ) 
      trav_ParentSubType( *Me.ParentSubType() );
    break;
  case Choices::c_ParentType:
    if ( trav_ParentType ) 
      trav_ParentType( *Me.ParentType() );
    break;
  case Choices::c_SetSubType:
    if ( trav_SetSubType ) 
      trav_SetSubType( *Me.SetSubType() );
    break;
  case Choices::c_SequenceSubType:
    if ( trav_SequenceSubType ) 
      trav_SequenceSubType( *Me.SequenceSubType() );
    break;
  case Choices::c_SubtypeValueSet:
    if ( trav_SubtypeValueSet ) 
      trav_SubtypeValueSet( *Me.SubtypeValueSet() );
    break;
  case Choices::c_ValueRange:
    if ( trav_ValueRange ) 
      trav_ValueRange( *Me.ValueRange() );
    break;
  case Choices::c_LowerEndpoint:
    if ( trav_LowerEndpoint ) 
      trav_LowerEndpoint( *Me.LowerEndpoint() );
    break;
  case Choices::c_UpperEndpoint:
    if ( trav_UpperEndpoint ) 
      trav_UpperEndpoint( *Me.UpperEndpoint() );
    break;
  case Choices::c_UpperEndValue:
    if ( trav_UpperEndValue ) 
      trav_UpperEndValue( *Me.UpperEndValue() );
    break;
  case Choices::c_LowerEndValue:
    if ( trav_LowerEndValue ) 
      trav_LowerEndValue( *Me.LowerEndValue() );
    break;
  case Choices::c_InnerTypeConstraints:
    if ( trav_InnerTypeConstraints ) 
      trav_InnerTypeConstraints( *Me.InnerTypeConstraints() );
    break;
  case Choices::c_WithComponent:
    if ( trav_WithComponent ) 
      trav_WithComponent( *Me.WithComponent() );
    break;
  case Choices::c_WithComponents:
    if ( trav_WithComponents ) 
      trav_WithComponents( *Me.WithComponents() );
    break;
  case Choices::c_FullSpecification:
    if ( trav_FullSpecification ) 
      trav_FullSpecification( *Me.FullSpecification() );
    break;
  case Choices::c_PartialSpecification:
    if ( trav_PartialSpecification ) 
      trav_PartialSpecification( *Me.PartialSpecification() );
    break;
  case Choices::c_SingleTypeConstraint:
    if ( trav_SingleTypeConstraint ) 
      trav_SingleTypeConstraint( *Me.SingleTypeConstraint() );
    break;
  case Choices::c_MultipleTypeConstraints:
    if ( trav_MultipleTypeConstraints ) 
      trav_MultipleTypeConstraints( *Me.MultipleTypeConstraints() );
    break;
  case Choices::c_TypeConstraints:
    if ( trav_TypeConstraints ) 
      trav_TypeConstraints( *Me.TypeConstraints() );
    break;
  case Choices::c_NamedConstraintList:
    if ( trav_NamedConstraintList ) 
      trav_NamedConstraintList( *Me.NamedConstraintList() );
    break;
  case Choices::c_NamedConstraint:
    if ( trav_NamedConstraint ) 
      trav_NamedConstraint( *Me.NamedConstraint() );
    break;
  case Choices::c_ValueConstraint:
    if ( trav_ValueConstraint ) 
      trav_ValueConstraint( *Me.ValueConstraint() );
    break;
  case Choices::c_PresenceConstraint:
    if ( trav_PresenceConstraint ) 
      trav_PresenceConstraint( *Me.PresenceConstraint() );
    break;
  case Choices::c_Constraint:
    if ( trav_Constraint ) 
      trav_Constraint( *Me.Constraint() );
    break;
  case Choices::c_ASN1_LocalTypes:
    if ( trav_ASN1_LocalTypes ) 
      trav_ASN1_LocalTypes( *Me.ASN1_LocalTypes() );
    break;
  case Choices::c_TypeAssignmentList:
    if ( trav_TypeAssignmentList ) 
      trav_TypeAssignmentList( *Me.TypeAssignmentList() );
    break;
  case Choices::c_TypeAssignment:
    if ( trav_TypeAssignment ) 
      trav_TypeAssignment( *Me.TypeAssignment() );
    break;
  case Choices::c_ASN1_Value:
    if ( trav_ASN1_Value ) 
      trav_ASN1_Value( *Me.ASN1_Value() );
    break;
  case Choices::c_BitStringValue:
    if ( trav_BitStringValue ) 
      trav_BitStringValue( *Me.BitStringValue() );
    break;
  case Choices::c_IdentifierList:
    if ( trav_IdentifierList ) 
      trav_IdentifierList( *Me.IdentifierList() );
    break;
  case Choices::c_SequenceValue:
    if ( trav_SequenceValue ) 
      trav_SequenceValue( *Me.SequenceValue() );
    break;
  case Choices::c_ElementValueList:
    if ( trav_ElementValueList ) 
      trav_ElementValueList( *Me.ElementValueList() );
    break;
  case Choices::c_SequenceOfValue:
    if ( trav_SequenceOfValue ) 
      trav_SequenceOfValue( *Me.SequenceOfValue() );
    break;
  case Choices::c_ASN1_ValueList:
    if ( trav_ASN1_ValueList ) 
      trav_ASN1_ValueList( *Me.ASN1_ValueList() );
    break;
  case Choices::c_SetValue:
    if ( trav_SetValue ) 
      trav_SetValue( *Me.SetValue() );
    break;
  case Choices::c_SetOfValue:
    if ( trav_SetOfValue ) 
      trav_SetOfValue( *Me.SetOfValue() );
    break;
  case Choices::c_ChoiceValue:
    if ( trav_ChoiceValue ) 
      trav_ChoiceValue( *Me.ChoiceValue() );
    break;
  case Choices::c_SelectionValue:
    if ( trav_SelectionValue ) 
      trav_SelectionValue( *Me.SelectionValue() );
    break;
  case Choices::c_AnyValue:
    if ( trav_AnyValue ) 
      trav_AnyValue( *Me.AnyValue() );
    break;
  case Choices::c_NamedValue:
    if ( trav_NamedValue ) 
      trav_NamedValue( *Me.NamedValue() );
    break;
  case Choices::c_ObjectIdentifierValue:
    if ( trav_ObjectIdentifierValue ) 
      trav_ObjectIdentifierValue( *Me.ObjectIdentifierValue() );
    break;
  case Choices::c_ObjIdComponentList:
    if ( trav_ObjIdComponentList ) 
      trav_ObjIdComponentList( *Me.ObjIdComponentList() );
    break;
  case Choices::c_ObjIdComponent:
    if ( trav_ObjIdComponent ) 
      trav_ObjIdComponent( *Me.ObjIdComponent() );
    break;
  case Choices::c_NameForm:
    if ( trav_NameForm ) 
      trav_NameForm( *Me.NameForm() );
    break;
  case Choices::c_NumberForm:
    if ( trav_NumberForm ) 
      trav_NumberForm( *Me.NumberForm() );
    break;
  case Choices::c_NameAndNumberForm:
    if ( trav_NameAndNumberForm ) 
      trav_NameAndNumberForm( *Me.NameAndNumberForm() );
    break;
  case Choices::c_RealValue:
    if ( trav_RealValue ) 
      trav_RealValue( *Me.RealValue() );
    break;
  case Choices::c_NumericRealValue:
    if ( trav_NumericRealValue ) 
      trav_NumericRealValue( *Me.NumericRealValue() );
    break;
  case Choices::c_Mantissa:
    if ( trav_Mantissa ) 
      trav_Mantissa( *Me.Mantissa() );
    break;
  case Choices::c_Base:
    if ( trav_Base ) 
      trav_Base( *Me.Base() );
    break;
  case Choices::c_Exponent:
    if ( trav_Exponent ) 
      trav_Exponent( *Me.Exponent() );
    break;
  case Choices::c_SpecialRealValue:
    if ( trav_SpecialRealValue ) 
      trav_SpecialRealValue( *Me.SpecialRealValue() );
    break;
  case Choices::c_DefinedValue:
    if ( trav_DefinedValue ) 
      trav_DefinedValue( *Me.DefinedValue() );
    break;
  case Choices::c_SignedNumber:
    if ( trav_SignedNumber ) 
      trav_SignedNumber( *Me.SignedNumber() );
    break;
  case Choices::c_DefaultValue:
    if ( trav_DefaultValue ) 
      trav_DefaultValue( *Me.DefaultValue() );
    break;
  case Choices::c_Identifier:
    if ( trav_Identifier ) 
      trav_Identifier( *Me.Identifier() );
    break;
  case Choices::c_FormalParList:
    if ( trav_FormalParList ) 
      trav_FormalParList( *Me.FormalParList() );
    break;
  case Choices::c_FormalParAndType:
    if ( trav_FormalParAndType ) 
      trav_FormalParAndType( *Me.FormalParAndType() );
    break;
  case Choices::c_FormalParIdList:
    if ( trav_FormalParIdList ) 
      trav_FormalParIdList( *Me.FormalParIdList() );
    break;
  case Choices::c_FormalParType:
    if ( trav_FormalParType ) 
      trav_FormalParType( *Me.FormalParType() );
    break;
  case Choices::c_TestGroupReference:
    if ( trav_TestGroupReference ) 
      trav_TestGroupReference( *Me.TestGroupReference() );
    break;
  case Choices::c_TestStepGroupReference:
    if ( trav_TestStepGroupReference ) 
      trav_TestStepGroupReference( *Me.TestStepGroupReference() );
    break;
  case Choices::c_DefaultGroupReference:
    if ( trav_DefaultGroupReference ) 
      trav_DefaultGroupReference( *Me.DefaultGroupReference() );
    break;
  case Choices::c_Ostring:
    if ( trav_Ostring ) 
      trav_Ostring( *Me.Ostring() );
    break;
  case Choices::c_Cstring:
    if ( trav_Cstring ) 
      trav_Cstring( *Me.Cstring() );
    break;
  case Choices::c_Bstring:
    if ( trav_Bstring ) 
      trav_Bstring( *Me.Bstring() );
    break;
  case Choices::c_Hstring:
    if ( trav_Hstring ) 
      trav_Hstring( *Me.Hstring() );
    break;
  case Choices::c_INTEGER:
    if ( trav_INTEGER ) 
      trav_INTEGER( *Me.INTEGER() );
    break;
  case Choices::c_BOOLEAN:
    if ( trav_BOOLEAN ) 
      trav_BOOLEAN( *Me.BOOLEAN() );
    break;
  case Choices::c_BITSTRING:
    if ( trav_BITSTRING ) 
      trav_BITSTRING( *Me.BITSTRING() );
    break;
  case Choices::c_HEXSTRING:
    if ( trav_HEXSTRING ) 
      trav_HEXSTRING( *Me.HEXSTRING() );
    break;
  case Choices::c_OCTETSTRING:
    if ( trav_OCTETSTRING ) 
      trav_OCTETSTRING( *Me.OCTETSTRING() );
    break;
  case Choices::c_BooleanType:
    if ( trav_BooleanType ) 
      trav_BooleanType( *Me.BooleanType() );
    break;
  case Choices::c_OctetStringType:
    if ( trav_OctetStringType ) 
      trav_OctetStringType( *Me.OctetStringType() );
    break;
  case Choices::c_ObjectIdentifierType:
    if ( trav_ObjectIdentifierType ) 
      trav_ObjectIdentifierType( *Me.ObjectIdentifierType() );
    break;
  case Choices::c_NumericString:
    if ( trav_NumericString ) 
      trav_NumericString( *Me.NumericString() );
    break;
  case Choices::c_PrintableString:
    if ( trav_PrintableString ) 
      trav_PrintableString( *Me.PrintableString() );
    break;
  case Choices::c_TeletexString:
    if ( trav_TeletexString ) 
      trav_TeletexString( *Me.TeletexString() );
    break;
  case Choices::c_VideotexString:
    if ( trav_VideotexString ) 
      trav_VideotexString( *Me.VideotexString() );
    break;
  case Choices::c_VisibleString:
    if ( trav_VisibleString ) 
      trav_VisibleString( *Me.VisibleString() );
    break;
  case Choices::c_IA5String:
    if ( trav_IA5String ) 
      trav_IA5String( *Me.IA5String() );
    break;
  case Choices::c_GraphicString:
    if ( trav_GraphicString ) 
      trav_GraphicString( *Me.GraphicString() );
    break;
  case Choices::c_GeneralString:
    if ( trav_GeneralString ) 
      trav_GeneralString( *Me.GeneralString() );
    break;
  case Choices::c_T61String:
    if ( trav_T61String ) 
      trav_T61String( *Me.T61String() );
    break;
  case Choices::c_ISO646String:
    if ( trav_ISO646String ) 
      trav_ISO646String( *Me.ISO646String() );
    break;
  case Choices::c_GeneralizedTime:
    if ( trav_GeneralizedTime ) 
      trav_GeneralizedTime( *Me.GeneralizedTime() );
    break;
  case Choices::c_UTCTime:
    if ( trav_UTCTime ) 
      trav_UTCTime( *Me.UTCTime() );
    break;
  case Choices::c_EXTERNAL:
    if ( trav_EXTERNAL ) 
      trav_EXTERNAL( *Me.EXTERNAL() );
    break;
  case Choices::c_ObjectDescriptor:
    if ( trav_ObjectDescriptor ) 
      trav_ObjectDescriptor( *Me.ObjectDescriptor() );
    break;
  case Choices::c_RealType:
    if ( trav_RealType ) 
      trav_RealType( *Me.RealType() );
    break;
  case Choices::c_UNIVERSAL:
    if ( trav_UNIVERSAL ) 
      trav_UNIVERSAL( *Me.UNIVERSAL() );
    break;
  case Choices::c_APPLICATION:
    if ( trav_APPLICATION ) 
      trav_APPLICATION( *Me.APPLICATION() );
    break;
  case Choices::c_PRIVATE_:
    if ( trav_PRIVATE_ ) 
      trav_PRIVATE_( *Me.PRIVATE_() );
    break;
  case Choices::c_ANY:
    if ( trav_ANY ) 
      trav_ANY( *Me.ANY() );
    break;
  case Choices::c_Max:
    if ( trav_Max ) 
      trav_Max( *Me.Max() );
    break;
  case Choices::c_Min:
    if ( trav_Min ) 
      trav_Min( *Me.Min() );
    break;
  case Choices::c_INCLUSIVE:
    if ( trav_INCLUSIVE ) 
      trav_INCLUSIVE( *Me.INCLUSIVE() );
    break;
  case Choices::c_PRESENT:
    if ( trav_PRESENT ) 
      trav_PRESENT( *Me.PRESENT() );
    break;
  case Choices::c_IF_PRESENT:
    if ( trav_IF_PRESENT ) 
      trav_IF_PRESENT( *Me.IF_PRESENT() );
    break;
  case Choices::c_ABSENT:
    if ( trav_ABSENT ) 
      trav_ABSENT( *Me.ABSENT() );
    break;
  case Choices::c_OPTIONAL:
    if ( trav_OPTIONAL ) 
      trav_OPTIONAL( *Me.OPTIONAL() );
    break;
  case Choices::c_NullType:
    if ( trav_NullType ) 
      trav_NullType( *Me.NullType() );
    break;
  case Choices::c_NullValue:
    if ( trav_NullValue ) 
      trav_NullValue( *Me.NullValue() );
    break;
  case Choices::c_Plus_INFINITY:
    if ( trav_Plus_INFINITY ) 
      trav_Plus_INFINITY( *Me.Plus_INFINITY() );
    break;
  case Choices::c_MinusINFINITY:
    if ( trav_MinusINFINITY ) 
      trav_MinusINFINITY( *Me.MinusINFINITY() );
    break;
  case Choices::c_Minus_INFINITY:
    if ( trav_Minus_INFINITY ) 
      trav_Minus_INFINITY( *Me.Minus_INFINITY() );
    break;
  case Choices::c_INFINITY:
    if ( trav_INFINITY ) 
      trav_INFINITY( *Me.INFINITY() );
    break;
  case Choices::c_PDU:
    if ( trav_PDU ) 
      trav_PDU( *Me.PDU() );
    break;
  case Choices::c_CP:
    if ( trav_CP ) 
      trav_CP( *Me.CP() );
    break;
  case Choices::c_TIMER:
    if ( trav_TIMER ) 
      trav_TIMER( *Me.TIMER() );
    break;
  case Choices::c_UT:
    if ( trav_UT ) 
      trav_UT( *Me.UT() );
    break;
  case Choices::c_LT:
    if ( trav_LT ) 
      trav_LT( *Me.LT() );
    break;
  case Choices::c_MTC:
    if ( trav_MTC ) 
      trav_MTC( *Me.MTC() );
    break;
  case Choices::c_PTC:
    if ( trav_PTC ) 
      trav_PTC( *Me.PTC() );
    break;
  case Choices::c_PicoSeconds:
    if ( trav_PicoSeconds ) 
      trav_PicoSeconds( *Me.PicoSeconds() );
    break;
  case Choices::c_NanoSeconds:
    if ( trav_NanoSeconds ) 
      trav_NanoSeconds( *Me.NanoSeconds() );
    break;
  case Choices::c_MicroSeconds:
    if ( trav_MicroSeconds ) 
      trav_MicroSeconds( *Me.MicroSeconds() );
    break;
  case Choices::c_MilliSeconds:
    if ( trav_MilliSeconds ) 
      trav_MilliSeconds( *Me.MilliSeconds() );
    break;
  case Choices::c_Seconds:
    if ( trav_Seconds ) 
      trav_Seconds( *Me.Seconds() );
    break;
  case Choices::c_Minutes:
    if ( trav_Minutes ) 
      trav_Minutes( *Me.Minutes() );
    break;
  case Choices::c_AIMPLICIT:
    if ( trav_AIMPLICIT ) 
      trav_AIMPLICIT( *Me.AIMPLICIT() );
    break;
  case Choices::c_AEXPLICIT:
    if ( trav_AEXPLICIT ) 
      trav_AEXPLICIT( *Me.AEXPLICIT() );
    break;
  case Choices::c_RETURN_:
    if ( trav_RETURN_ ) 
      trav_RETURN_( *Me.RETURN_() );
    break;
  case Choices::c_PASS:
    if ( trav_PASS ) 
      trav_PASS( *Me.PASS() );
    break;
  case Choices::c_PreliminaryPASS:
    if ( trav_PreliminaryPASS ) 
      trav_PreliminaryPASS( *Me.PreliminaryPASS() );
    break;
  case Choices::c_FAIL:
    if ( trav_FAIL ) 
      trav_FAIL( *Me.FAIL() );
    break;
  case Choices::c_PreliminaryFAIL:
    if ( trav_PreliminaryFAIL ) 
      trav_PreliminaryFAIL( *Me.PreliminaryFAIL() );
    break;
  case Choices::c_INCONC:
    if ( trav_INCONC ) 
      trav_INCONC( *Me.INCONC() );
    break;
  case Choices::c_PreliminaryINCONC:
    if ( trav_PreliminaryINCONC ) 
      trav_PreliminaryINCONC( *Me.PreliminaryINCONC() );
    break;
  case Choices::c_R:
    if ( trav_R ) 
      trav_R( *Me.R() );
    break;
  case Choices::c_NONE:
    if ( trav_NONE ) 
      trav_NONE( *Me.NONE() );
    break;
  case Choices::c_R_TYPE:
    if ( trav_R_TYPE ) 
      trav_R_TYPE( *Me.R_TYPE() );
    break;
  case Choices::c_OMIT:
    if ( trav_OMIT ) 
      trav_OMIT( *Me.OMIT() );
    break;
  case Choices::c_ANYValue:
    if ( trav_ANYValue ) 
      trav_ANYValue( *Me.ANYValue() );
    break;
  case Choices::c_AnyOrOmit:
    if ( trav_AnyOrOmit ) 
      trav_AnyOrOmit( *Me.AnyOrOmit() );
    break;
  case Choices::c_Equal:
    if ( trav_Equal ) 
      trav_Equal( *Me.Equal() );
    break;
  case Choices::c_Less:
    if ( trav_Less ) 
      trav_Less( *Me.Less() );
    break;
  case Choices::c_Greater:
    if ( trav_Greater ) 
      trav_Greater( *Me.Greater() );
    break;
  case Choices::c_NotEqual:
    if ( trav_NotEqual ) 
      trav_NotEqual( *Me.NotEqual() );
    break;
  case Choices::c_GreaterOrEqual:
    if ( trav_GreaterOrEqual ) 
      trav_GreaterOrEqual( *Me.GreaterOrEqual() );
    break;
  case Choices::c_LessOrEqual:
    if ( trav_LessOrEqual ) 
      trav_LessOrEqual( *Me.LessOrEqual() );
    break;
  case Choices::c_Two:
    if ( trav_Two ) 
      trav_Two( *Me.Two() );
    break;
  case Choices::c_Ten:
    if ( trav_Ten ) 
      trav_Ten( *Me.Ten() );
    break;
  case Choices::c_Mult:
    if ( trav_Mult ) 
      trav_Mult( *Me.Mult() );
    break;
  case Choices::c_Div:
    if ( trav_Div ) 
      trav_Div( *Me.Div() );
    break;
  case Choices::c_Mod:
    if ( trav_Mod ) 
      trav_Mod( *Me.Mod() );
    break;
  case Choices::c_And:
    if ( trav_And ) 
      trav_And( *Me.And() );
    break;
  case Choices::c_Or:
    if ( trav_Or ) 
      trav_Or( *Me.Or() );
    break;
  case Choices::c_Minus:
    if ( trav_Minus ) 
      trav_Minus( *Me.Minus() );
    break;
  case Choices::c_Not:
    if ( trav_Not ) 
      trav_Not( *Me.Not() );
    break;
  case Choices::c_Plus:
    if ( trav_Plus ) 
      trav_Plus( *Me.Plus() );
    break;
  case Choices::c_ATrue:
    if ( trav_ATrue ) 
      trav_ATrue( *Me.ATrue() );
    break;
  case Choices::c_AFalse:
    if ( trav_AFalse ) 
      trav_AFalse( *Me.AFalse() );
    break;
  case Choices::c_MacroSymbol:
    if ( trav_MacroSymbol ) 
      trav_MacroSymbol( *Me.MacroSymbol() );
    break;
  case Choices::c_last_choice:
  default:     trav_error("Bad Access Node for trav"); break;
  }

}