                                                                                                              
  TYPE                                                                                                        
    dut$execution_environment = RECORD                                                                        
      restart_file_allows_modify: boolean,                                                                    
      processing_options: dut$ee_processing_options,                                                          
      output_file_opened: boolean,                                                                            
      output_file: dut$ee_output_file_record,                                                                 
      restart_files: dut$ee_restart_files_record,                                                             
      data_file_p: ^dut$ee_restart_file_record,                                                               
      memory_file_p: ^dut$ee_restart_file_record,                                                             
      processor_registers: ARRAY [0 .. duc$de_maximum_processors] OF dut$ee_processor_registers,              
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_a_register = RECORD                                                                                
      two_bytes: 0 .. 0ffff(16),                                                                              
      pva: ost$pva,                                                                                           
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_address_parameter = RECORD                                                                         
      CASE 1 .. 4 OF                                                                                          
      = 1 =                                                                                                   
        pva_fill: 0 .. 0ffff(16),                                                                             
        pva_part: ost$pva,                                                                                    
      = 2 =                                                                                                   
        sva_fill: 0 .. 0fff(16),                                                                              
        sva_part: dut$ee_system_virtual_address,                                                              
      = 3 =                                                                                                   
        rma_part: integer,                                                                                    
      = 4 =                                                                                                   
        quarter_part_1: 0 .. 0ffff(16),                                                                       
        quarter_part_2: 0 .. 0ffff(16),                                                                       
        quarter_part_3: 0 .. 0ffff(16),                                                                       
        quarter_part_4: 0 .. 0ffff(16),                                                                       
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_asid = PACKED RECORD                                                                               
      CASE 0 .. 2 OF                                                                                          
      = 0 =                                                                                                   
        asid: SET OF 0 .. 15,                                                                                 
      = 1 =                                                                                                   
        value: 0 .. 0ffff(16),                                                                                
      = 2 =                                                                                                   
        asid_hash: SET OF 0 .. 5,                                                                             
        filler: 0 .. 3ff(16),                                                                                 
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_cpu1_installed_commands = (duc$ee_cic_disd, duc$ee_cic_dismr),                                     
                                                                                                              
    dut$ee_output_file_record = RECORD                                                                        
      display_control: clt$display_control,                                                                   
      name: string (fsc$max_path_size),                                                                       
      size: 0 .. fsc$max_path_size,                                                                           
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_page_number = PACKED RECORD                                                                        
      CASE 0 .. 3 OF                                                                                          
      = 0 =                                                                                                   
        fill1: 0 .. 3f(16),                                                                                   
        low_order_16_bits: SET OF 0 .. 15,                                                                    
      = 1 =                                                                                                   
        fill2: 0 .. 7fff(16),                                                                                 
        psm: dut$ee_page_size_mask,                                                                           
      = 2 =                                                                                                   
        value: 0 .. 3fffff(16),                                                                               
      = 3 =                                                                                                   
        filler: 0 .. 0ffff(16),                                                                               
        low_order_6_bits: SET OF 0 .. 5,                                                                      
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_page_offset = PACKED RECORD                                                                        
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        value: 0 .. 0ffff(16),                                                                                
      = FALSE =                                                                                               
        psm: dut$ee_page_size_mask,                                                                           
        rightmost_9_bits: 0 .. 1ff(16),                                                                       
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_page_size_mask = SET OF 0 .. 6,                                                                    
                                                                                                              
    dut$ee_page_table_address = PACKED RECORD                                                                 
      leftmost_6_bits: 0 .. 03f(16),                                                                          
      ptl: dut$ee_page_table_length,                                                                          
      zeros: 0 .. 0fff(16),                                                                                   
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_page_table_length = SET OF 0 .. 13,                                                                
                                                                                                              
    dut$ee_processing_options = (duc$ee_po_all_memory, duc$ee_po_critical_memory, duc$ee_po_no_memory),       
                                                                                                              
    dut$ee_processor_mr_jps = PACKED RECORD                                                                   
      fill1: 0 .. 0ffffffff(16),                                                                              
      value: ost$real_memory_address,                                                                         
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_mr_mps = PACKED RECORD                                                                   
      fill1: 0 .. 0ffffffff(16),                                                                              
      value: ost$real_memory_address,                                                                         
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_mr_psm = PACKED RECORD                                                                   
      fill1: 0 .. 0ffffffffffff(16),                                                                          
      fill2: 0 .. 0ff(16),                                                                                    
      fill3: boolean,                                                                                         
      value: dut$ee_page_size_mask,                                                                           
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_mr_pta = PACKED RECORD                                                                   
      fill1: 0 .. 0ffffffff(16),                                                                              
      value: dut$ee_page_table_address,                                                                       
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_mr_ptl = PACKED RECORD                                                                   
      fill1: 0 .. 0ffffffffffff(16),                                                                          
      fill2: 0 .. 3,                                                                                          
      value: dut$ee_page_table_length,                                                                        
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_mr_ss = PACKED RECORD                                                                    
      fill: 0 .. 0ffffffffffff(16),                                                                           
      value: dut$ee_processor_status_summary,                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_processor_registers = RECORD                                                                       
      available: boolean,                                                                                     
      status_summary: dut$ee_processor_status_summary,                                                        
      job_process_state: ost$real_memory_address,                                                             
      monitor_process_state: ost$real_memory_address,                                                         
      page_size_mask: dut$ee_page_size_mask,                                                                  
      page_table_address: dut$ee_page_table_address,                                                          
      page_table_length: dut$ee_page_table_length,                                                            
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_pro_cy2000_ss_reg_bits = (duc$ee_cy_not_used_48, duc$ee_cy_not_used_49, duc$ee_cy_not_used_50,     
          duc$ee_cy_not_used_51, duc$ee_cy_not_used_52, duc$ee_cy_monitor_mode, duc$ee_cy_clock_halted_1,     
          duc$ee_cy_clock_halted_2, duc$ee_cy_pmf_halted, duc$ee_cy_capture_buffer_halted,                    
          duc$ee_cy_microcode_halted, duc$ee_cy_not_used_59, duc$ee_cy_mac_halt, duc$ee_cy_due,               
          duc$ee_cy_subsystem_fault_bit, duc$ee_cy_retryable_error),                                          
                                                                                                              
    dut$ee_pro_general_ss_reg_bits = (duc$ee_gen_not_used_48, duc$ee_gen_not_used_49, duc$ee_gen_not_used_50, 
          duc$ee_gen_not_used_51, duc$ee_gen_not_used_52, duc$ee_gen_not_used_53, duc$ee_gen_not_used_54,     
          duc$ee_gen_not_used_55, duc$ee_gen_not_used_56, duc$ee_gen_not_used_57, duc$ee_gen_180_monitor_mode,
          duc$ee_gen_short_warning, duc$ee_gen_processor_halt, duc$ee_gen_uncorrectable_error,                
          duc$ee_gen_corrected_error, duc$ee_gen_long_warning),                                               
                                                                                                              
    dut$ee_pro_cy2000_ss_set = SET OF dut$ee_pro_cy2000_ss_reg_bits,                                          
                                                                                                              
    dut$ee_pro_general_ss_set = SET OF dut$ee_pro_general_ss_reg_bits,                                        
                                                                                                              
    dut$ee_processor_status_summary = RECORD                                                                  
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        general: dut$ee_pro_general_ss_set,                                                                   
      = FALSE =                                                                                               
        cy2000: dut$ee_pro_cy2000_ss_set,                                                                     
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_psm_value = PACKED RECORD                                                                          
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        psm: dut$ee_page_size_mask,                                                                           
      = FALSE =                                                                                               
        value: 0 .. 7f(16),                                                                                   
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_pta_value = PACKED RECORD                                                                          
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        pta: dut$ee_page_table_address,                                                                       
      = FALSE =                                                                                               
        value: 0 .. 0ffffffff(16),                                                                            
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_ptl_value = PACKED RECORD                                                                          
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        ptl: dut$ee_page_table_length,                                                                        
      = FALSE =                                                                                               
        value: 0 .. 03fff(16),                                                                                
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_restart_files_record = ARRAY [1..duc$maximum_restart_files] OF dut$ee_restart_file_record,         
                                                                                                              
    dut$ee_restart_file_record = RECORD                                                                       
      opened: boolean,                                                                                        
      file_identifier: amt$file_identifier,                                                                   
      segment_pointer: amt$segment_pointer                                                                    
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_system_virtual_address = PACKED RECORD                                                             
      asid: dut$ee_asid,                                                                                      
      CASE 0 .. 3 OF                                                                                          
      = 0 =                                                                                                   
        offset: ost$segment_offset,                                                                           
      = 1 =                                                                                                   
        fill1: boolean,                                                                                       
        pn: dut$ee_page_number,                                                                               
      = 2 =                                                                                                   
        fill2: 0 .. 0ffff(16),                                                                                
        po: dut$ee_page_offset,                                                                               
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_x_register = RECORD                                                                                
      CASE boolean OF                                                                                         
      = TRUE =                                                                                                
        part: ARRAY [0 .. 3] OF 0 .. 0ffff(16),                                                               
      = FALSE =                                                                                               
        int: integer,                                                                                         
      CASEND,                                                                                                 
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_xp = RECORD                                                                                        
      p_register: dut$ee_a_register,                                                                          
      data: dut$ee_xp_data,                                                                                   
      tos_registers: ARRAY [1 .. 0f(16)] OF dut$ee_a_register,                                                
    RECEND,                                                                                                   
                                                                                                              
    dut$ee_xp_data = RECORD                                                                                   
      a_regs: ARRAY [ost$register_number] OF dut$ee_a_register,                                               
      x_regs: ARRAY [ost$register_number] OF dut$ee_x_register,                                               
      mdw: dut$ee_x_register,                                                                                 
      sta1: dut$ee_a_register,                                                                                
      sta2: dut$ee_a_register,                                                                                
      debug_word: dut$ee_a_register,                                                                          
    RECEND;                                                                                                   
                                                                                                              
*copyc amt$file_identifier                                                                                    
*copyc amt$segment_pointer                                                                                    
*copyc clt$display_control                                                                                    
*copyc duc$dump_analyzer_constants                                                                            
*copyc dut$dump_environment                                                                                   
*copyc fsc$max_path_size                                                                                      
*copyc osd$virtual_address                                                                                    
*copyc ost$hardware_subranges                                                                                 
