?? RIGHT := 110 ??
?? TITLE := 'Obtain resources from the C170 for VE'  ??
MODULE dsm$obtain_resources_for_ve ALIAS 'DSMORFV';
*copyc pxiotyp
?? PUSH (LISTEXT := ON) ??
*copyc zn7prcl
?? POP ??
*copyc dsc$constant_definitions
*copyc dst$deadstart_condition
*copyc dsp$dst_compass_interface
*copy dsp$copy_memory
*copy dsi$virtual_memory_access
?? EJECT ??
{***********************************************************************

*copyc dst$170_request_block
*copyc dsp$callver
*copyc dsp$callsda
*copyc dsp$send_data_via_ssr
*copyc dsp$copy_memory
*copy dsi$define_hardware_config
*copyc dsi$support_eicb_version_4
  CONST
    dsc$cpu_elid_810 = 14(16),
    dsc$cpu_elid_830 = 13(16);
  VAR
    got_cpu_attr:  boolean:= FALSE,
    request: dst$170_resource_request;
?? OLDTITLE, NEWTITLE := '~~~~~   claim_pp ', EJECT ??
  PROCEDURE claim_pp;

    VAR
      hold_general_status: 0 .. 07777(8),
      i: integer,
      j: integer,
      req_driver: boolean,
      req_partner_pp: boolean;

    req_driver := request.driver_pp;
    req_partner_pp := request.partner_pp;

  /try_both_types/
    FOR i := 1 TO 2 DO

    /try_requested_type/
      FOR j := 1 TO 400 DO  { About 10 seconds with default recall rate
        ver_request.clear := 0;
        ver_request.general_status := 0;
        ver_request.length := 1;

        IF request.channel_used.channel_protocol = dsc$cpt_nio THEN

          { Attempt to get a NIO PP.

          ver_request.pp.kind := non_driver_pp;
          IF req_partner_pp THEN
             ver_request.pp.kind := pair_of_pps;
          ELSEIF req_driver THEN
             ver_request.pp.kind := driver_pp;
          IFEND;

          IF d7ty.eicb_version < dsc$eicb_version_4 THEN
            callver (ver_request, rspp, TRUE);
          ELSE
            callver (ver_request, rspt, TRUE);
          IFEND;
          IF ver_request.general_status <= 1 THEN
             EXIT /try_both_types/;
          IFEND;
        ELSE

          { Attempt to get a single CIO PP.

          IF d7ty.eicb_version < dsc$eicb_version_4 THEN
            request.status := dsc$170_rre_bad_request;
            dyfstring ('CIO PP requests not supported', system_dayf);
            RETURN;
          IFEND;
          ver_request.pp.kind := cio_cluster_0;
          IF request.channel_used.number > 4 THEN
            ver_request.pp.kind := cio_cluster_1;
          IFEND;
          callver (ver_request, rspt, TRUE);

          { The secondary PP is set to zero to make sure a partner PP is retrieved if one is requested.

          IF ver_request.general_status <= 1 THEN
            ver_request.pp.secondary := 0;
            EXIT /try_both_types/;
          IFEND;
        IFEND;
        n7p$recall;
      FOREND /try_requested_type/;

      { Toggle driver/nondriver status and retry PP acquisition.

      IF req_partner_pp THEN
        EXIT /try_both_types/;
      ELSE
        req_driver := NOT req_driver;
      IFEND;

    FOREND /try_both_types/;

?? SKIP := 2 ??

    IF ver_request.general_status = 1 THEN
      request.primary_pp := request.channel_used;
      request.primary_pp.number := ver_request.pp.primary;
      IF request.channel_used.channel_protocol = dsc$cpt_cio THEN
        dyfstrnum ('GET CIO PP', ver_request.pp.primary, user_dayf);
      ELSE
        dyfstrnum ('GET PP', ver_request.pp.primary, user_dayf);
      IFEND;
      request.status := dsc$170_rre_request_ok;

      IF request.partner_pp THEN
        request.secondary_pp := request.channel_used;
        IF ver_request.pp.secondary > 0 THEN
          dyfstrnum ('AND PP', ver_request.pp.secondary, user_dayf);
          request.secondary_pp.number := ver_request.pp.secondary;
        ELSE

         /repeat_loop/
          FOR i := 1 to 10 DO
            ver_request.clear := 0;
            ver_request.general_status := 0;
            ver_request.length := 1;

            IF request.channel_used.channel_protocol = dsc$cpt_cio THEN

              { Get a partner CIO PP.

              ver_request.pp.kind := cio_cluster_0;
              IF request.channel_used.number > 4 THEN
                ver_request.pp.kind := cio_cluster_1;
              IFEND;
              callver (ver_request, rspt, TRUE);
            ELSE

              { This code exists for Pre NOS 2.5.1 systems.

              ver_request.pp.kind := driver_pp;
              callver (ver_request, rspp, TRUE);
            IFEND;

            IF ver_request.general_status <= 1 THEN
               EXIT /repeat_loop/;
            IFEND;
            n7p$recall;
          FOREND /repeat_loop/;

          IF ver_request.general_status > 1 THEN
            hold_general_status := ver_request.general_status;
            return_pp (request.primary_pp);
            decode_and_display_error (hold_general_status);
          ELSE
            IF request.channel_used.channel_protocol = dsc$cpt_cio THEN
              dyfstrnum ( 'GET SECOND CIO PP', ver_request.pp.primary, user_dayf);
            ELSE
              dyfstrnum ( 'GET SECOND PP', ver_request.pp.primary, user_dayf);
            IFEND;
            request.secondary_pp.number := ver_request.pp.primary;
            request.status := dsc$170_rre_request_ok;
          IFEND;
        IFEND;

        { *NOTE: Code for Special case S1 Cost Reduced PP requests for dual pps
        { here!  This code is specifically for the NOS 2.4.3 with NOS/VE 1.2.1 combination

        IF d7ty.eicb_version < dsc$eicb_version_4 THEN
        /s1cr/
          BEGIN
           IF NOT got_cpu_attr THEN
              set_configuration;
              got_cpu_attr := TRUE;
           IFEND;
           IF (configuration_record [1].processor.element_id.model_number = dsc$cpu_elid_810) OR
                 (configuration_record [1].processor.element_id.model_number = dsc$cpu_elid_830) THEN
              { Exit occurs (implicitly) for non 810/830 processors.
              s1cr_dualpp_check;
           IFEND;
          END /s1cr/;
        IFEND;
      IFEND;

    ELSEIF ver_request.general_status > 1 THEN
      decode_and_display_error (ver_request.general_status);
    ELSEIF ver_request.general_status < 0 THEN
       dyfstring ('call to VER returned with status < 1', system_dayf);
       request.status := dsc$170_rre_null_response;
       RETURN;
    IFEND;

  PROCEND claim_pp;
?? OLDTITLE, NEWTITLE := '~~~~~obtain_pp and return_pp ', EJECT ??

  PROCEDURE [XDCL] obtain_pp (VAR pp: integer);

{
{     The purpose of this procedure is to obtain a single nondriver and nonconcurrent
{ PP for NOS/VE.
{

    IF NOT got_eicb_d7ty THEN

     {  Have not read the D7TY word from the EICB, read it.

      get_dscb(dscb_d7ty,^d7ty, 1);

      { the eicb entry d7ty.eicb_version will be used to choose VER functions

      got_eicb_d7ty:= TRUE;
    IFEND;

    request.driver_pp := FALSE;
    request.partner_pp := FALSE;
    request.channel_used.channel_protocol := dsc$cpt_nio;
    request.primary_pp.number := 0;
    claim_pp;
    pp := request.primary_pp.number;
  PROCEND obtain_pp;
?? SKIP := 3 ??

  PROCEDURE return_pp (pp: dst$170_iou_resource);

    IF pp.channel_protocol = dsc$cpt_cio THEN
      dyfstrnum ('RETURN CIO PP', pp.number, user_dayf);
      ver_request.pp.kind := cio_cluster_0;
    ELSE
      dyfstrnum ('RETURN PP', pp.number, user_dayf);
      ver_request.pp.kind := driver_pp;
    IFEND;
    ver_request.pp.primary := pp.number;
    idle_driver_pp (pp);
    IF request.status = dsc$170_rre_request_ok THEN
      ver_request.general_status := 0;
      ver_request.return_all := FALSE;
      ver_request.length := 1;
      IF d7ty.eicb_version < dsc$eicb_version_4 THEN
        IF pp.channel_protocol = dsc$cpt_cio THEN
           request.status := dsc$170_rre_bad_request;
           dyfstring ('CIO PP requests not supported', system_dayf);
           RETURN;
        IFEND;
        callver (ver_request, rtpp, TRUE);
      ELSE  {use nos 2.5.1 VER request code for any return PP request
        IF pp.channel_protocol = dsc$cpt_cio THEN
           ver_request.pp.kind := cio_cluster_0;
           IF pp.number > 4 THEN
             ver_request.pp.kind := cio_cluster_1;
           IFEND;
        IFEND;
        callver (ver_request, rnpt, TRUE);
      IFEND;
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;
    IFEND;
  PROCEND return_pp;
?? OLDTITLE, NEWTITLE := '~~~~~validate_driver_pp and idle_driver_pp', EJECT ??
  PROCEDURE validate_driver_pp (pp: dst$170_iou_resource);
    ver_request.general_status := 0;
    ver_request.clear := 0;
    ver_request.pp.primary := pp.number;
    ver_request.length := 1;
    IF d7ty.eicb_version < dsc$eicb_version_4 THEN
        IF pp.channel_protocol = dsc$cpt_cio THEN
           request.status := dsc$170_rre_bad_request;
           dyfstring ('CIO PP requests not supported', system_dayf);
           RETURN;
        IFEND;
       callver (ver_request, stpp, TRUE);
    ELSE
       { use NOS 2.5.1 VER request codes
        IF pp.channel_protocol = dsc$cpt_cio THEN
           ver_request.pp.kind := cio_cluster_0;
           IF pp.number > 4 THEN
             ver_request.pp.kind := cio_cluster_1;
           IFEND;
        IFEND;
       callver (ver_request, stpt, TRUE);
    IFEND;
    IF ver_request.general_status > 1 THEN
      decode_and_display_error (ver_request.general_status);
      RETURN;
    IFEND;
  PROCEND validate_driver_pp;
?? SKIP := 3 ??

  PROCEDURE idle_driver_pp (pp: dst$170_iou_resource);
    validate_driver_pp (pp);
    IF d7ty.eicb_version < dsc$eicb_version_4 THEN
        IF pp.channel_protocol = dsc$cpt_cio THEN
           request.status := dsc$170_rre_bad_request;
           dyfstring ('CIO PP requests not supported', system_dayf);
           RETURN;
        IFEND;
    IFEND;
    pp_table.pp_number := pp.number;
    IF pp.channel_protocol = dsc$cpt_cio THEN
       { when SDA idles a pp it uses bit number 8 of the
       { pp number to determine if the pp is CIO
       pp_table.pp_number:= pp_table.pp_number + 256;
    IFEND;
    callsda (idle_pp, pp_table);
  PROCEND idle_driver_pp;
?? SKIP := 3 ??
?? OLDTITLE ??

  PROCEDURE decode_and_display_error (error_status: integer);

    VAR
      status: integer;

    status := error_status DIV 8;
    CASE status OF
    = 1 = { 1X octal }
      dyfstring ('CHANNEL NOT AVAILABLE/NOT ASSIGNED', system_dayf);
      request.status := dsc$170_rre_ch_not_available;
    = 2 = { 2X octal }
      dyfstring ('EQUIPMENT NOT AVAILABLE/NOT ASSIGNED', system_dayf);
      request.status := dsc$170_rre_eq_not_available;
    = 3 = { 3X octal }
      dyfstring ('UNIT NOT AVAILABLE/NOT ASSIGNED', system_dayf);
      request.status := dsc$170_rre_unit_not_available;
    = 4 = { 4X octal }
      dyfstring ('CM NOT AVAILABLE/NOT ASSIGNED', system_dayf);
      request.status := dsc$170_rre_cm_not_available;
    = 5 = { 5X octal }
      dyfstring ('PP NOT AVAILABLE/NOT ASSIGNED', system_dayf);
      request.status := dsc$170_rre_pp_not_available;
    = 6 = { 6X octal }
      dyfstring ('CHANNEL/EQUIPMENT/UNIT NOT IN EST', system_dayf);
      request.status := dsc$170_rre_no_such_resource;
    = 7 = { 7X octal }
      dyfstring ('EQUIPMENT/UNIT ALREADY ASSIGNED TO NOS/VE', system_dayf);
      request.status := dsc$170_rre_already_assigned;
    = 10(8) = { 10X octal }
      dyfstring ('DO NOT DOWNLINE LOAD CONTROLWARE', system_dayf);
      request.status := dsc$170_rre_no_load_controlware;
    = 11(8) = { 11X octal }
      dyfstring ('CONCURRENT CHANNEL NOT PRESENT', system_dayf);
      request.status := dsc$170_rre_cio_ch_not_present;
    = 15(8) = { 15X octal }
      dyfstring ('CONCURRENT PP NOT PRESENT', system_dayf);
      request.status := dsc$170_rre_cio_pp_not_present;
    ELSE
      request.status := dsc$170_rre_bad_request;
      IF status = 38(16) THEN { 70X octal }
        dyfstring ('INSUFFICIENT LENGTH IN RESPONSE BUFFER', system_dayf);
      ELSEIF status = 40(16) THEN { 100X octal }
        dyfstring ('ILLEGAL REQUEST', system_dayf);
      ELSEIF status = 80(16) THEN { 200X octal }
        dyfstring ('DUAL STATE NOT ENABLED', system_dayf);
      ELSE
        RETURN;
      IFEND;
    CASEND;
  PROCEND decode_and_display_error;
?? NEWTITLE := '^^^^   dsp$claim_nve_resources', EJECT ??
{********************************************************}

  PROCEDURE [XDCL] dsp$claim_nve_resources (VAR rblock: dst$170_request_block);

?? SKIP := 3 ??

    PROCEDURE equipment_request (kind_of_request: ver_functions);

      VAR
        statflg: boolean;

      ver_request.clear := 0;
      ver_request.eq.channel := request.equipment_path.channel_number;
      ver_request.eq.equipment := request.equipment_path.equipment_number;
      ver_request.eq.unit := request.equipment_path.unit_number;
      ver_request.return_all := FALSE;
      IF kind_of_request = rseq THEN
        ver_request.length := 2;
      ELSE
        ver_request.length := 1;
      IFEND;
      ver_request.fill := 0;
      ver_request.general_status := 0;
      callver (ver_request, kind_of_request, statflg);
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;
    PROCEND equipment_request;
?? SKIP := 3 ??
    IF NOT got_eicb_d7ty THEN
      get_dscb(dscb_d7ty,^d7ty, 1);
      { the eicb entry d7ty.eicb_version will be used to choose VER functions
      got_eicb_d7ty:= TRUE;
    IFEND;

    request := rblock.resource_request;
    request.status := dsc$170_rre_request_ok;
    CASE request.resource_request_type OF

    = dsc$170_rrt_get_channel =
      ver_request.general_status := 0;
      ver_request.return_all := FALSE;
      ver_request.length := 1;
      ver_request.channel.primary := request.channel.number;
      IF request.channel.channel_protocol = dsc$cpt_cio THEN
        IF d7ty.eicb_version < dsc$eicb_version_4 THEN
          request.status := dsc$170_rre_bad_request;
          dyfstring ('CIO channel requests not supported', system_dayf);
          RETURN;
        IFEND;
        dyfstrnum ('GET CIO CHANNEL', request.channel.number, user_dayf);
        ver_request.channel.kind := cio_channel;
        callver (ver_request, rsct, TRUE);
      ELSE
        dyfstrnum ('GET CHANNEL', request.channel.number, user_dayf);
        ver_request.channel.kind := nio_channel;
        IF d7ty.eicb_version < dsc$eicb_version_4 THEN
            { use pre 2.5.1 code on ver request
            callver (ver_request, rsch, TRUE);
        ELSE
             { try new ( ie. NOS 2.5.1 ) request code
             callver (ver_request, rsct, TRUE);
        IFEND;
      IFEND;
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;

    = dsc$170_rrt_return_channel =
      ver_request.general_status := 0;
      ver_request.return_all := FALSE;
      ver_request.length := 1;
      ver_request.channel.primary := request.channel.number;
      IF d7ty.eicb_version < dsc$eicb_version_4 THEN
        IF request.channel.channel_protocol = dsc$cpt_cio THEN
           request.status := dsc$170_rre_bad_request;
           dyfstring ('CIO channel requests not supported', system_dayf);
           RETURN;
        IFEND;
        dyfstrnum ('RETURN CHANNEL', request.channel.number, user_dayf);
        ver_request.channel.kind := cio_channel;
        callver (ver_request, rtch, TRUE);
      ELSE { use NOS 2.5.1 VER requests
        IF request.channel.channel_protocol = dsc$cpt_cio THEN
           dyfstrnum ('RETURN CIO CHANNEL', request.channel.number, user_dayf);
           ver_request.channel.kind := cio_channel;
        ELSE
           dyfstrnum ('RETURN NIO CHANNEL', request.channel.number, user_dayf);
           ver_request.channel.kind := nio_channel;
        IFEND;
        callver (ver_request, rnct, TRUE);
      IFEND;
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;

    = dsc$170_rrt_get_pp =
      claim_pp;

    = dsc$170_rrt_return_pp =
      return_pp (request.primary_pp);
      IF request.partner_pp THEN
        return_pp (request.secondary_pp);
      IFEND;

    = dsc$170_rrt_get_equipment =
      dyfstrnum ('GET EQUIPMENT', request.equipment_path.channel_number * 1000
            + request.equipment_path.equipment_number * 100 +
            request.equipment_path.unit_number, user_dayf);
      equipment_request (rseq);

    = dsc$170_rrt_return_equipment =
      dyfstrnum ('RETURN EQUIPMENT', request.equipment_path.channel_number * 1000
            + request.equipment_path.equipment_number * 100 +
            request.equipment_path.unit_number, user_dayf);
      equipment_request (rteq);

    = dsc$170_rrt_update_free_clock =
      dyfstring ('INCREMENT FRC' , system_dayf);
      ver_request.return_all := FALSE;
      ver_request.fill:= 0;
      ver_request.length := 1;
      ver_request.general_status := 0;
      ver_request.fill1:= 0;
      ver_request.new_value:= request.new_value;
      callver (ver_request, ifrc, TRUE);
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;

    ELSE
      request.status := dsc$170_rre_bad_request;
      dyfstring ('BAD REQUEST', system_dayf);
    CASEND;

    rblock.resource_request := request;

  PROCEND dsp$claim_nve_resources;
?? TITLE := '***  S1CR_dualpp_check ***', EJECT ??
  PROCEDURE s1cr_dualpp_check;

    FUNCTION pps_r_partners_or_drivers
      (    pp_1: 0 .. 31;
           pp_2: 0 .. 31): boolean;

      pps_r_partners_or_drivers := FALSE;
      { if the pair is a partner pair everything is A-OK
      IF (pp_1 + 20(8) = pp_2) OR (pp_1 = pp_2 + 20(8)) THEN
        pps_r_partners_or_drivers := TRUE;
        RETURN;
      IFEND;
      { if they are both from the driver barrel thats okay too
      IF (pp_1 >= 20(8)) AND (pp_2 >= 20(8)) THEN
        pps_r_partners_or_drivers := TRUE;
        RETURN;
      IFEND;
    FUNCEND pps_r_partners_or_drivers;

    VAR
      temp_ver_request: ver_request_block,
      s1cr_request: dst$170_resource_request,
      s1cr_pair_req_ok: boolean,
      s1cr_req_list: array [1 .. 10] of dst$170_iou_resource,
      temp: dst$170_iou_resource,
      req_: 0 .. 11,
      i,
      j: integer;

  /s1cr_outer/
    BEGIN
      s1cr_pair_req_ok := FALSE;
      IF pps_r_partners_or_drivers (request.primary_pp.number, request.
            secondary_pp.number) THEN
        s1cr_pair_req_ok := TRUE;
        EXIT /s1cr_outer/;
      IFEND;
      {  get another pp and see if it is okay
      req_ := 0;

    /s1cr_inner/
      BEGIN
        REPEAT
          temp_ver_request.clear := 0;
          temp_ver_request.general_status := 0;
          temp_ver_request.length := 1;
          temp_ver_request.pp.kind := non_driver_pp;
          callver (temp_ver_request, rspp, TRUE);
          IF temp_ver_request.general_status <> 1 THEN
            EXIT /s1cr_inner/;
          IFEND;
          dyfstrnum ('GET PP', temp_ver_request.pp.primary, user_dayf);
          s1cr_request.primary_pp := request.channel_used;
          s1cr_request.primary_pp.number := temp_ver_request.pp.primary;

          { so now we have a new PP to consider as a candidate
          req_ := req_ + 1;
          IF pps_r_partners_or_drivers (s1cr_request.primary_pp.number,
                request.secondary_pp.number) THEN
            s1cr_pair_req_ok := TRUE;
            s1cr_req_list [req_] := request.primary_pp;
            request.primary_pp := s1cr_request.primary_pp;
            EXIT /s1cr_inner/;
          IFEND;
          IF pps_r_partners_or_drivers (s1cr_request.primary_pp.number,
                request.primary_pp.number) THEN
            s1cr_pair_req_ok := TRUE;
            s1cr_req_list [req_] := request.secondary_pp;
            request.secondary_pp := s1cr_request.primary_pp;
            EXIT /s1cr_inner/;
          IFEND;
          { this new pp gained nothing, so add it to the list and get another
          s1cr_req_list [req_] := s1cr_request.primary_pp;
          IF req_ > 1 THEN { perhaps 2 PPs from the list are ok
            FOR i := 1 TO (req_ - 1) DO
              FOR j := i TO (req_ - 1) DO
                IF pps_r_partners_or_drivers (s1cr_req_list [j].number,
                      s1cr_req_list [j + 1].number) THEN
                  s1cr_pair_req_ok := TRUE;
                  temp := request.primary_pp;
                  request.primary_pp := s1cr_req_list [j];
                  s1cr_req_list [j] := temp;
                  temp := request.secondary_pp;
                  request.secondary_pp := s1cr_req_list [j + 1];
                  s1cr_req_list [j + 1] := temp;
                  EXIT /s1cr_inner/;
                IFEND;
              FOREND;
            FOREND;
          IFEND;
        UNTIL (req_ = 10);
      END /s1cr_inner/;

      { now send the extra PPs back to NOS
      IF req_ > 0 THEN
        FOR i := 1 TO req_ DO
          temp_ver_request.clear := 0;
          temp_ver_request.general_status := 0;
          temp_ver_request.length := 1;
          temp_ver_request.pp.kind := non_driver_pp;
          temp_ver_request.pp.primary := s1cr_req_list [i].number;
          callver (temp_ver_request, rtpp, TRUE);
          IF ver_request.general_status > 1 THEN
            decode_and_display_error (ver_request.general_status);
            EXIT /s1cr_outer/;
          IFEND;
          dyfstrnum ('RETURN PP', s1cr_req_list [i].number, user_dayf);
        FOREND;
      IFEND;
    END /s1cr_outer/;
    IF NOT s1cr_pair_req_ok THEN {return the two in the request and set status
      request.status := dsc$170_rre_pp_not_available;
      { return the first one of the two
      temp_ver_request.clear := 0;
      temp_ver_request.general_status := 0;
      temp_ver_request.length := 1;
      temp_ver_request.pp.kind := non_driver_pp;
      temp_ver_request.pp.primary := request.primary_pp.number;
      callver (temp_ver_request, rtpp, TRUE);
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
        RETURN;
      IFEND;
      dyfstrnum ('RETURN PP', request.primary_pp.number, user_dayf);
      { return the second one of the two
      temp_ver_request.clear := 0;
      temp_ver_request.general_status := 0;
      temp_ver_request.length := 1;
      temp_ver_request.pp.kind := non_driver_pp;
      temp_ver_request.pp.primary := request.secondary_pp.number;
      callver (temp_ver_request, rtpp, TRUE);
      IF ver_request.general_status > 1 THEN
        decode_and_display_error (ver_request.general_status);
      IFEND;
      dyfstrnum ('RETURN PP', request.secondary_pp.number, user_dayf);
    IFEND;
  PROCEND s1cr_dualpp_check;
?? OLDTITLE ??
MODEND dsm$obtain_resources_for_ve;
