?? RIGHT := 110 ??
?? NEWTITLE := 'LOM$LOADER_FRONT_END', EJECT ??
MODULE lom$loader_front_end;

{ PURPOSE:  This module contains the front end and utility routines for
{           running the loader in standalone mode.



?? PUSH (LIST := OFF) ??
*copyc clp$convert_string_to_file
*copyc clp$count_list_elements
*copyc clp$evaluate_parameters
*copyc clp$convert_integer_to_rjstring

*copyc amp$file
*copyc amp$open
*copyc fsp$open_file
*copyc amp$get_segment_pointer
*copyc amp$set_segment_eoi
*copyc amp$close

*copyc mmp$create_scratch_segment

*copyc pmp$load
*copyc pmp$load_module_from_library
*copyc pmp$generate_unique_name
*copyc pmp$get_task_jobmode_statistics
*copyc pmp$get_binary_mainframe_id

*copyc osp$set_status_abnormal
*copyc osp$generate_message

*copyc lop$load_program
*copyc lov$task_services_entry_points
*copyc lot$loader_type_definitions
*copyc mmt$page_map_offsets
*copyc pmt$initialization_value
*copyc pmt$loader_seq_descriptor
*copyc pmt$program_description
*copyc pmt$prog_options_and_libraries
*copyc loc$task_services_library_name
*copyc clc$standard_file_names

*copyc dmt$chapter_number
*copyc mmt$attribute_keyword
*copyc osd$virtual_address
*copyc ost$heap
*copyc ost$processor_model_definitions
*copyc pmt$loadable_rings
*copyc pmt$task_control_block
*copyc oce$library_generator_errors
?? POP ??
?? NEWTITLE := '  STATIC VARIABLES ', EJECT ??

?? FMT (FORMAT := OFF) ??
  VAR
    tcb_proto: pmt$task_control_block :=
      [0,                       { task_id }
       NIL,                     { parent }
       NIL,                     { first_child }
       NIL,                     { next_sibling }
       0,                       { target_ring }
       NIL,                     { condition_environment_stack }
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], { flag_execution_ring }
       [0, 0, 0, 0],            { signal_execution_ring }
       [NIL, NIL],              { task_local_signal_list }
       0,                       { task_kill_count }
       pmc$task_executing,      { task_kill_phase }
       osc$tk_nosve_task,       { task_kind }
       [NIL,                    { program_description }
       NIL,                     { mpe_description }
       NIL,                     { program_parameters }
       NIL,                     { termination_status }
       NIL,                     { parent_task_status_variable }
       NIL,                     { debug_table }
       clc$null_file,           { debug_input }
       clc$null_file,           { debug_output }
       clc$null_file,           { abort_file }
       pmc$debug_mode_off,      { initial_debug_mode }
       FALSE,                   { cl_task }
       [mmc$cell_pointer, NIL], { ada_shared_stack_pointer }
       NIL,                     { ada_critical_frame }
       NIL,                     { ada_starting_procedure }
       NIL,                     { ada_task_table }
       0,                       { task_condition_count }
       0,                       { task_handler_count }
       TRUE]];                  { task_io_enabled }
?? FMT (FORMAT := ON) ??

  VAR
    debug_table_proto: pmt$debug_table_info :=
      [[mmc$sequence_pointer, NIL], [mmc$sequence_pointer, NIL], NIL, NIL, NIL, NIL, 0];

  VAR
    lov$enable_source_type_checking: [XDCL] boolean := FALSE,
    lov$ignore_param_verification: [XDCL] integer := 0,
    mmv$preset_conversion_table: [XDCL, READ] array [pmt$initialization_value]
        of integer := [1, 2, 3, 4],
    mmv$page_map_offsets: [XDCL] mmt$page_map_offsets := [0, 0, 0, 0, 0],
    osv$global_processor_model_info: [XDCL] ost$processor_model_definition,
    pmv$prog_options_and_libraries: [XDCL] ^pmt$prog_options_and_libraries,
    pmv$task_tcb_p: [XDCL] ^pmt$task_control_block,
    processor_model_definition1: ost$processor_model_definition :=
        [osc$cyber_180_model_855, osc$cyber_180_model_855, pmc$cyber_180_model_855,
         pmc$cyber_180_model_855_class, pmc$cyber_180_model_855_class,
         30000, 50000, TRUE, TRUE, pmc$no_vectors],
    processor_model_definition2: ost$processor_model_definition :=
        [osc$cyber_180_model_990, osc$cyber_180_model_990, pmc$cyber_180_model_990,
         pmc$cyber_180_model_990_class, pmc$cyber_180_model_995_class,
         30000, 50000, TRUE, TRUE, pmc$standard_vectors],
    prog_options_and_libraries: pmt$prog_options_and_libraries,
    osv$page_size: [XDCL] ost$page_size := 1000(16),
    osv$task_private_heap: [XDCL] ^ost$heap;
?? OLDTITLE ??
?? NEWTITLE := '  TASK_SERVICES_ENTRY_POINTS', EJECT ??
?? FMT (FORMAT := OFF) ??
  CONST
    max_tsep = 1651;

  VAR
    task_services_entry_point: [STATIC] lot$task_services_entry_point :=
      [*,[1,1d(16),0f0f0f0(16)],[1,1b(16),0f0f0f0(16)],TRUE,*,1,3,15,osc$cyber_180_mode,FALSE,*,llc$cybil],
    task_services_entry_points: ^array [1 .. max_tsep] of lot$task_services_entry_point,
    task_services_entry_point_names: [static] array [1 .. max_tsep] of pmt$program_name := [
?? PUSH (LIST := OFF) ??
    'ADJUST_AGE_INTERVAL              ',
    'AMP$ACCESS_METHOD                ',
    'AMP$ADD_TO_FILE_DESCRIPTION      ',
    'AMP$CHECK_RECORD                 ',
    'AMP$CLOSE                        ',
    'AMP$COPY_FILE                    ',
    'AMP$DELETE_KEY                   ',
    'AMP$FETCH                        ',
    'AMP$FETCH_ACCESS_INFORMATION     ',
    'AMP$FETCH_FAP_POINTER            ',
    'AMP$FILE                         ',
    'AMP$FLUSH                        ',
    'AMP$GET_DIRECT                   ',
    'AMP$GET_FILE_ATTRIBUTES          ',
    'AMP$GET_KEY                      ',
    'AMP$GET_NEXT                     ',
    'AMP$GET_NEXT_KEY                 ',
    'AMP$GET_PARTIAL                  ',
    'AMP$GET_SEGMENT_POINTER          ',
    'AMP$OPEN                         ',
    'AMP$OVERRIDE_FILE_ATTRIBUTES     ',
    'AMP$PUTREP                       ',
    'AMP$PUT_DIRECT                   ',
    'AMP$PUT_KEY                      ',
    'AMP$PUT_NEXT                     ',
    'AMP$PUT_PARTIAL                  ',
    'AMP$RENAME                       ',
    'AMP$REPLACE_KEY                  ',
    'AMP$RETURN                       ',
    'AMP$REWIND                       ',
    'AMP$SEEK_DIRECT                  ',
    'AMP$SET_FILE_INSTANCE_ABNORMAL   ',
    'AMP$SET_LOCAL_NAME_ABNORMAL      ',
    'AMP$SET_SEGMENT_EOI              ',
    'AMP$SET_SEGMENT_POSITION         ',
    'AMP$SKIP                         ',
    'AMP$SKIP_TAPE_MARKS              ',
    'AMP$START                        ',
    'AMP$STORE                        ',
    'AMP$STORE_FAP_POINTER            ',
    'AMP$VALIDATE_CALLER_PRIVILEGE    ',
    'AMP$WRITE_END_PARTITION          ',
    'AMP$WRITE_TAPE_MARK              ',
    'AVP$BEGIN_ACCOUNT                ',
    'AVP$CHANGE_PASSWORD              ',
    'AVP$CHANGE_USER                  ',
    'AVP$CONSTRAIN                    ',
    'AVP$CONSTRAIN_INTERFACE          ',
    'AVP$CREATE_FAMILY                ',
    'AVP$CREATE_FAMILY_INTERFACE      ',
    'AVP$CREATE_USER                  ',
    'AVP$DEFINE_FAMILY                ',
    'AVP$DELETE                       ',
    'AVP$DELETE_USER                  ',
    'AVP$END_ACCOUNT                  ',
    'AVP$GET_ADMINISTRATOR_STATUS     ',
    'AVP$GET_EPILOGS                  ',
    'AVP$GET_FAMILY_ADMINISTRATOR     ',
    'AVP$GET_JOB_LIMITS               ',
    'AVP$GET_NEXT_USER                ',
    'AVP$GET_PROLOGS                  ',
    'AVP$GET_SCRATCH_SETS             ',
    'AVP$GET_SRU_INTERFACE            ',
    'AVP$GET_USER_SET                 ',
    'AVP$INITIALIZE                   ',
    'AVP$INITIALIZE_SEGMENT           ',
    'AVP$INSERT                       ',
    'AVP$LOGIN_USER                   ',
    'AVP$MAXIMUM_WORKING_SET          ',
    'AVP$MONITOR_STATISTICS_HANDLER   ',
    'AVP$PREVALIDATE_USER             ',
    'AVP$READ_USER                    ',
    'AVP$REGISTER_FAMILY              ',
    'AVP$REGISTER_SYSTEM_FAMILIES     ',
    'AVP$REMOVE_FAMILY                ',
    'AVP$RING_MIN                     ',
    'AVP$RING_NOMINAL                 ',
    'AVP$SEARCH                       ',
    'AVP$SEQUENTIAL_SEARCH            ',
    'AVP$SET_JOB_LIMITS               ',
    'AVV$JOB_LIMITS_BLOCK             ',
    'AVV$REGISTERED_FAMILY_LIST       ',
    'BAP$ADD_TO_FILE_DESCRIPTION      ',
    'BAP$BYTE_MOVE                    ',
    'BAP$CHANGE_FILE_ATTRIBUTES       ',
    'BAP$DATA_PROFILE                 ',
    'BAP$END_OPEN_NEW_PROCESSING      ',
    'BAP$FAP_CONTROL                  ',
    'BAP$FETCH_ART_TABLE_POINTER      ',
    'BAP$FILE_COMMAND                 ',
    'BAP$GET_DATA_PROFILE             ',
    'BAP$GET_DEVICE_CLASS             ',
    'BAP$GET_FILE_ATTRIBUTES          ',
    'BAP$GET_OPEN_INFORMATION         ',
    'BAP$MARK_FAP_LAYER_CLOSED        ',
    'BAP$MARK_FAP_LAYER_OPEN          ',
    'BAP$MAX_SEGMENT_LENGTH           ',
    'BAP$NULL_DEVICE                  ',
    'BAP$OPEN                         ',
    'BAP$RELEASE_RESOURCE_COMMAND     ',
    'BAP$RENAME                       ',
    'BAP$REQUEST_NULL_DEVICE_COMMAND  ',
    'BAP$REQUEST_TAPE_COMMAND         ',
    'BAP$REQUEST_TERMINAL_COMMAND     ',
    'BAP$RESERVE_RESOURCE_COMMAND     ',
    'BAP$RETURN                       ',
    'BAP$SKIP_TAPE_MARKS              ',
    'BAP$STORE_ART_TABLE_POINTER      ',
    'BAP$SYS_BLK_VARIABLE_REC_FAP     ',
    'BAP$TAPE_FAP                     ',
    'BAV$ENTRY_ASSIGNED_SELECT        ',
    'BAV$ENTRY_FREE_SELECT            ',
    'BAV$TASK_FILE_TABLE              ',
    'BAV$TFT_ENTRY_ASSIGNMENT         ',
    'BRING_UP_JOB_TASKS               ',
    'CDEULER                          ',
    'CITOII                           ',
    'CLP$ADD_TO_JOB_COMMAND_LIST      ',
    'CLP$ASSIGN_VARIABLE_VALUE        ',
    'CLP$ASSOCIATE_PATH_DESC_ENTRIES  ',
    'CLP$BUILD_PATH_SUBTITLE          ',
    'CLP$BUILD_STANDARD_TITLE         ',
    'CLP$CHANGE_PF_NAME_IN_PATH_DESC  ',
    'CLP$CHECK_LIST_FOR_VARIABLE      ',
    'CLP$CLOSE_COMMAND_FILE           ',
    'CLP$CLOSE_CONNECTED_FILE         ',
    'CLP$CLOSE_DISPLAY                ',
    'CLP$CLOSE_OPENED_TARGET_FILE     ',
    'CLP$CLOSE_UNOPENED_TARGET_FILE   ',
    'CLP$COLLECT_COMMANDS             ',
    'CLP$CONNECTED_FILE_FAP           ',
    'CLP$CONSOLE_FAP                  ',
    'CLP$CONTINUE                     ',
    'CLP$CONVERT_CHAR_TO_GRAPHIC      ',
    'CLP$CONVERT_CONSOLE_TO_ASCII     ',
    'CLP$CONVERT_INTEGER_TO_RJSTRING  ',
    'CLP$CONVERT_INTEGER_TO_STRING    ',
    'CLP$CONVERT_STRING_TO_FILE       ',
    'CLP$CONVERT_STRING_TO_INTEGER    ',
    'CLP$CONVERT_STRING_TO_NAME       ',
    'CLP$CONVERT_VALUE_TO_STRING      ',
    'CLP$CREATE_FILE_CONNECTION       ',
    'CLP$CREATE_VARIABLE              ',
    'CLP$CYCLE_BLOCK                  ',
    'CLP$DELETE_ALL_JOB_COMMAND_LIST  ',
    'CLP$DELETE_FILE_CONNECTION       ',
    'CLP$DELETE_FROM_JOB_CMND_LIST    ',
    'CLP$DELETE_IF_ONLY_PATH_REF      ',
    'CLP$DELETE_NAMED_TASK_ENTRY      ',
    'CLP$DELETE_VARIABLE              ',
    'CLP$DETERMINE_LINE_LAYOUT        ',
    'CLP$DISCARD_ACCUMULATED_DISPLAY  ',
    'CLP$DISESTABLISH_COND_HANDLER    ',
    'CLP$DISPLAY_ALL_INPUT_COMMAND    ',
    'CLP$DISPLAY_ALL_OUTPUT_COMMAND   ',
    'CLP$END_SCAN_COMMAND_FILE        ',
    'CLP$ESTABLISH_CONDITION_HANDLER  ',
    'CLP$ESTABLISH_SYS_COMMAND_LIB    ',
    'CLP$EXECUTE_NAMED_TASK           ',
    'CLP$EXIT_BLOCK                   ',
    'CLP$EXIT_PROC                    ',
    'CLP$FETCH_CONSOLE_FAP_DATA       ',
    'CLP$FETCH_DISPLAY_LOG_INDICES    ',
    'CLP$FETCH_NAMED_TASK_ENTRY       ',
    'CLP$FETCH_SYSTEM_FILE_ID         ',
    'CLP$FIND_CMND_LIB_ENTRY_POINTS   ',
    'CLP$FIND_CURRENT_BLOCK           ',
    'CLP$FIND_CYCLE_BLOCK             ',
    'CLP$FIND_INPUT_BLOCK             ',
    'CLP$FIND_NEXT_VAR_BLOCK          ',
    'CLP$FIND_OPEN_CONNECTED_FILE     ',
    'CLP$FIND_PATH_DESC_VIA_LFN       ',
    'CLP$FIND_PF_PATH_DESC_VIA_LFN    ',
    'CLP$FIND_TASK_BLOCK              ',
    'CLP$FIND_VARIABLE_ACCESS         ',
    'CLP$FIND_VAR_BLOCK               ',
    'CLP$GET_CMND_LIB_ENTRY_POINTS    ',
    'CLP$GET_COMMAND_FILE_DEVICE      ',
    'CLP$GET_COMMAND_LINE             ',
    'CLP$GET_COMMAND_MODE             ',
    'CLP$GET_COMMAND_ORIGIN           ',
    'CLP$GET_COMMAND_SEARCH_MODE      ',
    'CLP$GET_DATA_LINE                ',
    'CLP$GET_DATA_RECORD              ',
    'CLP$GET_INTERPRETER_MODE         ',
    'CLP$GET_LIB_PROGRAM_DESCRIPTION  ',
    'CLP$GET_LINE_FROM_COMMAND_FILE   ',
    'CLP$GET_LINE_FROM_CONSOLE        ',
    'CLP$GET_LIST_OF_$LOCAL_FILES     ',
    'CLP$GET_PARAMETER                ',
    'CLP$GET_PARAMETER_LIST           ',
    'CLP$GET_PATH_DESCRIPTION         ',
    'CLP$GET_PATH_NAME                ',
    'CLP$GET_QUEUE_ID                 ',
    'CLP$GET_SET_COUNT                ',
    'CLP$GET_VALUE                    ',
    'CLP$GET_VALUE_COUNT              ',
    'CLP$GET_WORKING_CATALOG          ',
    'CLP$HORIZONTAL_TAB_DISPLAY       ',
    'CLP$IGNORE_REST_OF_FILE          ',
    'CLP$INITIALIZE_FILE_RING_ATTR    ',
    'CLP$INITIALIZE_PVT               ',
    'CLP$INITIALIZE_VARIABLE          ',
    'CLP$INIT_COMMAND_LIST_DISPLAY    ',
    'CLP$INIT_COMMAND_LIST_SEARCH     ',
    'CLP$INIT_FUNCTION_LIST_SEARCH    ',
    'CLP$INIT_MESSAGE_LIST_SEARCH     ',
    'CLP$INTERNAL_CREATE_VARIABLE     ',
    'CLP$ISOLATE_COMMAND              ',
    'CLP$KEYPOINT                     ',
    'CLP$K_DISPLAY_FAP                ',
    'CLP$LOAD_SYSTEM_COMMAND          ',
    'CLP$LOCAL_QUEUE_FAP              ',
    'CLP$LOCK_CONNECTED_FILE_LIST     ',
    'CLP$LOG_COMMAND_LINE             ',
    'CLP$LOG_COMMENT                  ',
    'CLP$LOG_EDITED_LOGIN_COMMAND     ',
    'CLP$MAKE_PATH_DESC_GLOBAL        ',
    'CLP$NEW_DISPLAY_LINE             ',
    'CLP$NEW_DISPLAY_PAGE             ',
    'CLP$NOTIFY_BEFORE_COMMAND_READ   ',
    'CLP$OPEN_COMMAND_FILE            ',
    'CLP$OPEN_CONNECTED_FILE          ',
    'CLP$OPEN_CONNECTED_FILE_TARGET   ',
    'CLP$OPEN_DISPLAY                 ',
    'CLP$PARSE_COMMAND                ',
    'CLP$PASS_VARIABLE_PARAMETER      ',
    'CLP$POP_BLOCK_STACK              ',
    'CLP$POP_INPUT_STACK              ',
    'CLP$POP_PARAMETERS               ',
    'CLP$POP_TASK_COMMAND_LIST        ',
    'CLP$POP_TERMINATED_BLOCKS        ',
    'CLP$POP_UTILITY                  ',
    'CLP$PUSH_BLOCK_STACK             ',
    'CLP$PUSH_INPUT_STACK             ',
    'CLP$PUSH_PARAMETERS              ',
    'CLP$PUSH_TASK_COMMAND_LIST       ',
    'CLP$PUSH_UTILITY                 ',
    'CLP$PUSH_WHEN_BLOCK              ',
    'CLP$PUT_COMMAND_PARAMETERS       ',
    'CLP$PUT_DISPLAY                  ',
    'CLP$PUT_ERROR_OUTPUT             ',
    'CLP$PUT_JOB_COMMAND_RESPONSE     ',
    'CLP$PUT_JOB_OUTPUT               ',
    'CLP$PUT_PARTIAL_DISPLAY          ',
    'CLP$READ_INPUT_FILE              ',
    'CLP$READ_VARIABLE                ',
    'CLP$REBUILD_INPUT_QUEUE          ',
    'CLP$REBUILD_OUTPUT_QUEUE         ',
    'CLP$RECORD_PATH_REFERENCE        ',
    'CLP$REFERENCE_VARIABLE           ',
    'CLP$RESET_FOR_NEXT_DISPLAY_PAGE  ',
    'CLP$RESET_INPUT_POSITION         ',
    'CLP$RESOLVE_CYCLE_SELECTOR       ',
    'CLP$RETURN_LOCAL_FILE            ',
    'CLP$REWRITE_VARIABLE             ',
    'CLP$SAVE_PVT                     ',
    'CLP$SCAN_ARGUMENT_LIST           ',
    'CLP$SCAN_COMMAND_FILE            ',
    'CLP$SCAN_COMMAND_LINE            ',
    'CLP$SCAN_EXPRESSION              ',
    'CLP$SCAN_PARAMETER_LIST          ',
    'CLP$SCAN_PROC_DECLARATION        ',
    'CLP$SCAN_TOKEN                   ',
    'CLP$SEARCH_COMMAND_LIBRARY       ',
    'CLP$SEARCH_MESSAGE_LIBRARY       ',
    'CLP$SET_COMMAND_ATTRIBUTES       ',
    'CLP$SET_CURRENT_PROMPT_STRING    ',
    'CLP$SET_EXIT_POSITION            ',
    'CLP$SET_FOR_BLOCK                ',
    'CLP$SET_FOR_VALUE                ',
    'CLP$SET_IF_BLOCK                 ',
    'CLP$SET_INPUT_LINE               ',
    'CLP$SET_INPUT_LINE_INDEX         ',
    'CLP$SET_JOB_COMMAND_SEARCH_MODE  ',
    'CLP$SET_JSN_COMMAND              ',
    'CLP$SET_PREV_CMND_NAME_AND_STAT  ',
    'CLP$SET_PRIMARY_TASK             ',
    'CLP$SET_PROC_NAME                ',
    'CLP$SET_REPEAT_WHILE_BLOCK       ',
    'CLP$SET_SYSTEM_LOGGING_ACTIVE    ',
    'CLP$SET_TASK_STATEMENT_TASK      ',
    'CLP$SET_WORKING_CATALOG          ',
    'CLP$SET_WORKING_CATALOG_PATH     ',
    'CLP$SIMULATOR_FAP                ',
    'CLP$SKIP_BLOCK                   ',
    'CLP$STORE_CONSOLE_FAP_DATA       ',
    'CLP$STORE_DISPLAY_LOG_INDICES    ',
    'CLP$STORE_SYSTEM_FILE_ID         ',
    'CLP$SUPPRESS_COMMAND_LOGGING     ',
    'CLP$TASK_TASKEND                 ',
    'CLP$TEST_PARAMETER               ',
    'CLP$TEST_RANGE                   ',
    'CLP$TRIMMED_STRING_SIZE          ',
    'CLP$TURN_KEYPOINT_OFF            ',
    'CLP$UNLOCK_CONNECTED_FILE_LIST   ',
    'CLP$UNRESOLVE_CYCLE_SELECTOR     ',
    'CLP$UPDATE_CONNECTED_FILE        ',
    'CLP$VERTICAL_TAB_DISPLAY         ',
    'CLP$WRITE_VARIABLE               ',
    'CLV$CHARACTER_CLASS              ',
    'CLV$COMMENT_DELIMITER            ',
    'CLV$CONNECTED_FILE_LIST          ',
    'CLV$ISOLATE_COMMAND              ',
    'CLV$NON_ALPHANUMERIC             ',
    'CLV$STRING_DELIMITER             ',
    'CLV$SYSTEM_LOGGING_ACTIVATED     ',
    'CMP$ACQUIRE_170_RESOURCES        ',
    'CMP$ACTIVATE_VOLUME              ',
    'CMP$ASSIGN_UNIT                  ',
    'CMP$BEGIN_TRANSITION             ',
    'CMP$BUILD_INTERFACE_TABLES       ',
    'CMP$BUILD_LCT                    ',
    'CMP$BUILD_LOGICAL_CONF           ',
    'CMP$BUILD_PCT                    ',
    'CMP$BUILD_REQUEST_ENTRY          ',
    'CMP$BUILD_STND_INTERFACE_TABLES  ',
    'CMP$CHECK_FOR_UNIQUE_ELEMENT     ',
    'CMP$CONFIGURE_INSTALLED_SYSTEM   ',
    'CMP$CONFIGURE_SYSTEM_DEVICE      ',
    'CMP$DEADSTART_PHASE              ',
    'CMP$DISPLAY_NAMED_ELEMENT        ',
    'CMP$DISPLAY_TYPE_ELEMENTS        ',
    'CMP$FIND_ELEMENT                 ',
    'CMP$GENERATE_INTERFACE_TABLES    ',
    'CMP$GET_CONFIGURATION_FILE       ',
    'CMP$GET_CONTROLLER_TYPE          ',
    'CMP$GET_CONTROLLER_TYPE_R3       ',
    'CMP$GET_DEVICE_FILE              ',
    'CMP$GET_ELEMENT_NAME             ',
    'CMP$GET_ELEMENT_R3               ',
    'CMP$GET_LOGICAL_ATTRIBUTES       ',
    'CMP$GET_LOGICAL_CONF_TABLE       ',
    'CMP$GET_LOGICAL_UNIT_NUMBER      ',
    'CMP$GET_LOGICAL_UNIT_NUMBER_R3   ',
    'CMP$GET_MAINFRAME_ELEMENT        ',
    'CMP$GET_PHYSICAL_ATTRIBUTES      ',
    'CMP$GET_PHYSICAL_CONF_TABLE      ',
    'CMP$GET_SYS_DEV_REC_VSN          ',
    'CMP$GET_UNIT_NUMBER_VIA_VSN      ',
    'CMP$INITIALIZE_ADTT              ',
    'CMP$INITIALIZE_MS_VOLUME         ',
    'CMP$PC_GET_ELEMENT               ',
    'CMP$PC_GET_LOGICAL_UNIT          ',
    'CMP$PC_GET_NEXT_CHANNEL          ',
    'CMP$RELEASE_UNIT                 ',
    'CMP$SAVE_DEVICE_FILE             ',
    'CMP$VOLUME_ONLINE                ',
    'CMV$ASSIGNABLE_DEVICE            ',
    'CMV$LOGICAL_CONFIGURATION        ',
    'CMV$LOGICAL_CONF_DEV_FILE_NAME   ',
    'CMV$LOGICAL_PP_TABLE             ',
    'CMV$LOGICAL_UNIT_TABLE           ',
    'CMV$NEW_LOGICAL_PP_TABLE         ',
    'CMV$NEW_LOGICAL_UNIT_TABLE       ',
    'CMV$PHYSICAL_CONFIGURATION       ',
    'CMV$PHYSICAL_CONF_DEV_FILE_NAME  ',
    'CMV$PRODUCT_ID_PTR               ',
    'CMV$SYSTEM_CORE_COMMANDS         ',
    'CMV$SYSTEM_DEVICE_ADDRESS_TYPE   ',
    'CONSTRUCT_AJL_ENTRY              ',
    'CYP$ALLOCATE                     ',
    'CYP$ERROR                        ',
    'CYP$FREE                         ',
    'CYP$NIL                          ',
    'CYP$OUTPUT_FLOATING_NUMBER       ',
    'CYP$ROUND_FLOATING_NUMBER        ',
    'CYP$SCALE_FLOATING_NUMBER        ',
    'CYP$STRINGREP                    ',
    'CYP$VALOG                        ',
    'CYP$VALOG10                      ',
    'CYP$VDEXP                        ',
    'CYP$VDLOG                        ',
    'CYP$VDLOG10                      ',
    'CYV$DOUBLE_POWERS_OF_TEN         ',
    'DBP$ENTRY_POINT_TABLE_ADDRESS    ',
    'DBP$MODULE_TABLE_ADDRESS         ',
    'DMP$ACQUIRE_TAPE_RESOURCE        ',
    'DMP$ACTION_OPERATOR              ',
    'DMP$ACTIVATE_VOLUME              ',
    'DMP$ADMINISTER_ALLOCATION_LOG    ',
    'DMP$ADMINISTER_DEVICE_LOG        ',
    'DMP$ASSIGN_TAPE                  ',
    'DMP$ATTACH_DEVICE_FILE           ',
    'DMP$ATTACH_FILE                  ',
    'DMP$CLOSE_DAT_R3                 ',
    'DMP$CLOSE_DEVICE_FILE_R3         ',
    'DMP$CLOSE_DIRECTORY_R3           ',
    'DMP$CLOSE_LABEL_R3               ',
    'DMP$CLOSE_SEGMENT_ACCESS_FILE    ',
    'DMP$CONVERT_SFID_TO_LUN          ',
    'DMP$CRACK_ASSIGN_REPLY           ',
    'DMP$CREATE_DEVICE_FILE           ',
    'DMP$CREATE_FILE_ENTRY            ',
    'DMP$CREATE_TAPE_MESSAGE          ',
    'DMP$CREATE_TAPE_WINDOW           ',
    'DMP$CREATE_TIR                   ',
    'DMP$CREATE_TMD                   ',
    'DMP$DEACTIVATE_VOLUME            ',
    'DMP$DELETE_FILE_DESCRIPTOR       ',
    'DMP$DESELECT_TAPE_SUBFILE        ',
    'DMP$DESTROY_DEVICE_FILE          ',
    'DMP$DESTROY_FILE                 ',
    'DMP$DESTROY_PERMANENT_FILE       ',
    'DMP$DESTROY_SUB_FILE             ',
    'DMP$DESTROY_TAPE_WINDOW          ',
    'DMP$DESTROY_TMD                  ',
    'DMP$DETACH_DEVICE_FILE           ',
    'DMP$DETACH_FILE                  ',
    'DMP$DEV_MGMT_TABLE_UPDATE        ',
    'DMP$DISPLAY_DAT                  ',
    'DMP$DISPLAY_DEVICE_FILE          ',
    'DMP$DISPLAY_DEVICE_LOG           ',
    'DMP$DISPLAY_DEVICE_SPACE         ',
    'DMP$DISPLAY_DIRECTORY            ',
    'DMP$DISPLAY_LABEL                ',
    'DMP$DISPLAY_LOGIN_TABLE          ',
    'DMP$ENABLE_UPDATE                ',
    'DMP$EVACUATE_ACTIVE_DEVICE_LOG   ',
    'DMP$EVACUATE_OLD_DEVICE_LOG      ',
    'DMP$FETCH_EOI                    ',
    'DMP$FETCH_SEGMENT_FILE_INFO      ',
    'DMP$FIXUP_FILE_ALLOCATION_UNIT   ',
    'DMP$FIXUP_FILE_EOF               ',
    'DMP$FIXUP_FILE_EOI               ',
    'DMP$FIXUP_SUBF_ALLOCATED_LENGTH  ',
    'DMP$FIXUP_SUBF_LOGICAL_LENGTH    ',
    'DMP$FREE_BACKING_STORE           ',
    'DMP$FREE_FILE_TABLES             ',
    'DMP$GET_ALLOCATION_SIZE          ',
    'DMP$GET_LOGICAL_ATTRIBUTES       ',
    'DMP$GET_LOGICAL_UNIT_NUMBER      ',
    'DMP$GET_PHYSICAL_ATTRIBUTES      ',
    'DMP$GET_STORED_FMD               ',
    'DMP$GET_STORED_FMD_HEADER        ',
    'DMP$GET_STORED_FMD_SIZE          ',
    'DMP$GET_STORED_FMD_SUBFILES      ',
    'DMP$GET_TAPE_MEDIUM_DESCRIPTOR   ',
    'DMP$GET_TMD_FIELD                ',
    'DMP$GET_VOLUMES_ACTIVE           ',
    'DMP$INCREASE_FAT_SIZE            ',
    'DMP$INHIBIT_UPDATE               ',
    'DMP$INITIALIZE_MS_VOLUME         ',
    'DMP$LOCK_DAT                     ',
    'DMP$LOCK_DFLT                    ',
    'DMP$LOCK_DIRECTORY               ',
    'DMP$LOCK_FILE                    ',
    'DMP$LOCK_FILE_DESCRIPTOR_ENTRY   ',
    'DMP$LOCK_LOGIN_TABLE             ',
    'DMP$LOGOUT_RECOVERED_MAINFRAME   ',
    'DMP$OPEN_DAT_FOR_SEGMENT_ACCES   ',
    'DMP$OPEN_DAT_R3                  ',
    'DMP$OPEN_DEVICE_FILE_R3          ',
    'DMP$OPEN_DFLT_FOR_SEGMENT_ACCES  ',
    'DMP$OPEN_DIRECTORY_R3            ',
    'DMP$OPEN_DIR_FOR_SEG_ACCESS      ',
    'DMP$OPEN_FILE_FOR_SEGMENT_ACCES  ',
    'DMP$OPEN_FILE_SEGMENT            ',
    'DMP$OPEN_LABEL_R3                ',
    'DMP$OPEN_LAB_FOR_SEGMENT_ACCES   ',
    'DMP$OPEN_LGIN_FOR_SEGMENT_ACCES  ',
    'DMP$PROCESS_DEVICE_LOG_ENTRY     ',
    'DMP$RECOVER_FILE                 ',
    'DMP$RECOVER_MAINFRAME            ',
    'DMP$RETURN_DAT_ENTRIES           ',
    'DMP$RETURN_DFL_ENTRIES           ',
    'DMP$RETURN_TAPE_RESOURCE         ',
    'DMP$SEARCH_LOGIN_TABLE           ',
    'DMP$SEARCH_VOL_DIRECTORY_NAME    ',
    'DMP$SELECT_TAPE_SUBFILE          ',
    'DMP$SET_EOI                      ',
    'DMP$SET_FILE_LIMIT               ',
    'DMP$SET_LOWER_PRIORITY           ',
    'DMP$SET_TRANSFER_SIZE            ',
    'DMP$SPLIT_ALLOCATION_LOG         ',
    'DMP$SWAP_TAPE                    ',
    'DMP$UNLOCK_DAT                   ',
    'DMP$UNLOCK_DFLT                  ',
    'DMP$UNLOCK_DIRECTORY             ',
    'DMP$UNLOCK_FILE                  ',
    'DMP$UNLOCK_LOGIN_TABLE           ',
    'DMP$UPDATE_VOLUME_TABLES         ',
    'DMP$VALIDATE_ASSIGN_REPLY        ',
    'DMP$VALIDATE_EXTERNAL_VSN        ',
    'DMP$VOLUME_ONLINE                ',
    'DMV$ACTIVE_VOLUME_TABLE          ',
    'DMV$ADMINISTER_LOG_INITIATED     ',
    'DMV$ALLOCATION_LOG               ',
    'DMV$DEBUG_OPTIONS                ',
    'DMV$EXTERNAL_INTERRUPT_SELECTOR  ',
    'DMV$FREE_POSITION_CHAIN          ',
    'DMV$FREE_POSITION_CHAIN_LOCKED   ',
    'DMV$MAXIMUM_MAT_FILE_SPACE       ',
    'DMV$MAX_MAT_ALLOCATION_STYLES    ',
    'DMV$MINIMUM_MAT_FILE_SPACE       ',
    'DMV$MIN_MAT_ALLOCATION_STYLES    ',
    'DMV$MS_DEFAULT_FAT_ENTRY         ',
    'DMV$MS_DEFAULT_FAT_HEADER        ',
    'DMV$NOM_MAT_ALLOCATION_STYLES    ',
    'DMV$NULL_SFID                    ',
    'DMV$NULL_VSN                     ',
    'DMV$N_MAT_ENTRIES_IN_FREE_CHAIN  ',
    'DMV$P_JOB_FILE_TABLE_ROOT        ',
    'DMV$P_JOB_TAPE_TABLE             ',
    'DMV$SIZE_OF_FDT_ALLOCATION       ',
    'DMV$SPLIT_AL_INITIATED           ',
    'DMV$SYSTEM_DEVICE_LUN            ',
    'DMV$SYSTEM_DEVICE_PRODUCT_ID     ',
    'DMV$SYSTEM_DEVICE_RECORDED_VSN   ',
    'DMV$SYSTEM_FILE_TABLE_ROOT       ',
    'DMV$TAPE_REQUEST_LIST            ',
    'DMV$VOLUME_WEIGHTING_FACTORS     ',
    'DMV$WIDTH_OF_SFT                 ',
    'DPP$6_12_TO_ASCII                ',
    'DPP$DISPLAY_TO_ASCII             ',
    'DPP$OPEN                         ',
    'DPP$PUT                          ',
    'DPP$PUT_DIRECT                   ',
    'DPP$SCROLL                       ',
    'DPV$DISPLAY_DELAY                ',
    'DSOPT                            ',
    'DSP$ADVANCE_RECOVERY_SEQUENCE    ',
    'DSP$CLEAR_SFT_LOCK               ',
    'DSP$DISABLE_DEADSTART_INPUT      ',
    'DSP$FETCH_COMMAND_BLOCK          ',
    'DSP$FETCH_LIST_BLOCK             ',
    'DSP$FETCH_PVAS_OF_IMAGE_PAGES    ',
    'DSP$GET_DEADSTART_INPUT          ',
    'DSP$GET_FILE_ALLOCATION_TABLE    ',
    'DSP$GET_FILE_MEDIUM_DESCRIPTOR   ',
    'DSP$GET_FMD_SUBFILE              ',
    'DSP$GET_JOB_SEQUENCE_NUMBER      ',
    'DSP$GET_LAST_DSTAPE_RECORD_TYPE  ',
    'DSP$GET_LOCKED_SFT_ENTRY         ',
    'DSP$GET_NVE_IMAGE_DESCRIPTION    ',
    'DSP$GET_STANDALONE_FLAG          ',
    'DSP$HANDLE_ERROR_JOURNAL_FLAG    ',
    'DSP$LOAD_FILES                   ',
    'DSP$MAKE_IMAGE_FILE              ',
    'DSP$MAKE_SSR_SEGMENT             ',
    'DSP$POSITION_DEADSTART_TAPE      ',
    'DSP$R3GET_DEADSTART_INPUT        ',
    'DSP$R3GET_STANDALONE_FLAG        ',
    'DSP$R3POSITION_DEADSTART_TAPE    ',
    'DSP$R3SET_GLOBAL_POINTER         ',
    'DSP$R3SKIP_DEADSTART_INPUT       ',
    'DSP$R3TERMINATE_DEADSTART_INPUT  ',
    'DSP$RECEIVE_DATA_VIA_SSR         ',
    'DSP$RECOVER_COMMANDS             ',
    'DSP$RECOVER_LIST                 ',
    'DSP$RESET_IMAGE_FILE             ',
    'DSP$SEARCH_ACTIVE_VOLUME_TABLE   ',
    'DSP$SEND_DATA_VIA_SSR            ',
    'DSP$SETUP_DEADSTART              ',
    'DSP$SET_JOB_SEQUENCE_NUMBER      ',
    'DSP$SKIP_DEADSTART_INPUT         ',
    'DSP$STORE_COMMANDS               ',
    'DSP$STORE_COMMAND_BLOCK          ',
    'DSP$STORE_LIST                   ',
    'DSP$STORE_LIST_BLOCK             ',
    'DSP$SYSTEM_COMMITTED             ',
    'DSP$TERMINATE_DEADSTART_INPUT    ',
    'DSP$TEST_DEADSTART_INPUT         ',
    'DSP$TEST_IMAGE                   ',
    'DSP$TEST_SSR_ENVIRON             ',
    'DSV$CONSOLE_MODE                 ',
    'DSV$DEADSTART_MODE               ',
    'DSV$IMAGE_SEGMENT                ',
    'DSV$INSTALL_TPXXXK               ',
    'DSV$JOURNAL_CONTROL_RECORD       ',
    'DSV$LOAD_FILES                   ',
    'DSV$MEMORY_IMAGE                 ',
    'DSV$MTR_SSR_SEGMENT_P            ',
    'DSV$MULTI_TAPE_DEADSTART         ',
    'DSV$NO_SSR_USAGE                 ',
    'DSV$NVE_IMAGE_STATUS             ',
    'DSV$PGLOBAL                      ',
    'DSV$RCV_MAINFRAME_WIRED_ASID     ',
    'DSV$RCV_MAINFRAME_WIRED_PVA      ',
    'DSV$RCV_MAINFRAME_WIRED_SEGMENT  ',
    'DSV$RCV_SSR_DESCRIPTOR_P         ',
    'DSV$RECORD_ERRORS                ',
    'DSV$REC_ATTEMPT_NO_IMAGE         ',
    'DSV$REC_ATTEMPT_WITH_IMAGE       ',
    'DSV$SSR_DESCRIPTOR_P             ',
    'DSV$SSR_ENVIRONMENT_READY        ',
    'DSV$SSR_SEGMENT_P                ',
    'DSV$SSR_SHAPE_MTR                ',
    'ENTRY_INDEX                      ',
    'FMP$ADD_TO_FILE_DESCRIPTION      ',
    'FMP$CHANGE_FILE_ATTRIBUTES       ',
    'FMP$CLOSE_CHAPTER                ',
    'FMP$CLOSE_TAPE_FILE              ',
    'FMP$END_OPEN_PROCESSING          ',
    'FMP$FETCH_SYSTEM_LABEL           ',
    'FMP$FETCH_SYSTEM_LABEL_SIZE      ',
    'FMP$FILE_COMMAND                 ',
    'FMP$FILE_IS_LOCAL                ',
    'FMP$GET_DEVICE_CLASS             ',
    'FMP$GET_JL_POINTER               ',
    'FMP$GET_LNT_INFO                 ',
    'FMP$IMPLICIT_RETURN_FILE         ',
    'FMP$LN_ATTACH                    ',
    'FMP$LN_CREATE                    ',
    'FMP$LN_GET_JFID_SFID             ',
    'FMP$LN_JOB_EXIT                  ',
    'FMP$LN_OPEN_CHAPTER              ',
    'FMP$LN_RENAME                    ',
    'FMP$LN_RETURN                    ',
    'FMP$LOGICALLY_POSITION_TAPE      ',
    'FMP$OPEN_CHAPTER                 ',
    'FMP$OPEN_LOCAL_NAME_TABLE        ',
    'FMP$PUT_JL_POINTER               ',
    'FMP$RELEASE_RESOURCE             ',
    'FMP$REQUEST_MASS_STORAGE         ',
    'FMP$REQUEST_NULL_DEVICE          ',
    'FMP$REQUEST_TAPE                 ',
    'FMP$REQUEST_TERMINAL             ',
    'FMP$RESERVE_RESOURCE             ',
    'FMP$REWIND_TAPE                  ',
    'FMP$SKIP_TAPE_MARKS              ',
    'FMP$STORE_BAM_EOI                ',
    'FMP$STORE_SYSTEM_LABEL           ',
    'FMP$TAPE_PAGE_FAULT_MONITOR      ',
    'FMP$VALIDATE_PF_ACCESS           ',
    'FMP$WRITE_TAPE_MARK              ',
    'FMV$ENTRY_ASSIGNED_SELECTOR      ',
    'FMV$ENTRY_FREE_SELECTOR          ',
    'FMV$FILE_DESCRIPTION_TABLE       ',
    'FMV$FILE_DESCRIPTION_TABLE_LOCK  ',
    'FMV$JFT_ENTRY_ASSIGNMENT         ',
    'FMV$JOB_FILE_TABLE               ',
    'FMV$JOB_FILE_TABLE_LOCK          ',
    'FMV$LOCAL_NAME_TABLE             ',
    'FMV$LOCAL_NAME_TABLE_LOCK        ',
    'FMV$LOCAL_NAME_TREES             ',
    'FMV$NULL_JFID                    ',
    'FSP$CLOSE_FILE                   ',
    'FSP$OPEN_FILE                    ',
    'GENERATE_SWAP_REQ                ',
    'GET_AJL_STATISTICS               ',
    'GET_SWAPPED_JOB_COUNT            ',
    'HPP$INITIALIZE                   ',
    'ICP$FAP_CONTROL                  ',
    'IFP$ADVANCE                      ',
    'IFP$BEGIN_HANDLER                ',
    'IFP$DEFAULT_INTERACTIVE_HANDLER  ',
    'IFP$DISCARD_SUSPENDED_OUTPUT     ',
    'IFP$END_HANDLER                  ',
    'IFP$FAP_CONTROL                  ',
    'IFP$FAP_CONTROL_RING_3           ',
    'IFP$FETCH_CONTEXT                ',
    'IFP$FETCH_TERMINAL               ',
    'IFP$FETCH_TERM_CONN_ATTRIBUTES   ',
    'IFP$GET_DEFLT_TERM_ATTRIBUTES    ',
    'IFP$GET_GTID                     ',
    'IFP$GET_TERMINAL_ATTRIBUTES      ',
    'IFP$JOB_INITIALIZE               ',
    'IFP$MARK_ATTRIBUTES_CHANGE       ',
    'IFP$REJECT_CONNECTION            ',
    'IFP$SEND_ATTRIBUTE_KLUDGE        ',
    'IFP$START_PAUSE_UTILITY          ',
    'IFP$STOP_INTERACTIVE             ',
    'IFP$STORE_CONTEXT                ',
    'IFP$STORE_TERMINAL               ',
    'IFP$STORE_TERM_CONN_ATTRIBUTES   ',
    'IFP$TERMINAL                     ',
    'IFP$TERMINAL_COMMAND             ',
    'IIP$ADD_SENDER                   ',
    'IIP$ALLOCATE_QUEUE_ENTRY         ',
    'IIP$BEGIN_HANDLER                ',
    'IIP$CHECK_FOR_CONDITION          ',
    'IIP$CLEAR_JOB_LOCKS              ',
    'IIP$CLEAR_LOCK                   ',
    'IIP$CLOSE                        ',
    'IIP$CONFIRM_SEND                 ',
    'IIP$DISCARD_SUSPENDED_OUTPUT     ',
    'IIP$DISCARD_TYPED_AHEAD_INPUT    ',
    'IIP$END_HANDLER                  ',
    'IIP$FETCH_ACCESS_INFORMATION     ',
    'IIP$FETCH_TERMINAL               ',
    'IIP$FLUSH                        ',
    'IIP$FREE_QUEUE_ENTRY             ',
    'IIP$GET                          ',
    'IIP$GET_DEFLT_TERM_ATTRIBUTES    ',
    'IIP$GET_TERMINAL_ATTRIBUTES      ',
    'IIP$OPEN                         ',
    'IIP$PAUSE_UTILITY                ',
    'IIP$PUT                          ',
    'IIP$RECEIVE_FROM_PASS_ON         ',
    'IIP$REGISTER_HANDLER             ',
    'IIP$REPORT_STATUS_ERROR          ',
    'IIP$ROUTE                        ',
    'IIP$SEND_TO_PASS_ON              ',
    'IIP$SET_LOCK                     ',
    'IIP$SIGN_OFF                     ',
    'IIP$SIGN_ON                      ',
    'IIP$STORE_TERMINAL               ',
    'IIP$TERMINAL                     ',
    'IIP$TERMINAL_COMMAND             ',
    'IIP$UPDATE_OPEN_DESC_ATTRIBUTES  ',
    'IIV$BREAK_REASON                 ',
    'IIV$BREAK_STACK                  ',
    'IIV$INTERACTIVE_WAIT_TIME        ',
    'IIV$JOB_BREAK_LEVEL              ',
    'IIV$JOB_CONNECTION               ',
    'IIV$JOB_MONITOR_TASK_ID          ',
    'IIV$SEND_OUTPUT_LOCK             ',
    'IIV$TASK_BREAK_LEVEL             ',
    'INCR_SWAP_JOB_COUNT              ',
    'INITIALIZE_SWAP_ENTRY            ',
    'INITIATE_JOB_FROM_SCHEDULER      ',
    'IOP$ALLOCATE_IMAGE_REQUESTS      ',
    'IOP$BACKSPACE_TAPE               ',
    'IOP$DATA_SECURITY_ERASE_TAPE     ',
    'IOP$ERASE_TAPE                   ',
    'IOP$FORMAT_TAPE_UNIT             ',
    'IOP$FORSPACE_TAPE                ',
    'IOP$INITIALIZE_TAPE_UNIT         ',
    'IOP$MASS_STORAGE_IO              ',
    'IOP$QUEUE_IMAGE_REQUEST          ',
    'IOP$READ_TAPE                    ',
    'IOP$REWIND_TAPE                  ',
    'IOP$SKIP_TAPEMARK_BACKWARD       ',
    'IOP$SKIP_TAPEMARK_FORWARD        ',
    'IOP$TAPE_BUILD_PP_REQ_HEADER     ',
    'IOP$TAPE_INITIALIZATION          ',
    'IOP$TAPE_INITIALIZE_UNIT         ',
    'IOP$TAPE_INTERNAL_REQUEST_STAT   ',
    'IOP$TAPE_QUEUE_REQUEST           ',
    'IOP$TAPE_QUEUE_REQUEST_SETUP     ',
    'IOP$TAPE_REQUEST_STATUS          ',
    'IOP$TAPE_RETURN_WIRED_REQUEST    ',
    'IOP$UNLOAD_TAPE                  ',
    'IOP$WRITE_TAPE                   ',
    'IOP$WRITE_TAPEMARK               ',
    'IOV$67X_COMMAND_TABLE            ',
    'IOV$DISK_TYPE_TABLE              ',
    'IOV$TAPE_COMPLETION_Q_TABLE      ',
    'IOV$TAPE_UD_P_TABLE              ',
    'IOV$TAPE_UD_TABLES               ',
    'JMP$ACQUIRE_ALL                  ',
    'JMP$ACQUIRE_COMPLETE             ',
    'JMP$ACQUIRE_TERMINAL_FAMILIES    ',
    'JMP$ADJUST_JOB_PRIORITY          ',
    'JMP$ADJUST_PRIORITY_OF_NEW_JOB   ',
    'JMP$AGE_SWAPPED_JOBS             ',
    'JMP$ALTER_JOB_PRIORITY           ',
    'JMP$ALTER_QFILE                  ',
    'JMP$ASSIGN_JSN                   ',
    'JMP$AUTO_INIT_SET                ',
    'JMP$CHANGE_CLASS_ATTR            ',
    'JMP$CHANGE_JOB_PRIORITY          ',
    'JMP$CHANGE_SCH_TBL               ',
    'JMP$CHANGE_SWAP_JOB              ',
    'JMP$CLEAR_OPERATOR_ACTION        ',
    'JMP$COMPARE_QUEUES_VIA_PRIORITY  ',
    'JMP$CONVERT_JOB_TEMPLATE_FILE    ',
    'JMP$DISPLAY_ALL_INPUT_COMMAND    ',
    'JMP$DISPLAY_ALL_OUTPUT_COMMAND   ',
    'JMP$DIVERT_FAMILY                ',
    'JMP$DIVERT_OWNED                 ',
    'JMP$DIVERT_QFILE                 ',
    'JMP$DROP_QFILE                   ',
    'JMP$DSTAPE_FORMAT                ',
    'JMP$EXECUTE_JOB_TEMPL_TASK       ',
    'JMP$EXIT_JOB                     ',
    'JMP$GET_CLASS_ATTR               ',
    'JMP$GET_JOB_INTERNAL_INFO        ',
    'JMP$GET_JOB_PARAMETERS           ',
    'JMP$GET_KEYBOARD_INPUT           ',
    'JMP$GET_MAX_SWAPPED_JOBS         ',
    'JMP$GET_NEXT_ENTRY               ',
    'JMP$GET_SCH_ATTR                 ',
    'JMP$GET_SWAPPED_JOBS_ATTR        ',
    'JMP$INITIALIZE_JOB_ENVIRONMENT   ',
    'JMP$INITIALIZE_JOB_LOCAL_TABLES  ',
    'JMP$INITIALIZE_JOB_SEQ_NUMBER    ',
    'JMP$INITIALIZE_JSN               ',
    'JMP$INITIALIZE_SCHED_RING_2      ',
    'JMP$INITIAL_JOB_BEGIN            ',
    'JMP$INSTALL_SYS_JOB_TEMPLATE     ',
    'JMP$INTERNAL_ROUTE               ',
    'JMP$JOB_BEGIN                    ',
    'JMP$JOB_END                      ',
    'JMP$JOB_FILE_FAP                 ',
    'JMP$JOB_SCHEDULER_ENTRY_POINT    ',
    'JMP$JOB_SCHED_ASYNC_ENTRY_PT     ',
    'JMP$JSN                          ',
    'JMP$KJL_RETHREAD                 ',
    'JMP$LIST_JOBS_VIA_MODE           ',
    'JMP$LOAD_JOB_TEMPLATE            ',
    'JMP$LOGOUT                       ',
    'JMP$MANAGE_AJL_KJL_LOCKS         ',
    'JMP$MANAGE_SENSE_SWITCHES        ',
    'JMP$MANAGE_SWAP_LIST_LOCK        ',
    'JMP$PRIORITY                     ',
    'JMP$PROCESS_JOB_REQUESTED_SWAP   ',
    'JMP$PROCESS_TERMINAL_WAIT        ',
    'JMP$PURGE_JOB_TEMPLATE_FILE      ',
    'JMP$QCOUNT_ALL                   ',
    'JMP$QCOUNT_FAMILY                ',
    'JMP$QCOUNT_OWNED                 ',
    'JMP$QSTATUS_ALL_FULL             ',
    'JMP$QSTATUS_FAMILY_FULL          ',
    'JMP$QSTATUS_FILE_FULL            ',
    'JMP$QSTATUS_OWNED_FULL           ',
    'JMP$QSTATUS_USER_FULL            ',
    'JMP$REBUILD_INPUT_QUEUE          ',
    'JMP$REBUILD_OUTPUT_QUEUE         ',
    'JMP$RECORD_TERMINAL_WAIT         ',
    'JMP$ROUTE                        ',
    'JMP$SAVE_JP_TS_TP_TEMPL          ',
    'JMP$SAVE_SCHEDULER_TASKID        ',
    'JMP$SAVE_SCHED_ASYNC_TASKID      ',
    'JMP$SAVE_SFID_OF_SWAP_FILE       ',
    'JMP$SAVE_TERMINATOR_TASKID       ',
    'JMP$SCHEDULER_TABLE_INITIALIZE   ',
    'JMP$SCHED_SWAPIN_JOB             ',
    'JMP$SCHED_SWAPOUT_JOB            ',
    'JMP$SCH_CHANGE_CAT               ',
    'JMP$SCH_CHANGE_JST               ',
    'JMP$SCH_CHANGE_SWAP_JOB          ',
    'JMP$SEND_SENSE_SWITCH_SIGNAL     ',
    'JMP$SET_ACCOUNT_PROJECT          ',
    'JMP$SET_JOB_MODE                 ',
    'JMP$SET_JOB_TEMPLATE_P           ',
    'JMP$SET_MAX_ACT_IN_CLASS_ATT     ',
    'JMP$SET_MAX_ACT_JOB_LIMITS       ',
    'JMP$SET_OPERATOR_ACTION          ',
    'JMP$SET_OPERATOR_INFO_POINTER    ',
    'JMP$SET_SCHED_FLAG               ',
    'JMP$SET_SWAPPING_CONTROL         ',
    'JMP$SET_SWAP_CONTROL_VARIABLE    ',
    'JMP$STATUS_OPERATOR_ACTION       ',
    'JMP$SWAPIN_BY_PRIORITY           ',
    'JMP$SWAPIN_JOB                   ',
    'JMP$SWAPOUT_JOB                  ',
    'JMP$SYSTEM_ERROR                 ',
    'JMP$SYSTEM_JOB                   ',
    'JMP$WORKING_SET_LOCALITY_SEARCH  ',
    'JMP$WRITE_ROUTE_LABEL            ',
    'JMV$AJL_P                        ',
    'JMV$AUTOMATIC_JOB_INIT           ',
    'JMV$CLASS_LIST                   ',
    'JMV$DEBUG_STATUS                 ',
    'JMV$EXECUTING_WITHIN_SYSTEM_JOB  ',
    'JMV$JCB                          ',
    'JMV$JMTR_XCB                     ',
    'JMV$JOB_CLASS_COUNTS             ',
    'JMV$JOB_SCHEDULER_TABLE          ',
    'JMV$JOB_SEQUENCE_NUMBER          ',
    'JMV$KEYBOARD_BUFFER              ',
    'JMV$KEYBOARD_BUFFER_LOCK         ',
    'JMV$KJL_P                        ',
    'JMV$MEMORY_QUEUE_UPDATE_BY_SWAP  ',
    'JMV$MX_JOBS                      ',
    'JMV$PERFORM_SYSTEM_DEADSTART     ',
    'JMV$SCHEDULER_FLAG               ',
    'JMV$SDT                          ',
    'JMV$SDTX                         ',
    'JMV$SSN_MASK                     ',
    'JMV$SWAPOUT_LIST_HEADER          ',
    'JMV$SYSTEM_CORE_TEMPLATE         ',
    'JMV$SYSTEM_JOB_TEMPLATE_P        ',
    'JMV$TASK_PRIVATE_TEMPL_P         ',
    'JMV$TEMPL_DESC                   ',
    'JMV$TOTAL_SWAPPED_JOBS           ',
    'JOBROOT                          ',
    'JOB_XCB_LIST                     ',
    'JSP$SWAP_JOB_IN                  ',
    'JSP$SWAP_JOB_OUT                 ',
    'JSV$ASIDS_REASSIGNED_ON_SWAPIN   ',
    'JSV$ASID_REASSIGNED_COUNT        ',
    'JSV$JOB_SWAPPING_CONTROL_BLOCK   ',
    'LGP$ADD_ENTRY_TO_ASCII_LOG       ',
    'LGP$ADD_ENTRY_TO_SYSTEM_LOG      ',
    'LGP$DISPLAY_LOG                  ',
    'LGP$DISPLAY_LOG_COMMAND          ',
    'LGP$DISPLAY_SYSTEM_LOG           ',
    'LGP$DISPLAY_SYSTEM_LOG_COMMAND   ',
    'LGP$GET_ENTRY_FROM_GLOBAL_LOG    ',
    'LGP$GET_ENTRY_FROM_LOCAL_LOG     ',
    'LGP$GET_GLOBAL_DESCRIPTOR        ',
    'LGP$INITIALIZE_GLOBAL_LOG_LCD    ',
    'LGP$INSTALL_GLOBAL_LOGS          ',
    'LGP$INTERCEPT_LOG_IO_REQUEST     ',
    'LGP$RECOVER_GLOBAL_LOGS          ',
    'LGP$SETUP_ACCESS_TO_LOCAL_LOGS   ',
    'LGP$SETUP_RECOVERY_LOGGING       ',
    'LGP$TERMINATE_LOG                ',
    'LGP$TERMINATE_LOG_COMMAND        ',
    'LGP$TERMINATE_LOG_PROCESSOR      ',
    'LGV$EXTERNAL_LOG_NAMES_ARRAY     ',
    'LGV$GLOBAL_LOG_CTL               ',
    'LGV$INTERNAL_LOG_NAMES_ARRAY     ',
    'LGV$LOCAL_LOG_CNTL_P             ',
    'LGV$LOCAL_LOG_CTL                ',
    'LOP$DEFIX_BINDING_SEGMENT_ATTR   ',
    'LOP$FIX_BINDING_SEGMENT_ATTR     ',
    'LOP$STORE_LINKAGE                ',
    'MANAGE_LOGICAL_CONFIGURATION     ',
    'MANAGE_PHYSICAL_CONFIGURATION    ',
    'MANLC                            ',
    'MANPC                            ',
    'MLP$ADD_SENDER                   ',
    'MLP$ADD_SENDER_OS                ',
    'MLP$CONFIRM_SEND                 ',
    'MLP$CONFIRM_SEND_OS              ',
    'MLP$DELETE_SENDER                ',
    'MLP$DELETE_SENDER_OS             ',
    'MLP$FETCH_LINK_PARTNER_INFO      ',
    'MLP$FETCH_LINK_PARTNER_INFO_OS   ',
    'MLP$FETCH_RECEIVE_LIST           ',
    'MLP$FETCH_RECEIVE_LIST_OS        ',
    'MLP$GET_HANDLER_INFO             ',
    'MLP$GET_HANDLER_INFO_OS          ',
    'MLP$HANDLE_SIGNAL                ',
    'MLP$HELP_C170                    ',
    'MLP$INITIALIZE                   ',
    'MLP$INITIALIZE_HELPER            ',
    'MLP$INVOKE_MLI_HELPER            ',
    'MLP$RECEIVE_MESSAGE              ',
    'MLP$RECEIVE_MESSAGE_OS           ',
    'MLP$REGISTER_SIGNAL_HANDLER      ',
    'MLP$REGISTER_SIGNAL_HANDLER_OS   ',
    'MLP$SEND_MESSAGE                 ',
    'MLP$SEND_MESSAGE_OS              ',
    'MLP$SIGN_OFF                     ',
    'MLP$SIGN_OFF_OS                  ',
    'MLP$SIGN_ON                      ',
    'MLP$SIGN_ON_OS                   ',
    'MLP$TASK_TERMINATION_CLEANUP     ',
    'MLV$170_COUNT                    ',
    'MLV$170_TIME                     ',
    'MLV$C170_RQST_BLK                ',
    'MLV$DEBUG                        ',
    'MLV$ENABLED                      ',
    'MLV$RB_READY_TASK                ',
    'MMP$ADD_SDT_SDTX_ENTRY           ',
    'MMP$ADVISE_IN                    ',
    'MMP$ADVISE_OUT                   ',
    'MMP$ADVISE_OUT_IN                ',
    'MMP$ASSIGN_DEVICE_TO_SEGMENT     ',
    'MMP$ASSIGN_STACK_TO_DISK         ',
    'MMP$CLOSE_SEGMENT                ',
    'MMP$CREATE_INHERITED_SDT         ',
    'MMP$CREATE_SCRATCH_SEGMENT       ',
    'MMP$CREATE_SEGMENT               ',
    'MMP$DELETE_SCRATCH_SEGMENT       ',
    'MMP$DELETE_SEGMENT               ',
    'MMP$DESELECT_SIGNAL_ON_PAGE_FLT  ',
    'MMP$FETCH_MAX_WS_SIZE            ',
    'MMP$FETCH_PVAS_OF_IMAGE_PAGES    ',
    'MMP$FETCH_PVA_UNWRITTEN_PAGES    ',
    'MMP$FETCH_SEGMENT_ATTRIBUTES     ',
    'MMP$FREE_PAGES                   ',
    'MMP$GET_DIS_HEADER_LINE          ',
    'MMP$GET_SEGMENT_LENGTH           ',
    'MMP$INT_SEGMENT_FAULT_HANDLER    ',
    'MMP$INVALIDATE_SEGMENT           ',
    'MMP$JOB_DELETE_INHERITED_SDT     ',
    'MMP$LOCK_PAGES                   ',
    'MMP$LOCK_SEGMENT                 ',
    'MMP$OPEN_FILE_SEGMENT            ',
    'MMP$OPEN_SEGMENT                 ',
    'MMP$PROCESS_DM_CALLS_FOR_SM      ',
    'MMP$RETRIEVE_RECOVERY_INFO       ',
    'MMP$SAVE_RECOVERY_INFORMATION    ',
    'MMP$SELECT_SIGNAL_ON_PAGE_FAULT  ',
    'MMP$SET_ACCESS_MODE              ',
    'MMP$SET_ACCESS_SELECTIONS        ',
    'MMP$SET_SEGMENT_LENGTH           ',
    'MMP$STORE_MAX_WS_SIZE            ',
    'MMP$STORE_SEGMENT_ATTRIBUTES     ',
    'MMP$TASK_DELETE_INHERITED_SDT    ',
    'MMP$UNLOCK_PAGES                 ',
    'MMP$UNLOCK_SEGMENT               ',
    'MMP$UPDATE_SDT_SDTX_ENTRY        ',
    'MMP$VALIDATE_SEGMENT_NUMBER      ',
    'MMP$VERIFY_ACCESS                ',
    'MMP$WRITE_ALL_SEGMENTS_TO_DISK   ',
    'MMP$WRITE_MODIFIED_PAGES         ',
    'MMV$AGGRESSIVE_AGING_LEVEL       ',
    'MMV$AGING_ALGORITHM              ',
    'MMV$AGING_STATISTICS             ',
    'MMV$ALLOCATION_SIZE              ',
    'MMV$AST_P                        ',
    'MMV$A_DIVISOR                    ',
    'MMV$A_MULT                       ',
    'MMV$BIG_SEGMENT                  ',
    'MMV$DEFAULT_SDTX_ENTRY           ',
    'MMV$FREE_QUEUE_THRESHOLD         ',
    'MMV$JWS_QUEUE_AGE_INTERVAL       ',
    'MMV$MAX_PAGES_NO_FILE            ',
    'MMV$MAX_WORKING_SET_SIZE         ',
    'MMV$MIN_PAGEABLE_PAGE_FRAMES     ',
    'MMV$MULTI_PAGE_WRITE             ',
    'MMV$NO_MEMORY_BUFFERING          ',
    'MMV$NUMBER_FREE_ASTES            ',
    'MMV$PAGEABLE_PAGE_FRAMES         ',
    'MMV$PERIODIC_CALL_INTERVAL       ',
    'MMV$PFT_P                        ',
    'MMV$PF_STATISTICS                ',
    'MMV$PF_SVA_ARRAY                 ',
    'MMV$PQL_P                        ',
    'MMV$PT_FULL                      ',
    'MMV$PT_LENGTH                    ',
    'MMV$PT_P                         ',
    'MMV$SHARED_QUEUE_AGE_INTERVAL    ',
    'MMV$TABLES_INITIALIZED           ',
    'MMV$TICK_TIME                    ',
    'MMV$TIME_TO_CALL_MEM_MGR         ',
    'MMV$TRANSFER_SIZE                ',
    'MMV$UNUSED_AGE_TABLE             ',
    'MMV$WRITE_AGED_OUT_PAGES         ',
    'MTV$CST1                         ',
    'MTV$CST2                         ',
    'MTV$DEADSTART_PANEL_SETTING      ',
    'MTV$DUE_LOG                      ',
    'MTV$HALT_CPU_RING_NUMBER         ',
    'MTV$HALT_ON_PROC_MALF            ',
    'MTV$MONITOR_EXCHANGE_PACKAGE     ',
    'MTV$MX_AJL_ENTRIES               ',
    'MTV$NOS_JPS                      ',
    'MTV$NOS_SEG_P                    ',
    'MTV$NST_P                        ',
    'MTV$NS_XP_P                      ',
    'MTV$PP_TABLE_P                   ',
    'MTV$REQUEST_TABLE                ',
    'MTV$SCB                          ',
    'MTV$SYS_CORE_INIT_COMPLETE       ',
    'MTV$TIME_TO_CHECK_SCB_STATUS     ',
    'MTV$TOTAL_NOS_CPU_TIME           ',
    'MTV$TRACE_BUFFER                 ',
    'MTV$XP_INITIAL_VALUE             ',
    'OFP$ACTION_MESSAGE_DISPLAY       ',
    'OFP$ALTER_DISPLAY                ',
    'OFP$CLEAR_DISPLAY_MESSAGE        ',
    'OFP$CLEAR_HEADER_MESSAGE         ',
    'OFP$CP_DISPLAY                   ',
    'OFP$DISPLAY_STATUS_MESSAGE       ',
    'OFP$DISPLAY_STATUS_MSG_HELPER    ',
    'OFP$EXECUTE_DISPLAY_TASK         ',
    'OFP$GET_DISPLAY_MESSAGE_HELPER   ',
    'OFP$GET_DISPLAY_STATUS_MESSAGE   ',
    'OFP$GET_FIRST_ACTION_MESSAGE     ',
    'OFP$GET_NEXT_ACTION_MESSAGE      ',
    'OFP$HANDLE_SIGNAL_PROCESSOR      ',
    'OFP$INITIALIZE_OPERATOR_FILES    ',
    'OFP$INTERNAL_K_FAP_CONTROL       ',
    'OFP$JOB_BEGIN                    ',
    'OFP$JOB_END                      ',
    'OFP$JOB_FILE_FAP                 ',
    'OFP$JOB_MONITOR_TASK             ',
    'OFP$K_FAP_CONTROL                ',
    'OFP$LOG_DISPLAY                  ',
    'OFP$RECEIVE_FROM_OPERATOR        ',
    'OFP$RECEIVE_FROM_OPERATOR_HELP   ',
    'OFP$REPLY_ACTION_SIGNAL_HELPER   ',
    'OFP$REPLY_TO_ACTION              ',
    'OFP$REPLY_TO_ACTION_HELPER       ',
    'OFP$REPORT_STATUS_ERROR          ',
    'OFP$SCREEN_MANAGER               ',
    'OFP$SEND_TO_OPERATOR             ',
    'OFP$SEND_TO_OPERATOR_HELPER      ',
    'OFP$SET_DISPLAY_MESSAGE          ',
    'OFP$SYSTEM_DISPLAY_MANAGER       ',
    'OFP$SYSTEM_HEADER_DISPLAY        ',
    'OFP$TASK_END                     ',
    'OFP$TASK_END_HELPER              ',
    'OFV$DISPLAY_MESSAGE_UPDATE       ',
    'OFV$HEADER_MESSAGE_UPDATE        ',
    'OFV$MESSAGE_STRUCTURE_HEAP       ',
    'OSP$APPEND_STATUS_INTEGER        ',
    'OSP$APPEND_STATUS_PARAMETER      ',
    'OSP$AWAIT_ACTIVITY               ',
    'OSP$AWAIT_ACTIVITY_COMPLETION    ',
    'OSP$BEGIN_SYSTEM_ACTIVITY        ',
    'OSP$BEGIN_TEXT_DUMP              ',
    'OSP$BROKEN_JOB_DUMP_TASK         ',
    'OSP$CHECK_SYSTEM_DEBUG           ',
    'OSP$CLEAR_SIGNATURE_LOCK         ',
    'OSP$DUMP_BROKEN_TASK             ',
    'OSP$DUMP_TASK                    ',
    'OSP$END_SYSTEM_ACTIVITY          ',
    'OSP$END_TEXT_DUMP                ',
    'OSP$FETCH_STATISTICAL_DATA       ',
    'OSP$FETCH_SYSTEM_CONSTANT        ',
    'OSP$FORMAT_MESSAGE               ',
    'OSP$GENERATE_ERROR_MESSAGE       ',
    'OSP$GENERATE_LOG_MESSAGE         ',
    'OSP$GENERATE_MESSAGE             ',
    'OSP$GET_MESSAGE_LEVEL            ',
    'OSP$GET_STATUS_CONDITION_STRING  ',
    'OSP$GET_STATUS_MESSAGE_BY_CODE   ',
    'OSP$GET_STATUS_SEVERITY          ',
    'OSP$INITIALIZE_SIGNATURE_LOCK    ',
    'OSP$JOB_TEMPLATE_INIT_PH1        ',
    'OSP$JOB_TEMPLATE_INIT_PH2        ',
    'OSP$JOB_TEMPLATE_INIT_PH3        ',
    'OSP$NOS_TRAP_HANDLER             ',
    'OSP$OUTPUT_DEBUG_TEXT            ',
    'OSP$PROCESS_INIT_ERROR           ',
    'OSP$PROCESS_SYSTEM_DEBUG         ',
    'OSP$RECOVERABLE_SYSTEM_ERROR     ',
    'OSP$RESET_HEAP                   ',
    'OSP$SET_MESSAGE_LEVEL            ',
    'OSP$SET_SIGNATURE_LOCK           ',
    'OSP$SET_STATUS_ABNORMAL          ',
    'OSP$SET_STATUS_FROM_CONDITION    ',
    'OSP$STORE_SYSTEM_CONSTANT        ',
    'OSP$SYSTEM_ERROR                 ',
    'OSP$TERMINATE_SYSTEM             ',
    'OSP$TERMINATE_SYSTEM_JOB         ',
    'OSP$TEST_SIGNATURE_LOCK          ',
    'OSV$180_MEMORY_LIMITS            ',
    'OSV$ADTT_PTR                     ',
    'OSV$BASE_SYSTEM_TIME             ',
    'OSV$BROKEN_JOB_BUFFER            ',
    'OSV$BROKEN_JOB_DUMPER_GTID       ',
    'OSV$BROKEN_JOB_DUMP_LOCK         ',
    'OSV$BROKEN_JOB_GTID              ',
    'OSV$BROKEN_JOB_SEGMENT_ARRAY     ',
    'OSV$CONFIGURATION_PROLOG_NAME    ',
    'OSV$CTI_PARAMETERS               ',
    'OSV$DEADSTART_PHASE              ',
    'OSV$DEFAULT_SIT_VALUE            ',
    'OSV$DEFAULT_SYSTEM_DATE_FORMAT   ',
    'OSV$DEFAULT_SYSTEM_TIME_FORMAT   ',
    'OSV$EQUAL_PRIORITY_SUBPRIORITY   ',
    'OSV$ERROR_IDLE_HALT              ',
    'OSV$IMAGE_FILE_ADTT_PTR          ',
    'OSV$INITIALIZATION_PROLOG_NAME   ',
    'OSV$JOB_FIXED_HEAP               ',
    'OSV$LEFT_BUFFER                  ',
    'OSV$LOWER_TO_UPPER               ',
    'OSV$MAINFRAME_PAGEABLE_HEAP      ',
    'OSV$MAINFRAME_WIRED_HEAP         ',
    'OSV$OPERATING_MODE               ',
    'OSV$OPERATOR_INTERVENTION        ',
    'OSV$PAGE_SIZE                    ',
    'OSV$PP_ADDRESS_ARRAY             ',
    'OSV$PP_CONSOLE_INPUT             ',
    'OSV$RIGHT_BUFFER                 ',
    'OSV$SPAA                         ',
    'OSV$TASK_PRIVATE_HEAP            ',
    'OSV$TASK_SHARED_HEAP             ',
    'OSV$TEMPLATE_ARRAY_160000_P      ',
    'OSV$TEMPLATE_ARRAY_170000_P      ',
    'OSV$TEMPLATE_ARRAY_180000_P      ',
    'OSV$TEMPLATE_ARRAY_190000_P      ',
    'OSV$TEMPLATE_ARRAY_200000_P      ',
    'OSV$TEMPLATE_ARRAY_210000_P      ',
    'OSV$TEMPLATE_ARRAY_220000_P      ',
    'OSV$TEMPLATE_ARRAY_230000_P      ',
    'OSV$TEMPLATE_ARRAY_240000_P      ',
    'OSV$TEMPLATE_ARRAY_250000_P      ',
    'OSV$TEMPLATE_ARRAY_260000_P      ',
    'OSV$TEMPLATE_ARRAY_270000_P      ',
    'OSV$TEMPLATE_ARRAY_280000_P      ',
    'OSV$TEMPLATE_ARRAY_290000_P      ',
    'OSV$TEMPLATE_ARRAY_320000_P      ',
    'OSV$TEMPLATE_ARRAY_340000_P      ',
    'OSV$TEMPLATE_ARRAY_570000_P      ',
    'OSV$TPH_LENGTH                   ',
    'OSV$TSH_LENGTH                   ',
    'OSV$UPPER_TO_LOWER               ',
    'PERFORM_PHYSICAL_SWAPOUT         ',
    'PERFORM_STATE_TRANSITIONS        ',
    'PFP$ATTACH                       ',
    'PFP$CHANGE                       ',
    'PFP$DEFINE                       ',
    'PFP$DEFINE_CATALOG               ',
    'PFP$DEFINE_DATA                  ',
    'PFP$DEFINE_MASTER_CATALOG        ',
    'PFP$DELETE_CATALOG_PERMIT        ',
    'PFP$DELETE_PERMIT                ',
    'PFP$FIND_CATALOG_DESCRIPTION     ',
    'PFP$FIND_CYCLE_ARRAY             ',
    'PFP$FIND_CYCLE_ENTRY             ',
    'PFP$FIND_DIRECTORY_ARRAY         ',
    'PFP$FIND_DIRECT_INFO_RECORD      ',
    'PFP$FIND_FILE_DESCRIPTION        ',
    'PFP$FIND_LOG_ARRAY               ',
    'PFP$FIND_NEXT_INFO_RECORD        ',
    'PFP$FIND_PERMIT_ARRAY            ',
    'PFP$GET_FAMILY_INFO              ',
    'PFP$GET_ITEM_INFO                ',
    'PFP$GET_MASTER_CATALOG_INFO      ',
    'PFP$GET_MULTI_ITEM_INFO          ',
    'PFP$PERMIT                       ',
    'PFP$PERMIT_CATALOG               ',
    'PFP$PROCESS_UNEXPECTED_STATUS    ',
    'PFP$PURGE                        ',
    'PFP$PURGE_CATALOG                ',
    'PFP$PURGE_MASTER_CATALOG         ',
    'PFP$PUT_CYCLE_INFO               ',
    'PFP$PUT_FAMILY_INFO              ',
    'PFP$PUT_ITEM_INFO                ',
    'PFP$PUT_MASTER_CATALOG_INFO      ',
    'PFP$R2_ATTACH                    ',
    'PFP$R2_CHANGE                    ',
    'PFP$R2_DEFINE                    ',
    'PFP$R2_DEFINE_CATALOG            ',
    'PFP$R2_DEFINE_DATA               ',
    'PFP$R2_DEFINE_MASTER_CATALOG     ',
    'PFP$R2_DELETE_CATALOG_PERMIT     ',
    'PFP$R2_DELETE_PERMIT             ',
    'PFP$R2_GET_FAMILY_INFO           ',
    'PFP$R2_GET_ITEM_INFO             ',
    'PFP$R2_GET_MASTER_CATALOG_INFO   ',
    'PFP$R2_GET_MULTI_ITEM_INFO       ',
    'PFP$R2_PERMIT                    ',
    'PFP$R2_PERMIT_CATALOG            ',
    'PFP$R2_PURGE                     ',
    'PFP$R2_PURGE_CATALOG             ',
    'PFP$R2_PURGE_MASTER_CATALOG      ',
    'PFP$R2_PUT_CYCLE_INFO            ',
    'PFP$R2_PUT_FAMILY_INFO           ',
    'PFP$R2_PUT_ITEM_INFO             ',
    'PFP$R2_PUT_MASTER_CATALOG_INFO   ',
    'PFP$R2_RECOVER_SET               ',
    'PFP$R2_REORGANIZE_CATALOG        ',
    'PFP$R2_REORGANIZE_SET_CATALOGS   ',
    'PFP$R2_SPECIAL_ATTACH            ',
    'PFP$R2_VALIDATE_CATALOG          ',
    'PFP$R2_VALIDATE_SET_CATALOGS     ',
    'PFP$R3_ATTACH                    ',
    'PFP$R3_SPECIAL_ATTACH            ',
    'PFP$RECOVER_SET                  ',
    'PFP$REORGANIZE_CATALOG           ',
    'PFP$REORGANIZE_SET_CATALOGS      ',
    'PFP$SPECIAL_ATTACH               ',
    'PFP$VALIDATE_CATALOG             ',
    'PFP$VALIDATE_SET_CATALOGS        ',
    'PMP$ABORT                        ',
    'PMP$ACQUIRE_RAW_TASK_STATISTICS  ',
    'PMP$ACTIVATE_RING_ALARM          ',
    'PMP$AWAIT_TASK                   ',
    'PMP$AWAIT_TASK_TERMINATION       ',
    'PMP$BINARY_TO_ASCII              ',
    'PMP$CAUSE_CONDITION              ',
    'PMP$CHANGE_BINARY_TO_ALPHA_DATE  ',
    'PMP$CHANGE_BINARY_TO_ALPHA_TIME  ',
    'PMP$CHANGE_DEBUG_LIBRARY_LIST    ',
    'PMP$CHANGE_DEFAULT_PROG_OPTIONS  ',
    'PMP$CHANGE_JOB_LIBRARY_LIST      ',
    'PMP$CLEANUP_LOADED_RINGS         ',
    'PMP$CLOSE_COMMON_BLOCK_FILE      ',
    'PMP$COLLECT_RAW_TASK_STATISTICS  ',
    'PMP$COMPUTE_DATE_TIME            ',
    'PMP$CONNECT_QUEUE                ',
    'PMP$CONTINUE_TO_CAUSE            ',
    'PMP$CREATE_CHILD_XCB             ',
    'PMP$CREATE_TASK_ENVIRONMENT      ',
    'PMP$CYCLE                        ',
    'PMP$DEBUG_ABORT_FILE_SPECIFIED   ',
    'PMP$DEBUG_CRITICAL_FRAME         ',
    'PMP$DEFINE_DEBUG_ENTRY           ',
    'PMP$DEFINE_QUEUE                 ',
    'PMP$DEFINE_SIGNAL_HANDLER        ',
    'PMP$DEFINE_SYSTEM_FLAG_HANDLER   ',
    'PMP$DELAY                        ',
    'PMP$DELETE_CURRENT_ENVIRONMENT   ',
    'PMP$DELETE_ENVIRONMENT           ',
    'PMP$DELETE_NON_INHERITED_SEGS    ',
    'PMP$DETERMINE_PIT_SET            ',
    'PMP$DISCONNECT_QUEUE             ',
    'PMP$DISESTABLISH_COND_HANDLER    ',
    'PMP$DISESTABLISH_END_HANDLER    ',
    'PMP$ENABLE_JOB_FREE_FLAG         ',
    'PMP$ENABLE_SYSTEM_CONDITIONS     ',
    'PMP$ESTABLISH_CH_IN_BLOCK        ',
    'PMP$ESTABLISH_CONDITION_HANDLER  ',
    'PMP$ESTABLISH_DEBUG_CFF          ',
    'PMP$ESTABLISH_END_HANDLER        ',
    'PMP$EXECUTE                      ',
    'PMP$EXECUTE_TASK                 ',
    'PMP$EXECUTE_WITH_APD             ',
    'PMP$EXECUTE_WITH_LESS_PRIVILEGE  ',
    'PMP$EXIT                         ',
    'PMP$FIND_BEGIN_DEBUG             ',
    'PMP$FIND_DEBUG                   ',
    'PMP$FIND_END_DEBUG               ',
    'PMP$FIND_ENTRY_POINT_ADDRESS     ',
    'PMP$FIND_ENTRY_POINT_IN_LIBRARY  ',
    'PMP$FIND_EXECUTING_TASK_TCB      ',
    'PMP$FIND_EXECUTING_TASK_XCB      ',
    'PMP$FIND_STACK_SEGMENT           ',
    'PMP$FIND_TASK_TCB                ',
    'PMP$FIND_TASK_XCB                ',
    'PMP$FIX_INITIAL_DEBUG            ',
    'PMP$FORMAT_COMPACT_DATE          ',
    'PMP$FORMAT_COMPACT_TIME          ',
    'PMP$GENERATE_UNIQUE_NAME         ',
    'PMP$GET_ACCOUNT_PROJECT          ',
    'PMP$GET_BINARY_DATE_AND_TIME     ',
    'PMP$GET_COMMON_BLOCK_INFO        ',
    'PMP$GET_COMPACT_DATE_TIME        ',
    'PMP$GET_CURRENT_ENVIRONMENT      ',
    'PMP$GET_DATE                     ',
    'PMP$GET_DEBUG_ABORT_FILE         ',
    'PMP$GET_DEBUG_ENTRY              ',
    'PMP$GET_DEBUG_ENVIRONMENT        ',
    'PMP$GET_DEBUG_ID                 ',
    'PMP$GET_DEBUG_INPUT_FILE         ',
    'PMP$GET_DEBUG_LIBRARY_LIST       ',
    'PMP$GET_DEBUG_OUTPUT_FILE        ',
    'PMP$GET_DEFAULT_PROGRAM_OPTIONS  ',
    'PMP$GET_DELAYED_CONDITION        ',
    'PMP$GET_ENTRY_POINT_DICTIONARY   ',
    'PMP$GET_EXECUTING_TASK_GTID      ',
    'PMP$GET_JOB_LIBRARY_LIST         ',
    'PMP$GET_JOB_MODE                 ',
    'PMP$GET_JOB_NAMES                ',
    'PMP$GET_LAST_PATH_NAME           ',
    'PMP$GET_LEGIBLE_DATE_TIME        ',
    'PMP$GET_MICROSECOND_CLOCK        ',
    'PMP$GET_NUMBER_OF_DEBUG_LIBS     ',
    'PMP$GET_NUMBER_OF_JOB_LIBRARIES  ',
    'PMP$GET_OS_VERSION               ',
    'PMP$GET_PROCESSOR_ATTRIBUTES     ',
    'PMP$GET_PROGRAM_DESCRIPTION      ',
    'PMP$GET_PROGRAM_SIZE             ',
    'PMP$GET_QUEUE_LIMITS             ',
    'PMP$GET_SRUS                     ',
    'PMP$GET_SYSTEM_TIME              ',
    'PMP$GET_TASK_CP_TIME             ',
    'PMP$GET_TASK_ID                  ',
    'PMP$GET_TASK_JOBMODE_STATISTICS  ',
    'PMP$GET_TERMINATION_STATUS       ',
    'PMP$GET_TIME                     ',
    'PMP$GET_USER_IDENTIFICATION      ',
    'PMP$INHIBIT_SYSTEM_CONDITIONS    ',
    'PMP$INITIALIZE_JOB_XCB_LIST      ',
    'PMP$INITIALIZE_TASKING_TABLES    ',
    'PMP$INITIAL_DEBUG_MODE_ON        ',
    'PMP$INITIATE_CHILD_TASK          ',
    'PMP$JOB_DEBUG_RING               ',
    'PMP$LOAD                         ',
    'PMP$LOAD_DEBUG_PROCEDURES        ',
    'PMP$LOAD_ENTRY_POINT             ',
    'PMP$LOAD_MODULE_FROM_LIBRARY     ',
    'PMP$LOG                          ',
    'PMP$LOG_ASCII                    ',
    'PMP$LONG_TERM_WAIT               ',
    'PMP$MANAGE_SENSE_SWITCHES        ',
    'PMP$MODIFY_DEBUG_ENTRY           ',
    'PMP$OPEN_COMMON_BLOCK_FILE      ',
    'PMP$POP_TASK_DEBUG_MODE          ',
    'PMP$POSITION_OBJECT_LIBRARY      ',
    'PMP$POST_CURRENT_ENVIRONMENT     ',
    'PMP$POST_DEBUG_ENVIRONMENT       ',
    'PMP$POST_DELAYED_CONDITION       ',
    'PMP$PUSH_TASK_DEBUG_MODE         ',
    'PMP$READY_TASK                   ',
    'PMP$RECEIVE_FROM_QUEUE           ',
    'PMP$RECEIVE_QUEUE_MESSAGE        ',
    'PMP$RECORD_PROGRAM_TERMINATION   ',
    'PMP$RECORD_TASK_NAME             ',
    'PMP$RELEASE_CHILD_XCB            ',
    'PMP$RELEASE_TASK_ENVIRONMENT     ',
    'PMP$REMOVE_DEBUG_ENTRY           ',
    'PMP$REMOVE_QUEUE                 ',
    'PMP$RESET_DEBUG_SCAN             ',
    'PMP$REVOKE_PROGRAM_TERMINATION   ',
    'PMP$SEND_SIGNAL                  ',
    'PMP$SEND_TO_QUEUE                ',
    'PMP$SET_DEBUG_ENDING             ',
    'PMP$SET_JOB_DEBUG_RING           ',
    'PMP$SET_PROCESS_INTERVAL_TIMER   ',
    'PMP$SET_SPY_IDENTIFIER           ',
    'PMP$SET_SYSTEM_FLAG              ',
    'PMP$SET_TASK_DEBUG_MODE          ',
    'PMP$SET_TASK_DEBUG_RING          ',
    'PMP$STATUS_QUEUE                 ',
    'PMP$STATUS_QUEUES_DEFINED        ',
    'PMP$TASK_DEBUG_MODE_ON           ',
    'PMP$TASK_DEBUG_RING              ',
    'PMP$TASK_END                     ',
    'PMP$TASK_STATE                   ',
    'PMP$TERMINATE                    ',
    'PMP$TEST_CONDITION_HANDLER       ',
    'PMP$THIS_IS_A_LEAP_YEAR          ',
    'PMP$UPDATE_TOS_RING_1            ',
    'PMP$UPDATE_TOS_RING_3            ',
    'PMP$VALIDATE_PREVIOUS_SAVE_AREA  ',
    'PMP$VERIFY_COMPACT_DATE          ',
    'PMP$VERIFY_COMPACT_TIME          ',
    'PMP$WAIT                         ',
    'PMP$ZERO_OUT_TABLE               ',
    'PMV$JOB_INITIALIZATION_COMPLETE  ',
    'PMV$OS_NAME                      ',
    'PMV$QUANTUM                      ',
    'PMV$TASK_TEMPLATE                ',
    'PPCOMM                           ',
    'PPDISVEC                         ',
    'P_FDE                            ',
    'P_OLD_FDE                        ',
    'QFP$ACQUIRE                      ',
    'QFP$ACQUIRE_ALL                  ',
    'QFP$ACQUIRE_COMPLETE             ',
    'QFP$ALTER_QFILE                  ',
    'QFP$ALTER_QJOB                   ',
    'QFP$COUNT_ALL_FILES              ',
    'QFP$COUNT_ALL_JOBS               ',
    'QFP$COUNT_FAMILY_FILES           ',
    'QFP$COUNT_FAMILY_JOBS            ',
    'QFP$COUNT_OWNED_FILES            ',
    'QFP$COUNT_OWNED_JOBS             ',
    'QFP$DIVERT_FAMILY_JOBS           ',
    'QFP$DIVERT_FAMILY_OUTPUTS        ',
    'QFP$DIVERT_OWNED_JOBS            ',
    'QFP$DIVERT_OWNED_OUTPUTS         ',
    'QFP$DIVERT_QFILE                 ',
    'QFP$DIVERT_QJOB                  ',
    'QFP$DROP_QFILE                   ',
    'QFP$DROP_QJOB                    ',
    'QFP$FILENAME_TO_SSN              ',
    'QFP$GET_JOB_INTERNAL_INFO        ',
    'QFP$INPUT_ROUTE                  ',
    'QFP$INTERNAL_INPUT_ROUTE         ',
    'QFP$JOBNAME_TO_SSN               ',
    'QFP$KJL_MASTER_SEARCH            ',
    'QFP$KJL_RETHREAD                 ',
    'QFP$LIST_JOBS_VIA_MODE           ',
    'QFP$OUTPUT_ROUTE                 ',
    'QFP$READ_MY_ROUTE_DESCRIPTOR     ',
    'QFP$REBUILD_INPUT_QUEUE          ',
    'QFP$REBUILD_OUTPUT_QUEUE         ',
    'QFP$SET_AJL_STATUS               ',
    'QFP$STATUS_ALL_JOBS              ',
    'QFP$STATUS_ALL_OUTPUTS           ',
    'QFP$STATUS_FAMILY_JOBS           ',
    'QFP$STATUS_FAMILY_OUTPUTS        ',
    'QFP$STATUS_FILES                 ',
    'QFP$STATUS_JOBS                  ',
    'QFP$STATUS_OWNED_JOBS            ',
    'QFP$STATUS_OWNED_OUTPUTS         ',
    'QFP$UNLINK_AJL_KJL               ',
    'RESTORE_JOB_ENVIRONMENT          ',
    'RHP$LINK_USER_DESCRIPTOR_SAVED   ',
    'RHP$MLI_GET_PERMANENT_FILE       ',
    'RHP$MLI_REPLACE_PERMANENT_FILE   ',
    'RHP$OVERRIDE_FILE_ATTRIBUTES     ',
    'RHP$SAVE_LINK_USER_DESCRIPTION   ',
    'RHV$LINK_USER_CURRENT_FAMILY     ',
    'RHV$LINK_USER_DESCRIPTOR_P       ',
    'RHV$SIGNAL                       ',
    'RMP$GET_DEVICE_CLASS             ',
    'RMP$REQUEST_MASS_STORAGE         ',
    'RMP$REQUEST_NULL_DEVICE          ',
    'RMP$REQUEST_TAPE                 ',
    'RMP$REQUEST_TERMINAL             ',
    'SCAN_AJL_FOR_SWAP_CONDITIONS     ',
    'SCITOII                          ',
    'SET_AJL_SWAP_STATUS              ',
    'SFP$CHANGE_ROUTING_CONTROL       ',
    'SFP$CREATE_ROUTING_CONTROL       ',
    'SFP$DELETE_ROUTING_CONTROL       ',
    'SFP$DISABLE_GLOBAL_STATISTIC     ',
    'SFP$DISABLE_LOCAL_STATISTIC      ',
    'SFP$DISABLE_STATISTIC            ',
    'SFP$DISABLE_SYSTEM_STATISTIC     ',
    'SFP$DISESTABLISH_GLOBAL_STAT     ',
    'SFP$DISESTABLISH_LOCAL_STAT      ',
    'SFP$DISESTABLISH_STATISTIC       ',
    'SFP$DISESTABLISH_SYSTEM_STAT     ',
    'SFP$EMIT_GLOBAL_STATISTIC        ',
    'SFP$EMIT_LOCAL_STATISTIC         ',
    'SFP$EMIT_STATISTIC               ',
    'SFP$EMIT_SYSTEM_STATISTIC        ',
    'SFP$ENABLE_GLOBAL_STATISTIC      ',
    'SFP$ENABLE_LOCAL_STATISTIC       ',
    'SFP$ENABLE_ROUTING_CONTROLS      ',
    'SFP$ENABLE_STATISTIC             ',
    'SFP$ENABLE_SYSTEM_STATISTIC      ',
    'SFP$ESTABLISH_GLOBAL_STATISTIC   ',
    'SFP$ESTABLISH_LOCAL_STATISTIC    ',
    'SFP$ESTABLISH_STATISTIC          ',
    'SFP$ESTABLISH_SYSTEM_STATISTIC   ',
    'SFP$GET_ROUTING_CONTROLS         ',
    'SFP$INITIALIZE_GLOBAL_STATS      ',
    'SFP$INITIALIZE_ROUTING_CONTROL   ',
    'SFP$SAVE_LRCT_POINTER            ',
    'SFP$SETUP_ACCESS_TO_LOCAL_STATS  ',
    'SFV$LOCAL_ROUTING_CONTROL_TABLE  ',
    'SRP$CONVERSION_SERVICE_MANAGER   ',
    'SRP$FETCH_SYSTEM_LABEL           ',
    'SRP$FETCH_SYSTEM_LABEL_SIZE      ',
    'SRP$RECORD_CONVERSION_MANAGER    ',
    'SRP$STORE_SYSTEM_LABEL           ',
    'SSR_SHAPE                        ',
    'STP$ADD_MEMBER_IN_AST            ',
    'STP$ADD_MEMBER_IN_MASTER_VST     ',
    'STP$ADD_MEMBER_VOL_TO_SET        ',
    'STP$ATTACH_VST                   ',
    'STP$BUILD_MEMBER_LIST_LOCATOR    ',
    'STP$BUILD_MEMBER_LIST_POINTER    ',
    'STP$BUILD_MEMBER_VST             ',
    'STP$BUILD_PF_ROOT_LOCATOR        ',
    'STP$BUILD_PF_ROOT_POINTER        ',
    'STP$CHANGE_ACCESS_TO_SET         ',
    'STP$CHANGE_AST_ACCESS_STATUS     ',
    'STP$CLEAR_AST_PF_LOCK            ',
    'STP$CLEAR_EXCLUSIVE_ACCESS       ',
    'STP$CLEAR_PF_LOCK                ',
    'STP$CLEAR_READ_ACCESS            ',
    'STP$CREATE_AST_ENTRY             ',
    'STP$CREATE_SET                   ',
    'STP$CREATE_VST                   ',
    'STP$DEALLOCATE_AST_ENTRY         ',
    'STP$DECREMENT_JOB_USE_IN_AST     ',
    'STP$DESTROY_VST                  ',
    'STP$DETACH_VST                   ',
    'STP$DISK_VOLUME_ACTIVE           ',
    'STP$DISK_VOLUME_INACTIVE         ',
    'STP$DM_CHECK_IF_FILES_ON_VOL     ',
    'STP$DM_MOUNT_VOLUME              ',
    'STP$DM_STORE_SET_ORDINAL         ',
    'STP$FILL_MASTER_VST              ',
    'STP$GET_ACTIVE_SET_LIST          ',
    'STP$GET_JOBS_SCRATCH_VOLUMES     ',
    'STP$GET_PF_ACTIVE_SET_ENTRY      ',
    'STP$GET_PF_ROOT                  ',
    'STP$GET_PF_ROOT_SIZE             ',
    'STP$GET_SET_OWNER                ',
    'STP$GET_UNUSED_ENTRY_IN_AST      ',
    'STP$GET_UNUSED_MEL_ENTRY         ',
    'STP$GET_VOLUMES_BY_AST_INDEX     ',
    'STP$GET_VOLUMES_BY_SET_ORDINAL   ',
    'STP$GET_VOLUMES_IN_SET           ',
    'STP$GET_VOLUMES_SET_NAME         ',
    'STP$INACTIVATE_MASTER            ',
    'STP$INACTIVATE_MEMBER            ',
    'STP$INCREMENT_JOB_COUNT_IN_AST   ',
    'STP$INITIALIZE_SETS              ',
    'STP$INSERT_MEMBER_INTO_MEL       ',
    'STP$IS_VOLUME_IN_SET             ',
    'STP$MEMBERS_ACTIVE_ON_SET        ',
    'STP$MEMBERS_INACTIVE_ON_SET      ',
    'STP$MEMBERS_ON_SET               ',
    'STP$OBTAIN_AST_ENTRY             ',
    'STP$OBTAIN_AST_MEMBER_LIST       ',
    'STP$OBTAIN_AST_PF_ROOT           ',
    'STP$OBTAIN_AST_SIZE              ',
    'STP$OBTAIN_MASTER_VST_INFO       ',
    'STP$OBTAIN_MEMBER_VST_INFO       ',
    'STP$OBTAIN_VST_HEADER            ',
    'STP$OBTAIN_VST_PF_ROOT           ',
    'STP$OPEN_ATTACHED_VST            ',
    'STP$OPEN_VST                     ',
    'STP$PURGE_AST_PF_ROOT            ',
    'STP$PURGE_PF_ROOT                ',
    'STP$PURGE_SET                    ',
    'STP$PURGE_VST_PF_ROOT            ',
    'STP$REMOVE_MEMBER_FROM_MASTER    ',
    'STP$REMOVE_MEMBER_FROM_MEL       ',
    'STP$REMOVE_MEMBER_VOL_FROM_SET   ',
    'STP$REMOVE_SET_FROM_AST          ',
    'STP$REMOVE_SET_FROM_VST          ',
    'STP$REQUEST_DM_VOLUME_INFO       ',
    'STP$RETURN_OPENED_VST            ',
    'STP$RING2_ADD_MEMBER             ',
    'STP$RING2_CREATE_SET             ',
    'STP$RING2_PURGE_SET              ',
    'STP$RING2_REMOVE_MEMBER          ',
    'STP$SEARCH_AST_BY_SET            ',
    'STP$SEARCH_AST_BY_UNIQUE_SET     ',
    'STP$SEARCH_AST_BY_VOLUME         ',
    'STP$SEARCH_JAST_FOR_SET          ',
    'STP$SEARCH_MEL_FOR_VOL           ',
    'STP$SEARCH_MEMBER_LIST           ',
    'STP$SEARCH_MVL_FOR_UNUSED_ENTRY  ',
    'STP$SET_AST_PF_LOCK              ',
    'STP$SET_END_JOB                  ',
    'STP$SET_EXCLUSIVE_ACCESS         ',
    'STP$SET_PF_LOCK                  ',
    'STP$SET_READ_ACCESS              ',
    'STP$STORE_AST_MASTER_HEADER      ',
    'STP$STORE_AST_PF_ROOT            ',
    'STP$STORE_DM_PACKET_IN_MASTER    ',
    'STP$STORE_DM_PACKET_IN_MEL       ',
    'STP$STORE_DM_PACKET_IN_MVL       ',
    'STP$STORE_INACTIVE_MASTER        ',
    'STP$STORE_MASTER_DM_PACKET       ',
    'STP$STORE_MEMBER_DM_PACKET       ',
    'STP$STORE_PF_ROOT                ',
    'STP$STORE_VST_BEING_MODIFIED     ',
    'STP$STORE_VST_PF_ROOT            ',
    'SYP$ADVISED_MOVE_BYTES           ',
    'SYP$CHECK_FOR_KEYPOINT_CLASS     ',
    'SYP$CLEANUP_KEYPOINT_PROCESSING  ',
    'SYP$COLLECT_SOFTWARE_KEYPOINTS   ',
    'SYP$CONVERSION_SERVICES          ',
    'SYP$ENABLE_JOB_FREE_FLAG         ',
    'SYP$END_KEYPOINT_COLLECTING      ',
    'SYP$FETCH_SYSTEM_CONSTANT        ',
    'SYP$INITIALIZE_JT_PTR_ARRAY      ',
    'SYP$INITIALIZE_KEYPOINT          ',
    'SYP$INITIATE_PMF_ACTIVITY        ',
    'SYP$INVOKE_SYSTEM_DEBUGGER       ',
    'SYP$PUT_ASCII                    ',
    'SYP$RETURN_JOBS_R1_RESOURCES     ',
    'SYP$SET_PROCESS_INTERVAL_TIMER   ',
    'SYP$STORE_SYSTEM_CONSTANT        ',
    'SYP$TERMINATE_SYSTEM_CORE        ',
    'SYP$TURN_KEYPOINT_ON             ',
    'SYP$UPDATE_DEADSTART_STATUS      ',
    'SYV$ACTIVE_KEYPOINT_COUNT        ',
    'SYV$ASCII_CONSOLE_BUFFER         ',
    'SYV$DEBUG_CONTROL                ',
    'SYV$DEBUG_DISPLAY_ID             ',
    'SYV$DEFAULT_KEYPOINT_MASK        ',
    'SYV$HARDWARE_KEYPOINT_COUNT      ',
    'SYV$INHIBIT_KEYBOARD_INPUT       ',
    'SYV$JOB_KCB_P_OFFSET             ',
    'SYV$NOS_SYSTEM_TIME              ',
    'SYV$PMF_CB_RM_WORD_ADDRESS       ',
    'SYV$SYSTEM_KCB_P                 ',
    'SYV$USEIP_DEFINED_FROM_FILE      ',
    'TMP$ALLOCATE_EXECUTION_RINGS     ',
    'TMP$CLEAR_SYSTEM_FLAG            ',
    'TMP$CLEAR_WAIT_INHIBITED         ',
    'TMP$DISABLE_SIGNALS_FLAGS        ',
    'TMP$DISPOSE_OF_RING2_FLAGS       ',
    'TMP$DISPOSE_OF_RING2_SIGNALS     ',
    'TMP$DISPOSE_PREEMPTIVE_COMMO     ',
    'TMP$ENABLE_PREEMPTIVE            ',
    'TMP$ENABLE_PREEMPTIVE_COMMO      ',
    'TMP$FETCH_JOB_STATISTICS         ',
    'TMP$FIND_FLAG_TO_PROCESS         ',
    'TMP$FIND_MAINFRAME_SIGNAL        ',
    'TMP$FIND_MONITOR_FAULT           ',
    'TMP$FIND_SIGNAL                  ',
    'TMP$GET_MONITOR_FAULT            ',
    'TMP$GET_SIGNAL                   ',
    'TMP$POST_MAINFRAME_SIGNAL        ',
    'TMP$POST_MONITOR_FAULT_SFSA      ',
    'TMP$READY_SYSTEM_TASK            ',
    'TMP$SAVE_SYSTEM_TASK_ID          ',
    'TMP$SET_FLAG_INTERVAL            ',
    'TMP$WAIT                         ',
    'TMV$DCT                          ',
    'TMV$HALT_ON_HUNG_TASK            ',
    'TMV$PTL_P                        ',
    'TMV$SCHEDULER_GLOBAL_TASK_ID     ',
    'TMV$SYSTEM_DEBUG_RING            ',
    'TMV$SYSTEM_ERROR_HANG_COUNT      ',
    'UUTL                             '];
?? POP ??


?? FMT (FORMAT := ON) ??
?? OLDTITLE ??
?? NEWTITLE := '  INITIALIZE_LOADER_ENVIRONMENT', EJECT ??

  PROCEDURE initialize_loader_environment;


    VAR
      mainframe_id: pmt$binary_mainframe_id,
      task_private_heap: ^HEAP (REP 10000 of cell),
      from_pointer: ^^cell,
      to_pointer: ^^cell,
      ignore_status: ost$status,
      i: integer;


    { initialize osv$task_private_heap to a manageable size }

    ALLOCATE task_private_heap;

    from_pointer := #LOC (task_private_heap);
    to_pointer := #LOC (osv$task_private_heap);
    to_pointer^ := from_pointer^;

    RESET osv$task_private_heap^;


    { initialize lov$task_services_entry_points }

    ALLOCATE lov$task_services_entry_points: [1 .. max_tsep];

    FOR i := 1 TO UPPERBOUND (task_services_entry_point_names) DO
      lov$task_services_entry_points^ [i] := task_services_entry_point;
      lov$task_services_entry_points^ [i].name := task_services_entry_point_names [i];
    FOREND;

    prog_options_and_libraries.job_library_list := NIL;
    pmv$prog_options_and_libraries := ^prog_options_and_libraries;

    ALLOCATE pmv$task_tcb_p;
    pmv$task_tcb_p^ := tcb_proto;
    ALLOCATE pmv$task_tcb_p^.nosve.debug_table;
    pmv$task_tcb_p^.nosve.debug_table^ := debug_table_proto;
    pmv$task_tcb_p^.parent := ^tcb_proto;
    pmp$get_binary_mainframe_id (mainframe_id, ignore_status);
    IF (mainframe_id.model_number <> osc$cyber_180_model_990) OR
         (mainframe_id.model_number <> osc$cyber_180_model_990e) THEN
      osv$global_processor_model_info := processor_model_definition1;
    ELSE
      osv$global_processor_model_info := processor_model_definition2;
    IFEND;

  PROCEND initialize_loader_environment;
?? OLDTITLE ??
?? NEWTITLE := '  INITIALIZE_MPE_LOADER_SEQ', EJECT ??

  PROCEDURE initialize_mpe_loader_seq (VAR seq_name: amt$local_file_name;
    VAR status: ost$status);


    VAR
      file_attributes: [STATIC] array [1 .. 5] of amt$access_selection := [[amc$return_option,
        amc$return_at_task_exit], [amc$file_structure, amc$data], [amc$file_contents, amc$unknown_contents],
        [amc$file_processor, amc$unknown_processor], [amc$record_type, amc$undefined]],

      unique_name: ost$unique_name,
      file_identifier: amt$file_identifier,
      interblock_file_identifier: amt$file_identifier,
      interblock_references_hdr: ^pmt$interblock_references_hdr,
      interblock_segment_pointer: amt$segment_pointer,
      segment_pointer: amt$segment_pointer,
      descriptor: ^pmt$loader_seq_descriptor;


    pmp$generate_unique_name (unique_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    seq_name := unique_name.value;


    amp$open (seq_name, amc$segment, ^file_attributes, file_identifier, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$get_segment_pointer (file_identifier, amc$sequence_pointer, segment_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;


    RESET segment_pointer.sequence_pointer;

    NEXT descriptor IN segment_pointer.sequence_pointer;

    descriptor^.block_name_map_exists := FALSE;
    descriptor^.local_block_id := 0;
    descriptor^.remote_block_id := 0;
    descriptor^.local_block_name_map := NIL;
    descriptor^.remote_block_name_map := NIL;
    descriptor^.max_segment_length := 150000000;

    pmp$generate_unique_name (unique_name, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    descriptor^.first_interblock_segment_name := unique_name.value;

    amp$open (unique_name.value, amc$segment, ^file_attributes, interblock_file_identifier, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$get_segment_pointer (interblock_file_identifier, amc$sequence_pointer, interblock_segment_pointer,
          status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    RESET interblock_segment_pointer.sequence_pointer;
    descriptor^.last_interblock_segment := interblock_segment_pointer.sequence_pointer;
    descriptor^.number_of_interblock_segments := 1;

    NEXT interblock_references_hdr IN interblock_segment_pointer.sequence_pointer;

    interblock_references_hdr^.file_id := interblock_file_identifier;
    interblock_references_hdr^.number_of_interblock_references := 0;
    interblock_references_hdr^.next_segment_file_name := osc$null_name;



    amp$set_segment_eoi (file_identifier, segment_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$close (file_identifier, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$set_segment_eoi (interblock_file_identifier, interblock_segment_pointer, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    amp$close (interblock_file_identifier, status);


  PROCEND initialize_mpe_loader_seq;
?? OLDTITLE ??
?? NEWTITLE := '  DISPLAY_RESULTS', EJECT ??

  PROCEDURE display_results (loader_entry_point: string ( * );
        load_status: ost$status;
        starting: pmt$task_jobmode_statistics;
        ending: pmt$task_jobmode_statistics);


    VAR
      cp_time: integer,
      page_faults: integer,
      strng: string (100),
      length: integer,
      cp_string: string (25),
      cp_length: integer,
      output_status: ost$status,
      ignore_status: ost$status;


    STRINGREP (strng, length, loader_entry_point, ' returned the following status: ');
    osp$set_status_abnormal ('LO', oce$misc_exception, strng (1, length), output_status);
    osp$generate_message (output_status, ignore_status);

    IF load_status.normal THEN
      osp$set_status_abnormal ('LO', oce$misc_exception, 'NORMAL STATUS  --', output_status);
      osp$generate_message (output_status, ignore_status);

    ELSE
      osp$generate_message (load_status, ignore_status);
    IFEND;


    cp_time := (ending.jobmode_cptime - starting.jobmode_cptime);

    page_faults := ending.paging_statistics.page_in_count + ending.paging_statistics.
          pages_reclaimed_from_queue + ending.paging_statistics.new_pages_assigned;
    page_faults := page_faults - starting.paging_statistics.page_in_count - starting.paging_statistics.
          pages_reclaimed_from_queue - starting.paging_statistics.new_pages_assigned;

    STRINGREP (cp_string, cp_length, (cp_time DIV 1000000), '.');
    clp$convert_integer_to_rjstring ((cp_time MOD 1000000), 10, FALSE, '0', cp_string (cp_length + 1, 6),
          ignore_status);
    STRINGREP (strng, length, 'Job cp time =', cp_string (1, cp_length + 6),
          '   page faults =', page_faults, '.');

    osp$set_status_abnormal ('LO', oce$misc_exception, strng (1,length), output_status);
    osp$generate_message (output_status, ignore_status);

    osp$set_status_abnormal ('LO', oce$misc_exception, ' ', output_status);
    osp$generate_message (output_status, ignore_status);


  PROCEND display_results;
?? OLDTITLE ??
?? NEWTITLE := '  LOP$STANDALONE_LOADER_FRONT_END', EJECT ??

  PROCEDURE [XDCL, #GATE] lop$standalone_loader_front_end (parameter_list: clt$parameter_list;
    VAR status: ost$status);




{ *** WARNING - change 'LOC$TASK_SERVICES_ENTRY_POINTS' *** }


{ PROCEDURE load_program (
{   file, files, f: list of file = $optional
{   library, libraries, l: list of any of
{       file
{       key
{         loc$task_services_library_name
{       keyend
{     anyend = $optional
{   module, modules, m: list of program_name = $optional
{   starting_procedure, sp: program_name = $optional
{   load_map, lm: file = :$local.loadmap
{   load_map_option, load_map_options, lmo: any of
{       key
{         all, none
{       keyend
{       list of key
{         (segment, s)
{         (block, b)
{         (entry_point, ep)
{         (cross_reference, cr)
{       keyend
{     anyend = all
{   termination_error_level, tel: key
{       (warning, w)
{       (error, e)
{       (fatal, f)
{     keyend = error
{   preset_value, pv: key
{       (zero, z)
{       (floating_point_indefinite, fpi)
{       (infinity, i)
{       (alternate_ones, ao)
{     keyend = zero
{   stack_size, ss: integer 0..osc$max_segment_length = 33554432
{   job_library_list, jll: list of file = $optional
{   target_ring, tr: integer osc$min_ring..osc$max_ring = 11
{   debug_ring, dr: integer osc$min_ring..osc$max_ring = 11
{   target_text, tt: file = $optional
{   dynamic_load, dl: key
{       none
{       (load, l)
{       (module, m)
{     keyend = none
{   dynamic_load_proc, dlp: program_name = $optional
{   load_module_library_name, lmln: file = $optional
{   status)

?? PUSH (LISTEXT := ON) ??
?? FMT (FORMAT := OFF) ??

  VAR
    pdt: [STATIC, READ, cls$declaration_section] record
      header: clt$pdt_header,
      names: array [1 .. 37] of clt$pdt_parameter_name,
      parameters: array [1 .. 17] of clt$pdt_parameter,
      type1: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
        recend,
      recend,
      type2: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
          qualifier: clt$union_type_qualifier,
          type_size_1: clt$type_specification_size,
          element_type_spec_1: record
            header: clt$type_specification_header,
          recend,
          type_size_2: clt$type_specification_size,
          element_type_spec_2: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 1] of clt$keyword_specification,
          recend,
        recend,
      recend,
      type3: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
        recend,
      recend,
      type4: record
        header: clt$type_specification_header,
      recend,
      type5: record
        header: clt$type_specification_header,
        default_value: string (15),
      recend,
      type6: record
        header: clt$type_specification_header,
        qualifier: clt$union_type_qualifier,
        type_size_1: clt$type_specification_size,
        element_type_spec_1: record
          header: clt$type_specification_header,
          qualifier: clt$keyword_type_qualifier,
          keyword_specs: array [1 .. 2] of clt$keyword_specification,
        recend,
        type_size_2: clt$type_specification_size,
        element_type_spec_2: record
          header: clt$type_specification_header,
          qualifier: clt$list_type_qualifier,
          element_type_spec: record
            header: clt$type_specification_header,
            qualifier: clt$keyword_type_qualifier,
            keyword_specs: array [1 .. 8] of clt$keyword_specification,
          recend,
        recend,
        default_value: string (3),
      recend,
      type7: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 6] of clt$keyword_specification,
        default_value: string (5),
      recend,
      type8: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 8] of clt$keyword_specification,
        default_value: string (4),
      recend,
      type9: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (8),
      recend,
      type10: record
        header: clt$type_specification_header,
        qualifier: clt$list_type_qualifier,
        element_type_spec: record
          header: clt$type_specification_header,
        recend,
      recend,
      type11: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (2),
      recend,
      type12: record
        header: clt$type_specification_header,
        qualifier: clt$integer_type_qualifier,
        default_value: string (2),
      recend,
      type13: record
        header: clt$type_specification_header,
      recend,
      type14: record
        header: clt$type_specification_header,
        qualifier: clt$keyword_type_qualifier,
        keyword_specs: array [1 .. 5] of clt$keyword_specification,
        default_value: string (4),
      recend,
      type15: record
        header: clt$type_specification_header,
      recend,
      type16: record
        header: clt$type_specification_header,
      recend,
      type17: record
        header: clt$type_specification_header,
      recend,
    recend := [
    [1,
    [89, 10, 5, 10, 36, 32, 386],
    clc$command, 37, 17, 0, 0, 0, 0, 17, ''], [
    ['DEBUG_RING                     ',clc$nominal_entry, 12],
    ['DL                             ',clc$abbreviation_entry, 14],
    ['DLP                            ',clc$abbreviation_entry, 15],
    ['DR                             ',clc$abbreviation_entry, 12],
    ['DYNAMIC_LOAD                   ',clc$nominal_entry, 14],
    ['DYNAMIC_LOAD_PROC              ',clc$nominal_entry, 15],
    ['F                              ',clc$abbreviation_entry, 1],
    ['FILE                           ',clc$nominal_entry, 1],
    ['FILES                          ',clc$alias_entry, 1],
    ['JLL                            ',clc$abbreviation_entry, 10],
    ['JOB_LIBRARY_LIST               ',clc$nominal_entry, 10],
    ['L                              ',clc$abbreviation_entry, 2],
    ['LIBRARIES                      ',clc$alias_entry, 2],
    ['LIBRARY                        ',clc$nominal_entry, 2],
    ['LM                             ',clc$abbreviation_entry, 5],
    ['LMLN                           ',clc$abbreviation_entry, 16],
    ['LMO                            ',clc$abbreviation_entry, 6],
    ['LOAD_MAP                       ',clc$nominal_entry, 5],
    ['LOAD_MAP_OPTION                ',clc$nominal_entry, 6],
    ['LOAD_MAP_OPTIONS               ',clc$alias_entry, 6],
    ['LOAD_MODULE_LIBRARY_NAME       ',clc$nominal_entry, 16],
    ['M                              ',clc$abbreviation_entry, 3],
    ['MODULE                         ',clc$nominal_entry, 3],
    ['MODULES                        ',clc$alias_entry, 3],
    ['PRESET_VALUE                   ',clc$nominal_entry, 8],
    ['PV                             ',clc$abbreviation_entry, 8],
    ['SP                             ',clc$abbreviation_entry, 4],
    ['SS                             ',clc$abbreviation_entry, 9],
    ['STACK_SIZE                     ',clc$nominal_entry, 9],
    ['STARTING_PROCEDURE             ',clc$nominal_entry, 4],
    ['STATUS                         ',clc$nominal_entry, 17],
    ['TARGET_RING                    ',clc$nominal_entry, 11],
    ['TARGET_TEXT                    ',clc$nominal_entry, 13],
    ['TEL                            ',clc$abbreviation_entry, 7],
    ['TERMINATION_ERROR_LEVEL        ',clc$nominal_entry, 7],
    ['TR                             ',clc$abbreviation_entry, 11],
    ['TT                             ',clc$abbreviation_entry, 13]],
    [
{ PARAMETER 1
    [8, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 19, clc$optional_parameter, 0, 0],
{ PARAMETER 2
    [14, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 83, clc$optional_parameter, 0, 0],
{ PARAMETER 3
    [23, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 19, clc$optional_parameter, 0, 0],
{ PARAMETER 4
    [30, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],
{ PARAMETER 5
    [18, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_default_parameter, 0, 15],
{ PARAMETER 6
    [19, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 420, clc$optional_default_parameter, 0, 3],
{ PARAMETER 7
    [35, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 229, clc$optional_default_parameter, 0, 5],
{ PARAMETER 8
    [25, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 303, clc$optional_default_parameter, 0, 4],
{ PARAMETER 9
    [29, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 20, clc$optional_default_parameter, 0, 8],
{ PARAMETER 10
    [11, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 19, clc$optional_parameter, 0, 0],
{ PARAMETER 11
    [32, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 20, clc$optional_default_parameter, 0, 2],
{ PARAMETER 12
    [1, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 20, clc$optional_default_parameter, 0, 2],
{ PARAMETER 13
    [33, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],
{ PARAMETER 14
    [5, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 192, clc$optional_default_parameter, 0, 4],
{ PARAMETER 15
    [6, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],
{ PARAMETER 16
    [21, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name, clc$specify_positionally],
    clc$pass_by_value, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0],
{ PARAMETER 17
    [31, clc$normal_usage_entry, clc$non_secure_parameter,
    $clt$parameter_spec_methods[clc$specify_by_name],
    clc$pass_by_reference, clc$immediate_evaluation,
  clc$standard_parameter_checking, 3, clc$optional_parameter, 0, 0]],
{ PARAMETER 1
    [[1, 0, clc$list_type], [3, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$file_type]]
    ],
{ PARAMETER 2
    [[1, 0, clc$list_type], [67, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$union_type], [[clc$file_type,
      clc$keyword_type],
      FALSE, 2],
      3, [[1, 0, clc$file_type]],
      44, [[1, 0, clc$keyword_type], [1], [
        [LOC$TASK_SERVICES_LIBRARY_NAME, clc$nominal_entry,
  clc$normal_usage_entry, 1]]
        ]
      ]
    ],
{ PARAMETER 3
    [[1, 0, clc$list_type], [3, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$program_name_type]]
    ],
{ PARAMETER 4
    [[1, 0, clc$program_name_type]],
{ PARAMETER 5
    [[1, 0, clc$file_type],
    ':$local.loadmap'],
{ PARAMETER 6
    [[1, 0, clc$union_type], [[clc$keyword_type,
    clc$list_type],
    FALSE, 2],
    81, [[1, 0, clc$keyword_type], [2], [
      ['ALL                            ', clc$nominal_entry,
  clc$normal_usage_entry, 1],
      ['NONE                           ', clc$nominal_entry,
  clc$normal_usage_entry, 2]]
      ],
    319, [[1, 0, clc$list_type], [303, 1, clc$max_list_size, FALSE],
        [[1, 0, clc$keyword_type], [8], [
        ['B                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
        ['BLOCK                          ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
        ['CR                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4],
        ['CROSS_REFERENCE                ', clc$nominal_entry,
  clc$normal_usage_entry, 4],
        ['ENTRY_POINT                    ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
        ['EP                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
        ['S                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
        ['SEGMENT                        ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
        ]
      ]
    ,
    'all'],
{ PARAMETER 7
    [[1, 0, clc$keyword_type], [6], [
    ['E                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['ERROR                          ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
    ['F                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['FATAL                          ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['W                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
    ['WARNING                        ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
    ,
    'error'],
{ PARAMETER 8
    [[1, 0, clc$keyword_type], [8], [
    ['ALTERNATE_ONES                 ', clc$nominal_entry,
  clc$normal_usage_entry, 4],
    ['AO                             ', clc$abbreviation_entry,
  clc$normal_usage_entry, 4],
    ['FLOATING_POINT_INDEFINITE      ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
    ['FPI                            ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['I                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['INFINITY                       ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['Z                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 1],
    ['ZERO                           ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
    ,
    'zero'],
{ PARAMETER 9
    [[1, 0, clc$integer_type], [0, osc$max_segment_length, 10],
    '33554432'],
{ PARAMETER 10
    [[1, 0, clc$list_type], [3, 1, clc$max_list_size, FALSE],
      [[1, 0, clc$file_type]]
    ],
{ PARAMETER 11
    [[1, 0, clc$integer_type], [osc$min_ring, osc$max_ring, 10],
    '11'],
{ PARAMETER 12
    [[1, 0, clc$integer_type], [osc$min_ring, osc$max_ring, 10],
    '11'],
{ PARAMETER 13
    [[1, 0, clc$file_type]],
{ PARAMETER 14
    [[1, 0, clc$keyword_type], [5], [
    ['L                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 2],
    ['LOAD                           ', clc$nominal_entry,
  clc$normal_usage_entry, 2],
    ['M                              ', clc$abbreviation_entry,
  clc$normal_usage_entry, 3],
    ['MODULE                         ', clc$nominal_entry,
  clc$normal_usage_entry, 3],
    ['NONE                           ', clc$nominal_entry,
  clc$normal_usage_entry, 1]]
    ,
    'none'],
{ PARAMETER 15
    [[1, 0, clc$program_name_type]],
{ PARAMETER 16
    [[1, 0, clc$file_type]],
{ PARAMETER 17
    [[1, 0, clc$status_type]]];

?? FMT (FORMAT := ON) ??
?? POP ??

    CONST
      p$file = 1,
      p$library = 2,
      p$module = 3,
      p$starting_procedure = 4,
      p$load_map = 5,
      p$load_map_option = 6,
      p$termination_error_level = 7,
      p$preset_value = 8,
      p$stack_size = 9,
      p$job_library_list = 10,
      p$target_ring = 11,
      p$debug_ring = 12,
      p$target_text = 13,
      p$dynamic_load = 14,
      p$dynamic_load_proc = 15,
      p$load_module_library_name = 16,
      p$status = 17;

    VAR
      pvt: array [1 .. 17] of clt$parameter_value;

    VAR
      object_file_list: ^pmt$object_file_list,
      module_list: ^pmt$module_list,
      execute_library_list: ^pmt$object_library_list,
      job_library_list: ^pmt$object_library_list,
      starting_procedure: pmt$program_name,
      target_ring: ost$ring,
      loaded_ring: ost$valid_ring,
      call_bracket_ring: ost$valid_ring,
      loader_options: lot$loader_options,
      mpe_description: pmt$loader_description,
      loaded_program_cbp: ^ost$external_code_base_pointer,
      dynamic_load: 0 .. 2,
      dynamic_load_proc: pmt$program_name,
      load_module_library_name: amt$local_file_name,
      load_module_segment_pointer: amt$segment_pointer,
      file_identifier: amt$file_identifier,
      usage_attributes: array [1 .. 3] of fst$attachment_option,
      local_status: ost$status;


    VAR
      set_count: clt$list_size,
      i: clt$list_size,
      loaded_address: pmt$loaded_address,
      load_status: ost$status,
      node: ^clt$data_value,
      starting_statistics: pmt$task_jobmode_statistics,
      ending_statistics: pmt$task_jobmode_statistics;

    status.normal := TRUE;

    initialize_loader_environment;

    clp$evaluate_parameters (parameter_list, #SEQ (pdt), NIL, ^pvt, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

{ FILE

    IF NOT pvt [p$file].specified THEN
      object_file_list := NIL;
    ELSE
      set_count := clp$count_list_elements (pvt [p$file].value);
      PUSH object_file_list: [1 .. set_count];
      node := pvt [p$file].value;
      FOR i := 1 TO set_count DO
        object_file_list^ [i] := node^.element_value^.file_value^;
        node := node^.link;
      FOREND;
    IFEND;

{ LIBRARY

    IF NOT pvt [p$library].specified THEN
      execute_library_list := NIL;
    ELSE
      set_count := clp$count_list_elements (pvt [p$library].value);
      PUSH execute_library_list: [1 .. set_count];
      node := pvt [p$library].value;
      FOR i := 1 TO set_count DO
        IF node^.element_value^.kind = clc$keyword THEN
          execute_library_list^ [i] := node^.element_value^.keyword_value;
        ELSE
          execute_library_list^ [i] := node^.element_value^.file_value^;
        IFEND;
        node := node^.link;
      FOREND;
    IFEND;

{ MODULE

    IF NOT pvt [p$module].specified THEN
      module_list := NIL;
    ELSE
      set_count := clp$count_list_elements (pvt [p$module].value);
      PUSH module_list: [1 .. set_count];
      node := pvt [p$module].value;
      FOR i := 1 TO set_count DO
        module_list^ [i] := node^.element_value^.program_name_value;
        node := node^.link;
      FOREND;
    IFEND;

{ STARTING_PROCEDURE

    IF NOT pvt [p$starting_procedure].specified THEN
      starting_procedure := osc$null_name;
    ELSE
      starting_procedure := pvt [p$starting_procedure].value^.program_name_value;
    IFEND;

{ LOAD_MAP

    loader_options.map_file := pvt [p$load_map].value^.file_value^;

{ LOAD_MAP_OPTION

    loader_options.map := $pmt$load_map_options [];
    IF pvt [p$load_map_option].value^.kind = clc$keyword THEN
      IF pvt [p$load_map_option].value^.keyword_value = 'ALL' THEN
        loader_options.map := $pmt$load_map_options [pmc$segment_map, pmc$block_map, pmc$entry_point_map];
      ELSE
        loader_options.map := $pmt$load_map_options [pmc$no_load_map];
      IFEND;
    ELSE
      node := pvt [p$load_map_option].value;
      WHILE (node <>  NIL) AND (node^.element_value <> NIL) DO
        CASE node^.element_value^.keyword_value (1) OF
        = 'S' =
          loader_options.map := loader_options.map + $pmt$load_map_options [pmc$segment_map];
        = 'B' =
          loader_options.map := loader_options.map + $pmt$load_map_options [pmc$block_map];
        = 'E' =
          loader_options.map := loader_options.map + $pmt$load_map_options [pmc$entry_point_map];
        = 'C' =
          loader_options.map := loader_options.map + $pmt$load_map_options [pmc$entry_point_xref];
        CASEND;
      WHILEND;
    IFEND;

{ TERMINATION_ERROR_LEVEL

    CASE pvt [p$termination_error_level].value^.keyword_value (1) OF
    = 'W' =
      loader_options.termination_error_level := pmc$warning_load_errors;
    = 'E' =
      loader_options.termination_error_level := pmc$error_load_errors;
    = 'F' =
      loader_options.termination_error_level := pmc$fatal_load_errors;
    CASEND;

{ PRESET_VALUE

    CASE pvt [p$preset_value].value^.keyword_value (1) OF
    = 'Z' =
      loader_options.preset := 0;
    = 'I' =
      loader_options.preset := 050000000(16);
    = 'F' =
      loader_options.preset := 070000000(16);
    = 'A' =
      loader_options.preset := 0aaaaaaaa(16);
    CASEND;

{ STACK_SIZE

    loader_options.maximum_stack_size := pvt [p$stack_size].value^.integer_value.value;

{ JOB_LIBRARY_LIST

    IF NOT pvt [p$job_library_list].specified THEN
      job_library_list := NIL;
    ELSE
      set_count := clp$count_list_elements (pvt [p$job_library_list].value);
      PUSH job_library_list: [1 .. set_count];
      node := pvt [p$job_library_list].value;
      FOR i := 1 TO set_count DO
        job_library_list^ [i] := node^.element_value^.file_value^;
        node := node^.link;
      FOREND;
    IFEND;

    pmv$prog_options_and_libraries^.job_library_list := job_library_list;

{ TARGET_RING

    target_ring := pvt [p$target_ring].value^.integer_value.value;

    pmv$task_tcb_p^.parent^.target_ring := target_ring;
    pmv$task_tcb_p^.target_ring := target_ring;

{ DEBUG_RING

    loader_options.debug_ring := pvt [p$debug_ring].value^.integer_value.value;

{ TARGET_TEXT

    IF NOT pvt [p$target_text].specified THEN
      mpe_description.apd_load := FALSE;
    ELSE
      mpe_description.apd_load := TRUE;
      clp$convert_string_to_file (pvt [p$target_text].value^.file_value^, mpe_description.
             target_text, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      initialize_mpe_loader_seq (mpe_description.mpe_loader_seq, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
    IFEND;

{ DYNAMIC_LOAD

    CASE pvt [p$dynamic_load].value^.keyword_value (1) OF
    = 'N' =
      dynamic_load := 0;
    = 'L' =
      dynamic_load := 1;
    = 'M' =
      dynamic_load := 2;
    CASEND;

{ DYNAMIC_LOAD_PROC

    IF dynamic_load <> 0 THEN
      IF NOT pvt [p$dynamic_load_proc].specified THEN
        dynamic_load_proc := osc$null_name;
      ELSE
        dynamic_load_proc := pvt [p$dynamic_load_proc].value^.program_name_value;
      IFEND;
    IFEND;

{ LOAD_MODULE_LIBRARY_NAME

    IF NOT pvt [p$load_module_library_name].specified THEN
      load_module_library_name := osc$null_name;
    ELSE
      load_module_library_name := pvt [p$load_module_library_name].value^.file_value^;
    IFEND;

{ LOP$LOAD_PROGRAM

    pmp$get_task_jobmode_statistics (starting_statistics, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    lop$load_program (object_file_list, module_list, execute_library_list, job_library_list,
          starting_procedure, target_ring, loader_options, ^mpe_description, loaded_program_cbp,
          load_status);

    pmp$get_task_jobmode_statistics (ending_statistics, status);
    IF NOT status.normal THEN
      RETURN;
    IFEND;

    display_results ('LOP$LOAD_PROGRAM', load_status, starting_statistics, ending_statistics);

    IF dynamic_load = 0 THEN
      RETURN;

{ PMP$LOAD }

    ELSEIF dynamic_load = 1 THEN
      pmp$get_task_jobmode_statistics (starting_statistics, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      pmp$load (dynamic_load_proc, pmc$procedure_address, loaded_address, load_status);

      pmp$get_task_jobmode_statistics (ending_statistics, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_results ('PMP$LOAD', load_status, starting_statistics, ending_statistics);
      RETURN;

    ELSEIF dynamic_load = 2 THEN

{ PMP$LOAD_MODULE_FROM_LIBRARY }

      pmp$get_task_jobmode_statistics (starting_statistics, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      usage_attributes [1].selector := fsc$access_and_share_modes;
      usage_attributes [1].access_modes.selector := fsc$specific_access_modes;
      usage_attributes [1].access_modes.value  := $fst$file_access_options [fsc$read,fsc$execute];
      usage_attributes [1].share_modes.selector := fsc$determine_from_access_modes;
      usage_attributes [2].selector := fsc$access_and_share_modes;
      usage_attributes [2].access_modes.selector := fsc$specific_access_modes;
      usage_attributes [2].access_modes.value  := $fst$file_access_options [fsc$execute];
      usage_attributes [2].share_modes.selector := fsc$determine_from_access_modes;
      usage_attributes [3].selector := fsc$create_file;
      usage_attributes [3].create_file := FALSE;

      fsp$open_file (load_module_library_name, amc$segment, ^usage_attributes, NIL, NIL, NIL, NIL,
              file_identifier, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      amp$get_segment_pointer (file_identifier, amc$sequence_pointer, load_module_segment_pointer, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      pmp$load_module_from_library (dynamic_load_proc, target_ring,
            pmc$procedure_address, load_module_library_name, loaded_ring, call_bracket_ring,
                  loaded_address, load_status);

      pmp$get_task_jobmode_statistics (ending_statistics, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;

      display_results ('PMP$LOAD_MODULE_FROM_LIBRARY', load_status, starting_statistics, ending_statistics);
    IFEND;

  PROCEND lop$standalone_loader_front_end;
?? OLDTITLE ??
?? NEWTITLE := '  FMP$LN_OPEN_CHAPTER', EJECT ??

  PROCEDURE [XDCL] fmp$ln_open_chapter (local_file_name: amt$local_file_name;
        chapter_number: dmt$chapter_number;
        validation_ring: ost$valid_ring;
        segment_attributes: ^array [ * ] of mmt$attribute_descriptor;
        pointer_kind: mmt$segment_pointer_kind;
    VAR segment_pointer: mmt$segment_pointer;
    VAR status: ost$status);


    status.normal := TRUE;


  PROCEND fmp$ln_open_chapter;
?? OLDTITLE ??
?? NEWTITLE := '  MMP$CREATE_SEGMENT', EJECT ??

  PROCEDURE [XDCL] mmp$create_segment (seg_attributes_p: ^array [ * ] OF mmt$attribute_descriptor;
        pointer_kind: mmt$segment_pointer_kind;
        validation_ring_number: ost$valid_ring;
    VAR pointer: mmt$segment_pointer;
    VAR status: ost$status);


    VAR
      return_option: [STATIC] array [1 .. 1] of amt$access_selection := [[amc$return_option,
        amc$return_at_task_exit]],
      unique_name: ost$unique_name,
      id: amt$file_identifier,
      segment: amt$segment_pointer;


    status.normal := TRUE;


    CASE pointer_kind OF
    = mmc$heap_pointer =
      mmp$create_scratch_segment (amc$heap_pointer, mmc$as_random, segment, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      pointer.heap_pointer := segment.heap_pointer;
      RESET pointer.heap_pointer^;

    = mmc$sequence_pointer, mmc$cell_pointer =
      mmp$create_scratch_segment (amc$sequence_pointer, mmc$as_random, segment, status);
      IF NOT status.normal THEN
        RETURN;
      IFEND;
      RESET segment.sequence_pointer;
      IF pointer_kind = mmc$sequence_pointer THEN
        pointer.seq_pointer := segment.sequence_pointer;
      ELSE
        NEXT pointer.cell_pointer IN segment.sequence_pointer;
      IFEND;
    CASEND;


  PROCEND mmp$create_segment;
?? OLDTITLE ??
?? NEWTITLE := '  MMP$DELETE_SEGMENT', EJECT ??

  PROCEDURE [XDCL] mmp$delete_segment (VAR pointer: mmt$segment_pointer;
        validation_ring_number: ost$valid_ring;
    VAR status: ost$status);


    status.normal := TRUE;


  PROCEND mmp$delete_segment;
?? OLDTITLE ??
?? NEWTITLE := '  MMP$STORE_SEGMENT_ATTRIBUTES', EJECT ??

  PROCEDURE [XDCL] mmp$store_segment_attributes (pva: ^cell;
        validation_ring_number: ost$valid_ring;
        seg_attributes: array [ * ] OF mmt$attribute_descriptor;
    VAR status: ost$status);


    status.normal := TRUE;


  PROCEND mmp$store_segment_attributes;
?? OLDTITLE ??
?? NEWTITLE := '  MMP$FETCH_SEGMENT_ATTRIBUTES', EJECT ??

  PROCEDURE [XDCL] mmp$fetch_segment_attributes (pva: ^cell;
    VAR seg_attributes: array [ * ] OF mmt$attribute_descriptor;
    VAR status: ost$status);


    VAR
      i: integer;


    FOR i := 1 TO UPPERBOUND (seg_attributes) DO
      CASE seg_attributes [i].keyword OF
        = mmc$kw_max_segment_length =
          seg_attributes [i].max_length := 7fffffff(16);
        ELSE
      CASEND;
    FOREND;


  PROCEND mmp$fetch_segment_attributes;
?? OLDTITLE ??
?? NEWTITLE := '  HPP$INITIALIZE', EJECT ??

  PROCEDURE [XDCL] osp$reset_heap (heap_p: ^ost$heap;
        l: integer;
        wait_option: boolean;
        algorithm: 0 .. 255);



  PROCEND osp$reset_heap;
?? OLDTITLE ??
?? NEWTITLE := '  PMP$RECORD_TASK_NAME', EJECT ??

  PROCEDURE [XDCL] pmp$record_task_name (task_name: ost$name;
        override_old_name {control} : boolean);




  PROCEND pmp$record_task_name;
?? OLDTITLE ??
?? NEWTITLE := '  PMP$GET_LOADED_RINGS', EJECT ??

  PROCEDURE [XDCL] pmp$get_loaded_rings (VAR loaded_rings: pmt$loadable_rings);


    loaded_rings := $pmt$loadable_rings [1, 2, 3];


  PROCEND pmp$get_loaded_rings;
?? OLDTITLE ??
?? NEWTITLE := '  FSP$CHANGE_SEGMENT_NUMBER', EJECT ??

  PROCEDURE [XDCL] fsp$change_segment_number
    (    file_identifier: amt$file_identifier;
         new_segment_number: ost$segment;
         validation_ring: ost$valid_ring;
         pointer_kind: amt$pointer_kind;
     VAR segment_pointer: amt$segment_pointer;
     VAR status: ost$status);

  PROCEND fsp$change_segment_number;
?? OLDTITLE ??
?? NEWTITLE := '  PMP$FIND_OPTNS_LIBS_FIRST_TIME', EJECT ??

  PROCEDURE [XDCL] pmp$find_optns_libs_first_time (VAR tcb: ^pmt$prog_options_and_libraries);



  PROCEND pmp$find_optns_libs_first_time;
?? OLDTITLE ??
?? NEWTITLE := 'SYP$FETCH_SYSTEM_CONSTANT', EJECT ??

  PROCEDURE [XDCL] syp$fetch_system_constant (VAR name: string (*);
    VAR index: integer;
    VAR value: integer;
    VAR status: ost$status);


    value := 150000000;


  PROCEND syp$fetch_system_constant;
?? OLDTITLE ??
?? NEWTITLE := 'BAP$INHIBIT_IMPLICIT_DETACH', EJECT ??

  PROCEDURE [XDCL] bap$inhibit_implicit_detach
    (    file_identifier: amt$file_identifier);

  PROCEND bap$inhibit_implicit_detach;
?? OLDTITLE ??
MODEND lom$loader_front_end;
