*COMDECK ALLDPH1
      OVERLAY(3,0)
      PROGRAM LDPH1 
C 
C 
C 
C        THIS IS THE FIRST PHASE OF THE LOADING PROCESS.  ALL MODULES 
C        WHICH BELONG TO DEFINED APPLICATIONS AND HAVE ABSOLUTE 
C        LOAD ADDRESSES SPECIFIED BY THE USER OR WILL BE PLACED IN
C        PAGED MEMORY ARE LOADED HERE.
C 
C 
C 
C 
C 
*CALL ALCOMMON
      DIMENSION PGAPPL(32),NEEDLD(2,500),NXTPGAD(32),APPFLEN(60)
      DIMENSION PAGEADR(32) 
      LOGICAL PGASGND(32),NPFLAG
      DATA MODULE /4/ 
C 
C 
C 
C 
C 
C        SET THE BIT MAP OF DEFINED APPLICATIONS TO ZERO. 
C 
      DEFMASK = 0 
C 
C        NOW BUILD UP A NEW BIT MAP 
C 
      DO 2 I=1,APPLCTR
C 
C        SET J TO COUNT FROM THE TOP DOWN, AS OPPOSED TO I, WHICH 
C        COUNTS FROM THE BOTTOM UP
C 
      J = APPLCTR + 1 - I 
C 
C        SHIFT THE APPLICATION BIT MAP LEFT ONE BIT 
C 
      DEFMASK = DEFMASK * 2 
C 
C        NOW LOOK TO SEE IF THIS APPLICATION IS DEFINED FOR THIS LOAD 
C 
      DO 1 K=1,DAPPLCT
      IF (AND(APPLNAM(J),ANAMASK).EQ.AND(DEFAPPL(K),ANAMASK)) GO TO 3 
    1 CONTINUE
C 
C        IF NOT DEFINED, DO NOT SET THIS BIT
C 
      GO TO 2 
C 
C        IF WE FOUND IT DEFINED, SET THE BIT ON I THE BIT MAP 
C 
    3 DEFMASK = OR (DEFMASK,1)
      IF(AND(DEFAPPL(K),BASEMSK) .NE. 0)
     X    APPLNAM(J) = OR(APPLNAM(J),BASEMSK) 
    2 CONTINUE
C 
C  -------------------------------------------------------------- 
C 
C        ABORT THE LOAD IF A DEFINED APPLICATION CONTAINS A MODULE
C        THAT HAD NO OBJECT TEXT. 
C 
      SWITCH = 1
      DO 7 I=1,MODCNTR
      IF (AND(MODTABL(5,I),BINOMSK).NE.0) GO TO 7 
      IF (AND(MODTABL(3,I),DEFMASK).NE.0) GO TO 930 
    7 CONTINUE
      IF (ERROR) GO TO 1000 
C 
C---------------------------------------------------- 
C 
C        ISSURE WARNING IF INPUT DIRECTIVES 
C        FORCE MODULE OVERLAP 
C 
C        SORT MODTABLE BY ADDRESS 
C 
      CALL SORTARY(SRTDADR,MODCNTR,4) 
C 
C        FIND FIRST MODULE WITH A 
C        LOAD ADDRESS AND BELONGING TO A DEFINED
C        APPLICATION
C 
      SWITCH = 1
      DO 3000 I=1,MODCNTR 
      IF(AND(MODTABL(4,SRTDADR(I)),ADRFLAG) .EQ. 0) GO TO 3000
      IF(AND(MODTABL(3,SRTDADR(I)),DEFMASK) .EQ. 0) GO TO 3000
      GO TO 3010
 3000 CONTINUE
C        NO FIXED ADDRESSES 
      GO TO 3050
 3010 IF(I .EQ.MODCNTR) GO TO 3050
      I1 = I + 1
      DO 3020 J=I1,MODCNTR
      IF(AND(MODTABL(4,SRTDADR(J)),ADRFLAG) .EQ. 0) GO TO 3020
      IF(AND(MODTABL(3,SRTDADR(J)),DEFMASK) .EQ. 0) GO TO 3020
      GO TO 3030
 3020 CONTINUE
C        NO MORE FIXED ADDRESSES
      GO TO 3050
C 
C        COMPARE ENDING ADDRESS OF ONE TO 
C                BEGINNING ADDRESS OF THE NEXT
C 
 3030 END1 = AND(MODTABL(1,SRTDADR(I)),LDADMSK) 
     1       + MODTABL(2,SRTDADR(I))
      BEGIN2 = AND(MODTABL(1,SRTDADR(J)),LDADMSK) 
      IF(END1 .GT. BEGIN2) GO TO 960
 3040 I = J 
      GO TO 3010
 3050 CONTINUE
C 
C        INITIALIZE THE APPLICATION LENGTHS FOR THE REPORT. 
C 
      DO 1040 I=1,60
      APPLMN(I) = 0 
 1040 APPLPGD(I) = 0
C 
C        SET HIPAGE TO THE HIGHEST PAGE NUMBER IN THE TARGET SYSTEM.
C 
      TEST = 65536
      DO 1001 I=2,32
      TEST = TEST + PAGSIZS(I)
      IF (TEST.GT.CORESIZ) GO TO 1002 
 1001 CONTINUE
 1002 HIPAGE = I - 1
C 
C        NOW CHECK FOR ANY MODULES HAVING PAGE= SPECIFIED WITH A
C        PAGE GREATER THAN THE MAXIMUM PAGE NUMBER. 
C 
      DO 1004 I=1,MODCNTR 
C 
C        IGNORE MODULES WITH NO DEFINED APPLICATIONS. 
C 
      IF (AND(MODTABL(3,I),DEFMASK).EQ.0) GO TO 1004
      PAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF)
      IF (PAGE.GT.HIPAGE) GO TO 950 
 1004 CONTINUE
C 
*        RETURN IF ERROR
C 
         IF (ERROR) RETURN
* 
*        SCAN MOD TABLE, CHANGING P=P TO P=NP IF MOD -
*          HAS NOT BEEN ASSIGNED, AND 
*          IS P=P, AND
*          IS NOT FILL, AND 
*          HAS MORE THAN ONE APPLICATION DEFINED
* 
10100    CONTINUE 
         DO 10200 PTR = 1,MODCNTR 
         MDTBPTR = SRTDADR(PTR) 
         IF ((MODTABL(1,MDTBPTR).AND.LDADMSK) .NE. 0) GO TO 10200 
         MDTBWD5 = MODTABL(5,MDTBPTR) 
         IF ((MDTBWD5.AND.PVALMSK) .NE. PVP) GO TO 10200
         MDTBWD4 = MODTABL(4,MDTBPTR) 
         IF ((MDTBWD4.AND.FILLMSK) .NE. 0) GO TO 10200
         IF (CNTBITS (MODTABL(3,MDTBPTR).AND.DEFMASK) .LT. 2) 
     1   GO TO 10200
         MODTABL(5,MDTBPTR) = (MDTBWD5.AND.PVALCMP).OR.PVNP 
         MODTABL(4,MDTBPTR) = MDTBWD4.OR.PEQNPMK
10200    CONTINUE 
* 
*        BRANCH IF NO SAM AREA OR NO SAM MODULES
* 
11100    CONTINUE 
         IF ((.NOT.SAMAFLG) .OR. (.NOT. SAMMFLG)) GO TO 13200 
         SAMPNTR = SAMSTRT
* 
*        IF ANY MODULO MODULES, SORT BY DECREASING MODULO LENGTH
* 
         IF (MDUFLAG) CALL SORTARY (SRTDMDU,MODCNTR,6)
* 
*        MAKE 2 PASSES - FIRST ONE GETS NP MODULES
* 
         NPFLAG = .TRUE.
* 
*        ASSIGN ALL SAM AREA MODULES WITH MODULO ADDRESSES FIRST
*          (IF ANY), THEN ALL OTHER SAM AREA MODULES
* 
11200    CONTINUE 
         DO 12900 SAMPTR = 1,MODCNTR
         MDTBPTR = SRTDADR(SAMPTR)
*        IF (.NOT. MDUFLAG) GO TO 12100 
         DO 12800 MDUPTR = 1,MODCNTR
         IF (.NOT. MDUFLAG) GO TO 12100 
         MDTBPTR = SRTDMDU(MDUPTR)
* 
*        SKIP MODULE IF - 
*          PASS 1 AND NOT NP, OR
*          ALREADY ASSIGNED, OR 
*          APPLICATION(S) NOT DEFINED, OR 
*          NOT SAM MODULE 
* 
         IF (NPFLAG .AND. 
     1   ((MODTABL(5,MDTBPTR).AND.PVALMSK) .NE. PVNP)) GO TO 12800
         IF ((MODTABL(1,MDTBPTR).AND.LDADMSK) .NE. 0) GO TO 12800 
         IF ((MODTABL(3,MDTBPTR).AND.DEFMASK) .EQ. 0) GO TO 12800 
         IF ((MODTABL(4,MDTBPTR).AND.SAMMASK) .EQ. 0) GO TO 12800 
* 
*        PICK UP MODULO ADDRESS 
* 
         MDUVALU = (MODTABL(4,MDTBPTR).AND.MDUMASK)+1 
* 
*        BRANCH IF NOT ZERO 
* 
         IF (MDUVALU .NE. 1) GO TO 11300
* 
*        ZERO MODULO ADDRESS FOUND - END OF MODULO MODULES
* 
         MDUFLAG = .FALSE.
         MDTBPTR = SRTDADR(SAMPTR)
         GO TO 12100
* 
*        APPLY MODULO ADJUSTMENT TO SAM AREA POINTER IF REQUIRED
* 
11300    CONTINUE 
         IF (MOD (SAMPNTR,MDUVALU) .NE. 0)
     1   SAMPNTR = ((SAMPNTR/MDUVALU)+1)*MDUVALU
         GO TO 12200
* 
*        SKIP MODULE IF - 
*          PASS 1 AND NOT NP, OR
*          ALREADY ASSIGNED, OR 
*          APPLICATION(S) NOT DEFINED, OR 
*          NOT SAM MODULE 
* 
12100    CONTINUE 
         IF (NPFLAG .AND. 
     1   ((MODTABL(5,MDTBPTR).AND.PVALMSK) .NE. PVNP)) GO TO 12900
         IF ((MODTABL(1,MDTBPTR).AND.LDADMSK) .NE. 0) GO TO 12900 
         IF ((MODTABL(3,MDTBPTR).AND.DEFMASK) .EQ. 0) GO TO 12900 
         IF ((MODTABL(4,MDTBPTR).AND.SAMMASK) .EQ. 0) GO TO 12900 
* 
*        BRANCH IF NO SAM AREA LEFT 
* 
12200    CONTINUE 
         IF (SAMPNTR .GE. SAMEND) GO TO 13100 
* 
*        BRANCH IF MODULE WOULD EXTEND PAST SAM AREA
* 
         TEST = SAMPNTR+MODTABL(2,MDTBPTR)
         IF (TEST .GE. SAMEND) GO TO 13100
* 
*        SCAN THE MOD TABLE, CHECK FOR ANOTHER MODULE ALREADY 
*          ASSIGNED TO THE AREA WHERE WE WANT TO PUT THIS ONE.
* 
         DO 12400 CHKPTR = 1,MODCNTR
* 
*        SKIP MODULE IF - 
*          NOT A DUMMY MODULE AND - 
*            ITS APPLICATION(S) NOT DEFINED, OR 
*            IT HAS NOT BEEN ASSIGNED AN ADDRESS
* 
         IF ((MODTABL(4,SRTDADR(CHKPTR)).AND.DUMYMSK) .NE. 0) 
     1   GO TO 12300
         IF ((MODTABL(3,SRTDADR(CHKPTR)).AND.DEFMASK) .EQ. 0) 
     1   GO TO 12400
         IF ((MODTABL(1,SRTDADR(CHKPTR)).AND.LDADMSK) .EQ. 0) 
     1   GO TO 12400
* 
*        BRANCH IF START ADDRESS OF CHECK MODULE .GE. END ADDRESS 
*          OF TEST MODULE (OK TO ASSIGN)
* 
12300    CONTINUE 
         CHKSTRT = MODTABL(1,SRTDADR(CHKPTR)).AND.LDADMSK 
         IF (CHKSTRT .GE. TEST) GO TO 12500 
* 
*        BRANCH IF END ADDRESS OF CHECK MODULE .LE. START ADDRESS 
*          OF TEST MODULE (CONTINUE SCAN) 
* 
         CHKEND = CHKSTRT+MODTABL(2,SRTDADR(CHKPTR))
         IF (CHKEND .LE. SAMPNTR) GO TO 12400 
* 
*        OVERLAP - ADJUST SAM AREA POINTER AND TRY AGAIN
* 
         SAMPNTR = CHKEND 
         IF (MDUFLAG) GO TO 11300 
         GO TO 12100
* 
12400    CONTINUE 
* 
*        ASSIGN MODULE
* 
12500    CONTINUE 
         MODTABL(1,MDTBPTR) = MODTABL(1,MDTBPTR)+SAMPNTR
         SAMPNTR = TEST 
         IF (.NOT. MDUFLAG) GO TO 12900 
12800    CONTINUE 
* 
12900    CONTINUE 
* 
*        END OF PASS
* 
         IF (.NOT. NPFLAG) GO TO 13200
         NPFLAG = .FALSE. 
         GO TO 11200
* 
*        NO SAM AREA LEFT 
* 
13100    CONTINUE 
         SAMMFLG = .FALSE.
* 
*        NO SAM OR DONE WITH SAM
* 
13200    CONTINUE 
* 
C 
C  -------------------------------------------------------------- 
C 
C        SKIP THE FOLLOWING LOGIC IF WE ARE GENERATING REPORTS NOW
C        OR IF NO PAGE REGISTER WAS DEFINED.
C 
      IF(.NOT. PGREGD) GO TO 1030 
C 
C        OTHERWISE, CALCULATE THE MAIN MEMORY PAGE AREA AS REQUIRING
C        ENOUGH SPACE TO COVER THE LARGEST PAGE.  THEN SET UP THIS
C        AREA AS A RESERVED AREA. 
C 
C        PGAREAB AND PGAREAE ARE THE BEGINNING AND ENDING ADDRESSES 
C        OF THIS MAIN MEMORY BLOCK. 
C 
      PGAREAB = PAGEREG * 2048
      BIGGEST = 0 
      DO 1028 I=2,HIPAGE
      IF (PAGSIZS(I).LE.BIGGEST) GO TO 1028 
      BIGGEST = PAGSIZS(I)
 1028 CONTINUE
      PGAREAE = PGAREAB + BIGGEST - 1 
      PAGSIZS(1) = BIGGEST
C 
C        INITIALIZE SOME STUFF
C 
 1030 DO 4 I=1,32 
C 
C        PGFULL(I) IS TRUE IF PAGE I IS FULL OR HAS AN APPLICATION
C        ASSIGNED WHICH CANNOT BE COMBINED WITH OTHERS. 
C 
      PGFULL(I) = .FALSE. 
C 
C        PGASGND(I) IS TRUE IF PAGE (I) HAS AT LEAST ONE MODULE LOADED
C        INTO IT. 
C 
      PGASGND(I) = .FALSE.
C 
C        PGSPACE(I) IS THE AMOUNT OF SPACE TAKEN BY ROUTINES LOADED 
C        TO PAGE I. 
C 
      PGSPACE(I) = 0
C 
C        PGAPPL(I) IS A BIT MAP OF THE APPLICATIONS WHICH MAY BE
C        INCLUDED IN PAGE I BY VIRTUE OF A MOD DIRECTIVE WITH 
C        PAGE=N SPECIFIED.
C 
    4 PGAPPL(I) = 0 
C 
C        SET THE FIXED LENGTH OF APPLICATIONS TO ZERO.
C 
      DO 1025 I=1,60
 1025 APPFLEN(I) = 0
C 
C  -------------------------------------------------------------- 
C 
C        GET THE START ADDRESS OF EACH PAGE, AND SET THE PAGE 
C        FULL FLAGS OFF 
C 
      FRSTPGA(1) = PGAREAB
      NXTPGAD(1) = PGAREAB
      LSTPGAD(1) = PGAREAE
      PGFULL(1) = .FALSE. 
      FRSTPGA(2) = 200000B
      NXTPGAD(2) = 200000B
      PGFULL(2) = .FALSE. 
      LSTPG = HIPAGE + 1
      DO 105 I=3,LSTPG
      FRSTPGA(I) = FRSTPGA(I-1) + PAGSIZS(I-1)
      NXTPGAD(I) = FRSTPGA(I) 
      PGFULL(I) = .FALSE. 
  105 LSTPGAD(I-1) = FRSTPGA(I) - 1 
C 
C        ASSIGN PAGE=N TO PAGEABLE OR FORCED MODULES WITH ADDRESSES,
C        BUT IGNORE MODULES WHICH ARE UNDEFINED.
C 
 106  DO 109 L=1,MODCNTR
      ADDR = AND(MODTABL(1,L),LDADMSK)
      IF (ADDR .EQ. 0) GO TO 109
      IF (AND(MODTABL(3,L),DEFMASK) .EQ. 0) GO TO 109 
      PGSTAT = SHIFT(AND(MODTABL(5,L),PVALMSK),-PVALSHF)
      IF (PGSTAT .NE. FORCE .AND. PGSTAT .NE. PAGABLE) GO TO 109
C 
C        DETERMINE THE PAGE TO WHICH THE MODULE BELONGS.
C 
      DO 107 L2=1,HIPAGE
      IF (ADDR .GE. FRSTPGA(L2) .AND. ADDR .LT. LSTPGAD(L2))
     X      GO TO 108 
 107  CONTINUE
      GO TO 109 
 108  MODTABL(5,L) = OR(AND(MODTABL(5,L),COMPL(PGVLMSK)), 
     X      SHIFT(L2,PGVLSHF),SHIFT(PAGABLE,PVALSHF)) 
 109  CONTINUE
C 
C  -------------------------------------------------------------- 
C 
C        COMPUTE THE PAGEABLE LENGTH OF EACH APPLICATION
C        EXCLUDING THE FILLER MODULES.
C 
      DO 50 I=1,MODCNTR 
C 
C        IGNORE MODULE IF P NOT EQUAL TO P OR F, OR A FILLER. 
C 
      BITS = SHIFT(AND(MODTABL(5,I),PVALMSK),-PVALSHF)
      IF (BITS .NE. PAGABLE .AND. BITS .NE. FORCE) GO TO 50 
      IF (AND(MODTABL(4,I),FILLMSK) .NE. 0) GO TO 50
C 
C        GET THE APPLICATION FLAG AND MODULE LENGTH.
C 
      APPLTMP = AND(MODTABL(3,I),DEFMASK) 
      IF (APPLTMP.EQ.0) GO TO 50
      LENGTH = MODTABL(2,I) 
C 
C        GET THE PAGE ASSIGNED TO THIS MODULE IF PAGE= GIVEN. 
C 
      MODPAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF) 
C 
C        NOW LOOK FOR AN APPLICATION IN THAT PAGE.
      DO 42 J=1,APPLCTR 
      IF (MOD(APPLTMP,2).EQ.0) GO TO 42 
C 
C        BRANCH IF PAGE= NOT GIVEN FOR THIS MODULE; 
C 
      IF (MODPAGE.EQ.0) GO TO 41
C 
C        ELSE MAKE SURE THIS APPLICATION IS IN THE SAME PAGE. 
C 
      IF (SHIFT(AND(APPLNAM(J),APAGMSK),-APAGSHF).NE.MODPAGE) GO TO 42
C 
C        ADD THE MODULE LENGTH TO THE LENGTH OF THE APPLICATION.
C 
   41 APPLNAM(J) = APPLNAM(J) + LENGTH
      GO TO 50
   42 APPLTMP = APPLTMP / 2 
   50 CONTINUE
C 
C  -------------------------------------------------------------- 
C        BUILD UP THE PGAPPL BIT MAP ARRAY BY FINDING MODS WITH 
C        PAGE=N SPECIFIED.
C 
      DO 5 I=1,MODCNTR
      PAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF)
C 
C        BRANCH IF NOT SPECIFIED FOR THIS MODULE
C 
      IF (PAGE.EQ.0) GO TO 5
C 
C        GET A BIT MAP OF APPLICATIONS DEFINED FOR THIS MODULE. 
C 
      THISAPP = AND(DEFMASK,MODTABL(3,I)) 
C 
C         INCLUDE IT IN THE PGAPPL BIT MAP
C 
      PGAPPL(PAGE) = OR(PGAPPL(PAGE),THISAPP) 
    5 CONTINUE
C 
C        NOW GO THROUGH, AND FOR EACH MOD WITH P=F SPECIFED,
C        ADD ITS LENGTH TO THE FORCED APPLICATION LENGTH. 
C 
      DO 1020 I=1,MODCNTR 
C 
C        IGNORE IF NO APPLICATIONS ARE DEFINED. 
C 
      TEST = AND(MODTABL(3,I),DEFMASK)
      IF (TEST.EQ.0) GO TO 1020 
C 
C        IGNORE IF P= IS NOT SET TO F.
C 
      IF (SHIFT(AND(MODTABL(5,I),PVALMSK),-PVALSHF).NE.FORCE) 
     1    GO TO 1020
C 
C        IF OK, FIND THE APPLICATION AND ADD THE LENGTH OF THIS MODULE. 
C 
      DO 1015 J=1,APPLCTR 
      IF (MOD(TEST,2) .EQ. 1) GO TO 1018
      TEST = TEST / 2 
 1015 CONTINUE
 1018 APPFLEN(J) = APPFLEN(J) + MODTABL(2,I)
 1020 CONTINUE
C 
C        ASSIGN PAGES TO THOSE APPLICATIONS WHICH CONTAIN A 
C        MODULE WHERE PAGE= WAS SPECIFIED, AND ONLY ONE APPLICATION 
C        IS DEFINED.
C 
      DO 1010 I=1,MODCNTR 
C 
C        IGNORE IF NO PAGE= WAS GIVEN OR NO APPLICATIONS DEFINED. 
C 
      PAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF)
      IF (PAGE.EQ.0) GO TO 1010 
      TEST = AND(MODTABL(3,I),DEFMASK)
      SAVE = COMPL(TEST)
      IF (TEST.EQ.0) GO TO 1010 
C 
C        NOW FIND OUT IF ONLY ONE APPLICATION WAS DEFINED.
C 
      COUNT = 0 
      DO 1006 J=1,APPLCTR 
C 
C        BRANCH AROUND IF THIS APPLICATION IS NOT DEFINED.
C 
      IF (MOD(TEST,2).EQ.0) GO TO 1006
      COUNT = COUNT + 1 
C 
C        DO NOT LOAD THIS IF MORE THAN ONE APPLICATION FOUND. 
C 
      IF (COUNT.GT.1) GO TO 1010
C 
C        OTHERWISE, SAVE THE APPLICATION NUMBER AND GO CHECK FOR MORE.
C 
      APPL = J
 1006 TEST = TEST / 2 
C 
C 
C        WE GET HERE IF ONLY ONE APPLICATION IS DEFINED.  MAKE SURE 
C        THE APPLICATION WAS NOT ALREADY LOADED INTO A DIFFERENT PAGE,
C        THEN LOAD IT AND DELETE IT FROM THE LIST OF CANDIDATES 
C        TO BE LOADED TO EACH PAGE. 
C 
      TEST = SHIFT(AND(APPLNAM(APPL),APAGMSK),-APAGSHF) 
      IF (TEST.NE.0 .AND. TEST.NE.PAGE) GO TO 940 
      APPLNAM(APPL) = OR (APPLNAM(APPL),SHIFT(PAGE,APAGSHF))
C 
C        THE FIRST APPLICATION ASSIGNED TO A PAGE IS ALLOCATED
C        SUFFICIENT SPACE TO LOAD THE MAXIMUM PAGE AMOUNT;
C        THEREAFTER ONLY THE FORCED LENGTH IS TESTED. 
C 
      IF (PGSPACE(PAGE) .EQ. 0) GO TO 1007
      PGSPACE(PAGE) = PGSPACE(PAGE) + APPFLEN(APPL) 
      IF (PGSPACE(PAGE).GT.PAGSIZS(PAGE)) GO TO 920 
      GO TO 2008
 1007 PGSPACE(PAGE) = AND(APPLNAM(APPL),APLNMSK)
C 
C        MODIFY THE PGAPPL ARRAY BY DELETING THE BIT RELATING TO
C        THE NEWLY PAGED APPLICATION. 
C 
 2008 DO 1008 J=1,HIPAGE
 1008 PGAPPL(J) = AND(PGAPPL(J),SAVE) 
C 
C        NOW SET A FLAG TO INDICATE SOMETHING IS STORED IN THIS 
C        PAGE, AND SET THE PAGE FULL IF THE APPLICATION HAS THE 
C        (NC) ATTRIBUTE.
C 
      PGASGND(PAGE) = .TRUE.
      IF (AND(APPLNAM(APPL),CVALMSK).NE.0) GO TO 1010 
      PGFULL(PAGE) = .TRUE. 
 1010 CONTINUE
C 
C 
C        NOW WE SET UP A MAP CALLED "REQUIRD" WHICH TELLS US WHICH
C        APPLICATIONS MAY BE ASSIGNED TO THIS PAGE, BUT DO NOT HAVE 
C        A SIMILAR ASSIGNMENT TO ANOTHER PAGE.  WE WILL THEN ASSIGN 
C        THESE APPLICATIONS TO THIS PAGE. 
C 
C 
C        SWITCH TELLS US IF WE FOUND ANY REQUIRED APPLICATIONS. 
C 
    6 SWITCH = 0
      DO 10 I=1,HIPAGE
C 
C        IGNORE IF THIS PAGE IS FULL. 
C 
      IF (PGFULL(I)) GO TO 10 
C 
C        INITIALLY, ALL APPLICATIONS ARE REQUIRED 
C 
      REQUIRD = PGAPPL(I) 
      IF (REQUIRD .EQ. 0) GO TO 10
C 
C        NOW GO THROUGH AND DELETE THOSE BITS WHICH ARE ALSO
C        CONTAINED IN OTHER PGAPPL MEMBERS. 
C 
      DO 8 J=1,HIPAGE 
C 
C        IGNORE IF THE PAGE IS FULL.
C 
      IF (PGFULL(J)) GO TO 8
      IF (J.EQ.I) GO TO 8 
      REQUIRD = AND(REQUIRD,COMPL(PGAPPL(J))) 
    8 CONTINUE
C 
C        IF NO APPLICATIONS ARE REQUIRED, GO TRY THE NEXT PAGE
C 
      IF (REQUIRD.EQ.0) GO TO 10
      VALUE = REQUIRD 
C 
C        NOW GO THROUGH AND ASSIGN THIS PAGE TO EACH APPLICATION
C        REQUIRING IT.
C 
      DO 9 J=1,APPLCTR
C 
C        BRANCH IF THIS APPLICATION BIT IS NOT SET
C 
      IF (MOD(VALUE,2).EQ.0) GO TO 9
C 
C        OTHERWISE, ASSIGN THE APPLICATION TO THE PAGE AND FLAG THE 
C        PAGE AS CONTAINING SOMETHING.
C 
C        DO NOT ASSIGN IT IF THERE IS ALREADY SOMETHING IN THE PAGE 
C        AND THIS APPLICATION HAS THE (NC) ATTRIBUTE, OR IF THE 
C        MINIMUM MODULES WILL NOT FIT.
C 
      IF (PGSPACE(I)+APPFLEN(J).GT.PAGSIZS(I)) GO TO 9
      IF (.NOT.PGASGND(I)) GO TO 11 
      IF (AND(APPLNAM(J),CVALMSK).EQ.0) GO TO 9 
   11 APPLNAM(J) = OR(APPLNAM(J),SHIFT(I,APAGSHF))
      PGASGND(I) = .TRUE. 
      PGSPACE(I) = PGSPACE(I) + AND(APPLNAM(J),APLNMSK) 
C 
C        SET THE SWITCH TO INDICATE AN ASSIGNMENT WAS PERFORMED.
C 
      SWITCH = 1
C 
C        IF THIS HAS THE (NC) ATTRIBUTE, FLAG THE PAGE FULL.
C 
      IF (AND(APPLNAM(J),CVALMSK).NE.0) GO TO 9 
      PGFULL(I) = .TRUE.
      GO TO 12
C 
C        SHIFT THE BIT MAP RIGHT ONE BIT
C 
    9 VALUE = VALUE/2 
C 
C        WHEN DONE, REMOVE THE APPLICATIONS JUST ASSIGNED FROM THE
C        BIT MAP. 
C 
   12 DO 1017 J=1,HIPAGE
 1017 PGAPPL(J) = AND(PGAPPL(J),COMPL(REQUIRD)) 
   10 CONTINUE
C 
C        IF WE ASSIGNED ANY REQUIRED APPLICATIONS, GO CHECK FOR MORE
C 
      IF (SWITCH.EQ.1)GO TO 6 
C 
C        NOW MAKE SURE ANY APPLICATIONS WHERE NC WAS SPECIFIED HAVE 
C        NOT BEEN FORCE-LOADED ALONG WITH ANOTHER APPLICATION.  ALSO, 
C        MARK THE PAGE FULL FOR NC-TYPE APPLICATIONS. 
C 
      DO 20 I=1,APPLCTR 
C 
C        GET THE PAGE ASSIGNED TO THIS APPLICATION
C 
      TEST = AND(APPLNAM(I),APAGMSK)
C 
C        IGNORE IT IF NOT ASSIGNED YET
C 
      IF (TEST.EQ.0) GO TO 20 
C 
C        CHECK FOR OTHER APPLICATIONS ASSIGNED TO THE SAME PAGE 
C 
      DO 15 J=1,APPLCTR 
      IF (I.EQ.J) GO TO 15
C 
C        O.K. IF THAT APPL = (C)
C 
      IF (AND(APPLNAM(J),CVALMSK).NE.0) GO TO 15
C 
C        OTHERWISE, IF IT IS ON THE SAME PAGE AS THE TEST APPLICATION,
C        WE HAVE AN ERROR 
C 
      IF (AND(APPLNAM(J),APAGMSK).EQ.TEST) GO TO 910
   15 CONTINUE
C 
C        IF ALL O.K. AND THIS APPLICATION IS (NC), SET THE PAGE FULL
C        AND FLAG NO MORE APPLICATIONS FOR THIS PAGE. 
C 
      IF (AND(APPLNAM(I),CVALMSK).NE.0) GO TO 20
      VALUE = SHIFT(TEST,-APAGSHF)
      PGFULL(VALUE) = .TRUE.
      PGAPPL(VALUE) = 0 
   20 CONTINUE
C 
C  -------------------------------------------------------------- 
C 
C        NOW GO THROUGH ALL THE MODS, AND FOR ANY THAT HAVE 
C        BEEN SPECIFIED WITH PAGE= WITHOUT HAVING HAD THE 
C        DESIGNATED PAGE ASSIGNED TO ITS APPLICATION, ASSIGN
C        TO EACH APPLICATION ENCOUNTERED ITS PROPER PAGE. 
C 
C 
C        NONEED IS A BIT MAP OF THOSE APPLICATIONS THAT HAVE
C        PAGES ASSIGNED IN THIS LOOP. 
C 
      NONEED = 0
      DO 30 I=1,HIPAGE
C 
C        GET THE BIT MAP OF REMAINING APPLICATIONS THAT MAY BE
C        CONTAINED IN THIS PAGE.
C 
      VALUE = AND(PGAPPL(I),COMPL(NONEED))
C 
C        IGNORE THIS PAGE IF NONE TO CHECK. 
C 
      IF (VALUE.EQ.0) GO TO 30
C 
C        OTHERWISE, ASSIGN THE FIRST ENCOUNTERED APPLICATION TO 
C        THIS PAGE. 
C 
      DO 24 J=1,APPLCTR 
C 
C        BRANCH IF THIS APPLICATION BIT IS NOT SET. 
C 
      IF (MOD(VALUE,2).EQ.0) GO TO 24 
C 
C        DO NOT LOAD HERE IF THERE IS ALREADY STUFF HERE AND THIS 
C        APPLICATION HAS THE (NC) ATTRIBUTE.
C 
      IF (PGSPACE(I)+APPFLEN(J).GT.PAGSIZS(I)) GO TO 24 
      IF (AND(APPLNAM(J),CVALMSK).NE.0) GO TO 22
      IF (PGASGND(I)) GO TO 24
      PGFULL(I) = .TRUE.
C 
C        SET THE PAGE NUMBER FOR THIS APPLICATION.
C 
   22 APPLNAM(J) = OR(APPLNAM(J),SHIFT(I,APAGSHF))
      PGASGND(I) = .TRUE. 
C 
C        INDICATE THAT THIS APPLICATION HAS BEEN LOADED.
C 
      NONEED = OR(NONEED,SHIFT(1,J-1))
      PGSPACE(I) = PGSPACE(I) + AND(APPLNAM(J),APLNMSK) 
      GO TO 30
C 
C        SHIFT TO LOOK AT THE NEXT APPLICATION BIT. 
C 
   24 VALUE = VALUE/2 
   30 CONTINUE
C 
C  -------------------------------------------------------------- 
C        GO THROUGH AND ASSIGN ANY REMAINING APPLICATIONS 
C        WITH (NC) SPECIFIED TO FREE PAGES. 
C 
      APPLFLG = DEFMASK 
      DO 40 I=1,APPLCTR 
C 
C        DO NOT ASSIGN IF THIS APPLICATION IS NOT DEFINED FOR THIS MODULE.
C 
      IF (MOD(APPLFLG,2).EQ.0) GO TO 40 
C 
C        IGNORE IF (C). 
C 
      IF (AND(APPLNAM(I),CVALMSK).NE.0) GO TO 40
C 
C        LOOK FOR A FREE PAGE.
C 
      START = 1 
   34 DO 35 J=START,HIPAGE
      IF (.NOT.PGASGND(J)) GO TO 37 
   35 CONTINUE
C 
C        BRANCH IF NO FREE PAGES LEFT.
C 
      GO TO 40
C 
C        ASSIGN THIS APPLICATION TO THE FREE PAGE.
C 
   37 NEWSIZE = PGSPACE(J) + APPFLEN(I) 
C 
C        IF THIS WILL NOT FIT, GO TRY ANOTHER PAGE. 
C 
      IF (NEWSIZE.LE.PAGSIZS(J)) GO TO 38 
      START = J + 1 
      GO TO 34
   38 PGSPACE(J) = NEWSIZE
      PGASGND(J) = .TRUE. 
      PGFULL(J) = .TRUE.
      APPLNAM(I) = OR(APPLNAM(I),SHIFT(J,APAGSHF))
   40 APPLFLG = APPLFLG / 2 
C 
C  -------------------------------------------------------------- 
C 
C        LOOK FOR MODS WITH PAGE= SPECIFED, BUT NO ASSOCIATED 
C        APPLICATIONS IN THAT PAGE.  TRY TO ASSIGN AN APPLICATION,
C        AND GIVE AN ERROR IF NO PAGES OR APPLICATIONS LEFT.
C 
      DO 60 I=1,MODCNTR 
      TEST = AND(MODTABL(3,I),DEFMASK)
      SAVE = TEST 
C 
C        IGNORE IF NOT DEFINED APPLICATIONS OR PAGE= NOT SPECIFIED. 
C 
      IF (TEST.EQ.0) GO TO 60 
      MPAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF) 
      IF (MPAGE.EQ.0) GO TO 60
C 
C        IGNORE IF WE CAN FIND AN APPLICATION LOADED TO THIS PAGE.
C 
      DO 52 J=1,APPLCTR 
      IF (MOD(TEST,2).EQ.0) GO TO 52
      IF (SHIFT(AND(APPLNAM(J),APAGMSK),-APAGSHF).EQ.MPAGE) GO TO 60
   52 TEST = TEST / 2 
C 
C        LOOK FOR ASSOCIATED APPLICATIONS THAT HAVE NOT BEEN ASSIGNED 
C        A PAGE TO SEE IF THEY FIT. 
C 
      TEST = SAVE 
      DO 54 J=1,APPLCTR 
      IF (MOD(TEST,2).EQ.0) GO TO 54
      IF (AND(APPLNAM(J),APAGMSK).NE.0) GO TO 54
      NEWSIZE = PGSPACE(MPAGE) + APPFLEN(J) 
      IF (NEWSIZE.GT.PAGSIZS(MPAGE)) GO TO 54 
C 
C        IF EVERYTHING IS O.K., LOAD IT.
C 
      APPLNAM(J) = OR(APPLNAM(J),SHIFT(MPAGE,APAGSHF))
      PGSPACE(MPAGE) = PGSPACE(MPAGE) + AND(APPLNAM(J),APLNMSK) 
      GO TO 60
   54 TEST = TEST / 2 
C 
C        ERROR IF NO APPLICATION CAN BE LOADED. 
C 
      GO TO 920 
   60 CONTINUE
C 
C        SORT THE APPLICATIONS IN ORDER OF DECREASING LENGTH. 
C 
      CALL SORTARY(SRTDAPL,APPLCTR,3) 
C 
C        NOW ASSIGN REMAINING APPLICATIONS AS THEY FIT INTO PAGES.
C 
      DO 72 MODE = 1,2
      DO 70 I=1,APPLCTR 
C 
C        IGNORE IF THIS APPLICATION IS UNDEFINED OR UNPAGEABLE. 
C 
      IF (AND(DEFMASK,SHIFT(1,SRTDAPL(I)-1)) .EQ. 0) GO TO 70 
      APPLICN = APPLNAM(SRTDAPL(I)) 
      LENGTH = AND(APPLICN,APLNMSK) 
      IF (LENGTH .EQ. 0) GO TO 70 
C 
C        IGNORE IT IF THIS APPLICATION HAS ALREADY BEEN ASSIGNED. 
C 
      IF (AND(APPLICN,APAGMSK).NE.0) GO TO 70 
C 
C        OTHERWISE, TRY TO FIND A SPOT FOR IT.
C 
      DO 65 J=1,HIPAGE
C 
C        LOAD THE LARGEST APPLICATIONS FIRST. 
C 
      IF (MODE .EQ. 1 .AND. LENGTH .LT. PAGSIZS(J)) GO TO 65
C 
C        FORGET THIS ONE IF THE PAGE IS ALREADY FULL. 
C 
      IF (PGFULL(J)) GO TO 65 
C 
C        OTHERWISE, GET A TEMPORARY NEW LENGTH TO SEE IF IT FITS. 
C 
      NEWLENG = PGSPACE(J) + LENGTH 
      IF(PGSPACE(J) .EQ. 0 .AND. MODE .EQ. 1) GO TO 63
C 
C        FORGET IT IF IT DOESN'T FIT. 
C 
      IF (NEWLENG.GT.PAGSIZS(J)) GO TO 65 
C 
C        ELSE ADD IT IN PERMANENTLY, THEN FLAG THE APPLICATION
C        FOR THIS PAGE. 
C 
   63 PGSPACE(J) = NEWLENG
      APPLNAM(SRTDAPL(I)) = OR(APPLICN,SHIFT(J,APAGSHF))
      GO TO 70
   65 CONTINUE
   70 CONTINUE
   72 CONTINUE
C 
C 
C        FOR ANY APPLICATIONS STILL NOT ASSIGNED, PLACE THEM
C        IN THE PAGES WITH THE BIGGEST HOLES LEFT.
C 
      DO 80 I=1,APPLCTR 
C 
C        IGNORE IF THIS APPLICATION IS UNDEFINED OR UNPAGEABLE. 
C 
      II2 = SRTDAPL(I)
      IF (AND(DEFMASK,SHIFT(1,II2-1)) .EQ. 0) GO TO 80
      APPLICN = APPLNAM(II2)
      LENGTH = AND(APPLICN,APLNMSK) 
      IF (LENGTH .EQ. 0) GO TO 80 
C 
C        IGNORE IF ALREADY ASSIGNED.
C 
      IF (AND(APPLICN,APAGMSK).NE.0) GO TO 80 
C 
C        SET THE BIGGEST SPACE FOUND TO ZERO, WITH A PAGE OF ZERO.
C 
      BIGGEST = 0 
      INDEX = 0 
C 
C        LOOP THROUGH AND SET INDEX TO THE PAGE NUMBER WITH THE 
C        LARGEST FREE SPACE, WITH BIGGEST EQUAL TO THE AMOUNT 
C        OF SPACE.
C 
      DO 75 J=1,HIPAGE
      IF (PGFULL(J)) GO TO 75 
      REMAIN = PAGSIZS(J) - PGSPACE(J)
      IF (REMAIN.LE.BIGGEST) GO TO 75 
      BIGGEST = REMAIN
      INDEX = J 
   75 CONTINUE
C 
C        SET THIS APPLICATION IN THE PAGE WITH THE BIGGEST HOLE,
C        THEN FLAG THAT PAGE FULL.
C 
      IF (BIGGEST.LT.APPFLEN(II2)) GO TO 80 
      APPLNAM(II2) = OR(APPLNAM(II2),SHIFT(INDEX,APAGSHF),APRTMSK)
      PGFULL(INDEX) = .TRUE.
   80 CONTINUE
C 
C 
C        SET UP THE RESERVE TABLE FOR THOSE MODULES WITH ABSOLUTE 
C        MEMORY ADDRESSES SPECIFIED BY THE USER.
C 
      RSVCTR2 = RSRVCTR 
      DO 90 I=1,MODCNTR 
C 
C        IGNORE THIS MOD IF IT HAS NO DEFINED APPLICATIONS. 
C 
      IF (AND(DEFMASK,MODTABL(3,I)).EQ.0) GO TO 90
C 
C        IGNORE IF IT HAS NO ABSOLUTE ADDRESS.
C 
      ADDR = AND(MODTABL(1,I),LDADMSK)
      IF (ADDR.EQ.0) GO TO 90 
C 
C        ELSE SET THE NEXT RESERVE ARRAY POSITION TO INDICATE 
C        THE START AND END OF THE RESERVED AREA, AS WELL AS 
C        THE INDEX OF THE MODTABL ENTRY.
C 
      RSVCTR2=RSVCTR2 + 1 
      RESERVD(1,RSVCTR2) = AND(MODTABL(1,I),LDADMSK)
      RESERVD(2,RSVCTR2) = RESERVD(1,RSVCTR2) + MODTABL(2,I) - 1
      RESERVD(3,RSVCTR2) = I
   90 CONTINUE
C 
C        SORT THE RESERVED AREAS IN ORDER OF INCREASING LENGTH. 
C 
      CALL SORTARY(SRTDRSV,RSVCTR2,2) 
C 
C   ------------------------------------------------------------------- 
C 
C        LOAD THE MODULES TO THEIR ACTUAL LOAD ADDRESSES.  USE THE
C        PAGE= PARAMETER IF SPECIFIED, OR ELSE LOAD TO THE FIRST
C        APPLICATION PAGE WHERE IT FITS 
C 
C 
C        NEEDPTR POINTS TO THE NEEDLD ARRAY, WHICH IS USED TO KEEP
C        TRACK OF MODULES THAT WON'T FIT, SO WE CAN CHECK FOR HOLES 
C        LATER. 
C 
      NOFIT = 0 
      NEEDPTR = 0 
      LOOP = 1
  205 DO 250 I=1,MODCNTR
C 
C        IGNORE IT IF IT ALREADY HAS A LOAD ADDRESS 
C 
      IF (AND(MODTABL(1,I),LDADMSK).NE.0) GO TO 250 
C 
C        ALSO IGNORE IT IF IT HAS NO DEFINED APPLICATIONS OR
C        IF P=NP WAS SPECIFIED. 
C 
      IF (AND(DEFMASK,MODTABL(3,I)).EQ.0) GO TO 250 
      BITS = SHIFT(AND(MODTABL(5,I),PVALMSK),-PVALSHF)
      IF (BITS .NE. PAGABLE .AND. BITS .NE. FORCE) GO TO 250
C 
C        IF THIS IS THE FIRST TIME THROUGH, LOAD ONLY THOSE MODULES 
C        WITH P=F SPECIFIED.
C 
      IF (LOOP .EQ. 1  .AND.  BITS .NE. FORCE) GO TO 250
      IF (AND(MODTABL(4,I),FILLMSK) .NE. 0) GO TO 250 
C 
C        GET THE MODULE PAGE, IF ONE WAS GIVEN. 
C 
      MPAGE = SHIFT(AND(MODTABL(5,I),PGVLMSK),-PGVLSHF) 
C 
C        NOW ASSIGN AN ADDRESS IN A PAGE WHERE AN ASSIGNED APPLICATION
C        RESIDES, OR THE PAGE= PAGE.
C 
      START = 1 
  208 DO 210 J=START,APPLCTR
C 
C        DO NOT LOAD IF THIS IS A PARTIALLY-PAGED APPLICATION.
C 
      IF (MPAGE.NE.0 .OR. LOOP.EQ.1) GO TO 209
      IF (AND(APPLNAM(J),APRTMSK).NE.0) GO TO 210 
C 
C        DO NOT LOAD TO THIS APPLICATION'S PAGE IF IT DOES NOT
C        BELONG TO THIS APPLICATION.
C 
  209 IF (AND(MODTABL(3,I),SHIFT(1,J-1)).EQ.0) GO TO 210
C 
C        GET THE PAGE FOR THIS APPLICATION, BUT DO NOT LOAD THE 
C        MODULE HERE IF THIS APPLICATION HAS NO PAGE. 
C 
      APAGE = SHIFT(AND(APPLNAM(J),APAGMSK),-APAGSHF) 
      IF (APAGE.EQ.0) GO TO 210 
C 
C        IF PAGE= WAS GIVEN FOR THE MODULE, MAKE SURE THIS APPLICATION
C        RESIDES IN THE REQUIRED PAGE.
C        BRANCH OUT IF WE CAN LOAD THE MODULE TO THIS PAGE. 
C 
      IF (APAGE.EQ.MPAGE .OR. MPAGE.EQ.0) GO TO 220 
  210 CONTINUE
C 
C        IF WE CAN'T FIND A PLACE TO PUT IT, GO SAVE A POINTER
C        TO IT SO WE CAN TRY LATER. 
C 
      GO TO 245 
C 
C        COMPUTE THE START AND ENDING ADDRESSES, TO MAKE SURE IT
C        CAN FIT ON THE PAGE.  BRANCH IF IT FITS. 
C 
  220 APPLTMP = J 
      STARTAD = NXTPGAD(APAGE)
      ENDAD = STARTAD + MODTABL(2,I) - 1
      IF (ENDAD.LT.LSTPGAD(APAGE)) GO TO 225
C 
C        IF IT DOESN'T FIT, BUT CAN GO TO ANY PAGE, TRY ANOTHER PAGE. 
C        OTHERWISE, GO SAVE A POINTER SO WE CAN TRY IT LATER. 
C 
      IF (MPAGE.NE.0) GO TO 245 
      START = J + 1 
      GO TO 208 
C 
C        NOW SEE IF THE MODULE WILL OVERLAY ANY RESERVED AREAS IF 
C        WE PUT IT HERE.  BRANCH OUT IF IT WILL.
C 
  225 DO 230 J=1,RSVCTR2
      TESTLOW = RESERVD(1,J)
      TESTHI = RESERVD(2,J) 
      IF (STARTAD.LE.TESTLOW .AND. ENDAD.GE.TESTLOW) GO TO 240
      IF (STARTAD.GT.TESTLOW .AND. STARTAD.LT.TESTHI) GO TO 240 
  230 CONTINUE
C 
C        IF WE GET HERE, IT FITS.  SET THE LOAD ADDRESS AND INCREMENT 
C        THE NEXT LOAD ADDRESS FOR THE PAGE.
C 
      MODTABL(1,I) = OR(MODTABL(1,I),STARTAD) 
      NXTPGAD(APAGE) = ENDAD + 1
      APPLPGD(APPLTMP) = APPLPGD(APPLTMP) + MODTABL(2,I)
      GO TO 250 
C 
C        IF THERE IS A CONFLICT WITH A RESERVED AREA, ADVANCE THE 
C        NEXT AVAILABLE LOCATION POINTER BEYOND THE RESERVED LOCATIONS. 
C 
  240 NXTPGAD(APAGE) = TESTHI + 1 
      GO TO 220 
C 
C        IF WE CAN'T FIND A SPACE FOR A MODULE NOW, SAVE A POINTER
C        TO IT SO WE CAN CHECK FOR HOLES LATER. 
C 
  245 NOFIT = NOFIT + 1 
      IF (MPAGE.EQ.0) GO TO 250 
      NEEDPTR = NEEDPTR + 1 
      NEEDLD(1,NEEDPTR) = I 
      NEEDLD(2,NEEDPTR) = MPAGE 
  250 CONTINUE
C 
C 
C        SORT THE MODTABL ARRAY ACCORDING TO ADDRESS, AND BRANCH
C        OUT IF ALL MODULES WERE SUCCESSFULLY LOADED. 
C 
      CALL SORTARY(SRTDADR,MODCNTR,4) 
      IF (LOOP .GE. 2) GO TO 251
      LOOP = LOOP + 1 
      GO TO 205 
  251 IF (NOFIT .EQ. 0) GO TO 400 
      NOFIT = NOFIT - NEEDPTR 
C 
C        IF SOME MODULES WITH PAGE= SPECIFIED WOULD NOT FIT,
C        LOAD THEM INTO ANY HOLES, IF POSSIBLE. 
C 
      IF (NEEDPTR .EQ. 0) GO TO 300 
  255 DO 290 I=1,NEEDPTR
C 
C        GET THE BOUNDARY ADDRESSES OF THE PAGE WHERE THIS MUST GO. 
C 
      ADDRLOW = FRSTPGA(NEEDLD(2,I))
      ADDRHI  = LSTPGAD(NEEDLD(2,I))
C 
C        GET THE LENGTH OF THE MODULE TO BE PLACED. 
C 
      LENGTH = MODTABL(2,NEEDLD(1,I)) 
C 
C        NOW LOOK FOR HOLES.
C 
      DO 260 J=1,MODCNTR
      J2=SRTDADR(J) 
C 
C        TESTADR IS THE LOAD ADDRESS OF THE NEXT MODULE.  HOLBEGN IS
C        THE LAST ADDRESS OF THAT MODULE, AND HOLEND IS THE START 
C        ADDRESS OF THE MODULE FOLLOWING THE NEXT ONE.  THE SIZE OF 
C        THE HOLE IS THEN HOLEND-HOLBEGN. 
C 
      TESTADR = AND(MODTABL(1,J2),LDADMSK)
      IF (TESTADR .LT. ADDRLOW) GO TO 260 
      IF (TESTADR .GE. ADDRHI)  GO TO 263 
      HOLBEGN = TESTADR + MODTABL(2,J2) - 1 
      HOLEND = AND(MODTABL(1,SRTDADR(J+1)),LDADMSK) 
      IF (HOLEND .GT. ADDRHI) HOLEND = ADDRHI 
      IF(HOLEND-HOLBEGN .LT. LENGTH) GO TO 260
      IF (HOLBEGN+LENGTH .LE. ADDRHI) GO TO 265 
  260 CONTINUE
C 
C        BRANCH IF WE CAN'T FIND A BIG ENOUGH HOLE. 
C 
  263 GO TO 290 
C 
C        IF WE FIND A HOLE, MAKE SURE IT ISN'T TAKEN UP BY A
C        RESERVED AREA. 
C 
  265 DO 270 K=1,RSVCTR2
      IF(RESERVD(1,K).LE.HOLBEGN .AND. RESERVD(2,K).GE.HOLBEGN)GOTO 275 
      IF(RESERVD(1,K).GT.HOLBEGN .AND. RESERVD(1,K).LE.HOLEND)GO TO 277 
  270 CONTINUE
C 
C        BRANCH IF EVERYTHING IS O.K. 
C 
      GO TO 280 
C 
C        GET A NEW PREVIOUS HIGH. 
C 
  275 HOLBEGN = RESERVD(2,K) + 1
      GO TO 279 
C 
C        GET A NEW NEXT LOW.
C 
  277 HOLEND = RESERVD(1,K) - 1 
C 
C        BRANCH OUT IF THERE IS NOT ENOUGH ROOM.
C 
  279 IF (HOLEND-HOLBEGN .LT. LENGTH) GO TO 290 
      GO TO 265 
C 
C        SINCE SPACE EXISTS, INSERT THE MODULE. 
C 
  280 MODTABL(1,NEEDLD(1,I)) = OR(MODTABL(1,NEEDLD(1,I)),HOLBEGN+1) 
      TEST = AND(MODTABL(3,NEEDLD(1,I)),DEFMASK)
      DO 281 K=1,APPLCTR
      IF (MOD(TEST,2) .NE. 0) GO TO 283 
  281 TEST = TEST/2 
  283 APPLPGD(K) = APPLPGD(K) + LENGTH
C 
C        PUT THIS MODULE IN THE ARRAY OF MODULE NAMES SORTED BY ADDRESS,
C        SO WE DON'T THINK IT'S A HOLE LATER. 
C 
      DO 282 K=1,MODCNTR
  282 IF (SRTDADR(K) .EQ. NEEDLD(1,I)) GO TO 284
  284 K = K + 1 
      DO 285 L=K,J
  285 SRTDADR(L-1) = SRTDADR(L) 
      SRTDADR(J) = NEEDLD(1,I)
  290 CONTINUE
C 
C 
C 
C        NOFIT IS THE NUMBER OF MODULES THAT COULD NOT BE LOADED
C        BECAUSE THEY BELONGED TO ONLY PARTIALLY-PAGED APPLICATIONS,
C        AND DID NOT HAVE THE PAGE= PARAMETER SUPPLIED. 
C 
  300 IF (NOFIT.EQ.0) GO TO 400 
      NOFIT = 0 
C 
C        SORT THE MODTABL ARRAY ACCORDING TO LOAD ADDRESS, THEN RE-LOAD 
C        THE NEEDLD ARRAY WITH THE REMAINING MODULES TO BE LOADED.
C 
      CALL SORTARY(SRTDADR,MODCNTR,4) 
      NEEDPTR = 0 
      DO 330 I2=1,MODCNTR 
      I = SRTDADR(I2) 
C 
C        IF WE FIND A MODULE WITH A LOAD ADDRESS, WE HAVE LOOKED
C        AT ALL MODULES THAT HAVE NOT YET BEEN LOADED.
C 
      IF (AND(MODTABL(1,I),LDADMSK).NE.0) GO TO 340 
C 
C        IGNORE ANY MODULES THAT HAVE NO DEFINED APPLICATIONS OR THAT 
C        ARE NOT PAGEABLE.
C 
      TEST = AND(MODTABL(3,I),DEFMASK)
      IF (TEST.EQ.0) GO TO 330
      IF (AND(MODTABL(4,I),FILLMSK) .NE. 0) GO TO 330 
      IF (SHIFT(AND(MODTABL(5,I),PVALMSK),-PVALSHF).NE.PAGABLE)GO TO 330
C 
C        OTHERWISE, IT IS A CANDIDATE FOR LOADING NOW.  FIND A PARTIAL
C        APPLICATION CONTAINING THIS MODULE.
C 
      DO 320 J=1,APPLCTR
C 
C        IGNORE IF THIS APPLICATION DOES NOT CONTAIN THIS MODULE, OR
C        IF THIS MODULE IS NOT PARTIALLY PAGED. 
C 
      IF (MOD(TEST,2).EQ.0) GO TO 320 
      IF (AND(APPLNAM(J),APRTMSK).EQ.0) GO TO 320 
C 
C        OTHERWISE, SET UP FOR AN ATTEMPT AT LOADING. 
C 
      NEEDPTR = NEEDPTR + 1 
      NEEDLD(1,NEEDPTR) = I 
      NEEDLD(2,NEEDPTR) = SHIFT(AND(APPLNAM(J),APAGMSK),-APAGSHF) 
      GO TO 330 
  320 TEST = TEST / 2 
  330 CONTINUE
  340 IF (NEEDPTR.EQ.0) GO TO 400 
      GO TO 255 
C 
C        RE-CALCULATE THE NEXT AVAILABLE ADDRESS FOR EACH PAGE. 
C 
 400  CALL SORTARY(SRTDADR,MODCNTR,4) 
      DO 405 J=1,HIPAGE 
 405  NXTPGAD(J) = FRSTPGA(J) 
      DO 415 K=1,HIPAGE 
      DO 410 K2=1,MODCNTR 
      ADDR = AND(MODTABL(1,SRTDADR(K2)),LDADMSK)
      IF (AND(MODTABL(3,SRTDADR(K2)),DEFMASK) .EQ. 0) GO TO 410 
      IF (ADDR .LT. FRSTPGA(K)) GO TO 410 
      IF (ADDR .GE. LSTPGAD(K)) GO TO 415 
      NXTPGAD(K) = NXTPGAD(K) + MODTABL(2,SRTDADR(K2))
 410  CONTINUE
 415  CONTINUE
C 
C        SORT THE MODULES BY DECREASING LENGTH. 
C 
      CALL SORTARY(SRTDADR,MODCNTR,5) 
C 
C        LOAD ONLY PAGEABLE, FILLER MODULES.
C 
      DO 430 M=1,MODCNTR
      M2 = SRTDADR(M) 
C 
C        SKIP ADDRESSED, UNDEFINED, NON-PAGEABLE, NON-FILLER MODULES. 
C 
      IF (AND(MODTABL(1,M2),LDADMSK) .NE. 0) GO TO 430
      IF (AND(MODTABL(3,M2),DEFMASK) .EQ. 0) GO TO 430
      IF (AND(MODTABL(4,M2),FILLMSK) .EQ. 0) GO TO 430
      IF (SHIFT(AND(MODTABL(5,M2),PVALMSK),-PVALSHF) .NE. 
     X    PAGABLE) GO TO 430
      LENGTH = MODTABL(2,M2)
C 
C        DETERMINE WHETHER THE MODULE WILL FIT ON A PARTICULAR PAGE,
C        AND ASSIGN AN ADDRESS IF IT DOES.
C 
      DO 420 N=1,HIPAGE 
      TESTFIT = NXTPGAD(N) + LENGTH - 1 
      IF (TESTFIT. GT. LSTPGAD(N)) GO TO 420
         IF ((TESTFIT .AND. 177777B) .EQ. 177777B) GO TO 420
      MODTABL(1,M2) = MODTABL(1,M2) + NXTPGAD(N)
      NXTPGAD(N) = TESTFIT + 1
      GO TO 430 
 420  CONTINUE
 430  CONTINUE
      GO TO 1000
C 
C 
C 
C 
C        ERROR BRANCHES 
C 
C 
C 
C        AN APPLICATION HAD THE (NC) ATTRIBUTE, BUT OTHER APPLICATIONS
C        WERE REQUIRED TO RESIDE IN THE SAME PAGE BECAUSE THEY
C        CONTAIN MODULES WITH THE PAGE= PARAMETER.
C 
  910 CALL ERRMSG(MODULE,33)
      GO TO 1000
C 
C        COMBINING ALL REQUIRED APPLICATIONS FOR A PAGE CAUSES A
C        PAGE OVERFLOW. 
C 
  920 CALL ERRMSG(MODULE,35)
      GO TO 1000
C 
C 
C        A MODULE REQUIRED FOR A DEFINED APPLICATION HAD NO 
C        OBJECT TEXT. 
C 
  930 GO TO (931,932), SWITCH 
  931 SWITCH = 2
      CALL ERRMSG(MODULE,45)
  932 WRITE (ERRFIL,933) MODTABL(1,I) 
  933 FORMAT (10X,A6) 
      GO TO 7 
C 
C 
C        PAGE= SPECIFICATIONS OF DIFFERENT MODULES FORCES THE 
C        LOADING OF ONE APPLICATION TO SEVERAL PAGES. 
C 
  940 CALL ERRMSG(MODULE,47)
      GO TO 1000
C 
C 
C        MODULE ASSIGNED TO PAGE OUTSIDE OF MEMORY RANGE. 
C 
  950 GO TO (951,952), SWITCH 
  951 SWITCH = 2
      CALL ERRMSG(MODULE,46)
  952 WRITE (ERRFIL,933) MODTABL(1,I) 
      GO TO 1004
C 
C        MODULE OVERLAP FORCED BY INPUT DIRECTIVES
C 
  960 IF(RPTGEN) GO TO 3040 
      GO TO (961,962) SWITCH
  961 SWITCH = 2
      CALL REMARK("*WARNING-MODULE OVERLAP")
      WRITE(ERRFIL,964) 
  962 WRITE(ERRFIL,963)MODTABL(1,SRTDADR(I)),MODTABL(1,SRTDADR(J))
  963 FORMAT(10X,A6,3X,A6)
  964 FORMAT(1X,19H***** WARNING *****,3X 
     1        *INPUT DIRECTIVES ASSIGN OVERLAPPING ADDRESSES TO:*)
      GO TO 3040
 1000 RETURN
      END 
          IDENT  PH1SUBS
          ENTRY  CNTBITS
* 
* 
* 
 CNTBITS  PS
          SA2    X1          WORD TO X2 
          CX6    X2          BIT COUNT TO X6
          EQ     CNTBITS     EXIT 
* 
          END 
C 
C 
