*DECK,REGEN      REGEN PROGRAM. 
          IDENT  REGEN
          LCC    OVERLAY(REGEN,0,0) 
          ENTRY  FST,ALX,PVC,INIT,RT,UNLOAD 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*                                                                     * 
*                   CONTROL DATA PROPRIETARY PRODUCT.                 * 
*                   MAINTENANCE SOFTWARE.                             * 
*                                                                     * 
*          REPRODUCTION IN WHOLE OR IN PART WITHOUT EXPRESS           * 
*          WRITTEN PERMISSION OF CONTROL DATA CORPORATION             * 
*          IS STRICTLY PROHIBITED.                                    * 
*                                                                     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*                                                                     * 
*         THIS PROGRAM HAS BEEN CONVERTED TO ASSEMBLE UNDER FORTRAN   * 
*         VERSION 5.  TO ASSEMBLE UNDER FORTRAN VERSION 4, MODSET     * 
*         CMLA118 IS YANKED .  ANY CHANGES MADE TO THIS PROGRAM MUST   *
*         ASSEMBLE UNDER FORTRAN 4 AND FORTRAN 5.                     * 
*                                                                     * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
  
  
*         RA101 MUST BE SET EQUAL TO 1 IF THE SYSTEM LOADER 
*         LOADS CODE AT RA+101 ( SCOPE 3.4, NOS, NOSBE )
* 
*         RA101 MUST BE SET EQUAL TO 0 IF THE SYSTEM LOADER 
*         LOADS CODE AT RA+100 ( SCOPE 3.2, SCOPE 3.3 ) 
* 
* 
  
RA101     EQU    1
          IFEQ   RA101,0,1
          BSSZ   1
* 
*         CYBERL MUST BE SET EQUAL TO 1 IF THE NEW CYBER LOADER 
*         IS USED TO LOAD REGEN  ( NOS, NOSBE  )
* 
*         CYBERL MUST BE SET EQUAL TO 0 IF THE NEW CYBER LOADER 
*         IS NOT USED TO LOAD REGEN ( SCOPE ) 
* 
CYBERL    EQU    1
          IFEQ   CYBERL,0,1 
          BSSZ   6
  
*CALL,CPYCOM
  
***       PROGRAM REGEN 
*         ------------- 
* 
*         ********************************************
*         * COPYRIGHT CONTROL DATA CORPORATION 1975. *
*         ********************************************
* 
*         DESCRIPTION 
*         ----------- 
* 
*         REGEN IS AN ON-LINE CONFIDENCE TEST FOR 6000/CYBER 70/170 
*         SYSTEMS. IT HAS TWO MAJOR OBJECTIVES. 
* 
* 
*          1. VALIDATE SYSTEM DATA PATHS BY PASSING CHECKSUMMED DATA
*             ACROSS SELECTED DATA PATHS AND VERIFY THAT DATA DOES NOT
*             DETERIORATE DUE TO HARDWARE OR SOFTWARE ERRORS. 
* 
*          2. VERIFY THAT THE CPU/CENTRAL MEMORY CAN EXECUTE DIAGNOSTIC 
*             TESTS FST/ALX AND PRODUCE ANSWERS THAT AGREE WITH A 
*             MASTER DATA BASE OF ANSWERS ( IN REALITY, THE CHECKSUMS 
*             OF ANSWERS ARE COMPARED TO CHECKSUMS FROM THE DATA BASE)
* 
* 
*         REGEN CAN BE RUN AS A USER JOB CONCURRENT WITH NORMAL 
*         CUSTOMER OPERATION.  HOWEVER, IT CAN BE USED MUCH MORE
*         EFFECTIVELY IN A DEDICATED SYSTEM MODE WHERE SEVERAL COPIES 
*         OF REGEN ARE THE ONLY JOBS IN THE SYSTEM.  THIS ALLOWS THE
*         CUSTOMER ENGINEER TO VALIDATE A TOTAL SYSTEM UNDER VOLTAGE
*         OR CLOCK MARGINS OR WHILE SHOCK TESTING.
* 
*         REGEN CAN PERFORM 6 BASIC TASKS AS FOLLOWS. 
* 
*           1. GENERATE A DATA BASE ON A DISK OR TAPE FILE. 
* 
*           2. COPY A DATA BASE FROM ONE FILE TO ANOTHER. 
* 
*           3. REGENERATE A DATA BASE AND COMPARE IT TO A PREVIOUS
*              DATA BASE FILE.
* 
*           4. RETURN A FILE (CLOSE/UNLOAD).
* 
*           5. RUN A SPECIFIC PASS OF DIAGNOSTIC TESTS FST/ALX AND
*              PRINT RESULTS. 
* 
*           6. ANALIZE AN ERROR-LOG FROM A PREVIOUS REGEN RUN THAT
*              HAD ERRORS.
* 
* 
*         THESE TASKS ARE REFERED TO AS MODES OF OPERATION AND ARE
*         CALLED INTO OPERATION VIA DATA CARDS FROM THE INPUT FILE. 
*         THE MODE NAMES ARE GENERATE, COPY, REGENERATE, RETURN,
*         RUNPASS, AND ISOLATE. 
* 
* 
*         THE FIRST FOUR MODES DEAL WITH A DATA BASE.  A REGEN DATA 
*         BASE IS INITIALLY MADE WITH A GENERATE MODE AND CAN BE FROM 
*         1 TO  3750 DECIMAL RECORDS.  EACH RECORD IS 511 WORDS IN
*         LENGTH - 512 AFTER SYSTEM CONTROL INFORMATION IS ADDED, BUT 
*         THIS IS TRANSPARENT TO THE USER.  THIS REPRESENTS THE LARGEST 
*         PHYSICAL RECORD SIZE FOR INTERNAL TAPES AND FILLS EIGHT DISK
*         SECTORS ON THE 808/841/844 SUBSYSTEMS (64 WORDS PER SECTOR).
* 
*         DUE TO THE END CASE DIFFERENCES BETWEEN CY175/176 AND 6000/ 
*         CY70/LOWER170 IT IS NECESSARY TO GENERATE THE MASTER DATA 
*         BASE ON THE SAME TYPE OF MACHINE ON WHICH REGEN WILL BE RUN.
*         I.E. CY175/176 TO CY175/176 AND 6000/CY70/LOWER170 TO 6000/ 
*         CY70/LOWER170.
* 
*         THESE HARDWARE FEATURES WERE A GREAT INFLUENCE IN DESIGNING 
*         THE DATA BASE RECORD FORMAT.  IT IS MADE UP OF SEVEN 64-WORD
*         BLOCKS AND AN 8TH BLOCK OF 63 WORDS (511 TOTAL). ALL 8 BLOCKS 
*         CONTAIN 60 WORDS OF DATA PLUS A THREE-WORD CHECKSUM OF THOSE
*         60 WORDS (STRAIGHT LINE LOGICAL SUM, LEFT DIAGONAL AND RIGHT
*         DIAGONAL LOGICAL SUMS). THESE THREE-WORD CHECKSUMS WILL ALLOW 
*         REGEN TO ISOLATE A SINGLE BIT FAILURE WITHIN A 60 WORD BLOCK
*         TO THE WORD AND BIT THAT FAILED.  IT ALSO DETECTS MULTIPLE
*         BIT FAILURES BUT CANNOT ISOLATE THEM CLOSER THAT THE BLOCK
*         IN WHICH THE FAILURE OCCURRED.
* 
*         THE FIRST SEVEN BLOCKS ALSO CONTAIN A 64TH WORD USED TO 
*         VERIFY THAT THE HARDWARE AND SOFTWARE PASSES REGEN DATA FROM
*         THE CORRECT FILE, AND THAT THIS DATA IS IN CORRECT RECORD AND 
*         SECTOR ORDER. THE POSITON DATA WORD BREAKS DOWN AS FOLLOWS..
* 
*           1. BITS 24-59 = UNIQUE JOB NAME IDENTIFIER SUPPLIED BY THE
*                           USER ON THE FIRST INPUT DATA CARD OF A RUN. 
* 
*           2. BITS 15-23 = FILE NUMBER ( 1-32 ) THAT REPRESENTS TAPE1
*                           THRU TAPE32.
* 
*           3. BITS 03-14 = RECORD NUMBER OF 1-3750 (1-7246 OCTAL)
* 
*           4. BITS 00-02 = BLOCK NUMBER OF 1 TO 7. 
* 
*         REGEN WILL USE BUFFEROUT/BUFFERIN FORTRAN I/O STATEMENTS TO 
*         WRITE AND READ A DATA BASE. THIS WILL BYPASS THE NORMAL SYSTEM
*         BUFFERS AND THE DOUBLE-HANDLING OF DATA.  THE PPU MOVES INPUT/
*         OUTPUT DATA DIRECTLY TO/FROM OUR REGEN BUFFER SPACES IN CM. 
*         A TYPICAL DATA PATH WOULD BE AS FOLLOWS.. 
* 
*          --------   --------------    -----------    -----------
*          I      I   I            I    I         I    I         I
*          I UNIT I---I CONTROLLER I----I COUPLER I----I CHANNEL I
*          I      I   I            I    I         I    I         I
*          --------   --------------    -----------    -----------
*                                                           I 
*                                                           I 
*                        -----------    -----------    -----------
*                        I         I----I 1ST CM  I----I         I
*                        I   CPU   I    I BUFFER  I    I   PPU   I
*                        I         I----I---------I----I         I
*                        -----------    I 2ND CM  I    -----------
*                                       I BUFFER  I      (1 OF X) 
*                                       ----------- 
*                                            ** 
* 
*              **  IF REGEN IS RUN WITH OTHER USERS, STORAGE MOVES OR 
*                  SWAPS/ROLLS COULD CHANGE THE ABSOLUTE MEMORY 
*                  ADDRESSES FOR BUFFERS AND CONTROL CODE.  IN A
*                  CONTROLLED TEST, CM SPACE USAGE SHOULD BE SUCH THAT
*                  STORAGE MOVES/SWAPS/ROLLS SHOULD NOT BE TAKING PLACE.
* 
* 
* 
* 
*         AS STATED EARLIER, REGEN PERFORMS 6 DIFFERENT TASKS. WE WILL
*         NOW EXAMINE EACH OF THESE TASKS.
* 
* 
*                          REGEN DATA GENERATION
*                          ---------------------
* 
*         IN THE GENERATE MODE, A PASS OF FST AND ALX ARE RUN.  THIS
*         TESTS THE CPU/CENTRAL MEMORY AND PROVIDES US WITH 60 WORDS OF 
*         RESULT DATA. THESE 60 WORDS ARE AS FOLLOWS..
* 
*           WORDS  1-16 = FST FAST LOOP ANSWERS (EXCHANGE PKG FORMAT) 
*           WORDS 17-32 = FST FAST LOOP INSTRUCTIONS
*           WORDS 33-48 = ALX FAST LOOP ANSWERS (EXCHANGE PKG FORMAT) 
*           WORDS 49-53 = ALX FAST LOOP INSTRUCTIONS
*           WORDS 54-59 = ALX RANDOM OPERANDS 
*           WORD  60    = ALX PASS COUNT + 1
* 
*         A PARITY VECTOR CHECKSUMMING MODULE (PVC)IS CALLED TO GENERATE
*         A 3-WORD CHECKSUM OF THESE 60 WORDS TO REPRESENT THIS PASS. 
* 
*         THIS PROCEDURE IS REPEATED 20 TIMES UNTIL WE HAVE GENERATED 
*         60 WORDS OF CHECKSUMS. PVC IS THEN CALLED TO GENERATE A 3-WORD
*         CHECKSUM OF THE CHECKSUMS.  A 64TH WORD IS ADDED THAT IDENTI- 
*         FIES THIS BLOCKS JOB NAME, FILE NUMBER, RECORD NUMBER, AND
*         BLOCK NUMBER.  THE TOTAL PROCESS IS REPEATED 8 TIMES TO 
*         GENERATE A BLOCK OF 512 WORDS.  511 OF THESE WORDS ARE THEN 
*         WRITTEN TO TAPE X AS A RECORD. (THE LAST POSITION DATA WORD IS
*         NOT WRITTEN.) 
* 
*         THE TOTAL PROCESS IS REPEATED THE NUMBER OF TIMES REQUESTED ON
*         THE FIRST DATA CARD TO REGEN. ( TOTAL NUMBER OF RECORDS TO
*         PROCESS OF 1 TO 3750 DECIMAL.  3750 DECIMAL IS THE MAXIMUM
*         ALLOWED SINCE THIS WILL ALMOST FILL A 2400 FOOT REEL OF TAPE
*         AT 800 BPI. ) 
* 
*         IT SHOULD BE CLEAR NOW THAT A DATA BASE SERVES TWO FUNCTIONS. 
*         THE 60 WORDS OF DATA IN EACH BLOCK IS REALLY 3-WORD CHECKSUMS 
*         OF 20 PASSES OF FST/ALX. IN THE REGENERATE MODE DESCRIBED 
*         LATER, WE WILL TEST THE ABILITY OF THE CPU/CENTRAL MEMORY TO
*         RE-CREATE THESE SAME CHECKSUMS BY RE-RUNNING FST/ALX AND PVC. 
*         THE 3-WORD CHECKSUMS OF EACH 60 WORD BLOCK OF CHECKSUMS AND 
*         THE POSITION WORDS ARE USED TO VERIFY THAT DATA DOES NOT LOSE 
*         ITS INTEGRITY AFTER IT IS ROUTED THROUGH SELECTED DATA PATHS. 
* 
*         IF WE ANALYZE A DATA BASE OF 3750 RECORDS (EXCLUDING POSITION 
*         DATA WORDS) WE FIND THAT THERE IS A SMOOTH DISTRIBUTION OF
*         NUMBERS.  EACH  12-BIT VALUE OF 0000 TO 7777 OCTAL APPEARS IN 
*         THE DATA BASE FROM 2150 TO 2450 DECIMAL TIMES.
* 
*         THE GENERATE MODE IS PROVIDED TO INITIALLY BUILD A DATA BASE. 
*         IN ORDER TO CHECK SITE-TO-SITE COMPATABILITY OF SEVERAL SITES 
*         IN A NETWORK, ONLY ONE SITE SHOULD RUN THE INITIAL GENERATE.
*         COPIES OF THE DATA BASE COULD THEN BE MADE USING THE COPY MODE
*         TO BUILD MASTER DATA BASE COPIES FOR ALL THE OTHER SITES IN 
*         THE NETWORK.
* 
* 
* 
* 
*                            COPY MODE DESCRIPTION
*                            ---------------------- 
* 
*         THE PURPOSE OF THE COPY MODE IS TO VERIFY AN INPUT DATA PATH
*         AND CREATE A COPY OF A DATA BASE ON THE SAME OR ANOTHER DEVICE
*         IN THE SYSTEM.  NORMALLY THE COPY WE BUILD WILL BE VERIFIED ON
*         A SUBSEQUENT COPY OR REGENERATE MODE. 
* 
*         A 511 WORD RECORD IS READ FROM TAPE N AS SPECIFIED ON AN INPUT
*         DATA CARD TO REGEN (COPY     N NN   WHERE N  IS THE INPUT FILE
*         NUMBER OF 1 TO 32 REPRESENTING TAPE1 THRU TAPE32 AND NN IS THE
*         OUTPUT FILE NUMBER OF 1 TO 32).   PRIOR TO WRITING THIS RECORD
*         TO TAPE NN, A NUMBER OF VALIDATION CHECKS ARE MADE TO INSURE
*         THAT THE HARDWARE/SOFTWARE HAS NOT DETERIORATED THE DATA. IT
*         SHOULD BE KEPT IN MIND THAT THE FOLLOWING CHECKS ARE MADE ON
*         ALL READS OF A DATA BASE FILE PERFORMED BY REGEN. 
* 
*           1. PARITY ERROR  STATUS IS CHECKED.  IF WE GET CONTROL BACK 
*              FROM THE SYSTEM AFTER A PARITY ERROR, A BACKSPACE-REREAD 
*              IS DONE ONCE.  IF THE ERROR PERSITS, THE JOB IS ABORTED. 
* 
*           2. END-OF-FILE STATUS IS CHECKED.  IF WE REACH EOF IT MEANS 
*              THAT THE DATA BASE DOES NOT CONTAIN THE EXPECTED NUMBER
*              OF RECORDS AS SELECTED ON THE FIRST INPUT DATA CARD TO 
*              REGEN (NUMBER OF RECORDS TO PROCESS), SO THE JOB WILL BE 
*              ABORTED. 
* 
*           3. RECORD LENGTH IS CHECKED TO BE 511 WORDS.  ONE BACKSPACE/
*              REREAD IS PERFORMED IF IT IS INCORRECT.  IF THE ERROR
*              PERSISTS, THE JOB IS ABORTED.
* 
*           4. THE DATA IS CHECKED TO INSURE THAT IT BELONGS TO OUR JOB,
*              IS IN CORRECT RECORD-NUMBER SEQUENCE, AND THAT THE BLOCKS
*              (OR SECTORS IN CASE OF MASS STORAGE) ARE IN THE CORRECT
*              SEQUENCE.  THIS CHECK IS PERFORMED BY VALIDATING THE 7 
*              POSITION DATA WORDS WITHIN THE RECORD.  UP TO SIX RETRIES
*              CAN BE MADE TO CORRECT A RECORD THAT FAILS THESE TESTS.
* 
* 
*                A. AN IN-CORE RETRY OF THE TEST IS PERFORMED TO INSURE 
*                   THAT IT WAS NOT A TRANSIENT CPU ERROR.
* 
*                B. A BACKSPACE/REREAD TO THE SAME BUFFER IN CM IS DONE 
*                   TO SEE IF IT WAS A TRANSIENT I/O NETWORK ERROR. 
* 
*                C. A BACKSPACE/REREAD TO A SECOND BUFFER IN CM IS DONE 
*                   TO DETERMINE IF THE ERROR IS CM ADDRESS SENSITIVE.
*                   BUFFER 1 AND BUFFER 2 FIRST WORD ADDRESSES ARE
*                   STAGED 1001B WORDS OFF FROM EACH OTHER SO THAT A CM 
*                   BANK FAILURE WOULD MOVE OUR FAILURE TO A NEW ADDRESS
*                   WHEN WE SWITCH FROM BUFFER 1 TO BUFFER 2. 
* 
*                   NOTE..  THIS PROCESS COULD CORRECT A POSITION DATA
*                           ERROR SINCE IT IS ONLY ONE WORD IN LENGTH.
*                           HOWEVER, A CHECKSUM DATA ERROR COULD FOLLOW 
*                           SINCE WE COULD HAVE MOVED DATA INTO THE BAD 
*                           BANK ADDRESSES. 
*                           ONCE WE SWITCH FROM BUFFER 1 TO BUFFER 2
*                           ON A RECORD DUE TO AN ERROR, WE STAY IN THAT
*                           BUFFER UNTIL THIS RECORD IS PROCESSED. THE
*                           NEXT RECORD WILL BE PROCESSED OUT OF BUFFER 
*                           1.  WE ALWAYS USE BUFFER 1 ON THE GENERATE
*                           MODE, BUT BUFFER USE ON THE COPY OR THE 
*                           REGENERATE MODES ARE DICTATED BY ERROR
*                           SITUATIONS. 
* 
*                D. AN IN-CORE RETRY OF BUFFER 2. 
* 
*                E. A BACKSPACE/REREAD TO BUFFER 2. 
* 
* 
*              THE RETRIES ARE ONLY ATTEMPTED UNTIL A RECOVERY HAS BEEN 
*              SUCCESSFULLY COMPLETED OR UNTIL ALL OPTIONS HAVE BEEN
*              TRIED WITHOUT SUCCESS IN WHICH CASE THE JOB IS ABORTED.
*              ON EACH FAILURE, THE DATA IN  QUESTION IS PRINTED FOR CE 
*              ANALYSIS AND AN ERROR LOG IS WRITTEN TO TAPE99 FOR LATER 
*              MORE DETAIL ANALYSIS BY THE ISOLATE MODE OF REGEN IF IT
*              BECOMES NECESSARY.  DATA IS ALSO PRINTED AFTER A RECOVERY
*              TO PROVIDE THE CE WITH CORRECT DATA TO COMPARE WITH THE
*              BAD DATA PREVIOUSLY PRINTED.  IF WE ARE UNABLE TO RECOVER
*              AND ALL ERRORS ARE IDENTICAL, IT COULD BE ASSUMED THAT 
*              THE DATA WE ARE TRYING TO READ COULD HAVE BEEN WRITTEN 
*              INCORRECTLY. 
* 
* 
*           5. THE CHECKSUMS OF ALL EIGHT BLOCKS ARE VALIDATED BY PVC.
*              6 RETRIES ARE POSSIBLE IN CASE OF ERROR AND ARE IDENTICAL
*              TO THOSE USED ON POSITION DATA ERRORS.  IN ALL CASES, IF 
*              A RE-READ IS DONE TO RECOVER A SPECIFIC BLOCK ERROR, THE 
*              REREAD COULD HAVE CLOBBERED A PREVIOUSLY VALIDATED BLOCK.
*              THEREFORE, WE MUST REVALIDATE ALL POSITION AND CHECKSUM
*              WORDS AFTER A RECOVERY IF A RE-READ HAS BEEN DONE. 
* 
* 
*         IF ALL THE ABOVE CHECKS ARE SUCCESSFUL, NEW POSITION DATA IS
*         INSERTED INTO THE DATA READ FROM TAPE N AND THE 511 WORDS 
*         ARE WRITTEN TO TAPE NN.  NEW POSITION WORDS MUST BE ADDED TO
*         INSURE THAT THE JOB NAME IDENTIFIER SUPPLIED ON THIS RUN ON 
*         THE FIRST INPUT DATA CARD TO REGEN IS CARRIED WITH THE FILE.
*         THE PROCESS OF READING, VALIDATING, AND WRITING IS REPEATED 
*         FOR THE NUMBER OF RECORDS SPECIFIED ON THE FIRST INPUT DATA 
*         CARD TO REGEN ( NUMBER OF RECORDS TO PROCESS ). 
* 
* 
*                        REGENERATE MODE DESCRIPTION
*                        ---------------------------
* 
*         THE REGENERATE MODE ACCOMPLISHES TWO TASKS. 
* 
*           1. IT VERIFIES AN INPUT DATA PATH EXACTLY AS DONE ON THE
*              COPY MODE (PARITY, LENGTH, POSITION, AND CHECKSUMS). 
*              THE FILE NUMBER IS SPECIFIED ON THE INPUT DATA CARD
*              TO REGEN ( REGENERATE N   WHERE N IS 1 TO 32 THAT
*              REPRESENTS TAPE1 THRU TAPE32. )
* 
*           2. IT TESTS THE CPU/CENTRAL MEMORY BY RUNNING FST/ALX,
*              CALLING PVC TO GENERATE CHECKSUMS OF EACH PASS 
*              ANSWERS AND COMPARE THEM TO THE CHECKSUMS JUST READ
*              ACROSS THE INPUT DATA PATH.
* 
*         AFTER A RECORD OF 511 WORDS HAS BEEN READ AND VALIDATED, WE 
*         LOOK AT EACH BLOCK OF THIS RECORD AS TWENTY 3-WORD CHECKSUMS
*         THAT REPRESENT THE CHECKSUMS OF TWENTY PASSES OF FST/ALX. 
*         THEREFORE, WE RUN 20 PASSES OF FST/ALX BEFORE WE HAVE USED
*         UP A BLOCK AND WE REPEAT THIS PROCESS 8 TIMES TO USE UP A 
*         TOTAL RECORD ( 8 X 20 = 160 PASSES OF FST/ALX PER RECORD).
*         THE PROCESS OF READING A RECORD, VALIDATING THE RECORD, AND 
*         RUNNING FST/ALX/PVC TO TEST THE CPU/CM IS REPEATED THE
*         THE NUMBER OF RECORDS SPECIFIED ON THE FIRST DATA CARD TO 
*         REGEN ( NUMBER OF RECORDS TO PROCESS).
* 
* 
* 
*                        RETURN MODE DESCRIPTION
*                        -----------------------
* 
*         THE RETURN COMMAND (RETURN     N)  WILL REWIND TAPE N  AND
*         CALL A COMPASS SUBROUTINE (UNLOAD) TO PERFORM A CLOSE/UNLOAD
*         OPERATION ON TAPE N.  THIS WILL FREE UP A PHYSICAL TAPE UNIT
*         FOR USE BY ANOTHER JOB IN THE SYSTEM, OR FREE UP DISK SPACE 
*         FOR USE BY THIS OR ANOTHER JOB IN THE SYSTEM. ( N IS 1 TO 32
*         THAT REPRESENTS TAPE1 THRU TAPE32 ).
* 
* 
* 
*                        RUNPASS MODE DESCRIPTION 
*                        ------------------------ 
* 
* 
*         RUNPASS IS NOT A TEST - IT IS A MAINTENANCE AID TO HELP THE 
*         CE DETERMINE MORE ABOUT A FAILURE ON A PREVIOUS REGEN JOB 
*         WHERE FST/ALX FAILED TO RECREATE THE EXPECTED CHECKSUMS OF
*         A PARTICULAR PASS IN THE REGENERATE MODE.  WHEN THIS TYPE OF
*         ERROR OCCURS, ALL THAT IS KNOWN IS THE CURRENT DATA GENERATED 
*         BY FST/ALX, THE CURRENT CHECKSUMS OF THAT DATA, AND THE 
*         EXPECTED CHECKSUMS.  THERE IS NO WAY OF KNOWING THE CORRECT 
*         DATA THAT FST/ALX SHOULD HAVE GENERATED ON THIS PASS FOR
*         CHECKSUMMING. 
* 
*         RUNPASS WILL PROVIDE THE CE WITH THIS DATA BY INITIALIZING
*         FST/ALX TO THE PASS REQUESTED ON THE INPUT DATA CARD TO REGEN 
*         (RUNPASS            XXXXXXX   WHERE X IS AN OCTAL PASS NUMBER 
*         TO RUN FROM 0 TO 2223677 OCTAL ), RUN FST/ALX, CALL PVC TO
*         GENERATE A 3-WORD CHECKSUM OF THIS DATA, AND PRINT RESULTS. 
* 
*              CAUTION...  IF THE SAME SYSTEM IS USED TO RUN THIS TASK
*                          IT COULD FAIL IN THE SAME FASHION AS IT DID
*                          IN THE PREVIOUS RUN OF REGEN .  IF THIS DOES 
*                          HAPPEN, USE SMM DIAGNOSTICS OFF-LINE TO
*                          VERIFY SYSTEM OPERATION. 
* 
* 
* 
*                        ISOLATE MODE DESCRIPTION 
*                        ------------------------ 
* 
*         ISOLATE IS ANOTHER MAINTENANCE AID WITHIN REGEN TO AID THE
*         CE IN DETERMINING MORE ABOUT THE CHARACTERISTICS OF A FAILURE 
*         IN A PREVIOUS REGEN JOB.  ITS JOB IS TO PROCESS THE TAPE99
*         ERROR-LOG GENERATED BY A PREVIOUS REGEN JOB THAT HAD ERRORS.
* 
*         ISOLATE WILL REQUIRE TWO FILES WHICH ARE SPECIFIED ON THE 
*         INPUT DATA CARD TO REGEN ( ISOLATE   N NN   WHERE N IS A TAPE 
*         FILE NUMBER THAT REPRESENTS TAPE1 THRU TAPE32.  THIS IS THE 
*         FILE THAT MUST CONTAIN A GOOD COPY OF THE MASTER DATA BASE. 
*         NN IS 1 THRU 32 AND IS THE FILE THAT CONTAINS THE ERROR-LOG 
*         FROM A PREVIOUS REGEN RUN.
* 
*         ISOLATE WILL REWIND BOTH TAPES AND SEARCH THE MASTER DATA 
*         BASE FOR RECORDS THAT ARE ON THE ERROR-LOG.  ONCE FOUND, WE 
*         COMPARE THE TWO RECORDS AND PRINT NON-COMPARE WORDS.
*         THE RAW ERROR-LOGS GENERATED BY A REGEN JOB CAN HAVE RECORDS
*         OUT OF SEQUENTIAL ORDER RELATIVE TO OUR MASTER DATA BASE. 
*         THEREFORE, IT IS BEST TO RUN THE RAW ERROR-LOG THROUGH A
*         SORTMERGE PHASE BEFORE RUNNING THE ISOLATE MODE (IF SORTMERGE 
*         IS AVAILABLE ON-SITE. IF NOT, ISOLATE WILL DETECT THAT THE
*         RECORDS ARE OUT-OF-SEQUENCE AND REWIND THE MASTER DATA BASE 
*         FILE AND RE-START THE SEARCH.  IF THERE ARE MANY ERRORS ON
*         THE ERROR-LOG, THIS COULD BE QUITE TIME-CONSUMMING.)
* 
* 
* 
* 
* 
* 
* 
* 
*         INPUT CONTROL CARDS 
*         ------------------- 
* 
*         FIRST CARD OF INPUT DECK CONSISTS OF; 
* 
*         1. UNIQUE JOB IDENTIFER              COLUMNS 1-6  (ALPHA) 
*         2. NUMBER OF RECORDS RIGHT JUSTIFIED COLUMNS 8-11 (DECIMAL) 
* 
* 
*         CONTROL STATEMENTS FOR RUN OF REGEN 
*         ----------------------------------- 
* 
*         COLUMN   1         2
*         123456789012345678901234
* 
*         GENERATE   XX               GENERATE TAPE-XX
*         COPY       XX YY            COPY TAPE-XX TO TAPE-YY 
*         REGENERATE XX               REGENERATE TAPE-XX
*         RETURN     XX               CLOSE UNLOAD TAPE-XX
*         RUNPASS          ZZZZZZZ    RUN OCTAL PASS NO. ZZZZZZZ
*         ISOLATE    XX YY            RUN ISOLATE MODULE MASTER-XX
*                                     AND ERROR LOG TAPE-YY 
* 
* 
* 
* 
*         INSTALLATION DECK DESCRIPTION 
*         ------------------------------
* 
*         WHEN REGEN IS INSTALLED INTO A SYSTEM, TWO SYMBOLS WITHIN 
*         REGEN MUST BE PROPERLY DEFINED TO INSURE THAT A DATA BASE 
*         GENERATED ON ONE SOFTWARE SYSTEM IS THE SAME AS A DATA BASE 
*         GENERATED ON ANOTHER SOFTWARE SYSTEM ...  FOR EXAMPLE, SCOPE
*         IS THE SAME AS NOS. 
* 
*         THE TWO SYMBOLS USED ARE RA101 AND CYBERL.  WHEN PROPERLY 
*         DEFINED, THESE SYMBOLS WILL INSURE THAT THE FIRST EXECUTABLE
*         LINE OF CODE IN REGEN IS AT RA+107.  THIS WILL INSURE THAT THE
*         FST AND ALX MODULES GENERATE THE SAME RANDOM DATA FOR CHECKSUM
*         ROUTINE PVC REGARDLESS OF THE SOFTWARE SYSTEM USED. 
* 
* 
*         DEFAULT VALUES FOR THE SYMBOLS ARE FOR NOS AND NOS/BE 
*         WITH THE CYBER LOADER.
* 
*               RA101      EQU    1 
*               CYBERL     EQU    1 
* 
* 
*         THE FOLLOWING MOD WOULD BE REQUIRED FOR SCOPE 3.2 OR SCOPE 3.3. 
* 
*               *IDENT REGEN1 
*               *DELETE,REGEN.15
*               RA101      EQU    0 
*               *DELETE,REGEN.25
*               CYBERL     EQU    0 
*               *COMPILE,REGEN
* 
* 
*         THE FOLLOWING MOD WOULD BE REQUIRED FOR SCOPE 3.4 WITHOUT THE 
*         CYBER LOADER. 
* 
*               *IDENT REGEN1 
*               *DELETE,REGEN.25
*               CYBERL     EQU    0 
*               *COMPILE,REGEN
* 
* 
* 
* 
* 
*         SAMPLE JOBS 
*         ------------
* 
* 
*         1. GENERATE A MASTER DATA BASE OF 3750 RECORDS TO BE USED AS
*            THE SITE MASTER COPY. USE THE JOB NAME OF MASTER.
* 
*            JOBCARD. 
*            ACCOUNT AND RESOURCE CARDS AS REQUIRED.
*            REQUEST,TAPE1.   (MAG TAPE REQUEST CARD FOR DATA BASE) 
*            MODE,1.
*            REGEN. 
*            EXIT.
*            DMP,10000.              (IN CASE OF AN FST/ALX ERROR)
*            7/8/9            (EOR) 
*            MASTER 3750
*            GENERATE   01
*            6/7/8/9          (EOF) 
* 
* 
*         2. COPY TAPE1 TO TAPE2 TO TAPE3 TO TAPE4 AND REGENERATE 
*            DATA ON TAPE4. PROCESS 500 RECORDS WITH JOB NAME OF JOB1.
*            THE MASTER DATA BASE IS ON TAPE1, SO A REQUEST CARD MUST 
*            BE INCLUDED THAT PROPERLY IDENTIFIES IT.  THE FILES FOR
*            TAPE2, TAPE3, AND TAPE4 CAN RESIDE ANYWHERE ON TAPE OR 
*            DISK AS THE USER DESIRES.
* 
* 
*            JOBCARD. 
*            ACCOUNT AND RESOURCE CARDS AS REQUIRED.
*            REQUEST CARDS (TO SPECIFY THE PATH TO TAPES 1 - 4 )
*            REQUEST,TAPE99.  (MAG TAPE REQUEST CARD FOR ERROR-LOG) 
*            MODE,1.
*            REGEN. 
*            EXIT.
*            DMP,10000.              (IN CASE OF AN FST/ALX ERROR)
*            7/8/9            (EOR) 
*            JOB1   0500
*            COPY       01 02 
*            RETURN     01
*            COPY       02 03 
*            COPY       03 04 
*            REGENERATE 04
*            6/7/8/9          (EOF) 
* 
* 
* 
*         3. EXECUTE A RUNPASS OF FST/ALX PASS 0000123
* 
*            JOBCARD. 
*            ACCOUNT AND RESOURCE CARDS AS REQUIRED.
*            MODE,1.
*            REGEN. 
*            EXIT.
*            DMP,10000.             (IN CASE OF AN FST/ALX FAILURE) 
*            7/8/9            (EOR) 
*            JOB1 
*            RUNPASS          0000123 
*            6/7/8/9          (EOF) 
* 
* 
*         4. EXECUTE AN ISOLATE MODE AGAINST AN ERROR-LOG FROM A
*            PREVIOUS REGEN JOB.  SORTMERGE IS IN THE SYSTEM, SO
*            SORT THE ERROR-LOG FROM TAPE99 TO TAPE2 BEFORE PRESENTING
*            IT TO REGEN.  THE MASTER DATA BASE IS ON TAPE1.
* 
*            JOBCARD. 
*            ACCOUNT AND RESOURCE CARDS AS REQUIRED.
*            REQUEST,TAPE99,VSN=XXX.    REGEN ERROR LOG.
*            REWIND,TAPE2.
*            FILE CARDS AS REQUIRED ( MAXIMUM CHARACTER LENGTH = 5180)
*            SORTMRG. 
*            REQUEST,TAPE1,VSN=YYY.     MASTER DATA BASE
*            REGEN. 
*            7/8/9            (EOR) 
*            SORT 
*            BYTESIZE,60
*            FILE,INPUT=TAPE99(CU),OUTPUT=TAPE2(R)
*            FIELD,RECORD(1,1),BLOCK(2,1) 
*            KEY,RECORD(A,INTBCD),BLOCK(A,INTBCD) 
*            OPTIONS,RETAIN 
*            END
*            7/8/9            (EOR) 
*            JOB4 
*            ISOLATE    01 02 
*            6/7/8/9/         (EOF) 
* 
* 
* 
*         5. EXECUTE AN ISOLATE MODE AGAINST AN ERROR-LOG FROM A
*            PREVIOUS REGEN JOB.  SORTMERGE IS NOT IN THE SYSTEM. 
*            THE ERROR-LOG IS ON TAPE99 AND THE MASTER DATA BASE IS ON
*            TAPE1. 
* 
* 
*            JOBCARD. 
*            ACCOUNT AND RESOURCE CARDS AS REQUIRED.
*            REQUEST,TAPE99,VSN=XXX.      REGEN ERROR LOG.
*            REQUEST,TAPE1,VSN=YYY.       REGEN MASTER DATA BASE. 
*            REGEN. 
*            7/8/9           (EOR)
*            JOB5 
*            ISOLATE    01 99 
*            6/7/8/9         (EOF)
* 
* 
* 
* 
*         NORMAL MESSAGES 
*         ----------------
* 
*         TWO TYPES OF MESSAGES ARE ISSUED - DAYFILE MESSAGES AND OUT-
*         PUT FILE MESSAGES.  DAYFILE MESSAGES PROVIDE THE USER WITH
*         AN INDICATION OF THE CURRENT OPERATION IN PROGRESS.  NORMAL 
*         DAYFILE MESSAGES ARE AS FOLLOWS.. 
* 
*           1. GENERATE TAPE XX 
*           2. COPY  TAPE XX TO YY
*           3. REGENERATE TAPE XX 
*           4. RETURN TAPE XX 
*           5. RUNPASS  XXXXXXX 
*           6. RUNNING ISOLATE MODE 
* 
*         OUTPUT FILE MESSAGES PROVIDE A CROSS-CHECK OF DAYFILE MESSAGES
*         AND ARE ALL PRECEDED WITH THE DATE AND TIME-OF-DAY. 
* 
*           1. START XXXXXX  NUMBER OF RECORDS SELECTED = YYYY
*           2. START GENERATION OF TAPE XX
*           3. WALL CLOCK GENERATE TIME = XX.XX.XX (YYYY.YY CPU SECONDS 
*              USED)
*           4. START COPY OF TAPE XX TO TAPE YY 
*           5. WALL CLOCK COPY TIME = XX.XX.XX (YYYY.YY CPU SECONDS USED
*           6. START REGENERATION OF TAPE XX
*           7. WALL CLOCK REGENERATE TIME = XX.XX.XX (YYYY.YY CPU 
*              SECONDS USED)
*           8. RETURNING TAPE XX
*           9. WALL CLOCK RETURN TIME = XX.XX.XX (YYYY.YY CPU SECONDS 
*              USED)
*          10. START ISOLATE MODE 
*          11. WALL CLOCK ISOLATE TIME = XX.XX.XX (YYYY.YY CPU SECONDS
*              USES)
*          12. XXX END OF RUN XXX 
*          13. TOTAL WALL CLOCK RUN TIME = XX.XX.XX (XXXXXX.XX CPU
*              SECONDS USED)
*          14. XXX TOTAL BITS FOR RUN = XXXXXXXXXXXXX 
*          15. TOTAL ERRORS SAVED ON TAPE99 = XXXXX 
*          16. ANALYZING ERROR ON RECORD A BLOCK B TAPE C DUE TO D ERROR
*              (BFRFWA= EEEEE)  DATE = F  TIME = G
*                   WORD        EXPECTED    ACTUAL    DIFFERENCE
* 
*                     (  WORDS THAT FAILED TO COMPARE)
* 
* 
*                   A = DECIMAL RECORD NUMBER  OF 1 TO 3750 
*                   B = BLOCK NUMBER OF 1 TO 8
*                   C = TAPE NUMBER 1 TO 32 
*                   D = ERROR TYPE (PARITY, LENGTH, POSITION,CHECKSUM)
*                   E = FIRST WORD ADDRESS OF THE BUFFER THAT FAILED
*                   F = DATE ERROR OCCURRED 
*                   G = TIME ERROR OCCURRED 
* 
*                   WORD = OCTAL WORD NUMBER IN THE RECORD THAT FAILED
*                          TO COMPARE WITH THE MASTER DATA BASE.  THIS
*                          VALUE WILL BE 000 TO 776.  TO FIND THE 
*                          ABSOLUTE MEMORY ADDRESS OF A FAILURE, YOU
*                          MUST ADD THE FOLLOWING...
*                             WORD + E + REFERENCE ADDRESS (RA) 
* 
*                   EXPECTED =   DATA FROM THE MASTER DATA BASE 
* 
*                   ACTUAL =     DATA FROM THE ERROR LOG
* 
*                   DIFFERENCE = LOGICAL DIFFERENCE OF EXPECTED AND 
*                                ACTUAL 
* 
*          17. RECORD XXXX HAD YYYY NON-COMPARE WORDS 
*                   XXXX = 1 TO 3750 (DECIMAL)
*                   YYYY = 0 TO 511  (DECIMAL)
* 
*          18. NORMAL TERMINATION OF ISOLATE DUE TO EOF ON ERROR LOG. 
* 
* 
* 
* 
*         ERROR SITUATIONS
*         ----------------
* 
*         1. IF FST DETECTS A CPU/CM FAILURE, IT ABORTS ON A MODE 1 
*            ERORR BY JUMPING TO ADDRESS 377776 OCTAL. (SINCE FST AND 
*            ALX BOTH GENERATE MODE 2 AND MODE 4 ERRORS, AND TERMINATE
*            BY A MODE 1 ERROR, A CONTROL CARD MUST BE IN THE JOB DECK
*            THAT SELECTS PROPER ERROR EXIT SITUATIONS (MODE,1.)
* 
*            EXIT AND DMP CONTROL CARDS SHOULD BE USED AFTER THE CALL 
*            TO REGEN TO PROVIDE A MEMORY DUMP IN CASE FST OR ALX DO
*            ERROR EXIT.
* 
*         2. IF ALX DETECTS AN ERROR, THE SAME PROCEDURE AS IN FST IS 
*            USED EXCEPT ALX WILL JUMP TO ADDRESS 377777 OCTAL. 
* 
*            SINCE FST AND ALX DIAGNOSTICS ARE VERY SIMILAR TO THEIR
*            ON-LINE AND OFF-LINE  SMM  VERSIONS, ERRORS CAN BE ISOLATED
*            USING THE DUMP PROVIDED IN THE NORMAL FASHION.  THE DUMP 
*            CONTAINS THE INSTRUCTIONS THAT CREATED THE ERROR AS WELL AS
*            INPUT OPERANDS, GOOD RESULTS, AND BAD RESULTS IN EXCHANGE
*            PACKAGE FORMAT.  THE RANDOM NUMBER GENERATORS IN THE REGEN 
*            VERSION OF FST AND ALX ARE IDENTICAL TO THE OFF-LINE SMM 
*            VERSIONS, SO WHEN A FAILURE OCCURS ON A SPECIFIC FST/ALX 
*            PASS IN REGEN, SMM CAN BE USED TO DUPLICATE THE INSTRUCTION
*            SEQUENCES THAT FAILED. ( NOTE ..  THE INSTRUCTIONS WILL
*            BE THE SAME EXCEPT FOR MEMORY ADDRESSING VALUES WITHIN THE 
*            INSTRUCTIONS AS WELL AS THE ADDRESS VALUES LOADED INTO THE 
*            A REGISTERS. ) 
* 
*         3. A CHECKSUM ERROR CAN OCCUR ON DATA READ FROM TAPE N.  PVC
*            WILL REPORT THE ERROR AND HAS THE CAPABILITY TO ISOLATE A
*            SINGLE BIT FAILURE TO THE WORD AND BIT THAT FAILED 
*            (RELATIVE TO RA). MULTIPLE BIT FAILURES ARE DETECTED BUT 
*            CANNOT BE ISOLATED CLOSER THAN THE 63 WORD BLOCK WHICH IS
*            DUMPED FOR ANALYSIS. 
* 
*            THE FOLLOWING IS PRINTED IF AN ERROR OCCURS..
* 
*            A. FILE NAME.
*            B. BUFFER IN USE.
*            C. TRY/RETRY CONDITION.
*            D. RECORD NUMBER.
*            E. BLOCK NUMBER. 
*         ** F. ADDRESS AND BIT THAT FAILED.
*            G. X,Y,AND Z CHECKSUM VECTORS GENERATED. 
*            H. 60 WORDS OF DATA IN THE BLOCK.
*            I. 3 - WORD CHECKSUMS FROM TAPE FOR THIS BLOCK.
*            J. POSITION DATA WORD FOR THIS BLOCK ( IF BLOCK 1 - 7 )
* 
* 
*            ** THE FORMAT OF THE ADDRESS AND BIT DATA IS AS FOLLOWS..
* 
*                   XXXXXXXXYYZZZZZZZZZZ   OR   ZZZZZZZZZZXXXXXXXXYY
* 
*                   Z = 0 IF THE FAILURE WAS A SINGLE BIT FAILURE THAT
*                       HAS BEEN ISOLATED.
* 
*                   Z = -0 IF THE FAILURE WAS MORE THAN ONE BIT AND CAN 
*                       NOT BE ISOLATED.
* 
*                   Y = THE BIT THAT FAILED (00 TO 73 OCTAL )  Y = 00 
*                       IF THE ERROR CANNOT BE ISOLATED ( Z = -0) 
* 
*                   X = THE ADDRESS THAT FAILED ( RELATIVE TO RA ). IF
*                       Z = -0 (UNABLE TO ISOLATE), X IS THE FWA OF THE 
*                       63 WORD BLOCK THAT HAD THE ERROR. 
* 
*         4. A CHECKSUM ERROR CAN OCCUR ON DATA BEING REGENERATED BY THE
*            CPU IN THE REGENERATE MODE.  THE SAME INFORMATION AS IN 3.C
*            THRU 3.I ABOVE IS PRINTED FOR ANALYZIS.  THE FST/ALX PASS
*            COUNT IS ALSO PRINTED. 
* 
* 
*         5. I/O ERRORS ARE REPORTED AND RETRIES ON READ LENGTH AND READ
*            PARITY ERRORS ARE EXECUTED.  THE FOLLOWING ERRORS ARE FATAL
*            (JOB IS ABORTED).
* 
*              A. WRITE PARITY ERROR ON BUFFER OUT. 
*              B. EOF STATUS ON BUFFER OUT
*              C. EOF STATUS ON BUFFER IN 
*              D. UNCORRECTABLE PARITY ERROR ON BUFFER IN 
*              E. UNCORRECTABLE LENGTH ERROR ON BUFFER IN 
* 
*         6. POSITION DATA ERRORS CAN OCCUR ON DATA READ FROM TAPE N. 
*            THE FOLLOWING DATA IS REPORTED TO THE OUTPUT FILE. 
* 
*              A. FILE NAME.
*              B. BUFFER IN USE.
*              C. TRY/RETRY CONDITION.
*              D. RECORD NUMBER.
*              E. BLOCK NUMBER. 
*              F. EXPECTED AND ACTUAL DATA. 
* 
* 
* 
* 
*         ERROR MESSAGES TO THE DAYFILE 
*         ----------------------------- 
* 
* 
*         1. FST/ALX ERR ON PASS  XXXXXXX 
*         2. FST/ALX RETRY ERR ON PASS  XXXXXXX 
*         3. POSITION DATA ERROR ON PASS  XXXXXXX 
*         4. CHECKSUM ERR ON TRY X
* 
* 
* 
* 
* 
* 
*         ERROR MESSAGES TO THE OUTPUT FILE 
*         --------------------------------- 
* 
*         ALL ERROR MESSAGES WRITTEN TO THE OUTPUT FILE ARE PRECEDED BY 
*         THE DATE AND TIME.  THE MESSAGES ARE SELF-EXPLANATORY.
* 
*         THE FOLLOWING CHART LISTS EACH ERROR SITUATION, WHAT MESSAGE
*         IS ISSUED, WHAT IS IN EACH MESSAGE, AND WHAT ACTION IS TAKEN
*         BY REGEN AFTER THE MESSAGE IS POSTED. 
* 
* 
*              PROBLEM             DAYFILE  OUTPUT  ERR    ACTION 
*                                       MSG    MSG  LOG 
* 
*           1.  READ PARITY                 1    2  8  BKSP/REREAD ONCE 
*           2.  READ PARITY RECOVERY             2     CONTINUE 
*           3.  UNCORRECTABLE READ PARITY        2     ABORT JOB
*           4.  READ LENGTH ERROR           1    2     BKSP/REREAD ONCE 
*           5.  READ LENGTH RECOVERY             3     CONTINUE 
*           6.  UNCORRECTABLE LENGTH ERR         3     ABORT JOB
*           7.  EOF ON BUFFER IN                 2     ABORT JOB
*           8.  WRITE PARITY ERROR               2     ABORT JOB
*           9.  EOF ON WRITE                     2     ABORT JOB
*          10.  POSITION DATA ERROR         1    4  8  UP TO 6 RETRIES
*          11.  POSITION DATA RECOVERY           4     CONTINUE (MAY RE-
*                                                      CHECK POSITIONS) 
*          12.  UNCORRECTABLE POSITION ERR       4     ABORT JOB
*          13.  DATA CHECKSUM ERROR         1    5  8  UP TO 6 RETRIES
*          14.  DATA CHECKSUM RECOVERY           5     CONTINUE (MAY RE-
*                                                      CHECK POSITIONS +
*                                                      ALL CHECKSUMS) 
*          15.  UNCORRECTABLE CHECKSUM           5     ABORT JOB
*          16.  FST/ALX CHECKSUM ERROR           6     RETRY ONCE, RERUN
*                                                      FST/ALX ONCE 
*          17.  FST/ALX CHECKSUM RECOVERY        6     CONTINUE 
*          18.  UNCORRECTABLE FST/ALX CKSUM      6     ABORT JOB
*          19.  FST FAILURE                            MODE 1 AT 377776 
*          20.  ALX FAILURE                            MODE 1 AT 377777 
*          21.  ILLEGAL RUNPASS NUMBER           7     ABORT RUNPASS
*          22.  NO. OF RECORDS LT 0 OR GT 3750   9     END RUN
*          23.  UNRECOGNIZED INPUT STATEMENT    10     END RUN
* 
* 
* 
* 
*         MESSAGE KEYS ABOVE ARE AS FOLLOWS.
* 
*         1. TIME, RETRY COUNT
*         2. DATE, TIME, RECORD NUMBER, FILE NAME 
*         3. DATE, TIME, RECORD NUMBER, FILE NAME, LENGTH 1, LENGTH 2 
*         4. DATE, TIME, FILE NAME, BUFFER, TRY CONDITION, RECORD NUMBER
*            BLOCK NUMBER, EXPECTED DATA, ACTUAL DATA 
*         5. DATE, TIME, FILE NAME, BUFFER, TRY CONDITION, RECORD NUMBER
*            BLOCK NUMBER, ADDRESS DATA, XYZ VECTORS, 60 WORDS OF DATA, 
*            EXPECTED 3-WORD CHECKSUM, POSITION DATA (BLOCKS 1-7 ONLY)
*         6. DATE, TIME, PASS COUNT, ADDRESS DATA, XYZ VECTORS, 60 WORDS
*            OF DATA, EXPECTED CHE0KSUM 
*         7. DATE, TIME, PASS COUNT 
*         8. RECORD NUMBER, BLOCK NUMBER, FILE NAME, FAILURE CODE, DATE,
*            TIME, FWA OF BUFFER IN USE, 511 WORDS OF DATA. 
*         9. NUMBER OF RECORDS OUT OF RANGE = IIII
*        10. UNRECOGNIZED INPUT CONTROL STATEMENT = ZZZZZZZZZ 
* 
* 
* 
* 
* 
*         REGEN ERROR LOG 
*         ----------------
* 
*         IN ADDITION TO THE ERROR MESSAGES AND DATA PRINTED VIA THE
*         OUTPUT FILE, REGEN WRITES A RECORD TO TAPE99 ON ANY OF THE
*         FOLLOWING ERRORS. 
* 
*           1. READ PARITY ERROR ( IF REGEN GETS CONTROL FROM SYSTEM) 
*           2. READ LENGTH ERROR
*           3. POSITION DATA ERROR
*           4. CHECKSUM ERROR ON INPUT DATA.
* 
* 
*         THE FOLLOWING INFORMATION IS RECORDED ON TAPE99 FOR EACH
*         ERRORS. 
* 
*           1. RECORD NUMBER THAT FAILED ( 1 TO  3750 DECIMAL ) 
*           2. BLOCK NUMBER  (1-8 IF ISOLATED, 0 IF NOT)
*           3. FILE NUMBER (1-32 REPRESENTING TAPE1-TAPE32) 
*           4. ERROR CODE (1=PARITY, 2=LENGTH, 3=POSITION, 4= CHECKSUM) 
*           5. DATE OF FAILURE
*           6. TIME OF FAILURE
*           7. FIRST WORD ADDRESS OF THE BUFFER IN USE ON FAILURE.
*           8. THE 511 WORD RECORD CONTAINING THE ERROR.
* 
*         A RECORD IS WRITTEN FOR EACH UNSUCCESSFUL RETRY ON POSITION 
*         OR CHECKSUM ERROR JUST IN CASE THE ERRORS ARE NOT CAUSED BY 
*         THE SAME HARDWARE/SOFTWARE FAILURE.  TAPE99  IS AUTOMATICALLY 
*         WRITTEN BY REGEN, BUT THE USER IS RESPONSIBLE TO INSURE IT IS 
*         SAVED ACROSS REGEN JOBS BY ASSIGNING IT TO MAGNETIC TAPE FROM 
*         THE BEGINNING OF A JOB, BY COPYING IT TO TAPE AT THE END OF A 
*         JOB, OR BY CATALOGING IT AS A PERMANENT FILE AT THE END OF A
*         JOB.  THE ERRORLOG CAN THEN BE ANALYZED BY A LATER REGEN RUN
*         USING THE ISOLATE MODE OF OPERATION.
* 
* 
* 
*         SENSE SWITCH OPTIONS
*         --------------------
* 
* 
*         REGEN USES THREE SENSE SWITCHES TO CONTROL ERROR REPORTING
*         AND JOB EXECUTION.
* 
*         SENSE SWITCH 1, WHEN SET, WILL CAUSE REGEN TO TERMINATE AT
*         THE END OF THE CURRENT MODE REGARDLESS OF THE REMAINING 
*         MODE CARDS ON THE INPUT FILE. 
* 
*         SENSE SWITCH 2, WHEN SET, WILL CAUSE REGEN TO PAUSE AFTER 
*         EACH OF THE FOLLOWING ERROR SITUATIONS.  THE PAUSE MESSAGE
*         NUMBER AND THE DAYFILE MESSAGES ISSUED PRIOR TO THE PAUSE 
*         ALLOWS THE CE TO DETERMINE THE NATURE OF THE PAUSE.  AN 
*         OPERATOR  GO  IS REQUIRED TO CONTINUE PROCESSING. 
* 
*           PAUSE 1  = READ PARITY ERROR
*           PAUSE 2  = READ LENGTH ERROR
*           PAUSE 3  = POSITION DATA ERROR
*           PAUSE 4  = CHECKSUM DATA ERROR ON INPUT DATA
*           PAUSE 5  = FIRST TRY CHECKSUM ERROR ON FST/ALX DATA 
*                      DURING A REGENERATE MODE.
*           PAUSE 6  = THE IN-CORE RETRY OF THE CHECKSUM  OPERATION 
*                      FAILED ON THE FST/ALX DATA.
* 
*         SENSE SWITCH 3 IS USED TO CONTROL THE AMOUNT OF DATA THAT IS
*         PRINTED ON EACH FAILURE ANALYZED ON THE ISOLATE MODE. IF THIS 
*         SWITCH IS OFF, ONLY THE FIRST 10 WORDS IN ERROR WITHIN EACH 
*         RECORD IS PRINTED.  IF THE SWITCH IS ON, ALL NON-COMPARE WORDS
*         ARE PRINTED.  ( THIS COULD RESULT IN OVER 511 LINES PER RECORD
*         IN ERROR ). 
* 
* 
  
  
  
*         THIS IS THE START OF DIAGNOSTIC TEST FST
*         ENTRY/EXIT FOR THE TEST IS AT OO.FST
* 
* 
*           STORE REGISTERS AFTER EXECUTION 
* 
OO.CHK    SA7    OO.SANS+17B
          SX7    B1+B0
          SB1    B0+B0
          ZR     B0,OO.CHK1 
OO.FECK   SA7    OO.SANS+37B
          NO
          NO
          NO
          SX7    B1+B0
          SB1 B0+20B
OO.CHK1   SA7    B1+OO.SANS+1 
          NO
          SX7    A6+B0
          SA6    B1+OO.SANS+16B 
          SA7    B1+OO.SANS+6 
          LX6    B0,X0
          BX7    X1 
          SX1    A0+B0
          MX0    18 
          SA6    B1+OO.SANS+10B 
          SA7    B1+OO.SANS+11B 
          LX0    18 
          BX6    X2 
          SX2    A2+B0
          LX7    B0,X3
          SA6    B1+OO.SANS+12B 
          SA7    B1+OO.SANS+13B 
          BX1    X0*X1
          SX3    B0+B2
          LX6    B0,X4
          BX7    X5 
          SA6    B1+OO.SANS+14B 
          SA7    B1+OO.SANS+15B 
          LX1    18 
          SX4    A3+B0
          BX6    X0*X2
          SX2    B0+B3
          LX7    B0,X1
          BX3    X0*X3
          SX5    A4+B0
          SX1    B0+B4
          SA7    B1+OO.SANS 
          BX4    X0*X4
          LX6    18 
          IX6    X6+X3
          BX2    X0*X2
          LX4    18 
          SX3    A5+B0
          IX7    X4+X2
          SA6    B1+OO.SANS+2 
          BX5    X0*X5
          LX5    18 
          SA7    B1+OO.SANS+3 
          BX1    X0*X1
          IX6    X5+X1
          SX1    B0+B5
          SX5    B0+B6
          BX7    X0*X3
          SA2    B1+OO.SANS+1 
          SA4    B1+OO.SANS+6 
          LX7    18 
          BX1    X0*X1
          SX3    A1+B0
          SB2    B0+B0
          SA6    B1+OO.SANS+4 
          IX7    X1+X7
          BX4    X0*X4
          SA7    B1+OO.SANS+5 
          LX4    18 
          BX5    X0*X5
          BX3    X0*X3
          IX6    X4+X5
          SX4    B0+B7
          BX2    X0*X2
          SA6    B1+OO.SANS+6 
          LX3    18 
          BX7    X0*X4
          SA7    B1+OO.SANS+7 
          SB4    B0+B0
          IX6    X2+X3
          SA6    B1+OO.SANS+1 
          ZR     B1,OO.AA 
* 
*           COMPARE RESULTS 
*           ENTER WITH B2=0 
* 
OO.AB     SA1    B2+OO.SANS 
          SA2    B2+OO.SANS+20B 
          SB2    B2+1 
          BX6    X1-X2
          CX0    X6 
          NZ     X0,OO.CERR 
          EQ     B1,B2,OO.LOOP
          JP     OO.AB             VOID THE STACK 
OO.LOOP   SA1    OO.FLC 
          SX6    X1-1 
          SA6    OO.FLC 
          PL     X6,OO.SET
OO.GON    SA1    OO.SRT 
          SA3    OO.PCTR
          SX2    B0+1 
          NZ     X1,OO.DIDN 
          SA1    OO.FLC1           GET NUMBER OF FAST LOOP TRIES
          BX7    X1 
          IX6    X2+X3
          SA6    OO.PCTR
          SA7    OO.FLC            RESET LOOP COUNTER 
          SA2    OO.DATA
          SB1    B0 
          SB2    16 
          SB3    1
OO.MD     SA1    B1+OO.SANS 
          BX7    X1 
          SA7    X2+B1             MOVE ANSWERS FROM FST TO DATA ARRAY
          SB1    B1+B3
          NE     B1,B2,OO.MD
          SB1    B0 
          SX2    X2+B2
OO.MD1    SA1    B1+OO.FAST 
          BX7    X1 
          SA7    X2+B1             MOVE FST INSTRUCTION LOOP TO DATA ARR
          SB1    B1+B3
          NE     B1,B2,OO.MD1 
* 
* 
FST       BSS    0
OO.FST    BSSZ   1                 START OF FST TEST
          BX7    X1 
          SA7    OO.DATA           SAVE POINTER TO DATA ARRAY 
* 
OO.GON1   SA2    OO.RAN+4 
          SA1    OO.RAN+1 
          SA3    OO.RAN+3 
          SA5    OO.RAN+6 
* 
*           GENERATE RANDOM NUMBERS 
*           ENTER WITH X1,X2,X3,X5=OPERANDS 
* 
OO.GEN    IX0    X1+X2
          SB1    B0+1 
          IX7    X3+X5
          LX0    31B
          SB5    B0+10B 
          LX7    10 
          IX5    X7+X0
          SA7    OO.RAN+6 
          IX6    X5+X7
          IX1    X0+X3
          SA6    OO.RAN 
          LX1    42B
          IX7    X1-X5
          SB3    B0+B0
          SB4    B0+B0
          IX6    X0-X7
          SA7    OO.RAN+4 
          SA6    OO.RAN+5 
          MX4    15 
          SA2    OO.PAS4
          IX7    X7+X1
          BX6    X5 
          SA7    OO.RAN+1 
          NO
          SA6    OO.RAN+7 
          NO
          BX7    X1 
          SA7    OO.RAN+2 
          SA5    OO.PAS3
          BX6    X0 
          LX7    B0,X2
          SA6    OO.RAN+3 
* 
*           FILTER RANDOM NUMBERS 
*           ENTER WITH B1=1,B3=0(SLOW STORE INDEX),B4=0(FAST STORE INDEX
*            B5=10B,X4=15 BIT MASK,X5=3 PASSES,X7=4 PASSES
* 
OO.SAP    SA1    B4+OO.RAN
          SB2    B0+4 
OO.GAP    MX3    3
          BX2    X1*X3
          SB7    B2-B1
          LX0    B0,X1
          NG     X1,OO.MBK
          NZ     X2,OO.NOTK 
OO.PASS   MX3    45 
          SX0    B0+46000B
          LX3    45 
          LX0    45 
          BX2    X3*X1
          NO
          IX1    X0+X2
OO.NOTK   BX3    X1*X4
          SB2    B2-B1
          LX1    15 
          IX6    X3+X5
OO.STOR   SA7    B3+OO.SLOW 
          SB3    B3+B1
          NO
          SA6    B3+OO.SLOW 
          SB3    B3+B1
          NO
          NZ     B2,OO.GAP
          SA2    OO.SHNL
          BX6    X1 
          NO
          NZ     X2,OO.SHOT 
          SA6    B4+OO.FAST 
          SB4    B4+B1
          NO
          NE     B4,B5,OO.SAP 
          SA1    OO.SLJP
          SA2    OO.FSJP
          MX7    0
          BX6    X1 
          SA6    B3+OO.SLOW 
          SA7    B3+OO.SLOW+1 
          SB1    B0+B0
          BX6    X2 
          SA7    B4+OO.FAST+1 
          SA6    B4+OO.FAST 
          ZR     B0,OO.SET
OO.MBK    LX2    3
          SB6    X2-5 
          LX3    3
          NG     B6,OO.FORT        46XXX INSTRUCTION
          ZR     B6,OO.FIFT 
          LX0    6
          BX2    X0*X3
          SB6    X2-3 
          NG     B6,OO.ISK
          MX3    60-9 
          LX0    3
          BX2    -X3*X0 
          SB6    X2-660B
          ZR     B6,OO.PASS  IF 660XX INSTRUCTION PAD WITH PASS 
          SB6    X2-670B
          NZ     B6,OO.NOTK  IF NOT 670XX INSTRUCTION 
          EQ     OO.PASS
  
 OO.ISK   ZR     B7,OO.PASS 
OO.KTYP   MX3    30 
          SB2    B2-2 
          BX0    X3*X7
          LX0    30 
          BX2    X3*X1
          IX6    X0+X2
          LX1    30 
          ZR     B0,OO.STOR 
OO.FIFT   ZR     B7,OO.PASS 
          LX0    9
          NO
          BX2    X0*X3
          SB7    X2-6 
          LX0    21 
          SX2    X2+510B
          BX1    X0*X3
          LX2    21 
          NG     B7,OO.READ 
          SX1    X1+OO.WRIT 
          ZR     B0,OO.RDY
OO.READ   SX1    X1+OO.RAN
          NO
          NO
OO.RDY    MX3    30 
          IX2    X1+X2
          NO
          BX0    X0*X3
          IX1    X0+X2
          LX1    30 
          JP     OO.KTYP
* 
*           SHORTEN FAST LOOP 
*           ENTER WITH B2=0 
* 
OO.AEE    SA1    B2+OO.FAST 
          SB2    B2+1 
          ZR     X1,OO.AEEA 
          JP     OO.AEE            VOID THE STACK 
OO.AEEA   BSS    0
          SA1    B2+OO.FAST-2 
          SA2    B2+OO.FAST-3 
          SB5    B0+3 
          MX6    0
          BX7    X1 
          EQ     B2,B5,OO.NOMR
          SA6    B2+OO.FAST-2 
          SA7    B2+OO.FAST-3 
* 
*           CHECK NUMBER OF INSTRICTIONS IN WORD
*           ENTER WITH X2= WORD REMOVED FROM FAST LOOP
* 
          SB2    B0+4 
          NO
          SB1    B0+B0
OO.HOT    NG     X2,OO.POSI 
          NO
          NO
OO.SROT   SB1    B1+1 
          LX2 15
          NO
          SB2    B2-1 
          ZR     B2,OO.DONE 
          JP     OO.HOT            VOID THE STACK 
OO.POSI   BX1    X2 
          LX1 3 
          SX3 B0+7
          BX4    X1*X3
          SB3 B0+4
          SB4    X4+B0
          EQ     B3,B4,OO.SROT
          LX1 3 
          BX4    X1*X3
          SB5    X4-3 
          NO
          PL     B5,OO.SROT 
          SB1    B1+1 
          SB2    B2-2 
          LX2 30
          NO
          NZ     B2,OO.HOT
OO.DONE   BX6    X2 
          NO
          SA6    OO.SRT 
* 
*           SHORTEN SLOW LOOP 
* 
OO.GLOP   SA1    B2+OO.SLOW 
          SB2 B2+1
          ZR     X1,OO.GLOA 
          JP     OO.GLOP           VOID THE STACK 
OO.GLOA   BSS    0
          SB2    B2-3 
          SA3    B2+OO.SLOW+1 
          MX7    0
          BX6    X3 
          SA7    B2+OO.SLOW 
          SA6    B2+OO.SLOW-1 
          SB1    B1-1 
          ZR     B1,OO.GLOB 
          JP     OO.GLOP           VOID THE STACK 
OO.GLOB   BSS    0
          SX6 B0+50 
          SA6    OO.FLC 
          ZR     B0,OO.SET
* 
*           RESTORE BOTH LOOPS
*           ENTER WITH B4=0,X1= FAST LOOP WORD
* 
OO.DIDN   SA2    B4+OO.FAST 
          SB4    B4+1 
          ZR     X2,OO.DIDA 
          JP     OO.DIDN           VOID THE STACK 
OO.DIDA   BSS    0
          SA2    B4+OO.FAST-2 
          SA3    OO.PAS4
          BX6    X1 
          MX7    0
          SA6    B4+OO.FAST-2 
          SA7    B4+OO.FAST 
          SB1    B0+1 
          BX6    X2 
          SB3    B0+B0
          SA6    B4+OO.FAST-1 
          SB2    B0+4 
OO.SSL    SA4    B3+OO.SLOW 
          SB3    B3+1 
          ZR     X4,OO.SSLA 
          JP     OO.SSL            VOID THE STACK 
OO.SSLA   SA4    B3+OO.SLOW-2 
          SA5    OO.PAS3
          BX7    X3 
          LX6    B0,X4
          SB3    B3-2 
          SA6    OO.SHNL
          MX4    15 
          ZR     B0,OO.GAP
* 
*           CLEANUP AND EXIT, ERROR 
*           ENTER WITH X2= SLOW JUMP,B3= SLOW STORE INDEX 
* 
OO.SHOT   BX7    X2 
          MX6    0
          SA7    B3+OO.SLOW 
OO.NOMR   SA6    OO.SRT 
          SB1    B0+10B 
          SX2    B0+7B
          SA6    OO.SHNL
          SA1    OO.PCTR
          SA3    OO.MSGC
          SA4    OO.MESG-1
          BX6    X3 
          LX1    39 
OO.CONV   BX3    X1*X2
          LX1    3
          SB1    B1-1 
          IX6    X3+X6
          LX6    6
          ZR     B1,OO.CONA 
          JP     OO.CONV           VOID THE STACK 
OO.CONA   SA6    OO.MESG+1
          JP    377776B            ERROR EXIT 
+         VFD    60/15230700000000000000B+OO.MESG 
OO.MESG   DATA   06232446052222552023B
          DATA   0
          DATA   0
OO.FLC    DATA   2                 NUMBER OF FAST LOOP PASSES 
OO.SHNL   DATA   0                 SLOW BRANCH REMOVED AFTER NO FAILURE 
OO.SRT    DATA   0                 WORD REMOVED FROM FAST LOOP IN SHORT 
* 
OO.AA     SB1    20B
          NO
          NO
OO.SET    SA1    OO.RAN+1 
          SA2    OO.RAN+2 
          SA4    OO.RAN+4 
          SA5    OO.RAN+5 
          IX0    X1+X2
          SB2    X2+B0
          SA6    OO.WRIT
          SA7    OO.WRIT+1
          SA0    X0+B0
          SB6    X4+B0
          SB7    X5+B0
          BX6    X4 
          SA3    OO.RAN+3 
          SA4    OO.RAN+6 
          BX7    X5 
          SB3    X3+B0
          SA5    OO.RAN+7 
          ZR     B1,OO.ZAP
          SB4    X4+B0
          SB5    X5+B0
          NO
          SB1    X1+B0
OO.FAST   BSS    0
          DUP    16,1 
          DATA   -0 
OO.DIF    DATA   0                 RESULT SLOW MINUS RESULT FAST
OO.ERSL   DATA   0                 RESULT SLOW
OO.ERSF   DATA   0                 RESULT FAST
OO.ERSA   DATA   0                 RESULT SLOW ADDRESS
OO.ERFA   DATA   0                 RESULT FAST ADDRESS
OO.ERCO   DATA   0                 ERROR COUNT
OO.PCTR   DATA   0                 PASS COUNTER 
OO.SANS   BSSZ   40B
OO.SAVE   BSSZ   40B               SLOW AND FAST RESULTS OF LAST ERROR
OO.RAN    DATA   0
          DATA   05150000136110000000B
          DATA   0
          DATA   00170075001470600000B
          DATA   63060002141714450003B
          DATA   0
          DATA   36103201423643420216B
          DATA   0
OO.WRIT   BSSZ   10B
OO.SLJP   VFD    12/0400B,18/OO.CHK,30/0
OO.FSJP   VFD    12/0400B,18/OO.FECK,30/0 
OO.PAS3   DATA   460004600046000B 
OO.PAS4   DATA   46000460004600046000B
OO.ZAP    SB4    X4+B0
          SB5    X5+B0
          NO
          SB1    X1+B0
OO.SLOW   BSSZ   66 
OO.FLC1   DATA   2                 NUMBER OF FAST LOOP PASSES 
* 
* 
OO.ZERB   SA1    OO.FLC1
          NO
          SB1    0
          BX7    X1 
          SA7    OO.FLC 
          JP     OO.SET 
          SPACE  2
*     STORE ERROR RESULTS 
  
OO.CERR   SA6    OO.DIF 
          SB2    B0 
          SB5    OO.SAVE-OO.SANS
          SX3    1
          SA4    OO.ERCO
          SX6    A1+B5       FAILING REG LOC (SLOW) 
          SX7    A2+B5       FAILING REG LOC (FAST) 
          SA6    OO.ERSA           SLOP LOOP ERROR POINTER
          SA7    OO.ERFA           FAST LOOP ERROR POINTER
          IX6    X3+X4
          SA6    OO.ERCO           UPDATE ERROR COUNT 
          SX2    40B
OO.SVAN   SA1    X2+OO.SANS-1      SAVE ERROR RESULTS 
          IX2    X2-X3             JUST INCASE THE NEXT PASS
          BX6    X1                    DOES NOT FAIL
          SA6    X2+OO.SAVE 
          NZ     X2,OO.SVAN 
          JP     OO.AEE            GO SHORTEN THE FAST LOOP 
          SPACE  3
* 
*         MOD TO INHIBIT CMU INSTRUCTIONS 464XX-467XX 
* 
OO.FORT   BX3    X1*X4
          LX3    6
          SB6    X3-46B 
          ZR     B6,OO.PASS 
          ZR     B0,OO.NOTK 
OO.MSGC   DATA   33333333333333005533B
OO.MSG1   DIS    ,*FST FAILURE IN THE IDLER LOOP* 
OO.DATA   BSSZ   1
          EJECT 
ALX       BSS    0
OO.ALX    DATA   0                 START OF ALX DIAGNOSTIC
* 
* 
          BX7    X1 
          SA7    OO.DAT1           SAVE POINTER TO DATA ARRAY 
OO.CONT   SA1    OO.PCNT           .SET X1 FOR RANDOM NO. GENERATOR 
          RJ     OO.GEN3           .RJ TO RANDOM NUMBER GENERATOR 
          RJ     OO.SCAN           .RJ TO INSTRUCTION SEQUENCE SCANNER
OO.CON1   SB1    B0+0 
          RJ     OO.SETP           .RJ TO SET UP REGISTERS FOR FAST LOOP
          RJ     OO.EXEC           .RJ TO EXECUTE IN STACK (FAST LOOP)
          SB1    B0+0 
          RJ     OO.STAN           .RJ TO STORE RESULTS 
          SB1    B0+1 
          RJ     OO.SETP           .RJ TO SET UP REGISTERS FOR SLOW LOOP
          RJ     OO.EXEC           .RJ TO OUT OF STACK (SLOW LOOP)
          SB1    B0+20B 
          RJ     OO.STAN           .RJ TO STORE RESULTS 
          ZR     OO.CMP            .GO TO COMPARE ANSWERS 
OO.BSN1   DATA   12345123451234512345B       BASE RANDOM NUMBER 
OO.BSN    DATA   0
* 
* 
*          RANDOM NUMBER GENERATOR
* 
OO.GEN3   DATA   0
          SB1    B0+10B 
          SB2    OO.REG+7 
          SA2    OO.BSN1
          BX6    X2 
          SA6    OO.BSN 
          LX1    55B
          FX7    X1+X2
          LX2    34B
          IX7    X2+X7
          SA7    OO.BSN1
OO.GEN4   LX1    1                 .GENERATE RANDOM X REGISTER OPERANDS 
          LX7    17B
          IX6    X1+X7
          SA6    B1+B2       .STORE X REGISTER OPERANDS 
          SB1    B1-1 
          NE     B0,B1,OO.GEN4
          SB1    B0+5B
          SB2    OO.REG+2 
          MX5    44B         .MASK IN X5
          LX5    44B         .X5 = 0---0 7777 7777 7777 
OO.GEN1   LX7    20B               .GENERATE RANDOM A AND B OPERANDS
          IX6    X1+X7
          BX6    X5*X6
          SA6    B1+B2       .STORE A AND B REGISTER OPERANDS 
          SB1    B1-1 
          NE     B0,B1,OO.GEN1
          LX1    3B          .GENERATE A2 AND B2 OPERANDS 
          LX7    21B
          IX6    X1+X7
          MX5    22B         .MASK IN X5
          LX5    22B         .X5 = 0---0 0077 7777
          BX6    X5*X6
          LX6    22B
          SX4    OO.INST-1
          IX6    X4+X6
          SA6    OO.REG+2          .STORE A2 AND B2 OPERANDS
          BX6    X5*X7       .GENERATE A0 
          LX6    22B
          SA6    OO.REG            .STORE A0 OPERANDS 
          SX1    OO.REG+11B        .GENERATE A1 AND B1 OPERANDS 
          LX1    22B
          SX2    B0+2B
          IX6    X1+X2
          SA6    OO.REG+1          .STORE A1 AND B1 OPERANDS
          SB1    B0+5B
          SB2    OO.INST-1
          SA1    OO.BSN1
          IX7    X1+X7
OO.GEN2   LX1    3
          LX7    30B
          IX6    X1+X7
          SA6    B1+B2       .STORE RANDOM INSTRUCTIONS 
          SB1    B1-1 
          NE     B0,B1,OO.GEN2
          MX7    0
          SA7    OO.INST-1
          ZR     B0,OO.GEN3        .EXIT
* 
* 
*          INSTRUCTION SEQUENCE SCANNER 
* 
OO.SCAN   DATA   0
          SB1    1
          SB2    5
          SB3    OO.INST-1
          SB4    B0+B0
          SB5    B0+B0
          MX0    3B          .SET UP MASK IN X0,X2,X3,AND X4
          LX0    66B         .X0 = 007000---0 
          MX2    6B          .X2 = 770000---0 
          MX3    17B         .X3 = 777770---0 
          BX5    X2          .X4 = 770770---0 
          LX5    63B
          IX4    X2+X5
OO.SC16   SA1    B2+B3
OO.SC20   SX6    10B
          BX5    X1*X2
          LX5    6B 
          IX7    X5-X6
          NG     X7,OO.SC1
          SX6    50B
          BX5    X1*X2
          LX5    6B 
          IX7    X5-X6
          NG     X7,OO.SC2
          SX6    60B
          LX6    66B
          IX7    X1-X6
          PL     X7,OO.SC3
          ZR     B0,OO.SC4
 OO.SC3   MX7    9
          BX6    X7*X1
          LX6    9
          SX7    X6-660B
          ZR     X7,OO.SC11  IF 660XX INSTRUCTION PAD WITH PASS 
          SX7    X6-670B
          ZR     X7,OO.SC11  IF 670XX INSTRUCTION PAD WITH PASS 
          SX6    70B
          LX6    66B
          IX7    X1-X6
          PL     X7,OO.SC7
          ZR     B0,OO.SC6
OO.SC1    SX6    3000B
          LX6    55B
          IX7    X1-X6
          PL     X7,OO.SC10 
          ZR     B0,OO.SC11 
OO.SC10   SB7    B4-3 
          EQ     B0,B7,OO.SC11
          SB7    B2+B3
          SX6    B7+B1
          LX6    36B
          MX7    22B
          LX7    60B
          BX7    -X7*X1 
          IX1    X6+X7
          ZR     B0,OO.SC12 
OO.SC2    SX6    X7+2 
          ZR     X6,OO.SC11        46XXX INSTRUCTION
          SX6    27000B 
          LX6    55B
          IX7    X1-X6
          PL     X7,OO.SC13 
          SX6    24000B 
          IX7    X6-X1
          PL     X7,OO.SC13 
          SX6    30B
          LX6    55B
          BX1    X1+X6
          ZR     B0,OO.SC13 
OO.SC4    SX6    53000B 
          LX6    55B
          IX7    X1-X6
          NG     X7,OO.SC14 
          SX6    56020B 
          LX6    55B
          BX5    -X4
          BX7    X5*X1
          BX1    X6+X7
          ZR     B0,OO.SC13 
OO.SC14   SB7    B4-3 
          EQ     B0,B7,OO.SC11
          BX5    X3 
          LX5    55B
          IX5    X4+X5
          BX5    -X5
          SX6    51000B 
          SX7    OO.INST-1
          LX6    17B
          IX7    X6+X7
          LX7    36B
          BX6    X1*X5
          IX1    X6+X7
          SX6    100B 
          LX6    55B
          BX1    X1+X6
          ZR     B0,OO.SC12 
OO.SC6    SX6    63000B 
          LX6    55B
          IX7    X1-X6
          NG     X7,OO.SC15 
          SX6    300B 
          LX6    55B
          BX1    X1+X6
          ZR     B0,OO.SC13 
OO.SC15   SB7    B4-3 
          EQ     B0,B7,OO.SC11
          SX6    300B 
          LX6    55B
          BX1    X1+X6
          ZR     B0,OO.SC12 
OO.SC7    SX6    73000B 
          LX6    55B
          IX7    X1-X6
          PL     X7,OO.SC13 
          SB7    B4-3 
          EQ     B0,B7,OO.SC11
          ZR     B0,OO.SC12 
OO.SC11   SX6    46000B 
          LX6    55B
          BX7    -X3*X1 
          IX1    X6+X7
          ZR     B0,OO.SC13 
OO.SC12   SB4    B4+B1
          LX1    17B
OO.SC13   SB4    B4+B1
          LX1    17B
          SB7    B4-4 
          EQ     B0,B7,OO.SC17
          ZR     B0,OO.SC20 
OO.SC17   SB4    B0+B0
          BX6    X1 
          SA6    B2+B3
          SB2    B2-B1
          EQ     B0,B2,OO.SCAN
          ZR     B0,OO.SC16 
* 
* 
*          SETUP REGISTERS
* 
OO.SETP   DATA   0                  .SETUP B REGISTERS
          SA1    B1+OO.JUMP        .IF B1 = 0 STORE IN STACK JUMP 
          BX6    X1          .IF B1 = 1 STORE LOOP OUT OF STACK JUMP
          SA6    OO.INST+6
          SX7    B0+B0       .SET UP A AND B REGISTERS
          SA7    OO.INST-1
          SA1    OO.REG+7 
          SB7    X1+B0
          SA1    OO.REG+6 
          SB6    X1+B0
          SA1    OO.REG+5 
          SB5    X1+B0
          SA1    OO.REG+4 
          SB4    X1+B0
          SA1    OO.REG+3 
          SB3    X1+B0
          SA1    OO.REG+2 
          SB2    X1+B0
          SB1    2
          SA1    OO.REG+17B        .SET UP X REGISTERS
          BX7    X1 
          SA7    OO.REG+17B 
          SA1    OO.REG+16B 
          BX6    X1 
          SA6    OO.REG+16B 
          SA5    OO.REG+15B 
          SA4    OO.REG+14B 
          SA3    OO.REG+13B 
          SA2    OO.REG+12B 
          SA1    OO.REG+10B 
          BX0    X1 
          SA0    A1+B0
          SA1    OO.REG+11B 
          ZR     B0,OO.SETP 
OO.JUMP   ZR     OO.INST           .LOOP IN STACK JUMP
          JP     OO.INST           .LOOP OUT OF STACK JUMP
* 
* 
*          STORE RESULTS
* 
OO.STAN   DATA   0                 .STORE X REGISTER RESULTS
          SB2    A7+B0
          SA7    B1+OO.FANS+17B 
          BX7    X6 
          SA7    B1+OO.FANS+16B 
          BX7    X5 
          SA7    B1+OO.FANS+15B 
          BX7    X4 
          SA7    B1+OO.FANS+14B 
          BX7    X3 
          SA7    B1+OO.FANS+13B 
          BX7    X2 
          SA7    B1+OO.FANS+12B 
          BX7    X1 
          SA7    B1+OO.FANS+11B 
          BX7    X0 
          SA7    B1+OO.FANS+10B 
          MX5    22B         .STORE A AND B REGISTER RESULTS
          LX5    22B
          SX6    B7+B0
          BX6    X6*X5
          SX7    B2+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+7 
          SX6    B6+B0
          BX6    X6*X5
          SX7    A6+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+6 
          SX6    B5+B0
          BX6    X6*X5
          SX7    A5+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+5 
          SX6    B4+B0
          BX6    X6*X5
          SX7    A4+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+4 
          SX6    B3+B0
          BX6    X6*X5
          SX7    A3+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+3 
          SX6    OO.INST-1
          SX7    A2+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+2 
          SX6    B0+B0
          SX7    A1+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS+1 
          SX6    B0+B0
          SX7    A0+B0
          BX7    X7*X5
          LX7    22B
          IX7    X6+X7
          SA7    B1+OO.FANS 
          JP     OO.STAN
* 
* 
*          CHECK ANSWERS
* 
OO.CMP    SB1    20B               .INITIALIZE REGISTERS
          SB2    OO.FANS-1
          SB3    B1+B2
          SB4    OO.DANS-1
OO.CMP1   SA1    B1+B2             .COMPARE ANSWERS 
          SA2    B1+B3
          IX7    X1-X2
          SA7    B1+B4       .STORE ANSWER DIFFERENCE 
          SB1    B1-1 
          NE     B0,B1,OO.CMP1
          SB1    20B
          MX3    0
OO.CMP4   SA1    B1+B4             .CHECK ANSWER DIFFERENCE FOR NON ZERO
          IX3    X1+X3
          SB1    B1-1 
OO.CMP3   NE     B0,B1,OO.CMP4
          ZR     X3,OO.LCK         JUMP IF NO ERROR 
          JP     377777B           ERROR EXIT 
OO.MSG2   DIS    ,*ALX FAILURE IN THE IDLER LOOP* 
* 
* 
*          LOOP REPEAT CHECKER
* 
OO.LCK    SA1    OO.LCNT           .LOAD LOOP COUNT 
          SX7    X1-1        .DECREMENT LOOP COUNT
          SA7    OO.LCNT           .STOR LOOP COUNT 
          NZ     X7,OO.CON1        .NOT ZERO  EXECUTE INSTRUCTIONS AGAIN
          SX7    2                 IF ZERO,RESET LOOP COUNT 
          SA7    OO.LCNT           .RESET LOOP COUNT
          SA1    OO.PCNT
          SX2    1                                        & 
          IX7    X1+X2
          SA7    OO.PCNT           .STORE PASS COUNT
          SA2    OO.DAT1
          SB1    B0 
          SB2    16 
          SB3    1
OO.SD     SA1    OO.FANS+B1 
          BX7    X1 
          SA7    X2+B1             SAVE ALX ANSWERS IN DATA ARRAY 
          SB1    B1+B3
          NE    B1,B2,OO.SD 
          SX2    X2+B2
          SB1    B0 
          SB2    5
OO.SD1    SA1    B1+OO.INST 
          BX7    X1 
          SA7    X2+B1             SAVE ALX INST IN DATA ARRAY
          SB1    B1+B3
          NE     B1,B2,OO.SD1 
          SX2    X2+B2
          SB1    B0 
          SB2    6
OO.SD2    SA1    OO.REG+B1
          BX7    X1 
          SA7    X2+B1             SAVE SOME OF ALX RANDOM NUMBERS
          SB1    B1+B3
          NE     B1,B2,OO.SD2 
          SX2    X2+B2
          SA1    OO.PCNT
          BX7    X1 
          SA7    X2                SAVE ALX PASS COUNT IN DATA ARRAY
          JP     OO.ALX            EXIT TO DISTRIBUTOR AFTER ONE PASS 
OO.DAT1   BSSZ   1
OO.LCNT   DATA   2                 .LOOP COUNTER
* 
* 
* 
*          EXECUTE
* 
OO.EXEC   DATA   0
          ZR     OO.INST
          DATA   0
OO.INST   DATA   0                 .BEGINNING OF INSTRUCTION SEQUENCE 
          BSSZ   4B 
          SB1    B1-1 
          ZR     B1,OO.EXIT        .EXIT IF SEQUENCE EXECUTED TWO TIMES 
          DATA   0            .LOOP ON INSTRUCTION SEQUENCE 
          DATA   0
OO.EXIT   JP     OO.EXEC           .EXIT TO CONTROL PROGRAM 
* 
* 
OO.PCNT   DATA   0                 .PASS COUNTER
OO.REG    BSSZ   20B               .INITIAL REGISTER CONTENTS 
OO.DANS   BSSZ   20B               .DIFFERENCE ANSWERS
OO.FANS   BSSZ   20B               .FAST LOOP ANSWERS 
OO.SAN    BSSZ   20B               .SLOW LOOP ANSWERS 
          EJECT 
* PVC     THIS BLOCK OF CODE PROVIDES DOUBLE ERROR LOCATION AND MULTIPLE
*         ERROR DETECTION OF FIXED PORTIONS OF CMR AND ECS RESIDENT.
* 
*         THE CODE RUNS IN TWO MODES. IN THE FIRST MODE, LONGITUDINAL 
*         AND DOUBLE DIAGONAL PARITY VECTORS ARE COMPUTED FOR INDIVIDUAL
*         BLOCKS OF 60 WORDS OR LESS. IN THE SECOND MODE, THE SAME
*         CALCULATIONS ARE CARRIED OUT AND THEN COMPARED WITH THE 
*         RESULTS OBTAINED PREVIOUSLY IN THE GENERATE MODE. 
* 
*         THE THREE KINDS OF PARITY ARE DESIGNATED *X*,*Y* AND *Z*. 
*         EXAMPLES OF EACH OF THSES ARE SHOWN FOR FOUR BITS IN A
*         15-WORD, 15-BIT MODEL. THIS CODE DEALS WITH UP TO 60 WORDS OF 
*         60 BITS, OF COURSE. 
*         XXX     X          Y     Y      YY      ZZ   Z        Z 
*         XXX     X          YY     Y      Y      Z   Z        ZZ 
*         XXX     X          YYY     Y               Z        ZZZ 
*         XXX     X           YYY     Y             Z        ZZZ
*         XXX     X            YYY     Y           Z        ZZZ 
*         XXX     X             YYY     Y         Z        ZZZ
*         XXX     X              YYY     Y                ZZZ   Z 
*         XXX     X               YYY     Y              ZZZ   Z
*         XXX     X                YYY     Y            ZZZ   Z 
*         XXX     X          Y      YYY                ZZZ   Z
*         XXX     X           Y      YYY              ZZZ   Z 
*         XXX     X            Y      YYY            ZZZ   Z
*         XXX     X             Y      YYY          ZZZ   Z 
*         XXX     X              Y      YYY        ZZZ   Z
*         XXX     X               Y      YYY      ZZZ   Z 
* 
*         IN THE EVENT THAT THE CHECK MODE DISCOVERS AN ERROR,
*         DIAGNOSTIC CODE GENERATES INFORMATION FROM WHICH OPERATOR 
*         MESSAGES, REPORTS AND ACTUAL ERROR CORRECTION CAN BE GENERATED
*         OR CARRIED OUT. 
* 
*         CODING CONVENTIONS USED.
*                (B3) = GENERATE FLAG.  1 = ON, 0 = OFF 
*                (B7) = 1 
* 
*         MEMORY OF THE CONDITION OF THE GENERATE FLAG IS KEPT AT 
*         OO.PGFLG. 
  
*         REGISTERS ARE DEDICATED FOR THE FOLLOWING PURPOSES
*                (A0)   PARITY VECTOR FWA AND RETRY SWITCH
*                (B1) = NUMBER OF 4-WORD BLOCKS LEFT TO BE PROCESSED
*                (B2) = NUMBER OF EXTRA WORDS 
*                (B3) = GENERATE FLAG 
*                (B4) = 15 OR REMAINDER OF NUMBER OF 4-WORD BLOCKS
*                (B5) = 59 FOR SHIFT COUNT
*                (B6) = OUTER LOOP COUNTER
*                (B7) = 1 
*                (X1) = ) ALTERNATE DATA
*                (X2) = ) WORD REGISTERS
*                (X3) = X PARITY VECTOR 
*                (X4) = Y PARITY VECTOR 
*                (X5) = Z PARITY VECOR AND GENERAL PURPOSE
  
PVC       EQU    *
OO.PVC    BSSZ   1                 SUBROUTINE EXIT LINKAGE
          SB7    1       B7 = 1 
          SA2    A1+B7
          SA3    A2+B7
          SA4    A3+B7
          SA5    A4+B7
          SA0    X2                CHECKSUM AREA
          BX2    X1                 FWA OF DATA 
          SA1    X1                DATA 
          SA3    X3                LENGTH 
          SA4    X4                FLAG 
          SB3    X4                B3 = FLAG
          BX6    X5 
          SA6    OO.PVMSG          SAVE ADDRESS OF RETURN DATA
          SX7    X3                LENGTH 
          SA5    A0-B7             INITIALIZE (A5)
OO.PVC1   MX0    58                2-BIT MASK 
          BX6    -X0*X7            LOW ORDER TWO BITS OF LENGTH 
          SB4    15                SET (B4) = 15
          AX7    2                 DIVIDE LENGTH BY 4 
          SB2    X6                SET (B2) = NUMBER OF EXTRA WORDS 
          BX6    X5 
          SB5    59                SET (B5) = 59
          SB1    X7                SET (B1) = NUMBER OF 4-WORD BLOCKS 
          SA6    A5                INITIALIZE CONTENTS OF A6
          SX7    X2                X7 = BASE ADDRESS OF DATA
*         THIS IS THE BEGINNING OF THE OUTER LOOP WHICH PROCESSES 
*         4-WORD BLOCKS IN BATCHES OF 15 OR LESS. 
OO.PCOUT  NE     B0,B3,OO.PCLER    GO TO GENERATE SET-UP
          SA3    A5+B7
          SA4    A3+B7
          SA5    A4+B7
          ZR     OO.PVC2           AVOID CLEARING REGISTERS JUST SET UP.
OO.PCLER  IX3    X2-X2             CLEAR X VECTOR REGISTER
          SX4    B0                CLEAR Y VECTOR REGISTER
          BX5    X6-X6             CLEAR Z VECTOR REGISTER
OO.PVC2   LT     B1,B4,OO.PCL15 
          SB6    B4                SET INNER BLOCK COUNT TO 15
*         THIS IS THE BEGINNING OF THE INNER LOOP WHICH PROCESSES 
*         4-WORD BLOCKS 
OO.PVCIN  BX0    X4-X1                 )  ACCUMULATE
          SA2    A1+B7             FETCH NEXT DATA WORD 
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X1               )  ACCUMULATE
          LX5    B5,X0               )  Z - VECTOR
          BX3    X3-X1             ACCUMULATE X - VECTOR
          SA1    A2+B7             FETCH NEXT DATA WORD 
          BX0    X4-X2                 )  ACCUMULATE
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X2               )  ACCUMULATE
          LX5    B5,X0               ) Z - VECTOR 
          BX3    X3-X2             ACCUMULATE X - VECTOR
          SB6    B6-B7             COUNT DOWN INNER LOOP
          BX0    X4-X1                 )  ACCUMULATE
          SA2    A1+B7             FETCH NEXT DATA WORD 
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X1               )  ACCUMULATE
          LX5    B5,X0               )  Z - VECTOR
          BX3    X3-X1             ACCUMULATE X - VECTOR
          SA1    A2+B7             FETCH NEXT DATA WORD 
          BX0    X4-X2                 )  ACCUMULATE
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X2               )  ACCUMULATE
          LX5    B5,X0               ) Z - VECTOR 
          BX3    X3-X2             ACCUMULATE X - VECTOR
          LT     B0,B6,OO.PVCIN    CYCLE ON INNER LOOP
          BX6    X3+X4             INCLUSIVE X.OR.Y 
          CX0    X3                COUNT BITS IN X-VECTOR 
          NE     B0,B3,OO.PCGEN    GO STORE PARITY VECTORS
          SB1    B1-B4             DECREMENT OUTER BLOCK COUNT BY 15
          SX7    X7+60             INCREMENT BASE ADDRESS 
          BX6    X6+X5             INCLUSIVE X.OR.Y.OR.Z
          ZR     X6,OO.PCOUT       THIS DATA CHECKS OUT OK.  CYCLE OUTER
          SX7    X7-60             READJUST BASE ADDRESS
          CX1    X4                COUNT BITS IN Y-VECTOR 
          CX2    X5                COUNT BITS IN Z-VECTOR 
* 
* 
*         WE MUST SAVE THE FOLLOWING REGISTERS AND RESTORE THEM AFTER 
*         PROCESSING AND REPORTING AN ERROR TO ALLOW A CONTINUATION OF
*         THE CHECKSUMMING. 
* 
*                B1 = NUMBER OF 4-WORD BLOCKS LEFT TO DO
*                B2 = ODD NUMBER OF WORDS TO DO 
*                B3 = 0 ( GENERATE FLAG CLEAR)
*         B5 = 59 (SHIFT COUNT) 
*                B7 = 1 
*                A1 = ADDRESS OF NEXT DATA WORD TO TEST 
*                A5 = ADDRESS OF NEXT VECTOR BLOCK
*                X7 = BASE ADDRESS OF TEST BLOCK
* 
* 
          SA7    OO.BADDR          SAVE BASE ADDRESS (X7) 
          SX6    B2                ACCUMULATE B2 (B2 = O TO 3)
          SX7    B1 
          LX6    18 
          BX6    X6+X7             ACCUMULATE B1
          SX7    A1 
          LX6    18 
          BX6    X6+X7             ACCUMULATE A1
          SX7    A5 
          LX6    18 
          BX6    X6+X7             ACCUMULATE A5
          SA6    OO.SAV            SAVE B2,B1,A1,A5 
          RJ     OO.PEB            GO PROCESS THE ERROR 
          SB1    OO.PVMSG          B1 = POINTER TO ERROR MESSAGE
          RJ     OO.ERR            GO TO ERROR MESSAGE PROCESSOR
          SA1    OO.BADDR          RESTORE REGISTERS
          SA2    OO.SAV 
          BX7    X1                X7 = BASE ADDRESS
          SA5    X2                SET A5 
          AX2    18 
          SA1    X2                RESTORE X1,A1
          AX2    18 
          SB1    X2                RESTORE B1 
          AX2    18 
          SB2    X2                RESTORE B2 
          SB5    59                RESTORE B5  B7 SHOULD NOT CHANGE 
          SB3    B0                CLEAR GENERATE FLAG
          SX7    X7+60             ADJUST BASE ADDRESS TO NEXT BLOCK
          ZR     OO.PCOUT          CHECK NEXT BLOCK 
OO.SAV    BSSZ   1
*         THE FOLLOWING CODE SETS UP /B1/ AND /B6/ TO COPE WITH THE END 
*         CASE OF LESS THAN 15 FOUR-WORD BLOCKS.
*         NOTICE THAT IN THIS PARTICULAR CASE ANY REMAINING WORDS MUST
*         ALSO BE INCLUDED WITH THOSE IN THIS LAST COLLECTION OF 4-WORD 
*         BLOCKS, EVEN IF THIS LAST COLLECTION DOES NOT EXIST.
*         THIS LAST CASE OCCURS WHEN THE ORIGINAL VOLUME OF DATA
*         CONSISTS OF 1,2 OR 3 PLUS SOME MULTIPLE OF 60 WORDS,
*         FOR EXAMPLE,  1,2,3,61,62,63,121,122,123,ETC. 
OO.PCL15  SB6    B1                SET BLOCK COUNT (LESS THAN 15) 
          NZ     B1,OO.PCINL       JUMP IF MORE 4-WORD BLOCKS 
          NZ     B2,OO.PVCL4       JUMP IF ODD WORDS LEFT TO DO 
          ZR     OO.PVC            RETURN - ALL WORDS DONE
*         THIS LOOP PROCESSES UP TO 14 FOUR-WORD BLOCKS 
OO.PCINL  BX0    X4-X1                 )  ACCUMULATE
          SA2    A1+B7             FETCH NEXT DATA WORD 
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X1               )  ACCUMULATE
          LX5    B5,X0               )  Z - VECTOR
          BX3    X3-X1             ACCUMULATE X - VECTOR
          SA1    A2+B7             FETCH NEXT DATA WORD 
          BX0    X4-X2                 )  ACCUMULATE
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X2               )  ACCUMULATE
          LX5    B5,X0               ) Z - VECTOR 
          BX3    X3-X2             ACCUMULATE X - VECTOR
          SB6    B6-B7             COUNT DOWN INNER LOOP
          BX0    X4-X1                 )  ACCUMULATE
          SA2    A1+B7             FETCH NEXT DATA WORD 
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X1               )  ACCUMULATE
          LX5    B5,X0               )  Z - VECTOR
          BX3    X3-X1             ACCUMULATE X - VECTOR
          SA1    A2+B7             FETCH NEXT DATA WORD 
          BX0    X4-X2                 )  ACCUMULATE
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X2               )  ACCUMULATE
          LX5    B5,X0               ) Z - VECTOR 
          BX3    X3-X2             ACCUMULATE X - VECTOR
          LT     B0,B6,OO.PCINL    CYCLE
OO.PVCL4  ZR     B2,OO.PVC4        CONTINUE IF NO MORE DATA TO PROCESS
          SB6    B2                SET COUNT OF REMAINING WORDS 
OO.PCL4L  BX0    X4-X1                 )  ACCUMULATE
          SB6    B6-B7             REMAINING WORDS
          LX4    B7,X0                 )  Y - VECTOR
          BX0    X5-X1               )  ACCUMULATE
          LX5    B5,X0               )  Z - VECTOR
          BX3    X3-X1             ACCUMULATE X - VECTOR
          SA1    A1+B7             FETCH NEXT DATA WORD 
          LT     B0,B6,OO.PCL4L    PROCESS REMAINING WORDS
OO.PVC4   SX0    B1+B1             NUMBER OF 4-WORD BLOCKS * 2
          SB6    60                SET B6 = 60
          LX6    B7,X0             NUMBER OF 4-WORD BLOCKS * 4
          SB1    X6+B2             TOTAL NUMBER OF DATA WORDS MODULO 60 
          SB6    B6-B1             RIGHT SHIFT END-AROUND 
          SB1    B0                SET GENERATE COMPLETE FLAG 
          NE     B3,OO.PCGEN       IF GENERATE FLAG SET 
          BX6    X3+X4             INCLUSIVE X.OR.Y 
          CX0    X3                COUNT BITS IN X-VECTOR 
          BX6    X6+X5             INCLUSIVE X.OR.Y.OR.Z
          CX1    X4                COUNT BITS IN Y-VECTOR 
          ZR     X6,OO.PVC         RETURN 
          CX2    X5                COUNT BITS IN Z- VECTOR
          LX4    B6,X4             POSITION Y - VECTOR
          SB6    B0-B6
          SB6    B6+60             B6 = 60 OR N 
          LX5    B6,X5             POSITION Z VECTOR
          SA7    OO.BADDR          SAVE BASE ADDRESS OF THE FAILURE 
          RJ     OO.PEB            GO PROCESS THE ERROR 
          SB1    OO.PVMSG          B1 = POINTER TO ERROR MESSAGE
          RJ     OO.ERR 
          ZR     OO.PVC            EXIT AFTER REPORTING ERROR 
*         THE FOLLOWING CODE STORES THE PARITY VECTORS IN X3,X4 AND X5
*         AT THE SEQUENTIAL ADDRESSES GIVEN INITIALLY BY (A0).
*         (B1) IS USED TO DETERMINE COMPLETION. 
OO.PCGEN  BX6    X3                PUT X - VECTOR IN X6 
          LX7    B6,X4             PUT Y-VECTOR IN X7, SHIFTED RIGHT N
          SB6    B0-B6             (B6) = 0, OR  N-60 
          SA6    A6+B7             STORE X - VECTOR 
          SB6    B6+60             (B6) =60, OR  N
          SA7    A6+B7             STORE Y - VECTOR 
          LX6    B6,X5             PUT Z-VECTOR IN X6, SHIFTED LEFT N 
          SA6    A7+B7             STORE Z - VECTOR 
          EQ     B0,B1,OO.PVC      EXIT IF ALL WORDS PROCESSED
          SB1    B1-B4             DECREMENT OUTER BLOCK COUNT BY 15
          ZR     OO.PCOUT          GO PROCESS ANOTHER BLOCK 
OO.PVMSG  BSSZ   3                 ERROR MESSAGE BUFFER 
          EJECT 
OO.PEB    BSSZ   1
          BX7    X3                GET X - VECTOR 
          SA7    OO.ERRB+1         STORE X - VECTOR 
          BX6    X4                GET Y - VECTOR 
          LX7    B0,X5             GET Z - VECTOR 
          SA6    A7+B7             STORE Y - VECTOR IN ERROR BUFFER 
          SA7    A6+B7             STORE Z - VECTOR IN ERROR BUFFER 
          SB6    X2                ) FIND 
          IX7    X0+X1             ) GRAND TOTAL
          SB1    X7+B6             ) POPULATION 
          SB6    B1-7 
          GE     B6,B0,OO.MULT     GO TO MULTIPLE ERROR SEQUENCE
          JP     B1+*+1 
+         RJ     OO.ILL            SUM = 0
+         RJ     OO.ILL            SUM = 1
+         RJ     OO.ILL            SUM = 2
+         ZR     OO.PV3            SUM = 3
+         JP     OO.MULT           SUM = 4
+         RJ     OO.ILL            SUM = 5
+         JP     OO.MULT           SUM = 6
OO.PV3    SB6    B0-B7             B6=-1
          SX0    X0+B6
          NZ     X0,OO.PXNE1       IF PCX.NE.1
          SX1    X1+B6
          SX2    X2+B6
          NZ     X1,OO.PYNE1       IFPCY.NE. 1
          NZ     X2,OO.PZNE1       IFPCZ.NE.1 
*         THE 1,1,1 ERROR STATE IS ESTABLISHED AT THIS POINT. 
*     &   NOW NUMBER BITS IN REGISTER FROM LEFT TO RIGHT 1 THRU 60. 
*         USING THIS SCHEME, FIND THE POSITION OF THE ERROR BIT IN
*         EACH VECTOR, AND PLACE THE RESULT IN THE CORRESPOINDING 
*         B-REGISTER
          SB3    61                SET B3,B4 AND B5 = 61 INITIALLY
          SB4    B3 
          SB5    B3 
 +        LX3    59                POSITION BITS 60,59,58,ETC IN HIGH 
          SB3    B3-B7             COUNT DOWN 
          PL     X3,*              REPEAT IF HIGH ORDER BIT = 0 
 +        LX4    59 
          SB4    B4-B7
          PL     X4,* 
 +        LX5    59 
          SB5    B5-B7
          PL     X5,* 
*         AT THIS POINT, THIS ERROR BITS HAVE BEEN DETERMINED TO BE 
*              P = (B3) 
*              Q = (B4) 
*              R = (B5) 
*         THE BLOCK EQUATIONS CORRESPONDITO Q AND R ARE 
*              W =-X + Q + 1                 W =-X + Q + 61 
*              W = X - R + 1                 W = X - R + 61 
*         IF WE PUT 
*              Q + R = S   AND   Q - R + 2 = D
*         ADDITION AND SUBTRACTION OF THE BLOCK EQUATIONS YIELDS
*         FOUR SOLUTIONS FOR 2(X,W) 
*              (S,D),(S+60,D+60),(S-60,D+60) AND (S,D+120)
*         IF 2*P=S, THEN THE ERROR IS IN WORD D/2.
*         IF A VALUE OF D TWO SMALLER THAN INDICATED ABOVE IS USED, 
*         THEN THE SOLUTIONS CORRESPOND TO A WORD INDEX WITH ZERO ORGIN.
  
          SB1    B4+B5             S = Q + R  IN  B1
          SB2    B4-B5             D = Q - R IN B2
          SB3    B3+B3             DOUBLE P 
          SB4    60                B4 = 60
          SB6    B4+B4             B6 = 120 
          EQ     B3,B1,OO.PV12     IF ERROR BIT IN WORD D/2 OR (D+120)/2
          SB2    B2+B4
          SB1    B1-B4             NOW TRY THE S-60 CASE
          EQ     B3,B1,OO.PV1 
          SB1    B1+B6             NOW TRY THE S+60 CASE
          EQ     B3,B1,OO.PV1      IF ERROR BIT IS IN WORD S/2
*         THIS FALL-THROUGH REPRESENTS A LOGICAL OR CPU ERROR 
          RJ     OO.ILL 
          ZR     OO.ILL 
OO.PV12   GE     B2,B0,OO.PV1      IF D IS POSITIVE 
          SB2    B2+B6             RESET D POSITIVE 
OO.PV1    SA1    OO.BADDR          GET BASE ADDRESDS
          SX6    B2                D
          AX6    B7,X6
          SX0    B6-B1             (X0) = (BIT POSITION) * 2
          AX0    B7,X0
          IX7    X1+X6             FORM ADDRESS OF WRONG WORD 
          LX7    6                 ) PLACE WORD ADDRESS 
          BX6    X0+X7             ) AND BIT POSITION 
          LX6    30                ) IN HIGH ORDER
          SA6    OO.ERRB           STORE DIAGNOSTIC IN ERROR BUFFER 
          ZR     OO.PEXIT          PREPARE ERROR MESSAGE
OO.BADDR  DATA   0                 BASE ADDRESS OF TEST BLOCK 
OO.ERRB   BSSZ   4                 ERROR BUFFER 
OO.MULT   SA1    OO.BADDR 
          MX7    30 
          LX1    36                POSITION BASE ADDRESS
          BX6    -X7+X1 
          SA6    OO.ERRB           SET BASE ADDRESS AND -0 FLAG TFOR
*                                  MULTIPLE BIT FAILURES FOR THE TIME.
          ZR     OO.PEXIT          PREPARE ERROR MESSAGE
* 
OO.PXNE1  BSS    0
OO.PYNE1  BSS    0
OO.PZNE1  BSS    0
+         RJ     OO.ILL 
OO.ILL    DATA   0
* 
          MX6    30 
          SA1    OO.BADDR          GET BASE ADDRESS 
          LX1    6
          BX6    X1+X6
          SA6    OO.ERRB           SET ILLEGAL FLAG 
OO.PEXIT  BX0    X6                CONVERT X0 TO DISPLAY CODE IN X6,X7
          SB1    10 
          LX1    B0,X6
          SX2    7                 MASK 
          SX6    B0                CLEAR ANSWERS
          SX7    B0 
          AX1    30                X1 = UPPER HALF
OO.PEX1   BX4    X0*X2             GET CHARACTER FROM LOWER 
          SB1    B1-B7             DECREMENT LOOP COUNTER 
          BX6    X6+X4             BUILD LOWER HALF 
          AX0    3                 POSITION NEXT CHARACTER
          BX4    X1*X2             GET CHARACTER FROM UPPER 
          LX6    54 
          AX1    3
          BX7    X7+X4             BUILD UPPER HALF 
          LX7    54 
          NE     B0,B1,OO.PEX1
          SA1    OO.ZERO
          IX6    X6+X1             ADD BIAS 
          IX7    X7+X1
          SA7    OO.PVMSG+1 
          SA6    A7+B7
          JP     OO.PEB            EXIT 
OO.ZERO   DATA   33333333333333333333B
OO.ERR    BSSZ   1
          SB7    1
          SA1    OO.PVMSG 
          SA2    OO.ERRB
          SA3    A2+B7
          SA4    A3+B7
          SA5    A4+B7
          BX6    X2 
          LX7    B0,X3
          SA6    X1 
          SA7    A6+B7
          BX6    X4 
          LX7    B0,X5
          SA6    A7+B7
          SA7    A6+B7
          JP     OO.PVC            EXIT 
          EJECT 
*         REINITIALIZE FST AND ALX TO PASS 0 TO ALLOW GENERATE AND
*         REGENERATE CYCLES TO RUN TOGETHER 
* 
INIT      BSSZ   1
          SA2    X1                READ PASS COUNT TO CREATE FOR FST/ALX
          BX6    X2 
          SA6    PASS              SAVE IT
          SA6    OO.PCTR           SET FST PASS COUNT 
          SX7    B0 
          SA7    OO.PCNT           CLEAR ALX PASS COUNTER 
          SB1    1
          SB2    B0 
          SB3    5
INIT1     SA7    OO.INST+B2        CLEAR ALX INSTRUCTION BLOCK
          SB2    B1+B2
          NE     B2,B3,INIT1
          SB2    B0 
          SB3    20B
INIT2     SA7    OO.REG+B2         CLEAR ALX REGISTER VALUES
          SB2    B1+B2
          NE     B2,B3,INIT2
          SA7    OO.BSN            CLEAR ALX RANDOM NUMBER
          SA1    INIT5
          BX6    X1 
          SA6    OO.BSN1           RESET BASE NUMBER FOR ALX
          BX7    -X7
          SB2    B0 
          SB3    20B
INIT3     SA7    OO.FAST+B2        SET FST INSTRUCTIONS TO ALL ONES 
          SB2    B1+B2
          NE     B2,B3,INIT3
          SB2    B0 
          SB3    10B
INIT4     SA1    INIT6+B2 
          BX7    X1 
          SA7    OO.RAN+B2         RESTORE FST RANDOM NUMBERS 
          SB2    B1+B2
          NE     B2,B3,INIT4
          SA1    PASS 
          ZR     X1,INIT           EXIT IF PASS ZERO REQUESTED
INIT7     SA2    OO.RAN+4          NO, SO SET-UP FST TO NEXT PASS 
          SA1    OO.RAN+1 
          SA3    OO.RAN+3 
          SA5    OO.RAN+6 
          IX0    X1+X2
          IX7    X3+X5
          LX0    31B
          LX7    10 
          IX5    X7+X0
          SA7    OO.RAN+6 
          IX6    X5+X7
          IX1    X0+X3
          SA6    OO.RAN 
          LX1    42B
          IX7    X1-X5
          IX6    X0-X7
          SA7    OO.RAN+4 
          SA6    OO.RAN+5 
          IX7    X7+X1
          BX6    X5 
          SA7    OO.RAN+1 
          SA6    OO.RAN+7 
          BX7    X1 
          SA7    OO.RAN+2 
          BX6    X0 
          SA6    OO.RAN+3 
          SA1    OO.PCNT           GENERATE NEXT PASS FOR ALX 
          SA2    OO.BSN1
          BX6    X2 
          SA6    OO.BSN 
          BX0    X1 
          LX1    55B
          FX7    X1+X2
          SX3    1
          LX2    34B
          IX7    X2+X7
          SA7    OO.BSN1
          SA1    PASS 
          IX6    X0+X3             INCREMENT ALX PASS COUNT 
          IX7    X1-X3             DECREMENT LOOP COUNT 
          SA6    OO.PCNT
          SA7    PASS 
          NZ     X7,INIT7          JUMP IF NOT COMPLETE 
          JP     INIT              EXIT 
INIT5     DATA   12345123451234512345B
INIT6     DATA   0
          DATA   05150000136110000000B
          DATA   0
          DATA   00170075001470600000B
          DATA   63060002141714450003B
          DATA   0
          DATA   36103201423643420216B
          DATA   0
PASS      BSSZ   1
 ACTUAL   BSSZ   1
 MASKA    DATA   00777700777700777700B
 MASKB    DATA   77B
 MASKC    DATA   55000057000057000057B
 SUBER    DATA   333300333300333300B
 MULT     DATA   3600,60,1
 CROSSOV  DATA   86400
 JPCHK    DATA   0
* THE FOLLOWING SAVE AREAS NEED TO BE CONTIGUOUS AND IN ORDER 
*         SAVEA 
*         HRSMIN
*         TIMEA 
 SAVEA    BSSZ   1
 HRSMIN   BSS    6
 TIMEA    BSS    2
 RUNTIM   BSS    3
 RT       BSS    1           ENTRY/EXIT 
          SB1    1           B1 = 1 
          SX6    A1          A1 = ADDRESS OF ARGUMENTS
          SA6    SAVEA       SAVEA = A1 
 ST       SA2    X1          X1 = ARG1
          SB3    3           COUNTER
          SA1    MULT-1      X1 = ADDRESS OF MULTIPLIERS
          SA3    MASKA       X3 = MASKA 
          BX3    X2*X3       ZERO BITS(59-54,42-36,23-18,5-0) 
          SA2    SUBER       CONVERSION MASK
          IX3    X3-X2       CONVERSION TO BINARY 
          SX2    10          X2 = 10
          SA4    MASKB       X4 = MASKB 
 RT1      MX6    0           X6 = 0 
          SA1    A1+B1       X1 = MULTIPLIER
          LX3    12          12 BIT L SHIFT 
          BX5    X4*X3       SAVE LOWER 6 BITS
          IX5    X5*X2       MULTIPLY BY 10 
          IX6    X5+X6       ADD X5 TO X6 
          LX3    6           6 BIT L SHIFT
          BX5    X4*X3
          IX6    X5+X6       ADD X5 TO X6 
          IX6    X6*X1       MULTIPLY BY SECONDS FACTOR 
          SA6    A6+B1       STORE CONTENTS IN HRSMIN 
          SB3    B3-B1       B3 = (0,1,2) 
          NE     B3,RT1      B3 NOT = 0 JP RT1
          SA1    JPCHK       FLAG WORD
          NZ     X1,SUBTRAK  X1 NOT = 0 JP SUBTRAK
          SX7    B1          X7 = 1 
          SA7    A1          A1 = JPCHK 
          SA1    SAVEA       ADDRESS OF ARGS
          SA1    X1+B1       GET NEXT ADDRESS OF ARG
          JP     ST 
 SUBTRAK  SA1    HRSMIN-1 
 SUB2     MX6    0           X6 = 0 
          SB3    3           B3 = 3 
 SUB1     SA1    A1+B1       GET TIME COMPONENTS
          IX6    X6+X1       ADD X1 TO X6 
          SB3    B3-B1       SUB 1 FROM B3
          NE     B3,SUB1     B3 NOT = 0 JP SUB1 
          SA6    A6+B1       TIMEA SAVE AREA
          SA3    JPCHK       CHECK WORD 
          ZR     X3,SUB3     X3 = 0 JP SUB3 
          SX7    B0          X7 = 0 
          SA7    A3          A3 = JPCHK 
          JP     SUB2 
 SUB3     SA4    TIMEA       TIMEA
          SA5    A4+B1       TIMEA + 1
          IX6    X5-X4       END - START
          PL     X6,OKTIME   X6 POS JP OKTIME 
          SA2    CROSSOV     CROSSOVER BIAS 
          IX6    X2+X6       TOTAL RUN TIME 
 OKTIME   SB3    2           B3 = 2 
          MX7    0
          SX3    RUNTIM-1    ADDRESS OF RUNTIM-1
          SA2    MULT-1      ADDRESS OF MULTIPLIERS - 1 
 RUNT1    SA2    A2+B1       X2 = MULTIPLIER
 RUNTC    IX6    X6-X2       SUBTRACT X2 FROM X6
          NG     X6,STORE    X6 NEG JP STORE
          SX7    X7+B1       X7 =X7+B1
          JP     RUNTC
 STORE    SA7    X3+B1       STORE HOURS THEN MIN 
          SX3    X3+B1
          IX6    X6+X2       RESTORE X2 TO X6 
          MX7    0           X7 = 0 
          SB3    B3-B1       B3 = B3-1
          NE     B3,RUNT1    B3 NOT = 0 JP RUNT1
          SA6    X3+B1       STORE SEC
          MX7    0           X7 = 0 
          MX5    0           X5 = 0 
          SX2    10          X2 = 10
          SA3    RUNTIM-1 
          SB3    3
 REST2    SA3    A3+B1       GET HOURS THEN MIN THEN SECS 
          ZR     X3,ZEROFIL  X3 = 0 JP ZEROFIL
 REST1    IX3    X3-X2       SUBTRACT 10
          NG     X3,DISCHAR  X3    NEG   JP DISCHAR 
          SX7    X7+B1       INCR X7 BY 1 
          JP     REST1
 DISCHAR  LX5    6           LEFT SHIFT BY 6
          IX3    X3+X2       ADD 1S TO X3 
          IX5    X7+X5       ADD IN HIGHER BINARY BITS
          LX5    6           LEFT SHIFT 6 
          IX5    X5+X3       ADD IN LOWER BINARY BITS 
          LX5    6           LEFT SHIFT 6 BITS
          JP     BCHK 
 ZEROFIL  LX5    18          18    BIT LEFT SHIFT 
 BCHK     SB3    B3-B1       B3 = B3 - B1 
          MX7    0           X7 = 0 
          NE     B3,REST2    B3 NOT = 0 JP REST2
          SA4    SUBER       DIS CONVERSION WORD
          IX5    X4+X5
          SA4    MASKC
          BX6    X5+X4
          SA1    SAVEA
          SA1    X1+B1
          SA6    X1 
          SA6    ACTUAL 
          EQ     RT 
          EJECT 
  
*         UNLOAD IS USED TO RETURN A TAPE/DISK
*         UNIT/SPACE FOR OTHER USE. 
* 
  
UNLOAD    BSSZ   1
          SA2    X1          READ THE FILE NAME TO BE RETURNED
          ZR     X2,UNLOAD   EXIT IF ILLEGAL FILE NAME
          NG     X2,UNLOAD
          SX3    X2-33
          PL     X3,UNLOAD
          SB1    1
          SB2    FWA         SET FWA FOR SCAN 
          SB3    B2+10000B   SET LWA FOR SCAN 
          SA3    CHKWD
          MX0    0
LOOP3     SX2    X2-10       DETERMINE FIRST OF TWO POSSIBLE DIGITS 
          NG     X2,LOOP2 
          SX0    X0+B1
          EQ     LOOP3
LOOP2     SX2    X2+10+1R0   CONVERT DIGIT TO DISPLAY CODE
          LX2    30 
          ZR     X0,LOOP1    IF ONE DIGIT FILE NUMBER 
          SX0    X0+1R0      CONVERT LEFT DIGIT TO DISPLAY CODE 
          AX2    6
          LX0    30 
LOOP1     BX4    X2+X0       FORM FILE NUMBER 
          BX2    X3+X4       FORM WORD TO SEARCH FOR
          MX3    59 
LOOP      SA1    B2          READ A WORD
          BX4    X1*X3       MASK OUT COMPLETE BIT
          BX4    X4-X2
          ZR     X4,FOUND    FILE NAME FOUND
          SB2    B2+B1
          NE     B2,B3,LOOP  CONTINUE SEARCH IF NOT LWA 
          EQ     UNLOAD      EXIT UNABLE TO FIND IT 
FOUND     SX3    B2 
          SA1    CALL 
          LX3    30 
          SA2    CALLMSK
          BX6    X1*X2       MASK OUT OLD FET 
          BX6    X6+X3       ADD NEW FET
          SA6    CALL        STORE NEW CALL 
          JP     CALL        USE JUMP TO VOID STACK AND P+2 PROBLEMS
  
CHKWD     VFD    24/4LTAPE,36/52B 
CALLMSK   DATA   77770000007777777777B
TAPE1     BSSZ   1
  
CALL      CLOSE  TAPE1,UNLOAD,RECALL
          EQ     UNLOAD 
FWA       BSS    0
          END 
C*F45V1P0*
      PROGRAM REGEN1
     1(INPUT,OUTPUT,TAPE1=0,TAPE2=0,TAPE3=0,TAPE4=0,TAPE5=0,TAPE6=0,
     1TAPE7=0,TAPE8=0,TAPE9=0,TAPE10=0,TAPE11=0,TAPE12=0, 
     1TAPE13=0,TAPE14=0,TAPE15=0,TAPE16=0,TAPE17=0,TAPE18=0,
     2TAPE19=0,TAPE20=0,TAPE21=0,TAPE22=0,TAPE23=0,TAPE24=0,TAPE25=0, 
     3TAPE26=0,TAPE27=0,TAPE28=0,TAPE29=0,TAPE30=0,TAPE31=0,TAPE32=0, 
     3TAPE98=INPUT,TAPE99)
      DIMENSION DATA(60),CHECK(1030),RETURN(4),ITYPEA(4),MSG1(3), 
     ,MSG2(3),MSG3(3),MSG4(3),MSG5(3),MSG6(3),MSG7(3),MSG8(4),MSG9(5),
     ,MSG10(5),MSG11(4) 
      INTEGER RETURN,CHECK
      RETURN(1) = 0 
      IBUF = 0
      IRETRY = 0
      IREDO = 0 
      MASK  = O"77777777777777700000" 
      MASK1 = O"77777777777700000000" 
      MASK2 = O"00000000000000077777" 
      ITYPEA(1) = 10HPARITY 
      ITYPEA(2) = 10HLENGTH 
      ITYPEA(3) = 10HPOSITION 
      ITYPEA(4) = 10HCHECKSUM 
      MSG1(1)   = 10HGENERATE 
      MSG2(1)   = 10HREGENERATE 
      MSG3(1)   = 10HRUNPASS
      MSG4(1)   = 10HCOPY TAPE
      MSG5(1)   = 10HRETURN 
      MSG6(1)   = 10HREAD PE ON 
      MSG7(1)   = 10HREAD LE ON 
      MSG8(1)   = 10HFST/ALX ER 
      MSG8(2)   = 10HR ON PASS
      MSG9(1)   = 10HFST/ALX RE 
      MSG9(2)   = 10HTRY ERR ON 
      MSG9(3)   = 10H PASS
      MSG10(1)  = 10HPOSITION D 
      MSG10(2)  = 10HATA ERROR
      MSG10(3)  = 10HON TRY 
      MSG11(1)  = 10HCHECKSUM E 
      MSG11(2)  = 10HRR ON TRY
      MSG1(3)=MSG2(3)=MSG3(3)=MSG4(3)=MSG5(3)=MSG6(3)=MSG7(3) = 0 
      MSG8(4)=MSG9(5)=MSG10(5)=MSG11(4) = 0 
      ICORGR = 0
      ICOUNT = 0
      IPART = 0 
      ITOTAL = 0
  
  
**    1.0 CONTROL MODULE
*         --------------
* 
*         READ A CARD  FROM  INPUT.  IF  THE  CARD  CONTAINS GENERATE IN
*         COLUMN  1-10,  WE ENTER THE GENERATE MODE TO BUILD A DATA BASE
*         ON TAPE N.  IF THE CARD  CONTAINS  REGENERATE IN COLUMNS 1-10,
*         GO TO  REGENERATE THE DATA AND COMPARE IT  TO  TAPE N.  IF THE
*         CARD CONTAINS COPY IN COLUMNS 1-10, COPY TAPE N TO TAPE  NN IF
*         IT CONTAINS RETURN IN COLUMNS 1-10, REWIND AND  UNLOAD TAPE N.
*         THIS WILL ALSO RELEASE DISK SPACE. IF IT CONTAINS  RUNPASS  IN
*         COLUMNS 1-10 INITIALIZE FST/ALX OF THE REQUEST PASS COUNT, RUN
*         AND  PRINT RESULTS. IF IT CONTAINS ISOLATE IN COLUMNS 1-10 RUN
*         THE  ISOLATE  MODULE  TO  COMPARE  TAPE-NN  ERROR LOG WITH THE
*         MASTER DATA BASE ON TAPE N. 
*         THE FIRST CARD READ MUST CONTAIN THE UNIQUE JOB NAME IN COLUMN
*         1-6 AND THE NUMBER OF RECORDS TO PROCESS ON EACH FILE  IN  COL
*         8-11  RIGHT JUSTIFIED, (1-3750 DECIMAL).
* 
  
      PRINT 5 
5     FORMAT(1H1,30X,'R E G E N   A C T I V I T Y   L O G',//,
     13X,'DATE',7X,'TIME',25X,'ACTIVITY',//)
      READ(98,6,END=10000) JNAME,NR 
6     FORMAT(BZ,A6,1X,I4) 
10000 NAME = JNAME.AND.MASK1
      DAY = DATE()
      RSTART = TIME() 
      CPSTART = SECOND()
      IF(NR.EQ.0)NR = 3750
      IF((NR.GT.0).AND.(NR.LE.3750))GO TO 9006
      PRINT 9005,NR 
9005  FORMAT(' NUMBER OF RECORDS SELECTED OUT OF RANGE  =',I4)
      GO TO 905 
9006  IF(NR.EQ.0.OR.NR.GT.3750) NR = 3750 
      PRINT 7,DAY,RSTART,JNAME,NR 
7     FORMAT(2(1X,A10),2X,'START ',A6,3X,'NUMBER OF RECORDS SELECTED = '
     1,I4)
      IF(EOF(98)) 905,9,905 
9     READ(98,10,END=10001) IFLAG,N,NN,IPASS
10    FORMAT(BZ,A10,1X,I2,1X,I2,1X,O7)
10001 IF(EOF(98)) 905,11,905
11    IF(IFLAG.EQ.10HCOPY      ) GO TO 20 
      IF(IFLAG.EQ.10HREGENERATE) GO TO 30 
      IF(IFLAG.EQ.10HRETURN    ) GO TO 40 
      IF(IFLAG.EQ.10HRUNPASS   ) GO TO 50 
      IF(IFLAG.EQ.10HISOLATE   ) GO TO 60 
      IF(IFLAG.EQ.10HGENERATE  ) GO TO 9010 
      PRINT 9011,IFLAG
9011  FORMAT(' UNRECOGNIZED INPUT CONTROL STATEMENT =',A10) 
      GO TO 905 
  
**    2.0 GENERATE MODE DESCRIPTION MODULE
*         --------------------------------
* 
*         START GENERATE MODE.  WE WILL  GENERATE 60 WORDS OF  DATA  FOR
*         EACH CALL TO FST/ALX.  PVC WILL GENERATE A 3 WORD CHECKSUM  OF
*         THESE  60  WORDS  -  STRAIGHT  LINE LOGICAL SUM, LEFT DIAGONAL
*         AND RIGHT DIAGONAL SUMS.
*         THIS IS REPEATED 20 TIMES UNTIL WE HAVE 60 WORDS OF CHECKSUMS.
*         PVC IS THEN CALLED TO GENERATE A 3 WORD CHECKSUM OF THE CHECK-
*         SUMS WE NOW HAVE 63 WORDS GENERATED.
*         A 64TH WORD WILL  BE  ADDED TO  IDENTIFY THE JOB,  FILE  NAME,
*         RECORD NUMBER, AND BLOCK NUMBER.
* 
*         THE ABOVE  PROCESS IS REPEATED 8 TIMES UNTIL WE HAVE 512 WORDS
*         GENERATED.  511 OF THESE ARE THEN WRITTEN TO TAPE N.
* 
*         THE COMPLETE PROCESS IS REPEATED 3750 TIMES OR A TOTAL OF 
*         600,000 PASSES OF FST/ALX (20 X 8 X 3750).
* 
* 
*         1. INITIALIZE FST/ALX TO PASS 0 
* 
*         2. RUN A PASS OF FST/ALX TO GENERATE 60 WORDS OF DATA 
* 
  
9010  REWIND N
      ENCODE (10,1,MSG1(2))N
1     FORMAT(6H TAPE ,I2,2X)
      CALL REMARK (MSG1(1)) 
      IPASS = 0 
      CALL INIT(IPASS)
      DAY = DATE()
      START = TIME()
      CSTART = SECOND() 
      PRINT 1200,DAY,START,N
1200  FORMAT(2(1X,A10),2X,'START GENERATION OF TAPE',I2)
1204  ICORGR = 1
      DO 14 I=1,NR
      DO 13 J=1,8 
      DO 12 K=1,20
      L = (J-1) * 64 + ((K-1) * 3 + 1)
      CALL FST(DATA(1)) 
      CALL ALX(DATA(33))
  
**        3. GENERATE CHECKSUMS OF THE DATA GENERATED BY FST/ALX
  
      CALL PVC(DATA,CHECK(L),60,1,RETURN) 
  
**        4. REPEAT STEPS 2 AND 3 TWENTY TIMES UNTIL WE HAVE 60 WORDS.
  
  
12    CONTINUE
      L = L+3 
      M = L-60
  
**        5. GENERATE CHECKSUMS OF THE CHECKSUMS. 
  
      CALL PVC(CHECK(M),CHECK(L),60,1,RETURN) 
  
**        6. ADD RECORD BLOCK IDENTIFIERS TO THE 63 WORD BLOCK FOR LATER
*            VERIFICATION ON COPY AND REGENERATE MODES. 
  
      CHECK(L+3) = NAME.OR.(N*32768).OR.(I*8).OR.J
  
**        7. REPEAT STEPS 2 - 6 UNTIL 8 BLOCKS ARE GENERATED. 
  
  
13    CONTINUE
  
**        8. WRITE THE 511 WORD RECORD TO TAPE N.  REPEAT STEPS 2-8 
*            UNTIL ALL RECORDS HAVE BEEN WRITTEN. 
  
      BUFFER OUT (N,1) (CHECK(1),CHECK(511))
      IF(UNIT(N)) 14,16,18
14    CONTINUE
  
**        9. NORMAL TERMINATION OF THE GENERATE MODE. INDICATE SO AND GO
*            READ NEXT JOB DIRECTIVE. 
  
      REWIND N
      GO TO 900 
  
**       10. FATAL ERRORS IN THE GENERATE MODE ARE AS FOLLOWS.. 
*            EOF STATUS ON OUTPUT TO TAPE N  - ABORT
  
16    DAY = DATE()
      HOUR = TIME() 
      PRINT 17,DAY,HOUR,N,I 
17    FORMAT(2(1X,A10),2X,'JOB ABORTED DUE TO EOF STATUS ON OUTPUT FILE 
     1TAPE',I2,' ON RECORD ',I5)
      GO TO 999 
  
**           WRITE PARITY ERROR ON TAPE N - ABORT 
  
18    DAY = DATE()
      HOUR = TIME() 
      PRINT 19,DAY,HOUR,N,I 
19    FORMAT(2(1X,A10),2X,'JOB ABORTED DUE TO A WRITE PARITY ERROR ON OU
     1TPUT FILE TAPE',I2,' ON RECORD ',I5)
      GO TO 999 
  
**    3.0 COPY MODE DESCRIPTION MODULE
*         ----------------------------
* 
*         COPY MODE SELECTED, SO COPY TAPE-N TO TAPE-NN 
* 
* 
  
20    REWIND N
      REWIND NN 
      NAME1 = 0 
      ENCODE (10,2,MSG4(2))N,NN 
2     FORMAT(I2,4H TO  ,I2,2X)
      CALL REMARK(MSG4(1))
      ICORGR = 2
      DAY = DATE()
      START = TIME()
      CSTART = SECOND() 
      PRINT 1201,DAY,START,N,NN 
1201  FORMAT(2(1X,A10),2X,'START COPY OF TAPE',I2,' TO TAPE',I2)
      DO 23 I=1,NR
  
**        1. GO READ A RECORD FROM TAPE N.
* 
      IRTN = 1
      IBUF = 0
      GO TO 100 
  
**        2. GO CHECK THE 7 POSITION DATA WORDS IN THE RECORD JUST READ.
  
21    IRETRY = 0
      IRTN1 = 1 
      GOTO 1000 
  
**        3. GO VERIFY THE CHECKSUMS OF THE RECORD JUST READ. 
  
22    IRTN2 = 1 
      GOTO 1100 
  
**        4. NO ERROR ON THIS RECORD, SO ADD NEW POSITION DATA TO EACH
*            BLOCK AND WRITE IT TO TAPE NN. 
  
222   DO 223 JN=1,7 
      JM = JN*64+IBUF 
      CHECK(JM) = NAME.OR.(NN*32768).OR.(I*8).OR.JN 
223   CONTINUE
      BUFFER OUT (NN,1) (CHECK(IBUF+1),CHECK(IBUF+511)) 
      IF(UNIT(NN)) 23,26,28 
  
**        5. REPEAT STEPS 1 THRU 4 UNTIL NR RECORDS HAVE BEEN PROCESSED.
  
23    CONTINUE
  
**        6. THE COPY IS COMPLETE, SO PRINT TERMINATION MESSAGE AND GO
*            READ NEXT JOB DIRECTIVE
  
      REWIND N
      REWIND NN 
      GO TO 900 
25    FORMAT(/,/)                                                       000015
  
**        7. FATAL ERRORS IN COPY MODE DURING WRITING ARE AS FOLLOWS. 
*            EOF STATUS ON OUTPUT TO TAPE NN  - ABORT 
  
26    DAY = DATE()
      HOUR = TIME() 
      PRINT 17,DAY,HOUR,NN,I
      GO TO 999 
  
**           PARITY ERROR STATUS ON OUTPUT TO TAPE NN - ABORT.
  
28    DAY = DATE()
      HOUR = TIME() 
      PRINT 19,DAY,HOUR,NN,I
      GO TO 999 
  
**    4.0 REGENERATE MODE MODULE
*         ----------------------
* 
*         BEGIN THE CPU/CM TEST TO REGENERATE DATA
* 
*         1. INITIALIZE FST/ALX TO PASS 0 
  
30    IPASS = 0 
      CALL INIT(IPASS)
      NAME1 = 0 
      RETURN(1) = 0 
      REWIND N
      ENCODE (10,1,MSG2(2))N
      CALL REMARK (MSG2(1)) 
      DAY = DATE()
      START = TIME()
      CSTART = SECOND() 
      PRINT 1202,DAY,START,N
1202  FORMAT(2(1X,A10),2X,'START REGENERATION OF TAPE',I2)
      ICORGR = 1
      DO 32 I=1,NR
  
**        2. GO READ A RECORD FROM TAPE N.
      IRTN = 2
      IBUF = 0
      GO TO 100 
  
**        3. GO CHECK THE 7 POSITION DATA WORDS IN THE RECORD JUST READ.
  
300   IRETRY = 0
      IRTN1 = 2 
      GOTO 1000 
  
**        4. GO VERIFY THE CHECKSUMS OF THE RECORD JUST READ. 
  
301   IRTN2 = 2 
      GOTO 1100 
  
**        5. CALL FST/ALX AND PVC TO REGENERATE DATA AND VERIFY THAT
*            CHECKSUMS OF THE DATA GENERATED BY THIS PASS OF ALX/FST
*            AGREE WITH THE CHECKSUMS FROM TAPE N.  GO TO  STEP 7 IF
*            NO ERROR OCCURED.
  
31    DO 32 J=1,8 
      K = (J-1)*64+1+IBUF 
      DO 32 KK = 1,20 
      L = (KK-1)*3+K
      CALL FST(DATA(1)) 
      CALL ALX(DATA(33))
      CALL PVC(DATA,CHECK(L),60,0,RETURN) 
      IF(RETURN(1).EQ.0) GO TO 32 
  
**        6. CHECKSUM ERROR IN THE REGENERATED DATA FROM FST/ALX. 
*            REPORT THE ERROR AND RETRY THE CHECKSUM OPERATION. 
  
34    LL = ((I-1)*160) + ((J-1)*20) + KK - 1
      DAY = DATE()
      HOUR = TIME() 
      PRINT 35,DAY,HOUR,LL
      LM = L+2
      MAD = LOCF(DATA(1)) 
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(DATA(M),M=1,60),
     ,(CHECK(L1),L1=L,LM) 
35    FORMAT(2(1X,A10),2X,'CHECKSUM ERROR ON PASS ',O20,' IN DATA GENERA
     1TED BY FST/ALX')
39    FORMAT(26X,'ADDRESS DATA = ',O20,/, 
     126X,'X VECTOR =     ',O20,/,
     226X,'Y VECTOR =     ',O20,/,
     326X,'Z VECTOR =     ',O20,//, 
     45X,'DATA CONTAINING THE FAILURE FOLLOWS - FWA OF DATA PRINTED BELO
     5W = ',O5,2X,/,11(2X,6(O20,2X),/)) 
      PRINT 25                                                          000017
  
**           DISPLAY THE ERROR AND PAUSE5 IF SS2 IS ON. 
  
      ENCODE (10,55,MSG8(3))LL
      CALL REMARK(MSG8(1))
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 390 
      PAUSE 5 
390   ENCODE (10,1,MSG2(2))N
      CALL REMARK(MSG2(1))
  
**           RETRY THE CHECKSUM OPERATION.
  
      RETURN(1) = 0 
      RETURN(2) = 0 
      RETURN(3) = 0 
      RETURN(4) = 0 
      CALL PVC(DATA,CHECK(L),60,0,RETURN) 
      IF(RETURN(1).NE.0) GO TO 37 
  
**           RETRY WAS SUCCESSFUL. REPORT THE RECOVERY AND GO TO STEP 7.
  
      DAY = DATE()
      HOUR = TIME() 
      PRINT 36,DAY,HOUR,LL
36    FORMAT(2(1X,A10),2X,'RETRY CORRECTED THE CHECKSUM ERROR ON PASS ',
     1O20,' IN DATA GENERATED BY FST/ALX')
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(DATA(M),M=1,60),(CHECK(L1),L1=L,000019
     ,LM)                                                               000020
      PRINT 25                                                          000021
      GO TO 32
  
**           THE RETRY DID NOT CORRECT THE CHECKSUM ERROR, SO REPORT IT.
  
37    DAY = DATE()
      HOUR = TIME() 
      PRINT 38,DAY,HOUR,LL
38    FORMAT(2(1X,A10),2X,'THE RETRY FAILED TO CORRECT THE CHECKSUM ERRO
     1R IN PASS ',O20,' IN THE DATA GENERATED BY FST/ALX')
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(DATA(M),M=1,60),(CHECK(L1),L1=L,
     ,LM) 
      PRINT 25                                                          000023
**           DISPLAY THE ERROR AND PAUSE6 IF SS2 IS ON. 
  
      ENCODE (10,55,MSG9(4))LL
      CALL REMARK(MSG9(1))
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 380 
      PAUSE 6 
380   ENCODE (10,1,MSG2(2))N
      CALL REMARK (MSG2(1)) 
  
**           RERUN THE FST/ALX PASS AND RE-CHECK THE CHECKSUMS. 
  
      CALL INIT(LL) 
      CALL FST(DATA(1)) 
      CALL ALX(DATA(33))
      RETURN(1) = 0 
      RETURN(2) = 0 
      RETURN(3) = 0 
      RETURN(4) = 0 
      CALL PVC(DATA,CHECK(L),60,0,RETURN) 
      IF(RETURN(1).EQ.0) GO TO 382
  
**           THE RE-RUN OF THE PASS DID NOT CORRECT THE CHECKSUM ERR ABT
  
      DAY = DATE()
      HOUR = TIME() 
      PRINT 381,DAY,HOUR,LL 
381   FORMAT(2(1X,A10),2X,'THE RE-RUN OF FST/ALX FAILED TO CORRECT THE C
     1HECKSUM ERROR ON PASS ',O20,' - ABORT') 
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(DATA(M),M=1,60),(CHECK(L1),L1=L,000026
     ,LM)                                                               000027
      PRINT 25                                                          000028
      GO TO 999 
  
**           THE RE-RUN OF FST/ALX CORRECTED THE ERROR, SO REPORT AND 
*            CONTINUE 
  
382   DAY = DATE()
      HOUR = TIME() 
      PRINT 383,DAY,HOUR,LL 
383   FORMAT(2(1X,A10),2X,'THE RE-RUN OF FST/ALX CORRECTED THE CHECKSUM 
     1ERROR ON PASS ',O20)
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(DATA(M),M=1,60),(CHECK(L1),L1=L,000030
     ,LM)                                                               000031
      PRINT 25                                                          000032
  
**        7. REPEAT STEPS 5-6 TWENTY TIMES UNTIL WE USE UP A BLOCK OF 
*            DATA THEN 8 TIMES UNTIL A RECORD IS USED UP, AND THEN X
*            TIMES UNTILL NR RECORDS HAVE BEEN PROCESSED. 
* 
*         8. NORMAL TERMINATION OF THE REGENERATE MODE, SO INDICATE SO
*            AND GO READ NEXT JOB DIRECTIVE.
* 
  
32    CONTINUE
      REWIND N
      GO TO 900 
  
**    5.0 RETURN MODULE 
*         ------------- 
* 
*         1. REWIND TAPE N. 
* 
*         2. CALL UNLOAD TO CLOSE UNLOAD TAPE N.
* 
* 
  
40    REWIND N
      ENCODE (10,1,MSG5(2))N
      CALL REMARK (MSG5(1)) 
      DAY = DATE()
      START = TIME()
      CSTART = SECOND() 
      PRINT 41,DAY,START,N
41    FORMAT(2(1X,A10),2X,'RETURNING TAPE',I2)
      CALL UNLOAD(N)
      GO TO 900 
  
  
**    6.0 RUNPASS MODULE
*         --------------
* 
*         1. VALIDATE PASS NUMBER.  GO TO STEP 4 IF IT IS ILLEGAL.
* 
*         2. INITIALIZE FST/ALX TO THE SELECTED PASS.  RUN THAT PASS AND
*            CALL PVC TO GENERATE CHECKSUMS OF THE DATA GENERATED.
* 
*         3. PRINT RESULTS AND GO READ NEXT JOB DIRECTIVE.
* 
  
50    DAY = DATE()
      START = TIME()
      CSTART = SECOND() 
      IF(IPASS.GE.600000) GO TO 53
      PRINT 51,DAY,START,IPASS
51    FORMAT(2(1X,A10),2X,'RUNPASS ',O7)
      ENCODE (10,55,MSG3(2))IPASS 
55    FORMAT(O7,3HB   ) 
      CALL REMARK (MSG3(1)) 
      CALL INIT(IPASS)
      CALL FST(DATA(1)) 
      CALL ALX(DATA(33))
      CALL PVC(DATA,CHECK,60,1,RETURN)
      DAY = DATE()
      HOUR = TIME() 
      PRINT 52,DAY,HOUR,IPASS,(DATA(KL),KL=1,60),(CHECK(KM),KM=1,3) 
52    FORMAT(2(1X,A10),2X,'THE FOLLOWING 63 WORDS ARE THE DATA AND CHECK
     1SUMS GENERATED BY FST/ALX ON PASS ',O7,//,
     210(2X,6(O20,2X),/),2X,3(O20,2X),/)
      GO TO 900 
  
**        4. ILLEGAL PASS COUNT SO REPORT IT AND GO READ NEXT JOB 
*            DIRECTIVE. 
  
53    PRINT 54,DAY,START,IPASS
54    FORMAT(2(1X,A10),2X,'ILLEGAL PASS COUNT ON RUNPASS = ',O20) 
      GO TO 9 
  
**    8.0 ISOLATE MODULE
*         --------------
* 
*         1. OUTPUT REMARK RUNNING ISOLATE MODULE WITH TIME AND DATE. 
* 
* 
* 
  
60    CALL REMARK ('RUNNING ISOLATE MODULE')
      DAY   = DATE()
      START = TIME()
      PRINT 61,DAY,START,N,NN 
61    FORMAT(2(1X,A10),2X,'START ISOLATE MODE  DATA BASE = TAPE',I2,
     ,'  ERROR-LOG = TAPE',I2,/)
      I = 0 
      ICORGR = 0
  
**        2. REWIND ERRLOG-FILE AND MASTER-FILE 
  
      REWIND N
      REWIND NN 
  
*         3. READ A RECORD FROM THE ERROR LOG 
  
62    IRETRY = 0
63    READ(NN,END=10002)(CHECK(JJ),JJ=1,518)
10002 IF(EOF(NN))90,64,90 
  
**           VALIDATE VALID RECORD NUMBER READ FROM ERROR LOG 
  
64    IF(CHECK(1).EQ.0.OR.CHECK(1).GT.3750) GO TO 92
  
**           TRY TO FIND TWO NAMES THAT AGREE IN THE POSITION WORDS 
  
      DO 66 KK=1,6
      K1 = KK*64+7
      K2 = K1+64
      NAME  = CHECK(K1).AND.MASK
      NAME1 = CHECK(K2).AND.MASK
      IF(NAME.EQ.NAME1) GO TO 67
66    CONTINUE
  
**           DETERMINE IF OUR ERROR RECORD IS THE SAME AS THE RECORD
*            CURRENTLY IN THE BUFFER FROM THE MASTER DATA BASE
  
67    IF(I-CHECK(1)) 68,72,93 
  
**           NO, WE MUST SCAN FORWARD, SO READ ANOTHER RECORD FROM
*            DATA BASE. 
  
68    IRETRY = 0
      I = I+1 
      IF(I.EQ.3751) GO TO 96
69    BUFFER IN (N,1) (CHECK(519),CHECK(1029))
      IF(UNIT(N)) 71,94,70
  
**           PARITY ERROR, SO RETRY IF NOT TERMINAL RETRY COUNT 
  
70    IRETRY = IRETRY + 1 
      IF(IRETRY.EQ.3) GO TO 95
      BACKSPACE N 
      GO TO 69
  
**           NO PARITY, SO VERIFY LENGTH
  
71    L = LENGTH(N) 
      IF(L.EQ.511) GO TO 67 
      GO TO 70
  
**           RECORD NUMBERS COMPARE, SO COMPARE DATA. FIRST, ATTEMPT
*            TO MAKE POSITION DATA WORDS MATCH WITHOUT ERROR. 
  
72    DO 73 J=1,7 
      K =J*64+518 
      CHECK(K) = CHECK(K).AND.MASK2.OR.NAME 
73    CONTINUE
  
*     COMPARE AND REPORT NON-COMPARE WORDS.  REPORT ONLY THE FIRST
*     TEN NON-COMPARES IF SENSE SWITCH 3 IS OFF.  REPORT ALL NON- 
*     COMPARE WORDS IF IT IS ON.
* 
      CALL SSWTCH(3,M)
      L = 0 
      PRINT 74,CHECK(1),CHECK(2),CHECK(3),ITYPEA(CHECK(4)),CHECK(7),
     ,CHECK(5),CHECK(6) 
  
74    FORMAT('  ANALYZING ERROR ON RECORD ',I5,' BLOCK ',I1,' TAPE ',I2,
     1' DUE TO A ',A10,' ERROR .(BFR FWA=',O5,' DATE = ',A10,' TIME = ',
     2A10,//,10X,'WORD',8X,'EXPECTED',15X,'ACTUAL',14X,'DIFFERENCE',/)
  
      DO 77 J=1,511 
      IF(CHECK(J+7).EQ.CHECK(J+518)) GO TO 77 
  
*     SKIP THE PRINT OPERATION IF SS3 IS OFF AND NUMBER OF ERRS IS GT 10
  
      IF(M.EQ.2.AND.L.GT.10) GO TO 76 
      K = XOR(CHECK(J+7),CHECK(J+518))
      J1 = J-1
      PRINT 75,J1,CHECK(J+518),CHECK(J+7),K 
75    FORMAT(10X,O3,3(2X,O20))
76    L = L+1 
77    CONTINUE
      PRINT 78,I,L
78    FORMAT(/,10X,'RECORD ',I5,' HAD ',I3,' NON-COMPARE WORDS',//) 
      GO TO 62
  
  
80    FORMAT(/,2X,'NORMAL TERMINATION OF ISOLATE DUE TO EOF ON ERROR LOG
     1 TAPE',I2)
81    FORMAT(/,2X,'ABNORMAL TERMINATION OF ISOLATE DUE TO UNRECOVERABLE 
     1READ/LENGTH ERROR ON ERROR LOG TAPE',I2)
82    FORMAT(/,2X,'ABNORMAL TERMINATION OF ISOLATE DUE TO ILLEGAL RECORD
     1 NUMBER READ FROM THE ERROR LOG. RECORD NUMBER = ',O20) 
84    FORMAT(/,2X,'ABNORMAL TERMINATION OF ISOLATE DUE TO PREMATURE EOF 
     1ON MASTER DATA BASE TAPE',I2,' ON RECORD ',I5)
85    FORMAT(/,2X,'ABNORMAL TERMINATION OF ISOLATE DUE TO UNCORRECTABLE 
     1 READ PARITY OR LENGTH ERROR ON MASTER DATA BASE TAPE',I2)
86    FORMAT(/,2X,'ABNORMAL TERMINATION OF ISOLATE .  3750 RECORDS READ 
     1 FROM MASTER DATA BASE BUT ALL ERRORS NOT PROCESSED FROM ERROR LOG
     2 TAPE',I2)
  
**           EOF ON ERROR LOG, SO TERMINATE THE ISOLATE MODE
  
90    PRINT 80,NN 
      GO TO 99
  
**           FATAL ERROR ON READING ERROR LOG 
  
91    PRINT 81,NN 
      GO TO 99
  
**           ILLEGAL RECORD NUMBER READ FROM ERROR LOG
  
92    PRINT 82,CHECK(1) 
      GO TO 99
  
**           RECORD NUMBER OUT OF ORDER ON ERROR LOG - MUST NOT BE
*            SORTED, SO WE MUST REWIND TAPE N TO FIND THIS RECORD 
  
93    REWIND N
      I = 0 
      GO TO 68
  
**           PREMATURE EOF ON MASTER DATA BASE
  
94    PRINT 84,N,I
      GO TO 99
  
**           FATAL ERROR ON READING MASTER DATA BASE
  
95    PRINT 85,N
      GO TO 99
  
**           TERMINAL RECORD COUNT REACHED ON MASTER DATA BASE
  
96    PRINT 86,NN 
99    GO TO 900 
  
  
**    8.0 READ MODULE 
*         ----------- 
* 
*         BUFFER IN A 511 WORD RECORD FROM TAPE N.  RETRY ON PARITY 
*         ERROR, OR LENGTH ERRORS.  ABORT ON EOF OR UNCORRECTABLE 
*         PARITY/LENGTH.
* 
* 
  
  
100   BUFFERIN (N,1) (CHECK(IBUF+1),CHECK(IBUF+512))
      IF(UNIT(N)) 101,102,104 
101   LL = LENGTH(N)
      IF(LL.NE.511) GO TO 109 
  
**        1. READ IS SUCCESSFUL, SO RETURN TO CALLER. 
  
      GO TO (21,300,1012,1101) IRTN 
      CALL GOTOER 
  
**        2. EOF HAS BEEN REACHED ON TAPE N BEFORE EXPECTED, SO ABORT.
  
  
102   DAY = DATE()
      HOUR = TIME() 
      PRINT 103,DAY,HOUR,I,N
103   FORMAT(2(1X,A10),2X,'JOB ABORTED DUE TO PREMATURE EOF READ AT RECO
     1RD ',I5,' ON TAPE',I2)
      GO TO 999 
  
**        3. A PARITY ERROR OCCURRED ON THE READ, SO RETRY. 
  
104   BACKSPACE N 
      ITYPE = 1 
      K9 = 0
      DAY = DATE()
      HOUR = TIME() 
      PRINT 1040,DAY,HOUR,I,N 
1040    FORMAT(2(1X,A10),2X,'READ PARITY ERROR AT RECORD ',I5,' ON TAPE'
     1,I2)
      K8 = IBUF+1 
      K10 = IBUF+511
      K11 = LOCF(CHECK(K8)) 
  
**           WRITE ERROR DATA TO THE ERROR LOG TAPE 99
  
      WRITE(99) I,K9,N,ITYPE,DAY,HOUR,K11,(CHECK(K7),K7=K8,K10) 
      ITOTAL = ITOTAL + 1 
  
**           DISPLAY THE ERROR AND PAUSE1 IF SS2 IS ON. 
  
      ENCODE (10,1,MSG6(2))N
      CALL REMARK (MSG6(1)) 
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 1041
      PAUSE 1 
1041  IF(IFLAG.EQ.10HREGENERATE) CALL REMARK(MSG2(1)) 
      IF(IFLAG.EQ.10HCOPY      ) CALL REMARK(MSG4(1)) 
      BUFFER IN (N,1) (CHECK(IBUF+1),CHECK(IBUF+512)) 
      IF(UNIT(N)) 105,102,107 
  
**        4. THE RE-READ WAS SUCCESSFUL, SO REPORT THE RECOVERY AND 
*            CONTINUE 
  
105   DAY = DATE()
      HOUR = TIME() 
      PRINT 106,DAY,HOUR,I,N
106   FORMAT(2(1X,A10),2X,'RECOVERED READ PARITY ERROR AT RECORD ',I5,
     1' ON TAPE',I2)
      GO TO 101 
  
**        5. THE PARITY ERROR PERSISTS, SO REPORT IT AND ABORT. 
  
107   DAY = DATE()
      HOUR = TIME() 
      PRINT 108,DAY,HOUR,I,N
108   FORMAT(2(1X,A10),2X,'JOB ABORTED DUE TO UNCORRECTABLE READ PARITY 
     1ERROR ON RECORD ',I5,' OF TAPE',I2) 
      GO TO 999 
  
**        6. A LENGTH ERROR HAS BEEN DETECTED, SO RETRY THE READ. 
  
109   BACKSPACE N 
      ITYPE = 2 
      K9 = 0
      DAY = DATE()
      HOUR = TIME() 
      PRINT 1090,DAY,HOUR,I,N,LL
1090  FORMAT(2(1X,A10),2X,'READ LENGTH ERROR AT RECORD ',I4,' ON TAPE', 
     1I2,2X,'EXPECTED 511, ACTUAL = ',I3) 
      K8 = IBUF+1 
      K10 = IBUF+511
      K11 = LOCF(CHECK(K8)) 
  
**           WRITE ERROR LOG DATA TO TAPE 99
  
      WRITE(99) I,K9,N,ITYPE,DAY,HOUR,K11,(CHECK(K7),K7=K8,K10) 
      ITOTAL = ITOTAL + 1 
  
**           DISPLAY THE ERROR AND PAUSE2 IF SS2 IS ON. 
  
      ENCODE (10,1,MSG7(2))N
      CALL REMARK (MSG7(1)) 
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 1091
      PAUSE 2 
1091  IF(IFLAG.EQ.10HREGENERATE) CALL REMARK(MSG2(1)) 
      IF(IFLAG.EQ.10HCOPY      ) CALL REMARK(MSG4(1)) 
      BUFFER IN (N,1) (CHECK(IBUF+1),CHECK(IBUF+512)) 
      IF(UNIT(N)) 110,102,104 
110   LLL = LENGTH(N) 
      IF(LLL.NE.511) GO TO 112
  
**        7. THE RE-READ CORRECTED THE LENGTH ERROR, SO REPORT THE
*            RECOVERY 
  
      DAY = DATE()
      HOUR = TIME() 
      PRINT 111,DAY,HOUR,I,N,LL,LLL 
111   FORMAT(2(1X,A10),2X,'RECOVERED LENGTH ERROR ON RECORD ',I5,' OF TA
     1PE',I2,/,24X,'FIRST LENGTH WAS ',I4,' AND SECOND LENGTH WAS ',I4) 
  
**            GOOD RECOVERY, SO RETURN TO CALLER. 
  
      GO TO (21,300,1012,1101) IRTN 
      CALL GOTOER 
  
**        8. UNCORRECTABLE LENGTH ERROR, SO ABORT.
  
112   DAY = DATE()
      HOUR = TIME() 
      PRINT 113,DAY,HOUR,I,N,LL,LLL 
113   FORMAT(2(1X,A10),2X,'JOB ABORTED DUE TO UNCORRECTABLE LENGTH ERROR
     1 ON RECORD ',I4,' OF TAPE',I2,/,24X,'FIRST LENGTH READ WAS ',I4,
     2' AND SECOND LENGTH WAS ',I4) 
      GO TO 999 
  
**    9.0 VERIFY POSITION MODULE DESCRIPTION. 
*         ----------------------------------- 
* 
*         1. VERIFY POSITION DATA WITHIN THE RECORD JUST READ. THERE ARE
*            7 POSITION WORDS PER RECORD. UP TO 6 ATTEMPTS CAN BE MADE TO 
*            RECOVER THE FIRST FAILURE IN A RECORD. 
* 
*            - TWO IN-CORE TRIES FROM BUFFER 1
*            - ONE RE-READ AND RETRY FROM BUFFER 1
*            - TWO IN-CORE TRIES FROM BUFFER 2
*            - ONE RE-READ AND RETRY FOR BUFFER 2 
* 
*         THE IN-CORE RETRIES ARE DONE TO VERIFY  THAT  THE  CPU DID NOT
*         FAIL IN THE CHECKSUMMING.  THE SWITCH TO BUFFER 2 IS  DONE  TO
*         VERIFY THAT CENTRAL MEMORY IS NOT CAUSING  THE ERROR.  ONCE WE
*         SWITCH TO BUFFER 2, WE STAY IN IT FOR THE TOTAL  PROCESSING OF
*         THIS RECORD, BUT SWITCH BACK TO BUFFER 1 AFTER THIS RECORD HAS
*         BEEN PROCESSED. 
  
1000  IREREAD = 0 
1010  IF(NAME1.EQ.0) NAME1 = CHECK(IBUF+64).AND.MASK
1011  DO 1014 K1=1,7
1012  K2 = K1*64+IBUF 
      K0 = K1 
      ID = NAME1.OR.(I*8).OR.K0 
      IF(CHECK(K2).NE.ID) GO TO 1015
  
**        2. THE CHECK FOR ONE BLOCK IS OK - DETERMINE IF ANY RECOVERY
*            HAS BEEN USED, AND IF SO, REPORT HOW IT WAS RECOVERED. 
* 
      IF(IRETRY.EQ.0) GO TO 1014
      IF(IRETRY.EQ.3.AND.IREREAD.EQ.0) GO TO 1014 
      DAY = DATE()
      HOUR = TIME() 
      IF(IRETRY.EQ.1) PRINT 1020,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.2) PRINT 1021,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.3) PRINT 1022,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.4) PRINT 1023,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.5) PRINT 1024,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
  
**        3. RECOVERY HAS BEEN DONE ON THIS BLOCK, BUT WE MUST CONSIDER 
*            THAT OTHER BLOCKS ALREADY TESTED COULD HAVE BEEN CLOBBERED 
*            BY A RE-READS. IF WE ARE  NOT ON THE FIRST BLOCK, RE-CHECK 
*            ALL BLOCKS IF A RE-READ HAS BEEN DONE. 
* 
      IRETRY = 0
      IF(IBUF.NE.0) IRETRY = 3
      IF(K1.EQ.1.OR.IREREAD.EQ.0) GO TO 1013
      IREREAD = 0 
      GOTO 1011 
1013  IREREAD = 0 
1014  CONTINUE
  
**        4. POSITION DATA HAS BEEN VERIFIED, SO RETURN TO CALLER.
* 
      IREDO = 0 
      IF(IBUF.NE.0) IREDO = 3 
      IRETRY = IREDO
      IF(IRTN1-2) 22,301,1100 
  
**        5. POSITION DATA HAS BEEN FOUND IN ERROR. REPORT THE ERROR AND
*            DECIDE HOW TO RETRY. AFTER ALL POSSIBILITIES HAVE BEEN USED
*            ABORT THE JOB. 
  
1015  IRETRY = IRETRY + 1 
      DAY = DATE()
      HOUR = TIME() 
      IF(IRETRY.EQ.1) PRINT 1025,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.2) PRINT 1026,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.3) PRINT 1027,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.4) PRINT 1028,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.5) PRINT 1029,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      IF(IRETRY.EQ.6) PRINT 1030,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      ENCODE (10,3,MSG10(4))IRETRY
3     FORMAT(I2,8X) 
      CALL REMARK(MSG10(1)) 
      ITYPE = 3 
      K8 = IBUF+1 
      K10 = IBUF+511
      K11 = LOCF(CHECK(K8)) 
  
**           WRITE ERROR LOG DATA TO TAPE 99
  
      WRITE(99) I,K0,N,ITYPE,DAY,HOUR,K11,(CHECK(K7),K7=K8,K10) 
      ITOTAL = ITOTAL + 1 
      IF(IRETRY.EQ.6) GO TO 1017
  
**           DISPLAY THE ERROR AND PAUSE3 IF SSW2 IS ON 
  
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 1002
      PAUSE 3 
1002  IF(IFLAG.EQ.10HREGENERATE) CALL REMARK (MSG2(1))
      IF(IFLAG.EQ.10HCOPY      ) CALL REMARK (MSG4(1))
  
**           RETRY IN-CORE IF ON 1ST OR 4TH RETRY.
  
      IF(IRETRY.EQ.1.OR.IRETRY.EQ.4) GO TO 1012 
  
**           RE-READ THE RECORD IF 2ND OR 5TH RETRY.
  
      IF(IRETRY.EQ.2.OR.IRETRY.EQ.5) GO TO 1016 
  
**           RETRY COUNT IS 3, SO INDICATE BUFFER 2 IS NOW IN USE.
  
      IBUF = 513
  
**           SET RE-READ FLAG, BACKSPACE, AND RE-READ THE RECORD. 
*            THEN RETURN TO STEP 1 FOR FURTHER ISOLATION
  
1016  IREREAD = 1 
      BACKSPACE N 
      IRTN = 3
      GOTO 100
  
**           UNABLE TO CORRECT POSITON DATA ON RETRIES, SO TERMINATE JOB
  
1017  DAY = DATE()
      HOUR = TIME() 
      PRINT 1031,DAY,HOUR,N,I,K0,ID,CHECK(K2) 
      GO TO 999 
1020  FORMAT(/,2(1X,A10),2X,'POSITION RECOVERY ON DATA FROM TAPE',I2,1X,
     1'BY IN-CORE RETRY OF BUFFER 1 ON RECORD ',
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
1021  FORMAT(/,2(1X,A10),2X,'POSITION RECOVERY ON DATA FROM TAPE',I2,1X,
     1'BY BACKSPACE/RE-READ TO BUFFER 1 ON RECORD ',
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
1022  FORMAT(/,2(1X,A10),2X,'POSITION RECOVERY ON DATA FROM TAPE',I2,1X,
     1'ON FIRST READ TO BUFFER 2 ON RECORD ', 
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
1023  FORMAT(/,2(1X,A10),2X,'POSITION RECOVERY ON DATA FROM TAPE',I2,1X,
     1'BY IN-CORE RETRY OF BUFFER 2 ON RECORD ',
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
1024  FORMAT(/,2(1X,A10),2X,'POSITION RECOVERY ON DATA FROM TAPE',I2,1X,
     1'BY BACKSPACE/RE-READ TO BUFFER 2 ON RECORD ',
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
1025  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'FIRST TRY OF BUFFER 1 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1026  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'IN-CORE RETRY OF BUFFER 1 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1027  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'BACKSPACE/RE-READ TO BUFFER 1 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1028  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'FIRST TRY OF BUFFER 2 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1029  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'IN-CORE RETRY OF BUFFER 2 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1030  FORMAT(/,2(1X,A10),2X,'POSITION ERROR IN DATA FROM TAPE',I2,' ON '
     1,'BACKSPACE/RE-READ TO BUFFER 2 ON RECORD ',
     2 I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,/)
1031  FORMAT(/,2(1X,A10),2X,'UNRECOVERABLE POSITION ERROR ON DATA FROM T
     1APE',I2,' ON RECORD ',
     2I4,' BLOCK ',I1,/24X,'EXPECTED = ',O20,/,24X,'ACTUAL   = ',O20,//)
  
**   10.0 VERIFY CHECKSUM MODULE DESCRIPTION
*         ----------------------------------
* 
*         1. VERIFY CHECKSUMS ON DATA READ FROM TAPE N.  THERE ARE 8
*            BLOCKS OF 63 WORDS EACH TO BE VERIFIED.  UP TO 6 ATTEMPTS
*            CAN BE MADE TO RECOVER FROM A CHECKSUM ERROR.  THIS COULD
*            BE LIMITED TO 3 IF WE ARE ALREADY WORKING OUT OF BUFFER 2
*            WHEN CHECKSUM TESTING IS STARTED.
* 
*            - TWO IN-CORE TRIES FROM BUFFER 1. 
*            - ONE RE-READ AND RETRY FROM BUFFER 1. 
*            - TWO IN-CORE TRIES FROM BUFFER 2. 
*            - ONE RE-READ AND RETRY FROM BUFFER 2. 
* 
*            IF A RE-READ HAS TO BE DONE, POSITION DATA COULD BE CLOB-
*            BERED SO, POSITION DATA IS RE-VALIDATED AFTER CHECKSUM 
*            PROBLEM ISOLATION AND THEN THE CHECKSUMS ARE RE-VALIDATED
*            AGAIN TO INSURE DATA 
* 
*            INTEGRITY.   ...... WARNING...... THIS COULD CAUSE LOOPING.
  
1100  IREAD = 0 
      DO 1103 K3=1,8
1101  K4 = (K3-1)*64+IBUF+1 
      K5 =K4 + 60 
      RETURN(1) = 0 
      CALL PVC(CHECK(K4),CHECK(K5),60,0,RETURN) 
      IF(RETURN(1).NE.0) GO TO 1104 
  
**        2. THE CHECKSUM FOR THIS BLOCK IS GOOD DETERMINE IF RECOVERY
*            WAS USED TO GET HERE.  IF SO, REPORT HOW IT WAS DONE.
  
      IF(IREDO.EQ.0) GO TO 1103 
      IF(IREDO.EQ.3.AND.IREAD.EQ.0) GO TO 1103
      DAY = DATE()
      HOUR = TIME() 
      K6 = K3 
      IF(IREDO.EQ.1) PRINT 1110,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.2) PRINT 1111,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.3) PRINT 1112,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.4) PRINT 1113,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.5) PRINT 1114,DAY,HOUR,N,I,K6 
      K5 = K5+3 
      IF(K3.EQ.8) K5 = K5 - 1 
      MAD = LOCF(CHECK(K4)) 
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(CHECK(K7),K7=K4,K5) 
  
**        3. RECOVERY HAS BEEN DONE ON THIS BLOCK, BUT WE MUST CONSIDER 
*            THAT OTHER BLOCKS ALREADY PROCESSED COULD HAVE BEEN CLOB-
*            BERED BY A RE-READ.  IF ONE WAS DONE, WE MUST RE-CHECK ALL 
*            BLOCKS BOTH POSITION DATA AND CHECKSUMS. 
  
      IREDO = 0 
      IF(IBUF.NE.0) IREDO = 3 
      IF(IREAD.EQ.0) GO TO 1103 
      IREAD = 0 
      IRETRY = IREDO
      IRTN1 = 3 
      GOTO 1000 
1103  CONTINUE
  
**        4. CHECKSUM DATA HAS BEEN VERIFIED, SO RETURN TO CALLER.
  
      IF(IRTN2-2) 222,31,222
  
**        5. CHECKSUM ERROR HAS BEEN FOUND, SO REPORT IT AND RETRY IF 
*            POSSIBLE IF UNSUCCESSFUL AFTER ALL OPTIONS, ABORT THE JOB. 
  
1104  IREDO = IREDO+1 
      DAY = DATE()
      HOUR = TIME() 
      K6 = K3 
      IF(IREDO.EQ.1) PRINT 1115,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.2) PRINT 1116,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.3) PRINT 1117,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.4) PRINT 1118,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.5) PRINT 1119,DAY,HOUR,N,I,K6 
      IF(IREDO.EQ.6) PRINT 1120,DAY,HOUR,N,I,K6 
      K5 = K5+3 
      IF(K3.EQ.8) K5 = K5 - 1 
      MAD = LOCF(CHECK(K4)) 
      PRINT 39,(RETURN(MM),MM=1,4),MAD,(CHECK(K7),K7=K4,K5) 
      ITYPE = 4 
      K8 = IBUF+1 
      K10 = IBUF+511
      K11 = LOCF(CHECK(K8)) 
  
**           WRITE THE ERROR LOG DATA TO TAPE 99
  
      WRITE(99) I,K6,N,ITYPE,DAY,HOUR,K11,(CHECK(K7),K7=K8,K10) 
      ITOTAL = ITOTAL + 1 
  
**           DISPLAY THE ERROR DATA AND PAUSE4 IF SSW2 IS ON
  
      ENCODE (10,3,MSG11(3))IREDO 
      CALL REMARK(MSG11(1)) 
      CALL SSWTCH(2,M1) 
      IF(M1.NE.1) GO TO 1108
      PAUSE 4 
1108  IF(IFLAG.EQ.10HREGENERATE) CALL REMARK (MSG2(1))
      IF(IFLAG.EQ.10HCOPY      ) CALL REMARK (MSG4(1))
      IF(IREDO.EQ.6) GO TO 1106 
      RETURN(1) = 0 
      RETURN(2) = 0 
      RETURN(3) = 0 
      RETURN(4) = 0 
  
**           RETRY IN-CORE IF 1ST OR 4TH RETRY. 
  
      IF(IREDO.EQ.1.OR.IREDO.EQ.4) GO TO 1101 
  
**           RE-READ THE RECORD IF 2ND OR 5TH RETRY.
  
      IF(IREDO.EQ.2.OR.IREDO.EQ.5) GO TO 1105 
  
**           RETRY COUNT = 3, SO INDICATE BUFFER 2 IS NOW IN USE. 
  
      IBUF = 513
  
**           SET RE-READ FLAG, BACKSPACE, RE-READ AND RETURN TO STEP 1
*            TO  CONTINUE CHECKWORD ERROR ISOLATION 
  
1105  IREAD = 1 
      BACKSPACE N 
      IRTN = 4
      GO TO 100 
  
**        6. CHECKSUM RECOVERY UNSUCCESSFUL, SO TERMINATE JOB.
  
1106  DAY = DATE()
      HOUR = TIME() 
      PRINT 1121,DAY,HOUR,N,I,K6
      GO TO 999 
1110  FORMAT(/,2(1X,A10),2X,'CHECKSUM RECOVERY ON DATA FROM TAPE',I2, 
     1' BY IN-CORE RETRY OF BUFFER 1 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1111  FORMAT(/,2(1X,A10),2X,'CHECKSUM RECOVERY ON DATA FROM TAPE',I2, 
     1' BY BACKSPACE/RE-READ TO BUFFER 1 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1112  FORMAT(/,2(1X,A10),2X,'CHECKSUM RECOVERY ON DATA FROM TAPE',I2, 
     1' ON FIRST READ TO BUFFER 2 ON RECORD ',
     2I4,' BLOCK ',I1,/)
1113  FORMAT(/,2(1X,A10),2X,'CHECKSUM RECOVERY ON DATA FROM TAPE',I2, 
     1' BY IN-CORE RETRY OF BUFFER 2 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1114  FORMAT(/,2(1X,A10),2X,'CHECKSUM RECOVERY ON DATA FROM TAPE',I2, 
     1' BY BACKSPACE/REREAD TO BUFFER 2 ON RECORD ',
     2I4,' BLOCK ',I1,/)
1115  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON FIRST TRY OF BUFFER 1 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1116  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON IN-CORE RETRY OF BUFFER 1 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1117  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON BACKSPACE/RE-READ TO BUFFER 1 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1118  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON FIRST TRY OF BUFFER 2 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1119  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON IN-CORE RETRY OF BUFFER 2 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1120  FORMAT(/,2(1X,A10),2X,'CHECKSUM ERROR ON DATA FROM TAPE',I2,
     1' ON BACKSPACE/RE-READ TO BUFFER 2 ON RECORD ', 
     2I4,' BLOCK ',I1,/)
1121  FORMAT(/,2(1X,A10),2X,'UNRECOVERABLE CHECKSUM ERROR ON DATA FROM T
     1APE',I2,' ON RECORD ',I4,' BLOCK ',I1,/)
  
*     PERFORM TIME AND BIT CALCULATIONS 
  
900   IRTN3 = 1 
      GO TO 901 
999   IRTN3 = 2 
901   STOP = TIME() 
      CALL RT(START,STOP) 
      CEND = SECOND() 
      CEND = CEND - CSTART
      DAY = DATE()
      HOUR = TIME() 
      PRINT 903,DAY,HOUR,IFLAG,STOP,CEND
903   FORMAT(2(1X,A10),2X,'   WALL CLOCK ',A10,' TIME = ',A10,'  ( ', 
     1F7.2,' CPU SECONDS USED )') 
      IF(IRTN3.NE.1) GO TO 904
      ICOUNT = ICOUNT + ICORGR
      ICORGR = 0
      CALL SSWTCH(1,J)
      IF(J.EQ.1) GOTO 905 
      GOTO 9
  
*     TERMINATE JOB 
  
904   IPART = (I-1) * 30660 * ICORGR
905   REND = TIME() 
      CEND = SECOND() 
      CEND = CEND - CPSTART 
      HOUR = REND 
      DAY = DATE()
      PRINT 906,DAY,HOUR
906   FORMAT(2(1X,A10),2X,18H*** END OF RUN ***)
      CALL RT(RSTART,REND)
      PRINT 907,DAY,HOUR,REND,CEND
907   FORMAT(2(1X,A10),2X,'   TOTAL WALL CLOCK RUN TIME = ',A10,'  ( ', 
     1F9.2,' CPU SECONDS USED )') 
      ICORGR = ICOUNT * NR * 30660
      ICORGR = ICORGR + IPART 
      PRINT 908,DAY,HOUR,ICORGR 
908   FORMAT(2(1X,A10),2X,25H*** TOTAL BITS FOR RUN = ,I13) 
      PRINT 909,DAY,HOUR,ITOTAL 
909   FORMAT(2(1X,A10),2X,'TOTAL ERRORS SAVED ON TAPE99 = ',I5) 
*CALL,CPYFTN
      END 
