*DECK AKDRARE                                                            RPN0627
*CALL COMUSETXT 
PROC AK$RARE;  #ROUTINE WITH ALL AK RARE CODE MODULES#                   GAG0905
      BEGIN                                                              GAG0905
     XREF BEGIN                                                          GAG0905
          FUNC MXPR$AA;                                                  GAG0905
          PROC LOCB$AA;                                                  GAG0905
          PROC NUBL$AK;                                                  GAG0905
          PROC INCH$AA;                                                  GAG0905
          PROC UNCH$AA;                                                  GAG0905
          PROC NWEM$AK;                                                  GAG0905
          PROC UNFX$AA;                                                  GAG0905
          PROC DELL$AK ;                                                 GAG0905
          PROC RPPT$AA ;                                                 GAG0905
          PROC MSGF$AA ;                                                 GAG0905
          PROC ALTR$AA ;                                                 GAG0905
          PROC CURR$AK ;                                                 GAG0905
          FUNC MACH$AK ;                                                 GAG0905
          PROC FIXX$AA;                                                  GAG0905
          PROC CONS$AA;                                                  GAG0905
          PROC RCKN$AK;                                                  GAG0905
          PROC RLOV$AK;                                                  GAG0905
          PROC CURR$AA;                                                  GAG0905
          PROC PWOK$AK;                                                  GAG0905
          PROC SEBL$AA;                                                  GAG0905
          PROC MSGZ$AA;                                                  GAG0905
          PROC SETR$AA;                                                  GAG0905
          PROC IMPR$AA;                                                  GAG0905
          PROC RPGT$AA;                                                  GAG0905
          PROC EXRP$AA ;
          PROC SPAC$AK;                                                  GAG0905
          PROC CYCL$AK ;                                                 GAG0905
          PROC ADRC$AK ;                                                 GAG0905
          PROC SVEC$AK ;
          LABEL EXIT$AA;                                                 GAG0905
          END                                                            GAG0905
     XDEF BEGIN                                                          GAG0905
          PROC SPC1$AK;                                                  GAG0905
          PROC MALR$AK;                                                  GAG0905
          PROC MKRM$AK;                                                  GAG0905
          END                                                            GAG0905
                                                                         GAG0905
          ITEM IX;    #INDUCTION VARIABLE#                               GAG0905
                                                                         GAG0905
CONTROL EJECT;                                                           GAG0905
PROC SPC1$AK(RCLG,PRU);                                                  GAG0905
          BEGIN                                                          GAG0905
 #                                                                       GAG0905
* *   SPC1$AK - SPACE SEARCH ROUTINE             PAGE  1                 GAG0905
* *   PROGRAM - RARE$AK                                                  GAG0905
* *   THIS IS A CONTINUATION OF SPAC$AK                                  GAG0905
* *   R.P.NG.                                   DATE.                    GAG0905
* 1CD SPC1$AK - CONTINUE THE SPACE SEARCH PROCESS.                       GAG0905
*                                                                        GAG0905
* CD  FUNCTION                                                           GAG0905
*                                                                        GAG0905
*     THIS LOGICALLY BELONGS TO SPAC$AK.  IT IS BROKEN UP FOR THE        GAG0905
*     PURPOSE OF BEING ABLE TO PUT THIS SECTION OF CODE IN THE RARE CODE GAG0905
*     CAPSULE.  THIS CODE WILL CONTINUE THE SEARCH FOR A BLOCK IN THE    GAG0905
*     FILE THAT HAS ENOUGH SPACE TO SATISFY A CERTAIN SPACE REQUEST.     GAG0905
*                                                                        GAG0905
* CD  ENTRY CONDITIONS                                                   GAG0905
*                                                                        GAG0905
*     THE TWO PARAMETERS ARE                                             GAG0905
*     RCLG - AMOUNT OF SPACE NEEDED IN HALF WORDS.                       GAG0905
*     PRU - PRU NUMBER OF BLOCK TO BE EXCLUDED FROM SEARCH, 0 IF NONE.   GAG0905
*     P<FSTT$AA> MUST BE SET TO USER FSTT.                               GAG0905
*     GCOM CELL NEWBNUM IS ZERO FROM SPAC$AK.                            GAG0905
*                                                                        GAG0905
* CD  EXIT CONDITIONS.                                                   GAG0905
*                                                                        GAG0905
*     NEWBNUM CONTAINS THE PRU OF A BLOCK THAT QUALIFIES IF ONE IS FOUND GAG0905
*     P<BLOK$AA> IS NOT PRESERVED ACROSS THIS CALL.                      GAG0905
*                                                                        GAG0905
* CD  ERROR CONDITIONS.                                                  GAG0905
*                                                                        GAG0905
*     NONE DIRECTLY REPORTED BY THIS ROUTINE.                            GAG0905
*                                                                        GAG0905
* CD  CALLED ROUTINES.                                                   GAG0905
*                                                                        GAG0905
*     MXPR$AA - TO DETERMINE THE LAST PRU USED IN FILE.                  GAG0905
*     ATEI$AA - EXTEND FILE BY ONE BLOCK.                                GAG0905
*     LOCB$AA - TO READ A BLOCK ON THE SERIAL PROBE OR SEARCH.           GAG0905
*     INCH$AA AND UNCH$AA - TO BIAS AGE OF READ IN BLOCK.                GAG0905
*     NWEM$AK - TO UPDATE THE MOST EMPTY TABLE.                          GAG0905
*     EXRP$AA - TO SIGNAL A READ ERROR IF IT TURNS UP HERE. 
*                                                                        GAG0905
* CD  DESCRIPTION.                                                       GAG0905
*                                                                        GAG0905
*     AS MENTIONED BEFORE, THIS IS STAGE 3 THROUGH 5 OF THE SPACE SEARCH GAG0905
*     PROCESS, AND IS LOGICALLY A CONTINUATION OF SPAC$AK.  WE SHOULD    GAG0905
*     THEREFORE REFER BACK TO SPAC$AK FOR MORE DETAIL DESCRIPTION.       GAG0905
*                                                                        GAG0905
* CD  STAGE 3 - SERIAL PROBE FOR SPACE.                                  GAG0905
*     IF THE FILE IS EMPTY, STAGE 3 IS SKIPPED.                          GAG0905
 #                                                                       GAG0905
          ITEM RCLG,PRU,PER,TOTAL,IX,BN,LAST,PZ;                         GAG0905
          TOTAL = 0;                                                     GAG0905
          PZ =FSBLKSIZ;                                                  GAG0905
          LAST = MXPR$AA -PZ;  #LAST BLOCK S PRU#                        GAG0905
          IF FSBLKCNT NQ 0  #FILE MUST NOT BE EMPTY FOR 3#               GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
 #                                                                       GAG0905
* 0   COMPUTE PER AS THE INDEX OF EMPTINESS DESIRED.                     GAG0905
*     TOTAL UP THE NUMBER OF BLOCKS IN THE FILE WHICH ARE KNOWN TO       GAG0905
*     BE EMPTY ENOUGH FROM THE PERCENT EMPTY TABLE (INTO TOTAL).         GAG0905
 #                                                                       GAG0905
              IX = (BRICK(0) - DBLKHEDSZ) * 2 ; #MAXMT# 
              PER = (RCLG * 10) / IX ;
              IF IX*PER LS RCLG*10
              THEN
                  BEGIN 
                  PER = PER + 1 ; 
                  END 
              FOR IX = PER STEP 1 UNTIL 10 DO                            GAG0905
                  BEGIN                                                  GAG0905
                  TOTAL = TOTAL + FSPCEMTAB[IX];                         GAG0905
                  END                                                    GAG0905
 #                                                                       GAG0905
*     IF NUMBER OF BLOCKS IN FILE / TOTAL IS LS FSPRCNTBK, WE SHOULD     GAG0905
*     TRIGGER A SERIAL PROBE FOR SPACE.  THE ACTUAL READING UP AND       GAG0905
*     EXAMINATION OF A BLOCK IS DONE IN THE SUBPROC READABLK.            GAG0905
 #                                                                       GAG0905
              IF FSPRCNTBK * TOTAL GQ FSBLKCNT                           GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  PER = FSPROBLIM;    #LIMIT OF TIMES OF PROBE#          GAG0905
                  FOR IX = 1 STEP 1 UNTIL PER DO                         GAG0905
                      BEGIN                                              GAG0905
                      IF FSTRIGBNO + PZ GQ LAST                          GAG0905
                      THEN                                               GAG0905
                          BEGIN                                          GAG0905
                          FSTRIGBNO = PRU3;                              GAG0905
                          END                                            GAG0905
                      ELSE                                               GAG0905
                          BEGIN                                          GAG0905
                          FSTRIGBNO = FSTRIGBNO + PZ;                    GAG0905
                          END                                            GAG0905
                      BN = FSTRIGBNO;                                    GAG0905
                      READABLK;                                          GAG0905
                      IF NEWBNUM NQ 0 THEN RETURN; #EXIT IF BLOCK FOUND# GAG0905
                      END                                                GAG0905
                  END                                                    GAG0905
              END     #END STAGE 3#                                      GAG0905
 #                                                                       GAG0905
* CD      STAGE 4 - EXTEND FILE BY ONE BLOCK IF POSSIBLE BY CALLING      GAG0905
*         NUBL$AK.                                                       GAG0905
 #                                                                       GAG0905
          NUBL$AK;                                                       GAG0905
          IF NEWBNUM NQ 0                                                GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              RETURN;                                                    GAG0905
              END   #END STAGE 4#                                        GAG0905
                                                                         GAG0905
 #                                                                       GAG0905
* CD  STAGE 5 - SERIAL PASS OF FILE FOR SPACE.                           GAG0905
* 0   WHEN 4 FAILS, WE WILL HAVE TO MAKE A SERIAL PASS OF THE FILE       GAG0905
*     LOOKING FOR SPACE.  IF TOTAL FROM 3 IS ZERO, THIS STAGE IS OF      GAG0905
*     COURSE SKIPPED.  IF FSSPSRCNT IS LOWER THAN 2 * DFMETLG (LENGTH    GAG0905
*     OF MOST EMPTY TABLE OF FILE), WE SKIPPED THIS STAGE ALSO AS        GAG0905
*     SPACE REQUESTS ON THIS FILE IS TOO TIGHT.  BEFORE WE GO INTO THE   GAG0905
*     SERIAL SEARCH, WE PUT OUT A NOTE WARNING THE USER OF WHAT WE ARE   GAG0905
*     DOING.  FSSPSRCNT IS RESET TO ZERO.  AS SOON AS A BLOCK WITH       GAG0905
*     SPACE IS FOUND, WE QUIT.  AFTER THE PASS, THE MOST EMPTY TABLE     GAG0905
*     SHOULD PRETTY WELL REFLECT THE MOST QUALIFIED EMPTY BLOCKS IN THE  GAG0905
*     FILE.  THE SUBPROC READABLK IS USED FOR READING UP A BLOCK.        GAG0905
 #                                                                       GAG0905
          IF TOTAL NQ 0 AND FSSPSRCNT GR 2 * DFMETLG                     GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              FSSPSRCNT = 0;                                             GAG1025
              MSGZ$AA ( NOTE047 ) ;                                      GAG0919
              FOR BN = PRU3 STEP PZ UNTIL LAST DO                        GAG0905
                  BEGIN                                                  GAG0905
                  READABLK;                                              GAG0905
                  IF NEWBNUM NQ 0 THEN RETURN;                           GAG0905
                  END                                                    GAG0905
              END  #END STAGE 5#                                         GAG0905
                                                                         GAG0905
CONTROL EJECT;                                                           GAG0905
          PROC READABLK;                                                 GAG0905
          BEGIN                                                          GAG0905
          ITEM DD ;                                                      GAG0905
 #                                                                       GAG0905
* 1CD SUBPROC - READABLK.                                                GAG0905
*     THIS SUBPROC READS UP (OR LOCATE) A BLOCK ACCORDING TO BN SET IN   GAG0905
*     THE MAIN PROC.  IT IS CALLED BY THE SERIAL PROBE AND THE SERIAL    GAG0905
*     PASS.  AFTER THE BLOCK IS READ IN, IT IS EXAMINED TO SEE IF THE    GAG0905
*     IF THE BLOCK WILL QUALIFY.  NOTE THAT IF BN IS EQUAL TO PRU, NO    GAG0905
*     READING IS DONE (PRU IS THE BLOCK TO BE EXCLUDED).  AFTER THE      GAG0905
*     LOCB$AA CALL, IF BLNFTRD IS SET, THAT MEANS LOCB$AA DID NOT READ   GAG0905
*     A BLOCK IN, BUT HAD JUST LOCATED A BLOCK IN CORE.  SINCE STAGE 1   GAG0905
*     WOULD HAVE EXAMINED THIS BLOCK ALREADY, WE AGAIN RETURN WITHOUT    GAG0905
*     DOING ANY WORK.  IF THE BLOCK IS INDEED READ IN, AND IT HAS SOME   GAG0905
*     AVAILABLE SLOTS FOR USE, WE THEN CHECK TO SEE IF THERE IS ENOUGH   GAG0905
*     ROOM IN THE BLOCK.  IF THERE IS, NEWBNUM IS SET TO THAT BLOCK PRU  GAG0905
*     AND WE EXIT.  NOTE THAT THE MOST EMPTY TABLE DOES NOT HAVE TO BE   GAG0905
*     UPDATED FOR THIS ENTRY, AS WE WILL BE USING THIS BLOCK RIGHT AWAY. GAG0905
*     IF THE BLOCK DOES NOT QUALIFY, WE WILL THEN TRY TO UPDATE THE      GAG0905
*     MOST EMPTY TABLE WITH THIS NEW BLOCK ENTRY.  THE BLOCK IS ALSO     GAG0905
*     MOVED TO THE TAIL END OF THE KICKOUT CHAIN, AS IT REALLY HAS NO    GAG0905
*     VALUE FOR OUR PURPOSE.                                             GAG0905
 #                                                                       GAG0905
          IF BN EQ PRU THEN RETURN;  #DO NOTHING IF BN EXCLUDED#         GAG0905
          LOCB$AA(BN,1);  #TRY TO READ IN BLOCK#                         GAG0905
          IF P<BLOK$AA> LS 0
          THEN
              BEGIN 
              EXRP$AA ; 
              END 
          IF BLNFTRD NQ 0 THEN RETURN;  #SKIP IF IN CORE BLOCK#          GAG0905
          IF BLFRESLTS NQ 0 OR RC LS FSBKFACTR  #FREE SLOTS#             GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              DD = EC - RCLG ;                                           GAG0905
              IF DD GR 0 OR ( DD EQ 0 AND BLFRESLTS[0] NQ 0 )            GAG0905
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  NEWBNUM = BN;                                          GAG0905
                  RETURN;  #FOUND THE NEEDED BLOCK#                      GAG0905
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN  #BLOCK NOT QUALIFIED#                           GAG0905
                  NWEM$AK;  #UPDATE MOST EMPTY TABLE#                    GAG0905
                  END                                                    GAG0905
              END                                                        GAG0905
          UNCH$AA(P<BLOK$AA>); #MOVE TO END OF K/O#                      GAG0905
          INCH$AA(P<BLOK$AA>,BFBCHNPTR);                                 GAG0905
          END  #END SUBPROC#                                             GAG0905
          END  #END SPC1$AK#                                             GAG0905
CONTROL EJECT;                                                           GAG0905
PROC MALR$AK ( N ) ;                                                     GAG0905
          BEGIN                                                          GAG0905
 #                                                                       AFB0926
* *   MALR$AK - MOVE AN ALIEN RECORD OUT OF ITS SLOT.          PAGE 1    AFB0926
* *   A.F.R.BROWN                                                        AFB0926
* 1DC MALR$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     TO MOVE THE CURRENT RECORD                                         AFB0926
*     INTO SOME OTHER SLOT IN THE FILE, AND MAKE ALL THE                 AFB0926
*     CONSEQUENT ADJUSTMENTS THAT MAY BE NECESSARY.                      AFB0926
*     TWO POSSIBLE REASONS FOR THIS -- (1) WE ARE TRYING TO MAKE         AFB0926
*     ROOM IN A BLOCK, AND KICKING OUT ALIENS IS ONE WAY, AND            AFB0926
*     REPLACING NATIVE RECORDS WITH ONE-WORD PLACEHOLDERS (MOTHERS)      AFB0926
*     IS ANOTHER.                                                        AFB0926
*     (2) A PUT-BY-KEY IS TAKING PLACE,                                  AFB0926
*     AND NAMES THE SLOT IN QUESTION. SINCE IT IS ONLY AN                AFB0926
*     ALIEN IN THE SLOT, THERE IS NO LOGICAL DIFFICULTY,                 AFB0926
*     BUT THE PRACTICAL COMPLICATION MAY BE GREAT.                       AFB0926
*                                                                        AFB0926
*     THIS SUBROUTINE IS CALLED AT ONE PLACE, IN                         AFB0926
*     SUBROUTINE PUT$AK, USING THE MACRO ((MALRDAK)) WHICH               AFB0926
*     CAUSES THE AK RARE CAPSULE TO BE LOADED IF NECESSARY,              AFB0926
*     AND THEN A JUMP INTO MALR$AK. THIS IS WHEN A                       AFB0926
*     PUT-BY-KEY NAMES THE SLOT IN QUESTION. IT IS ALSO CALLED           AFB0926
*     AT ONE PLACE IN SUBROUTINE MKRM$AK, BY A SIMPLE                    AFB0926
*     SUBROUTINE CALL. THIS IS WHEN WE ARE JUST TRYING TO MAKE           AFB0926
*     ROOM IN A BLOCK.                                                   AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     THERE IS ONE PARAMETER, PASSED IN THE NORMAL SYMPL                 AFB0926
*     WAY. THIS IS 0 IF THE CURRENT RECORD HAS TO BE MOVED               AFB0926
*     RIGHT OUT OF THE BLOCK, AND NON-ZERO IF IT WOULD ALSO              AFB0926
*     BE ACCEPTABLE FOR THE CURRENT RECORD, WHICH IS AN ALIEN, TO        AFB0926
*     BE MOVED TO A DIFFERENT SLOT IN THE SAME BLOCK.                    AFB0926
*                                                                        AFB0926
*     RECFWA IS THE FWA OF THE CURRENT RECORD IN ITS BLOCK IMAGE.        AFB0926
*     RECLNG IS ITS LENGTH IN WORDS, INCLUDING, IF IT IS AN ALIEN, THE   AFB0926
*       PREFIX WORD AT THE BEGINNING, WHICH POINTS BACK TO THE ALIEN-S   AFB0926
*       MOTHER.                                                          AFB0926
*     RECPTR IS A COPY OF THE RECORD POINTER.                            AFB0926
*     RPUCC, A FIELD OF RECPTR, IS 14 IF THE RECORD IS AN ALIEN,         AFB0926
*       OTHERWISE LESS THAN 10, FOR A NATIVE.                            AFB0926
*     P<BLOK$AA> POINTS TO THE BLOCK IMAGE CONTAINING THE RECORD.        AFB0926
*     PTREEWRD[0], THE FIRST WORD OF THE PTREE, POINTS TO THE            AFB0926
*       RECORD IN ITS BLOCK IMAGE. NOW THE CONVENTION IS                 AFB0926
*       THAT PTREEWRD[0] IS USED TO POINT TO A RECORD THAT IS            AFB0926
*       IN ITS OWN RIGHT PLACE OR TO A PLACEHOLDER (MOTHER),             AFB0926
*       AND IN THE LATTER CASE, PTREEWRD[1] OUGHT TO BE USED TO          AFB0926
*       POINT TO THE ALIEN TO WHICH THE PLACEHOLDER ALSO POINTS.         AFB0926
*       HOWEVER, IT WORKS OUT THAT WHEN MALR$AK IS CALLED,               AFB0926
*       PTREEWRD[0] MAY POINT TO AN ALIEN. IF SO, EARLY IN THE           AFB0926
*       PROCEEDINGS, THIS POINTER IS MOVED TO PTREEWRD[1],               AFB0926
*       AND THE ADDRESS OF THE PLACEHOLDER THAT POINTS TO THIS           AFB0926
*       ALIEN (ITS MOTHER) IS STORED IN PTREEWRD[0].                     AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     IF THE CURRENT RECORD WAS AN ALIEN, IT HAS BEEN MOVED SOMEWHERE    AFB0926
*     ELSE, ITS SLOT IS VACANT, AND ALL THE CORRESPONDING ADJUSTMENTS    AFB0926
*     HAVE BEEN MADE. IF NOT AN ALIEN, IT HAS BEEN COPIED TO SOME OTHER  AFB0926
*     BLOCK, WHERE IT NOW SITS AS AN ALIEN, AND ITS ORIGINAL PLACE       AFB0926
*     IS NOW OCCUPIED BY A MOTHER, OR PLACEHOLDER, THAT POINTS TO THAT   AFB0926
*     NEW ALIEN.                                                         AFB0926
*                                                                        AFB0926
*     NEWLNG AND NEWFWA HAVE BEEN PRESERVED AND RESTORED.                AFB0926
*     PTREEWRD[0] POINTS TO THE SAME SLOT THAT WAS CURRENT ON ENTRY.     AFB0926
*       IF THEN ALIEN, NOW VACANT. ELSE IT WAS NATIVE AT ENTRY, AND      AFB0926
*       NOW CONTAINS AN OVERFLOW POINTER (MOTHER, PLACEHOLDER).          AFB0926
*     CURPTR = 0.                                                        AFB0926
*     RECFWA, RECLNG, RECLWA ARE THE FWA, LENGTH IN WORDS, AND           AFB0926
*       LWA+1 OF THE DEAD RECORD AT THE VACATED SLOT, OR OF THE          AFB0926
*       PLACEHOLDER NOW FILLING THAT SLOT.                               AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     NONE THAT ARE NOTED HERE. MALR$AK FAILS IN THE END ONLY            AFB0926
*     IF SPAC1$AK FAILS, THE FILE BEING TOO FULL. IF THAT                AFB0926
*     HAPPENS, THE ERROR MESSAGE IS ISSUED FROM SPAC1$AK, WE             AFB0926
*     RETURN TO MALR$AK, THEN SET NEWBNUM = -1 TO MARK THE ERROR, 
*     AND RETURN. 
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     FIXX$AA - TO FREEZE IN CORE THE BLOCK THAT CONTAINS THE            AFB0926
*       RECORD THAT HAS TO BE SHIFTED.                                   AFB0926
*     UNFX$AA - TO UNFREEZE IT AND RETURN IT TO THE KICKOUT CHAIN        AFB0926
*       WHEN ALL IS DONE.                                                AFB0926
*     CURR$AA - TO LOCATE THE BLOCK AND RECORD TO WHICH THE CURRENT      AFB0926
*       WORD OF THE PTREE POINTS.                                        AFB0926
*     CURR$AK - SAME AS CURR$AA, PLUS SAFEGUARDS AGAINST OUT-OF-         AFB0926
*       RANGE BLOCK OR RECORD NUMBER. USED HERE TO LOCATE THE MOTHER     AFB0926
*       RECORD TO WHICH AN ALIEN POINTS BACK. THE POINTER, TAKEN         AFB0926
*       FROM THE DATA BLOCK, MIGHT BE BAD.                               AFB0926
*     MACH$AK - TO MATCH THE CURRENT RECORD WITH ITS MOTHER OR           AFB0926
*       DAUGHTER. HAVING FOLLOWED A POINTER TO GET TO THE MOTHER         AFB0926
*       OR DAUGHTER, WE SEE WHETHER THE MOTHER OR DAUGHTER CONTAINS      AFB0926
*       A POINTER BACK TO THE STARTING RECORD, AS IT SHOULD.             AFB0926
*       MACH$AK IS A FUNCTION THAT = 0 IF ALL IS WELL, NONZERO           AFB0926
*       IF BAD.                                                          AFB0926
*     MSGF$AA - TO ISSUE A FATAL ERROR MESSAGE.                          AFB0926
*     RCKN$AK - TO DECIDE IF THERE IS ROOM IN THE CURRENT BLOCK          AFB0926
*       FOR A GIVEN RECORD, AND TO CALL CONS$AA WITHOUT FURTHER          AFB0926
*       ADO IF THIS WOULD BE NECESSARY TO CONSOLIDATE THE ROOM           AFB0926
*       AND MAKE IT AVAILABLE FOR THE GIVEN RECORD.                      AFB0926
*     ADRC$AK - TO INSERT A NEW RECORD INTO THE CURRENT BLOCK,           AFB0926
*       IN PLACE OF THE CURRENT RECORD, WHICH MAY OR MAY NOT             AFB0926
*       BE DEAD.                                                         AFB0926
*     CONS$AA - TO CONSOLIDATE THE EMPTY SPACE IN THE CURRENT            AFB0926
*       BLOCK, BY SQUEEZING OUT DEAD RECORDS. IN AN AK FILE,             AFB0926
*       DEAD RECORD POINTERS ARE NOT SQUEEZED OUT, THOUGH IN             AFB0926
*       AN IS OR DA FILE THEY WOULD BE.                                  AFB0926
*     RPGT$AA - TO FETCH A RECORD POINTER BY NUMBER FROM THE             AFB0926
*       CURRENT BLOCK TO VARIABLE RECPTR.                                AFB0926
*     RPPT$AA - TO DO THE REVERSE.                                       AFB0926
*     ALTR$AA - TO DO THE FORMALITIES BEFORE ALTERING A BLOCK            AFB0926
*       IMAGE FOR WHAT MAY BE THE FIRST TIME.                            AFB0926
*     SPAC$AK - TO LOOK FOR A BLOCK WITH ENOUGH FREE SPACE               AFB0926
*       FOR A RECORD NEWLNG CHARACTERS LONG.                             AFB0926
*     PWOK$AK - HAVING FOUND THE BLOCK, TO CHOOSE A FREE SLOT,           AFB0926
*       PUT IN THE RECORD, AND ADD TO IT A POINTER BACK TO               AFB0926
*       THE MOTHER RECORD.                                               AFB0926
*     RLOV$AK - HAVING DONE PWOK$AK, TO STORE AS THE MOTHER              AFB0926
*       RECORD A POINTER TO THE POSITION AT WHICH PWOK$AK                AFB0926
*       STORED THE DAUGHTER (ALIEN).                                     AFB0926
*     DELL$AK - TO DELETE AN ALIEN RECORD, AFTER A COPY OF               AFB0926
*       IT HAS BEEN STORED SOMEWHERE ELSE. THIS FREES THE SLOT           AFB0926
*       FORMERLY OCCUPIED BY THE ALIEN.                                  AFB0926
*     SVEC$AK - TO SET OLDEC (IN NRO$AK) TO THE EFFECTIVE EMPTY 
*       COUNT OF THE BLOCK. THIS WE ALWAYS DO BEFORE DOING SOMETHING
*       THAT WILL AFFECT THE COUNT, SO THAT AFTERWARDS, OLDEC 
*       AND THE NEW EFFECTIVE EMPTY COUNT TELL PCEM$AK HOW TO 
*       UPDATE THE PERCENT-EMPTY TABLE. THE EFFECTIVE EMPTY COUNT 
*       =EC IF THERE IS AT LEAST ONE AVAILABLE SLOT IN THE BLOCK, 
*       OR =0 IF NONE.
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     NEWFWA AND NEWLNG ARE THE FWA AND LENGTH IN CHARACTERS OF          AFB0926
*       A NEW RECORD, AS USED BY ROUTINES LIKE ADRC$AK AND               AFB0926
*       RCKN$AK. MALR$AK SAVES THEM AT THE BEGINNING AND RESTORES        AFB0926
*       THEM AT THE END. IN BETWEEN, THEY TAKE VARIOUS VALUES            AFB0926
*       WHEN THE ALIEN AND MOTHER ARE STORED.                            AFB0926
*     RECFWA AND RECLNG ARE THE FWA AND LENGTH IN WORDS OF THE           AFB0926
*       CURRENT RECORD, AS SET BY CURR$AA, CURR$AK, AND OTHERS.          AFB0926
*     QMF IS SET TO 0 BY CURR$AK IF THE CURRENT WORD OF THE PTREE        AFB0926
*       POINTS TO A BLOCK BEYOND THE END OF THE FILE, OR A RECORD        AFB0926
*       WHOSE NUMBER IS GREATER THAN THE NUMBER OF RECORDS               AFB0926
*       ACTUALLY IN THE BLOCK, OR TO AN ALIEN OR DEAD RECORD.            AFB0926
*       IT IS SET TO 1 BY CURR$AK IF THE CURRENT WORD OF THE PTREE       AFB0926
*       POINTS TO A RECORD THAT EXISTS AND BELONGS TO ITS PLACE.         AFB0926
*     SPLTFLG IS SET BY RCKN$AK, GREATER THAN 0 IF THE CURRENT BLOCK     AFB0926
*       HAS NOT ENOUGH FREE SPACE FOR A NEW RECORD OF NEWLNG             AFB0926
*       CHARACTERS. TO 0 OR NEGATIVE IF THE BLOCK HAS ENOUGH FREE        AFB0926
*       SPACE. NEGATIVE MEANS THAT CONS$AA HAS BEEN CALLED FOR THE       AFB0926
*       BLOCK, BUT FUNCTIONALLY HERE THERE IS NO DIFFERENCE BETWEEN      AFB0926
*       NEGATIVE AND 0.                                                  AFB0926
*     NEWBNUM - SET BY SPAC$AK TO THE PRU NUMBER OF A BLOCK THAT         AFB0926
*       HAS ENOUGH EMPTY SPACE. IF IT IS SET TO 0, THE FILE IS           AFB0926
*       TOO FULL AND CANNOT BE EXTENDED.                                 AFB0926
*     RECPTR IS SET BY RPGT$AA TO BE A COPY OF A GIVEN RECORD POINTER,   AFB0926
*       OR USED BY RPPT$AA TO REPLACE A GIVEN RECORD POINTER.            AFB0926
*     RNO IS GENERALLY THE CURRENT RECORD NUMBER, SET BY CURR$AA OR      AFB0926
*       CURR$AK, AND USED BY ADRC$AK OR DELL$AK.                         AFB0926
*                                                                        AFB0926
* DC  NARRATIVE                                                          AFB0926
*                                                                        AFB0926
*     FREEZE THE BLOCK. SAVE NEWFWA AND NEWLNG FOR RESTORATION AT THE    AFB0926
*     END OF THE SUBROUTINE. IF THE CURRENT RECORD IS NATIVE,SET NEWFWA  AFB0926
*     AND NEWLNG = ITS FWA AND LENGTH IN CHARACTERS, SET PTREEWRD[2]     AFB0926
*     = 0 AS A SIGNAL THAT THE RECORD IS NATIVE NOT ALIEN (THE SIGNAL    AFB0926
*     IS PICKED UP A FEW LINES BELOW LABEL MALORY), AND SKIP TO MALORY.  AFB0926
*     ELSE, FOR AN ALIEN, SET NEWFWA AND NEWLNG TO ITS FWA AND LENGTH    AFB0926
*     EXCLUDING THE ONE-WORD POINTER AT ITS BEGINNING. PTREEWRD[2] WILL  AFB0926
*     BE SET NON-ZERO SOMEWHAT LATER, BUT BEFORE WE GET TO MALORY. THIS  AFB0926
*     CASE IS MORE COMPLICATED BECAUSE IN THE END WE HAVE 3 RECORD       AFB0926
*     SLOTS TO THINK ABOUT, THE ALIEN HERE, THE ALIEN AT ITS NEW         AFB0926
*     POSITION, AND THE ALIEN-S MOTHER. WHEN WE START AT A NATIVE, IT    AFB0926
*     IS SIMPLER BECAUSE ONLY TWO SLOTS ARE INVOLVED, THE PRESENT ONE    AFB0926
*     WHERE THE NATIVE IS TO BE REPLACED BY A MOTHER, AND THE PREVIOUSLY AFB0926
*     VACANT SLOT IN WHICH THE RECORD WILL TAKE UP RESIDENCE AS AN ALIEN AFB0926
*                                                                        AFB0926
*     STARTING AT AN ALIEN, THEN. COPY PTREEWRD[0] INTO PTREEWRD[1]      AFB0926
*     SO THAT WE CAN TREAT THIS AS AN ALIEN AND LET PTREEWRD[0]          AFB0926
*     POINT TO THE                                                       AFB0926
*     MOTHER. COPY THE POINTER TO THE MOTHER FROM THE START OF THE       AFB0926
*     ALIEN RECORD TO PTREEWRD[0], AND CALL CURR$AK TO LOCATE            AFB0926
*     THE MOTHER. IF CURR$AK FAILS, FATAL ERROR BECAUSE THE FILE         AFB0926
*     STRUCTURE MUST BE BAD.                                             AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          ITEM N,SVNEWLNG,SVNEWFWA,A,B,C,D,G,I,J,K,X,Y,Z;                GAG0905
                                                                         GAG0905
          FIXX$AA ( P<BLOK$AA> , 1 ) ;                                   GAG0919
          SVNEWLNG = NEWLNG ;                                            GAG0905
          SVNEWFWA = NEWFWA ;                                            GAG0905
          IF RPUCC NQ ALIEN                                              GAG0919
          THEN                                                           GAG0919
              BEGIN                                                      GAG0919
              NEWFWA = RECFWA ;                                          GAG0919
              NEWLNG = RECLNG * 10 - RPUCC ;                             GAG0919
              PTREEWRD[2] = 0 ;                                          GAG0919
              GOTO MALORY ;                                              GAG0919
              END                                                        GAG0919
          NEWFWA = RECFWA + 1 ;                                          GAG0905
          NEWLNG = ( RECLNG * 10 ) - 10 - B<0,4>W[RECFWA] ;              GAG0905
          PTREEWRD[1] = PTREEWRD[0] ;                                    GAG0905
          BLPTRADR[0] = LOC(PTREEWRD[1]) ;                               GAG0905
          PTREEWRD[0] = W[RECFWA] ;                                      GAG0905
          CURPTR = 0 ;                                                   GAG0905
          CURR$AK ;                                                      GAG0905
          IF QMF EQ 0 OR MACH$AK NQ 0                                    GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              MSGF$AA ( EC553 ) ;                                        GAG0905
              NEWBNUM = -1; 
              RETURN; 
              END                                                        GAG0905
 #                                                                       AFB0926
*     THE BEST PLACE TO MOVE THE ALIEN RECORD WOULD BE BACK TO ITS       AFB0926
*     PROPER SLOT, WHICH IS NOW OCCUPIED BY ITS MOTHER (PLACEHOLDER).    AFB0926
*     THAT BLOCK MAY HAVE BECOME EMPTIER SINCE THIS RECORD WAS FORCED    AFB0926
*     TO BECOME AN ALIEN. SO CALL RCKN$AK TO TEST THE MOTHER-S BLOCK     AFB0926
*     FOR SPACE. IF SPLTFLG .LQ. 0, SUCCESS -- WE CAN IMMEDIATELY        AFB0926
*     REPLACE THE MOTHER BY THE ALIEN AND THEN SKIP TO MALRA TO DELETE   AFB0926
*     THE ALIEN FROM ITS PREVIOUS POSITION, AND FINISH OFF.              AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          RCKN$AK ;                                                      GAG0905
          IF SPLTFLG LQ 0                                                GAG0905
          THEN                                                           GAG0905
              BEGIN #ALIEN RETURNS TO MOTHER#                            GAG0905
              SVEC$AK ; 
              ADRC$AK ;                                                  GAG0905
              CURPTR = 1 ;                                               GAG0905
              GOTO MALRA ;                                               GAG0905
              END                                                        GAG0905
 #
*     IF WE CANT MOVE THE ALIEN BACK TO THE MOTHER POSITION,
*     WE HAVE TO FIND ROOM
*     IN SOME OTHER BLOCK, AND MOVE IT THERE. FIRST SAVE THE POSITION    AFB0926
*     OF THE ALIEN, BY COPYING PTREEWRD[1] TO PTREEWRD[2]. WE ARE        AFB0926
*     GOING TO CALL SPAC$AK, WHICH NEEDS A WORD OF THE PTREE TO WORK     AFB0926
*     IN, AND PTREEWRD[1] WOULD BE THE MOST APPROPRIATE. THUS WE         AFB0926
*     SET CURPTR=1 BEFORE CALLING SPAC$AK. THIS ALSO TELLS SPAC$AK       AFB0926
*     THE RECORD WILL BE STORED AS AN ALIEN, SO THAT AN EXTRA WORD       AFB0926
*     OF STORAGE WILL BE NEEDED FOR THE POINTER BACK TO THE MOTHER.      AFB0926
*     (SETTING PTREEWRD[2] NON-ZERO IS ALSO IMPORTANT FOR THE TEST,      AFB0926
*     10 LINES BELOW LABEL MALORY.)                                      AFB0926
*                                                                        AFB0926
*     THE FIRST PARAMETER FOR SPAC$AK IS THE AMOUNT OF PADDING. THIS     AFB0926
*     MATTER IS FAIRLY URGENT, SO FORGET PADDING. THE SECOND PARAMETER   AFB0926
*     IS THE PRU NUMBER OF THE BLOCK THAT CONTAINS AT PRESENT THE        AFB0926
*     ALIEN RECORD. THIS IS TO BE EXCLUDED BY SPAC$AK FROM ITS           AFB0926
*     SEARCH. THE THIRD PARAMETER IS NON-ZERO, WHICH MEANS THAT IF       AFB0926
*     SPAC$AK NEEDS TO CALL SPC1$AK (THE ((RARE)) PART OF THE SPACE      AFB0926
*     SEARCH) IT SHOULD DO SO BY DIRECTLY CALLING THE SUBROUTINE         AFB0926
*     WHOSE ADDRESS IS GIVEN AS THE FOURTH PARAMETER. THIS IS TO         AFB0926
*     PREVENT SPAC$AK FROM CALLING SPC1$AK IN THE ((ORDINARY)) WAY,      AFB0926
*     WHICH INVOLVES ENTERING THE AK RARE CAPSULE AT ITS ONE AND         AFB0926
*     ONLY ENTRY POINT, WITH A PARAMETER TELLING WHICH ROUTINE IS        AFB0926
*     TO BE EXECUTED. WE ARE ALREADY IN THE RARE CAPSULE, AND            AFB0926
*     CALLING SPC1$AK THAT WAY WOULD DESTROY THE RETURN ADDRESS          AFB0926
*     WE NEED FOR OUR EVENTUAL EXIT FROM MALR$AK. WITH THE THIRD         AFB0926
*     AND FOURTH PARAMETERS IN THE CALL TO SPAC$AK HERE, WE ENABLE       AFB0926
*     IT TO CALL SPC1$AK, IF NECESSARY, DIRECTLY AND WITHOUT             AFB0926
*     DISTURBING THE RETURN ADDRESS THAT IS ALREADY SAVED AT THE         AFB0926
*     ONLY PROPER ENTRY POINT TO THE RARE CAPSULE.                       AFB0926
*                                                                        AFB0926
*     IF THE RETURN FROM SPAC$AK IS WITH NEWBNUM=0, NO OTHER PLACE       AFB0926
*     FOR THE RECORD COULD BE FOUND. AN ERROR MESSAGE HAS                AFB0926
*     ALREADY BEEN ISSUED FROM SPAC$AK, SO WE UNFREEZE THE BLOCK, 
*     SET NEWBNUM = -1 TO MARK THE ERROR, AND RETURN. 
*     OTHERWISE, SPAC$AK HAS SET PTREEWRD[1] TO POINT TO THE NEW         AFB0926
*     BLOCK WITH SPACE. CALL PWOK$AK TO PUT THE RECORD INTO SOME         AFB0926
*     FREE SLOT OF THAT BLOCK. NEWFWA AND NEWLNG POINT TO THE            AFB0926
*     RECORD (IN ITS FROZEN BLOCK) WITHOUT ITS PREFIX (IF ANY).          AFB0926
*     PWOK$AK AUTOMATICALLY ADDS A PREFIX BECAUSE IT KNOWS, FROM         AFB0926
*     CURPTR BEING 1 NOT 0, THAT THIS IS OR WILL BE AN ALIEN RECORD. THE AFB0926
*     PREFIX IS MORE OR LESS A COPY OF PTREEWRD[0].                      AFB0926
*     THEN CALL RLOV$AK TO UPDATE THE MOTHER RECORD AND MAKE IT          AFB0926
*     POINT TO THE NEW LOCATION OF THE ALIEN RECORD.                     AFB0926
*     IF WE HAVE JUST MOVED OUT A NATIVE, RLOV$AK HERE REPLACES THAT     AFB0926
*     NATIVE BY A ONE-WORD ((MOTHER)). PTREEWRD[0] WAS POINTING TO       AFB0926
*     THE NATIVE, AND NOW POINTS TO THE MOTHER. IF PTREEWRD[2]=0,        AFB0926
*     WE HAVE JUST CONVERTED A NATIVE TO A MOTHER+ALIEN, EVERYTHING      AFB0926
*     IS IN EQUILIBRIUM, AND WE CAN SKIP TO MALIC. BUT IF NOT, WE        AFB0926
*     HAVE JUST COPIED AN ALIEN TO A NEW POSITION, AND HAVE YET TO       AFB0926
*     DELETE THE ALIEN FROM ITS FORMER PLACE. SO RESTORE PTREEWRD[1]     AFB0926
*     TO POINT TO THE ALIEN IN ITS FORMER PLACE.                         AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          PTREEWRD[2] = PTREEWRD[1] ;                                    GAG0905
MALORY:                                                                  GAG0919
          CURPTR = 1 ;                                                   GAG0905
          SPAC$AK ( 0,BLOCKID[FIXHOLD[1]-P<BLOK$AA>],1,SPC1$AK ) ;       GAG0905
          IF NEWBNUM EQ 0                                                GAG0905
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              UNFX$AA ( 1 ) ;                                            GAG0905
              NEWBNUM = -1; 
              RETURN; 
              END                                                        GAG0905
          PWOK$AK ;                                                      GAG0905
          RLOV$AK ;                                                      GAG0905
          IF PTREEWRD[2] EQ 0                                            GAG0919
          THEN                                                           GAG0919
              BEGIN                                                      GAG0919
              GOTO MALIC ;                                               GAG0919
              END                                                        GAG0919
          PTREEWRD[1] = PTREEWRD[2] ;                                    GAG0905
          CURPTR = 1 ;                                                   GAG0905
 #                                                                       AFB0926
*                                                                        AFB0926
*     WE COME TO MALRA WHEN WE HAVE EITHER REPLACED THE MOTHER           AFB0926
*     RECORD BY A COPY OF THE ALIEN IN QUESTION, OR STORED A             AFB0926
*     COPY OF THE ALIEN, AS AN ALIEN, IN SOME OTHER BLOCK, AND           AFB0926
*     ALTERED THE MOTHER ACCORDINGLY. BUT THE ORIGINAL ALIEN             AFB0926
*     STILL HAS TO BE DELETED FROM ITS PREVIOUS PLACE.                   AFB0926
*     CURPTR = 1, AND PTREEWRD[1] POINTS TO THE ALIEN TO BE              AFB0926
*     DELETED. SO JUST CALL CURR$AA TO LOCATE IT, AND DELL$AK            AFB0926
*     TO DELETE IT.                                                      AFB0926
*                                                                        AFB0926
*     ON THE OTHER HAND, IF THE ALIEN HAS BEEN MOVED TO ANOTHER          AFB0926
*     SLOT IN THE SAME BLOCK, IT DOES NOT NOW HAVE TO BE DELETED.        AFB0926
*     ALL CHANGES TO THE BLOCK HAVE ALREADY BEEN MADE, AND WE HAVE       AFB0926
*     SKIPPED MALRA AND JUMPED TO MALRB.                                 AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
MALRA:                                                                   GAG0905
          CURR$AA ;                                                      GAG0905
          DELL$AK ;                                                      GAG0905
 #                                                                       AFB0926
*     AT MALRB, JUST TIDY UP. PTREEWRD[1] POINTS TO THE NOW EMPTY        AFB0926
*     SLOT THAT HELD THE ALIEN. COPY THIS BACK TO PTREEWRD[0], AS        AFB0926
*     WE PROBABLY INTEND TO USE IT FOR A RECORD IN ITS OWN RIGHTFUL      AFB0926
*     PLACE. THE BACK POINTER FROM THE BLOCK TO THE PTREE HAS TO BE      AFB0926
*     ADJUSTED IN SUCH CASES. THEN CALL CURR$AA TO MAKE RECFWA,          AFB0926
*     RECLNG, AND RECLWA POINT TO THIS DEAD RECORD. UNFREEZE THE         AFB0926
*     BLOCK, AND RESTORE NEWLNG AND NEWFWA TO WHAT THEY WERE WHEN        AFB0926
*     MALR$AK WAS ENTERED. THEN RETURN.                                  AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
MALRB:                                                                   GAG0905
          PTREEWRD[0] = PTREEWRD[1] ;                                    GAG0905
          BLPTRADR[0] = LOC(PTREEWRD[0]) ;                               GAG0905
          CURPTR = 0 ;                                                   GAG0905
          CURR$AA ;                                                      GAG0905
MALIC:                                                                   GAG0919
          UNFX$AA ( 1 ) ;                                                GAG0905
          NEWLNG = SVNEWLNG ;                                            GAG0905
          NEWFWA = SVNEWFWA ;                                            GAG0905
          RETURN ;                                                       GAG0905
                                                                         GAG0905
                                                                         GAG0905
          END  #OF MALR$AK#                                              GAG0905
CONTROL EJECT;                                                           GAG0905
PROC MKRM$AK;  #MAKE ROOM IN THE CURRENT BLOCK#                          GAG0905
          BEGIN  #MKRM$AKCODE#                                           GAG0905
 #                                                                       AFB0926
* *   MKRM$AK - MAKE ROOM IN CURRENT BLOCK             PAGE 1            AFB0926
* *   R.P.NG + A.F.R.BROWN                                               AFB0926
* 1DC MKRM$AK                                                            AFB0926
*                                                                        AFB0926
* DC  FUNCTION                                                           AFB0926
*                                                                        AFB0926
*     DURING AN AK PUT-WITH-KEY, WHEN THE SLOT IS FREE BUT THE           AFB0926
*     BLOCK HAS NOT ENOUGH EMPTY SPACE, TO MAKE EMPTY SPACE IN           AFB0926
*     THE BLOCK. IF POSSIBLE, ENOUGH FOR THE WHOLE NEW RECORD,           AFB0926
*     OR AT WORST, FOR A MOTHER RECORD CONSISTING OF A ONE-WORD          AFB0926
*     POINTER TO THE REAL RECORD, WHICH WILL BE STORED IN SOME           AFB0926
*     OTHER BLOCK AS AN ALIEN.                                           AFB0926
*                                                                        AFB0926
*     THIS IS CALLED IN ONLY ONE PLACE, IN SUBROUTINE PUT$AK.            AFB0926
*     IT HAS BEEN SEPARATED FROM THAT SUBROUTINE SO THAT IT COULD        AFB0926
*     RESIDE IN A ((RARE)) CAPSULE, BECAUSE WE HOPE PUT-WITH-KEY         AFB0926
*     IS FAIRLY RARE, AND SITUATIONS WHERE THE BLOCK IS TOO FULL         AFB0926
*     ON A PUT-WITH-KEY ARE RARER STILL.                                 AFB0926
*                                                                        AFB0926
* DC  ENTRY CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     PTREEWRD[0] POINTS TO THE CURRENT BLOCK, WHICH IS LOCATED          AFB0926
*     AS IF CURR$AA HAD JUST BEEN CALLED. THE IDENTITY OF THE            AFB0926
*     CURRENT RECORD DOES NOT MATTER.                                    AFB0926
*                                                                        AFB0926
*     SPLTFLG IS THE NUMBER OF HALF-WORDS BY WHICH THE BLOCK HAS         AFB0926
*     TO BE EMPTIED, IN ORDER TO MAKE ROOM FOR THE NEW RECORD.           AFB0926
*     FOR EVERY ALIEN RECORD MOVED OUT, WE CONSIDER WE HAVE              AFB0926
*     GAINED 2*N HALF-WORDS, WHERE N IS THE RECORD LENGTH IN WORDS       AFB0926
*     (I.E. NO EXTRA POINT FOR THE RECORD POINTER.)                      AFB0926
*     FOR EVERY NATIVE RECORD MOVED OUT, ONLY 2*N-2, BECAUSE WE          AFB0926
*     HAVE TO LEAVE BEHIND A 1-WORD PLACEHOLDER (MOTHER). HENCE          AFB0926
*     WE SHALL IGNORE NATIVE RECORDS THAT ARE ONLY ONE WORD LONG.        AFB0926
*                                                                        AFB0926
*     NEWLNG IS THE LENGTH IN CHARACTERS OF THE NEW RECORD FOR           AFB0926
*     WHICH WE ARE TRYING TO MAKE ROOM.                                  AFB0926
*                                                                        AFB0926
* DC  EXIT CONDITIONS                                                    AFB0926
*                                                                        AFB0926
*     PTREEWRD[0] AND RNO HAVE BEEN PRESERVED. THE BLOCK IS ONCE         AFB0926
*     AGAIN LOCATED AS IF CURR$AA HAD BEEN CALLED.                       AFB0926
*                                                                        AFB0926
*     NEWLNG AND NEWFWA HAVE BEEN PRESERVED.                             AFB0926
*                                                                        AFB0926
*     IF SPLTFLG = 0, THERE IS NOW ROOM IN THE BLOCK TO PUT THE          AFB0926
*     NEW RECORD INTO ITS OWN SLOT. OTHERWISE NOT, BUT THERE IS          AFB0926
*     AT LEAST ROOM FOR AN OVERFLOW POINTER (MOTHER RECORD) TO BE        AFB0926
*     PUT INTO THAT SLOT.                                                AFB0926
*                                                                        AFB0926
*     CONS$AA HAS BEEN CALLED IF NECESSARY, SO THAT ALL DEAD RECORDS     AFB0926
*     HAVE BEEN SQUEEZED OUT OF THE BLOCK.                               AFB0926
*                                                                        AFB0926
* DC  ERROR CONDITIONS                                                   AFB0926
*                                                                        AFB0926
*     IF SPAC$AK IS CALLED, AND RETURNS WITH NEWBNUM=0, FOR NO           AFB0926
*     ROOM, A NON-FATAL ERROR WILL HAVE ALREADY BEEN ISSUED BY           AFB0926
*     SPAC$AK, AND WE RETURN WITH NEWBNUM = -1, AS THIS 
*     CALL TO SPAC$AK WAS A LAST RESORT ON THE PART OF MKRM$AK.          AFB0926
*                                                                        AFB0926
* DC  CALLED ROUTINES                                                    AFB0926
*                                                                        AFB0926
*     RPGT$AA - TO GET A RECORD POINTER COPIED FROM THE BLOCK IMAGE      AFB0926
*       TO RECPTR.                                                       AFB0926
*     SETR$AA - TO LOCATE A RECORD IN THE BLOCK, GIVEN ITS NUMBER,       AFB0926
*       SETTING RECFWA, RECLWA, AND RECLNG AND ALSO STORING THE          AFB0926
*       NUMBER INTO PTCUREC[CURPTR].                                     AFB0926
*     MALR$AK - TO MOVE A RECORD OUT OF ITS PRESENT SLOT.                AFB0926
*       HERE WE CALL IT WITH A PARAMETER OF 0, MEANING THAT IF AN        AFB0926
*       ALIEN, THE RECORD                                                AFB0926
*       HAS TO BE MOVED INTO A DIFFERENT BLOCK, NOT MERELY A             AFB0926
*       DIFFERENT SLOT.                                                  AFB0926
*                                                                        AFB0926
*     CONS$AA - WHEN ALL IS OVER, THIS IS CALLED TO SQUEEZE OUT          AFB0926
*       DEAD RECORDS. IN AN IS OR DA FILE, CONS$AA WOULD ALSO            AFB0926
*       SQUEEZE OUT THEIR POINTERS, SO THEY COULD BE TRULY SAID TO       AFB0926
*       DISAPPEAR. IN AN AK FILE THE DEAD RECORDS ARE JUST REDUCED       AFB0926
*       TO ZERO LENGTH, BECAUSE THEIR POINTERS HAVE TO REMAIN IN         AFB0926
*       EXISTENCE.                                                       AFB0926
*                                                                        AFB0926
* DC  NON-LOCAL VARIABLES                                                AFB0926
*                                                                        AFB0926
*     RECPTR (AND ITS FIELDS RPUCC AND RPLWA) - RPGT$AA COPIES A         AFB0926
*       RECORD POINTER FROM BLOCK IMAGE TO HERE, AND RPPT$AA             AFB0926
*       COPIES ONE FROM HERE TO THE BLOCK IMAGE.                         AFB0926
*     IX FOR SCRATCH.                                                    AFB0926
*                                                                        AFB0926
* DC  NARRATIVE                                                          AFB0926
*                                                                        AFB0926
*     FIRST SET NEED = SPLTFLG. NEED WILL BE THE WORKING VALUE TO COUNT  AFB0926
*     DOWN AS WE INCREASE THE FREE SPACE IN THE BLOCK, WHILE SPLTFLG     AFB0926
*     WILL BE USED AS A RESULT VARIABLE. SET MINEED TO THE NUMBER OF     AFB0926
*     HALFWORDS BY WHICH THE FREE SPACE IN THE BLOCK WOULD HAVE          AFB0926
*     TO BE INCREASED TO MAKE ROOM FOR A ONE-WORD PLACEHOLDER            AFB0926
*     (MOTHER) RATHER THAN FOR THE WHOLE NEW RECORD. WE MAY              AFB0926
*     CONTENT OURSELVES WITH THIS MINIMUM EFFORT.                        AFB0926
*     MINEED MAY BE 0 OR NEGATIVE RIGHT FROM THE START, MEANING          AFB0926
*     WE ALREADY HAVE ROOM TO INSERT A PLACEHOLDER.                      AFB0926
*     SAVE RNO IN SVRNO. IT IS TO BE RESTORED AT EXIT.                   AFB0926
*                                                                        AFB0926
*     NOW SCAN THE BLOCK, LOOKING AT ALL THE LIVE RECORDS, NOTING THE    AFB0926
*     SIZE AND NUMBER OF THE LARGEST ALIEN RECORD (IF ANY), THE SIZE     AFB0926
*     AND NUMBER OF THE SMALLEST ALIEN RECORD THAT IS NOT SMALLER        AFB0926
*     THAN NEED (IF ANY) - I.E. THE SMALLEST ALIEN RECORD THAT WE        AFB0926
*     COULD SOLVE THE PROBLEM BY KICKING OUT. ALSO THE TOTAL SIZE        AFB0926
*     OF ALIEN RECORDS. ALSO THE LARGEST NATIVE (BUT IGNORING THOSE      AFB0926
*     UNDER 2 WORDS LONG, BECAUSE IF WE KICK OUT A NATIVE WE MUST        AFB0926
*     REPLACE IT BY A ONE-WORD PLACEHOLDER), THE SMALLEST NATIVE         AFB0926
*     WHOSE EXPULSION WOULD SATISFY MINEED, AND THE SMALLEST NATIVE      AFB0926
*     WHOSE EXPULSION WOULD SATISFY NEED.                                AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          ITEM N;                                                        GAG0905
          ITEM LGALN;  #LARGEST ALIEN#                                   GAG0905
          ITEM LGALNSZ;  #LARGEST ALIEN SIZE#                            GAG0905
          ITEM BSTALN;  #BEST ALIEN-SMALLEST,LARGE ENUF ALIEN SLOT#      GAG0905
          ITEM BSTALNSZ;  #BEST ALIEN SIZE-DIF BETWEEN BEST AND NEED#    GAG0905
          ITEM BSTNTV;  #BEST NATIVE-MOST NEARLY EQ NEW REC SZ + 1#      GAG0905
          ITEM BSTNTVSZ;  #BEST NATIVE SIZE-DIF BETWEEN BEST AND NEED+1# GAG0905
          ITEM SMNTV; #SMALLEST NATIVE THAT COULD ALLOW NEW MOTHER#      GAG0919
          ITEM SMNTVSZ;  #SMALLEST NATIVE SIZE#                          GAG0905
          ITEM LGNTV; #LARGEST NATIVE NUMBER#                            GAG0919
          ITEM LGNTVSZ; #LARGEST NATIVE SIZE#                            GAG0919
          ITEM ALNSP;  #SPACE IN THE BLOCK OCCUPIED BY ALIENS#           GAG0905
          ITEM NEED;  #AMOUNT OF SPACE REQUIRED BY NEW RECORD#           GAG0905
          ITEM RCFA;  #FIRST WORD ADDRESS OF RECORD#                     GAG0905
          ITEM RCLG;  #LENGTH OF RECORD#                                 GAG0905
          ITEM RECKNT;  #NUMBER OF RECORDS PER BLOCK#                    GAG0905
          ITEM UCC;  #UNUSED CHARACTER COUNT-OVFL/ALIEN/DEAD FLAGS#      GAG0905
          ITEM SVRNO;  #STORAGE FOR RNO#                                 GAG0905
          ITEM MINEED; #SPACE NEEDED FOR NEW PLACEHOLDER (MOTHER)#       GAG0919
                                                                         GAG0905
          NEED = SPLTFLG ;                                               GAG0905
          SVRNO = RNO ;                                                  GAG0905
          MINEED = NEED - 2*WLG(NEWLNG) + 2 ;                            GAG0919
START:                                                                   GAG0905
          LGALN = 0;                                                     GAG0905
          LGALNSZ = 0;                                                   GAG0905
          BSTALN = 0;                                                    GAG0905
          BSTALNSZ = O"377777" ;                                         GAG0905
          BSTNTV = 0;                                                    GAG0905
          BSTNTVSZ = O"377777" ;                                         GAG0905
          SMNTV = 0;                                                     GAG0905
          SMNTVSZ = O"377777" ;                                          GAG0905
          LGNTV = 0 ;                                                    GAG0919
          LGNTVSZ = 0 ;                                                  GAG0919
          ALNSP = 0;                                                     GAG0905
          RCFA = 0 ;                                                     GAG0905
          SPLTFLG = 0;                                                   GAG0905
          RECKNT = RC;                                                   GAG0905
          FOR N=1 STEP 1 UNTIL RECKNT DO                                 GAG0905
              BEGIN  #START BLOCK RECORD EVALUATION#                     GAG0905
              RPGT$AA(N);                                                GAG0905
              UCC = RPUCC;                                               GAG0905
              RCLG = (RPLWA - RCFA) * 2 ;                                GAG0905
              RCFA = RPLWA ;                                             GAG0905
              IF UCC EQ DEAD                                             GAG0905
              THEN                                                       GAG0905
                  BEGIN  #IF DEAD RECORD, SKIP FORWARD TO NEXT#          GAG0905
                  TEST ;                                                 GAG0905
                  END                                                    GAG0905
              IF UCC EQ ALIEN                                            GAG0905
              THEN                                                       GAG0905
                  BEGIN  #IF ALIEN RECORD, EVALUATE#                     GAG0905
                  ALNSP = ALNSP + RCLG;                                  GAG0905
                  IF RCLG GR LGALNSZ                                     GAG0905
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      LGALNSZ = RCLG;                                    GAG0905
                      LGALN = N;                                         GAG0905
                      END                                                GAG0905
                  IF RCLG GQ NEED AND RCLG LS BSTALNSZ                   GAG0919
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      BSTALNSZ = RCLG ;                                  GAG0919
                      BSTALN = N;                                        GAG0905
                      END                                                GAG0905
                  END  #END OF ALIEN RECORD EVALUATION#                  GAG0905
              ELSE                                                       GAG0905
                  BEGIN  #BEGIN NATIVE RECORD EVALUATION#                GAG0905
                  RCLG = RCLG - 2 ;                                      GAG0919
                  IF RCLG GR LGNTVSZ                                     GAG0919
                  THEN                                                   GAG0919
                      BEGIN                                              GAG0919
                      LGNTVSZ = RCLG ;                                   GAG0919
                      LGNTV = N ;                                        GAG0919
                      END                                                GAG0919
                  IF RCLG GR MINEED AND RCLG LS SMNTVSZ                  GAG0919
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      SMNTVSZ = RCLG;                                    GAG0905
                      SMNTV = N;                                         GAG0905
                      END                                                GAG0905
                  IF RCLG GQ NEED AND RCLG LS BSTNTVSZ                   GAG0919
                  THEN                                                   GAG0905
                      BEGIN                                              GAG0905
                      BSTNTVSZ = RCLG ;                                  GAG0919
                      BSTNTV = N;                                        GAG0905
                      END                                                GAG0905
                  END  #END OF NATIVE RECORD EVALUATION#                 GAG0905
              END  #END OF BLOCK RECORD EVALUATION#                      GAG0905
 #                                                                       AFB0926
*                                                                        AFB0926
*     HERE IS OUR LIST OF POSSIBILITIES, FROM BEST TO WORST--            AFB0926
*     (1) KICK OUT THE SMALLEST ALIEN THAT WOULD MAKE ROOM FOR           AFB0926
*     THE WHOLE NEW RECORD (BSTALN).                                     AFB0926
*     (2) IF TOTAL LENGTH OF ALIENS IS LESS THAN NEED, BUT               AFB0926
*     MINEED IS ZERO OR NEGATIVE, DO NOTHING. WE ALREADY HAVE            AFB0926
*     ROOM FOR A PLACEHOLDER, KICKING OUT ALL THE ALIENS                 AFB0926
*     WOULD NOT MAKE ROOM FOR THE WHOLE NEW RECORD, AND IT               AFB0926
*     WOULD BE A WASTE OF TIME TO KICK OUT ONE OR MORE                   AFB0926
*     NATIVES TO MAKE ROOM FOR THE WHOLE NEW RECORD.                     AFB0926
*     (3) KICK OUT THE LARGEST ALIEN. THIS WILL (A) BE A                 AFB0926
*     CONTRIBUTION TO MAKING ROOM FOR THE WHOLE NEW RECORD, OR           AFB0926
*     (B) MAKE ROOM FOR A NEW PLACEHOLDER, OR (C) BE A                   AFB0926
*     CONTRIBUTION TO MAKING ROOM FOR A NEW PLACEHOLDER.(LGALN)          AFB0926
*     (4) KICK OUT THE SMALLEST NATIVE THAT WOULD MAKE ROOM FOR          AFB0926
*     THE WHOLE NEW RECORD (BSTNTV).                                     AFB0926
*     (5) KICK OUT THE SMALLEST NATIVE THAT WOULD MAKE ROOM FOR          AFB0926
*     A NEW PLACEHOLDER (SMNTV).                                         AFB0926
*     (6) KICK OUT THE LARGEST NATIVE, TO MAKE A CONTRIBUTION TO         AFB0926
*     ROOM FOR A NEW RECORD OR PLACEHOLDER (LGNTV).                      AFB0926
*     (WHAT ABOUT THE WORST CASE, IN WHICH THE BLOCK HOLDS NOTHING       AFB0926
*     BUT ONE-WORD NATIVES OR PLACEHOLDERS, AND YET WE HAVE TO MAKE      AFB0926
*     MORE ROOM. THIS IS SUPPOSED TO BE EXCLUDED BY THE FACT THAT        AFB0926
*     WHEN THE FILE IS CREATED, THE BLOCK SIZE MUST AT LEAST ALLOW ONE   AFB0926
*     AND A HALF WORDS TIMES THE BLOCKING FACTOR -- FOR EACH SLOT,       AFB0926
*     AT LEAST A WORD FOR A PLACEHOLDER AND HALF A WORD FOR THE          AFB0926
*     RECORD POINTER.)                                                   AFB0926
*                                                                        AFB0926
*     IF WE HAVE CHOSEN A RECORD TO KICK OUT, I.E. HAVE SET N,           AFB0926
*     CALL SETR$AA TO SET THE PTREE WORD AND TO LOCATE THAT RECORD,      AFB0926
*     THEN COUNT DOWN NEED AND MINEED BY THE PROFIT WE SHALL MAKE        AFB0926
*     ON THE RECORD, AND IF THE RECORD IS AN ALIEN, REDUCE ALNSP BY      AFB0926
*     ITS LENGTH. THEN CALL MALR$AK TO KICK OUT THE RECORD.              AFB0926
*                                                                        AFB0926
*     WHETHER OR NOT WE JUST KICKED ONE OUT, TAKE STOCK OF THE           AFB0926
*     SITUATION. IF MINEED GR 0, WE HAVE NOT DONE ENOUGH, SO RETURN      AFB0926
*     TO START TO SCAN THE BLOCK AND KICK OUT ONE MORE RECORD.           AFB0926
*     (MINEED CANNOT BE GREATER THAN NEED.) ELSE WE HAVE DONE THE        AFB0926
*     MINIMUM ALREADY. NOW IF NEED LQ 0, WE HAVE DONE ALL WE NEED TO     AFB0926
*     AND CAN SET SPLTFLG=0 (ROOM FOR WHOLE NEW RECORD) AND DROP OUT     AFB0926
*     OF THIS LOOP. IF NEED GR 0 BUT THE TOTAL REMAINING LENGTH OF       AFB0926
*     ALIEN RECORDS (ALNSP) GQ NEED, WE COULD MAKE ROOM FOR THE WHOLE    AFB0926
*     NEW RECORD JUST BY KICKING OUT ALIENS. SO RETURN TO START FOR      AFB0926
*     ANOTHER PASS. BUT IF ALNSP LS NEED, WE WOULD HAVE TO KICK OUT      AFB0926
*     ONE OR MORE NATIVES TO MAKE ROOM FOR THE WHOLE NEW RECORD.         AFB0926
*     SO BE CONTENT WITH ROOM FOR A NEW PLACEHOLDER, AND DROP OUT        AFB0926
*     OF THE LOOP, AFTER SETTING SPLTFLG=1 AS A SIGNAL THAT THERE        AFB0926
*     IS ONLY ROOM FOR THE NEW PLACEHOLDER.                              AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
                                                                         GAG0919
          IF ALNSP LS NEED AND MINEED LQ 0                               AFB0926
          THEN                                                           AFB0926
              BEGIN                                                      AFB0926
              GOTO MKRMB ;                                               AFB0926
              END                                                        AFB0926
          N = BSTALN ;                                                   GAG0919
          IF N EQ 0                                                      GAG0919
          THEN                                                           GAG0905
              BEGIN                                                      GAG0905
              N = LGALN ;                                                GAG0919
              IF N EQ 0                                                  AFB0926
              THEN                                                       GAG0919
                  BEGIN                                                  GAG0919
                  N = BSTNTV ;                                           GAG0919
                  IF N EQ 0                                              GAG0919
                  THEN                                                   GAG0919
                      BEGIN                                              GAG0919
                      N = SMNTV ;                                        GAG0919
                      IF N EQ 0                                          GAG0919
                      THEN                                               GAG0919
                          BEGIN                                          GAG0919
                          N = LGNTV ;                                    GAG0919
                          END                                            GAG0919
                      END                                                GAG0919
                  END                                                    GAG0919
              END                                                        GAG0905
          IF N NQ 0                                                      GAG0919
          THEN                                                           GAG0919
              BEGIN                                                      GAG0919
              SETR$AA ( N ) ;                                            GAG0919
              IX = 2 * RECLNG ;                                          GAG0919
              IF RPUCC NQ ALIEN                                          GAG0919
              THEN                                                       GAG0919
                  BEGIN                                                  GAG0919
                  IX = IX - 2 ;                                          GAG0919
                  END                                                    GAG0919
              ELSE                                                       GAG0919
                  BEGIN                                                  GAG0919
                  ALNSP = ALNSP - IX ;                                   GAG0919
                  END                                                    GAG0919
              NEED = NEED - IX ;                                         GAG0919
              MINEED = MINEED - IX ;                                     GAG0919
              MALR$AK ( 0 ) ;                                            GAG0919
              IF NEWBNUM EQ -1 THEN RETURN; 
              END                                                        GAG0919
          IF MINEED GR 0                                                 GAG0919
          THEN                                                           GAG0919
              BEGIN                                                      GAG0919
              GOTO START ;                                               GAG0919
              END                                                        GAG0919
          IF NEED LQ 0                                                   GAG0919
          THEN                                                           GAG0919
              BEGIN                                                      GAG0919
              SPLTFLG = 0 ;                                              GAG0919
              END                                                        GAG0919
          ELSE                                                           GAG0905
              BEGIN                                                      GAG0905
              IF ALNSP GQ NEED                                           GAG0919
              THEN                                                       GAG0905
                  BEGIN                                                  GAG0905
                  GOTO START ;                                           GAG0919
                  END                                                    GAG0905
              ELSE                                                       GAG0905
                  BEGIN                                                  GAG0905
MKRMB:                                                                   AFB0926
                  SPLTFLG = 1 ;                                          GAG0919
                  END                                                    GAG0905
              END                                                        GAG0905
 #                                                                       AFB0926
*                                                                        AFB0926
*     RESTORE RNO AND PTCUREC[0] TO THE RECORD NUMBER AT WHICH WE WERE   AFB0926
*     POSITIONED ON ENTERING MKRM$AK, IN THE BLOCK IN WHICH WE HAVE JUST AFB0926
*     MADE ROOM. AT THIS POINT CURPTR MUST = 0 AND P<BLOK$AA> POINT TO   AFB0926
*     THE ORIGINAL BLOCK, AS PART OF THE EXIT CONDITIONS. IF WE KICKED   AFB0926
*     OUT ONE OR MORE RECORDS, CURPTR AND P<BLOK$AA> WERE LEFT SO BY     AFB0926
*     MALR$AK. IF NOTHING HAS BEEN KICKED OUT, CURPTR AND P<BLOK$AA>     AFB0926
*     HAVE NOT BEEN DISTURBED AT ALL BY MKRM$AK.                         AFB0926
*                                                                        AFB0926
*     FINALLY, IF WE HAVE KICKED OUT ANYTHING, CALL CONS$AA TO SQUEEZE   AFB0926
*     OUT THE EMPTY RECORD(S) IN CASE THIS HAS NOT ALREADY BEEN DONE.    AFB0926
*                                                                        AFB0926
 #                                                                       AFB0926
          PTCUREC[0] = SVRNO ;                                           GAG0905
          RNO = SVRNO ; #MAKE THE ORIGINAL RECORD CURRENT#               GAG0905
          CONS$AA ; 
          END  #OF MKRM$AK CODE#                                         GAG0905
      END   #END AK$RARE#                                                GAG0905
      TERM;                                                              GAG0905
