                                                                                                              
  CONST                                                                                                       
    duc$de_7154_adapter = 0,                                                                                  
    duc$de_isd_adapter = 1,                                                                                   
    duc$de_7155_adapter = 2,                                                                                  
    duc$de_ismt_adapter = 3,                                                                                  
    duc$de_895_adapter = 4;                                                                                   
                                                                                                              
  CONST                                                                                                       
    duc$de_control_store_size = 08000(16),                                                                    
    duc$de_element_byte_number = 5,                                                                           
    duc$de_max_cio_pp_memories = 25,                                                                          
    duc$de_max_definition_length = 60,                                                                        
    duc$de_max_other_record_length = 500000,                                                                  
    duc$de_max_other_records = 0ffff(16),                                                                     
    duc$de_max_page_size = 65536,                                                                             
    duc$de_max_pp_memories = 25,                                                                              
    duc$de_max_register_length = 8,                                                                           
    duc$de_max_register_number = 0fff(16),                                                                    
    duc$de_max_register_parts = 256,                                                                          
    duc$de_maximum_bc_size = 35840,                                                                           
    duc$de_maximum_channels = 33,                                                                             
    duc$de_maximum_ious = 1,                                                                                  
    duc$de_maximum_mci_port = 6,                                                                              
    duc$de_maximum_processors = 3,                                                                            
    duc$de_maximum_rma = 0ffffffff(16),                                                                       
    duc$de_model_byte_number = 6,                                                                             
    duc$de_number_of_iou_mrs_dumped = 256,                                                                    
    duc$de_number_of_mem_mrs_dumped = 256,                                                                    
    duc$de_number_of_pro_mrs_dumped = 500,                                                                    
    duc$de_serial_num_byte_number = 7;                                                                        
                                                                                                              
{ The DUT$DUMP_ENVIRONMENT is the first part of the restart file. It exists in the following ways:            
{                                                                                                             
{ Revision_Level 1030 (= 406(16))                                                                             
{   This revision level supports one single restart file, only. We support it to be able to analyze           
{   older restart files where the dump tape is lost.                                                          
{                                                                                                             
{   The dump environment contains all fields except the restart_identifier, which sits on top of other        
{   records.                                                                                                  
{                                                                                                             
{ Revision_Level 263936 (= 40700(16))                                                                         
{   This revision level supports one restart file and two restart files for full dumps to allow               
{   analyzing full dumps of a 2 GByte memory system.                                                          
{   The sub_revision_level (last Byte of the revision level) indicates the file type:                         
{                                                                                                             
{   01 (= 40701(16)): File 1/1 - contains all records.                                                        
{     The dump environment contains all fields.                                                               
{     The field Restart_Identifier.File_Count is 1.                                                           
{                                                                                                             
{   01 (= 40701(16)): File 1/2: contains all but the CM records.                                              
{     The dump environment contains all fields (including the dut$de_central_memory field, but                
{     the data  of it is in file 2.                                                                           
{     The field Restart_Identifier.File_Count is 2.                                                           
{     The field Restart_Identifier.Identifier of file 1 & 2 must match for the same dump.                     
{                                                                                                             
{   02 (= 40702(16)): File 2/2: contains the CM records only.                                                 
{     The dump environment contains only few fields to keep the extra used amount of space as small           
{     as possible - see dut$dump_environment_40702                                                            
{                                                                                                             
                                                                                                              
  TYPE                                                                                                        
    dut$dump_environment = RECORD                                                                             
      revision_level: integer,                                                                                
      dump_identifier: dut$de_dump_identifier,                                                                
      central_memory: dut$de_central_memory,                                                                  
      critical_memory: dut$de_critical_memory,                                                                
      active_exchange: dut$de_exchange_packages,                                                              
      jps_exchange: dut$de_exchange_packages,                                                                 
      mps_exchange: dut$de_exchange_packages,                                                                 
      iou_maintenance_registers: ARRAY [0 .. duc$de_maximum_ious] OF dut$de_iou_maintenance_regs,             
      mem_maintenance_registers: dut$de_mem_maintenance_regs,                                                 
      pro_maintenance_registers: ARRAY [0 .. duc$de_maximum_processors] OF dut$de_pro_maintenance_regs,       
      iou_memory: ARRAY [0 .. duc$de_maximum_ious] OF dut$de_iou_memory,                                      
      register_file: ARRAY [0 .. duc$de_maximum_processors] OF dut$de_register_file,                          
      control_store: dut$de_control_store,                                                                    
      buffer_controlware: dut$de_buffer_controlware,                                                          
      other_records: dut$de_other_records,                                                                    
                                                                                                              
{ The following definition exist only for revision_levels after 1030 (= 406(16))                              
      restart_identifier: dut$de_restart_identifier,                                                          
    RECEND;                                                                                                   
                                                                                                              
  TYPE                                                                                                        
    dut$dump_environment_40702 = RECORD                                                                       
      revision_level: integer,                                                                                
      restart_identifier: dut$de_restart_identifier,                                                          
    RECEND;                                                                                                   
                                                                                                              
  TYPE                                                                                                        
    dut$de_buffer_controlware = RECORD                                                                        
      available: boolean,                                                                                     
      number_of_entries: 0 .. 0ff(16),                                                                        
      first_bc_entry: amt$file_byte_address,                                                                  
    RECEND,                                                                                                   
                                                                                                              
    dut$de_buffer_controlware_entry = RECORD                                                                  
      channel_number: 0 .. duc$de_maximum_channels,                                                           
      channel_type: dut$de_channel_type,                                                                      
      words: 0 .. duc$de_maximum_bc_size,                                                                     
      first_byte: amt$file_byte_address,                                                                      
      next_bc_entry: amt$file_byte_address,                                                                   
    RECEND,                                                                                                   
                                                                                                              
    dut$de_buffer_controlware_word = 0 .. 0ffff(16),                                                          
                                                                                                              
    dut$de_central_memory = RECORD                                                                            
      available: boolean,                                                                                     
      first_byte: amt$file_byte_address,                                                                      
      last_byte: amt$file_byte_address,                                                                       
      bias: amt$file_byte_address,                                                                            
    RECEND,                                                                                                   
                                                                                                              
    dut$de_channel_type = duc$de_7154_adapter .. duc$de_ismt_adapter,                                         
                                                                                                              
    dut$de_control_store = RECORD                                                                             
      main: ARRAY [0 .. duc$de_maximum_processors] OF dut$de_control_store_entry,                             
      shadow: ARRAY [0 .. duc$de_maximum_processors] OF dut$de_control_store_entry,                           
    RECEND,                                                                                                   
                                                                                                              
    dut$de_control_store_entry = RECORD                                                                       
      available: boolean,                                                                                     
      size: 0 .. duc$de_control_store_size,                                                                   
      first_byte: amt$file_byte_address,                                                                      
    RECEND,                                                                                                   
                                                                                                              
    dut$de_control_store_word = RECORD                                                                        
      upper: integer,                                                                                         
      lower: integer,                                                                                         
    RECEND,                                                                                                   
                                                                                                              
    dut$de_critical_memory = RECORD                                                                           
      available: boolean,                                                                                     
      page_size: 0 .. duc$de_max_page_size,                                                                   
      page_table_size: 0 .. 0ffff(16),                                                                        
      cpt_start: amt$file_byte_address,                                                                       
      cpt_end: amt$file_byte_address,                                                                         
      critical_page_table_offset: amt$file_byte_address,                                                      
      first_entry: amt$file_byte_address,                                                                     
      last_entry: amt$file_byte_address,                                                                      
      current_entry: amt$file_byte_address,                                                                   
      first_page: amt$file_byte_address,                                                                      
      current_page_offset: amt$file_byte_address,                                                             
      first_rma_available: 0 .. 0ffffffff(16),                                                                
      last_rma_available: 0 .. 0ffffffff(16),                                                                 
      last_ccm_other_record: amt$file_byte_address,                                                           
      total_ccm_size: integer,                                                                                
      multiple_ccm_exists: boolean,                                                                           
    RECEND,                                                                                                   
                                                                                                              
    dut$de_critical_page_entry = RECORD                                                                       
      available: boolean,                                                                                     
      page_offset: amt$file_byte_address,                                                                     
    RECEND,                                                                                                   
                                                                                                              
    dut$de_dump_identifier = RECORD                                                                           
      available: boolean,                                                                                     
      edd_revision_level: string (3),                                                                         
      size: 0 .. 0ffff(16),                                                                                   
      first_byte: amt$file_byte_address,                                                                      
    RECEND,                                                                                                   
                                                                                                              
    dut$de_element = (duc$de_iou, duc$de_cpu, duc$de_memory),                                                 
                                                                                                              
    dut$de_exchange_data = RECORD                                                                             
      available: boolean,                                                                                     
      value: dut$exchange_package,                                                                            
      radial_mci: 0 .. duc$de_maximum_mci_port,                                                               
    RECEND,                                                                                                   
                                                                                                              
    dut$de_exchange_packages = ARRAY [0 .. duc$de_maximum_processors] OF dut$de_exchange_data,                
                                                                                                              
    dut$de_iou_maintenance_regs = RECORD                                                                      
      available: boolean,                                                                                     
      registers: ARRAY [1 .. duc$de_number_of_iou_mrs_dumped] OF dut$de_maintenance_register,                 
    RECEND,                                                                                                   
                                                                                                              
    dut$de_iou_memory = RECORD                                                                                
      nio_pp: ARRAY [0 .. duc$de_max_pp_memories] OF dut$de_pp_memory,                                        
      cio_pp: ARRAY [0 .. duc$de_max_cio_pp_memories] OF dut$de_pp_memory,                                    
    RECEND,                                                                                                   
                                                                                                              
    dut$de_maintenance_register = RECORD                                                                      
      available: boolean,                                                                                     
      number: 0 .. duc$de_max_register_number,                                                                
      part: 1 .. duc$de_max_register_parts,                                                                   
      length: 0 .. duc$de_max_register_length,                                                                
      value: ARRAY [1 .. duc$de_max_register_length] OF 0 .. 0ff(16),                                         
    RECEND,                                                                                                   
                                                                                                              
    dut$de_mem_maintenance_regs = RECORD                                                                      
      available: boolean,                                                                                     
      registers: ARRAY [1 .. duc$de_number_of_mem_mrs_dumped] OF dut$de_maintenance_register,                 
    RECEND,                                                                                                   
                                                                                                              
    dut$de_other_record_entry = RECORD                                                                        
      name: dut$de_other_record_name,                                                                         
      index: 0 .. duc$de_max_other_records,                                                                   
      record_type: dut$de_other_record_type,                                                                  
      size: 0 .. 0ffffffff(16),                                                                               
      header_line_count: 0 .. 3ffff(16),                                                                      
      report_record_length: 0 .. 3ffff(16),                                                                   
      first_byte: amt$file_byte_address,                                                                      
      next_record: amt$file_byte_address,                                                                     
    RECEND,                                                                                                   
                                                                                                              
    dut$de_other_record_name = string (3),                                                                    
                                                                                                              
    dut$de_other_records = RECORD                                                                             
      available: boolean,                                                                                     
      number_of_records: 0 .. duc$de_max_other_records,                                                       
      first_record: amt$file_byte_address,                                                                    
    RECEND,                                                                                                   
                                                                                                              
    dut$de_other_record_type = (duc$de_ort_detail, duc$de_ort_dump, duc$de_ort_report),                       
                                                                                                              
    dut$de_pp_memory = RECORD                                                                                 
      available: boolean,                                                                                     
      r_register: 0 .. 3fffff(16),                                                                            
      size: 0 .. 0ffffffff(16),                                                                               
      first_byte: amt$file_byte_address,                                                                      
    RECEND,                                                                                                   
                                                                                                              
    dut$de_pro_maintenance_regs = RECORD                                                                      
      available: boolean,                                                                                     
      registers: ARRAY [1 .. duc$de_number_of_pro_mrs_dumped] OF dut$de_maintenance_register,                 
      radial_mci: 0 .. duc$de_maximum_mci_port,                                                               
    RECEND,                                                                                                   
                                                                                                              
    dut$de_register_file = RECORD                                                                             
      available: boolean,                                                                                     
      number_of_registers: 0 .. (duc$de_max_register_number DIV 8),                                           
      register: ARRAY [0 .. (duc$de_max_register_number DIV 8)] OF dut$de_register_file_entry,                
    RECEND,                                                                                                   
                                                                                                              
    dut$de_register_file_entry = RECORD                                                                       
      available: boolean,                                                                                     
      value: integer,                                                                                         
    RECEND,                                                                                                   
                                                                                                              
    dut$de_restart_identifier = RECORD                                                                        
      file_number: integer,                                                                                   
      file_count: integer,                                                                                    
      identifier: integer,                                                                                    
    RECEND;                                                                                                   
                                                                                                              
*copyc dut$exchange_package                                                                                   
*copyc amt$file_byte_address                                                                                  
*copyc amt$file_identifier                                                                                    
