*DECK D44 
*** D44 - AN 844 DIAGNOSTIC BASED ON THE CML D44 DIAGNOSTIC 
*** EXTERNAL DOCUMENTATION
**
* 
* AUTHOR - MAINTENANCE SOFTWARE ENGINNERING 
* 
* OVERVIEW - D44 IS A SERIES OF DIAGNOSTICS FOR 7X54 AND FMD
*            CONTROLLERS WITH 844 2X  AND  4X  DISK  DRIVES.
*            THE DIAGNOSTIC IS DIVIDED IN THREE PARTS.  PART
*            I CONSISTS  OF  MODULES  WHICH ARE   CONFIDENCE
*            LEVEL DIAGNOSTICS.  THE BASIC INDIVIDUAL FUNCT-
*            IONS ARE  CHECKED BEFORE  CHECKING THE FEATURES
*            INVOLVING  A COMBINATION  OF THESE BASIC FUNCT-
*            IONS.   EACH MODULE IS A  SEPERATE ENTITY, THAT
*            CAN BE  LOOPED  ON ITSELF.   THESE MODULES HAVE
*            NO PARAMETER INPUT.
* 
*            PART   II  CONSISTS  OF  INDIVIDUAL  SELECTABLE
*            MODULES IN PRESCRIBED MODES DRIVEN BY PARAMETER
*            INPUT.   THE  TWO  SURFACE TESTS IN THIS SERIES
*            ARE NOT PARAMETER DRIVEN.  THESE TESTS  ANALYZE
*            THE FULL DISK PACK.
* 
*            PART  III  CONSISTS  OF  INDIVIDUAL MAINTENANCE
*            MODULES TO LOOP ON PRESCRIBED AREAS OF DISK  OR
*            CONTROLLER  FUNCTIONS.  PARAMETER INPUT IS USED
*            WHERE APPLICABLE.
* 
* 
* PART I MODULE DESCRIPTIONS
*              CONFIDENCE LEVEL DIAGNOSTICS 
* 
*   MODULE 00 - CONNECT TEST -
*        THIS MODULE CONNECTS THE CONTROLLER AND
*        RELEASES THE CONTROLLER 10 TIMES.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION 
* 
*   MODULE 01 - GENERAL STATUS TEST - 
*        RESERVE THE CONTROLLER, GENERAL STATUS, SAVE 
*        STATUS, REPEAT GETTING THE GENERAL STATUS
*        1000 TIMES COMPARING EACH STATUS WITH THE FIRST
*        STATUS TAKEN.  THE ABOVE IS REPEATED 4 TIMES.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION 
* 
*   MODULE 02 - DETAIL STATUS TEST -
*        RESERVE THE CONTROLLER, TAKE DETAILED STATUS, SAVE 
*        STATUS, REPEAT GETTING THE DETAILED STATUS 1000
*        TIMES COMPARING EACH STATUS WITH THE FIRST DETAILED
*        STATUS TAKEN.  THE ABOVE IS REPEATED 4 TIMES.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION 
* 
*   MODULE 03 - DIAGNOSTIC WRITE / READ TEST -
*        RESERVE THE CONTROLLER, DIAGNOSTIC READ CONTROLLER 
*        MEMORY AND SAVE IN THE OUTPUT BUFFER, REPEAT THE 
*        DIAGNOSTIC READ 50 TIMES COMPARING THE INPUT TO
*        THE SAVED OUTPUT BUFFER.  THE FOLLOWING SEQUENCE 
*        WILL BE DONE FOR EACH OF THESE PATTERNS.  (5252, 
*        2525, RANDOM DATA)  RESERVE THE CONTROLLER, SET
*        THE OUTPUT BUFFER WITH ONE OF THE ABOVE PATTERNS,
*        DIAGNOSTIC WRITE, DIAGNOSTIC READ, COMPARE INPUT 
*        TO OUTPUT (REPEAT 50 TIMES), RELEASE THE 
*        CONTROLLER.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION 
* 
*   MODULE 04 - CYLINDER SEEK TEST -
*        RESERVE DRIVE, SEEK CYLINDERS ON THREE DIFFERENT 
*        TIMED MOVE CONDITIONS OF CYLINDER SEEKS, READING 
*        EACH SEEK FOR CORRECT POSITION ADDRESS, STATUS,
*        RELEASE THE CHANNEL BETWEEN EACH OF THE DIFFERENT
*        CYLINDER SEEK CONDITIONS.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 05 - READ PACK FLAWED SECTOR TEST -
*        RESERVE DRIVE, (SEPARATE SUBROUTINES, READ SERIAL
*        NUMBER, FACTORY FLAWED SECTOR, UTILITY FLAWED
*        SECTOR) SAVE SECTOR IN THE OUTPUT BUFFER, AND
*        REREAD THE SECTOR 10 TIMES, CHECKING STATUS AND
*        COMPARING DATA EACH TIME.  RELEASE THE CHANNEL 
*        AT THE END OF EACH SUBROUTINE. 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 06 - READ INNERMOST CYLINDER TEST -
*        RESERVE DRIVE, READ CODED ADDRESS ON THE INTER-
*        MOST CYLINDER IN 2/1 INTERLACE, TRACK MODE, STATUS 
*        AND COMPARE THE PREWRITTEN RANDOM DATA. THE CHANNEL
*        IS RELEASED BETWEEN EACH TRACK.
* 
*        NOTE- MODULE 41 MUST HAVE PREVIOUSLY WRITTEN THIS
*        CYLINDER.
*        MODULE 6 CAN BE USED AS A COMPATIBILITY CHECK IF 
*        MODULE 41 IS RUN ONCE PER PACK ON A PROPERLY 
*        ALIGNED DRIVE. 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 07 - READ COUPLER BUFFER TEST -
*        WRITE/READ THE 7154 COUPLER BUFFER WITH A 5252,
*        2525, AND 20 PASSES OF RANDOM DATA PATTERNS.  EACH 
*        DATA PATTERN WILL BE READ 50 TIMES.  THE COUPLER IS
*        RESERVED AT THE BEGINNING OF EACH DATA PATTERN.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 08 - WRITE FIRST 2 PREALLOCATED CYLINDERS TEST - 
*        CHECK FOR ACCESS LEVEL OF 3 OR ABOVE.
*        RESERVE THE DRIVE, WRITE THE FIRST 2 PREALLOCATED
*        CYLINDERS AT 1/1 INTERLACE, ADDRESS CODED, TRACK 
*        MODE, WITH RANDOM DATA.  THE CHANNEL IS RELEASED 
*        AT END OF EACH TRACK.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 09 - READ FIRST 2 PREALLOCATED CYLINDERS TEST -
*        READ THE FIRST TWO PREALLOCATED CYLINDERS AT 2/1 
*        INTERLACE, TRACK MODE, CHECKING STATUS AND COM-
*        PARING DATA.  THE CHANNEL IS CONNECTED AT THE
*        BEGINNING OF EACH TRACK AND RELEASED AT THE END
*        OF TRACK.
*        NOTE- MODULE 08 MUST HAVE WRITTEN THESE CYLINDERS
*              BEFORE THIS MODULE CAN BE RUN WITHOUT ERRORS.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 10 - FORCE CHECKWORD ERROR TEST -
*        READ SHORT EACH ONE OF THE SUBTEST PATTERNS LISTED 
*        BELOW 3 TIMES.  THE CHANNEL IS RESERVED AND                     D44001J
*        RELEASED ON EACH SUBTEST.  SECTOR 0 ON TRACK 0 
*        OF THE FIRST PREALLOCATED CYLINDER WILL BE USED FOR
*        TESTING. 
* 
*        SUBTEST  PATTERN   GENERAL STATUS
*          1       4000       4640
*          2       7760       4640
*          3       7777       4600
*      4 THRU 13   RANDOM     4640       RANDOM DATA, 
*                                        RANDOM ADDRESS 
*                                        WITH RANDOM DATA 
*                                        IN CORRECTABLE 8 
*                                        BIT FORMAT.
*                                        REPEATED 10 TIMES. 
* 
*        NOTE- WHEN RUNNING ON A FMD CONTROLLER, THE GENERAL
*              STATUS HAS BIT 5 REMOVED.  (THE GENERAL
*              STATUS WOULD BE 4640 ON A 7X54 OR 4600 ON A
*              FMD CONTROLLER.  THE MODULE REMOVES BIT 5.)
* 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 11 - WRITE VERIFY TEST - 
*        WRITE VERIFY THE FIRST PREALLOCATED CYLINDER.
*        FORCES A SECTOR ERROR TO VERIFY ERROR DETECTION. 
*        THE CHANNEL IS RESERVED AT THE BEGINING OF THE 
*        CYLINDER AND RELEASED AT THE END OF THE WRITE
*        VERIFY OF THE CYLINDER.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 12 - READ CHECKWORD TEST - 
*        READ CHECK WORD THE FIRST PREALLOCTED CYLINDER IN
*        1/1 INTERLACE.  THE CHANNEL IS RESERVED ON THE 
*        START OF THE CYLINDER AND RELEASED ON FINISH.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 13 -CHECK MARGIN TEST- 
*        SET THE MARGINS FROM THE TABLE BELOW (NINE COM-
*        BINATIONS), READ THE FIRST PREALLOCATED CYLINDER.
*        THE CHANNEL IS RELEASED BETWEEN TRACKS.
* 
*                    NORMAL    NORMAL 
*                    FORWARD   EARLY
*                    REVERSE   LATE 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 14 - RANDOM SEEK TEST -
*        RANDOM SEEKS TO ANY POSITION ON THE DISK, SEEK 
*        BACK TO THE MAXIMUM CYLINDER, READ ADDRESS, AND
*        CHECK STATUS.  THIS SEQUENCE IS REPEATED 25 TIMES. 
*        THE CHANNEL IS RELEASED AND RECONNECTED AFTER EACH 
*        SEQUENCE.  THE TOTAL SEQUENCE IS REPEATED 25                    D44002J
*        TIMES. 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 15 - WRITE CODED CYLINDER TEST - 
*        CHECK FOR ACCESS LEVEL OF 3 OR ABOVE.
*        WRITES ADDRESS CODED, RANDOM DATA, 1/1 INTER-
*        LACE, ON THE FIRST CYLINDER OF THE PREALLOCATED
*        AREA.  THE CHANNEL IS RESERVED AT THE BEGINING AND 
*        RELEASED AT THE END OF THE WRITE SEQUENCE. 
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 16 - READ CODED VERIFY TEST -
*        VERIFIES THE ADDRESS CODING WAS CORRECT FROM THE 
*        PRECEDING MODULE.  READ CODED VERIFY AT 2/1 INTER- 
*        LACE, ON THE FIRST PREALLOCATED CYLINDER.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
* 
* PART II MODULE DESCRIPTION
*               INDIVIDUAL SELECTABLE 
* 
* 
*                            *********
*                            *CAUTION*
*                            *********
* 
*        IN PARAMETER DRIVEN MODULES WITH AN ACCESS LEVEL OF
*        4, DATA CAN BE DESTROYED ANYWHERE ON THE PACK. IT IS 
*        ADVISABLE NOT TO SWAP PACKS WHILE RUNNING THE
*        DIAGNOSTIC.
* 
* 
*   MODULE 17 - READCW SEQUENTIAL DISK TEST 1/1 
*        ACCESS LEVEL OF 3 IS REQUIRED IF *SECURE*IS
*        DEFINED ON INSTALLATION OF PL5/REL2B. ACCESS 
*        LEVEL OF 1 IS REQUIRED IF *SECURE*IS NOT.
*        STARTING WITH SECTOR 0, TRACK 0, CYLINDER P0,
*        THE DISK IS READ IN SEQUENTIAL, TRACK MODE AT
*        1/1 INTERLACE THROUGH CYLINDER P1. THE CHANNEL 
*        IS RESERVED AT THE BEGINNING OF EACH TRACK AND 
*        RELEASED AT  THE  END  OF  EACH TRACK.  READCW 
*        COMMANDS ARE USED TO READ THE PACK AND NO DATA 
*        IS TRANSFERRED TO THE PPU.  IF P0 AND P1 ARE 
*        BOTH ZERO THE ENTIRE PACK WILL BE READ.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
* 
*   MODULE 30 - SEQUENTIAL WRITE/READ, TRACK MODE, 2/1 -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE DRIVE IS
*        RESERVED, AND A WRITE/READ AT 2/1 INTERLACE START- 
*        ING AT THE LOWEST SECTOR SPECIFIED TO THE HIGHEST
*        SECTOR SPECIFIED, ON THE LOWEST TRACK, AND 
*        CYLINDER.  THE TRACK THEN CYLINDER COUNTS ARE
*        INCREMENTED UNTIL THEIR VALUES HAVE BEEN 
*        COMPLETED. 
*        THE CHANNEL IS RELEASED BETWEEN EACH TRACK GROUP.
* 
*        PARAMETERS- REPEAT CONDITION.
* 
* 
*   MODULE 31 - SEQUENTIAL WRITE/READ, CYLINDER MODE, 2/1 - 
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE DRIVE IS
*        RESERVED, AND A WRITE/READ AT 2/1 INTERLACE START- 
*        ING AT THE LOWEST CYLINDER SPECIFIED TO THE HIGHEST
*        CYLINDER SPECIFIED WILL BE COMPLETED.  ALL SECTORS 
*        AND TRACKS ARE WRITTEN OR READ IN THE SPECIFIED
*        CYLINDERS.  THE CHANNEL IS RELEASED BETWEEN EACH 
*        CYLINDER.
* 
*        PARAMETERS- REPEAT CONDITION.
* 
*   MODULE 32 - SEQUENTIAL WRITE/READ, TRACK MODE, 1/1 -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE DRIVE IS
*        RESERVED, AND A WRITE/READ AT 1/1 INTERLACE START- 
*        ING AT THE LOWEST SECTOR SPECIFIED TO THE HIGHEST
*        SECTOR SPECIFIED, ON THE LOWEST TRACK, AND 
*        CYLINDER.  THE TRACK, THEN CYLINDER COUNTS ARE 
*        INCREMENTED UNTIL THE THEIR VALUES HAVE BEEN 
*        COMPLETED. 
*        THE CHANNEL IS RELEASED BETWEEN EACH TRACK GROUP.
* 
*        PARAMETERS- REPEAT CONDITION.
* 
* 
*   MODULE 33 - SEQUENTIAL WRITE/READ, CYLINDER MODE, 1/1 - 
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE DRIVE IS
*        RESERVED, AND A WRITE/READ AT 1/1 INTERLACE START- 
*        ING AT THE LOWEST CYLINDER SPECIFIED TO THE HIGHEST
*        CYLINDER SPECIFIED WILL BE COMPLETED.  ALL SECTORS 
*        AND TRACKS ARE WRITTEN OR READ IN THE SPECIFIED
*        CYLINDERS.  THE CHANNEL IS RELEASED BETWEEN EACH 
*        CYLINDER.
* 
*        PARAMETERS- REPEAT CONDITION.
* 
* 
*   MODULE 34 - RANDOM WRITE/READ, ONE CYL, TRK, SEC -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        A RANDOM CYLINDER, TRACK AND SECTOR IS FOUND THAT
*        WILL FIT INTO THE CONFINES OF THE PARAMETERS 
*        SPECIFIED.  THE DRIVE IS RELEASED, AND A WRITE/
*        READ OF THE CYLINDER, TRACK AND SECTOR IS COMPLETED
*        WITHIN THE CONFINES OF THE PARAMETERS. 
*        THE ABOVE IS REPEATED 4096 TIMES.  IF THE ITERATION
*        COUNT IS SET, REPEAT 4096 TIMES FOR EACH COUNT IN
*        THE ITERATION REGISTER.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 35 - SURFACE TEST, TRACK MODE, 2/1 - 
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        THE TEST USES TWO SUBTESTS THAT WRITE AND WRITE/ 
*        READ CYLINDER P0 THRU CYLINDER P1, IN A 2/1 INTERLACE, 
*        TRACK MODE, ADDRESS CODED WITH RANDOM DATA 
*        PATTERNS.
*             SUBTESTS- 
*        1.  WRITES ADDRESS CODED, RANDOM DATA TO THE 
*            COMPLETE DISK SURFACE.  FLAWED AREAS ARE NOTED.
*        2.  GENERATES A NEW RANDOM DATA PATTERN AT THE 
*            BEGINING OF EACH RUN, WRITES AN ADDRESS CODED
*            TRACK, AND THEN READS THE TRACK JUST WRITTEN.
*            THE TEST SEQUENCES THROUGH THE TRACK AND THEN
*            CYLINDERS UNTIL THE DISK HAS BEEN WRITTEN AND
*            READ THE APPROPRIATE NUMBER OF TIMES.  FLAWS 
*            ARE NOT REPORTED.  THE CHANNEL IS RELEASED 
*            BETWEEN TRACKS.
* 
*             THE ABOVE TEST SEQUENCE WILL BE REPEATED
*             4 MORE TIMES, WITH THE MARGINS SET AS BELOW.
* 
*            A.  SET MARGINS OF READ EARLY/ CARRIAGE OFFSET 
*                REVERSE. 
*            B.  SET MARGINS OF READ LATE/ CARRIAGE OFFSET
*                REVERSE. 
*            C.  SET MARGINS OF READ EARLY/ CARRIAGE OFFSET 
*                FORWORD. 
*            D.  SET MARGINS OF READ LATE/ CARRIAGE OFFSET
*                FORWORD. 
* 
* 
*   MODULE 36 - SURFACE TEST, CYLINDER MODE, 1/1 -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        THE TEST USES TWO SUBTESTS THAT WRITE AND WRITE/ 
*        READ CYLINDER P0 THRU CYLINDER P1, AN A 1/1 INTERLACE
*        CYLINDER MODE, ADDRESS CODED WITH RANDOM DATA
*        PATTERNS.
*             SUBTESTS- 
*        1.  WRITES ADDRESS CODED, RANDOM DATA TO THE 
*            COMPLETE DISK SURFACE.  FLAWED AREAS ARE NOTED.
*        2.  GENERATES A NEW RANDOM DATA PATTERN AT THE 
*            BEGINING OF EACH RUN, WRITES AN ADDRESS CODED
*            TRACK, AND THEN READS THE TRACK JUST WRITTEN.
*            THE TEST SEQUENCES THROUGH THE TRACK AND THEN
*            CYLINDERS UNTIL THE DISK HAS BEEN WRITTEN AND
*            READ THE APPROPRIATE NUMBER OF TIMES.  FLAWS 
*            ARE NOT REPORTED.  THE CHANNEL IS RELEASED 
*            BETWEEN CYLINDERS. 
* 
*              THE ABOVE TEST SEQUENCE WILL BE REPEATED 
*              4 MORE TIMES, WITH THE MARGINS SET AS BELOW. 
* 
*            A.  SET MARGINS OF READ EARLY/ CARRIAGE OFFSET 
*                REVERSE. 
*            B.  SET MARGINS OF READ LATE/ CARRIAGE OFFSET
*                REVERSE. 
*            C.  SET MARGINS OF READ EARLY/ CARRIAGE OFFSET 
*                FORWORD. 
*            D.  SET MARGINS OF READ LATE/ CARRIAGE OFFSET
*                FORWORD. 
* 
*   MODULE 37 - HEAD TEST, TRACK GROUPS, 2/1 -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE TEST
*        WILL WRITE/READ AT 2/1 INTERLACE, THE LOWEST 
*        STARTING SECTOR, TRACK AND CYLINDER BY FIRST 
*        SEQUENCING THROUGH ALL SPECIFIED SECTORS AND 
*        CYLINDERS.  THE TRACK COUNT IS THEN INCREMENTED AND
*        THE ABOVE SEQUENCE REPEATED UNTIL THE PARAMETERS 
*        HAVE BEEN MEET.
*        THE CHANNEL IS RELEASED BETWEEN TRACKS.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
*   MODULE 38 - HEAD TEST, TRACK GROUPS, 1/1 -
*        CRACK PARAMETERS AND DETERMINE ACCESS LEVEL NEEDED.
*        WITHIN THE CONFINES OF THE PARAMETERS, THE TEST
*        WILL WRITE/READ AT 1/1 INTERLACE, THE LOWEST 
*        STARTING SECTOR, TRACK AND CYLINDER BY FIRST 
*        SEQUENCING THROUGH ALL SPECIFIED SECTORS AND 
*        CYLINDERS.  THE TRACK COUNT IS THEN INCREMENTED AND
*        THE ABOVE SEQUENCE REPEATED UNTIL THE PARAMETERS 
*        HAVE BEEN MET. 
*        THE CHANNEL IS RELEASED BETWEEN TRACKS.
* 
*        PARAMETERS- REPEAT CONDITION 
* 
* PART III MODULE DESCRIPTIONS
*                INDIVIDUAL MAINTENANCE 
* 
* 
*                            *********
*                            *CAUTION*
*                            *********
* 
*        IN PARAMETER DRIVEN MODULES WITH AN ACCESS LEVEL OF
*        4, DATA CAN BE DESTROYED ANYWHERE ON THE PACK. IT IS 
*        ADVISABLE NOT TO SWAP PACKS WHILE RUNNING THE
*        DIAGNOSTIC.
* 
* 
*   MODULE 40 - RESTART BUFFER CONTROLLER REPAIR TOOL - 
*        RESET THE BUFFER CONTROLLER FIRMWARE.  RESERVE THE 
*        CONTROLLER, OUTPUT FOUR WORDS OF RESTART ADDRESS,
*        GENERAL STATUS, AND RETURN THE CHANNEL.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 41 - PRESET WRITE PRORGRAM FOR MODULE 06 - 
*        ACCESS LEVEL OF 3 OR ABOVE.
*        CODE THE INNERMOST CYLINDER FOR A PRESET READ
*        PROGRAM.  RESERVE THE DRIVE, WRITES CODED ADDRESS, 
*        RANDOM DATA, IN TRACK MODE,  RELEASE CHANNEL.
*        CHANNEL RELEASED BETWEEN EACH TRACK INCREMENT. 
* 
*        PARAMETERS- REPEAT CONDITION.
* 
*   MODULE 42 - SEEK DISK ADDRESS - 
*        CRACK INPUT PARAMETERS. RESERVE DISK, SEEK ADDRESS,
*        RELEASE CHANNEL. 
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 43 - WRITE ONE SECTOR -
*        CRACK INPUT PARAMETERS, DETERMINE ACCESS LEVEL 
*        NEEDED.  RESERVE DRIVE, SEEK INPUT ADDRESS AND 
*        WRITE ONE SECTOR, RELEASE CHANNEL. 
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 44 - READ ONE SECTOR - 
*        CRACK INPUT PARAMETERS, DETERMINE ACCESS LEVEL 
*        NEEDED.  RESERVE DRIVE, SEEK INPUT ADDRESS AND 
*        READ ONE SECTOR, RELEASE CHANNEL.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 45 - WRITE AND READ ONE SECTOR - 
*        CRACK INPUT PARAMETERS, DETERMINE ACCESS LEVEL 
*        NEEDED.  RESERVE DRIVE, SEEK INPUT ADDRESS AND 
*        WRITE ONE SECTOR, SEEK INPUT ADDRESS AND READ
*        ONE SECTOR, RELEASE CHANNEL. 
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 46 - TOGGLE TEST - 
*        CRACK INPUT PARAMETERS, DETERMINE ACCESS LEVEL 
*        NEEDED.  RESERVE DRIVE, POSITION TO FIRST SET
*        OF INPUT PARAMETERS AND READ ONE SECTOR, 
*        POSITION TO THE SECOND SET OF INPUT PARAMETERS 
*        AND READ ONE SECTOR, RELEASE CHANNEL.
* 
*        PARAMETERS- SCOPE LOOP, REPEAT CONDITION.
* 
*   MODULE 47 - DEAD MAN TERMINATOR TEST -
*        ACCESS LEVEL OF 21 IS NEEDED.
*        RESERVE CHANNEL, GENERAL STATUS, OUTPUT A 4 PPU
*        WORD AUTO-LOAD SEQUENCE, AND WAIT FOR 2 TO 5 
*        SECONDS FOR THE DEAD MAN TERMINATOR TO DISCONNECT
*        THE CHANNEL.  RELEASE CHANNEL. 
* 
*        PARAMETERS- REPEAT CONDITION.
* 
*   MODULE 48 - READ AND PRINT FLAW MAPS -
*        READ AND PRINT THE DISK PACK SERIAL NUMBER FROM THE DISK 
*        PACK.  READ AND PRINT THE FACTORY AND UTILITY MAPS TO
*        IDENTIFY WHERE AND WHAT TYPE OF FLAWS EXIST IN EACH MAP. 
*        PERFORM A READ CHECKWORD OF THE ENTIRE DISK PACK IN 1:1
*        INTERLACE, TRACK MODE, AND PRINT THE ADDRESSES THAT
*        HAVE THE TRACK OR SECTOR FLAW BITS SET IN THE ADDRESS
*        FIELDS.  THIS MODULE PROVIDES A SCAN CAPABILITY ONLY AND 
*        DOES NOT PROVIDE THE ABILITY TO MODIFY OR WRITE ADDRESS
*        FIELDS.  DUE TO THE AMOUNT OF DATA GENERATED, IT SHOULD
*        BE EXECUTED IN BATCH OR TERMINAL MODE (NOT KL) SINCE NO
*        OUTPUT IS PROVIDED TO THE KL DISPLAY.
* 
*   MODULE 50 - COARSE POSITION PLOT
*        CHECK FOR DEVICE CODE OF DOUBLE DENSITY 844. SET UPPER 
*        CYLINDER LIMIT TO 256B. RESERVE DRIVE, SEEK TO CYLINDER
*        ZERO, THEN SEEK TO CYLINDER 256B. SAVE THE SEEK TIME 
*        AND REPEAT 44D TIMES. PLOT THE SEEKS.
* 
*   MODULE 51 - VELOCITY GAIN TIMING PLOT 
*        SET UPPER CYLINDER 632B FOR SINGLE DENSITY OR 1466B FOR
*        A DOUBLE DENSITY 844. RESERVE DRIVE, SEEK TO CYLINDER
*        ZERO, THEN SEEK TO UPPER CYLINDER. SAVE THE SEEK TIME
*        THEN SEEK BACK TO CYLINDER ZERO. SAVE THE SEEK TIME
*        AND REPEAT 44D TIMES. PLOT THE SEEKS.
* 
*   MODULE 52 - INTEGRATOR GAIN ADJUSTMENT
*        SET UPPER CYLINDER 64B FOR SINGLE DENSITY OR 32B FOR 
*        A DOUBLE DENSITY 844. RESERVE DRIVE, SEEK TO CYLINDER
*        ZERO, THEN SEEK TO UPPER CYLINDER. SAVE THE SEEK TIME
*        AND REPEAT 44D TIMES. PLOT THE SEEKS.
* 
*   MODULE 53 - FINE POSITION PLOT
*        CHECK FOR DEVICE CODE OF SINGLE DENSITY 844. SET UPPER 
*        CYLINDER LIMIT TO ONE. RESERVE DRIVE, SEEK TO CYLINDER 
*        ZERO, THEN SEEK TO CYLINDER ONE. SAVE THE SEEK TIME
*        AND REPEAT 44D TIMES. PLOT THE SEEKS.
* 
* 
* 
*   PARAMETER DESCRIPTION.
* 
*        P0 = LOWER CYLINDER  (RIGHT JUSTIFIED, ZERO FILLED)
* 
*        P1 = UPPER CYLINDER  (RIGHT JUSTIFIED, ZERO FILLED)
* 
*        P2 = (LLUU)   LL = LOWER/ UPPER TRACKS 
* 
*        P3 = (LLUU)   LL = LOWER/ UPPER SECTORS
* 
*        P4 = ENABLES 
*           BITS  0 - REPORT FLAWS
*                 1 - FULL INPUT BUFFER DUMP ON COMPARE 
*                     ERRORS. 
*                 2 - COMPARE DATA   (MODULES 30 THRU 32) 
*                                    (MODULES 37 AND 38)
*                 3 - CHANGE PATTERN ON TRACK BOUNDARIES. 
*                 4 - CHANGE PATTERN ON CYLINDER BOUNDARIES.
*                    *IF NEITHER TRACK OR CYLINDER
*                     BOUNDARIES ARE SET, THE PATTERN CHANGE
*                     WILL DEFAULT TO DISK BOUNDARIES.
* 
*        P5 = DISABLES
*           BITS  0 - ADDRESS CODING
*                 1 - READ
*                 2 - WRITE 
*                 3 - RANDOM DATA TO BUFFER 
*                 4 - RESET COMMAND 
* 
*        P6 = DATA CONTROL
*          (ZERO - AND RANDOM DATA SET (BIT 3 CLEAR IN P5)
*                  THE RANDOM START KEY WORD WILL COME FROM 
*                  THE REAL TIME CLOCK. 
*          (NON-ZERO) - AND RANDOM DATA SET (BIT 3 CLEAR IN 
*                       P5) THE RANDOM START WILL USE THIS
*                       DATA CONTROL WORD AS THE KEY START
*                       WORD. 
*          (NON-ZERO) - AND RANDOM DATA DISABLED (BIT 3 SET 
*                       IN P5) THE BUFFER WILL BE FILLED
*                       WITH THIS FIXED DATA CONTROL WORD.
* 
*        P7 = (00YX) MARGINS
* 
*                   Y = STROBES         X = OFFSETS 
*                  NORMAL  000X        NORMAL  00Y0 
*                  EARLY   001X        FORWARD 00Y1 
*                  LATE    002X        REVERSE 00Y2 
* 
*        P8 = ITERATION COUNT 
*          (ITERATION COUNT TIMES 4096 IF RANDOM COUNT) 
* 
* 
* MODULE CONTROLWARE LEVELS SUPPORTED 
* 
*     MALET DRIVER SUPPORTS LEVEL A07 AND ABOVE. PREVIOUS 
*     LEVELS MAY HAVE PROBLEMS. 
* 
* MODULE RUNNING MESSAGES 
* 
*     1.  MMMMM  (MODULE DESCRIPTION)  PASS COUNT 
*     2.  MMMMM  (MODULE DESCRIPTION)  DATA BEING USED
*     3.  MMMMM  (MODULE DESCRIPTION) 
*     4.  MMMMM  CYL (NUMBER), TRK (NUMBER), SEC (NUMBER) 
*               MMMMM = MODULE NAME.
* 
* 
* MODULE ERROR MESSAGES 
* 
*                                                                        D44009J
*         THE FIRST 4 MODULES OF THE CONFIDENCE TEST DO NOT REFERENCE    D44009J
*         THE DISK UNIT - THEY ONLY TEST THE STATUS/DATA PATH TO THE     D44009J
*         CONTROLLER.  EACH OF THESE MODULES HAS ITS OWN ERROR MESSAGE   D44009J
*         PROCESSOR THAT REPORTS THE LAST FUNCTION ISSUED, EXPECTED      D44009J
*         AND ACTUAL STATUS OR DATA.                                     D44009J
*                                                                        D44009J
*         ALL MODULES OF D44 THAT REFERENCE THE DISK UNIT CALL A COMMON  D44009J
*         ERROR PROCESSOR TO PRESENT ERROR DATA TO THE USER.  THE EXACT  D44009J
*         CONTENT OF THAT DATA DEPENDS UPON THE NATURE OF THE FAILURE.   D44009J
*         SOME TYPICAL EXAMPLES ARE PROVIDED BELOW, THEN A COMPLETE      D44009J
*         LIST OF POSSIBLE SYMPTOM CODE MESSAGES ARE PROVIDED.
*                                                                        D44009J
*      1. TYPICAL ERROR OUTPUT WITH NO RECOVERY ATTEMPTED.               D44009J
*                                                                        D44009J
*          D44 ERROR IN MODULE 0008 AT LINE 0023                         D44009J
*                                                                        D44009J
*           D4408  ER4525 L023  ABNORMAL GENERAL STATUS                  D44009J
*           WT=0000  LF=0000  RETRIES=0000  ERRORS=0001                  D44009J
*           OB(0-7)  =0000 0000 0000 0000 3501 3502 2707 5620            D44009J
*           IB(0-7)  =0000 0000 0000 0000 0000 0000 0000 0000            D44009J
*           B0 - B7  =0474 0100 0000 0001 0030 0000 0000 1464            D44009J
*           CYL=1464 TRK=0000 SEC=0000  LAST SEEK=0000 MSEC              D44009J
*                                                                        D44009J
*             LAST GENERAL STATUS = 5020                                 D44009J
*           DS(1-8)  =0000 0000 0000 1306 0000 0000 0000 0000            D44009J
*           DS(9-16) =2744 3201 7760 0000 0000 0000 0000 0000            D44009J
*           DS(17-20)=0000 0000 0000 0000                                D44009J
*          SC310- DSU BRUSH CYCLE IS STILL IN PROGRESS
*          --------------------------------------------------            D44009J
*                                                                        D44009J
*                                                                        D44009J
*         ER4525   = PRODUCT OVERLAY ERROR CODE                          D44009J
*         L023     = LINE NUMBER WITHIN THE MODULE WHERE THE ERROR WAS   D44009J
*                    DETECTED                                            D44009J
*         WT       = WORDS TRANSMITTED ON THE LAST I/O OPERATION         D44009J
*         LF       = LAST FUNCTION ISSUED TO THE DISK SUBSYSTEM          D44009J
*         RETRIES  = NUMBER OF CONTINUE FUNCTIONS ISSUED DURING ERROR    D44009J
*                    RECOVERY                                            D44009J
*         ERRORS   = NUMBER OF ERRORS REPORTED THUS FAR BY THE CURRENT   D44009J
*                    MODULE                                              D44009J
*         OB       = FIRST 8 WORDS OF THE OUTPUT BUFFER                  D44009J
*         IB       = FIRST 8 WORDS OF THE INPUT BUFFER                   D44009J
*         B0-B7    = REGISTERS B0 THRU B7                                D44009J
*         CYL      = CURRENT OCTAL CYLINDER NUMBER                       D44009J
*         TRK      = CURRENT OCTAL TRACK NUMBER                          D44009J
*         SEC      = CURRENT OCTAL SECTOR NUMBER                         D44009J
*         LAST SEEK= TIME REQUIRED TO PERFORM THE LAST SEEK OPERATION    D44009J
*         DS       = 20 DECIMAL WORDS OF DETAIL STATUS                   D44009J
*                                                                        D44009J
*                                                                        D44009J
*                                                                        D44009J
*      2. TYPICAL ERROR OUTPUT WITH SUCCESSFUL RECOVERY.                 D44009J
*                                                                        D44009J
*          D44 ERROR IN MODULE 0017 AT LINE 0023                         D44009J
*                                                                        D44009J
*           D4417  ER4530 L023  SUCCESSFUL RETRY                         D44009J
*           WT=0502  LF=0014  RETRIES=0001  ERRORS=0001                  D44009J
*           OB(0-7)  =0000 0000 0000 0000 0000 0000 0000 0000            D44009J
*           IB(0-7)  =0100 0000 1404 2200 0015 0000 1430 0000            D44009J
*           B0 - B7  =0000 0210 0000 0001 0027 0000 0000 0000            D44009J
*           CYL=0000 TRK=0000 SEC=0000  LAST SEEK=0000 MSEC              D44009J
*                                                                        D44009J
*             SUCCESSFUL RECOVERY - FIRST GENERAL STATUS=4600            D44009J
*           DS(1-8)  =0020 1000 0100 1306 0000 0000 0000 0000            D44009J
*           DS(9-16) =0740 4001 7560 0000 2100 0012 0000 6074            D44009J
*           DS(17-20)=6060 1012 0100 1412                                D44009J
*           DATA ERROR CORRECTION ADDR=0100 1ST=0012 2ND=0000            D44009J
*          SC104- CORRECTABLE DATA ERROR
*          --------------------------------------------------            D44009J
*                                                                        D44009J
*                                                                        D44009J
*                                                                        D44009J
*         ADDR = FIRST WORD IN THE INPUT BUFFER WHERE ERROR              D44009J
*                CORRECTION MUST BE APPLIED TO CORRECT THE DATA READ     D44009J
*                BY THE PP.                                              D44009J
*         1ST  = FIRST DATA WORD TO EXCLUSIVE OR WITH THE (ADDR) TO      D44009J
*                CORRECT THE DATA JUST READ.                             D44009J
*         2ND  = SECOND DATA WORD TO EXCLUSIVE OR WITH THE (ADDR+1) TO   D44009J
*                CORRECT THE DATA JUST READ.                             D44009J
*                                                                        D44009J
*                                                                        D44009J
*      3. TYPICAL ERROR OUTPUT WITH UNSUCCESSFUL RECOVERY.               D44009J
*                                                                        D44009J
*          D44 ERROR IN MODULE 0017 AT LINE 0023                         D44009J
*                                                                        D44009J
*           D4417  ER4525 L023  ABNORMAL GENERAL STATUS                  D44009J
*           WT=0502  LF=0014  RETRIES=0033  ERRORS=0003                  D44009J
*           OB(0-7)  =0000 0000 0000 0000 0000 0000 0000 0000            D44009J
*           IB(0-7)  =0005 0100 0000 0000 0000 0000 0000 0000            D44009J
*           B0 - B7  =0000 0210 0000 0011 0017 0010 0000 0000            D44009J
*           CYL=0000 TRK=0000 SEC=0010  LAST SEEK=0000 MSEC              D44009J
*                                                                        D44009J
*             UNSUCCESSFUL RECOVERY-FIRST GENERAL STATUS=4600            D44009J
*           DS(1-8)  =0020 1400 0100 1306 0000 0400 0000 0000            D44009J
*           DS(9-16) =0740 4001 7560 0000 2000 0000 0000 6074            D44009J
*           DS(17-20)=6060 1012 0100 1412                                D44009J
*                                                                        D44009J
*             LAST GENERAL STATUS = 5201                                 D44009J
*           DS(1-8)  =0700 1400 0100 1306 0000 0400 0000 0000            D44009J
*           DS(9-16) =0740 4001 7560 0000 2000 0000 0000 6074            D44009J
*           DS(17-20)=6060 1012 0300 5014                                D44009J
*          SC215- UNCORRECTABLE DATA CHECKWORD ERROR
*          --------------------------------------------------            D44009J
*                                                                        D44009J
*                                                                        D44009J
*      THE FOLLOWING MESSAGES REPRESENT ERRORS DETECTED BY THE 844       D44009J
*      PRODUCT OVERLAYS AND CAUSE COMMANDS TO BE ABORTED.                D44009J
*                                                                        D44009J
*       D44XXX ER4504 LYYY  WC OR BUFFER INDEX ERROR                     D44009J
*       D44XXX ER4510 LYYY  I/O CH NOT ASSIGNED                          D44009J
*       D44XXX ER4511 LYYY  I/O CH ACTIVE FROM SYSTEM                    D44009J
*       D44XXX ER4512 LYYY  NO INACTIVE TO LAST FUNC.                    D44009J
*       D44XXX ER4513 LYYY  NO INACTIVE TO GENERAL STATUS                D44009J
*       D44XXX ER4514 LYYY  NO INACTIVE TO DETAIL STATUS                 D44009J
*       D44XXX ER4515 LYYY  GENERAL STATUS NOT RETURNED                  D44009J
*       D44XXX ER4516 LYYY  INCOMPLETE STATUS RETURNED                   D44009J
*       D44XXX ER4517 LYYY  FUNCTION PARAMETERS NOT ACCEPTED             D44009J
*       D44XXX ER4520 LYYY  ALL DATA NOT ACCEPTED FROM PP                D44009J
*       D44XXX ER4521 LYYY  INCOMPLETE DATA RETURNED TO PP               D44009J
*       D44XXX ER4520 LYYY  CONTROLLER/UNIT NOT CONNECTED                D44009J
*       D44XXX ER4523 LYYY  ACCESS LEVEL TOO LOW FOR REQUEST             D44009J
*       D44XXX ER4524 LYYY  NO RESERVE IN 5 MINUTES                      D44009J
*       D44XXX ER4525 LYYY  ABNORMAL GENERAL STATUS                      D44009J
*       D44XXX ER4526 LYYY  ILLEGAL STROBE/OFFSET                        D44009J
*       D44XXX ER4527 LYYY  UNIT HUNG BUSY ON SEEK                       D44009J
*       D44XXX ER4530 LYYY  SUCCESSFUL RETRY                             D44009J
*       D44XXX ER4531 LYYY  DATA COMPARE ERROR                           D44009J
*       D44XXX ER4532 LYYY  DEVICE CODE/STATUS MISMATCH                  D44009J
*                                                                        D44009J
*          XXX = MODULE/SUBMODULE NUMBER                                 D44009J
*          YYY = LINE NUMBER WITHIN MODULE WHERE ERROR WAS DETECTED      D44009J
*                                                                        D44009J
*                                                                        D44009J
*      THE FOLLOWING MESSAGES REPRESENT SYMPTOM CODES THAT ARE REPORTED 
*      AS THE LAST LINE OF ERROR OUTPUT AS A RESULT OF STATUS ANALYSIS.  D44009J
*      ONLY ONE ERROR, THE MOST SERIOUS, IS REPORTED.                    D44009J
*                                                                        D44009J
*      IF NO RECOVERY HAS BEEN ATTEMPTED (RETRY COUNT IS ZERO), THE      D44009J
*      LAST GENERAL/DETAIL STATUS IS ANALYZED TO PRODUCE ONE OF THE      D44009J
*      FOLLOWING MESSAGES.  HOWEVER, IF RECOVERY HAS BEEN PERFORMED,     D44009J
*      THE FIRST TAKEN STATUS IS ANALYZED (THE REASON RECOVERY WAS       D44009J
*      REQUIRED) AND THE LAST TAKEN STATUS IS PROVIDED FOR CE ANALYSIS   D44009J
*      AS REQUIRED IF THE RECOVERY WAS UNSUCCESSFUL.                     D44009J
*                                                                        D44009J
*       SC100- COUPLER IS RESERVED TO OPPOSITE ACCESS 
*       SC101- DSU IS RESERVED TO OPPOSITE ACCESS 
*       SC102- DSC CHANNEL PARITY ERROR 
*       SC103- WRITE VERIFY FAILURE 
*       SC104- ADDRESS OR DATA FIELD COMPARE ERROR
*       SC105- ABNORMAL TERMINATION, NO CAUSE DETECTED
* 
*       SC200- DSC MEMORY PARITY ERROR
*       SC201- DSC DETECTED ILLEGAL COMMAND/PARAMETER 
*       SC202- DSC DEADMAN TIMER EXPIRED
*       SC203- DSC DETECTED HARDWARE ERROR
*       SC204- TRACK FLAW 
*       SC205- SECTOR FLAW
*       SC206- ADDRESS SYNC ERROR 
*       SC207- CORRECTABLE ADDRESS CHECKWORD ERROR
*       SC208- UNCORRECTABLE ADDRESS CHECKWORD ERROR
*       SC209- ADDRESS COMPARE ERROR - INCORRECT CYLINDER 
*       SC210- ADDRESS COMPARE ERROR - INCORRECT TRACK
*       SC211- ADDRESS COMPARE ERROR - INCORRECT SECTOR 
*       SC212- ADDRESS COMPARE ERROR - CAUSE NOT DEFINED
*       SC213- DATA SYNC ERROR
*       SC214- CORRECTABLE DATA CHECKWORD ERROR 
*       SC215- UNCORRECTABLE DATA CHECKWORD ERROR 
*       SC216- LOST DATA
*       SC217- SECTOR LENGTH ERROR (SEE WT REGISTER)
*       SC218- WRITE ERROR
*       SC230- DSC LOST DSU CLOCK 
*       SC231- DSC PROCESSOR TIMEOUT
*       SC232- DSC BUFFER MEMORY PARITY ERROR 
*       SC233- DSC DETECTED DATA PARITY ERROR 
* 
*       SC300- DSU IS NOT ON-LINE 
*       SC301- DSU IS NOT SELECTED
*       SC302- DSU POWER SUPPLY TEMPERATURE IS ABNORMAL 
*       SC303- DSU LOGIC TEMPERATURE IS ABNORMAL
*       SC304- DSU POSITIVE VOLTAGE IS ABNORMAL 
*       SC305- DSU NEGATIVE VOLTAGE IS ABNORMAL 
*       SC306- DSU DOES NOT HAVE A DISK PACK MOUNTED
*       SC307- DSU SECTOR BLOCK IS NOT IN POSITION (LID)
*       SC308- DSU START SWITCH IS NOT ON 
*       SC309- DSU SPINDLE MOTOR IS NOT ON
*       SC310- DSU BRUSH CYCLE IS STILL IN PROGRESS 
*       SC311- DSU HEADS ARE NOT LOADED BUT PACK IS SAFE
*       SC312- DSU HEADS UNLOADED DUE TO PACK UNSAFE
*       SC313- DSU SEEK ERROR BUT IT IS ON CYLINDER 
*       SC314- DSU SEEK ERROR AND NOT ON CYLINDER 
*       SC315- DSU WRITE AND READ ATTEMPTED AT SAME TIME
*       SC316- DSU CURRENT FAULT
*       SC317- DSU DATA TRANSFER WHILE NOT ON CYLINDER
*       SC318- DSU DISK PACK IS UNSAFE
*       SC319- DSU NOT READY
*       SC320- DSU MALFUNCTION BUT NO CAUSE DETERMINED
*       SC321- DSU INTERLOCK PROBLEM
*       SC322- DSU IS BUSY
*       SC323- DSU HUNG BUSY ON A SEEK TO CYLINDER XXXX 
*                                                                        D44009J
*                                                                        D44009J
*                                                                        D44009J
* DATA COMPARE ERROR MESSAGES                                            D44009J
*                                                                        D44009J
*         IF A DATA MIS-COMPARE IS DETECTED BETWEEN THE OUTPUT BUFFER    D44009J
*         AND INPUT BUFFER, THE FIRST FOUR NON-COMPARE WORDS ARE         D44009J
*         REPORTED IN THE FOLLOWING FORMAT.                              D44009J
*                                                                        D44009J
*                           // DATA COMPARE ERROR //                     D44009J
*           WORD=XXXX  EXPECTED=XXXX  ACTUAL=XXXX  DIFF=XXXX             D44009J
*                                                                        D44009J
*         IF THE USER HAS SET BIT 1 OF P4 (ENABLE FULL DUMP OF THE       D44009J
*         INPUT BUFFER ON DATA COMPARE ERRORS), 502 OCTAL WORDS OF THE   D44009J
*         INPUT BUFFER ARE DUMPED IN THE FOLLOWING FORMAT.               D44009J
*                                                                        D44009J
*           IB(0000) - IB(0077) IS BELOW                                 D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                              .                                         D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                                                                        D44009J
*           IB(0100) - IB(0177) IS BELOW                                 D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                              .                                         D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                                                                        D44009J
*                              .                                         D44009J
*                              .                                         D44009J
*           IB(0400) - IB(501) IS BELOW                                  D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                              .                                         D44009J
*                XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX                 D44009J
*                XXXX XXXX                                               D44009J
*                                                                        D44009J
*                                                                        D44009J
* DAYFILE ERROR MESSAGES                                                 D44009J
*                                                                        D44009J
*         THE FOLLOWING MESSAGE IS ISSUED TO THE SYSTEM DAYFILE BY       D44009J
*         ANY MODULE THAT DETECTS ERRORS. (MMMMM IS THE MODULE NUMBER)   D44009J
*                                                                        D44009J
*             MMMMM  ERROR(S) IN MODULE                                  D44009J
*                                                                        D44009J
*                                                                        D44009J
*                                                                        D44009J
* PARAMETER ERROR MESSAGES                                               D44009J
*                                                                        D44009J
*         MMMMM = MODULE NAME                                            D44009J
*         XXXX  = CONTENTS OF THE PARAMETER REGISTER                     D44009J
*                                                                        D44009J
*         MMMMM - LOWER CYLINDER PARAM ERROR  P0 = XXXX                  D44009J
*         MMMMM - UPPER CYLINDER PARAM ERROR  P1 = XXXX                  D44009J
*         MMMMM - LOWER GREATER THAN UPPER CYLINDER                      D44009J
*         MMMMM - READ AND WRITE BOTH DISABLED                           D44009J
*         MMMMM - LOWER GREATER THAN UPPER SECTOR                        D44009J
*         MMMMM - LOWER GREATER THAN UPPER TRACK                         D44009J
*         MMMMM - TRACK PARAM ERROR  P2 = XXXX                           D44009J
*         MMMMM - SECTOR PARAM ERROR  P3 = XXXX                          D44009J
*         MMMMM - ERROR IN MARGIN COMMAD  P7 = XXXX                      D44009J
*                                                                        D44009J
* SCOPE LOOP MESSAGES                                                    D44009J
*                                                                        D44009J
*         LC=NNNN,EC=MMMM, SCOPE LOOP                                    D44009J
*                    OR                                                  D44009J
*         LC=NNNN, SCOPE LOOP                                            D44009J
*                                                                        D44009J
*           LC    = LOOP COUNT                                           D44009J
*           NNNN  = NUMBER OF TIMES THROUGH THE LOOP                     D44009J
*           EC    = ERROR COUNT                                          D44009J
*           MMMM  = NUMBER OF ERRORS FOUND                               D44009J
*                                                                        D44009J
*                                                                        D44009J
* 
   MODULE D4400,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         RESERVE CONTROLLER. 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE CONTROLLER. 
*         3.  RELEASE CHANNEL AND CONTROLLER. 
*         4.  IF SCOPING LOOP TURNED ON, DISPLAY LOOPING
*             MESSAGE AND RETURN TO 2.
*         5.  REPEAT LOOP FROM 1 TO 5, 10 TIMES.
*         6.  IF REPEAT CONDITION TURNED ON, REPEAT 1 
*             THROUGH 6, REPORTING ERRORS 
*         7.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
*  REGISTER USAGE 
* 
*         B1 = LOOP COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         WC = ERROR COUNTER. 
* 
* 
 1 FORMAT D4400 RESERVE CONTROLLER
 2 FORMAT LC=*DEC,EC=*DEC, SCOPE LOOP 
 3 FORMAT D4400 - ERROR(S) IN MODULE
 4 FORMAT FNC= *OCT, SB= *OCT 
 5 FORMAT RESTART COMMAND EXECUTED
20 B1 = 0                        *LOOP COUNT
   B2 = 0                        *SCOPE LOOP COUNT
   WC = 0                        * ERROR COUNT
   MSG 1 TO DISPLAY, PRINT
21 MSG 1 TO DISPLAY 
22 RES CONTROLLER, ABT 60 
   IF (ES AND SL EQ SL) GOTO 65  *IF SCOPE LOOP 
   REL, ABT 60
24 GOTO 21 WHILE(B1+1 LE 10D)    *LOOP 10 TIMES 
   IF (ES AND RC EQ RC) GOTO 21  *IF REPEAT CONDITON
   IF (WC EQ 0) GOTO 30          *IF NO ERRORS
   MSG 3 TO DAYFILE 
30 PICTURE
   EXIT 
/        PROCESS ERRORS 
60 WC = WC+1                     *ERROR COUNT 
   IF (ES AND SL EQ SL) GOTO 65  *SCOPING LOOP
   MSG EM TO LINE 1 
   MSG 4 (LF SB) TO LINE 3
   PICTURE
   HALT 
   BLANK                           *CLEAR SCREEN
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB NE 7777B) GOTO 21        *IF CORRECT STATUS 
   RES CONTROLLER, ABT 61 
61 RESET, ABT 60
   REL, ABT 60
   MSG 5 TO LINE 1                 *RESTART MESSAGE 
   PICTURE AND BLANK
62 GOTO 21
/         SCOPE LOOP
65 B2 = B2+1
   MSG 2 (B2 WC) TO DISPLAY 
   GOTO 22
   END 20 
COMPILE 
   MODULE D4401,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        GENERAL STATUS 
* 
*         1.  DISPLAY MODULE FUNCTION AND PASS COUNT. 
*         2.  RESERVE CONTROLLER. 
*         3.  GENERAL STATUS CONTROLLER AND SAVE IN THE 
*             OUTPUT BUFFER.
*         4.  GENERAL STATUS CONTROLLER 1000 TIMES, COMPARE 
*             STATUS READ TO STATUS SAVED.
*         5.  RELEASE CHANNEL.
*         6.  REPEAT THE ABOVE SEQUENCE 4 TIMES.
*         7.  REPEAT CONDITION LOOP FROM 1 THROUGH 5. 
*         8.  SCOPE LOOP FROM 2 THROUGH 4, DISPLAY LOOP 
*             MESSAGE AND NOT REPORTING ERRORS. 
*         9.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
*    REGISTER USAGE 
* 
*         B1 = INNER PASS COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = MAIN PASS COUNTER. 
*         B4 = STATUS DIFFERENCE. 
*         WC = ERROR COUNTER. 
* 
* 
 1 FORMAT D4401 GENERAL STATUS *DEC 
 2 FORMAT LC=*DEC,EC=*DEC, SCOPE LOOP 
 3 FORMAT D4401 - ERROR(S) IN MODULE
 4 FORMAT FNC= *OCT, SB= *OCT, SAVE= *OCT, DIFF= *OCT 
 5 FORMAT RESTART COMMAND EXECUTED
20 B1 = 0                       *INNER PASS COUNT 
   B2 = 0                       *SCOPE LOOP COUNT 
   B3 = 0                       *PASS COUNT 
   WC = 0 
   MSG 1 TO DISPLAY,PRINT 
21 MSG 1 TO DISPLAY 
22 RES CONTROLLER, ABT 60 
   STATUS GENERAL, ABT 60 
   OB = SB                       *SAVE GENERAL STATUS 
23 IF (ES AND SL EQ SL) GOTO 25  *IF SCOPING, NO DISPLAY
   MSG 1 (B1) TO DISPLAY         *DISPLAY INNER PASS COUNT
25 STATUS GENERAL, ABT 60 
   IF (SB NE OB) GOTO 60           *IF DIFFERENT STATUS 
26 GOTO 23 WHILE(B1+1 LE 200D)   *LOOP
27 B1 = 0                          *CLEAR INNER PASS COUNT
   IF (ES AND SL EQ SL) GOTO 65    *IF SCOPING LOOP 
   REL, ABT 60
   GOTO 21 WHILE(B3+1 LE 20D)    *MAKE 20 PASSES
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
   IF (WC EQ 0) GOTO 30            *IF NO ERRORS
   MSG 3 TO DAYFILE 
30 PICTURE
   EXIT 
/         PROCESS ERRORS
60 WC = WC+1                       *ERROR COUNTER 
   IF (ES AND SL EQ SL) GOTO 65    *IF SCOPING LOOP 
   MSG EM TO LINE 1 
   B4 = SB XOR OB 
   MSG 4 (LF SB OB B4) TO LINE 3
   PICTURE
   HALT 
   BLANK
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB NE 7777B) GOTO 27        *IF CORRECT STATUS 
   RES CONTROLLER, ABT 61 
61 RESET, ABT 60
   REL, ABT 60
   MSG 5 TO LINE 1                 *RESTART MESSAGE 
   PICTURE AND BLANK
62 GOTO 27
/         SCOPE LOOP
65 B2 = B2+1
   MSG 2 (B2 WC) TO DISPLAY 
   GOTO 22
   END 20 
COMPILE 
   MODULE D4402,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         DETAIL STATUS 
* 
*         1.  DISPLAY MODULE FUNCTION AND PASS COUNT. 
*         2.  RESERVE CONTROLLER. 
*         3.  DETAIL STATUS CONTROLLER AND SAVE IN THE
*             OUTPUT BUFFER.
*         4.  DETAIL STATUS CONTROLLER 1000 TIMES, COMPARE
*             STATUS READ TO STATUS SAVED.
*         5.  RELEASE CHANNEL.
*         6.  REPEAT THE ABOVE SEQUENCE 4 TIMES.
*         7.  REPEAT CONDITION LOOP FROM 1 THROUGH 5. 
*         8.  SCOPE LOOP FROM 2 THROUGH 4, DISPLAY LOOP 
*             MESSAGE AND NOT REPORTING ERRORS. 
*         9.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
*    REGISTER USAGE 
* 
*         B0 = DISPLAY LINE COUNTER.
*         B1 = INNER LOOP COUNTER.
*         B2 = BUFFER INDEX COUNTER.
*         B3 = COMPARE REGISTER.
*         B4 = MAIN LOOP COUNTER. 
*         B5 = SCOOP LOOP COUNTER.
*         B7 = NUMBER OF STATUS WORDS TO COMPARE. 
*         WC = ERROR COUNTER. 
* 
 1 FORMAT D4402 DETAILED STATUS *DEC
 2 FORMAT LC=*DEC,EC=*DEC, SCOPE LOOP 
 3 FORMAT D4402 - ERROR(S) IN MODULE
 4 FORMAT FNC= *OCT, SB= *OCT, SAVE= *OCT, DIFF= *OCT 
 5 FORMAT RESTART COMMAND EXECUTED
20 B1 = 0                        *INNER PASS COUNT
   B4 = 0                        *OUTER PASS COUNT
   B7 = 20D                      *COMPARE WORDS 
   WC = 0 
   MSG 1 TO DISPLAY,PRINT 
21 MSG 1 TO DISPLAY 
22 RES CONTROLLER, ABT 60 
   STATUS DETAIL, ABT 60
   COPY SB(1) TO OB FOR 20D      *SAVE DETAILED STATUS
23 IF (ES AND SL EQ SL) GOTO 25  *IF SCOPING LOOP 
   MSG 1 (B1) TO DISPLAY         *DISPLAY LOOP COUNT
25 STATUS DETAIL, ABT 60
   B7 = 20D                      *COMPARE COUNT 
   OB(8) = SB(9)                                                         D44005G
   OB(9) = SB(10D)                                                       D44016J
   OB(22)=SB(23)                                                         D44004G
   OB(23)=SB(24)                                                         D44004G
   COMPARE SB(1) TO OB FOR B7, ABT 60 
26 GOTO 23 WHILE(B1+1 LE 200D)   *LOOP
   B1 = 0 
   IF (ES AND SL EQ SL) GOTO 75  *IF SCOPING LOOP 
   REL, ABT 60
   GOTO 21 WHILE(B4+1 LE 20D)    *MAKE 20 PASSES
   IF (ES AND RC EQ RC) GOTO 21  *IF REPEAT CONDITION 
   IF (WC EQ 0) GOTO 30          *IF NO ERROR 
   MSG 3 TO DAYFILE 
30 PICTURE
   EXIT 
/         PROCESS ERRORS
60 WC = WC+1                     *ERROR COUNTER 
   IF (ES AND SL EQ SL) GOTO 75  *IF SCOPE
   MSG EM TO LINE B0
   B2 = 0                        *BUFFER COMPARE COUNTER
62 B0 = B0+1
   B3 = SB(B2+1) XOR OB(B2) 
   MSG 4 (LF SB(B2+1) OB(B2) B3) TO LINE B0 
   GOTO 62 WHILE (B2+1 LE 19)                                            D44016J
   IF (WC.GE.12) GOTO 30                                                 D44016J
   PICTURE
   HALT 
   B0 = 0 
   BLANK
   ERROR 0/0                     *CLEAR ERROR 
   IF (SB EQ 7777B) GOTO 63      *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 21   *IF BC OK
63 RES CONTROLLER, ABT 64 
64 RESET, ABT 60
   REL, ABT 60
   MSG 5 TO LINE 1               *RESTART MESSAGE 
   PICTURE AND BLANK
65 GOTO 21
/         SCOPE LOOP
75 B5 = B5+1
   MSG 2 (B5 WC) TO DISPLAY 
   GOTO 22
   END 20 
COMPILE 
   MODULE D4403,844FT(02,03,04,05)LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        DIAGNOSTIC READ/WRITE CONTROLLER BUFFER
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE CONTROLLER. 
*         3.  DIAGNOSTIC READ THE CONTROLLER AND SAVE THE 
*             INPUT IN THE OUTPUT BUFFER. 
*         4.  DIAGNOSTIC READ THE CONTROLLER 50 TIMES 
*             COMPARING THE INPUT TO THE SAVED OUTPUT 
*             BUFFER. 
*         5.  RELEASE CHANNEL.
*         6.  DIAGNOSTIC WRITE A 5252, 2525, AND 2 RANDOM 
*             PATTERNS TO THE CONTROLLER AND DIAGNOSTIC 
*             READING EACH PATTERN, AND COMPARING 50 TIMES. 
*             THE CHANNEL IS RELEASED AND REQUESTED BETWEEN 
*             EACH DATA PATTERN.
*         7.  REPEAT CONDITION CAN BE LOOPED ON ANY ONE OF
*             THE DATA PATTERNS.
*         8.  SCOPE LOOP IS THE SAME AS THE REPEAT LOOP BUT 
*             NO ERROR MESSAGES AND NOT REPORTING ERRORS. 
*         9.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
*    REGISTER USAGE 
* 
*         B0 = TEST LOOP COUNTER. 
*         B1 = SUB TEST COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = ERROR COUNTER
*         B4 = OVERLAY SUBTEST COUNT
*         B5 = MAIN COUNTER 
*         B6 = ERROR WORD COUNT.
*         B7 = LINE COUNT.
*         WC = 502B BUFFER WORD COUNT.
* 
 1 FORMAT D4403 DIAGNOSTIC READ/WRITE BUFFER TEST 
 2 FORMAT LC=*DEC,EC=*DEC, SCOPE LOOP 
 3 FORMAT D4403 - ERROR(S) IN MODULE
 4 FORMAT OB(0-7) = *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT 
 5 FORMAT IB(0-7) = *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT 
 6 FORMAT ERR - WD= *OCT, AC= *OCT, EX= *OCT, DIFF= *OCT
 7 FORMAT B0 - B7 = *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT 
10 FORMAT D4403 R/W PATTERN = *OCT
11 FORMAT            // DATA COMPARE ERROR // 
20 WC = 500                         *BUFFER WORD COUNT
   B1 = 0                           *SUBTEST COUNTER
   B2 = 0                           *SCOPE LOOP COUNTER 
   B4 = 0                           *OVERLAY SUBTEST COUNTER
   MSG 1 TO DISPLAY,PRINT 
22 RES CONTROLLER, ABT 67           *READ LOOP
   DIAGRD, ABT 67                   *SAVE BUFFER
   COPY IB TO OB FOR WC 
23 B0 = 0                           *RESET LOOP COUNT 
24 IF (ES AND SL EQ SL) GOTO 25     *IF SCOPING LOOP
   MSG 10 (OB) TO DISPLAY 
25 DIAGRD, ABT 67                   *READ BUFFER
   COMPARE IB TO OB FOR WC, ABT 50  *COMPARE TO SAVED BUF 
   GOTO 24 WHILE (B0+1 LT 50D)      *LOOP 
   IF (ES AND SL EQ SL) GOTO 51     *IF SCOPE LOOP
   REL, ABT 67
26 IF (ES AND RC EQ RC) GOTO 22     *IF REPEAT CONDITION
27 DUP 5252 TO OB FOR WC            *SET TO 5252 PATTERN
   B1 = 1 
30 B0 = 0                           *RESET LOOP COUNTER 
   IF (ES AND SL EQ SL) GOTO 32     *IF SCOPE LOOP
31 MSG 10 (OB) TO DISPLAY 
32 RES CONTROLLER, ABT 67 
33 DIAGWR, ABT 67 
   DIAGRD, ABT 67 
   COMPARE IB TO OB FOR WC, ABT 50
   GOTO 33 WHILE (B0+1 LT 50D)      *LOOP 
   IF (ES AND SL EQ SL) GOTO 51     *IF SCOPE LOOP
   REL, ABT 67
   IF (ES AND RC EQ RC) GOTO 30     *IF REPEAT CONDITION
34 GOTO 35 WHILE (B1+1 GT 2)
   DUP 2525 TO OB FOR WC            *SET 2525 PATTERN 
   GOTO 30
35 IF (B1 EQ 4) GOTO 36             *IF SUBTEST = 3 
   RANDOM TO OB FOR WC              *SET RANDOM BUFFER
   GOTO 30
36 IF (B3 EQ 0) GOTO 37             *IF NO ERRORS 
   MSG 3 TO DAYFILE 
37 PICTURE
   EXIT 
40 WC = 500                         *RESET WORD COUNT 
   B1 = B4                          *RESTORE SUBTEST COUNT
41 IF (ES AND SL NE SL) GOTO 42     *IF NO SCOPE LOOP 
   GOSUB 75 
   GOTO 43
42 IF (ES AND RC EQ RC) GOTO 43     *IF REPEAT CONDITION
   GOTO 43 WHILE (B3+0 LT 4)        *FOUR ERROR LIMIT 
   GOTO 36
43 IF (B4 EQ 0) GOTO 22 
   IF (B4-1 EQ 0) GOTO 27 
   GOTO 32
50 WC = 500                         *RESET WORD COUNT 
51 IF (ES AND SL EQ SL) GOTO 41     *IF NO SCOPE LOOP 
   B3 = B3+1                        *ERROR COUNT
   B4 = B1                          *SAVE SUBTEST COUNT 
   GOSUB 60 
   GOTO 41
/         PROCESS MODULE ERROR
60 MSG EM TO LINE 0 
   MSG 11 TO LINE 1 
   B7 = 3 
   MSG 4(OB OB(1)OB(2)OB(3)OB(4)OB(5)OB(6)OB(7)) TO LINE B7 
   B7 = B7+1
   MSG 5(IB IB(1)IB(2)IB(3)IB(4)IB(5)IB(6)IB(7)) TO LINE B7 
   B7 = B7+1
   MSG 7(B0,B1,B2,B3,B4,B5,B6,B7) TO LINE B7
   B2 = 10
62 B5 = IB(B2) XOR OB(B2) 
   IF (B5 NE 0) GOTO 64 
63 GOTO 62 WHILE(B2+1 LE WC)
   GOTO 65
64 B7 = B7+1
   MSG 6(B2 IB(B2) OB(B2) B5) TO LINE B7
   GOTO 63 WHILE (B6+1 LT 4)    *4 ERROR LINES TO OUTOUT
65 PICTURE
   B6 = 0                       *RESET COMPARE ERROR LOOP 
   HALT 
   BLANK
   ERROR 0/0                    *CLEAR ERROR
   RES CONTROLLER, ABT 67 
   PICTURE AND BLANK
66 RETURN 
/         PROCESS OVERLAY ERROR 
67 B4 = B1                          *SAVE SUBTEST COUNT 
   IF (ES AND SL EQ SL) GOTO 41     *IF SCOPE LOOP
   B1 = 30
   CALL 98F                         *CALL ERROR PROCESSOR 
   GOTO 40
/         SCOPE LOOP SUBROUTINE 
75 B2 = B2+1                        *SCOPE LOOP COUNT 
   B3 = B3+1                        *ERROR COUNT
   MSG 2(B2 B3) TO DISPLAY
   RETURN 
   END 20 
COMPILE 
   MODULE D4404,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        SEEK CYLINDERS AND CHECK ADDRESS 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE CONTROLLER. 
*         3.  SEEK THE FIRST 7 CYLINDER ADDRESSES FROM
*             THE OUTPUT BUFFER 10 TIMES, READING THE 
*             CYLINDER ADDRESS FROM THE DISK AND COMPARING
*             IT TO THE SEEKED ADDRSS.
*         4.  RELEASE CHANNEL.
*         5.  REPEAT THE ABOVE SEQUENCE WITH 3 SETS OF DATA 
*             BUFFER CYLINDER ADDRESSES, AND 4 RANDOM SETS
*             OF CYLINDER ADDRESS, 1 TIME EACH. 
*         6.  REPEAT CONDITION WILL REPEAT ANY OF THE ABOVE 
*             SEQUENCES.
*         7.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
*    REGISTER USAGE 
* 
*         B0 = NUMBER OF CYLINDERS TO SEEK                               D44007J
*         B1 = MILLISECOND SEEK RATE.                                    D44007J
*         B2 = BUFFER INDEX COUNTER.                                     D44007J
*         B3 = ERROR COUNTER.                                            D44007J
*         B4 = LOOP COUNTER.                                             D44007J
*         B5 = CURRENT SECTOR.                                           D44007J
*         B6 = CURRENT TRACK.                                            D44007J
*         B7 = CURRENT CYLINDER                                          D44007J
*         WC = SET TO SINGLE OR DOUBLE DENSITY CYLINDER.                 D44007J
* 
* 
 1 FORMAT D4404 CYLINDER SEEK TEST
 3 FORMAT D4404 - ERROR(S) IN MODULE
 4 FORMAT CYLINDER ADDRESS EXPECTED = *OCT, RECEIVED = *OCT 
 5 FORMAT SEEK TIME TOO LONG - EXP=*DEC MSEC, ACT=*DEC MSEC              D44007J
 6 FORMAT D4404 - CYL *OCT, TRK *OCT, SEC *OCT
   DATA (OB,CON) 1,3,5,6,7,11,12,11 
   DATA (OB(20D),CON) 15,20,16,21,17,22,20,23,27,32,27
   DATA (OB(40D),CON) 20,40,63,45,70,100,120,145,167,200
20 WC = 632                  *SINGLE DENSITY                             D44007J
   IF (DC EQ 2) GOTO 21      *IF SINGLE DENSITY 
   IF (DC EQ 4) GOTO 21      *IF SINGLE DENSITY 
   WC = 1466                 *DOUBLE DENSITY                             D44007J
21 MSG 1 TO DISPLAY,PRINT 
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
22 B2 = 0                    *PASS 1
   B0 = 7                    *SET NUMBER OF SEEK CYLINDERS               D44007J
   B1 = 10D                  *MILLISECONDS                               D44007J
   GOSUB 50                  *SEEK MOVES
   GOTO 22 WHILE(B4+1 LE 10D)    *PASS 1 - 10 TIMES 
   IF (ES AND RC EQ RC) GOTO 22  *REPEAT CONDITION
32 B2 = 20D 
   B0 = 10D                  *SET NUMBER OF SEEKS                        D44007J
   B1 = 15D                  *MILLISECONDS                               D44007J
   GOSUB 50                  *SEEK MOVES
   IF (ES AND RC EQ RC) GOTO 32  *IF REPEAT 
35 B2 = 40D 
   B0 = 9D                   *SET NUMBER OF SEEKS                        D44007J
   B1 = 20D                  *MILLISECONDS                               D44007J
   GOSUB 50                  *SEEK MOVES
   IF (ES AND RC EQ RC) GOTO 35  *IF REPEAT 
   B4 = 0                    *RESET PASS COUNT
   B1 = 55D                  *MILLISECONDS                               D44007J
40 B0 = 60D                                                              D44007J
41 OB(B0) = RT.AND.1777                                                  D44007J
   IF(OB(B0) GT WC) GOTO 41  *IF NUMBER TOO LARGE                        D44007J
   GOTO 41 WHILE (B0+1 LT 71D)   *IF NOT FULL                            D44007J
   B2 = 60D 
   B0 = 10D                      *SET NUMBER OF SEEKS                    D44007J
   GOSUB 50                      *SEEK MOVES
   GOTO 40 WHILE (B4+1 LE 4)     *MAKE 4 RANDOM PASSES
   IF (ES AND RC EQ RC) GOTO 40  *IF REPEAT 
45 IF(B3 EQ 0) GOTO 46           *IF NO ERRORS                           D44007J
   MSG 3 TO DAYFILE 
46 PICTURE
   EXIT 
/         SEEK MOVES
50 RES DRIVE, ABT 60
/         SET FIRST CYLINDER
51 B7 = OB(B2)                   *CURRENT CYLINDER                       D44007J
   SEEK CYL B7 TRK B6 SEC B5, ABT 60                                     D44007J
/         RESET CYLINDER AND TIME SEEKS 
52 B7 = OB(B2)                                                           D44007J
   MSG 6 (B7 B6 B5) TO DISPLAY                                           D44007J
   SEEK CYL B7 TRK B6 SEC B5, ABT 60                                     D44007J
   RTNADDR TO IB, ABT 60
   IF(IB EQ.OB(B2)) GOTO 53      *IF RIGHT CYLINDER                      D44007J
   MSG 4 (OB(B2) IB) TO LINE 1                                           D44007J
   GOTO 60                                                               D44007J
53 IF(SB(60) LE B1) GOTO 54      *IF SEEK TIME OK                        D44007J
   MSG 5 (B1 SB(60)) TO LINE 1                                           D44007J
   GOTO 60                                                               D44007J
54 GOTO 52 WHILE (B2+1 LE B0)                                            D44007J
55 REL, ABT 60
   RETURN 
/         PROCESS ERROR SUBROUTINE
60 B1 = 40                                                               D44007J
   CALL 98A                      *CALL ERROR PROCESSOR                   D44007J
   RES DRIVE, ABT 60                                                     D44007J
   GOTO 54                                                               D44007J
   END 20 
COMPILE 
   MODULE D4405,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ SERIAL NUMBER/ FACTORY FLAW/ UTILITY FLAW 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  READ DISK SERIAL NUMBER SECTOR AND SAVE IN
*             THE OUTPUT BUFFER.  READ THE SERIAL NUMBER
*             SECTOR 10 TIMES COMPARING DATA READ WITH DATA 
*             SAVED.
*         4.  RELEASE CHANNEL.
*         5.  REPEAT THE ABOVE SEQUENCE WITH FACTORY AND
*             UTILITY FLAW SECTORS. 
*         6.  REPEAT CONDITION ON ANY OF THE ABOVE
*             SEQUENCES.
*         7.  A RESET CONTROLWARE COMMAND WILL BE EXECUTED
*             AFTER THE ERROR DISPLAY ON A HUNG BUFFER
*             CONTROLLER. 
* 
* 
*    REGISTER USAGE 
* 
*         B0 = LOOP COUNTER.
*         B2 = START OF COMPARE INDEX COUNTER.
*         B3 = ERROR COUNTER. 
*         B5 = CURRENT SECTOR                                            D44008J
*         B6 = CURRENT TRACK                                             D44008J
*         B7 = CURRENT CYLINDER                                          D44008J
* 
* 
 1 FORMAT D4405 READ FLAW MAPS
 3 FORMAT D4405 - ERROR(S) IN MODULE
 4 FORMAT DATA COMPARE ERROR ON SERIAL NUMBER SECTOR                     D44008J
 5 FORMAT DATA COMPARE ERROR ON FACTORY FLAW MAP SECTOR                  D44008J
 6 FORMAT DATA COMPARE ERROR ON UTILITY FLAW MAP SECTOR                  D44008J
10 FORMAT READ SERIAL NUMBER
11 FORMAT READ FACTORY FLAWS
12 FORMAT READ UTILITY FLAWS
20 WC = 322D
   MSG 1 TO DISPLAY,PRINT 
   B1 = 50
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 51 
   B7 = 632                                                              D44008J
   IF(DC EQ 2) GOTO 21             *IF SINGLE DENSITY                    D44008J
   IF(DC EQ 4) GOTO 21             *IF SINGLE DENSITY                    D44008J
   B7 = 1466                       *DOUBLE DENSITY                       D44008J
21 MSG 10 TO DISPLAY
   B1 = 50                                                               D44008J
   B5 = 0                                                                D44008J
   RES DRIVE, ABT 51                                                     D44008J
   GET SERIAL, ABT 51                                                    D44008J
   COPY IB TO OB FOR WC                                                  D44008J
22 GET SERIAL, ABT 51                                                    D44008J
   COMPARE IB TO OB FOR WC, ABT 23                                       D44008J
   GOTO 24                                                               D44008J
23 MSG 4 TO LINE 1           *REPORT COMPARE ERROR                       D44008J
   B1 = 51                                                               D44008J
   GOTO 51                                                               D44008J
24 GOTO 22 WHILE (B0+1 LT 10D)     *LOOP 10 TIMES                        D44008J
   B0 = 0                           *RESET LOOP COUNTER 
   REL, ABT 51
   IF (ES AND RC EQ RC) GOTO 21     *IF REPEAT CONDITION
26 MSG 11 TO DISPLAY
   B0 = 0                           *RESET LOOP COUNTER 
   B1 = 50                                                               D44008J
   B5 = 1                          *SECTOR 1                             D44008J
   RES DRIVE, ABT 52
   GET FACTORY, ABT 52                                                   D44008J
   COPY IB TO OB FOR WC                                                  D44008J
27 GET FACTORY, ABT 52                                                   D44008J
   COMPARE IB TO OB FOR WC, ABT 30                                       D44008J
   GOTO 31                                                               D44008J
30 MSG 5 TO LINE 1                 *REPORT COMPARE ERROR                 D44008J
   B1 = 51                                                               D44008J
   GOTO 52                                                               D44008J
31 GOTO 27 WHILE (B0+1 LT 10D)     *LOOP 10 TIMES                        D44008J
   REL, ABT 52
   B0 = 0                           *RESET LOOP COUNT 
   IF (ES AND RC EQ RC) GOTO 26     *IF REPEAT CONDITION
32 MSG 12 TO DISPLAY
   B0 = 0                           *RESET LOOP COUNT 
   B1 = 50                                                               D44008J
   B5 = 2                          *SECTOR 2                             D44008J
   RES DRIVE, ABT 53
   GET UTILITY, ABT 53                                                   D44008J
   COPY IB TO OB FOR WC                                                  D44008J
33 GET UTILITY, ABT 53                                                   D44008J
   COMPARE IB TO OB FOR WC, ABT 34                                       D44008J
   GOTO 35                                                               D44008J
34 MSG 6 TO LINE 1                 *REPORT COMPARE ERROR                 D44008J
   B1 = 51                                                               D44008J
   GOTO 53                                                               D44008J
35 GOTO 33 WHILE (B0+1 LT 10D)     *LOOP 10 TIMES                        D44008J
   REL, ABT 53
   IF (ES AND RC EQ RC) GOTO 32     *IF REPEAT CONDITON 
40 IF (B3 EQ 0) GOTO 42             *IF NO ERRORS 
41 MSG 3 TO DAYFILE 
42 PICTURE
   EXIT                             *END IT 
51 CALL 98A                         *CALL ERROR PROCESSOR                D44008J
   WC = 322D                                                             D44008J
   IF (ES AND RC EQ RC) GOTO 21     *IF REPEAT CONDITION
   GOTO 26                          *NEXT LEVEL 
52 CALL 98A                         *CALL ERROR PROCESSOR                D44008J
   WC = 322D                                                             D44008J
   IF (ES AND RC EQ RC) GOTO 26     *IF REPEAT CONDITION
   GOTO 32                          *NEXT LEVEL 
53 CALL 98A                         *CALL ERROR PROCESSOR                D44008J
   WC = 322D                                                             D44008J
   IF (ES AND RC EQ RC) GOTO 32     *IF REPEAT CONDITION
   GOTO 40                          *PROCESS END
   END 20 
COMPILE 
   MODULE D4406,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ INNERMOST CYLINDER
/        TRACK MODE AND COMPARE DATA
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE INNERMOST CYLINDER AND READ 
*             PRERECORDED CODED SECTORS IN TRACK MODE,
*             ONE SECTOR AT A TIME COMPARING RANDOM DATA. 
*             CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
*         6.  THE ENTIRE SEQUENCE IS REPEATED FOR ALL COMBINATIONS
*             OF STROBES AND OFFSETS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = STROBE/OFFSET MESSAGE NUMBER 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         B8 = READ CODED FLAG. 
*         B9 = ERROR FREE PASS FLAG.
*         B10 = FLAG TO ERROR PROCESSOR TO ISSUE MODULE 41 MESSAGE. 
*         B11 = TEMPORARY STORAGE.
*         B12 = TEMPORARY STORAGE.
*         B13 = TEMPORARY STORAGE.
*         B14 = TEMPORARY STORAGE.
* 
* 
 1 FORMAT D4406 READ INNERMOST CYLINDER 
 3 FORMAT D4406 - ERROR(S) IN MODULE
 4 FORMAT D4406 - CYL *OCT, TRK *OCT, SEC *OCT
 6 FORMAT   *A*A*A*A AT NORMAL OFFSET, NORMAL STROBES 
 7 FORMAT   *A*A*A*A AT NORMAL OFFSET, EARLY STROBES
10 FORMAT   *A*A*A*A AT NORMAL OFFSET, LATE STROBES 
11 FORMAT   *A*A*A*A AT FORWARD OFFSET, NORMAL STROBES
12 FORMAT   *A*A*A*A AT FORWARD OFFSET, EARLY STROBES 
13 FORMAT   *A*A*A*A AT FORWARD OFFSET, LATE STROBES
14 FORMAT   *A*A*A*A AT REVERSE OFFSET, NORMAL STROBES
15 FORMAT   *A*A*A*A AT REVERSE OFFSET, EARLY STROBES 
16 FORMAT   *A*A*A*A AT REVERSE OFFSET, LATE STROBES
20 MSG 1 TO PRINT 
   B0 = 474                  *COMPARE WORD COUNT
   B4 = 1                    *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 632                  *CURRENT CYLINDER
   IF(DC.EQ.2) GOTO 21      *IF 2X DRIVE
   IF(DC.EQ.4) GOTO 21      *IF 2X DRIVE
   B7 = 1466
21 B2 = 6 
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   GOSUB 22 
   B2 = 7 
   MARGINS NORMAL OFFSET EARLY STROBES, ABT 60
   GOSUB 22 
   B2 = 10
   MARGINS NORMAL OFFSET LATE STROBES, ABT 60 
   GOSUB 22 
   B2 = 11
   MARGINS FWD OFFSET NORMAL STROBES, ABT 60
   GOSUB 22 
   B2 = 12
   MARGINS FWD OFFSET EARLY STROBES, ABT 60 
   GOSUB 22 
   B2 = 13
   MARGINS FWD OFFSET LATE STROBES, ABT 60
   GOSUB 22 
   B2 = 14
   MARGINS REV OFFSET NORMAL STROBES, ABT 60
   GOSUB 22 
   B2 = 15
   MARGINS REV OFFSET EARLY STROBES, ABT 60 
   GOSUB 22 
   B2 = 16
   MARGINS REV OFFSET LATE STROBES, ABT 60
   GOSUB 22 
   GOTO 26                  *EXIT 
* 
*---------READ AND COMPARE DATA SUBROUTINE. 
* 
22 B11 = 5515                *DISPLAY CODE FOR MARGINS
   B12 = 0122 
   B13 = 0711 
   B14 = 1623 
   MSG B2 (B11,B12,B13,B14) TO PRINT     *REPORT ACTIVE MARGINS 
30 RES DRIVE, ABT 60
   MSG 4 (B7 B6 B5) TO DISPLAY
23 B8 = 1                    *READ CODED FLAG 
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR B0, START IB(4)
   COMPARE IB(5) TO OB(5) FOR B0, ABT 66
   B9 = 1                    *ERROR FREE PASS FLAG
24 B4 = 1 
   GOTO 23 WHILE(B5+2 LT 30)       *SECTOR COUNT
   IF (B5 EQ 31) GOTO 25           *IF LAST ODD SECTOR
   B5 = 1                          *EST ODD SECTOR
   GOTO 23                         *READ ODD SECTORS
25 REL, ABT 64
   B5 = 0                          *SET EVEN SECTOR 
   IF (ES AND RC EQ RC) GOTO 30    *REPEAT CONDITION
   GOTO 30 WHILE(B6+1 LE 22)       *TRACK COUNT 
   B6 = 0                   *RESET TRACK NUMBER 
   RETURN                   *EXIT SUBROUTINE
* 
*---------EXIT
* 
26 IF(B3.EQ.0) GOTO 27      *IF NO ERRORS 
   MSG 3 TO DAYFILE 
27 PICTURE
   EXIT 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 63B                        *RESTART NEEDED
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   B8 = 0                    *CLEAR READ CODED FLAG 
   IF (SB(6) AND 10 NE 0) GOTO 25  *IF TRACK FLAW 
63 RES DRIVE, ABT 60               *NEXT SECTOR 
   GOTO 24
64 B1 = 60B 
   IF(B8.NE.1) GOTO 65       *NOT CODED READ
67 IF(B9.EQ.1) GOTO 65       *ERROR FREE PASS ALREADY COMPLETED 
   B10 = 3                   *SET FLAG FOR MODULE 41 MESSAGE
   B8 = 0                    *CLEAR READ CODED FOR NEXT PASS
65 B11 = 5555                *DISPLAY CODE FOR ERROR
   B12 = 5505 
   B13 = 2222 
   B14 = 1722 
   MSG B2 (B11,B12,B13,B14) TO LINE 1    *REPORT ACTIVE MARGINS 
   CALL 98A                 *CALL ERROR PROCESSOR 
   B0 = 474                        *COMPARE WORD COUNT
   IF (ES AND RC EQ RC) GOTO 22    *REPEAT CONDITION
   GOTO 63                         *CONTINUE
66 B1 = 61B                        *COMPARE ERROR 
   GOTO 67
   END 20 
COMPILE 
   MODULE D4407,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ 7154 COUPLER BUFFER 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK FOR A 7154 CONTROLLER, IF NOT ABORT 
*             MODULE. 
*         3.  RESERVE DRIVE.
*             WRITE COUPLER BUFFER WITH A GIVEN PATTERN,
*             AND READ THE COUPLER BUFFER BACK AND COMPARE
*             5 TIMES.
*             RELEASE CHANNEL.
*         4.  THE ABOVE SEQUENCE IS EXECUTED WITH A 5252, 
*             2525, AND 20 RANDOM BUFFER PATTERNS.
*         5.  REPEAT CONDITION LOOPS ON ANY SEQUENCE. 
*         6.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98C FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = LOOP COUNTER.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = BUFFER SIZE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         WC = BUFFER SIZE. 
* 
 1 FORMAT D4407 READ COUPLER BUFFER 
 3 FORMAT D4407 - ERROR(S) IN MODULE
 5 FORMAT //D4407 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
 6 FORMAT D4407 RUNS ONLY ON 7154 CONTROLLERS 
 7 FORMAT D4407 R/W PATTERN = *OCT
10 FORMAT D4407 REQUIRES FT CW - DS WD4=*OCT. 
20 MSG 1 TO DISPLAY, PRINT
   IF (AL GE 3) GOTO 21      *IF ACCESS GOOD
   MSG 5 (AL) TO LINE 1 
   GOTO 32                   *END IT
21 WC = 500                  *READ BUFFER SIZE
   B4 = 1                    *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 40      *IF 7054 CONTROLLER
   IF (DC EQ 3) GOTO 40      *IF 7054 CONTROLLER
   IF (DC EQ 4) GOTO 26      *IF 2X DRIVE 
   B7 = 1464
26 DUP 0 TO OB FOR WC 
   GOSUB 50                  *WRITE SUBROUTINE
   DUP 5252 TO OB FOR WC
   GOSUB 50                  *WRITE SUBROUTINE
   DUP 2525 TO OB FOR WC
   GOSUB 50                  *WRITE SUBROUTINE
27 RANDOM TO OB FOR WC, START RT
   GOSUB 50 
   OB(504) = OB(504)+1
   IF (OB(504) LE 20D) GOTO 27     *MAKE 20 RANDOM PASSES 
30 IF (B3 EQ 0) GOTO 32            *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT                            *END 
40 MSG 6 TO PRINT,DISPLAY 
   GOTO 32
/ 
42 MSG 10 (SB(4)) TO LINE 1 
   PICTURE
   HALT 
   BLANK
   GOTO 32                   *TERMINATE 
/ 
/         SUBROUTINE WRITE AND CHECK BUFFER 
50 B0 = 0                          *LOOP COUNT
   B4 = 1                          *SECTOR COUNT
   B2 = WC
   RES DRIVE, ABT 70
   IF (SB(4).AND.4000B.EQ.0) GOTO 42   *IF NOT FT CW
   WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 51 
51 READCB, ABT 70 
   MSG 7 (OB) TO DISPLAY
   COMPARE IB TO OB FOR B2, ABT 76
   GOTO 51 WHILE(B0+1 LE 20D)      *REPEAT LOOP 20 TIMES
52 REL, ABT 74
   IF (ES AND RC EQ RC) GOTO 50    *REPEAT CONDITION
   RETURN 
/         ERROR ROUTINES
70 IF (SB EQ 7777B) GOTO 71        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 74     *IF BC OK
71 B1 = 73B                        *RESTART 
   GOTO 75
74 B1 = 70B 
75 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 50    *REPEAT CONDITION
   GOTO 52                         *NEXT SECTOR 
76 B1 = 71B                        *COMPARE ERROR 
   GOTO 75
   END 20 
COMPILE 
   MODULE D4408,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE FIRST TWO PREALLOCATED CYLINDERS 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  FILL THE OUTOUT BUFFER WITH RANDOM DATA.
*         4.  SEEK TO THE FIRST PREALLOCATED CYLINDER AND 
*             WRITE CODED 1/1 INTERLACE, TRACK MODE, THE
*             FIRST TWO PREALLOCATED CYLINDERS. 
*             THE CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         6.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98C FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4408 PREALLOCATED AREA WRITE 
 3 FORMAT D4408 - ERROR(S) IN MODULE
 5 FORMAT //D4408 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
 6 FORMAT D4408 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   IF (AL GE 3) GOTO 21      *IF ACCESS GOOD
   MSG 5 (AL) TO LINE 1 
   GOTO 32                   *END IT
21 B0 = 474                  *COMPARE SET 
   B4 = 30                   *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 23      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 23      *IF 2X DRIVE 
   B7 = 1464
23 RANDOM TO OB(4) FOR B0, START RT 
24 RES DRIVE, ABT 60
25 MSG 6 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
26 REL, ABT 65
   B4 = 30                         *RESET SECTORS 
   B5 = 0 
   IF (ES AND RC EQ RC) GOTO 24    *IF REPEAT CONDITION 
   GOTO 23 WHILE (B6+1 LE 22)      *IF NOT LAST TRACK 
   IF (B7 EQ 631) GOTO 30          *END IT
   IF (B7 EQ 1465) GOTO 30         *END IT
   B6 = 0 
   B7 = B7+1
   GOTO 23                         *WRITE NEXT CYLINDER 
30 IF (B3 EQ 0) GOTO 32            *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT                            *END 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 103B                       *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 26  *IF TRACK FLAW 
64 B5 = B5+1
   GOTO 24 WHILE(B4-1 GT 0)        *NEXT SECTOR 
   GOTO 26                         *NEXT TRACK
65 B1 = 100B                       *INSTRUCTION ERROR 
66 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 24    *REPEAT CONDITION
   GOTO 64                         *NEXT SECTOR 
   END 20 
COMPILE 
   MODULE D4409,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ FIRST TWO PREALLOCATED CYLINDERS
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEKS TO THE FIRST PREALLOCATED CYLINDER AND
*             READS CODED SECTORS, IN 2/1 INTERLACE, TRACK
*             MODE, COMPARING DATA ON EACH SECTOR BY THE
*             RANDOM SEAD LEFT IN WORD 4 BY MODULE 8. 
*             THE CHANNEL IS RELEASED ON EACH TRACK BOUNDARY. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4409 PREALLOCATED AREA READ
 3 FORMAT D4409 - ERROR(S) IN MODULE
 4 FORMAT D4409 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   B0 = 474                  *COMPARE WORD COUNT
   B4 = 1                    *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 22      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 22      *IF 2X DRIVE 
   B7 = 1464
22 RES DRIVE, ABT 60
23 MSG 4 (B7 B6 B5) TO DISPLAY
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR B0, START IB(4)
   COMPARE IB(5) TO OB(5) FOR B0, ABT 65
24 B4 = 1 
   GOTO 23 WHILE(B5+2 LT 30)     *SECTOR COUNT
   IF (B5 EQ 31) GOTO 25         *IF SECTORS COMPLETED
   B5 = 1 
   GOTO 23                       *READ ODD SECTORS
25 REL, ABT 63
   B4 = 1                        *READ 1 SECTOR 
   B5 = 0                        *EVEN SECTORS
   IF (ES AND RC EQ RC) GOTO 22  *IF REPEAT CONDITION 
   GOTO 22 WHILE(B6+1 LT 23)     *TRACK COUNT 
   B6 = 0 
   B7 = B7+1
   IF (B7 EQ 631) GOTO 22        *IF SECOND CYLINDER
   IF (B7 EQ 1465) GOTO 22       *IF SECOND CYLINDER
   IF (B3 EQ 0) GOTO 27          *IF NO ERRORS
26 MSG 3 TO DAYFILE 
27 PICTURE
   EXIT 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 113B                       *RESTART 
   GOTO 64
62 IF (SB EQ 0) GOTO 63            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 63  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 25  *IF TRACK FLAW 
   GOTO 24
63 B1 = 110B                       *INSTRUCTION ERROR 
64 CALL 98A                        *CALL ERROR PROCESSOR
   B0 = 474                        *COMPARE WORD COUNT
   IF (ES AND RC EQ RC) GOTO 22    *REPEAT CONDITION
   RES DRIVE, ABT 60
   GOTO 24                         *NEXT SECTOR 
65 B1 = 111B                       *COMPARE ERROR 
66 GOTO 64                         *ERROR PROCESS 
   END 20 
COMPILE 
   MODULE D4410,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ SHORT ROUTINE 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  ZERO THE OUTPUT BUFFER, AND SET THE DATA WORD 
*             AT THE SPECIFIED BUFFER ADDRESS, RESERVE THE
*             DRIVE, AND WRITE ONE SECTOR.  WHEN READ SHORT 
*             COMPARING THE GENERAL STATUS WITH THE EXPECTED
*             GENERAL STATUS AND THE CORRECTION VECTORS 
*             RETURNED WITH THE EXPECTED CORRECTION VECTORS.
*             THE SHORT READ IS EXECUTED 3 TIMES.                        D44001J
*         3.  THE ABOVE IS EXECUTED 13 TIMES.  SEE MODULE 10
*             WRITE UP FOR EXPECTED PATTERNS. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT BUFFER. 
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = PASS COUNTER.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = INDEX COUNTER. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         OB(502) = DATA INPUT WORD.
*         OB(503) = ADDRESS OF INPUT WORD.
*         OB(504) = EXPECTED GENERAL STATUS.
* 
 1 FORMAT D4410 READ SHORT PASS *DEC
 3 FORMAT D4410 - ERROR(S) IN MODULE
 5 FORMAT //D4410 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
 6 FORMAT D4410 - CANNOT WRITE ON DISK
10 FORMAT STATUS ERR- EXP=*OCT,ACT=*OCT  DATA=*OCT ADDR=*OCT
11 FORMAT DATA ERROR- EXP=0000,ACT=*OCT  DATA=*OCT ADDR=*OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   IF (AL GE 3) GOTO 21      *IF ACCESS LEVEL GOOD
   MSG 5 (AL) TO LINE 1 
   GOTO 32                   *END IT
21 WC = 500                  *READ BUFFER SIZE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 22      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 22      *IF 2X DRIVE 
   B7 = 1464
22 B0 = 1                    *FIRST PASS
   OB(502) = 0001                *DATA
   OB(503) = 0               *ADDRESS 
   OB(504) = 4640            *EXPECTED GENERAL STATUS 
   GOSUB 35                  *TEST FIRST SECTION
   IF(ES.AND.RC.NE.0) GOTO 22    *IF REPEAT CONDITION 
23 OB(502) = 7760                *DATA
   OB(503) = 0                   *ADDRESS 
   OB(504) = 4640                *EXPECTED GENERAL STATUS 
   B0 = 2                        *PASS 2
   GOSUB 35                      *SECOND TEST 
   IF(ES.AND.RC.NE.0) GOTO 23    *IF REPEAT CONDITION 
24 OB(502) = 7777                *DATA
   OB(503) = 0                   *ADDRESS 
   OB(504) = 5201                *EXPECTED GENERAL STATUS 
   B0 = 3                        *PASS 3
   GOSUB 35                      *THIRD TEST
   IF(ES.AND.RC.NE.0) GOTO 24    *IF REPEAT CONDITION 
25 B0 = B0+1                     *PASS COUNT
26 OB(502) = RT.AND.377 
   IF(OB(502).EQ.0) GOTO 26      *IF NO BITS SET
27 OB(503) = RT.AND.777 
   IF (OB(503) GT 450) GOTO 27   *IF ADDRESS TOO LARGE
   OB(504) = 4640                *EXPECTED GENERAL STATUS 
   GOSUB 35                      *TEST RANDOM 
   IF(ES.AND.RC.NE.0) GOTO 26    *IF REPEAT CONDITION 
   IF (B0 LE 13D) GOTO 25        *REPEAT RANDOM 10 TIMES
   IF (B3 EQ 0) GOTO 32          *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT                          *END 
/         WRITE SECTOR SUBROUTINE 
35 DUP 0 TO OB FOR WC            *CLEAR BUFFER
   MSG 1 (B0) TO DISPLAY         *DISPLAY PASS COUNT
   B4 = OB(503)                  *SET ADDRESS 
   OB(B4) = OB(502)              *SET DATA
   IF(B0.EQ.1) OB(B4+1) = 2000   *SECOND BAD DATA WORD
   B4 = 1                        *NUMBER OF SECTORS TO WRITE
   RES DRIVE, ABT 60
   IF (SB(4) AND 2000B EQ 0) GOTO 37  *IF NOT A FMD 
   IF(B0.NE.3) OB(504) = 0
   OB(504) = OB(504) AND 7736B        *CLEAR BITS 5 AND 0 FOR FMD 
37 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 46 
   B4 = 0                             *LOOP COUNT 
41 SHORTRD CYL B7 TRK B6 SEC B5, ABT 60 
   IF(SB.NE.OB(504)) ERROR 0/0, GOTO 65    *DATA ERROR
   IF(B0.EQ.3) GOTO 44           *IF UNCORRECTABLE PASS 
42 B2 = SB(13D) AND 777B             *CORRECTION ADDRESS
   IF(SB(4).AND.2000.NE.0) GOTO 43   *IF A 7155 CONTROLLER
   IB(B2) = IB(B2) XOR SB(14D)       *CORRECTION WORD 
   IB(B2+1) = IB(B2+1) XOR SB(15D)   *CORRECTION WORD 
43 IF(IB(B2).NE.0) ERROR 0/0, GOTO 66    *DATA ERROR
   IF(IB(B2+1).NE.0) ERROR 0/0, GOTO 67   *DATA ERROR 
   RES DRIVE, ABT 60                                                     D44001J
44 GOTO 41 WHILE (B4+1 LE 2)   *SHORT READ 3 TIMES                       D44001J
   REL, ABT 52
45 RETURN 
/         ERROR ROUTINE 
46 IF (SB EQ 7777B) GOTO 47          *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 50       *IF BC GOOD
47 B1 = 123B
   GOTO 53
50 IF (SB EQ 0) GOTO 52              *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 52    *IF NOT A FLAW 
   ERROR 0/0                         *CLEAR ERROR 
51 GOTO 35 WHILE (B6+1 LE 22)        *TRY NEXT TRACK
   MSG 6 TO LINE 1
   GOTO 31                           *END IT
52 B1 = 120B
53 CALL 98A                          *CALL ERROR PROCESSOR
   GOTO 45
60 IF (SB EQ 7777B) GOTO 47          *IF BC HUNG
   IF(SB(4).EQ.7777B)GOTO 47       IF BC HUNG                            D44004G
   GOTO 52
65 MSG 10(OB(504),SB,OB(502),OB(503)) TO LINE 1   *STATUS ERR 
   GOTO 52
66 MSG 11(IB(B2),OB(502),OB(503)) TO LINE 1      *DATA ERROR
   GOTO 52
67 MSG 11(IB(B2+1),OB(B2+1),OB(503)) TO LINE 1    *DATA ERROR 
   GOTO 52
   END 20 
COMPILE 
   MODULE D4411,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE VERIFY THE FIRST PREALLOCATED CYLINDER 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE INNERMOST CYLINDER AND WRITE
*             RANDOM DATA, CODED SECTORS IN CYLINDER MODE.
*             THE CHANNEL IS RELEASED AT THE END OF THE 
*             CYLINDER. 
*         4.  REPEAT CONDITION LOOPS ON THE FIRST 
*             PREALLOCATED CYLINDER.
*         5.  SEEK TO THE INNERMOST CYLINDER AND READ 
*             VERIFY PRERECORDED CODED SECTORS IN CYLINDER
*             MODE.  THE CHANNEL IS RELEASED AT THE FINISH
*             OF THE CYLINDER.
*         6.  REPEAT CONDITION LOOPS ON THE FIRST 
*             PREALLOCATED CYLINDER.
*         7.  RESERVE THE DISK FILE AND FORCE A RANDOM DATA 
*             PATTERN INTO ONE WORD OF THE WRITE BUFFER 
*             AND EXCUTES A READ VERIFY.  IF A FAILURE
*             DOES NOT OCCUR, AN ERROR WILL BE REPORTED.
*             RELEASE CHANNEL.
*         8.  REPEAT CONDITION LOOPS ON THE CURRENT SECTOR. 
*         9.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         OB(504) = FIRST PREALLOCATED CYLINDER.
* 
 1 FORMAT D4411 WRITE VERIFY TEST 
 5 FORMAT //D4411 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
 7 FORMAT D4411 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   IF (AL GE 3) GOTO 21      *IF ACCESS GOOD
   MSG 5 (AL) TO LINE 1 
   PICTURE
   EXIT                      *END IT
21 B0 = 474                  *COMPARE WORD COUNT
   B4 = 456D                 *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   OB(504) = 630
   IF (DC EQ 2) GOTO 23      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 23      *IF 2X DRIVE 
   OB(504) = 1464 
23 RANDOM TO OB(4) FOR B0, START RT 
24 RES DRIVE, ABT 60
   B7 = OB(504)              *SET CYLINDER
25 MSG 7 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
26 REL, ABT 66
   EXIT TO 111                     *NEXT MODULE LEVEL 
/         ERROR SUBROUTINE
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 133B                       *RESTART 
   GOTO 67
62 IF (SB EQ 0) GOTO 66            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 66  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 25 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
64 IF (B5 AND 1 EQ 0) GOTO 65      *IF EVEN SECTORS 
   B5 = 1                          *SET FOR ODD SECTORS 
   GOTO 25 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 26                         *LAST TRACK AND SECTOR 
65 B5 = 0                          *SET EVEN SECTOR 
   GOTO 25 WHILE (B6+1 LE 22)      *NEXT EVEN SECTOR, TRACK 
   B5 = 1                          *ODD SECTOR
   B6 = 0                          *START TRACK 0 
   GOTO 25
66 B1 = 130B                       *INSTRUCTION ERROR 
67 CALL 98A                        *CALL ERROR PROCESSOR
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
   RES DRIVE, ABT 66
   GOTO 63                         *NEXT SECTOR 
   END 20 
COMPILE 
   MODULE D44111,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE VERIFY THE FIRST PREALLOCATED CYLINDER 
* 
 3 FORMAT D4411 - ERROR(S) IN MODULE
 7 FORMAT D4411 - CYL *OCT, TRK *OCT, SEC *OCT
20 B4 = 456D                 *SECTORS 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = OB(504)              *CURRENT CYLINDER
21 RES DRIVE, ABT 60
25 MSG 7 (B7 B6 B5) TO DISPLAY
   VERIFY B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   IF (ES AND RC EQ RC) GOTO 20   *IF REPEAT CONDITION
26 REL, ABT 66
   B5 = 0                          *CURRENT SECTOR
   B6 = 0                          *CURRENT TRACK 
   B7 = OB(504)                    *CURRENT CYLINDER
27 RES DRIVE, ABT 70
   B1 = 1                          *SECTOR COUNT
30 MSG 7 (B7 B6 B5) TO DISPLAY
/         FORCE A VERIFY ERROR
   OB(40) = OB(40).XOR.7777B       *COMPLEMENT OB(40) 
   B4 = 1 
   VERIFY B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 40
   ERROR 5/0
   GOTO 66
40 REL, ABT 75
41 IF (ES AND RC EQ RC) GOTO 26    *IF REPEAT CONDITION 
   IF (B3 EQ 0) GOTO 43            *IF NO ERRORS
42 MSG 3 TO DAYFILE 
43 PICTURE
   EXIT                            *END 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 133B                       *RESTART 
   GOTO 67
62 IF (SB EQ 0) GOTO 66            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 66  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 25 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
64 IF (B5 AND 1 EQ 0) GOTO 65      *IF EVEN SECTORS 
   B5 = 1                          *SET FOR ODD SECTORS 
   GOTO 25 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 26                         *LAST TRACK AND SECTOR 
65 B5 = 0                          *SET EVEN SECTOR 
   GOTO 25 WHILE (B6+1 LE 22)      *NEXT EVEN SECTOR, TRACK 
   B5 = 1                          *ODD SECTOR
   B6 = 0                          *START TRACK 0 
   GOTO 25
66 B1 = 130B                       *INSTRUCTION ERROR 
67 CALL 98A                        *CALL ERROR PROCESSOR
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
   RES DRIVE, ABT 60
   GOTO 63                         *NEXT SECTOR 
70 IF (SB EQ 7777B) GOTO 71        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 133B                       *RESTART 
   GOTO 76
72 IF (SB EQ 0) GOTO 75            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 75  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 EQ 0) GOTO 74  *IF SECTOR FLAW
73 B5 = 0                          *NEXT TRACK
   GOTO 30 WHILE (B6+1 LE 22) 
   GOTO 41
74 GOTO 30 WHILE(B5+1 LE 27)       *NEXT SECTOR 
   GOTO 73                         *NEXT TRACK
75 B1 = 130B
76 CALL 98A                        *CALL ERROR PROCESSOR
   IF (ES AND RC EQ RC) GOTO 27    *REPEAT CONDITION
   GOTO 41                         *NEXT SECTOR 
   END 20 
COMPILE 
   MODULE D4412,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ CHECK WORD FIRST PREALLOCATED CYLINDER
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE FIRST PREALLOCATED CYLINDER AND 
*             READ CHECK WORD THE FULL CYLINDER IN 1/1
*             INTERLACE, CYLINDER MODE. 
*             CHANNEL IS RELEASED AT THE END OF CYLINDER. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98C FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4412 READ CHECK WORD TEST
 3 FORMAT D4412 - ERROR(S) IN MODULE
 4 FORMAT D4412 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
21 B4 = 456D                 *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 22      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 22      *IF 2X DRIVE 
   B7 = 1464
22 RES DRIVE, ABT 60
23 MSG 4 (B7 B6 B5) TO DISPLAY
   READCW B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   REL, ABT 65
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
25 IF (B3 EQ 0) GOTO 32            *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT                            *END 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 113B                       *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 23 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
64 B5 = 0 
   GOTO 23 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 25                         *END 
65 B1 = 140B                       *INSTRUCTION ERROR 
66 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
   RES DRIVE, ABT 60
   GOTO 63                         *NEXT SECTOR 
   END 20 
COMPILE 
   MODULE D4413,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        CHECK MARGINS
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE INNERMOST CYLINDER AND READ 
*             THE FULL CYLINDER IN TRACK MODE, 2/1
*             INTERLACE.  THIS CONDITION IS REPEATED
*             9 TIMES WITH EACH ONE OF THE POSIBLE OFFSETS. 
*             CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = STROBE/OFFSET MESSAGE NUMBER 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4413 CHECK MARGIN TEST 
 3 FORMAT D4413 - ERROR(S) IN MODULE
 4 FORMAT D4413 - ERROR IN MARGIN COMAND
 5 FORMAT D4413 - CYL *OCT, TRK *OCT, SEC *OCT
 6 FORMAT     ERROR AT NORMAL OFFSET, NORMAL STROBES
 7 FORMAT     ERROR AT NORMAL OFFSET, EARLY STROBES 
10 FORMAT     ERROR AT NORMAL OFFSET, LATE STROBES
11 FORMAT     ERROR AT FORWARD OFFSET, NORMAL STROBES 
12 FORMAT     ERROR AT FORWARD OFFSET, EARLY STROBES
13 FORMAT     ERROR AT FORWARD OFFSET, LATE STROBES 
14 FORMAT     ERROR AT REVERSE OFFSET, NORMAL STROBES 
15 FORMAT     ERROR AT REVERSE OFFSET, EARLY STROBES
16 FORMAT     ERROR AT REVERSE OFFSET, LATE STROBES 
20 MSG 1 TO DISPLAY, PRINT
   B0 = 476                  *COMPARE WORD COUNT
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 23      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 23      *IF 2X DRIVE 
   B7 = 1464
23 MSG 1 TO DISPLAY 
   B2 = 6 
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 57 
   GOSUB 50 
   B2 = 7 
   MARGINS NORMAL OFFSET EARLY STROBES, ABT 57
   GOSUB 50 
   B2 = 10
   MARGINS NORMAL OFFSET LATE STROBES, ABT 57 
   GOSUB 50 
   B2 = 11
   MARGINS FWD OFFSET NORMAL STROBES, ABT 57
   GOSUB 50 
   B2 = 12
   MARGINS FWD OFFSET EARLY STROBES, ABT 57 
   GOSUB 50 
   B2 = 13
   MARGINS FWD OFFSET LATE STROBES, ABT 57
   GOSUB 50 
   B2 = 14
   MARGINS REV OFFSET NORMAL STROBES, ABT 57
   GOSUB 50 
   B2 = 15
   MARGINS REV OFFSET EARLY STROBES, ABT 57 
   GOSUB 50 
   B2 = 16
   MARGINS REV OFFSET LATE STROBES, ABT 57
   GOSUB 50 
30 IF (B3 EQ 0) GOTO 32      *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT                      *END IT
/         READ SUBROUTINE 
50 B0 = B7                   *SET CYLINDER
   B4 = 14                   *SET SECTOR
   B6 = 0                    *SET TRACK 
   B5 = 0                    *EVEN SECTOR 
51 RES DRIVE, ABT 60
52 MSG 5 (B0 B6 B5) TO DISPLAY
   READ B4 SECTORS AT CYL B0 TRK B6 SEC B5, ABT 60
53 B4 = 14                       *RESET SECTORS 
   IF (B5 EQ 27) GOTO 54
   B5 = 1                        *ODD SECTOR
   GOTO 52                       COMPLETE ODD SECTORS 
54 B5 = 0 
   B4 = 14                       *INSURE SECTORS SET
   GOTO 51 WHILE (B6+1 LE 22)    *READ ALL TRACKS 
   IF (ES AND RC EQ RC) GOTO 50  *IF REPEAT CONDITION 
55 REL, ABT 64
   RETURN 
/         ERROR ROUTINES
57 MSG 4 TO LINE 1                 *MARGIN COMMAND ERROR
   GOTO 31                         *END IT
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 153B                       *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 54  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 52 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
   IF (B5 EQ 31) GOTO 54           *IF LAST SECTOR
   GOTO 53                         *NEXT ODD SECTOR 
64 B1 = 150B                       *INSTRUCTION ERROR 
65 MSG B2 TO LINE 1         *REPORT STROBES/OFFSET ACTIVE 
   CALL 98A                 *CALL ERROR PROCESSOR 
   IF (ES AND RC EQ RC) GOTO 50    *REPEAT CONDITION
   RES DRIVE, ABT 60
   GOTO 63                         *NEXT SECTOR 
   END 20 
COMPILE 
   MODULE D4414,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        RANDOM SEEK, SEEK BACK TO PREALLOCATION
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  GENERATE 25 RANDOM CYLINDER ADDRESS BETWEEN 
*             ZERO AND THE MAXIMUM CYLINDER ON THE DISK FILE
*             IN THE OUTPUT BUFFER. 
*         3.  RESERVE DISK FILE.
*         4.  SEEK TO THE FIRST RANDOM CYLINDER ADDRESS OF
*             THE OUTPUT BUFFER, READ THE DISK ADDRESS AND
*             COMPARE WITH THE ADDRESS SEEKED.  SEEK THE
*             MAXIMUM DISK ADDRESS.  REPEAT THIS SEQUENCE 
*             FOR EACH OF THE 25 RANDOM CYLINDER ADDRESSES
*             IN THE OUTPUT BUFFER.  THE CHANNEL IS RELEASED
*             AT THE END OF EACH SEQUENCE.  THE TOTAL                    D44002J
*             SEQUENCE IS REPEATED 25 TIMES.                             D44002J
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT 25
*             RANDOM CYLINDERS. 
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = RANDOM CYLINDER. 
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = CYLINDER INDEX COUNTER.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = MAXIMUM CYLINDER.
*         OB(504) = MAIN PASS COUNTER.
* 
 1 FORMAT D4414 RANDOM SEEK TEST
 3 FORMAT D4414 - ERROR(S) IN MODULE
 4 FORMAT D4414 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   B0 = 0                    *LOOP COUNT
   B4 = 1                    *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 632                  *CURRENT CYLINDER
   IF(DC EQ 2) GOTO 21       *IF 2X DRIVE                                D44002J
   IF(DC EQ 4) GOTO 21       *IF 2X DRIVE                                D44002J
   B7 = 1466
21 GOSUB 50                  *SET RANDOM
22 RES DRIVE, ABT 60
23 B0 = OB(B2)                   *SET RANDOM CYLINDER 
   MSG 4 (B0 B6 B5) TO DISPLAY
   SEEK CYL B0 TRK B6 SEC B5, ABT 60
   RTNADDR TO IB, ABT 60
   IF (IB NE OB(B2)) GOTO 65     *IF WRONG CYLINDER 
   MSG 4 (B7 B6 B5) TO DISPLAY
   SEEK CYL B7 TRK B6 SEC B5, ABT 60
   RTNADDR TO IB, ABT 60
   IF (IB NE B7) GOTO 65         *IF WRONG CYLINDER 
24 GOTO 22 WHILE (B2+1 LE 25D)   *REPEAT LOOP 25 TIMES                   D44002J
   REL, ABT 63
   B2 = 0                        *RESET LOOP
   IF (ES AND RC EQ RC) GOTO 22  *IF REPEAT CONDITION 
   OB(504) = OB(504)+1           *ADD 1 TO MAIN PASS COUNT
   IF (OB(504) GE 25D) GOTO 30   *IF 25 PASSES
   GOSUB 50                      *SET RANDOM
   GOTO 22
30 IF (B3 EQ 0) GOTO 32          *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   EXIT 
/         RANDOM SUBROUTINE 
50 B2 = 0 
51 RANDOM TO OB(B2) FOR 1, START RT 
   IF (OB(B2) GT B7) GOTO 51       *IF CYLINDER TOO LARGE 
   GOTO 51 WHILE (B2+1 LE 25D)     *NUMBER OF NEW SEEKS 
   B2 = 0 
   RETURN 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 63     *IF BC OK
61 B1 = 163B                       *RESTART 
   GOTO 64
63 B1 = 160B                       *INSTRUCTION ERROR 
64 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 22    *REPEAT CONDITION
   RES DRIVE, ABT 60
   GOTO 24
65 B1 = 161B                       *COMPARE ERROR 
66 GOTO 64                         *ERROR PROCESS 
   END 20 
COMPILE 
   MODULE D4415,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE A CODED CYLINDER AT 1 TO 1 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE FIRST PREALLOCATED CYLINDER AND 
*             WRITE CODED SECTORS IN 1/1 CYLINDER MODE, WITH
*             RANDOM DATA BUFFER. 
*             CHANNEL IS RELEASED AT THE END OF CYLINDER. 
*         4.  REPEAT CONDITION LOOPS ON THE CYLINDER. 
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98C FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4415 WRITE CODED CYLINDER
 3 FORMAT D4415 - ERROR(S) IN MODULE
 4 FORMAT D4415 - CYL *OCT, TRK *OCT, SEC *OCT
 5 FORMAT //D4415 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   IF (AL GE 3) GOTO 21      *IF ACCESS GOOD
   MSG 5 (AL) TO LINE 1 
   GOTO 31                   *END IT
21 B0 = 474                  *RANDOM BUFFER SIZE
   RANDOM TO OB(4) FOR B0, START RT 
22 B4 = 456D                 *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 23      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 23      *IF 2X DRIVE 
   B7 = 1464
23 RES DRIVE, ABT 60
24 MSG 4 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
25 REL, ABT 65
   IF (ES AND RC EQ RC) GOTO 22    *IF REPEAT CONDITION 
   IF (B3 EQ 0) GOTO 31            *IF NO ERRORS
30 MSG 3 TO DAYFILE 
31 PICTURE
   EXIT 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 173B                       *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 24 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
64 B5 = 0 
   GOTO 24 WHILE(B6+1 LE 22)       *IF TRACK FLAW 
   GOTO 25
65 B1 = 170B                       *INSTRUCTION ERROR 
66 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 22    *REPEAT CONDITION
   RES DRIVE, ABT 60
   GOTO 63
   END 20 
COMPILE 
   MODULE D4416,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ A CODED VERIFY AT 2 TO 1
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE FIRST PREALOCATED CYLINDER AND
*             READ PRERECORDED CODED SECTORS IN CYLINDER
*             MODE THAT WAS WRITTEN BY MODULE 15. 
*         4.  REPEAT CONDITION LOOPS ON THE CYLINDER. 
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4416 READ VERIFY 
 3 FORMAT D4416 - ERROR(S) IN MODULE
 4 FORMAT D4416 - CYL *OCT, TRK *OCT, SEC *OCT
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
21 B4 = 456D                 *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 630                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 22      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 22      *IF 2X DRIVE 
   B7 = 1464
22 RES DRIVE, ABT 60
23 MSG 4 (B7 B6 B5) TO DISPLAY
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
24 REL, ABT 66
   IF (ES AND RC EQ RC) GOTO 21    *IF REPEAT CONDITION 
   IF (B3 EQ 0) GOTO 31            *IF NO ERRORS
30 MSG 3 TO DAYFILE 
31 PICTURE
   GOTO 77                       *EXIT
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 203B                       *RESTART 
   GOTO 67
62 IF (SB EQ 0) GOTO 66            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 66  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 23 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
64 IF (B5 AND 1 EQ 0) GOTO 65      *IF EVEN SECTORS 
   B5 = 1                          *SET FOR ODD SECTOR
   GOTO 23 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 24                         *LAST TRACK AND SECTOR 
65 B5 = 0                          *EVEN SECTOR 
   GOTO 23 WHILE (B6+1 LE 22)      *NEXT EVEN SECTOR TRACK
   B5 = 1                          *ODD SECTOR
   B6 = 0                          *START OVER ON TRACK 0 
   GOTO 23                         *START ODD SECTOR
66 B1 = 200B                       *INSTRUCTION ERROR 
67 CALL 98A                        *CALL ERROR PROCESSOR
   IF (ES AND RC EQ RC) GOTO 21    *REPEAT CONDITION
   RES DRIVE, ABT 60
   GOTO 63                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4417,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READCW SEQUENTIAL,TRACK MODE 1/1 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK VALIDITY OF INPUT PARAMETERS. 
*         3.  RESERVE THE DISK FILE.
*         4.  SEEK TO CYLINDER P0 AND READCW IN TRACK MODE, 
*             1/1 INTERLACE, THROUGH P1. IF P0 AND P1 ARE 
*             BOTH ZERO THE ENTIRE DISK SURFACE WILL BE READ. 
*             THE CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         6.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98C FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         OB(504) = FIRST PREALLOCATED CYLINDER.
* 
*     INPUT REGISTER USAGE
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
* 
 1 FORMAT D4417 READCW DISK SEQUENTIAL                                   D44003J
 3 FORMAT D4417 - ERROR(S) IN MODULE
 4 FORMAT D4417 - CYL *OCT, TRK *OCT, SEC *OCT
 5 FORMAT D4417 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
 6 FORMAT D4417 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
 7 FORMAT D4417 - LOWER GREATER THAN UPPER CYLINDER 
20 MSG 1 TO DISPLAY, PRINT
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 60 
   B4 = 27       *NUMBER OF SECTORS TO READ 
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   OB(504) = 632
   IF (DC.EQ.2) GOTO 21      *IF 2X DRIVE 
   IF (DC.EQ.4) GOTO 21      *IF 2X DRIVE 
   OB(504) = 1466 
21 IF (P0.GT.OB(504)) GOTO 40   *P0 PARAMETER ERROR 
   IF (P1.GT.OB(504)) GOTO 42   *P1 PARAMETER ERROR 
   IF (P1.LT.P0) GOTO 44     *LOWER CYLINDER GREATER THAN UPPER 
   B7 = P0                   *SET STARTING CYLINDER 
   IF (P1.EQ.0) GOTO 22      *P0 AND P1 ZERO DO ENTIRE PACK 
   OB(504) = P1              *SET ENDING CYLINDER 
22 RES DRIVE, ABT 64
23 MSG 4 (B7 B6 B5) TO DISPLAY
   READCW B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60                     D44003J
25 B4 = 27                          *RESET SECTORS
   B5 = 0                           *EVEN SECTOR
   GOTO 22 WHILE (B6+1 LE 22)       *IF OTHER TRACK 
   B6 = 0                           *RESET TRACK
   IF (ES AND RC EQ RC) GOTO 22     *IF REPEAT CONDITION
   GOTO 22 WHILE(B7+1 LE OB(504)) 
   REL, ABT 64
30 IF (B3 EQ 0) GOTO 32             *IF NO ERRORS 
31 MSG 3 TO DAYFILE 
32 PICTURE
   GOTO 77                          *END
40 B3 = B3+1
   MSG 5 (P0) TO LINE 2          *LOWER CYLINDER PARAMETER ERROR
   GOTO 30
42 B3 = B3+1
   MSG 6 (P1) TO LINE 2          *UPPER CYLINDER PARAMETER ERROR
   GOTO 30
44 B3 = B3+1
   MSG 7 TO LINE 2               *LOWER CYLINDER GREATER THAN UPPER 
   GOTO 30
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 213B                       *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   ERROR 0/0                       *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 25  *IF TRACK FLAW 
63 B5 = B5+1
   GOTO 23 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 25                         *NEXT TRACK
64 B1 = 210B                       *INSTRUCTION ERROR 
65 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC EQ RC) GOTO 22    *IF REPEAT CONDITION 
   RES DRIVE, ABT 60
   GOTO 63                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4430,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         TRACK MODE SEQUENTIAL WRITE/READ TEST.
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE. 
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4430 SEQUENTIAL WRITE/READ TEST (TRACK MODE) 
 2 FORMAT D4430 - ERROR(S) IN MODULE
 3 FORMAT D4430 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4430 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4430 - SECTOR PARAM ERROR  P3 = *OCT 
 7 FORMAT D4430 - TRACK PARAM ERROR  P2 = *OCT
10 FORMAT D4430 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4430 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4430 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4430 - READ AND WRITE BOTH DISABLED
14 FORMAT D4430 - LOWER GREATER THAN UPPER SECTOR 
15 FORMAT D4430 - LOWER GREATER THAN UPPER TRACK
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                 *WORD COUNT
   B4 = P3 AND 77B           *UPPER SECTOR
   B5 = P3 RS 6              *LOWER SECTOR
   IF (B4 GT 27) GOTO 21     *IF BAD SECTOR 
   IF (B5 LE 27) GOTO 22     *SECTORS OK
21 B3 = 1 
   MSG 6 (P3) TO LINE 2      *SECTOR ERROR MESSAGE
22 IF (B5 LE B4) GOTO 23     *IF LOWER LT UPPER SECTOR
   B3 = B3+1
   MSG 14 TO LINE 3          *SECTOR LOWER MESSAGE
23 B0 = P2 AND 77B           *UPPER TRACK 
   B6 = P2 RS 6              *LOWER TRACK 
   IF (B0 GT 22) GOTO 24     *IF TRACK BAD
   IF (B6 LE 22) GOTO 25     *IF TRACKS OK
24 B3 = B3+1
   MSG 7 (P2) TO LINE 4      *TRACK ERROR MESSAGE 
25 IF (B6 LE B0) GOTO 26     *IF LOWER LT UPPER TRACK 
   B3 = B3+1
   MSG 15 TO LINE 5          *TRACK LOWER MESSAGE 
26 B4 = 632                  *SINGLE DENSITY
   IF (DC EQ 2) GOTO 27      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 27      *IF 2X DRIVE 
   B4 = 1466                 *DOUBLE DENSITY
27 B7 = P0                   *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE B4) GOTO 30     *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 6     *LOWER CYLINDER MESSAGE
   B3 = B3+1
30 IF (P1 LE B4) GOTO 31     *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 7
   B3 = B3+1
31 IF (P0 LE P1) GOTO 36     *IF CYLINDER OK
   MSG 12 TO LINE 10         *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40  *WRITE NOT DISABLED
   IF (P5 AND 2 EQ 0) GOTO 45  *READ NOT DISABLED 
   MSG 13 TO LINE 11           *READ AND WRITE BOTH OFF 
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50        *WRITE IN DATA AREA
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50        *WRITE IN PREALLOCATED 
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50        *READ DATA AREA
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                     *IF MARGINS OK 
51 B3 = B3+1
   MSG 3 (P7) TO LINE 14       *MARGIN MESSAGE
55 IF (B3 NE 0) GOTO 65        *IF PARAMETER ERROR
   B3 = 0                           *CLEAR ERROR COUNTER
   B2 = P3 AND 77B - B5             *MAX SECTOR - MIN SECTOR
   IF (P5 AND 10 EQ 0) GOTO 56      *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC           *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61  *IF NO COMPARE 
   IF (P5 AND 4 EQ 0) GOTO 60  *IF WRITE SET
   EXIT TO 303                 *COMPARE DATA WITH NO WRITE
60 EXIT TO 302                 *COMPARE OVERLAY 
61 EXIT TO 301                 *NEXT OVERLAY
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44301,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         TRACK MODE 2 TO 1 SEQUENTIAL WRITE/READ TEST
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 4 FORMAT D4430 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27      *SET DATA PATTERN 
22 IF (P6 EQ 0) GOTO 24             *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
27 GOSUB 42                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 32       *IF WRITE DISABLED
   B4 = B2+2 RS 1                   *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 45                         *WRITE ROUTINE
   B4 = B2+1 RS 1                   *RESET SECTORS SECOND 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 32             *ONE SECTOR WRITE 
   GOSUB 45                         *WRITE ROUTINE
32 IF (P5 AND 2 NE 0) GOTO 33       *IF READ DISABLED 
   B4 = B2+2 RS 1                   *SECTORS FIRST PASS 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 52                         *READ ROUTINE 
   B4 = B2+1 RS 1                   *RESET SECTORS LEFT 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 33             *ONE SECTOR READ
   GOSUB 52                         *READ ROUTINE 
33 ENDSUB 
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 35 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
35 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 37 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
37 GOTO 40 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
40 EXIT TO 304                      *END TEST 
41 B1 = 3610B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
42 RES DRIVE, ABT 41
   RETURN                           *RETURN TO CALL 
/         WRITE ROUTINE 
45 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 47       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 50
47 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
50 RETURN 
/         READ ROUTINE
52 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 54       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 56
54 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
56 RETURN 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 3613B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 3612B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   GOTO 33                         *NEXT TRACK
63 B5 = B5+2
   GOTO 45 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 50                         *NEXT TRACK
64 B1 = 3610B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 42                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 3613B                      *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B1 = 3612B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 75      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 73  *IF SECTOR FLAW
   GOTO 33                         *NEXT TRACK
73 B5 = B5+2
   GOTO 52 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 56                         *NEXT TRACK
74 B1 = 3610B                      *INSTRUCTION ERROR 
75 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 42                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 76            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
76 GOTO 73                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44302,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         TRACK MODE 2 TO 1 SEQUENTIAL WRITE/READ TEST
/         WRITE/READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
*         OB(503) = ODD/EVEN PASS COUNT.
*         OB(504) = UPPER SECTOR. 
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 4 FORMAT D4430 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27      *SET DATA PATTERN 
22 IF (P6 EQ 0) GOTO 24             *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT  *START FROM REAL TIME
27 GOSUB 47                         *RESERVE DRIVE
   B4 = B2+2 RS 1                   *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 50                         *WRITE ROUTINE
   B4 = B2+1 RS 1                   *RESET SECTORS SECOND 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 32             *IF ONE SECTOR WRITE
   GOSUB 50                         *WRITE ROUTINE
32 OB(503) = 0                      *LOOP COUNT 
   OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
33 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 34       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 35
34 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
35 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
36 GOTO 33 WHILE (B5+2 LE OB(504))  *COMPLETE FIRST PASS
   OB(503) = OB(503)+1              *COUNT FOR SECOND PASS
   IF (OB(503) EQ 2) GOTO 40        *IF EQUAL TO SECOND PASS
   B5 = P3 RS 6 + 1                 *LOW SECTOR PLUS 1
   IF (B5 GT OB(504)) GOTO 40       *IF ONE SECTOR READ 
   GOTO 33                          *START SECOND PASS
40 ENDSUB 
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
45 EXIT TO 304                      *END MODULE 
46 B1 = 3620B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                           *RETURN TO CALL 
/         WRITE ROUTINE 
50 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 52       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 54
52 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
54 RETURN 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 3623B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 3622B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   GOTO 40                         *NEXT TRACK
63 B5 = B5+2
   GOTO 50 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 54                         *NEXT TRACK
64 B1 = 3620B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 3623B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 3622B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 36  *IF SECTOR FLAW
   GOTO 40                         *NEXT TRACK
73 B1 = 3620B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 36                         *NEXT SECTOR 
76 B1 = 3621B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44303,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         TRACK MODE 2 TO 1 SEQUENTIAL WRITE/READ TEST
* 
*         1.  IF RANDOM SELECTED AND P6 =0, SET OUTPUT
*             BUFFER WITH THE DATA AS DESCRIBED.
*         2.  RESERVE DRIVE.
*         3.  IF A SET DATA PATTERN SELECTED, GO TO 4, ELSE 
*             READ THE FIRST SECTOR AS GIVEN FROM THE INPUT 
*             PARAMETERS AND GENERATE THE RANDOM DATA 
*             PATTERN FROM THE SEED WORD OF THAT SECTOR.
*         4.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         6.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         7.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*         8.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*         9.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
*         OB(503) = ODD/EVEN SECTOR PASS COUNT. 
*         OB(504) = UPPER SECTOR. 
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4430 - CANNOT READ DISK
 4 FORMAT D4430 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27      *SET DATA PATTERN 
22 IF (P6 EQ 0) GOTO 24             *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
/         SET RANDOM PATTERN FOR VERIFY 
24 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
25 B4 = 1 
   GOSUB 47                         *RESERVE DRIVE
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR WC, START IB(4)
27 OB(503) = 0                      *LOOP COUNT 
   OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 47                         *RESERVE DRIVE
33 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 34       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 35
34 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
35 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
36 GOTO 33 WHILE (B5+2 LE OB(504))  *COMPLETE FIRST PASS
   OB(503) = OB(503)+1              *COUNT FOR SECOND PASS
   IF (OB(503) EQ 2) GOTO 40        *IF EQUAL TO SECOND PASS
   B5 = P3 RS 6 + 1                 *LOW SECTOR PLUS 1
   IF (B5 GT OB(504)) GOTO 40       *IF ONE SECTOR READ 
   GOTO 33                          *START SECOND PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
45 EXIT TO 304                      *END MODULE 
46 B1 = 3630B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61         *IF HUNG BC 
   IF (SB(4) NE 7777B) GOTO 62      *IF BC OK 
61 B1 = 3633B                       *RESTART
   GOTO 66
62 IF (SB EQ 0) GOTO 65             *ASSUME NO DETAIL 
   IF (SB(6) AND 30 EQ 0) GOTO 65   *IF NOT A FLAW
   B1 = 3632B                       *FLAW 
   IF (P4 AND 1 NE 0) GOTO 66       *REPORT FLAW
   IF (SB(6) AND 10 NE 0) GOTO 64   *IF TRACK FLAW
63 GOTO 25 WHILE (B5+1 LE OB(504))  *TRY NEXT SECTOR
64 GOTO 24 WHILE (B6+1 LE B0)       *TRY NEXT TRACK 
   B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 24 WHILE (B7+1 LE P1)       *TRY NEXT TRACK 
   MSG 1 TO LINE 1
   PICTURE
   HALT 
   GOTO 45                         *FLAWED AREA - END IT
65 B1 = 3630B                      *INSTRUCTION ERROR 
66 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 24     *IF REPEAT CONDITION 
   IF (B1 NE 2) GOTO 67            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *UPDATE TRACK FROM FLAW
67 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 3633B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 3632B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 36  *IF SECTOR FLAW
   GOTO 40                         *NEXT TRACK
73 B1 = 3630B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 36                         *NEXT SECTOR 
76 B1 = 3631B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44304,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         END SUB MODULE FOR THE 30 SERIES
* 
*         1.  DISPLAY ERROR MESSAGE IN THE DAYFILE IF ERRORS
*             WERE DETECTED IN THE RUNNING OF THESE MODULES.
* 
*   REGISTER USAGE
* 
*         B3 = ERROR COUNT. 
* 
 3 FORMAT D4430 - ERROR(S) IN MODULE
/         END ROUTINE 
20 IF (B3 EQ 0) GOTO 22            *IF NO ERRORS
   MSG 3 TO DAYFILE 
22 PICTURE
   END 20                          *END 
COMPILE 
   MODULE D4431,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         SEQUENTIAL 2 TO 1 WRITE/READ TEST (CYLINDER MODE) 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL METS THE
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4431 SEQUENTIAL WRITE/READ TEST (CYLINDER MODE)
 2 FORMAT D4431 - ERROR(S) IN MODULE
 3 FORMAT D4431 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4431 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
10 FORMAT D4431 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4431 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4431 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4431 - READ AND WRITE BOTH DISABLED
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                   *WORD COUNT
24 B4 = 632                    *SINGLE DENSITY
   IF (DC EQ 2) GOTO 25        *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 25        *IF 2X DRIVE 
   B4 = 1466                   *DOUBLE DENSITY
25 IF (P0 LE B4) GOTO 26       *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 4       *LOWER CYLINDER MESSAGE
   B3 = B3+1
26 IF (P1 LE B4) GOTO 27       *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 5
   B3 = B3+1
27 B7 = P0                     *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE P1) GOTO 36       *IF CYLINDER OK
   MSG 12 TO LINE 6            *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40  *WRITE NOT DISABLED
   IF (P5 AND 2 EQ 0) GOTO 45  *READ NOT DISABLED 
   MSG 13 TO LINE 7            *READ AND WRITE BOTH OFF 
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50        *WRITE IN DATA AREA
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50        *WRITE IN PREALLOCATED 
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50        *READ DATA AREA
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 10 
50 MARGINS P7, ABT 51 
   GOTO 55                     *IF MARGINS OK 
51 B3 = B3+1
   MSG 3 (P7) TO LINE 11       *MARGIN MESSAGE
55 IF (B3 NE 0) GOTO 65        *IF PARAMETER ERROR
   B3 = 0                           *CLEAR ERROR COUNTER
   IF (P5 AND 10 EQ 0) GOTO 56      *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC           *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61       *IF NO COMPARE
   IF (P5 AND 4 EQ 0) GOTO 60       *IF WRITE SET 
   EXIT TO 313                      *COMPARE DATA NO WRITE
60 EXIT TO 312                      *COMPARE OVERLAY
61 EXIT TO 311                      *NEXT OVERLAY 
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44311,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 2 TO 1 WRITE/READ TEST (CYLINDER MODE) 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  WRITE ALL SECTORS AT A 2/1 INTERLACE ON THE 
*             SELECTED CYLINDER.
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  READ ALL SECTORS AT A 2/1 INTERLACE ON THE
*             SELECTED CYLINDER.
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDER. 
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4431 - ERROR(S) IN MODULE
 4 FORMAT D4431 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27      *SET DATA PATTERN 
22 IF (P6 EQ 0) GOTO 24             *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
/         WRITE ROUTINE 
27 GOSUB 47                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 33       *IF WRITE DISABLED
   B4 = 456D                        *SECTORS TO WRITE 
   B5 = 0                           *START SECTOR 
   B6 = 0                           *START TRACK
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 50 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 50 
33 IF (P5 AND 2 NE 0) GOTO 36       *IF READ DISABLED 
/         READ ROUTINE
   B4 = 456D                        *SECTORS TO WRITE 
   B5 = 0                           *START SECTOR 
   B6 = 0                           *START TRACK
34 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 65
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 65
36 IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOTO 37 WHILE (B7+1 GT P1)      *LAST CYLINDER 
   IF (P5 AND 10 NE 0) GOTO 27     *USE SET DATA
   IF (P4 AND 20 EQ 0) GOTO 27     *NO PATTERN CHANGE 
   GOTO 22                         *CONTINUE NEXT CYLINDER
37 GOTO 40 WHILE (BA+1 GT P8)      *ITERATION COUNT 
   B7 = P0                         *SET LOW CYLINDER
   GOTO 20                         *RESTART TEST
/         END ROUTINE 
40 IF (B3 EQ 0) GOTO 41            *IF NO ERRORS
   MSG 3 TO DAYFILE 
41 PICTURE
   GOTO 77                         *END 
46 B1 = 3710B                      *SET MODULE NUMBER 
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                          *RETURN TO CALL
/         ERROR ROUTINES
50 IF (SB EQ 7777B) GOTO 51        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 52     *IF BC OK
51 B1 = 3713B                      *RESTART 
   GOTO 57
52 IF (SB EQ 0) GOTO 56            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 56  *IF NOT A FLAW 
   B1 = 3712B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 57      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 54  *IF TRACK FLAW 
53 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 31 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
54 IF (B5 AND 1 EQ 0) GOTO 55      *IF EVEN SECTOR
   B5 = 1                          *SET FOR ODD SECTOR
   GOTO 31 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 33                         *LAST TRACK AND SECTOR 
55 B5 = 0                          *SET EVEN SECTOR 
   GOTO 31 WHILE (B6+1 LE 22)      *NEXT EVEN SECTOR, TRACK 
   B5 = 1                          *SET ODD SECTOR
   B6 = 0                          *START TRACK 0 
   GOTO 31
56 B1 = 3710B                      *INSTRUCTION ERROR 
57 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 60            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 54  *UPDATE TRACK FROM FLAW
60 GOTO 53                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
65 IF (SB EQ 7777B) GOTO 66        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 67     *IF BC OK
66 B1 = 3713B                      *RESTART 
   GOTO 74
67 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 3712B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 71  *IF TRACK FLAW 
70 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 34 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
71 IF (B5 AND 1 EQ 0) GOTO 72      *IF EVEN SECTOR
   B5 = 1                          *SET FOR ODD SECTOR
   GOTO 34 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 36                         *LAST TRACK AND SECTOR 
72 B5 = 0                          *SET EVEN SECTOR 
   GOTO 34 WHILE (B6+1 LE 22)      *NEXT EVEN SECTOR, TRACK 
   B5 = 1                          *SET ODD SECTOR
   B6 = 0                          *START TRACK 0 
   GOTO 34
73 B1 = 3710B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 71  *UPDATE TRACK FROM FLAW
75 GOTO 70                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44312,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 2 TO 1 WRITE/READ TEST (CYLINDER MODE) 
/         WRITE/READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  WRITE ALL SECTORS AT A 2/1 INTERLACE ON THE 
*             SELECTED CYLINDER.
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  READ ALL SECTORS AT A 2/1 INTERLACE ON THE
*             SELECTED CYLINDER COMPARING DATA EACH SECTOR. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDER. 
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4431 - ERROR(S) IN MODULE
 4 FORMAT D4431 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT  *START FROM REAL TIME
27 GOSUB 51                          *RESERVE DRIVE 
/         WRITE ROUTINE 
   B4 = 456D
   B5 = 0 
   B6 = 0 
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 56 
   GOTO 34
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 56 
34 B5 = 0                           *LOWER SECTOR 
   B6 = 0                           *LOWER TRACK
35 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 36       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 37
36 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
37 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
40 GOTO 35 WHILE (B5+2 LE 27)       *NEXT SECTOR
41 IF (B5 AND 1 EQ 0) GOTO 42       *IF EVEN SECTORS DONE 
   B5 = 0 
   GOTO 35 WHILE (B6+1 LE 22)       *IF NEXT EVEN SECTOR
   B5 = 1 
   B6 = 0 
   GOTO 35                          *NEXT FIRST SECTOR
42 B5 = 1 
   GOTO 35 WHILE (B6+1 LE 22)       *NEXT ODD SECTOR
43 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   B6 = 0                           *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
   MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
50 B1 = 3720B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
51 RES DRIVE, ABT 50
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
56 IF (SB EQ 7777B) GOTO 57         *IF HUNG BC 
   IF (SB(4) NE 7777B) GOTO 60      *IF BC OK 
57 B1 = 3723B                       *RESTART
   GOTO 65
60 IF (SB EQ 0) GOTO 64             *ASSUME NO DETAIL 
   IF (SB(6) AND 30 EQ 0) GOTO 64   *IF NOT A FLAW
   B1 = 3722B                       *FLAW 
   IF (P4 AND 1 NE 0) GOTO 65       *REPORT FLAW
   IF (SB(6) AND 10 NE 0) GOTO 62   *IF TRACK FLAW
61 B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 31 WHILE (B5+2.LE.27)      *IF SECTOR FLAW
62 IF (B5 AND 1 EQ 0) GOTO 63       *IF EVEN SECTOR 
   B5 = 1                           *SET FOR ODD SECTOR 
   GOTO 31 WHILE (B6+1 LE 22)       *NEXT TRACK 
   GOTO 42                          *LAST TRACK AND SECTOR
63 B5 = 0                           *SET EVEN SECTOR
   GOTO 31 WHILE (B6+1 LE 22)       *NEXT EVEN SECTOR, TRACK
   B5 = 1                           *SET ODD SECTOR 
   B6 = 0                           *START TRACK 0
   GOTO 31
64 B1 = 3720B                       *INSTRUCTION ERROR
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOSUB 51                         *RESERVE DRIVE
   IF (B1 NE 2) GOTO 66             *IF NOT FLAW ERROR
   IF (SB(6) AND 10 NE 0) GOTO 62   *UPDATE TRACK FROM FLAW 
66 GOTO 61                          *NEXT SECTOR
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71         *IF HUNG BC 
   IF (SB(4) NE 7777B) GOTO 72      *IF BC OK 
71 B1 = 3723B                       *RESTART
   GOTO 74
72 IF (SB EQ 0) GOTO 73             *ASSUME NO DETAIL 
   IF (SB(6) AND 30 EQ 0) GOTO 73   *IF NOT A FLAW
   B1 = 3722B                       *FLAW 
   IF (P4 AND 1 NE 0) GOTO 74       *REPORT FLAW
   IF (SB(6) AND 10 EQ 0) GOTO 40   *IF SECTOR FLAW 
   GOTO 41                          *NEXT TRACK 
73 B1 = 3720B                       *INSTRUCTION ERROR
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOSUB 51                         *RESERVE DRIVE
   IF (B1 NE 2) GOTO 75             *IF NOT FLAW ERROR
   IF (SB(6) AND 10 NE 0) GOTO 41   *UPDATE TRACK FROM FLAW 
75 GOTO 40                          *NEXT SECTOR
76 B1 = 3721B                       *COMPARE ERROR
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44313,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 2 TO 1 WRITE/READ TEST (CYLINDER MODE) 
/         READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED AND P6 =0, SET OUTPUT
*             BUFFER WITH THE DATA AS DESCRIBED.
*         2.  RESERVE DRIVE.
*         3.  IF A SET DATA PATTERN SELECTED, GO TO 4, ELSE 
*             READ THE FIRST SECTOR AS GIVEN FROM THE INPUT 
*             PARAMETERS AND GENERATE A RANDOM PATTERN DATA 
*             FROM THE SEED WORD OF THAT SECTOR.
*         4.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDER. 
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4431 - CANNOT READ DISK
 3 FORMAT D4431 - ERROR(S) IN MODULE
 4 FORMAT D4431 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
/         SET RANDOM PATTERN FOR VERIFY 
24 B5 = 0                           *LOWER SECTOR 
   B6 = 0                           *LOWER TRACK
25 B4 = 1 
   GOSUB 51                         *RESERVE DRIVE
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR WC, START IB(4)
27 B5 = 0                           *LOWER SECTOR 
   B6 = 0                           *LOWER TRACK
   GOSUB 51                         *RESERVE DRIVE
35 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 36       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 37
36 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
37 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
40 GOTO 35 WHILE (B5+2 LE 27)       *NEXT SECTOR
41 IF (B5 AND 1 EQ 0) GOTO 42       *IF ODD SECTORS 
   B5 = 0 
   GOTO 35 WHILE (B6+1 LE 22)       *IF NEXT EVEN SECTOR
   B5 = 1 
   B6 = 0 
   GOTO 35                          *NEXT FIRST SECTOR
42 B5 = 1 
   GOTO 35 WHILE (B6+1 LE 22)       *NEXT ODD SECTOR
43 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   B6 = 0                           *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
46 MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
50 B1 = 3730B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
51 RES DRIVE, ABT 50
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 3733B                      *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   B1 = 3732B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 66      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 GOTO 25 WHILE (B5+1 LE 27)      *TRY NEXT SECTOR 
64 GOTO 24 WHILE (B6+1 LE 22)      *TRY NEXT TRACK
   B6 = P2 RS 6                    *RESET LOWER TRACK 
   GOTO 24 WHILE (B7+1 LE P1)      *TRY NEXT TRACK
   MSG 1 TO LINE 1
   PICTURE
   HALT 
   GOTO 46                         *FLAWED AREA - END IT
65 B1 = 3730B                      *INSTRUCTION ERROR 
66 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 24     *IF REPEAT CONDITION 
   IF (B1 NE 2) GOTO 67            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *UPDATE TRACK FROM FLAW
67 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 3733B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 3732B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 40  *IF SECTOR FLAW
   GOTO 41                         *NEXT TRACK
73 B1 = 3730B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 51                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 41  *UPDATE TRACK FROM FLAW
75 GOTO 40                         *NEXT SECTOR 
76 B1 = 3731B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D4432,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         SEQUENTIAL 1 TO 1 WRITE/READ TEST (TRACK MODE)
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4432 SEQUENTIAL WRITE/READ TEST (TRACK MODE) 
 2 FORMAT D4432 - ERROR(S) IN MODULE
 3 FORMAT D4432 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4432 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4432 - SECTOR PARAM ERROR  P3 = *OCT 
 7 FORMAT D4432 - TRACK PARAM ERROR  P2 = *OCT
10 FORMAT D4432 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4432 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4432 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4432 - READ AND WRITE BOTH DISABLED
14 FORMAT D4432 - LOWER GREATER THAN UPPER SECTOR 
15 FORMAT D4432 - LOWER GREATER THAN UPPER TRACK
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                 *WORD COUNT
   B4 = P3 AND 77B           *UPPER SECTOR
   B5 = P3 RS 6              *LOWER SECTOR
   IF (B4 GT 27) GOTO 21     *IF SECTORS BAD
   IF (B5 LE 27) GOTO 22     *SECTORS OK
21 B3 = 1 
   MSG 6 (P3) TO LINE 2      *SECTOR ERROR MESSAGE
22 IF (B5 LE B4) GOTO 23     *IF LOWER LT UPPER SECTOR
   B3 = B3+1
   MSG 14 TO LINE 3          *SECTOR LOWER MESSAGE
23 B0 = P2 AND 77B           *UPPER TRACK 
   B6 = P2 RS 6              *LOWER TRACK 
   IF (B0 GT 22) GOTO 24     *IF BAD TRACK
   IF (B6 LE 22) GOTO 25     *IF TRACKS OK
24 B3 = B3+1
   MSG 7 (P2) TO LINE 4      *TRACK ERROR MESSAGE 
25 IF (B6 LE B0) GOTO 26     *IF LOWER LT UPPER TRACK 
   B3 = B3+1
   MSG 15 TO LINE 5          *TRACK LOWER MESSAGE 
26 B4 = 632                  *SINGLE DENSITY
   IF (DC EQ 2) GOTO 27      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 27      *IF 2X DRIVE 
   B4 = 1466                 *DOUBLE DENSITY
27 B7 = P0                   *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PREALLOCATED CYL                  D44012J
   IF (P0 LE B4) GOTO 30     *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 6     *LOWER CYLINDER MESSAGE
   B3 = B3+1
30 IF (P1 LE B4) GOTO 31     *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 7
   B3 = B3+1
31 IF (P0 LE P1) GOTO 36     *IF CYLINDER OK
   MSG 12 TO LINE 10         *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40  *WRITE NOT DISABLED
   IF (P5 AND 2 EQ 0) GOTO 45  *READ NOT DISABLED 
   MSG 13 TO LINE 11           *READ AND WRITE BOTH OFF 
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50        *WRITE IN DATA AREA
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50        *WRITE IN PREALLOCATED 
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50        *READ DATA AREA
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                     *IF MARGINS OK 
51 B3 = B3+1
   MSG 3 (P7) TO LINE 14       *MARGIN MESSAGE
55 IF (B3 NE 0) GOTO 65        *IF PARAMETER ERROR
   B3 = 0                      *CLEAR ERROR COUNTER 
   B2 = P3 AND 77B - B5        *MAX SECTOR - MIN SECTOR 
   IF (P5 AND 10 EQ 0) GOTO 56  *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC       *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61  *IF NO COMPARE 
   IF (P5 AND 4 EQ 0) GOTO 60  *IF WRITE SET
   EXIT TO 323                 *COMPARE DATA NO WRITE 
60 EXIT TO 322                 *COMPARE OVERLAY 
61 EXIT TO 321                 *NEXT OVERLAY
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44321,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 1 TO 1  WRITE/READ TEST (TRACK MODE) 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4432 - ERROR(S) IN MODULE
 4 FORMAT D4432 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27      *NOT RANDOM DATA SET
22 IF (P6 EQ 0) GOTO 24             *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
27 GOSUB 56                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 33       *IF WRITE DISABLED
   B4 = B2+1                        *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
/         WRITE ROUTINE 
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
33 IF (P5 AND 2 NE 0) GOTO 40       *IF READ DISABLED 
   B4 = B2+1                        *SECTORS FIRST PASS 
   B5 = P3 RS 6                     *LOWER SECTOR 
/         READ ROUTINE
34 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 40
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 41 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
41 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 42 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
42 GOTO 50 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
50 IF (B3 EQ 0) GOTO 52             *IF NO ERRORS 
51 MSG 3 TO DAYFILE 
52 PICTURE
   GOTO 77                          *END
55 B1 = 4010B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4013B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4012B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
63 B5 = B5+1
   GOTO 31 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 33
64 B1 = 4010B                      *INSTRUCTION ERROR 
65 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4013B                      *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B1 = 4012B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 75      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
73 B5 = B5+1
   GOTO 34 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 40                         *NEXT TRACK
74 B1 = 4010B                      *INSTRUCTION ERROR 
75 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 76            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
76 GOTO 73                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44322,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 1 TO 1 WRITE/READ TEST (TRACK MODE)
/         WRITE/READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4432 - ERROR(S) IN MODULE
 4 FORMAT D4432 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT  *START FROM REAL TIME
27 GOSUB 52                         *RESERVE DRIVE
   B4 = B2+1                        *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
/         WRITE ROUTINE 
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
33 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
34 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
36 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
37 GOTO 34 WHILE (B5+1 LE OB(504))  *COMPLETE FIRST PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
46 MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
51 B1 = 4020B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
52 RES DRIVE, ABT 51
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4023B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4022B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
63 B5 = B5+1
   GOTO 31 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 33                         *NEXT TRACK
64 B1 = 4020B                      *INSTRUCTION ERROR 
65 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 52                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4023B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4022B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
   GOTO 37                         *SECTOR FLAW 
73 B1 = 4020B                      *INSTRUCTION ERROR 
74 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 52                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 37                         *NEXT SECTOR 
76 B1 = 4021B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44323,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 1 TO 1 WRITE/READ TEST (TRACK MODE)
/         READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED AND P6 = 0, SET OUTPUT 
*             BUFFER WITH THE DATA AS DESCRIBED.
*         2.  RESERVE DRIVE.
*         3.  IF A SET DATA PATTERN SELECTED, GO TO 4, ELSE 
*             READ THE FIRST SECTOR AS GIVEN FROM THE INPUT 
*             PARAMETERS AND GENERATE A RANDOM PATTERN DATA 
*             FROM THE SEED WORD OF THAT SECTOR.
*         4.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         6.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         7.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*         8.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*         9.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4432 - CANNOT READ DISK
 3 FORMAT D4432 - ERROR(S) IN MODULE
 4 FORMAT D4432 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
/         SET RANDOM PATTERN FOR VERIFY 
24 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
25 B4 = 1 
   GOSUB 52                         *RESERVE DRIVE
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR WC, START IB(4)
27 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 52                         *RESERVE DRIVE
34 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
36 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
37 GOTO 34 WHILE (B5+1 LE OB(504))  *COMPLETE FIRST PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B6+1 GT B0)       *IF TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B6 = P2 RS 6                     *RESET LOWER TRACK
   GOTO 44 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
46 MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
51 B1 = 4030B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
52 RES DRIVE, ABT 51
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4033B                      *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   B1 = 4032B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 66      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 GOTO 25 WHILE (B5+1 LE OB(504))  *TRY NEXT SECTOR
64 GOTO 24 WHILE (B6+1 LE B0)      *TRY NEXT TRACK
   B6 = P2 RS 6                    *RESET LOWER TRACK 
   GOTO 24 WHILE (B7+1 LE P1)      *TRY NEXT TRACK
   MSG 1 TO LINE 1
   PICTURE
   HALT 
   GOTO 46                         *FLAWED AREA - END IT
65 B1 = 4030B                      *INSTRUCTION ERROR 
66 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 24     *IF REPEAT CONDITION 
   IF (B1 NE 2) GOTO 67            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *UPDATE TRACK FROM FLAW
67 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4033B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4032B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
   GOTO 37                         *SECTOR FLAW 
73 B1 = 4030B                      *INSTRUCTION ERROR 
74 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 52                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 37                         *NEXT SECTOR 
76 B1 = 4031B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D4433,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         SEQUENTIAL WRITE/READ TEST (CYLINDER MODE)
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4433 SEQUENTIAL WRITE/READ TEST (CYLINDER MODE)
 2 FORMAT D4433 - ERROR(S) IN MODULE
 3 FORMAT D4433 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4433 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
10 FORMAT D4433 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4433 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4433 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4433 - READ AND WRITE BOTH DISABLED
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                 *WORD COUNT
24 B4 = 632                  *SINGLE DENSITY
   IF (DC EQ 2) GOTO 25      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 25      *IF 2X DRIVE 
   B4 = 1466                 *DOUBLE DENSITY
25 IF (P0 LE B4) GOTO 26     *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 4     *LOWER CYLINDER MESSAGE
   B3 = B3+1
26 IF (P1 LE B4) GOTO 27     *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 5
   B3 = B3+1
27 B7 = P0                   *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE P1) GOTO 36     *IF CYLINDER OK
   MSG 12 TO LINE 6          *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40  *WRITE NOT DISABLED
   IF (P5 AND 2 EQ 0) GOTO 45  *READ NOT DISABLED 
   MSG 13 TO LINE 7            *READ AND WRITE BOTH OFF 
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50        *WRITE IN DATA AREA
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50        *WRITE IN PREALLOCATED 
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50        *READ DATA AREA
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                     *IF MARGINS OK 
51 B3 = B3+1
   MSG 3 (P7) TO LINE 11       *MARGIN MESSAGE
55 IF (B3 NE 0) GOTO 60        *IF PARAMETER ERROR
   B3 = 0                           *CLEAR ERROR COUNTER
   IF (P5 AND 10 EQ 0) GOTO 56      *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC           *START FROM P6
56 EXIT TO 331                      *NEXT OVERLAY 
60 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44331,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         SEQUENTIAL 1 TO 1 WRITE/READ TEST (CYLINDER MODE) 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  WRITE ALL SECTORS AT A 2/1 INTERLACE ON THE 
*             SELECTED CYLINDER.
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  READ ALL SECTORS AT A 2/1 INTERLACE ON THE
*             SELECTED CYLINDER COMPARING DATA EACH SECTOR. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDER. 
*         8.  THE TRACK COUNT IS INCREMENTED BY ONE AND THE 
*             ABOVE SEQUENCE IS REPEATED, UNTIL THE TRACK 
*             INPUT PARAMETERS ARE MET. 
*         9.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             THE ABOVE SEQUENCE IS REPEATED, UNTIL THE 
*             CYLINDER INPUT PARAMETERS ARE MET.
*        10.  CHECK FOR ANOTHER ITERATION OF THE TEST 
*             SEQUENCE, IF NOT, END MODULE. 
*        11.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4433 - ERROR(S) IN MODULE
 4 FORMAT D4433 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *RANDOM DATA SET 
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
/         WRITE ROUTINE 
27 GOSUB 47                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 33       *IF WRITE DISABLED
   B4 = 456D                        *SECTORS TO WRITE 
   B5 = 0                           *START SECTOR 
   B6 = 0                           *START TRACK
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 50 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 50 
33 IF (P5 AND 2 NE 0) GOTO 36       *IF READ DISABLED 
/         READ ROUTINE
   B4 = 456D                        *SECTORS TO WRITE 
   B5 = 0                           *START SECTOR 
   B6 = 0                           *START TRACK
34 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 65
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 65
36 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 37 WHILE (B7+1 GT P1)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
37 GOTO 40 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B7 = P0                          *SET LOW CYLINDER 
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
40 IF (B3 EQ 0) GOTO 41             *IF NO ERRORS 
   MSG 3 TO DAYFILE 
41 PICTURE
   GOTO 77                          *END
46 B1 = 4110B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
50 IF (SB EQ 7777B) GOTO 51        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 52     *IF BC OK
51 B1 = 4113B                      *RESTART 
   GOTO 57
52 IF (SB EQ 0) GOTO 56            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 56  *IF NOT A FLAW 
   B1 = 4112B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 57      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 54  *IF SECTOR FLAW
53 B5 = 0 
   GOTO 31 WHILE (B6+1 LE 22)      *NEXT READ TRACK 
   GOTO 33
54 GOTO 53 WHILE (B5+1 GT 27) 
   B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 31                         *IF SECTOR FLAW
56 B1 = 4110B                      *INSTRUCTION ERROR 
57 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 60            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 53  *UPDATE TRACK FROM FLAW
60 GOTO 54                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
65 IF (SB EQ 7777B) GOTO 66        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 67     *IF BC OK
66 B1 = 4113B                      *RESTART 
   GOTO 74
67 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4112B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 71  *IF SECTOR FLAW
70 B5 = 0 
   GOTO 34 WHILE (B6+1 LE 22) 
   GOTO 36
71 GOTO 70 WHILE (B5+1 GT 27) 
   B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 34
73 B1 = 4110B                      *INSTRUCTION ERROR 
74 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 70  *UPDATE TRACK FROM FLAW
75 GOTO 71                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4434,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         RANDOM WRITE/READ TEST
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 0 FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4434 RANDOM WRITE/READ TEST
 2 FORMAT D4434 - ERROR(S) IN MODULE
 3 FORMAT D4434 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4434 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4434 - SECTOR PARAM ERROR  P3 = *OCT 
 7 FORMAT D4434 - TRACK PARAM ERROR  P2 = *OCT
10 FORMAT D4434 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4434 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4434 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4434 - READ AND WRITE BOTH DISABLED
14 FORMAT D4434 - LOWER GREATER THAN UPPER SECTOR 
15 FORMAT D4434 - LOWER GREATER THAN UPPER TRACK
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                   *WORD COUNT
   OB(504) = P3 AND 77B        *UPPER SECTOR
   B5 = P3 RS 6                *LOWER SECTOR
   OB(503) = B5                *SAVE LOWER SECTOR 
   IF (OB(504) GT 27) GOTO 21  *IF SECTORS BAD
   IF (B5 LE 27) GOTO 22       *SECTORS OK
21 B3 = 1 
   MSG 6 (P3) TO LINE 2        *SECTOR ERROR MESSAGE
22 IF (B5 LE OB(504)) GOTO 23  *IF LOWER LT UPPER SECTOR
   B3 = B3+1
   MSG 14 TO LINE 3            *SECTOR LOWER MESSAGE
23 B0 = P2 AND 77B             *UPPER TRACK 
   B6 = P2 RS 6                *LOWER TRACK 
   IF (B0 GT 22) GOTO 24       *IF TRACKS BAD 
   IF (B6 LE 22) GOTO 25       *IF TRACKS OK
24 B3 = B3+1
   MSG 7 (P2) TO LINE 4        *TRACK ERROR MESSAGE 
25 IF (B6 LE B0) GOTO 26       *IF LOWER LT UPPER TRACK 
   B3 = B3+1
   MSG 15 TO LINE 5            *TRACK LOWER MESSAGE 
26 B4 = 632                    *SINGLE DENSITY
   IF (DC EQ 2) GOTO 27        *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 27        *IF 2X DRIVE 
   B4 = 1466                   *DOUBLE DENSITY
27 B7 = P0                     *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE B4) GOTO 30       *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 6       *LOWER CYLINDER MESSAGE
   B3 = B3+1
30 IF (P1 LE B4) GOTO 31       *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 7
   B3 = B3+1
31 IF (P0 LE P1) GOTO 36       *IF CYLINDERS GOOD 
   MSG 12 TO LINE 10           *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40  *WRITE NOT DISABLED
   IF (P5 AND 2 EQ 0) GOTO 45  *READ NOT DISABLED 
   MSG 13 TO LINE 11           *READ AND WRITE BOTH OFF 
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50        *WRITE IN DATA AREA
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50        *WRITE IN PREALLOCATED 
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50        *READ DATA AREA
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                     *IF MARGINS OK 
51 B3 = B3+1
   MSG 3 (P7) TO LINE 14       *MARGIN MESSAGE
55 IF (B3 NE 0) GOTO 65        *IF PARAMETER ERROR
   B2 = 0                           *CLEAR FOR PASS COUNT 
   B3 = 0                           *CLEAR ERROR COUNTER
   IF (P5 AND 10 EQ 0) GOTO 56      *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC           *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61  *IF NO COMPARE 
60 EXIT TO 342                 *COMPARE OVERLAY 
61 EXIT TO 341                 *NEXT OVERLAY
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44341,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         RANDOM WRITE/READ TEST
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  CALULATE A RANDOM CYLINDER, TRACK AND SECTOR
*             WITHIN THE CONFINES OF THE INPUT PARAMETERS.
*         3.  RESERVE DRIVE.
*         4.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         5.  WRITE (CODED OR NON-CODED AS PARAMETER
*             SELECTED) THE CYLINDER, TRACK AND SECTOR AS 
*             DESCRIBED ABOVE.
*         6.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         7.  READ (CODED OR NON-CODED AS PARAMETER 
*             SELECTED) THE CYLINDER, TRACK AND SECTOR AS 
*             DESCRIBED ABOVE.
*         8.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDR, TRACK, AND SECTOR. 
*         9.  THE ABOVE IS REPEATED 4096 TIMES.  IF THE 
*             ITERATION COUNT IS SET, REPEAT 4096 TIMES FOR 
*             EACH COUNT IN THE ITERATION REGISTER. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4434 - ERROR(S) IN MODULE
 4 FORMAT D4434 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 23       *SET DATA PATTERN
21 IF (P6 EQ 0) GOTO 22              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 23
22 RANDOM TO OB(4) FOR WC, START RT 
23 RANDOM TO IB(1) FOR WC, START RT  *SET INPUT BUFFER
   B4 = 0 
   IF (P0 EQ P1) GOTO 25             *IF SAME CYLINDERS 
24 GOTO 23 WHILE (B4+1 GE WC)        *IF NO CYLINDER FOUND
   B7 = IB(B4) AND 1777B             *RANDOM CYLINDER 
   IF (B7 LT P0) GOTO 24
   IF (B7 GT P1) GOTO 24
25 B1 = P2 RS 6                      *LOWER TRACK 
   IF (B1 EQ B0) GOTO 27             *IF SAME TRACKS
   B4 = 0 
26 GOTO 23 WHILE (B4+1 GE WC)        *IF NO TRACK FOUND 
   B6 = IB(B4) AND 37B               *RANDOM TRACK
   IF (B6 GT B0) GOTO 26             *LARGER UPPER TRACK
   IF (B6 LT B1) GOTO 26             *IF CYLINDER TOO LARGE 
27 IF (OB(504) EQ OB(503)) GOTO 35   *SECTORS EQUAL 
   B4 = 0 
30 GOTO 23 WHILE (B4+1 GE WC)        *IF NO SECTOR FOUND
   B5 = IB(B4) AND 37B               *SET SECTOR
   IF (B5 GT OB(504)) GOTO 30        *IF SECTOR TOO LARGE 
   IF (B5 LT OB(503)) GOTO 30        *IF SECTOR TOO SMALL 
35 GOSUB 56                          *RESERVE DRIVE 
   B4 = 1                            *ONE SECTOR
   IF (P5 AND 4 NE 0) GOTO 40        *IF WRITE DISABLED 
/         WRITE ROUTINE 
   MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 36        *IF CODED NOT SELECTED 
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 40
36 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
40 IF (P5 AND 2 NE 0) GOTO 42       *IF READ DISABLED 
/         READ ROUTINE
   MSG 4 (B7 B6 B5) TO DISPLAY
   B4 = 1                           *ONE SECTOR 
   IF (P5 AND 1 NE 0) GOTO 41       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 42
41 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
  
42 IF (ES AND RC NE 0) GOTO 35      *IF REPEAT CONDITION
43 REL, ABT 74
45 GOTO 50 WHILE (B2+1 GE 7777B)    *PASS COUNT 
   GOTO 20                          *START OVER 
50 B2 = 0                           *CLEAR PASS COUNT 
   GOTO 51 WHILE (BA+1 GT P8)       *ITERATION COUNT
   GOTO 20                          *RESTART TEST 
51 IF (B3 EQ 0) GOTO 52             *IF NO ERRORS 
   MSG 1 TO DAYFILE 
52 PICTURE
   GOTO 77                          *END
55 B1 = 4210B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4213B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4212B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   GOTO 42                         *NEXT ITIERATION 
64 B1 = 4210B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 EQ 2) GOTO 42            *IF A FLAW 
   GOTO 40                         *NEXT ITERATION
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4213B                      *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B1 = 4212B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 75      *REPORT FLAW 
   GOTO 42                         *NEXT ITERATION
74 B1 = 4210B                      *INSTRUCTION ERROR 
75 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   GOTO 42                         *NEXT ITERATION
77 END 20 
COMPILE 
   MODULE D44342,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         RANDOM WRITE/READ COMPARE DATA TEST 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  CALULATE A RANDOM CYLINDER, TRACK AND SECTOR
*             WITHIN THE CONFINES OF THE INPUT PARAMETERS.
*         3.  RESERVE DRIVE.
*         4.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         5.  WRITE (CODED OR NON-CODED AS PARAMETER
*             SELECTED) THE CYLINDER, TRACK AND SECTOR AS 
*             DESCRIBED ABOVE.
*         6.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         7.  READ (CODED OR NON-CODED AS PARAMETER 
*             SELECTED) THE CYLINDER, TRACK AND SECTOR AS 
*             DESCRIBED ABOVE AND COMPARE DATA. 
*         8.  REPEAT CONDITION LOOPS ON THE CURRENT 
*             CYLINDER, TRACK AND SECTOR. 
*         9.  THE ABOVE IS REPEATED 4096 TIMES.  IF THE 
*             ITERATION COUNT IS SET, REPEAT 4096 TIMES FOR 
*             EACH COUNT IN THE ITERATION REGISTER. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4434 - ERROR(S) IN MODULE
 4 FORMAT D4434 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 23        *SET DATA PATTERN 
21 IF (P6 EQ 0) GOTO 22               *RANDOM STARTER WANTED
   RANDOM TO OB(4) FOR WC, START P6   *START FOR INPUT PARAM
   GOTO 23
22 RANDOM TO OB(4) FOR WC, START RT   *START FROM REAL TIME 
23 RANDOM TO IB(1) FOR WC, START RT  *SET INPUT BUFFER
   B4 = 0 
   IF (P0 EQ P1) GOTO 25             *IF SAME CYLINDERS 
24 GOTO 23 WHILE (B4+1 GE WC)        *IF NO CYLINDER FOUND
   B7 = IB(B4) AND 1777B             *RANDOM CYLINDER 
   IF (B7 LT P0) GOTO 24             *IF CYLINDER TOO SMALL 
   IF (B7 GT P1) GOTO 24             *IF CYLINDER TOO LARGE 
25 B1 = P2 RS 6                      *LOWER TRACK 
   IF (B1 EQ B0) GOTO 27             *IF SAME TRACKS
   B4 = 0 
26 GOTO 23 WHILE (B4+1 GE WC)        *IF NO TRACK FOUND 
   B6 = IB(B4) AND 37B               *RANDOM TRACK
   IF (B6 GT B0) GOTO 26             *LARGER UPPER TRACK
   IF (B6 LT B1) GOTO 26             *SMALLER LOWER TRACK 
27 IF (OB(504) EQ OB(503)) GOTO 35   *SECTORS EQUAL 
   B4 = 0 
30 GOTO 23 WHILE (B4+1 GE WC)        *IF NO SECTOR FOUND
   B5 = IB(B4) AND 37B               *SET SECTOR
   IF (B5 GT OB(504)) GOTO 30        *IF SECTOR TOO LARGE 
   IF (B5 LT OB(503)) GOTO 30        *IF SECTOR TOO SMALL 
35 GOSUB 57                          *RESERVE DRIVE 
   B4 = 1                            *ONE SECTOR
   IF (P5 AND 4 NE 0) GOTO 40        *IF WRITE DISABLED 
/         WRITE ROUTINE 
   MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 36        *IF CODED NOT SELECTED 
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 40
36 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
40 IF (P5 AND 2 NE 0) GOTO 45       *IF READ DISABLED 
   MSG 4 (B7 B6 B5) TO DISPLAY
   B4 = 1                           *ONE SECTOR 
   IF (P5 AND 1 NE 0) GOTO 41       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 44
41 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
44 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
45 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
46 REL, ABT 74
50 GOTO 52 WHILE (B2+1 GE 7777B)    *PASS COUNT 
   GOTO 20                          *START OVER 
52 B2 = 0                           *CLEAR PASS COUNT 
   GOTO 53 WHILE (BA+1 GT P8)       *ITERATION COUNT
   GOTO 20                          *RESTART TEST 
53 IF (B3 EQ 0) GOTO 55             *IF NO ERRORS 
   MSG 1 TO DAYFILE 
55 PICTURE
   GOTO 77                          *END
56 B1 = 4220B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
57 RES DRIVE, ABT 56
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4223B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4222B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   GOTO 45                         *NEXT ITERATION
64 B1 = 4220B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   GOSUB 57                        *RESERVE DRIVE 
   IF (B1 EQ 2) GOTO 40            *IF NOT FLAW ERROR 
   GOTO 40                         *READ
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4223B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4222B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   GOTO 45                         *NEXT ITERATION
73 B1 = 4220B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   GOSUB 57                        *RESERVE DRIVE 
   GOTO 45                         *NEXT ITERATION
76 B1 = 4221B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D4435,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         TRACK MODE SURFACE TEST.
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK VALIDITY OF INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  PASS 1. 
*         5.  RESERVE THE DISK FILE.
*         6.  STARTING AT CYLINDER P0 WRITE RANDOM DATA, AT 
*             2/1 INTERLACE THROUGH CYLINDER P1. IF P0 AND
*             P1 ARE BOTH ZERO THE ENTIRE DISK SURFACE WILL 
*             BE WRITTEN. 
*         7.  THE EXISTING SECTOR AND TRACK FLAWS ARE MAP-
*             PED, ALONG WITH ANY OTHER ERRORS DISPLAYED
*             THROUGH THE ERROR SUBROUTINE 98A. 
*             CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         8.  PASS 2 - NORMAL MARGINS.
*         9.  PASS 3 - SET MARGINS TO REVERSE OFFSET AND
*                      EARLY STROBES. 
*        10.  PASS 4 - SET MARGINS TO REVERSE OFFSET AND
*                      LATE STROBES.
*        11.  PASS 5 - SET MARGINS TO FORWARD OFFSET AND
*                      EARLY STROBES. 
*        12.  PASS 6 - SET MARGINS TO FORWARD OFFSET AND
*                      LATE STROBES.
*             PASS 2 THRU 6 START AT CYLINDER P0 AND
*             WRITE THEN READ AT A 2/1 INTERLACE, TRACK 
*             MODE, THRU CYLINDER P1. IF P0 AND P1 THE
*             ENTIRE DISK FILE WILL BE DONE.  FLAWS ARE 
*             NOT RECORDED ON THESE PASSES.  THE DATA 
*             BUFFER IS CHANGED ON EACH NEW PASS. 
* 
*    REGISTER USAGE 
* 
*         B0 = RANDOM BUFFER DUP COUNT. 
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = PASS COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
*     INPUT REGISTER USAGE
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
* 
 1 FORMAT D4435 SURFACE TEST (TRACK MODE) 
 2 FORMAT D4435 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
 3 FORMAT D4435 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
 4 FORMAT D4435 - CYL *OCT, TRK *OCT, SEC *OCT
 5 FORMAT //D4435 - NOT EXECUTED, NEEDS AL=0004, AL=*OCT // 
 6 FORMAT SECTOR FLAW - CYL *OCT, TRACK *OCT, SECTOR *OCT 
 7 FORMAT /TRACK FLAW - CYL *OCT, TRACK *OCT, SECTOR *OCT 
10 FORMAT D4435 - LOWER GREATER THAN UPPER CYLINDER 
11 FORMAT ///  PASS 1 /// 
20 MSG 1 TO DISPLAY, PRINT
   B0 = 474                  *RANDOM BUFFER SIZE
   B4 = 14                   *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   OB(504) = 632
   IF (DC.EQ.2) GOTO 17      *IF 2X DRIVE 
   IF (DC.EQ.4) GOTO 17      *IF 2X DRIVE 
   OB(504) = 1466 
17 IF (AL.GE.4) GOTO 21      *AL OK FOR OUTSIDE PREALLOCATED
   B8 = OB(504) 
   IF (B8-2.GT.P0) GOTO 46   *AL TOO LOW
21 IF (P0.GT.OB(504)) GOTO 40   *P0 PARAMETER ERROR 
   IF (P1.GT.OB(504)) GOTO 42   *P1 PARAMETER ERROR 
   IF (P1.LT.P0) GOTO 44     *LOWER CYLINDER GREATER THAN UPPER 
   B7 = P0                   *SET STARTING CYLINDER 
   IF (P1.EQ.0) GOTO 22      *P0 AND P1 ZERO DO ENTIRE PACK 
   OB(504) = P1              *SET ENDING CYLINDER 
22 RANDOM TO OB(4) FOR B0, START RT 
   MSG 11 TO PRINT
23 GOSUB 51                         *RESERVE DRIVE
24 MSG 4 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
25 B4 = 14                          *RESET SECTORS
   IF (B5 EQ 27) GOTO 27
26 B5 = 1                           *SET ODD SECTOR 
   GOTO 24                          *READ ODD SECTORS 
27 B5 = 0                           *EVEN SECTOR
   B4 = 14                          *RESET SECTORS
   GOTO 23 WHILE (B6+1 LE 22)       *IF OTHER TRACK 
   B6 = 0                           *RESET TRACK
   GOTO 23 WHILE(B7+1 LE OB(504)) 
   REL, ABT 64
   EXIT TO 351                      *EXIT TO NEXT OVERLAY 
32 PICTURE
   GOTO 77                          *END IT 
40 MSG 2 (P0) TO LINE 2          *LOWER CYLINDER PARAMETER ERROR
   GOTO 32
42 MSG 3 (P1) TO LINE 2          *UPPER CYLINDER PARAMETER ERROR
   GOTO 32
44 MSG 10 TO LINE 2              *LOWER CYLINDER GREATER THAN UPPER 
   GOTO 32
46 MSG 5 (AL) TO LINE 12     *AL TOO LOW
   GOTO 32                   *EXIT
50 B1 = 4300B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
51 RES DRIVE, ABT 50
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 433B                       *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   B3= B3+1                        *ERROR COUNT 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   MSG 7 (B7 B6 B5) TO PRINT       *TRACK FLAW MESSAGE
   GOTO 27                         *NEXT TRACK
63 MSG 6 (B7 B6 B5) TO PRINT       *SECTOR FLAW MESSAGE 
64 B5 = B5+2
   GOTO 23 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOSUB 51                        *RESERVE DRIVE 
   IF (B5 AND 1 EQ 0) GOTO 26      *IF ODD SECTORS LEFT 
   GOTO 27                         *NEXT TRACK
65 B1 = 430B                       *INSTRUCTION ERROR 
66 CALL 98A                        *CALL ERROR PROCESSOR
   GOTO 64                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44351,844HT(02,03,04,05),LOCK
 1 FORMAT ///  PASS *DEC  /// 
 2 FORMAT MARGIN ERROR - ABORT
 3 FORMAT D4435 - ERROR(S) IN MODULE
 4 FORMAT D4435 - CYL *OCT, TRK *OCT, SEC *OCT
20 B2 = 2                    *PASS 2
   MSG 1 (B2) TO PRINT
   GOSUB 21 
   MARGINS REV OFFSET EARLY STROBES, ABT 57 
   B2 = 3                    *PASS 3
   MSG 1 (B2) TO PRINT
   GOSUB 21 
   MARGINS REV OFFSET LATE STROBES, ABT 57
   B2 = 4                    *PASS 4
   MSG 1 (B2) TO PRINT
   GOSUB 21 
   MARGINS FWD OFFSET EARLY STROBES, ABT 57 
   B2 = 5                    *PASS 5
   MSG 1 (B2) TO PRINT
   GOSUB 21 
   MARGINS FWD OFFSET LATE STROBES, ABT 57
   B2 = 6                    *PASS 6
   MSG 1 (B2) TO PRINT
   GOSUB 21 
   GOTO 40                   *END IT
/         WRITE READ
21 B0 = 474                  *RANDOM BUFFER SIZE
   B4 = 14                   *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *RESET SECTOR
   B6 = 0                    *RESET TRACK 
   B7 = P0                   *RESET CYLINDER
22 RANDOM TO OB(4) FOR B0, START RT 
23 GOSUB 47                         *RESERVE DRIVE
24 MSG 4 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
25 B4 = 14                          *RESET SECTORS
   IF (B5 EQ 27) GOTO 27            *IF SECTORS COMPLETED 
26 B5 = 1                           *SET ODD SECTOR 
   GOTO 24                          *READ ODD SECTORS 
27 B4 = 14
   B5 = 0 
30 GOSUB 47                         *RESERVE DRIVE
31 MSG 4 (B7 B6 B5) TO DISPLAY
32 VERIFY B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   B4 = 14
   IF (B5 EQ 27) GOTO 34            *IF SECTORS COMPLETED 
33 B5 = 1 
   GOTO 31                          *VERIFY ODD SECTORS 
34 B5 = 0                           *EVEN SECTOR
   B4 = 14                          *INSURE SECTORS SET 
   GOTO 23 WHILE (B6+1 LE 22)       *IF OTHER TRACK 
   B6 = 0                           *RESET TRACK
   GOTO 23 WHILE(B7+1 LE OB(504)) 
   RETURN 
/         END ROUTINE 
40 IF (B3 EQ 0) GOTO 42      *IF NO ERRORS
41 MSG 3 TO DAYFILE 
42 PICTURE
   GOTO 77                          *END
46 B1 = 4310B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
57 MSG 2 TO LINE 1                 *MARGIN ERROR
   GOTO 41                         *END IT
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 433B                       *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B3 = B3+1                       *ERROR COUNTER 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   GOTO 34                         *NEXT TRACK
63 B5 = B5+2
   GOTO 23 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B5 AND 1 EQ 0) GOTO 26      *IF ODD SECTOR LEFT
   GOTO 27                         *NEXT TRACK
64 B1 = 430B                       *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR
   GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 433B                       *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B3 = B3+1                       *ERROR COUNT 
   IF (SB(6) AND 10 EQ 0) GOTO 73  *IF SECTOR FLAW
   GOTO 34                         *NEXT TRACK
73 B5 = B5+2
   GOTO 30 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B5 AND 1 EQ 0) GOTO 33      *IF ODD SECTORS LEFT 
   GOTO 34                         *NEXT TRACK
74 B1 = 430B                       *INSTRUCTION ERROR 
75 CALL 98A                        *CALL ERROR PROCESSOR
   GOTO 73                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4436,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         CYLINDER MODE SURFACE TEST. 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK VALIDITY OF INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  PASS 1. 
*         5.  RESERVE THE DISK FILE.
*         6.  STARTING AT CYLINDER P0 WRITE RANDOM DATA, AT 
*             1/1 INTERLACE THROUGH CYLINDER P1. IF P0 AND
*             P1 ARE BOTH ZERO THE ENTIRE DISK SUFACE WILL
*             BE WRITTEN. 
*         7.  THE EXISTING SECTOR AND TRACK FLAWS ARE MAP-
*             PED, ALONG WITH ANY OTHER ERRORS DISPLAYED
*             THROUGH THE ERROR SUBROUTINE 98A. 
*             CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         8.  PASS 2 - NORMAL MARGINS.
*         9.  PASS 3 - SET MARGINS TO REVERSE OFFSET AND
*                      EARLY STROBES. 
*        10.  PASS 4 - SET MARGINS TO REVERSE OFFSET AND
*                      LATE STROBES.
*        11.  PASS 5 - SET MARGINS TO FORWARD OFFSET AND
*                      EARLY STROBES. 
*        12.  PASS 6 - SET MARGINS TO FORWARD OFFSET AND
*                      LATE STROBES.
*             PASS 2 THRU 6 START AT CYLINDER P0 AND
*             WRITE THEN READ AT A 1/1 INTERLACE, CYLINDER
*             MODE, THRU CYLINDER P1. IF P0 AND P1 THE
*             ENTIRE DISK FILE WILL BE DONE.  FLAWS ARE 
*             NOT RECORDED ON THESE PASSES.  THE DATA 
*             BUFFER IS CHANGED ON EACH NEW PASS. 
* 
*    REGISTER USAGE 
* 
*         B0 = DUP BUFFER SIZE. 
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B2 = PASS COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
*     INPUT REGISTER USAGE
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
* 
 1 FORMAT D4436 SURFACE TEST (CYLINDER MODE)
 2 FORMAT ///  PASS 1  ///
 4 FORMAT D4436 - CYL *OCT, TRK *OCT, SEC *OCT
 5 FORMAT //D4436 - NOT EXECUTED, NEEDS AL=0004, AL=*OCT // 
 6 FORMAT SECTOR FLAW - CYL *OCT, TRACK *OCT, SECTOR *OCT 
 7 FORMAT /TRACK FLAW - CYL *OCT, TRACK *OCT, SECTOR *OCT 
10 FORMAT D4436 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4436 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4436 - LOWER GREATER THAN UPPER CYLINDER 
20 MSG 1 TO DISPLAY, PRINT
   B0 = 474                  *COMPARE SET 
   B4 = 456D                 *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   OB(504) = 632
   IF (DC.EQ.2) GOTO 17      *IF 2X DRIVE 
   IF (DC.EQ.4) GOTO 17      *IF 2X DRIVE 
   OB(504) = 1466 
17 IF (AL.GE.4) GOTO 21      *AL OK FOR OUTSIDE PREALLOCATED
   B8 = OB(504) 
   IF (B8-2.GT.P0) GOTO 46   *AL TOO LOW
21 IF (P0.GT.OB(504)) GOTO 40   *P0 PARAMETER ERROR 
   IF (P1.GT.OB(504)) GOTO 42   *P1 PARAMETER ERROR 
   IF (P1.LT.P0) GOTO 44     *LOWER CYLINDER GREATER THAN UPPER 
   B7 = P0                   *SET STARTING CYLINDER 
   IF (P1.EQ.0) GOTO 23      *P0 AND P1 ZERO DO ENTIRE PACK 
   OB(504) = P1              *SET ENDING CYLINDER 
23 RANDOM TO OB(4) FOR B0, START RT 
   MSG 2 TO PRINT                   *PASS COUNT MESSAGE 
24 GOSUB 56                         *RESERVE DRIVE
   MSG 4 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
26 B4 = 456D                        *RESET SECTORS
   B5 = 0 
   B6 = 0 
   GOTO 24 WHILE (B7+1 LE OB(504))  *NEXT CYLINDER
   REL, ABT 67
   EXIT TO 361                      *CALL OVERLAY 
32 PICTURE
   GOTO 77                          *END IT 
40 MSG 10 (P0) TO LINE 2         *LOWER CYLINDER PARAMETER ERROR
   GOTO 32
42 MSG 11 (P1) TO LINE 2         *UPPER CYLINDER PARAMETER ERROR
   GOTO 32
44 MSG 12 TO LINE 2              *LOWER CYLINDER GREATER THAN UPPER 
   GOTO 32
46 MSG 5 (AL) TO LINE 12         *AL TOO LOW
   GOTO 32                   *EXIT
55 B1 = 4400B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61         *IF HUNG BC 
   IF (SB(4) NE 7777B) GOTO 62      *IF BC OK 
61 B1 = 443B                        *RESTART
   GOTO 70
62 IF (SB EQ 0) GOTO 67             *ASSUME NO DETAIL 
   IF (SB(6) AND 30 EQ 0) GOTO 67   *IF NOT A FLAW
   B3 = B3+1
   IF (SB(6) AND 10 EQ 0) GOTO 64   *IF SECTOR FLAW 
   MSG 7 (B7 B6 B5) TO PRINT        *TRACK FLAW MESSAGE 
63 B5 = 0                           *RESET SECTOR 
   GOTO 24 WHILE (B6+1 LE 22)       *IF NOT LAST TRACK
   GOTO 26                          *DO NEXT CYLINDER 
64 MSG 6 (B7 B6 B5) TO PRINT        *SECTOR FLAW MESSAGE
65 GOTO 63 WHILE (B5+1 GT 27)       *IF MAX SECTOR
   B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 24                          *NEXT CYLINDER
67 B1 = 440B                        *INSTRUCTION ERROR
70 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   GOTO 65                          *NEXT SECTOR
77 END 20 
COMPILE 
   MODULE D44361,844FT(02,03,04,05),LOCK
 1 FORMAT D4436 PREALLOCATED AREA WRITE 
 2 FORMAT ///  PASS *DEC  /// 
 3 FORMAT D4436 - ERROR(S) IN MODULE
 4 FORMAT D4436 - CYL *OCT, TRK *OCT, SEC *OCT
11 FORMAT MARGIN ERROR - ABORT
20 B2 = 2                    *PASS 2
   MSG 2 (B2) TO PRINT
   GOSUB 40 
   MARGINS REV OFFSET EARLY STROBES, ABT 57 
   B2 = 3                    *PASS 3
   MSG 2 (B2) TO PRINT
   GOSUB 40 
   MARGINS REV OFFSET LATE STROBES, ABT 57
   B2 = 4                    *PASS 4
   MSG 2 (B2) TO PRINT
   GOSUB 40 
   MARGINS FWD OFFSET EARLY STROBES, ABT 57 
   B2 = 5                    *PASS 5
   MSG 2 (B2) TO PRINT
   GOSUB 40 
   MARGINS FWD OFFSET LATE STROBES, ABT 57
   B2 = 6                    *PASS 6
   MSG 2 (B2) TO PRINT
   GOSUB 40 
30 IF (B3 EQ 0) GOTO 32            *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   GOTO 77
/         WRITE - VERIFY SUB ROUTINE
40 B0 = 474                  *COMPARE SET 
   B4 = 456D                 *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *RESET SECTOR
   B6 = 0                    *RESET TRACK 
   B7 = P0                   *RESET CYLINDER
   RANDOM TO OB(4) FOR B0, START RT 
42 GOSUB 54                         *RESERVE DRIVE
   MSG 4 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
44 B4 = 456D                        *RESET SECTORS
   B5 = 0 
   B6 = 0 
45 GOSUB 54                         *RESERVE DRIVE
   MSG 4 (B7 B6 B5) TO DISPLAY
   VERIFY B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 65
   GOTO 46
65 STATUS GENERAL,ABT 70
   STATUS DETAIL,ABT 70 
   GOTO 70
46 B4 = 456D
   B6 = 0 
   B5 = 0 
   GOTO 42 WHILE (B7+1 LE OB(504))  *NEXT CYLINDER
   REL, ABT 75
   RETURN 
53 B1 = 4410B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
54 RES DRIVE, ABT 53
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
57 MSG 11 TO DISPLAY               *MARIN ERROR MESSAGE 
   GOTO 31                         *END IT
60 IF (SB EQ 7777B) GOTO 61        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 443B                       *RESTART 
   GOTO 67
62 IF (SB EQ 0) GOTO 66            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 66  *IF NOT A FLAW 
   B3 = B3+1                       *ERROR COUNT 
   IF (SB(6) AND 10 EQ 0) GOTO 64  *IF SECTOR FLAW
63 B5 = 0 
   GOTO 42 WHILE (B6+1 LE 22)      *NEXT TRACK
   GOTO 44                         *IF LAST TRACK 
64 GOTO 63 WHILE (B5+1 GT 27)      *IF MAX SECTOR 
   B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 42                         *NEXT SECTOR 
66 B1 = 440B
67 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   GOTO 64                         *NEXT SECTOR 
/         ERROR ROUTINES
70 IF (SB EQ 7777B) GOTO 71        *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 443B                       *RESTART 
   GOTO 76
72 IF (SB EQ 0) GOTO 75            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 75  *IF NOT A FLAW 
   B3 = B3+1                       *ERROR COUNT 
   IF (SB(6) AND 10 EQ 0) GOTO 74  *IF SECTOR FLAW
73 B5 = 0 
   GOTO 45 WHILE (B6+1 LE 22)      *IF MORE TRACKS
   GOTO 46                         *NEXT CYLINDER 
74 GOTO 73 WHILE (B5+1 GT 27)      *IF MAX SECTOR 
   B4 = B4 - 1                     *DECREMENT SECTOR COUNT
   GOTO 45                         *NEXT CYLINDER 
75 B1 = 440B
76 CALL 98F                      *CALL ERROR PROCESSOR                   D44015J
   GOTO 74                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4437,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         HEAD TEST 2 TO 1  (TRACK GROUPS)
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB-MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4437 HEAD TEST 2/1   (TRACK GROUPS)
 2 FORMAT D4437 - ERROR(S) IN MODULE
 3 FORMAT D4437 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4437 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4437 - SECTOR PARAM ERROR  P3 = *OCT 
 7 FORMAT D4437 - TRACK PARAM ERROR  P2 = *OCT
10 FORMAT D4437 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4437 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4437 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4437 - READ AND WRITE BOTH DISABLED
14 FORMAT D4437 - LOWER GREATER THAN UPPER SECTOR 
15 FORMAT D4437 - LOWER GREATER THAN UPPER TRACK
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                 *WORD COUNT
   B4 = P3 AND 77B           *UPPER SECTOR
   B5 = P3 RS 6              *LOWER SECTOR
   IF (B4 GT 27) GOTO 21
   IF (B5 LE 27) GOTO 22     *SECTORS OK
21 B3 = 1 
   MSG 6 (P3) TO LINE 2      *SECTOR ERROR MESSAGE
22 IF (B5 LE B4) GOTO 23     *IF LOWER LT UPPER SECTOR
   B3 = B3+1
   MSG 14 TO LINE 3          *SECTOR LOWER MESSAGE
23 B0 = P2 AND 77B           *UPPER TRACK 
   B6 = P2 RS 6              *LOWER TRACK 
   IF (B0 GT 22) GOTO 24
   IF (B6 LE 22) GOTO 25     *IF TRACKS OK
24 B3 = B3+1
   MSG 7 (P2) TO LINE 4      *TRACK ERROR MESSAGE 
25 IF (B6 LE B0) GOTO 26     *IF LOWER LT UPPER TRACK 
   B3 = B3+1
   MSG 15 TO LINE 5          *TRACK LOWER MESSAGE 
26 B4 = 632                  *SINGLE DENSITY
   IF (DC EQ 2) GOTO 27      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 27      *IF 2X DRIVE 
   B4 = 1466                 *DOUBLE DENSITY
27 B7 = P0                   *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE B4) GOTO 30     *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 6     *LOWER CYLINDER MESSAGE
   B3 = B3+1
30 IF (P1 LE B4) GOTO 31     *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 7
   B3 = B3+1
31 IF (P0 LE P1) GOTO 36     *IF CYLINDERS OK 
   MSG 12 TO LINE 10         *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40   *WRITE NOT DISABLED 
   IF (P5 AND 2 EQ 0) GOTO 45   *READ NOT DISABLED
   MSG 13 TO LINE 11            *READ AND WRITE BOTH OFF
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44013J
   IF (AL GE 4) GOTO 50         *WRITE IN DATA AREA 
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50         *WRITE IN PREALLOCATED
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50         *READ DATA AREA 
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                      *IF MARGINS OK
51 B3 = B3+1
   MSG 3 (P7) TO LINE 14        *MARGIN MESSAGE 
55 IF (B3 NE 0) GOTO 65         *IF PARAMETER ERROR 
   B3 = 0                       *CLEAR ERROR COUNTER
   B2 = P3 AND 77B - B5         *MAX SECTOR - MIN SECTOR
   IF (P5 AND 10 EQ 0) GOTO 56  *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC       *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61   *IF NO COMPARE
   IF (P5 AND 4 EQ 0) GOTO 60   *IF WRITE SET 
   EXIT TO 373                  *COMPARE DATA WITH NO WRITE 
60 EXIT TO 372                  *COMPARE OVERLAY
61 EXIT TO 371                  *NEXT OVERLAY 
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44371,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST 2 TO 1  (TRACK GROUPS)
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         9.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*         8.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4437 - ERROR(S) IN MODULE
 4 FORMAT D4437 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
27 GOSUB 44                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 32       *IF WRITE DISABLED
   B4 = B2+2 RS 1                   *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 45                         *WRITE ROUTINE
   B4 = B2+1 RS 1                   *RESET SECTORS SECOND 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 32             *ONE SECTOR WRITE 
   GOSUB 45                         *WRITE ROUTINE
32 IF (P5 AND 2 NE 0) GOTO 33       *IF READ DISABLED 
   B4 = B2+2 RS 1                   *SECTORS FIRST PASS 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 52                         *READ ROUTINE 
   B4 = B2+1 RS 1                   *RESET SECTORS LEFT 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 33             *ONE SECTOR READ
   GOSUB 52                         *READ ROUTINE 
33 ENDSUB 
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 35 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
35 B7 = P0                          *LOWER CYLINDER 
   GOTO 37 WHILE (B6+1 GT B0)       *LAST TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
37 GOTO 40 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *LOWER TRACK
   GOTO 20                          *RESTART TEST 
40 IF (B3 EQ 0) GOTO 42             *IF NO ERRORS 
41 MSG 3 TO DAYFILE 
42 PICTURE
   GOTO 77                          *END
43 B1 = 4510B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
44 RES DRIVE, ABT 43
   RETURN                           *RETURN TO CALL 
/         WRITE/READ ROUTINES 
45 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 47       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 50
47 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
50 RETURN 
52 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 54       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 56
54 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
56 RETURN 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4513B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4512B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   GOTO 33                         *NEXT CYLINDER 
63 B5 = B5+2
   GOTO 45 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 50                         *NEXT CYLINDER 
64 B1 = 4510B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 44                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4513B                      *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B1 = 4512B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 75      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 73  *IF SECTOR FLAW
   GOTO 33                         *NEXT CYLINDER 
73 B5 = B5+2
   GOTO 52 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 56                         *NEXT CYLINDER 
74 B1 = 4510B                      *INSTRUCTION ERROR 
75 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 44                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 76            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
76 GOTO 73                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44372,844HT(02,03,04,05)LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST 2 TO 1  (TRACK GROUPS)
/         COMPARE DATA
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS AND READ ONE SECTOR AT A TIME
*             COMPARING DATA. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         9.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 4 FORMAT D4437 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT  *START FROM REAL TIME
27 GOSUB 47                         *RESERVE DRIVE
   B4 = B2+2 RS 1                   *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 50                         *WRITE ROUTINE
   B4 = B2+1 RS 1                   *RESET SECTORS SECOND 
   B5 = P3 RS 6 + 1                 *MIN SECTOR PLUS 1
   IF (B4 EQ 0) GOTO 32             *IF ONE SECTOR WRITE
   GOSUB 50                         *WRITE ROUTINE
32 OB(503) = 0                      *LOOP COUNT 
   OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
33 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 34       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 35
34 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
35 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
36 GOTO 33 WHILE (B5+2 LE OB(504))  *COMPLETE FIRST PASS
   OB(503) = OB(503)+1              *COUNT FOR SECOND PASS
   IF (OB(503) EQ 2) GOTO 40        *IF EQUAL TO SECOND PASS
   B5 = P3 RS 6 + 1                 *LOW SECTOR PLUS 1
   IF (B5 GT OB(504)) GOTO 40       *IF ONE SECTOR READ 
   GOTO 33                          *START SECOND PASS
40 ENDSUB 
   IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B7 = P0                          *LOWER CYLINDER 
   GOTO 44 WHILE (B6+1 GT B0)       *LAST CYLINDER
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *LOWER TRACK
   GOTO 20                          *RESTART TEST 
45 EXIT TO 374                      *END SUB MODULE 
46 B1 = 4520B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
47 RES DRIVE, ABT 46
   RETURN                           *RETURN TO CALL 
/         WRITE ROUTINE 
50 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 52       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 54
52 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
54 RETURN 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4523B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4522B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 63  *IF SECTOR FLAW
   GOTO 40                         *NEXT CYLINDER 
63 B5 = B5+2
   GOTO 50 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 54                         *NEXT CYLINDER 
64 B1 = 4520B                      *INSTRUCTION ERROR 
65 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4523B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4522B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 36  *IF SECTOR FLAW
   GOTO 40                         *NEXT CYLINDER 
73 B1 = 4520B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 47                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 36                         *NEXT SECTOR 
76 B1 = 4521B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44373,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST 2 TO 1  (TRACK GROUPS)
/         READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED AND P6 =0, SET OUTPUT
*             BUFFER WITH THE DATA AS DESCRIBED.
*         2.  RESERVE DRIVE.
*         3.  IF A SET DATA PATTERN SELECTED, GO TO 4, ELSE,
*             READ THE FIRST SECTOR AS GIVEN FROM THE INPUT 
*             PARAMETERS AND GENERATE A RANDOM PATTERN DATA 
*             FROM THE SEED WORD OF THAT SECTOR.
*         4.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         9.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98E.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4437 - CANNOT READ DISK
 3 FORMAT D4437 - ERROR(S) IN MODULE
 4 FORMAT D4437 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
/         SET RANDOM PATTERN FOR VERIFY 
24 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
25 B4 = 1 
   GOSUB 56                         *RESERVE DRIVE
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR WC, START IB(4)
27 OB(503) = 0                      *LOOP COUNT 
   OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 56                         *RESERVE DRIVE
33 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 34       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 35
34 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
35 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
36 GOTO 33 WHILE (B5+2 LE OB(504))  *COMPLETE FIRST PASS
   OB(503) = OB(503)+1              *COUNT FOR SECOND PASS
   IF (OB(503) EQ 2) GOTO 40        *IF EQUAL TO SECOND PASS
   B5 = P3 RS 6 + 1                 *LOW SECTOR PLUS 1
   IF (B5 GT OB(504)) GOTO 40       *IF ONE SECTOR READ 
   GOTO 33                          *START SECOND PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B7 = P0                          *LOWER CYLINDER 
   GOTO 44 WHILE (B6+1 GT B0)       *LAST TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 50 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *SET LOW TRACK
   GOTO 20                          *RESTART TEST 
50 IF (B3 EQ 0) GOTO 52             *IF NO ERRORS 
51 MSG 3 TO DAYFILE 
52 PICTURE
   GOTO 77                          *END
55 B1 = 4530B                       *SET MODULE NUMBER
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4533B                      *RESTART 
   GOTO 66
62 IF (SB EQ 0) GOTO 65            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 65  *IF NOT A FLAW 
   B1 = 4532B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 66      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 64  *IF TRACK FLAW 
63 GOTO 25 WHILE (B5+1 LE OB(504))  *TRY NEXT SECTOR
64 GOTO 24 WHILE (B7+1 LE P1)      *TRY NEXT TRACK
   B7 = P0                         *LOWER CYLINDER
   GOTO 24 WHILE (B6+1 LE B0)      *NEXT TRACK
   MSG 1 TO LINE 1
   PICTURE
   HALT 
   GOTO 51                         *FLAWED AREA - END IT
65 B1 = 4530B                      *INSTRUCTION ERROR 
66 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 24     *IF REPEAT CONDITION 
   IF (B1 NE 2) GOTO 67            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *UPDATE TRACK FROM FLAW
67 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4533B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4532B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 EQ 0) GOTO 36  *IF SECTOR FLAW
   GOTO 40                         *NEXT CYLINDER 
73 B1 = 4530B                      *INSTRUCTION ERROR 
74 CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 36                         *NEXT SECTOR 
76 B1 = 4531B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44374,844HT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         END SUB MODULE FOR 372 MODULE.
* 
*         1.  DISPLAY ERROR MESSAGE IN THE DAYFILE IF ERRORS
*             WERE DETECTED IN THE RUNNING OF THESE MODULES.
* 
*   REGISTER USAGE
* 
*         B3 = ERROR COUNT. 
  
  
 3 FORMAT D4437 - ERROR(S) IN MODULE
/         END ROUTINE 
20 IF (B3 EQ 0) GOTO 22            *IF NO ERRORS
   MSG 3 TO DAYFILE 
22 PICTURE
   END 20                          *END 
COMPILE 
   MODULE D4438,844FT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         HEAD TEST   1 TO 1   (TRACK GROUPS) 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THAT THE ACCESS LEVEL MEETS THE 
*             CRITERIA ASKED FOR BY THE INPUT PARAMETERS. 
*         4.  IF INPUT ERRORS, THE DISCREPANCIES WILL BE
*             DISPLAYED AS FOUND AND THE MODULE TERMINATED. 
*         5.  NO ERRORS - MARGINS, IF ANY, ARE SET.  IF A 
*             FIXED DATA PATTERN IS USED, THE OUTPUT BUFFER 
*             IS FILLED AND THE APPROPRIATE SUB MODULE
*             IS EXECUTED.
* 
*    REGISTER USAGE 
* 
*         B0 = UPPER TRACK. 
*         B1 = TEMPORARY STORAGE FOR AL.
*         B2 = MAX SECTOR COUNT.
*         B3 = ERROR COUNTER. 
*         B4 = CYLINDER MAX.
*         B5 = BEGINNING SECTOR.
*         B6 = BEGINNING TRACK. 
*         B7 = BEGINNING CYLINDER.
*         B8 = FIRST PRE-ALLOCATED CYLINDER                              D44012J
*         WC = WORD COUNT.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOWER CYLINDER.
*         P1 = UPPER CYLINDER.
*         P2 = LOWER/UPPER TRACKS.
*         P3 = LOWER/UPPER SECTORS. 
*         P4 = ENABLES. 
*         P5 = DISABLES.
*         P6 = DATA.
*         P7 = MARGINS. 
*         P8 = ITERATION COUNT. 
* 
 1 FORMAT D4438 HEAD TEST 1/1  (TRACK GROUPS) 
 2 FORMAT D4438 - ERROR(S) IN MODULE
 3 FORMAT D4438 - ERROR IN MARGIN COMMAND P7 = *OCT 
 5 FORMAT //D4438 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4438 - SECTOR PARAM ERROR  P3 = *OCT 
 7 FORMAT D4438 - TRACK PARAM ERROR  P2 = *OCT
10 FORMAT D4438 - LOWER CYLINDER PARAM ERROR  P0 = *OCT 
11 FORMAT D4438 - UPPER CYLINDER PARAM ERROR  P1 = *OCT 
12 FORMAT D4438 - LOWER GREATER THAN UPPER CYLINDER 
13 FORMAT D4438 - READ AND WRITE BOTH DISABLED
14 FORMAT D4438 - LOWER GREATER THAN UPPER SECTOR 
15 FORMAT D4438 - LOWER GREATER THAN UPPER TRACK
/         VALIDATION ROUTINE
20 MSG 1 TO PRINT 
   MSG 1 TO DISPLAY 
   WC = 474B                 *WORD COUNT
   B4 = P3 AND 77B           *UPPER SECTOR
   B5 = P3 RS 6              *LOWER SECTOR
   IF (B4 GT 27) GOTO 21     *IF SECTOR BAD 
   IF (B5 LE 27) GOTO 22     *SECTORS OK
21 B3 = 1 
   MSG 6 (P3) TO LINE 2      *SECTOR ERROR MESSAGE
22 IF (B5 LE B4) GOTO 23     *IF LOWER LT UPPER SECTOR
   B3 = B3+1
   MSG 14 TO LINE 3          *SECTOR LOWER MESSAGE
23 B0 = P2 AND 77B           *UPPER TRACK 
   B6 = P2 RS 6              *LOWER TRACK 
   IF (B0 GT 22) GOTO 24     *IF TRACK BAD
   IF (B6 LE 22) GOTO 25     *IF TRACKS OK
24 B3 = B3+1
   MSG 7 (P2) TO LINE 4      *TRACK ERROR MESSAGE 
25 IF (B6 LE B0) GOTO 26     *IF LOWER LT UPPER TRACK 
   B3 = B3+1
   MSG 15 TO LINE 5          *TRACK LOWER MESSAGE 
26 B4 = 632                  *SINGLE DENSITY
   IF (DC EQ 2) GOTO 27      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 27      *IF 2X DRIVE 
   B4 = 1466                 *DOUBLE DENSITY
27 B7 = P0                   *SET LOWER CYLINDER
   B8 = B4-2                 *B8 = 1ST PRE-ALLOCATED CYL                 D44012J
   IF (P0 LE B4) GOTO 30     *LOWER CYLINDER OK 
   MSG 10 (P0) TO LINE 6     *LOWER CYLINDER MESSAGE
   B3 = B3+1
30 IF (P1 LE B4) GOTO 31     *UPPER CYLINDER OK 
   MSG 11 (P1) TO LINE 7
   B3 = B3+1
31 IF (P0 LE P1) GOTO 36     *IF CYLINDER OK
   MSG 12 TO LINE 10         *LOWER GT UPPER CYLINDER 
   B3 = B3+1
36 IF (P5 AND 4 EQ 0) GOTO 40   *WRITE NOT DISABLED 
   IF (P5 AND 2 EQ 0) GOTO 45   *READ NOT DISABLED
   MSG 13 TO LINE 11            *READ AND WRITE BOTH OFF
   B3 = B3+1
   GOTO 50
40 IF (P0 GE B8) GOTO 41     *WRITE IN PRE-ALLOCATED AREA                D44012J
   IF (AL GE 4) GOTO 50         *WRITE IN DATA AREA 
   B1 = 4 
   GOTO 46
41 IF (AL GE 3) GOTO 50         *WRITE IN PREALLOCATED
   B1 = 3 
   GOTO 46
45 IF (P0 GE B8) GOTO 50     *READ PRE-ALLOCATED AREA                    D44012J
   IF (AL GE 2) GOTO 50         *READ DATA AREA 
   B1 = 2 
46 B3 = B3+1
   MSG 5 (B1 AL) TO LINE 12 
50 MARGINS P7, ABT 51 
   GOTO 55                      *IF MARGINS OK
51 B3 = B3+1
   MSG 3 (P7) TO LINE 14        *MARGIN MESSAGE 
55 IF (B3 NE 0) GOTO 65         *IF PARAMETER ERROR 
   B3 = 0                       *CLEAR ERROR COUNTER
   B2 = P3 AND 77B - B5         *MAX SECTOR - MIN SECTOR
   IF (P5 AND 10 EQ 0) GOTO 56  *RANDOM DATA SET
   DUP P6 TO OB(4) FOR WC       *START FROM P6
56 IF (P4 AND 4 EQ 0) GOTO 61   *IF NO COMPARE
   IF (P5 AND 4 EQ 0) GOTO 60   *IF WRITE SET 
   EXIT TO 383                  *COMPARE DATA NO WRITE
60 EXIT TO 382                  *COMPARE OVERLAY
61 EXIT TO 381                  *NEXT OVERLAY 
65 MSG 2 TO DAYFILE 
   PICTURE
77 END 20 
COMPILE 
   MODULE D44381,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST   1 TO 1   (TRACK GROUPS) 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         9.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4438 - ERROR(S) IN MODULE
 4 FORMAT D4438 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *NOT RANDOM DATA SET 
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT 
27 GOSUB 56                         *RESERVE DRIVE
   IF (P5 AND 4 NE 0) GOTO 33       *IF WRITE DISABLED
   B4 = B2+1                        *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
/         WRITE ROUTINE 
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
33 IF (P5 AND 2 NE 0) GOTO 40       *IF READ DISABLED 
   B4 = B2+1                        *SECTORS FIRST PASS 
   B5 = P3 RS 6                     *LOWER SECTOR 
/         READ ROUTINE
34 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 40
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 41 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
41 B7 = P0                          *LOWER CYLINDER 
   GOTO 42 WHILE (B6+1 GT B0)       *LAST TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
42 GOTO 50 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *LOWER TRACK
   GOTO 20                          *RESTART TEST 
50 IF (B3 EQ 0) GOTO 52             *IF NO ERRORS 
51 MSG 3 TO DAYFILE 
52 PICTURE
   GOTO 77                          *END
55 B1 = 4610B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4613B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4612B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
63 B5 = B5+1
   GOTO 31 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 33
64 B1 = 4610B                      *INSTRUCTION ERROR 
65 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 33  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4613B                      *RESTART 
   GOTO 75
72 IF (SB EQ 0) GOTO 74            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 74  *IF NOT A FLAW 
   B1 = 4612B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 75      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
73 B5 = B5+1
   GOTO 34 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 40                         *NEXT CYLINDER 
74 B1 = 4610B                      *INSTRUCTION ERROR 
75 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 76            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
76 GOTO 73                         *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D44382,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST   1 TO 1   (TRACK GROUPS) 
/         WRITE/READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED, SET OUTPUT BUFFER  WITH 
*             THE DATA AS DESCRIBED IN PARAMETERS.
*         2.  RESERVE DRIVE.
*         3.  CHECK PARAMETERS FOR WRITE DISABLED, IF 
*             DISABLED GO TO  5.
*         4.  DETERMINE THE NUMBER OF SECTORS TO WRITE FROM 
*             THE INPUT PARAMETERS AND JUMP TO THE WRITE
*             SUBROUTINE.  THE WRITE ROUTINE WILL SELECT A
*             CODED OR NON-CODED WRITE FROM THE INPUT 
*             PARAMETERS. 
*         5.  CHECK PARAMETERS FOR READ DISABLED, IF
*             DISABLED GO TO 7. 
*         6.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND JUMP TO THE READ 
*             SUBROUTINE.  THE READ ROUTINE WILL SELECT A 
*             CODED OR NON-CODED READ FROM THE INPUT
*             PARAMETERS AND READ ONE SECTOR AT A TIME
*             COMPARING DATA. 
*         7.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         8.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         9.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*        10.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 3 FORMAT D4438 - ERROR(S) IN MODULE
 4 FORMAT D4438 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
24 RANDOM TO OB(4) FOR WC, START RT  *START FROM REAL TIME
27 GOSUB 56                         *RESERVE DRIVE
   B4 = B2+1                        *NUMBER OF SECTORS FIRST
   B5 = P3 RS 6                     *LOWER SECTOR 
/         WRITE ROUTINE 
31 MSG 4 (B7 B6 B5) TO DISPLAY
   IF (P5 AND 1 NE 0) GOTO 32       *IF CODED NOT SELECTED
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   GOTO 33
32 WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
33 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
34 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
36 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
37 GOTO 34 WHILE (B5+1 LE OB(504))  *COMPLETE FIRST PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B7 = P0                          *LOWER CYLINDER 
   GOTO 44 WHILE (B6+1 GT B0)       *LAST TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *SET LOWER TRACK
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
46 MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
55 B1 = 4620B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 62     *IF BC OK
61 B1 = 4623B                      *RESTART 
   GOTO 65
62 IF (SB EQ 0) GOTO 64            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64  *IF NOT A FLAW 
   B1 = 4622B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 65      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
63 B5 = B5+1
   GOTO 31 WHILE (B4-1 GT 0)       *NEXT SECTOR 
   GOTO 33                         *NEXT CYLINDER 
64 B1 = 4620B                      *INSTRUCTION ERROR 
65 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 66            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
66 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4623B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4622B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
   GOTO 37                         *SECTOR FLAW 
73 B1 = 4620B                      *INSTRUCTION ERROR 
74 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 37                         *NEXT SECTOR 
76 B1 = 4621B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D44383,844FT(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION 
/         HEAD TEST   1 TO 1   (TRACK GROUPS) 
/         READ COMPARE DATA 
* 
*         1.  IF RANDOM SELECTED AND P6 =0, SET OUTPUT
*             BUFFER WITH THE DATA AS DESCRIBED.
*         2.  RESERVE DRIVE.
*         3.  IF A SET DATA PATTERN SELECTED, GO TO 4, ELSE 
*             READ THE FIRST SECTOR AS GIVEN FROM THE INPUT 
*             PARAMETERS AND GENERATE A RANDOM PATTERN DATA 
*             FROM THE SEED WORD OF THAT SECTOR.
*         4.  DETERMINE THE NUMBER OF SECTORS TO READ FROM
*             THE INPUT PARAMETERS AND READ (CODED OR NON-
*             CODED AS SELECTED FROM THE INPUT PARAMETERS)
*             ONE SECTOR AT A TIME COMPARING DATA.
*         5.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         6.  THE CYLINDER COUNT IS INCREMENTED BY ONE AND
*             ABOVE IS REPEATED UNTIL THE CYLINDER COUNT
*             MEETS THE INPUT PARAMETERS. 
*         7.  THE TRACK COUNT IS INCREMENTED BY ONE AND 
*             ABOVE IS REPEATED UNTIL THE TRACK COUNT MEETS 
*             THE INPUT PARAMETERS. 
*         8.  ALL ERRORS ARE HANDLED THROUGH THE  ERROR 
*             SUBROUTINES.  THE ERROR ROUTINE, BY PARAMETER 
*             SELECTION, WILL REPORT OR BYPASS DISK FLAWS.
*             ALL OTHER ERRORS CALL THE ERROR PROCESSOR 
*             98G.
* 
*   REGISTER USAGE
* 
*         B0 = UPPER TRACK LIMITS.
*         B1 = MMSE 
*                MM = MODULE NUMBER.
*                 S = SUB MODULE NUMBER.
*                 E = ERROR SELECT CODE.
*         B2 = MAXIMUM - MINIMUM SECTORS. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         BA = ITERATION COUNT. 
*         WC = WORD COUNT.
* 
*   INPUT REGISTERS 
* 
*         AS SET IN PRIMARY MODULE. 
* 
 1 FORMAT D4438 - CANNOT READ DISK
 3 FORMAT D4438 - ERROR(S) IN MODULE
 4 FORMAT D4438 - CYL *OCT, TRK *OCT, SEC *OCT
20 IF (P5 AND 10 NE 0) GOTO 27       *SET DATA PATTERN
22 IF (P6 EQ 0) GOTO 24              *RANDOM STARTER WANTED 
   RANDOM TO OB(4) FOR WC, START P6  *START FOR INPUT PARAM 
   GOTO 27
/         SET RANDOM PATTERN FOR VERIFY 
24 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
25 B4 = 1 
   GOSUB 56                         *RESERVE DRIVE
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   RANDOM TO OB(4) FOR WC, START IB(4)
27 OB(504) = P3 AND 77B             *UPPER SECTOR 
   B5 = P3 RS 6                     *LOWER SECTOR 
   GOSUB 56                         *RESERVE DRIVE
34 MSG 4 (B7 B6 B5) TO DISPLAY
   B4 =1                            *ONE SECTOR READ
   IF (P5 AND 1 NE 0) GOTO 35       *IF CODED NOT SELECTED
   READ B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
   GOTO 36
35 READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 70
36 B1 = 474                         *COMPARE COUNT
   COMPARE IB(4) TO OB(4) FOR B1, ABT 76
37 GOTO 34 WHILE (B5+1 LE OB(504))  *COMPLETE FIRST PASS
40 IF (ES AND RC NE 0) GOTO 27      *IF REPEAT CONDITION
   GOTO 42 WHILE (B7+1 GT P1)       *IF CYLINDER MET
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 10 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CHANGE RANDOM PATTERN
42 B7 = P0                          *LOWER CYLINDER 
   GOTO 44 WHILE (B6+1 GT B0)       *LAST TRACK MET 
   IF (P5 AND 10 NE 0) GOTO 27      *USE SET DATA 
   IF (P4 AND 20 EQ 0) GOTO 27      *NO PATTERN CHANGE
   GOTO 22                          *CONTINUE NEXT CYLINDER 
44 GOTO 45 WHILE (BA+1 GT P8)       *ITERATION COUNT
   B6 = P2 RS 6                     *LOWER TRACK
   GOTO 20                          *RESTART TEST 
/         END ROUTINE 
45 IF (B3 EQ 0) GOTO 47             *IF NO ERRORS 
46 MSG 3 TO DAYFILE 
47 PICTURE
   GOTO 77                          *END
55 B1 = 4630B                       *SET MODULE NUMBER
   CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                           *RETURN TO CALL 
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61         *IF HUNG BC 
   IF (SB(4) NE 7777B) GOTO 62      *IF BC OK 
61 B1 = 4633B                       *RESTART
   GOTO 66
62 IF (SB EQ 0) GOTO 65             *ASSUME NO DETAIL 
   IF (SB(6) AND 30 EQ 0) GOTO 65   *IF NOT A FLAW
   B1 = 4632B                       *FLAW 
   IF (P4 AND 1 NE 0) GOTO 66       *REPORT FLAW
   IF (SB(6) AND 10 NE 0) GOTO 64   *IF TRACK FLAW
63 GOTO 25 WHILE (B5+1 LE OB(504))  *TRY NEXT SECTOR
64 GOTO 24 WHILE (B7+1 LE P1)       *TRY NEXT TRACK 
   B7 = P0                          *LOWER CYLINDER 
   GOTO 24 WHILE (B6+1 LE B0)       *NEXT TRACK 
   MSG 1 TO LINE 1
   PICTURE
   HALT 
   GOTO 46                         *FLAWED AREA - END IT
65 B1 = 4630B                      *INSTRUCTION ERROR 
66 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 24     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 67            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 64  *UPDATE TRACK FROM FLAW
67 GOTO 63                         *NEXT SECTOR 
/         VERIFY ERROR ROUTINE
70 IF (SB EQ 7777B) GOTO 71        *IF HUNG BC
   IF (SB(4) NE 7777B) GOTO 72     *IF BC OK
71 B1 = 4633B                      *RESTART 
   GOTO 74
72 IF (SB EQ 0) GOTO 73            *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 73  *IF NOT A FLAW 
   B1 = 4632B                      *FLAW
   IF (P4 AND 1 NE 0) GOTO 74      *REPORT FLAW 
   IF (SB(6) AND 10 NE 0) GOTO 40  *IF TRACK FLAW 
   GOTO 37                         *SECTOR FLAW 
73 B1 = 4630B                      *INSTRUCTION ERROR 
74 CALL 98F                        *CALL ERROR PROCESSOR                 D44009J
   IF (ES AND RC NE 0) GOTO 27     *IF REPEAT CONDITION 
   GOSUB 56                        *RESERVE DRIVE 
   IF (B1 NE 2) GOTO 75            *IF NOT FLAW ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 40  *UPDATE TRACK FROM FLAW
75 GOTO 37                         *NEXT SECTOR 
76 B1 = 4631B                      *COMPARE ERROR 
   GOTO 74
77 END 20 
COMPILE 
   MODULE D4440,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        RESET MAINTENANCE LOOP 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE CONTROLLER. 
*         3.  CHECK FOR CONTROLLER RESERVED FROM ALTERNATE
*             ACCESS.  ERROR EXIT IF RESERVED, ELSE RESET 
*             THE CONTROLLER. 
*         4.  REPEAT CONDITION LOOPS ON RESET INSTRUCTION 
*             AND DISPLAYS ERROR MESSAGE. 
*         5.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON THE RESET COMAND.
* 
*   REGISTER USAGE
* 
*         B2 = SCOPE LOOP COUNT.
*         B3 = ERROR COUNT. 
* 
 1 FORMAT D4440 RESET TEST
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4440 - ERROR(S) IN MODULE
20 MSG 1 TO DISPLAY, PRINT
23 MSG 1 TO DISPLAY 
25 RES CONTROLLER, ABT 26 
26 IF (SB EQ 2000B) GOTO 60        *IF RESERVED 
   RESET, ABT 60
   STATUS GENERAL, ABT 60 
   IF (ES AND SL NE 0) GOTO 75     *IF SCOPE LOOP 
   IF (ES AND RC NE 0) GOTO 23     *IF REPEAT CONDITION 
   REL, ABT 60
   IF (B3 EQ 0) GOTO 31            *IF NO ERRORS
30 MSG 3 TO DAYFILE 
31 PICTURE
   GOTO 77                         *END 
/         ERROR ROUTINE 
60 B3 = B3+1                       *ERROR COUNT                          D44011J
   IF (ES AND SL NE 0) GOTO 75     *IF SCOPE LOOP                        D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
65 IF (ES AND RC EQ RC) GOTO 23    *IF REPEAT LOOP
   GOTO 30
/         SCOPE LOOP
75 B2 =B2+1                        *SCOPE LOOP COUNT
   MSG 2 (B2,B3) TO DISPLAY 
   GOTO 25
77 END 20 
COMPILE 
   MODULE D4441,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE A CODED CYLINDER FOR MODULE 06 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  RESERVE DISK FILE.
*         3.  SEEK TO THE INNERMOST CYLINDER AND WRITE
*             CODED SECTORS IN TRACK MODE, FROM A RANDOM
*             DATA BUFFER.
*             CHANNEL IS RELEASED BETWEEN EACH TRACK. 
*         4.  REPEAT CONDITION LOOPS ON THE CURRENT TRACK.
*         5.  ERRORS ARE HANDLED THROUGH AN ERROR ROUTINE.
*             THE ERROR ROUTINE BYPASSES SECTOR AND TRACK 
*             FLAWS AND CALLS THE ERROR PROCESSOR 98A FOR 
*             ALL OTHER ERRORS. 
* 
*    REGISTER USAGE 
* 
*         B0 = COMPARE WORD COUNT.
*         B1 = NNNE 
*              NNN = MODULE NUMBER. 
*                E = ERROR SELECT CODE. 
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
 1 FORMAT D4441 WRITE CYLINDER
 3 FORMAT D4441 - ERROR(S) IN MODULE
 5 FORMAT //D4441 - NOT EXECUTED, NEEDS AL=0003, AL=*OCT // 
 6 FORMAT D4441 - CYL *OCT, TRK *OCT, SEC *OCT
 7 FORMAT B7 = *OCT  B6 = *OCT B5 = *OCT
10 FORMAT *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT 
20 MSG 1 TO DISPLAY, PRINT
   IF (AL GE 3) GOTO 21      *IF ACCESS OK
   MSG 5 (AL) TO PRINT
   GOTO 32                   *END IT
21 B0 = 474 
   B4 = 14                   *NUMBER OF SECTORS TO WRITE
   B5 = 0                    *CURRENT SECTOR
   B6 = 0                    *CURRENT TRACK 
   B7 = 632                  *CURRENT CYLINDER
   IF (DC EQ 2) GOTO 22      *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 22      *IF 2X DRIVE 
   B7 = 1466
22 RANDOM TO OB(4) FOR B0, START RT 
23 GOSUB 56                  *RESERVE DRIVE 
24 MSG 6 (B7 B6 B5) TO DISPLAY
   WRITE B4 CODED SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
25 B4 = 14                           *RESET SECTOR COUNT
   IF (B5 EQ 27) GOTO 26
   B5 = 1                            *SET ODD SECTOR
   GOTO 23                           *WRITE ODD SECTORS 
26 B5 = 0                            *EVEN SECTOR 
   B4 = 14                           *INSURE SECTORS SET
   IF (ES AND RC EQ RC) GOTO 23      *IF REPEAT CONDITION 
   GOTO 22 WHILE (B6+1 LE 22)        *IF ANOTHER TRACK
   REL, ABT 60
30 IF (B3 EQ 0) GOTO 32              *IF NO ERRORS
31 MSG 3 TO DAYFILE 
32 PICTURE
   GOTO 77                           *END 
55 B1 = 5100B                        *SET MODULE NUMBER 
   CALL 98A                        *CALL ERROR PROCESSOR                 D44009J
56 RES DRIVE, ABT 55
   RETURN                            *RETURN TO CALL
/         ERROR ROUTINES
60 IF (SB EQ 7777B) GOTO 61          *IF BC HUNG
   IF (SB(4) NE 7777B) GOTO 62       *IF BC OK
61 B1 = 513B                         *RESTART NEEDED
   GOTO 65
62 IF (SB EQ 0) GOTO 64              *ASSUME NO DETAIL
   IF (SB(6) AND 30 EQ 0) GOTO 64    *IF NOT A FLAW 
   ERROR 0/0                         *CLEAR ERROR 
   IF (SB(6) AND 10 NE 0) GOTO 26    *IF TRACK FLAW 
63 B5 = B5+2
   GOTO 24 WHILE (B4-1 GT 0)         *NEXT SECTOR 
   IF (B5 EQ 31) GOTO 26             *IF FLAW ON LAST SECTOR
   GOTO 25                           *NEXT TRACK
64 B1 = 510B
65 CALL 98A                          *CALL ERROR PROCESSOR
   IF (ES AND RC EQ RC) GOTO 23      *REPEAT CONDITION
   GOSUB 56                          *RESERVE DRIVE 
   GOTO 63                           *NEXT SECTOR 
77 END 20 
COMPILE 
   MODULE D4442,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        EXECUTE SEEK ADDRESS FROM PARAMETERS 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDTIY OF THE INPUT PARAMETERS. 
*         3.  RESERVE THE DRIVE AND SEEK TO THE CYLINDER, 
*             TRACK AND SECTOR DESCRIBED IN THE THE INPUT 
*             PARAMETERS. 
*         4.  REPEAT CONDITION REPEATS THE ABOVE SEQUENCE 
*             DISPLAYING ANY ERROR MESSAGES.
*         5.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON THE SEEK COMAND. 
* 
*    REGISTER USAGE 
* 
*         B0 = VALIDATION ERROR COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = ERROR COUNTER. 
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
*         OB(503) = CYLINDER MAXIMUM. 
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = CYLINDER.
*         P2 = TRACK. 
*         P3 = SECTOR.
* 
 1 FORMAT D4442 SEEK CYL=*OCT,TRK=*OCT,SEC=*OCT 
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4442 - ERROR(S) IN MODULE
 5 FORMAT D4442 - CYL *OCT, TRK *OCT, SEC *OCT
 6 FORMAT D4442 - SECTOR PARAM ERROR  *OCT
 7 FORMAT D4442 - TRACK PARAM ERROR  *OCT 
10 FORMAT D4442 - CYLINDER PARAM ERROR  *OCT
20 MSG 1 (P0 P2 P3) TO DISPLAY, PRINT                                    D440153
   GOSUB 65 
23 MSG 1 (B7 B6 B5) TO DISPLAY
24 RES DRIVE, ABT 60
   SEEK CYL B7 TRK B6 SEC B5, ABT 60
   IF (ES AND SL NE 0) GOTO 75    *IF SCOPE LOOP
   IF (ES AND RC NE 0) GOTO 23    *IF REPEAT CONDITION
   REL, ABT 60
   IF (B3 EQ 0) GOTO 30           *IF NO ERRORS 
27 MSG 3 TO DAYFILE 
30 PICTURE
   GOTO 77                        *END
/         ERROR ROUTINE 
60 B3 = B3+1                      *ERROR COUNT                           D44011J
   IF (ES AND SL NE 0) GOTO 75    *IF SCOPE LOOP                         D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
61 IF (ES AND RC NE 0) GOTO 23   *REPEAT CONDITION
   GOTO 27                       *MESSAGE AND END 
/         VALIDATION ROUTINE
65 IF (P3 LE 27) GOTO 66         *IF SECTOR OK
   B0 = 1 
   MSG 6 (P3) TO LINE 2          *SECTOR ERROR MESSAGE
66 B5 = P3                       *SET SECTOR
   IF (P2 LE 22) GOTO 67         *IF TRACK OK 
   B0 = B0+1
   MSG 7 (P2) TO LINE 3          *TRACK MESSAGE 
67 B6 = P2                       *CURRENT TRACK 
   OB(503) = 632                 *SINGLE DENSITY
   IF (DC EQ 2) GOTO 70          *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 70          *IF 2X DRIVE 
   OB(503) = 1466 
70 IF (P0 LE OB(503)) GOTO 71    *IF CYLINDER TO LARGE
   B0 = B0+1
   MSG 10 (P0) TO LINE 4         *CYLINDER MESSAGE
71 B7 = P0                       *SET CYLINDER
   IF (B0 NE 0) GOTO 27 
   RETURN                        *PARAMETERS OK 
/         SCOPE LOOP
75 B2 = B2+1
   MSG 2 (B2,B3) TO DISPLAY 
   GOTO 24
77 END 20 
COMPILE 
   MODULE D4443,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE ONE SECTOR FROM PARAMETERS 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THE ACCESS LEVEL MEETS THE CRITERIA OF
*             THE INPUT PARAMETERS. 
*         4.  RESERVE THE DRIVE AND WRITE ONE SECTOR AS 
*             DESCRIBED BY THE INPUT PARAMETERS.
*         5.  REPEAT CONDITION REPEATS THE ABOVE SEQUENCE 
*             DISPLAYING ANY ERROR MESSAGES.
*         6.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON SEQUENCE 4.
* 
*    REGISTER USAGE 
* 
*         B0 = VALIDATION ERROR COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = CYLINDER.
*         P2 = TRACK. 
*         P3 = SECTOR.
* 
 1 FORMAT D4443 WRITE CYL=*OCT,TRK=*OCT,SEC=*OCT
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4443 - ERROR(S) IN MODULE
 5 FORMAT //D4443 - NOT EXECTED, NEEDS AL=*OCT, AL=*OCT //
 6 FORMAT D4443 - SECTOR PARAM ERROR  *OCT
 7 FORMAT D4443 - TRACK PARAM ERROR  *OCT 
10 FORMAT D4443 - CYLINDER PARAM ERROR  *OCT
20 MSG 1 (P0 P2 P3) TO DISPLAY, PRINT                                    D440153
   GOSUB 65 
21 IF (P0 LT OB(503)) GOTO 22     *IF OUT OF PREALLOCATION
   IF (AL GE 3) GOTO 23           *IF ACCESS OK 
   B0 = 3 
   MSG 5 (B0 AL) TO LINE 1
   GOTO 51                        *END IT 
22 IF (AL GE 4) GOTO 23           *IF ACCESS OK 
   B0 = 4 
   MSG 5 (B0 AL) TO LINE 1
   GOTO 51
23 WC = 500                       *READ BUFFER SIZE 
   B4 = 1                         *NUMBER OF SECTORS TO READ
/         DATA CONTROL
   IF (P5 NE 10) GOTO 24          *RANDOM DATA SET
   DUP P6 TO OB FOR WC
   GOTO 26
24 IF (P6 EQ 0) GOTO 25           *IF RANDOM STARTER
   RANDOM TO OB FOR WC, START P6  *START FROM P6
   GOTO 26
25 RANDOM TO OB FOR WC, START RT
26 MSG 1 (B7 B6 B5) TO DISPLAY
27 RES DRIVE, ABT 60
   B4 = 1 
   WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   IF (ES AND SL NE 0) GOTO 75
   IF (ES AND RC NE 0) GOTO 26    *REPEAT CONDITION 
   REL, ABT 60
50 IF (B3 EQ 0) GOTO 52           *IF NO ERRORS 
51 MSG 3 TO DAYFILE 
52 PICTURE
   GOTO 77                        *END
/         ERROR ROUTINE 
60 B3 = B3+1                      *ERROR COUNT                           D44011J
   IF (ES AND SL NE 0) GOTO 75    *IF SCOPE LOOP                         D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
61 IF (ES AND RC EQ RC) GOTO 26   *REPEAT CONDITION 
   GOTO 51                        *MESSAGE AND END
/         VALIDATION ROUTINE
65 IF (P3 LE 27) GOTO 66          *IF SECTOR OK 
   B0 = 1 
   MSG 6 (P3) TO LINE 2           *SECTOR ERROR MESSAGE 
66 B5 = P3                        *SET SECTOR 
   IF (P2 LE 22) GOTO 67          *IF TRACK OK
   B0 = B0+1
   MSG 7 (P2) TO LINE 3           *TRACK MESSAGE
67 B6 = P2                        *CURRENT TRACK
   OB(503) = 632                  *SINGLE DENSITY 
   IF (DC EQ 2) GOTO 70 
   IF (DC EQ 4) GOTO 70 
   OB(503) = 1466 
70 IF (P0 LE OB(503)) GOTO 71     *IF CYLINDER TO LARGE 
   B0 = B0+1
   MSG 10 (P0) TO LINE 4          *CYLINDER MESSAGE 
71 OB(503) = OB(503) - 3          *SET FOR PREALLOCATED 
   B7 = P0                        *SET CYLINDER 
   IF (B0 NE 0) GOTO 51 
   RETURN                         *PARAMETERS OK
/         SCOPE LOOP
75 B2 = B2+1
   MSG 2 (B2,B3) TO DISPLAY 
   GOTO 27
77 END 20 
COMPILE 
   MODULE D4444,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        READ ONE SECTOR FROM PARAMETERS
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THE ACCESS LEVEL MEETS THE CRITERIA OF
*             THE INPUT PARAMETERS. 
*         4.  RESERVE THE DRIVE AND READ ONE SECTOR AS
*             DESCRIBED BY THE INPUT PARAMETERS.
*         5.  REPEAT CONDITION REPEATS THE ABOVE SEQUENCE 
*             DISPLAYING ANY ERROR MESSAGES.
*         6.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON SEQUENCE 4.
* 
*    REGISTER USAGE 
* 
*         B0 = VALIDATION ERROR COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = CYLINDER.
*         P2 = TRACK. 
*         P3 = SECTOR.
* 
 1 FORMAT D4444 READ CYL=*OCT,TRK=*OCT,SEC=*OCT 
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4444 - ERROR(S) IN MODULE
 5 FORMAT //D4444 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4444 - SECTOR PARAM ERROR  *OCT
 7 FORMAT D4444 - TRACK PARAM ERROR  *OCT 
10 FORMAT D4444 - CYLINDER PARAM ERROR  *OCT
/ 
20 MSG 1 (P0 P2 P3) TO DISPLAY, PRINT                                    D440153
   GOSUB 65                    *CHECK PARAMETERS
21 IF (P0 GE OB(503)) GOTO 23  *IF IN PREALLOCATION 
22 IF (AL GE 2) GOTO 23        *IF ACCESS OK
   B0 = 2 
   MSG 5 (B0 AL) TO LINE 0
   GOTO 40
23 B4 = 1                      *NUMBER OF SECTORS TO READ 
24 MSG 1 (B7 B6 B5) TO DISPLAY
25 RES DRIVE, ABT 60
   B4 = 1                      *NUMBER OF SECTORS 
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   IF (ES AND SL NE 0) GOTO 75    *SCOPE LOOP 
   IF (ES AND RC NE 0) GOTO 24    *REPEAT CONDITION 
   REL, ABT 60
   IF (B3 EQ 0) GOTO 41           *IF NO ERRORS 
40 MSG 3 TO DAYFILE 
41 PICTURE
   GOTO 77                        *END
/         ERROR ROUTINE 
60 B3 = B3+1                      *ERROR COUNT                           D44011J
   IF (ES AND SL NE 0) GOTO 75    *IF SCOPE LOOP                         D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
61 IF (ES AND RC NE 0) GOTO 24    *REPEAT CONDITION 
   GOTO 40                        *MESSAGE AND END
/         VALIDATION ROUTINE
65 IF (P3 LE 27) GOTO 66          *IF SECTOR OK 
   B0 = 1 
   MSG 6 (P3) TO LINE 2           *SECTOR ERROR MESSAGE 
66 B5 = P3                        *SET SECTOR 
   IF (P2 LE 22) GOTO 67          *IF TRACK OK
   B0 = B0+1
   MSG 7 (P2) TO LINE 3           *TRACK MESSAGE
67 B6 = P2                        *CURRENT TRACK
   OB(503) = 632                  *SINGLE DENSITY 
   IF (DC EQ 2) GOTO 70           *IF 2X DRIVE
   IF (DC EQ 4) GOTO 70           *IF 2X DRIVE
   OB(503) = 1466 
70 IF (P0 LE OB(503)) GOTO 71     *IF CYLINDER TO LARGE 
   B0 = B0+1
   MSG 10 (P0) TO LINE 4          *CYLINDER MESSAGE 
71 OB(503) = OB(503) - 3          *SET FOR PREALLOCATED 
   B7 = P0                        *SET CYLINDER 
   IF (B0 NE 0) GOTO 40 
   RETURN                         *PARAMETERS OK
/         SCOPE LOOP
75 B2 = B2+1
   MSG 2 (B2,B3) TO DISPLAY 
   GOTO 25
77 END 20 
COMPILE 
   MODULE D4445,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        WRITE/READ ONE SECTOR FROM PARAMETERS
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THE ACCESS LEVEL MEETS THE CRITERIA OF
*             THE INPUT PARAMETERS. 
*         4.  RESERVE THE DRIVE AND WRITE/READ ONE SECTOR AS
*             DESCRIBED BY THE INPUT PARAMETERS.
*         5.  REPEAT CONDITION REPEATS THE ABOVE SEQUENCE 
*             DISPLAYING ANY ERROR MESSAGES.
*         6.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON SEQUENCE 4.
* 
*    REGISTER USAGE 
* 
*         B0 = VALIDATION ERROR COUNTER.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = ERROR COUNTER. 
*         B4 = NUMBER OF SECTORS TO EXECUTE.
*         B5 = CURRENT SECTOR.
*         B6 = CURRENT TRACK. 
*         B7 = CURRENT CYLINDER.
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = CYLINDER.
*         P2 = TRACK. 
*         P3 = SECTOR.
* 
* 
 1 FORMAT D4445 W/R CYL=*OCT,TRK=*OCT,SEC=*OCT
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4445 - ERROR(S) IN MODULE
 5 FORMAT //D4445 - NOT EXECUTED, NEEDS AL=*OCT, AL=*OCT // 
 6 FORMAT D4445 - SECTOR PARAM ERROR  *OCT
 7 FORMAT D4445 - TRACK PARAM ERROR  *OCT 
10 FORMAT D4445 - CYLINDER PARAM ERROR  *OCT
20 MSG 1 (P0 P2 P3) TO DISPLAY, PRINT                                    D440153
   GOSUB 65                    *CHECK PARAMETERS
21 IF (P0 LT OB(503)) GOTO 22  *IF OUT OF PREALLOCATION 
   IF (AL GE 3) GOTO 23        *IF ACCESS OK
   B0 = 3 
   MSG 5 (B0 AL) TO LINE 1
   GOTO 40                     *END IT
22 IF (AL GE 4) GOTO 23        *IF ACCESS OK
   B0 = 4 
   MSG 5 (B0 AL) TO LINE 1
   GOTO 40
23 WC = 500                    *READ BUFFER SIZE
   B4 = 1                      *NUMBER OF SECTORS TO READ 
/         DATA CONTROL
   IF (P5 NE 10) GOTO 24       *RANDOM DATA SET 
   DUP P6 TO OB FOR WC         *START FROM P6 
   GOTO 26
24 IF (P6 EQ 0) GOTO 25            *IF RANDOM STARTER 
   RANDOM TO OB FOR WC, START P6   *STARTER P6
   GOTO 26
25 RANDOM TO OB FOR WC, START RT
26 MSG 1 (B7 B6 B5) TO DISPLAY
27 RES DRIVE, ABT 60
   B4 = 1                          *NUMBER OF SECTORS 
   WRITE B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60 
   B4 = 1 
   READ B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 60
   IF (ES AND SL NE 0) GOTO 75     *SCOPE LOOP
   IF (ES AND RC NE 0) GOTO 26     *REPEAT CONDITION
   REL, ABT 60
   IF (B3 EQ 0) GOTO 41            *IF NO ERRORS
40 MSG 3 TO DAYFILE 
41 PICTURE
   GOTO 77                         *END 
/         ERROR ROUTINE 
60 B3 = B3+1                       *ERROR COUNT                          D44011J
   IF (ES AND SL NE 0) GOTO 75     *IF SCOPE LOOP                        D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
61 IF (ES AND RC NE 0) GOTO 26     *REPEAT CONDITION
   GOTO 40                         *MESSAGE AND END 
/         VALIDATION ROUTINE
65 IF (P3 LE 27) GOTO 66           *IF SECTOR OK
   B0 = 1 
   MSG 6 (P3) TO LINE 2            *SECTOR ERROR MESSAGE
66 B5 = P3                         *SET SECTOR
   IF (P2 LE 22) GOTO 67           *IF TRACK OK 
   B0 = B0+1
   MSG 7 (P2) TO LINE 3            *TRACK MESSAGE 
67 B6 = P2                         *CURRENT TRACK 
   OB(503) = 632                   *SINGLE DENSITY
   IF (DC EQ 2) GOTO 70            *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 70            *IF 2X DRIVE 
   OB(503) = 1466 
70 IF (P0 LE OB(503)) GOTO 71      *IF CYLINDER TO LARGE
   B0 = B0+1
   MSG 10 (P0) TO LINE 4           *CYLINDER MESSAGE
71 OB(503) = OB(503) - 3           *SET FOR PREALLOCATED
   B7 = P0                         *SET CYLINDER
   IF (B0 NE 0) GOTO 40 
   RETURN                          *PARAMETERS OK 
/         SCOPE LOOP
75 B2 = B2+1
   MSG 2 (B2,B3) TO DISPLAY 
   GOTO 27
77 END 20 
COMPILE 
   MODULE D4446,844HT(02,03,04,05),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        TOGGLE PARAMETERS TEST 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK THE VALIDITY OF THE INPUT PARAMETERS. 
*         3.  CHECK THE ACCESS LEVEL MEETS THE CRITERIA OF
*             THE INPUT PARAMETERS. 
*         4.  RESERVE THE DRIVE AND TOGGLE BETWEEN THE
*             DESCRIBED INPUT PARAMETERS. 
*         5.  REPEAT CONDITION REPEATS THE ABOVE SEQUENCE 
*             DISPLAYING ANY ERROR MESSAGES.
*         6.  SCOPE LOOP DISPLAYS SCOPE LOOP MESSAGE TO THE 
*             DISPLAY AND LOOPS ON SEQUENCE 3.
* 
*    REGISTER USAGE 
* 
*         B0 = VALIDATION ERROR COUNTER.
*         B1 = NUMBER OF SECTORS TO EXECUTE.
*         B2 = SCOPE LOOP COUNTER.
*         B3 = CURRENT SECTOR.
*         B4 = LOW TRACK. 
*         B5 = HIGH TRACK.
*         B6 = LOW CYLINDER.
*         B7 = HIGH CYLINDER. 
*         WC = READ BUFFER SIZE.
*         OB(503) = LOW SECTOR. 
*         OB(504) = HIGH SECTOR.
*         BA = ERROR COUNTER. 
* 
*    INPUT REGISTER USAGE 
* 
*         P0 = LOW CYLINDER.
*         P1 = HIGH CYLINDER. 
*         P2 = TRACKS.
*         P3 = SECTORS. 
* 
 1 FORMAT D4446 - TOGGLE TEST 
 2 FORMAT LC=*DEC,EC=*DEC SCOPE LOOP
 3 FORMAT D4446 - ERROR(S) IN MODULE
 5 FORMAT //D4446 - NOT EXECUTED, NEEDS AL=0002, AL=*OCT // 
 6 FORMAT D4446 - SECTOR PARAM ERROR  *OCT
 7 FORMAT D4446 - TRACK PARAM ERROR  *OCT 
10 FORMAT D4446 - CYLINDER PARAM ERROR  *OCT
11 FORMAT D4446 - TOGGLE CYL=*OCT, TRK=*OCT, SEC=*OCT 
12 FORMAT D4446 -        CYL=*OCT, TRK=*OCT, SEC=*OCT 
20 MSG 1 TO DISPLAY,PRINT 
   IF (AL GE 2) GOTO 21      *IF ACCESS OK
   MSG 5 (AL) TO LINE 1 
   GOTO 40                   *END IT
21 WC = 500                  *READ BUFFER SIZE
   B4 = P2 RS 6              *LOW TRACK 
   B5 = P2 AND 77            *HIGH TRACK
   B6 = P0                   *LOW CYLINDER
   B7 = P1                   *HIGH CYLINDER 
   OB(503) = P3 RS 6         *LOW SECTOR
   OB(504) = P3 AND 77       *HIGH SECTOR 
   GOSUB 65                  *CHECK PARAMETERS
   MSG 11(B6,B4,OB(503)) TO PRINT 
   MSG 12(B7,B5,OB(504)) TO PRINT 
23 RES DRIVE, ABT 60
   B3 = OB(503)              *LOWER SECTOR
   B1 = 1 
   READ B1 SECTORS AT CYL B6 TRK B4 SEC B3, ABT 60
   B3 = OB(504)                      *UPPER SECTOR
   MSG 11(B7,B5,B3) TO DISPLAY
   B1 = 1 
   READ B1 SECTORS AT CYL B7 TRK B5 SEC B3, ABT 60
   IF (ES AND SL NE 0) GOTO 75       *SCOPE LOOP
   IF (ES AND RC NE 0) GOTO 23       *REPEAT CONDITION
   MSG 11(B6,B4,B3) TO DISPLAY
   REL, ABT 60
   IF (BA EQ 0) GOTO 41              *IF NO ERRORS
40 MSG 3 TO DAYFILE 
41 PICTURE
   GOTO 77                           *END 
/         ERROR ROUTINE 
60 BA = BA+1                         *ERROR COUNT                        D44011J
   IF (ES AND SL NE 0) GOTO 75       *IF SCOPE LOOP                      D44011J
   MSG EM TO LINE 1 
   PICTURE
   HALT 
   BLANK
61 IF (ES AND RC NE 0) GOTO 23       *REPEAT CONDITION
   GOTO 40                           *END IT
/         VALIDATION ROUTINE
65 IF (OB(503) GT 27) GOTO 66        *IF SECTOR OK
   IF (OB(504) LE 27) GOTO 67        *IF SECTOR OK
66 B0 = 1 
   MSG 6 (P3) TO LINE 2              *SECTOR ERROR MESSAGE
67 IF (B4 GT 22) GOTO 70             *IF TRACK OK 
   IF (B5 LE 22) GOTO 71
70 B0 = B0+1
   MSG 7 (P2) TO LINE 3              *TRACK MESSAGE 
71 IB(503) = 632                     *SINGLE DENSITY
   IF (DC EQ 2) GOTO 72              *IF 2X DRIVE 
   IF (DC EQ 4) GOTO 72              *IF 2X DRIVE 
   IB(503) = 1466 
72 IF (B6 GT IB(503)) GOTO 73        *IF CYLINDER TO0 LARGE 
   IF (B7 LE IB(503)) GOTO 74        *IF CYLINDER TO0 SMALL 
73 B0 = B0+1
   MSG 10 (P0) TO LINE 4             *CYLINDER MESSAGE
74 IF (B0 NE 0) GOTO 40 
   RETURN                            *PARAMETERS OK 
/         SCOPE LOOP
75 B2 = B2+1
   MSG 2 (B2,BA) TO DISPLAY                                              D44011J
   GOTO 23
77 END 20 
COMPILE 
   MODULE D4447,6000(02,03,04,05),LOCK
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/        DEAD MAN TERMINATOR TEST 
* 
*         1.  DISPLAY MODULE FUNCTION.
*         2.  CHECK FOR AN ACCESS LEVEL OF 21.
*         3.  RESERVE AND CONNECT TO THE CONTROLLER.
*         4.  GENERAL STATUS.  IF THE ATLERNET ACCESS IS IN 
*             USE, POST AN ACCESS RESERVED MESSAGE, AND WAIT
*             FOR THE ATLERNET ACCESS TO CLEAR OR THE MODULE
*             TO BE STOPPED.
*         5.  FUNCTION THE CONTROLLER WITH A START MEMORY 
*             LOAD FUNCTION, AND OUTPUT A 4 WORD RESTART
*             ADDRESS FOR THE BUFFER CONTROLLER.
*         6.  THE CHANNEL IS LEFT ACTIVE AFTER THE 4 WORD 
*             OUTPUT AND IS TIMED TO INSURE THAT AN INACTIVE
*             TAKES PLACE BEWTEEN 2 TO 5 SECONDS FROM THE 
*             DEAD MAN TIMER. 
*         7.  REPORT CONDITION LOOPS THE FULL DEAD MAN
*             TERMINATOR TEST.
* 
*    REGISTER USAGE 
* 
*         B1 = TEMPORARY STORAGE FOR LOOP COUNT.
*         B2 = DELAY COUNTER. 
*         B6 = MESSAGE INDEX. 
*         WC = WORD COUNT.
* 
 1 FORMAT D4447 DEAD MAN TEST 
 3 FORMAT D4447 - ERROR(S) IN MODULE
 5 FORMAT //D4447 - NOT EXECUTED, NEEDS AL=0021, AL=*OCT // 
 6 FORMAT D4447 FAILED ON RESERVE 
 7 FORMAT D4447 FAILED ON RELEASE 
10 FORMAT D4447 CHANNEL ACTIVE AFTER OUTPUT 
11 FORMAT D4447 NO DEACTIVE FROM DEAD MAN TIMER 
12 FORMAT D4447 FUNCTION FAILED ON GENERAL STATUS 
13 FORMAT D4447 FUNCTION //414//  START MEMORY LOAD FAILED
14 FORMAT D4447 OUTPUT INSTRUCTION FAILED 
15 FORMAT D4447 ACCESS RESERVED.  GENERAL STATUS *OCT 
   DATA (OB,CON) 1,0,274,0
20 MSG 1 TO DISPLAY, PRINT
   IF (AL GE 21) GOTO 23     *IF ACCESS OK
   MSG 5 (AL) TO LINE 1 
   GOTO 50                   *END IT
23 CONN, ABT 55 
24 FUNC 12, ABT 56           *GENERAL STATUS
   STATUS 1 WORDS TO SB 
   IF (SB NE 2000) GOTO 25   *CHECK ALTERNATE ACCESS
   DELAY 10 MSEC             *DELAY 
   MSG 15 (SB) TO DISPLAY 
   GOTO 24 WHILE(B1+1 LT 50)
   MSG 15 (SB) TO LINE 1
   PICTURE
   B1 = 0 
   GOTO 23                   *TIME OUT
25 B1 = 1 
   WC = 4 
   FUNC 414, ABT 57          *START MEMORY LOAD 
   OUTB CHAIN, ABT 60 
   ACN, ABT 30
   GOTO 61                   *ERROR 
30 DELAY 4000D USEC 
   GOTO 30 WHILE(B2+1 LT 250D)  *DELAY ONE SECOND 
   ACN, ABT 32                  *CHANNEL ACTIVE 
   GOTO 61
32 B2 = 0 
33 DELAY 4000D USEC 
   GOTO 33 WHILE(B2+1 LT 250D)  *DELAY ONE SECOND 
   ACN, ABT 34                  *CHANNEL ACTIVE 
   GOTO 61
34 B2 = 0 
35 DELAY 4000D USEC 
   GOTO 35 WHILE(B2+1 LT 250D)  *DELAY ONE SECOND 
   ACN, ABT 36                  *CHANNEL ACTIVE 
   GOTO 45
36 B2 = 0 
37 DELAY 4000D USEC 
   GOTO 37 WHILE(B2+1 LT 250D)  *DELAY ONE SECOND 
   ACN, ABT 40                  *CHANNEL ACTIVE 
   GOTO 45
40 B2 = 0 
41 DELAY 4000D USEC 
   GOTO 41 WHILE(B2+1 LT 250D)  *DELAY ONE SECOND 
   ACN, ABT 63                  *CHANNEL ACTIVE 
45 DCN, ABT 46
46 REL, ABT 62
   IF (ES AND RC EQ RC) GOTO 23  *IF REPEAT CONDITION 
   IF (B3 EQ 0) GOTO 50          *IF NO ERRORS
47 MSG 3 TO DAYFILE 
50 PICTURE
   GOTO 77                       *END 
/         PROCESS ERRORS
55 B6 = 6                        *RESERVE DRIVE 
   GOTO 66
56 B6 = 12                       *GENERAL STATUS
   GOTO 65
57 B6 = 13                       *START MEMORY FAILED 
   GOTO 65
60 B6 = 14                       *OUTPUT FAILED 
   GOTO 65
61 B6 = 10                       *ACTIVE CHANNEL
   GOTO 65
62 B6 = 7                        *FAILED ON RELEASE 
   GOTO 66
63 B6 = 11                       *NO DEACTIVE 
65 DCN, ABT 66
66 REL, ABT 67
67 MSG B6 TO LINE 2 
75 B7 = B7+1                     *ERROR COUNT 
   PICTURE
   HALT 
   BLANK
76 IF (ES AND RC EQ RC) GOTO 23   *REPEAT CONDITION 
   GOTO 47                        *REPORT ERROR END 
77 END 20 
COMPILE 
   MODULE D4448,844FT(2,3,4,5),LOCK 
*** INTERNAL DOCUMENTATION
* 
*   DESCRIPTION - 
/         READ AND PRINT FLAW MAPS AND ACTUAL ADDRESS FLAWS 
* 
*          1.  DISPLAY MODULE FUNCTION. 
*          2.  RESERVE DRIVE. 
*          3.  READ SERIAL NUMBER, RELEASE DRIVE AND PRINT SERIAL 
*              NUMBER OF THE PACK.
*          4.  RESERVE DRIVE. 
*          5.  READ FACTORY MAP, RELEASE DRIVE AND PRINT THE FLAW 
*              MAP (IN DECIMAL AND OCTAL) AND IDENTIFY THE TYPE OF
*              FLAW (CORRECTABLE, TRACK OR SECTOR). 
*          6.  RESERVE DRIVE. 
*          7.  READ THE UTILITY MAP, RELEASE DRIVE AND PRINT THE FLAW 
*              MAP (IN DECIMAL AND OCTAL) AND IDENTIFY THE TYPE OF
*              FLAW (CORRECTABLE, TRACK OR SECTOR). 
*          8.  PERFORM A READ CHECKWORD OPERATION ON THE ENTIRE DISK
*              PACK AT 1:1 INTERLACE IN TRACK MODE.  REPORT ALL TRACK 
*              AND SECTOR FLAWS (IN DECIMAL AND OCTAL) AND IDENTIFY 
*              THE TYPE OF FLAW (TRACK OR SECTOR).  IGNORE ALL OTHER
*              ERRORS EXCEPT FLAWS. 
* 
*   REGISTER USAGE
* 
*        B0 = INDEX TO INPUT BUFFER.
*        B1 = MESSAGE NUMBER TO PRINT.
*        B2 = CYLINDER WITH FLAW. 
*        B3 = TRACK WITH FLAW.
*           = MAXIMUM CYLINDER TO PROCESS + 1.
*        B4 = SECTOR WITH FLAW. 
*           = NUMBER OF SECTORS TO PROCESS. 
*        B5 = CURRENT SECTOR. 
*        B6 = CURRENT TRACK.
*        B7 = CURRENT CYLINDER. 
* 
 1 FORMAT D4448 - PACK FLAW REPORTS 
 2 FORMAT    PACK SERIAL NUMBER = *3H*3H
 3 FORMAT 
 4 FORMAT   CYL  TRK  SEC(DEC)   CYL  TRK  SEC(OCTAL) TYPE
 5 FORMAT  *DEC *DEC *DEC       *OCT *OCT *OCT   CORRECTABLE
 6 FORMAT  *DEC *DEC *DEC       *OCT *OCT *OCT       TRACK
 7 FORMAT  *DEC *DEC *DEC       *OCT *OCT *OCT       SECTOR 
10 FORMAT  *DEC *DEC *DEC       *OCT *OCT *OCT       TRACK
11 FORMAT             FACTORY FLAW MAP
12 FORMAT             UTILITY FLAW MAP
13 FORMAT         ACTUAL FLAWS IN ADDRESS FIELDS
14 FORMAT  I/O COMMAND ABORT - RERUN TEST 
15 FORMAT D4448 - CYL *OCT, TRK *OCT, SEC *OCT
* 
20 MSG 1 TO DISPLAY,PRINT    *POST RUNNING MESSAGE
   MARGINS NORMAL OFFSET NORMAL STROBES, ABT 70 
* 
*---------PRINT PACK SERIAL NUMBER
* 
   RES DRIVE, ABT 70
   GET SERIAL, ABT 70 
   REL, ABT 70
   MSG 2(IB,IB(1)) TO PRINT  *PRINT SERIAL NUMBER 
   MSG 3 TO PRINT            *BLANK LINE
* 
*---------PRINT FACTORY FLAW DATA 
* 
   MSG 11 TO PRINT           *FACTORY FLAW HEADER 
   MSG 4 TO PRINT 
   RES DRIVE, ABT 70
   GET FACTORY, ABT 70
   REL, ABT 70
   GOSUB 60                  *CONVERT AND PRINT FLAWS 
* 
*---------PRINT UTILITY FLAW DATA 
* 
   MSG 12 TO PRINT           *UTILITY FLAW HEADER 
   MSG 4 TO PRINT 
   RES DRIVE, ABT 70
   GET UTILITY, ABT 70
   REL, ABT 70
   GOSUB 60                  *CONVERT AND PRINT FLAWS 
* 
*---------PRINT ACTUAL ADDRESS FIELD FLAWS
* 
   MSG 13 TO PRINT           *ACTUAL FLAWS HEADER 
   MSG 4 TO PRINT 
   B7 = 0                    *STARTING CYLINDER 
   B3 = 633                  *MAX SINGLE DENSITY CYL+1
   IF(DC.AND.1.EQ.0)GOTO 30  *IF SINGLE DENSITY 
   B3 = 1467                 *MAX DOUBLE DENSITY CYL+1
30 B6 = 0                    *STARTING TRACK
32 B5 = 0                    *STARTING SECTOR 
34 B4 = 30                   *NUMBER OF SECTORS TO PROCESS
36 MSG 15(B7,B6,B5) TO DISPLAY
   RES DRIVE, ABT 70
   READCW B4 SECTORS AT CYL B7 TRK B6 SEC B5, ABT 50
40 GOTO 32 WHILE(B6+1.LE.22)  *READ ALL TRACKS
   GOTO 30 WHILE(B7+1.NE.B3)  *READ ALL CYLINDERS 
   MSG 3 TO PRINT 
   MSG 3 TO PRINT 
   GOTO 77                    *TERMINATE
* 
*--------PRINT ADDRESS FLAWS SUBROUTINE 
* 
50 IF(SB(6).AND.10.NE.0) GOTO 54  *IF TRACK FLAW
   IF(SB(6).AND.20.EQ.0) GOTO 52  *IF NO SECTOR FLAW
   MSG 7(B7,B6,B5,B7,B6,B5) TO PRINT  *REPORT SECTOR FLAW 
52 IF(B4.EQ.0) GOTO 40            *IF NO SECTORS LEFT 
   B4 = B4 - 1                    *CORRECT REGISTERS
   B5 = B5 + 1                    *TO POINT TO NEXT SECTOR
   GOTO 36                        *READ REMAINING SECTORS 
54 MSG 6(B7,B6,B5,B7,B6,B5) TO PRINT  *REPORT TRACK FLAW
   GOTO 40                        *READ NEXT TRACK
* 
*--------PRINT FLAW MAPS SUBROUTINE 
* 
60 MSG 3 TO PRINT 
   B0 = 0                         *INDEX TO INPUT BUFFER
62 IF(IB(B0).OR.IB(B0+1).EQ.0) GOTO 64  *IF END OF MAP
   B1 = IB(B0).RS.10D+5           *MESSAGE NUMBER TO POST 
   B2 = IB(B0).AND.1777           *CYLINDER 
   B3 = IB(B0+1).RS.6             *TRACK
   B4 = IB(B0+1).AND.77           *SECTOR 
   MSG B1(B2,B3,B4,B2,B3,B4) TO PRINT 
   GOTO 62 WHILE(B0+2.NE.500) 
64 MSG 3 TO PRINT 
   MSG 3 TO PRINT 
   MSG 3 TO PRINT 
   RETURN 
* 
*---------ABORT PROCESSOR 
* 
70 B1 = 600B
   CALL 98F                  *PROCESS RESERVE ABORTS
   MSG 14 TO PRINT
77 END 20 
COMPILE 
   MODULE D4450,844HT(02,03,04,05)
***  INTERNAL DOCUMENTATION 
* 
*    DESCRIPTION
/        COARSE POSITION PLOT 
* 
*        1. SET UPPER CYLINDER LIMIT TO 256B
*        2. CHECK DEVICE CODE FOR DOUBLE DENSITY
*        3. IF NOT DOUBLE DENSITY, POST MESSAGE AND EXIT
*        4. IF DOUBLE DENSITY, RESERVE DRIVE
*        5. SEEK TO CYLINDER ZERO (0) 
*        6. SEEK TO CYLINDER 256B AND SAVE SEEK TIME
*        7. REPEAT STEPS 4-6 44D TIMES
*        8. PLOT SEEK TIMES 
*        9. IF SEEK TIMES OUT OF SPEC, POST APPROPRIATE 
*           ADJUSTMENT MESSAGE
* 
*    REGISTER USAGE 
* 
*        B0 = GRAPH LINE NUMBER 
*        B1 = LINE COUNTER
*        B2 = LOOP COUNTER/SEEK TIME
*        B3 = OVER SPEC ERROR COUNTER 
*        B4 = UNDER SPEC ERROR COUNTER
*        B5 = SECTOR
*        B6 = TRACK AND LOWER CYLINDER
*        B7 = UPPER CYLINDER
*        B8 = ERROR FLAG
* 
1  FORMAT D4450 -  COARSE POSITION PLOT 
4  FORMAT D4450 RUNS ONLY ON DOUBLE DENSITY DRIVES
5  FORMAT   COARSE GAIN ADJ 256 CYL SEEK
6  FORMAT *DEC
7  FORMAT *DEC  --------------------------------------------- 
10 FORMAT OVER
11 FORMAT UNDER 
12 FORMAT           ADJ POT A ON A27 CLOCKWISE
13 FORMAT           ADJ POT A ON A27 COUNTER CLOCKWISE
20 MSG 1 TO DISPLAY,PRINT 
   B7=256                        *CYLINDER LIMIT
   IF (DC.AND.1.NE.0) GOTO 21    *IF DOUBLE DENSITY DRIVE 
   MSG 4 TO PRINT                *POST NOT SUPPORTED MSG
   EXIT 
21 RES DRIVE, ABT 60
   SEEK CYL B6 TRK B6 SEC B5,ABT 60    *SEEK TO CYL 0 
   SEEK CYL B7 TRK B6 SEC B5,ABT 60    *SEEK TO CYL 256 
   OB(B2) = SB(60)           *SAVE SEEK TIME IN OUTPUT BUF
   IF(SB(60).GE.25D)B3=B3+1  *IF SEEK TIME IS OVER 24MSEC 
   IF(SB(60).LE.21D)B4=B4+1  *IF SEEK TIME IS UNDER 22MSEC
24 GOTO 21 WHILE (B2+1.NE.44D)   *SEEK 44D TIMES
   REL,ABT 60                    *RELEASE THE DRIVE 
31 MSG 5 TO LINE 0           *POST PLOT HEADING 
   MSG 10 TO LINE 1          *POST OVER MSG 
   IF(B3.NE.0) B8=1          *IF UNIT OVER LIMIT
   IF(B4.NE.0) B8=2          *IF UNIT UNDER LIMIT 
   B0=30D                    *STARTING LINE NUMBER
   B1=2                      *LINE NUMBER 
32 IF (B0.EQ.25D)GOTO 33     *IF UPPER BIAS LINE
   IF (B0.EQ.21D)GOTO 33     *IF LOWER BIAS LINE
   MSG 6(B0) TO LINE B1 
   GOTO 34                   *PRINT TIMES IN MSEC 
33 MSG 7(B0) TO LINE B1 
34 B1=B1+1                   *BUMP LINE COUNTER 
   GOTO 32 WHILE(B0-1.NE.20D) 
   MSG 11 TO LINE B1
   B2=0 
   B3=6                      *CHARACTER POSITION
35 B0=OB(B2)+7               *ADJUST DATA TO PLOT 
   PLOT LINE B0 CHAR B3 
   B3=B3+1                     *ADD 1 TO CHARACTER POSITION 
   GOTO 35 WHILE(B2+1.NE.44D)  *PRINT ALL 44D SEEK TIMES
   IF(B8.EQ.1)MSG 12 TO LINE 16   *IF OVER
   IF(B8.EQ.2)MSG 13 TO LINE 16   *IF UNDER 
   PICTURE
   IF(B8.EQ.0) EXIT          *NO ERRORS EXIT
   HALT 
   BLANK
   EXIT 
60 B1=0620              *TEST NUMBER FOR ERROR HANDLER
   BLANK
   CALL 98A             *CALL ERROR PROCESSOR 
   GOTO 21
   END 20 
COMPILE 
   MODULE D4451,844HT(02,03,04,05)
***  INTERNAL DOCUMENTATION 
* 
*    DESCRIPTION
/        VELOCITY GAIN TIMING PLOT
* 
*        1. SET UPPER CYLINDER LIMIT TO 632B FOR SINGLE 
*           DENSITY, 1466B FOR DOUBLE DENSITY 
*        2. RESERVE DRIVE 
*        3. SEEK TO CYLINDER ZERO (0) 
*        4. SEEK TO UPPER CYLINDER AND SAVE SEEK TIME 
*        5. SEEK BACK TO CYLINDER ZERO (0) AND SAVE SEEK TIME 
*        6. REPEAT STEPS 2-5 44D TIMES
*        7. PLOT SEEK TIMES FOR FORWARD AND REVERSE 
*        8. IF SEEK TIMES OUT OF SPEC, POST APPROPRIATE 
*           ADJUSTMENT MESSAGE
* 
*    REGISTER USAGE 
* 
*        B0 = GRAPH LINE NUMBER 
*        B1 = LINE COUNTER/UNDER SPEC ERROR COUNTER 
*        B2 = LOOP COUNTER/SEEK TIME
*        B3 = CHARACTER POSITION/OVER SPEC ERROR COUNTER
*        B4 = UNDER SPEC ERROR COUNTER
*        B5 = SECTOR
*        B6 = TRACK AND LOWER CYLINDER
*        B7 = UPPER CYLINDER
*        B8 = ERROR FLAG
* 
1  FORMAT              VELOCITY GAIN MAX SEEK FORWARD 
2  FORMAT              VELOCITY GAIN MAX SEEK REVERSE 
3  FORMAT           ADJ POT B ON A27 CLOCKWISE
4  FORMAT           ADJ POT B ON A27 COUNTER CLOCKWISE
5  FORMAT *DEC
6  FORMAT *DEC  --------------------------------------------- 
7  FORMAT OVER
10 FORMAT UNDER 
11 FORMAT D4451 - VELOCITY GAIN TIMING PLOTS
12 FORMAT           ADJ POT A ON A29 CLOCKWISE
13 FORMAT           ADJ POT A ON A29 COUNTER CLOCKWISE
20 MSG 11 TO DISPLAY,PRINT
   B7=632                    *CYL LIMIT FOR SINGLE DENSITY
   IF(DC.AND.1.NE.0)B7=1466  *IF DOUBLE DENSITY UNIT
22 RES DRIVE, ABT 60
   SEEK CYL B6 TRK B6 SEC B5,ABT 60    *SEEK TO CYL 0 
   SEEK CYL B7 TRK B6 SEC B5,ABT 60    *DO MAX SEEK FORWARD 
   OB(B2) = SB(60)           *SAVE FORWARD SEEK TIME
   IF(SB(60).GE.56D)B3=B3+1  *IF OVER 55D BUMP ERR CNTR 
   IF(SB(60).LE.49D)B4=B4+1  *IF UNDER 50D BUMP ERR CNTR
   SEEK CYL B6 TRK B6 SEC B5,ABT 60    *REVERSE SEEK TO CYL 0 
   OB(B2+44D) = SB(60)       *SAVE REVERSE SEEK TIME
   IF(SB(60).GE.56D)B3=B3+1  *IF OVER 55D BUMP ERR CNTR 
   IF(SB(60).LE.49D)B4=B4+1  *IF UNDER 50D BUMP ERR CNTR
25 GOTO 22 WHILE (B2+1.NE.44D)    *REPEAT SEEK 44D TIMES
   REL,ABT 60                     *RELEASE THE DRIVE
   MSG 1 TO LINE 0
   MSG 7 TO LINE 1
   B0=60D                    *UPPER LIMIT FOR PLOT
   B1=2                      *LINE NUMBER 
   IF(DC.AND.1.EQ.0)GOTO 31      *IF SINGLE DENSITY UNIT
   IF(B3.NE.0) B8=3          *IF SEEK TIME OUT OF SPECS 
   IF(B4.NE.0) B8=4          *IF SEEK TIME OUT OF SPECS 
   GOTO 32                       *START PLOTS 
31 IF(B3.NE.0) B8=12         *IF SEEK TIME OUT OF SPECS 
   IF(B4.NE.0) B8=13         *IF SEEK TIME OUT OF SPECS 
32 IF(B0.EQ.56D)GOTO 33      *UPPER BIAS LINE 
   IF(B0.EQ.49D)GOTO 33      *LOWER BIAS LINE 
   MSG 5(B0) TO LINE B1 
   GOTO 34                   *BUILD PLOT
33 MSG 6(B0)TO LINE B1
34 B1=B1+1                        *BUMP LINE NUMBER 
   GOTO 32 WHILE(B0-1 .NE. 44D)   *LOWER PLOT LIMIT 
   MSG 10 TO LINE B1
   B2=0                      *LINE NUMBER 
   B3=6                      *CHARACTER NUMBER
35 B0=OB(B2)-23D             *ADJUST DATA TO PLOT 
   PLOT LINE B0 CHAR B3 
   B3=B3+1                   *ADD 1 TO CHARACTER POSITION 
   GOTO 35 WHILE (B2+1 .NE. 44D)  *PLOT ALL 44D SEEK TIMES
*    START OF REVERSE PLOT
   MSG 2 TO LINE 24 
   MSG 7 TO LINE 25          *POST OVER MESSAGE 
   B0 = 60D 
   B1 = 26                   *STARTING LINE NUMBER
40 IF(B0.EQ.56D)GOTO 41      *UPPER BIAS LINE 
   IF(B0.EQ.49D)GOTO 41      *LOWER BIAS LINE 
   MSG 5(B0) TO LINE B1 
   GOTO 42
41 MSG 6(B0) TO LINE B1 
42 B1=B1+1                        *BUMP LINE NUMBER 
   GOTO 40 WHILE (B0-1.NE.44D)    *IF NOT END OF PLOT 
   MSG 8 TO LINE B1               *POST UNDER MESSAGE 
   B3 = 6                         *CHARACTER POSITION 
   B2 = 44D                       *POINTER TO TIME DATA 
50 B0 = OB(B2)-43D                *ADJUST DATA TO PLOT
   PLOT LINE B0 CHAR B3 
   B3 = B3 + 1
   GOTO 50 WHILE(B2+1.NE.88D)    *PLOT REVERSE TIME 
   IF(B8.EQ.0) GOTO 54       *NO ERRORS EXIT
   MSG B8 TO LINE 47   *IF OUT OF SPECS 
54 PICTURE
   IF(B8.EQ.0) EXIT          *NO ERRORS EXIT
   HALT 
   BLANK
   EXIT 
60 B1=0630                   *MODULE NUMBER FOR ERROR PROCESSOR 
   BLANK
   CALL 98A                  *CALL ERROR HANDLER
   GOTO 22                   *RETRY THE TEST
   END 20 
COMPILE 
   MODULE D4452,844HT(02,03,04,05)
***  INTERNAL DOCUMENTATION 
* 
*    DESCRIPTION
/        INTEGRATOR GAIN ADJUSTMENT 
* 
*        1. SET UPPER CYLINDER LIMIT TO 64B FOR SINGLE
*           DENSITY, 32B FOR DOUBLE DENSITY 
*        2. RESERVE DRIVE 
*        3. SEEK TO CYLINDER ZERO (0) 
*        4. SEEK TO UPPER CYLINDER AND SAVE SEEK TIME 
*        5. REPEAT STEPS 2-4 44D TIMES
*        6. PLOT SEEK TIMES 
*        7. IF SEEK TIMES OUT OF SPEC, POST APPROPRIATE 
*           ADJUSTMENT MESSAGE
* 
*    REGISTER USAGE 
* 
*        B0 = OVER SPEC ERROR COUNTER/UPPER PLOT LIMIT
*        B1 = UNDER SPEC ERROR COUNTER
*        B2 = LOOP COUNTER/SEEK TIME
*        B3 = LOWER PLOT LIMIT/UPPER SEEK TIME SPEC 
*        B4 = UPPER BIAS LINE/LOWER SEEK TIME SPEC
*        B5 = LOWER BIAS LINE/SECTOR
*        B6 = TRACK AND LOWER CYLINDER/BIAS LINE
*        B7 = UPPER CYLINDER
*        B8 = ERROR FLAG
* 
1  FORMAT           ADJ POT A ON A28 CLOCKWISE
2  FORMAT           ADJ POT A ON A28 COUNTER CLOCKWISE
3  FORMAT D4452 - INTEGRATOR GAIN TIMING PLOT 
5  FORMAT  ERROR IN MODULE 52 
6  FORMAT             INTEGRATOR GAIN ADJUSTMENT
7  FORMAT *DEC
10 FORMAT *DEC  --------------------------------------------- 
11 FORMAT OVER
12 FORMAT UNDER 
13 FORMAT           ADJ POT C ON A27 CLOCKWISE
14 FORMAT           ADJ POT C ON A27 COUNTER CLOCKWISE
20 MSG 3 TO DISPLAY,PRINT 
   B3=13D                    *UPPER LIMIT DOUBLE DENSITY DRIVE
   B4=9D                     *LOWER LIMIT DOUBLE DENSITY DRIVE
   B7=32                     *CYL LIMIT FOR DOUBLE DENSITY
   IF(DC.AND.1.NE.0)GOTO 23  *IF DOUBLE DENSITY DRIVE 
   B3=22D                    *UPPER LIMIT SINGLE DENSITY DRIVE
   B4=19D                    *LOWER LIMIT SINGLE DENSITY DRIVE
   B7=64                     *CYL LIMIT SINGLE DENSITY
23 RES DRIVE,ABT 60          *RESERVE THE UNIT
   SEEK CYL B6 TRK B6 SEC B5,ABT 60  *SEEK TO CYLINDER 0
   SEEK CYL B7 TRK B6 SEC B5,ABT 60  *SEEK TO CYLINDER 32/64
   OB(B2) = SB(60)           *SAVE SEEK TIME
   IF(SB(60).GE.B3)B0=B0+1   *IF SEEK TIME OVER SPEC
   IF(SB(60).LE.B4)B1=B1+1   *IF SEEK TIME UNDER SPEC 
35 GOTO 23 WHILE(B2+1.NE.44D)     *REPEAT SEEKS 44D TIMES 
   REL,ABT 60                     *RELEASE THE DRIVE
   MSG 6 TO LINE 0
   IF(DC.AND.1.EQ.0)GOTO 41      *IF SINGLE DENSITY 
   IF(B0.NE.0) B8=13         *IF SERVO SLOW 
   IF(B1.NE.0) B8=14         *IF SERVO FAST 
   GOTO 42                       *START PLOTS 
41 IF(B0.NE.0) B8=1          *IF SERVO SLOW 
   IF(B1.NE.0) B8=2          *IF SERVO FAST 
42 MSG 11 TO LINE 1          *START BUILDING PLOT 
   B0=27D                    *UPPER PLOT LIMIT SINGLE DENSITY 
   B3=14D                    *LOWER PLOT LIMIT SINGLE DENSITY 
   B6=12                     *BIAS FOR PLOT SINGLE DENSITY
   B4=22D                    *UPPER BIAS LINE SINGLE DENSITY
   B5=19D                    *LOWER BIAS LINE SINGLE DENSITY
   IF(DC.AND.1.EQ.0)GOTO 43  *IF SINGLE DENSITY 
   B0=17D                    *UPPER PLOT LIMIT DOUBLE DENSITY 
   B3=3D                     *LOWER PLOT LIMIT DOUBLE DENSITY 
   B6=24                     *BIAS FOR PLOT DOUBLE DENSITY
   B4=13D                    *UPPER BIAS LINE DOUBLE DENSITY
   B5=9D                     *LOWER BIAS LINE DOUBLE DENSITY
43 B1=2                      *PLOT LINE COUNTER 
45 IF (B0.EQ.B4)GOTO 46      *IF UPPER BIAS LINE
   IF (B0.EQ.B5)GOTO 46      *IF LOWER BIAS LINE
   MSG 7(B0) TO LINE B1      *PLOT LINES
   GOTO 47                   *CONTINUE BUILDING PLOT
46 MSG 10(B0) TO LINE B1
47 B1=B1+1
   GOTO 45 WHILE(B0-1.NE.B3)  *LOOP UNTIL PLOT COMPLETE 
   MSG 12 TO LINE B1
   B2=0                      *LINE MUNBER 
   B3=6                      *CHARACTER POSITION
50 B0=OB(B2)+B6              *PLOT SEEK TIME ON GRAPH 
   PLOT LINE B0 CHAR B3 
   B3=B3+1                   *ADD 1 TO CHAR POSITION
   GOTO 50 WHILE(B2+1.NE.44D)     *REPEAT LOOP
   IF(B8.EQ.0) GOTO 54   *IF NO ERROR 
   MSG B8 TO LINE 20   *IF OUT OF SPEC
54 PICTURE
   IF(B8.EQ.0) EXIT          *NO ERRORS EXIT
   HALT 
   BLANK
   EXIT 
60 B1=0640                   *MODULE NUMBER FOR ERROR PROCESSOR 
   BLANK
   CALL 98A                  *CALL ERROR PROCESSOR
   GOTO 23
   END 20 
COMPILE 
   MODULE D4453,844HT(02,03,04,05)
***  INTERNAL DOCUMENTATION 
* 
*    DESCRIPTION
/        FINE POSITION PLOT 
* 
*        1. SET UPPER CYLINDER LIMIT TO ONE (1) 
*        2. CHECK DEVICE CODE FOR SINGLE DENSITY
*        3. IF NOT SINGLE DENSITY, POST MESSAGE AND EXIT
*        4. IF SINGLE DENSITY, RESERVE DRIVE
*        5. SEEK TO CYLINDER ZERO (0) 
*        6. SEEK TO CYLINDER ONE (1) AND SAVE SEEK TIME 
*        7. REPEAT STEPS 4-6 44D TIMES
*        8. PLOT SEEK TIMES 
* 
*    REGISTER USAGE 
* 
*        B0 = UPPER AND LOWER PLOT LIMIT
*        B1 = UPPER BIAS LIMIT
*        B2 = LOWER BIAS LIMIT/SEEK TIME
*        B3 = LINE COUNTER
*        B5 = SECTOR
*        B6 = TRACK AND LOWER CYLINDER
*        B7 = UPPER CYLINDER
* 
1  FORMAT D4453 - FINE POSITION PLOT
3  FORMAT   D4453 RUNS ONLY SGL DEN UNIT
4  FORMAT *DEC
5  FORMAT *DEC  --------------------------------------------- 
6  FORMAT  OVER 
7  FORMAT UNDER 
10 FORMAT            FINE POSITION PLOT 
11 FORMAT           ADJ POT D ON C30 CLOCKWISE
12 FORMAT           ADJ POT D ON C30 COUNTER CLOCKWISE
20 MSG 1 TO DISPLAY,PRINT 
   B7=1                      *CYLINDER LIMIT
   IF(DC.AND.1.EQ.0)GOTO 25  *IF SINGLE DENSITY UNIT
22 MSG 3 TO DISPLAY,PRINT    *POST NOT SUPPORTED MSG
   GOTO 77
25 RES DRIVE,ABT 60 
   SEEK CYL B6 TRK B6 SEC B5,ABT 60    *CHECK UNIT AT CYL 0 
   SEEK CYL B7 TRK B6 SEC B5,ABT 60    *SEEK 1 CYL
   OB(B2) = SB(60)           *SAVE SEEK TIME IN OB
   GOTO 25 WHILE(B2+1.NE.44D)   *SEEK 44D TIMES 
   MSG 10 TO LINE 0 
   MSG 6 TO LINE 1
   B0=12D                    *UPPER PLOT LIMIT
   B1=8D                     *UPPER BIAS LINE 
   B2=4                      *LOWER BIAS LINE 
   B3=2                      *LINE NUMBER 
32 IF (B0 EQ B1)GOTO 35      *START BUILDING PLOT 
   IF (B0 EQ B2)GOTO 35      *DRAW BIAS LINE
   MSG 4(B0) TO LINE B3 
   GOTO 36
35 MSG 5(B0) TO LINE B3 
36 B3=B3+1                   *ADD 1 TO LINE COUNTER 
   GOTO 32 WHILE(B0-1.NE.3)  *CHECK FOR PLOT COMPLETE 
   MSG 7 TO LINE B3 
   B2=0                      *SEEK TIME POINTER 
   B3=6                      *CHARACTER POSITION
37 B0=OB(B2)+31              *ADJUST DATA TO PLOT 
   PLOT LINE B0 CHAR B3 
   B3=B3+1                   *ADD 1 TO CHAR POSITION
   IF(OB(B2).GT.8)MSG 12 TO LINE 14  *IF PLOT OUT OF SPEC 
   IF(OB(B2).LT.4)MSG 11 TO LINE 14  *IF PLOT OUT OF SPEC 
   GOTO 37 WHILE(B2+1.NE.44D) 
   PICTURE
   GOTO 77
60 B1=0650                   *MODULE NUMBER FOR ERROR PROCESSOR 
   BLANK
   CALL 98A                  *CALL ERROR PROCESSOR
   GOTO 25
77 END 20 
COMPILE 
   MODULE D4498A,844HT(2,3,4,5)LOCK   - STATUS ANALYSIS                  D44009J
 1 FORMAT D44 ERROR IN MODULE *DEC AT LINE *OCT                          D44009J
 2 FORMAT  WT=*OCT  LF=*OCT  RETRIES=*OCT  ERRORS=*OCT                   D44009J
 3 FORMAT  OB(0-7)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 4 FORMAT  IB(0-7)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 5 FORMAT  B0 - B7  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 6 FORMAT  CYL=*OCT TRK=*OCT SEC=*OCT  LAST SEEK=*DEC MSEC               D44009J
 7 FORMAT    SUCCESSFUL RECOVERY - FIRST GENERAL STATUS=*OCT             D44009J
10 FORMAT    UNSUCCESSFUL RECOVERY-FIRST GENERAL STATUS=*OCT             D44009J
11 FORMAT  DS(1-8)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
12 FORMAT  DS(9-16) =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
13 FORMAT  DS(17-20)=*OCT *OCT *OCT *OCT                                 D44009J
14 FORMAT  DATA ERROR CORRECTION ADDR=*OCT 1ST=*OCT 2ND=*OCT             D44009J
15 FORMAT    LAST GENERAL STATUS = *OCT                                  D44009J
16 FORMAT  HUNG BUFFER CONTROLLER RESTARTED BY ITSELF                    D44009J
17 FORMAT  HUNG BUFFER CONTROLLER COULD NOT BE RESTARTED                 D44009J
20 FORMAT  HUNG BUFFER CONTROLLER SUCCESSFULLY RESTARTED                 D44009J
21 FORMAT D44 ERROR IN MODULE *DEC SUB *DEC AT LINE *OCT                 D44009J
22 FORMAT            // DATA COMPARE ERROR //                            D44009J
23 FORMAT  WORD=*OCT  EXPECTED=*OCT  ACTUAL=*OCT  DIFF=*OCT              D44009J
24 FORMAT D4406 ERROR - D44 MODULE 41 MAY HAVE TO BE RUN. 
30 B3 = B3 + 1               *BUMP ERROR COUNTER                         D44009J
   IB(502) = B1.RS.3         *SAVE MODULE NUMBER                         D44009J
   IB(503) = B2              *SAVE REGISTERS                             D44009J
   IB(504) = B3                                                          D44009J
   OB(502) = B4                                                          D44009J
   IF(IB(502).LT.100) GOTO 31  *IF NO SUBMOUDLE                          D44009J
   B4 = IB(502).AND.7          *ISOLATE SUBMODULE NUMBER                 D44009J
   IB(502) = IB(502).RS.3      *CORRECT MODULE NUMBER                    D44009J
   IF(B4.EQ.0) GOTO 31         *IF SUBMODULE = 0 (NONE)                  D44009J
   MSG 21 (IB(502),B4,EA) TO LINE 0                                      D44009J
   GOTO 32                                                               D44009J
31 MSG 1(IB(502),EA) TO LINE 0     *REPORT MODULE NUMBER                 D44009J
32 B4 = 2                          *SET LINE NUMBER                      D44009J
   IB(502) = B5                    *SAVE B5                              D44009J
   IF(EC.LT.4000) GOTO 33          *IF NO P.O. ERROR                     D44009J
   MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
33 MSG 2(WT,LF,SB(52),B3) TO LINE B4                                     D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 3, 8D WORDS FROM OB TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 4, 8D WORDS FROM IB TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 5 (B0,B1,B2,B3,OB(502),B5,B6,B7) TO LINE B4                       D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 6 (B7,B6,B5,SB(60)) TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   IF(B1.AND.7.EQ.3) GOTO 40       *IF BC IS HUNG                        D44009J
   IF(SB.NE.7777) GOTO 47          *IF BC IS RESPONDING                  D44009J
40 RES CONTROLLER, ABT 41          *TRY TO RESERVE                       D44009J
41 STATUS DETAIL, ABT 42           *ATTEMPT TO GET STATUS                D44009J
42 IF(SB(4).NE.7777) GOTO 44       *IF BC IS RUNNING AGAIN               D44009J
   RESET, ABT 43                   *ATTEMPT TO AUTOLOAD                  D44009J
   STATUS DETAIL, ABT 43           *ATTEMPT TO GET STATUS                D44009J
   IF(SB(4).NE.7777) GOTO 45       *IF BC WAS RE-STARTED OK              D44009J
43 MSG 17 TO LINE B4               *REPORT UNABLE TO RESTART             D44009J
   GOTO 46                                                               D44009J
44 MSG 16 TO LINE B4               *REPORT RUNNING BY ITSELF             D44009J
   GOTO 46                                                               D44009J
45 MSG 20 TO LINE B4               *REPORT RE-STARTED OK                 D44009J
46 B4 = B4 + 1                                                           D44009J
   MSG 15 (SB) TO LINE B4                                                D44009J
   B4 = B4 + 1                                                           D44009J
   B3 = 7777                       *TERMINATION VALUE TO B3              D44009J
   EXIT TO 98D                                                           D44009J
47 B4 = B4 + 1                                                           D44009J
   IF(SB(52).EQ.0) GOTO 52         *IF NO RECOVERY                       D44009J
   IF(SB.EQ.0) GOTO 50             *IF SUCCESSFUL RECOVERY               D44009J
   MSG 10 (SB(25)) TO LINE B4      *FIRST GENERAL STATUS                 D44009J
   GOTO 51                                                               D44009J
50 MSG 7 (SB(25)) TO LINE B4                                             D44009J
51 B4 = B4 + 1                                                           D44009J
   B3 = 26                                                               D44009J
   GOSUB 70                        *POST FIRST DETAIL STATUS             D44009J
   B4 = B4 + 1                                                           D44009J
52 MSG 15 (SB) TO LINE B4          *LAST GENERAL STATUS                  D44009J
   B4 = B4 + 1                                                           D44009J
   IF(SB.EQ.0) GOTO 53             *IF NO DETAIL STATUS                  D44009J
   B3 = 1                                                                D44009J
   GOSUB 70                        *POST LAST DETAIL STATUS              D44009J
   B3 = B3.AND.777B 
   B3 = B3.OR.SB(14).OR.SB(15)
   IF(B3.EQ.0) GOTO 53             *IF NO CORRECTION DATA                D44009J
   MSG 14 (SB(13),SB(14),SB(15)) TO LINE B4   *POST VECTORS 
   B4 = B4 + 1                                                           D44009J
53 IF(B1.AND.7.NE.1) GOTO 60   *IF NOT COMPARE ERROR                     D44009J
   B5 = 470                  *WORD COUNT FOR COMPARE                     D44009J
   COMPARE IB TO OB FOR B5, ABT 54                                       D44009J
   GOTO 60                   *IF COMPARE IS OK                           D44009J
54 MSG 22 TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
   B3 = B4 + 4               *LINE TERMINATION VALUE                     D44009J
55 B2 = IB(B5).XOR.OB(B5)    *LOGICAL DIFFERENCE                         D44009J
   IF(B2.EQ.0) GOTO 56       *IF WORDS COMPARE                           D44009J
   MSG 23(B5,OB(B5),IB(B5),B2) TO LINE B4 
   GOTO 56 WHILE (B4+1.LE.B3)  *DO UP TO 4 ERRORS                        D44009J
   GOTO 60                                                               D44009J
56 GOTO 55 WHILE (B5+1.LT.470)  *COMPARE 470 WORDS                       D44009J
60 IF(B10.EQ.3) GOSUB 74     *POST MODULE 41 MESSAGE
   EXIT TO 98B               *GO PROCESS STATUS 
*                                                                        D44009J
*---------POST STATUS SUBROUTINE                                         D44009J
*                                                                        D44009J
70 MSG 11, 8D WORDS FROM SB(B3) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 12, 8D WORDS FROM SB(B3+10) TO LINE B4                            D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 13, 4 WORDS FROM SB(B3+20) TO LINE B4                             D44009J
   B4 = B4 + 1                                                           D44009J
   RETURN                                                                D44009J
74 IF(ES.AND.TM.EQ.0) B4 = B4 + 1   *IF KL DISPLAY
   MSG 24 TO LINE B4         *MODULE 41 MESSAGE 
   B4 = B4 + 1
   RETURN 
   END 30                                                                D44009J
COMPILE   - D4498A -                                                     D44009J
   MODULE D4498B,844HT(2,3,4,5)LOCK  -STATUS ANALYSIS                    D44009J
 1 FORMAT SC100- COUPLER IS RESERVED TO OPPOSITE ACCESS 
 2 FORMAT SC101- DSU IS RESERVED TO OPPOSITE ACCESS 
 3 FORMAT SC300- DSU IS NOT ON-LINE 
 4 FORMAT SC301- DSU IS NOT SELECTED
 5 FORMAT SC302- DSU POWER SUPPLY TEMPERATURE IS ABNORMAL 
 6 FORMAT SC303- DSU LOGIC TEMPERATURE IS ABNORMAL
 7 FORMAT SC304- DSU POSITIVE VOLTAGE IS ABNORMAL 
10 FORMAT SC305- DSU NEGATIVE VOLTAGE IS ABNORMAL 
11 FORMAT SC306- DSU DOES NOT HAVE A DISK PACK MOUNTED
12 FORMAT SC307- DSU SECTOR BLOCK IS NOT IN POSITION (LID)
13 FORMAT SC308- DSU START SWITCH IS NOT ON 
14 FORMAT SC309- DSU SPINDLE MOTOR IS NOT ON
15 FORMAT SC310- DSU BRUSH CYCLE IS STILL IN PROGRESS 
16 FORMAT SC311- DSU HEADS ARE NOT LOADED BUT PACK IS SAFE
17 FORMAT SC312- DSU HEADS UNLOADED DUE TO PACK UNSAFE
20 FORMAT SC313- DSU SEEK ERROR BUT IT IS ON CYLINDER 
21 FORMAT SC314- DSU SEEK ERROR AND NOT ON CYLINDER 
22 FORMAT SC315- DSU WRITE AND READ ATTEMPTED AT SAME TIME
23 FORMAT SC102- DSC CHANNEL PARITY ERROR 
24 FORMAT SC201- DSC DETECTED ILLEGAL COMMAND/PARAMETER 
25 FORMAT SC321- DSU INTERLOCK PROBLEM
26 FORMAT SC322- DSU IS BUSY
27 FORMAT SC323- DSU HUNG BUSY ON A SEEK TO CYLINDER *OCT 
31 FORMAT --------------------------------------------------             D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
40 B3 = 0                    *SET TO ANALYZE LAST STATUS                 D44009J
   IF(SB(52).EQ.0) GOTO 41   *IF NO RECOVERY                             D44009J
   B3 = 25                   *ANALYZE FIRST TAKEN STATUS                 D44009J
41 IF(SB(B3).AND.BIT10.NE.0) ERROR 1/0, GOTO 70    *COUPLER              D44009J
   IF(SB(B3).AND.BIT3.NE.0) ERROR 2/0, GOTO 70     *DSU RES.             D44009J
   IF(SB(B3+4).AND.BIT10.NE.0) GOTO 62   *IF FMD
   IF(SB(B3+3).AND.144.EQ.144) GOTO 64   *IF WRITE VERIFY ERROR 
   GOTO 63
62 IF(SB(B3+3).AND.140.NE.140) GOTO 63   *IF NOT WRITE VERIFY ERROR 
   IF(SB(B3+16D).AND.BIT0.NE.0) GOTO 64     *IF WRITE VERIFY ERROR
63 IF(SB(B3).AND.BIT11.NE.0) GOTO 42        *ABNORMAL 
   IF(EC.AND.77.EQ.27) ERROR 27/0, GOTO 70  *BUSY ON SEEK 
   IF(SB(B3).AND.BIT1.NE.0) ERROR 26/0, GOTO 70    *BUSY                 D44009J
   B3 = 7777                 *TERMINATION VALUE                          D44009J
64 EXIT TO 98D               *PROCESS ERRORS
42 IF(SB(B3+4).AND.BIT10.EQ.0) GOTO 43             *NOT FMD 
   IF(SB(B3+3).AND.BIT3.NE.0)ERROR 24/0,GOTO 70    *COMMAND 
   IF(SB(B3+3).AND.BIT2.NE.0)ERROR 24/0,GOTO 70    *PARAM 
   GOTO 44
43 IF(SB(B3+3).AND.BIT0.NE.0)ERROR 23/0,GOTO 70    *PARITY
   IF(SB(B3+7).AND.BIT11.NE.0)ERROR 24/0,GOTO 70    *COMMAND             D44009J
44 IF(SB(B3+9D).AND.BIT6.EQ.0)ERROR 3/0,GOTO 70    *OFFLINE 
   IF(SB(B3+9D).AND.BIT8.EQ.0) ERROR 4/0, GOTO 70   *SELECT              D44009J
   IF(SB(B3+9D).AND.BIT5.EQ.0) GOTO 45   *SINGLE DENSITY
   IF(SB(B3+11D).AND.BIT11.EQ.0)ERROR 6/0,GOTO 70  *TEMP
   GOTO 46
45 IF(SB(B3+11D).AND.BIT11.EQ.0)ERROR 5/0,GOTO 70  *TEMP
   IF(SB(B3+10D).AND.BIT0.EQ.0) ERROR 6/0, GOTO 70   *TEMP.              D44009J
46 IF(SB(B3+10D).AND.BIT5.NE.0)ERROR 7/0,GOTO 70   *+V
   IF(SB(B3+10D).AND.BIT6.NE.0) ERROR 10/0, GOTO 70  *-V                 D44009J
   IF(SB(B3+11D).AND.BIT4.EQ.0)ERROR 11/0, GOTO 70   *PACK               D44009J
   IF(SB(B3+11D).AND.BIT5.NE.0) GOTO 47  *BLOCK OK
   IF(SB(B3+9D).AND.BIT5.EQ.0)ERROR 12/0,GOTO 70   *BLOCK 
   ERROR 25/0,GOTO 70     *DOUBLE DENSITY INTERLOCK PROBLEM 
47 IF(SB(B3+11D).AND.BIT8.EQ.0)ERROR 13/0,GOTO 70  *START 
   IF(SB(B3+11D).AND.BIT10.EQ.0)ERROR 14/0, GOTO 70  *SPIN               D44009J
   IF(SB(B3+11D).AND.BIT7.NE.0)ERROR 15/0, GOTO 70   *BRUSH              D44009J
   IF(SB(B3+11D).AND.BIT6.NE.0) GOTO 50            *LOADED
   IF(SB(B3+10D).AND.BIT9.EQ.0)ERROR 16/0, GOTO 70   *SAFE               D44009J
   ERROR 17/0, GOTO 70                               *UNSAFE             D44009J
50 IF(SB(B3+10D).AND.BIT7.NE.0) GOTO 51      *SEEK ERROR
   IF(SB(B3+10D).AND.BIT10.EQ.0)GOTO 52      *NO SEEK ERROR 
51 IF(SB(B3+10D).AND.BIT11.NE.0)ERROR 20/0,GOTO 70  *SEEK 
   ERROR 21/0, GOTO 70     *SEEK ERROR AND NOT ON CYLINDER               D44009J
52 IF(SB(B3+10D).AND.BIT3.NE.0)ERROR 22/0,GOTO 70  *WR/RD 
   EXIT TO 98C             *CONTINUE STATUS ANALYSIS                     D44009J
*                                                                        D44009J
70 MSG EM (B7) TO LINE B4                                                D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498B -                                                     D44009J
   MODULE D4498C,844HT(2,3,4,5) LOCK   - STATUS ANALYSIS                 D44009J
 1 FORMAT SC316- DSU CURRENT FAULT
 2 FORMAT SC317- DSU DATA TRANSFER WHILE NOT ON CYLINDER
 3 FORMAT SC318- DSU DISK PACK IS UNSAFE
 4 FORMAT SC319- DSU NOT READY
 5 FORMAT SC320- DSU MALFUNCTION BUT NO CAUSE DETERMINED
 6 FORMAT SC200- DSC MEMORY PARITY ERROR
 7 FORMAT SC202- DSC DEADMAN TIMER EXPIRED
10 FORMAT SC203- DSC DETECTED HARDWARE ERROR
11 FORMAT SC230- DSC LOST DSU CLOCK 
12 FORMAT SC231- DSC PROCESSOR TIMEOUT
13 FORMAT SC232- DSC BUFFER MEMORY PARITY ERROR 
14 FORMAT SC233- DSC DETECTED DATA PARITY ERROR 
15 FORMAT SC204- TRACK FLAW 
16 FORMAT SC205- SECTOR FLAW
17 FORMAT SC206- ADDRESS SYNC ERROR 
20 FORMAT SC207- CORRECTABLE ADDRESS CHECKWORD ERROR
21 FORMAT SC208- UNCORRECTABLE ADDRESS CHECKWORD ERROR
22 FORMAT SC209- ADDRESS COMPARE ERROR - INCORRECT CYLINDER 
23 FORMAT SC210- ADDRESS COMPARE ERROR - INCORRECT TRACK
24 FORMAT SC211- ADDRESS COMPARE ERROR - INCORRECT SECTOR 
25 FORMAT SC212- ADDRESS COMPARE ERROR - CAUSE NOT DEFINED
26 FORMAT SC213- DATA SYNC ERROR
31 FORMAT --------------------------------------------------             D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
40 IF(SB(B3+10D).AND.BIT4.NE.0)ERROR 1/0,GOTO 70    *CURRENT
   IF(SB(B3+10D).AND.BIT2.NE.0)ERROR 2/0,GOTO 70    *XFER 
   IF(SB(B3+10D).AND.BIT9.NE.0)ERROR 3/0,GOTO 70    *UNSAFE 
   IF(SB(B3+9D).AND.BIT7.EQ.0) ERROR 4/0,GOTO 70    *NOT RDY
   IF(SB(B3).AND.BIT4.NE.0)ERROR 5/0,GOTO 70  *MALFUNCTION
   IF(SB(B3+4).AND.BIT10.NE.0)GOTO 41    *FMD CONTROLLER
   IF(SB(B3+7).AND.BIT7.NE.0) ERROR 6/0,GOTO 70  *MEM PE
   IF(SB(B3+7).AND.BIT1.NE.0) ERROR 7/0,GOTO 70  *DEADMAN 
   IF(SB(B3+7).AND.BIT6.NE.0)ERROR 10/0,GOTO 70  *HARDWARE
   IF(SB(B3+6).AND.BIT3.NE.0)ERROR 15/0,GOTO 70  *TRACK 
   IF(SB(B3+6).AND.BIT4.NE.0)ERROR 16/0,GOTO 70  *SECTOR
   IF(SB(B3+7).AND.BIT8.NE.0)ERROR 17/0,GOTO 70  *SYNC
   GOTO 42
41 IF(SB(B3+17D).AND.BIT3.NE.0)ERROR 7/0,GOTO 70  *DEADMAN
   IF(SB(B3+16D).AND.BIT11.NE.0)ERROR 11/0,GOTO 70  *CLOCK
   IF(SB(B3+16D).AND.BIT5.NE.0)ERROR 12/0,GOTO 70  *TIMEOUT 
   IF(SB(B3+16D).AND.BIT1.NE.0)ERROR 13/0,GOTO 70  *BFR PE
   IF(SB(B3+16D).AND.BIT6.NE.0)ERROR 14/0,GOTO 70  *DATA PE 
   IF(SB(B3+6).AND.BIT3.NE.0)ERROR 15/0,GOTO 70  *TRACK 
   IF(SB(B3+6).AND.BIT4.NE.0)ERROR 16/0,GOTO 70  *SECTOR
   IF(SB(B3+17D).AND.BIT8.EQ.0) GOTO 42  *NO SYNC ERROR 
   IF(SB(B3+17D).AND.BIT0.NE.0)ERROR 17/0,GOTO 70  *SYNC
42 IF(SB(B3+2).AND.BIT11.EQ.0) GOTO 43    *NO ADDR CKWD ERR 
   IF(SB(B3+2).AND.BIT10.EQ.0)ERROR 20/0,GOTO 70   *CORR
   ERROR 21/0,GOTO 70    *UNCORRECTABLE ADDRESS CKWD ERROR
43 IF(SB(B3+1).AND.BIT3.EQ.0)GOTO 44  *NO ADDR COMPARE ERR
   IF(SB(B3+1).AND.BIT2.NE.0)ERROR 22/0,GOTO 70  *CYLINDER
   IF(SB(B3+1).AND.BIT1.NE.0)ERROR 23/0,GOTO 70  *TRACK 
   IF(SB(B3+1).AND.BIT0.NE.0)ERROR 24/0,GOTO 70  *SECTOR
   ERROR 25/0,GOTO 70    *UNDEFINED ADDR COMPARE ERROR
44 IF(SB(B3+4).AND.BIT10.EQ.0)GOTO 45  *NOT FMD CONTROLLER
   IF(SB(B3+17D).AND.BIT8.EQ.0)GOTO 46  *NO FMD DATA SYNC 
   IF(SB(B3+17D).AND.BIT1.EQ.0)GOTO 46  *NO DATA FIELD ERR
   ERROR 26/0,GOTO 70    *FMD CONTROLLER DATA SYNC ERROR
45 IF(SB(B3+7).AND.BIT2.NE.0)ERROR 26/0,GOTO 70  *DATA SYNC 
46 EXIT TO 98D           *CONTINUE STATUS ANALYSIS
70 MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498C -                                                     D44009J
   MODULE D4498D,844HT(2,3,4,5)LOCK   - STATUS ANALYSIS                  D44009J
 1 FORMAT SC214- CORRECTABLE DATA CHECKWORD ERROR 
 2 FORMAT SC215- UNCORRECTABLE DATA CHECKWORD ERROR 
 3 FORMAT SC216- LOST DATA
 4 FORMAT SC217- SECTOR LENGTH ERROR (SEE WT REGISTER)
 5 FORMAT SC218- WRITE ERROR
 6 FORMAT SC103- WRITE VERIFY FAILURE 
 7 FORMAT SC104- ADDRESS OR DATA FIELD COMPARE ERROR
10 FORMAT SC105- ABNORMAL TERMINATION, NO CAUSE DETECTED
26 FORMAT TYPE GO TO CONTINUE                                            D44009J
27 FORMAT IB(*OCT) - IB(*OCT) IS BELOW                                   D44009J
30 FORMAT      *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT                   D44009J
31 FORMAT --------------------------------------------------             D44009J
*                                                                        D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
*                                                                        D44009J
40 IF(B3.EQ.7777) GOTO 71    *IF TESTING COMPLETE                        D44009J
   IF(SB(B3+2).AND.BIT9.EQ.0) GOTO 41   *NO DATA CHECKWORD               D44009J
   IF(SB(B3+2).AND.BIT8.EQ.0) ERROR 1/0, GOTO 70  *CORR.                 D44009J
   ERROR 2/0, GOTO 70        *UNCORRECTABLE DATA CHECKWORD               D44009J
41 IF(SB(B3+4).AND.BIT10.NE.0) GOTO 42  *FMD CONTROLLER 
   IF(SB(B3+7).AND.BIT9.NE.0)ERROR 3/0,GOTO 70    *LOST DATA
   IF(SB(B3+7).AND.BIT10.NE.0)ERROR 4/0, GOTO 70  *LENGTH                D44009J
   IF(SB(B3+10D).AND.BIT1.NE.0)ERROR 5/0,GOTO 70  *WRITE
   IF(SB(B3+3).AND.BIT2.NE.0) ERROR 6/0, GOTO 70  *VERIFY                D44009J
   IF(SB(B3+3).AND.BIT3.NE.0) ERROR 7/0, GOTO 70  *COMPARE               D44009J
   ERROR 10/0, GOTO 70       *UNEXPLAINED ABNORMAL                       D44009J
42 IF(SB(B3+17D).AND.BIT9.NE.0)ERROR 3/0,GOTO 70  *LOST DATA
   IF(SB(B3+17D).AND.BIT10.NE.0)ERROR 4/0,GOTO 70  *LENGTH
   IF(SB(B3+10D).AND.BIT1.NE.0)ERROR 5/0,GOTO 70  *WRITE
   IF(SB(B3+16D).AND.BIT0.NE.0)ERROR 6/0,GOTO 70  *VERIFY 
   ERROR 10/0,GOTO 70   *UNEXPLAINED ABNORMAL 
*                                                                        D44009J
70 MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
71 MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   IF(B1.AND.7.NE.1) GOTO 77    *IF NOT COMPARE ERROR                    D44009J
   IF(P4.AND.BIT1.EQ.0)GOTO 77  *IF NO FULL BUFFER DUMP                  D44009J
   B2 = 0                       *BUFFER INDEX                            D44009J
   B3 = 77                      *LAST WORD OF BUFFER                     D44009J
   B4 = 0                       *LINE NUMBER                             D44009J
72 MSG 27(B2,B3) TO LINE B4                                              D44009J
   B4 = B4 + 1                                                           D44009J
73 MSG 30, 8D WORDS FROM IB(B2) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   GOTO 73 WHILE (B2+10.LT.B3)  *DO 64D WORDS (8 LINES)                  D44009J
   GOTO 72 WHILE (B3+100.LT.400)  *DO 400B WORDS                         D44009J
   PICTURE                                                               D44009J
   IF(ES.AND.TM.NE.0) GOTO 74   *IF TERMINAL MODE                        D44009J
   MSG 26 TO DISPLAY                                                     D44009J
   PAUSE                                                                 D44009J
74 BLANK                                                                 D44009J
   B3 = 501                     *LAST WORD OF BUFFER                     D44009J
   B4 = 0                       *LINE NUMBER                             D44009J
   MSG 27(B2,B3) TO LINE B4                                              D44009J
   B4 = B4 + 1                                                           D44009J
75 MSG 30, 8D WORDS FROM IB(B2) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   GOTO 75 WHILE (B2+10.LT.500)                                          D44009J
   MSG 30, 2 WORDS FROM IB(B2) TO LINE B4                                D44009J
   PICTURE                                                               D44009J
   IF(ES.AND.TM.NE.0) GOTO 76   *IF TERMINAL MODE                        D44009J
   MSG 26 TO DISPLAY                                                     D44009J
   PAUSE                                                                 D44009J
76 BLANK                                                                 D44009J
77 B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498D -                                                     D44009J
   MODULE D4498F,844FT(2,3,4,5)LOCK   - STATUS ANALYSIS                  D44009J
 1 FORMAT D44 ERROR IN MODULE *DEC AT LINE *OCT                          D44009J
 2 FORMAT  WT=*OCT  LF=*OCT  RETRIES=*OCT  ERRORS=*OCT                   D44009J
 3 FORMAT  OB(0-7)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 4 FORMAT  IB(0-7)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 5 FORMAT  B0 - B7  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
 6 FORMAT  CYL=*OCT TRK=*OCT SEC=*OCT  LAST SEEK=*DEC MSEC               D44009J
 7 FORMAT    SUCCESSFUL RECOVERY - FIRST GENERAL STATUS=*OCT             D44009J
10 FORMAT    UNSUCCESSFUL RECOVERY-FIRST GENERAL STATUS=*OCT             D44009J
11 FORMAT  DS(1-8)  =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
12 FORMAT  DS(9-16) =*OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT             D44009J
13 FORMAT  DS(17-20)=*OCT *OCT *OCT *OCT                                 D44009J
14 FORMAT  DATA ERROR CORRECTION ADDR=*OCT 1ST=*OCT 2ND=*OCT             D44009J
15 FORMAT    LAST GENERAL STATUS = *OCT                                  D44009J
16 FORMAT  HUNG BUFFER CONTROLLER RESTARTED BY ITSELF                    D44009J
17 FORMAT  HUNG BUFFER CONTROLLER COULD NOT BE RESTARTED                 D44009J
20 FORMAT  HUNG BUFFER CONTROLLER SUCCESSFULLY RESTARTED                 D44009J
21 FORMAT D44 ERROR IN MODULE *DEC SUB *DEC AT LINE *OCT                 D44009J
22 FORMAT            // DATA COMPARE ERROR //                            D44009J
23 FORMAT  WORD=*OCT  EXPECTED=*OCT  ACTUAL=*OCT  DIFF=*OCT              D44009J
30 B3 = B3 + 1               *BUMP ERROR COUNTER                         D44009J
   IB(502) = B1.RS.3         *SAVE MODULE NUMBER                         D44009J
   IB(503) = B2              *SAVE REGISTERS                             D44009J
   IB(504) = B3                                                          D44009J
   OB(502) = B4                                                          D44009J
   IF(IB(502).LT.100) GOTO 31  *IF NO SUBMOUDLE                          D44009J
   B4 = IB(502).AND.7          *ISOLATE SUBMODULE NUMBER                 D44009J
   IB(502) = IB(502).RS.3      *CORRECT MODULE NUMBER                    D44009J
   IF(B4.EQ.0) GOTO 31         *IF SUBMODULE = 0 (NONE)                  D44009J
   MSG 21 (IB(502),B4,EA) TO LINE 0                                      D44009J
   GOTO 32                                                               D44009J
31 MSG 1(IB(502),EA) TO LINE 0     *REPORT MODULE NUMBER                 D44009J
32 B4 = 2                          *SET LINE NUMBER                      D44009J
   IB(502) = B5                    *SAVE B5                              D44009J
   IF(EC.LT.4000) GOTO 33          *IF NO P.O. ERROR                     D44009J
   MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
33 MSG 2(WT,LF,SB(52),B3) TO LINE B4                                     D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 3, 8D WORDS FROM OB TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 4, 8D WORDS FROM IB TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 5 (B0,B1,B2,B3,OB(502),B5,B6,B7) TO LINE B4                       D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 6 (B7,B6,B5,SB(60)) TO LINE B4                                    D44009J
   B4 = B4 + 1                                                           D44009J
   IF(B1.AND.7.EQ.3) GOTO 40       *IF BC IS HUNG                        D44009J
   IF(SB.NE.7777) GOTO 47          *IF BC IS RESPONDING                  D44009J
40 RES CONTROLLER, ABT 41          *TRY TO RESERVE                       D44009J
41 STATUS DETAIL, ABT 42           *ATTEMPT TO GET STATUS                D44009J
42 IF(SB(4).NE.7777) GOTO 44       *IF BC IS RUNNING AGAIN               D44009J
   RESET, ABT 43                   *ATTEMPT TO AUTOLOAD                  D44009J
   STATUS DETAIL, ABT 43           *ATTEMPT TO GET STATUS                D44009J
   IF(SB(4).NE.7777) GOTO 45       *IF BC WAS RE-STARTED OK              D44009J
43 MSG 17 TO LINE B4               *REPORT UNABLE TO RESTART             D44009J
   GOTO 46                                                               D44009J
44 MSG 16 TO LINE B4               *REPORT RUNNING BY ITSELF             D44009J
   GOTO 46                                                               D44009J
45 MSG 20 TO LINE B4               *REPORT RE-STARTED OK                 D44009J
46 B4 = B4 + 1                                                           D44009J
   MSG 15 (SB) TO LINE B4                                                D44009J
   B4 = B4 + 1                                                           D44009J
   B3 = 7777                       *TERMINATION VALUE TO B3              D44009J
   EXIT TO 98I                                                           D44009J
47 B4 = B4 + 1                                                           D44009J
   IF(SB(52).EQ.0) GOTO 52         *IF NO RECOVERY                       D44009J
   IF(SB.EQ.0) GOTO 50             *IF SUCCESSFUL RECOVERY               D44009J
   MSG 10 (SB(25)) TO LINE B4      *FIRST GENERAL STATUS                 D44009J
   GOTO 51                                                               D44009J
50 MSG 7 (SB(25)) TO LINE B4                                             D44009J
51 B4 = B4 + 1                                                           D44009J
   B3 = 26                                                               D44009J
   GOSUB 70                        *POST FIRST DETAIL STATUS             D44009J
   B4 = B4 + 1                                                           D44009J
52 MSG 15 (SB) TO LINE B4          *LAST GENERAL STATUS                  D44009J
   B4 = B4 + 1                                                           D44009J
   IF(SB.EQ.0) GOTO 53             *IF NO DETAIL STATUS                  D44009J
   B3 = 1                                                                D44009J
   GOSUB 70                        *POST LAST DETAIL STATUS              D44009J
   B3 = SB(13).AND.777B      *MASK THE PP ADDRESS 
   B3 = B3.OR.SB(14).OR.SB(15)
   IF(B3.EQ.0) GOTO 53             *IF NO CORRECTION DATA                D44009J
   B3 = SB(13).AND.777B 
   MSG 14 (B3,SB(14),SB(15)) TO LINE B4   *POST CORRECTION VECTORS
   B4 = B4 + 1                                                           D44009J
53 IF(B1.AND.7.NE.1) GOTO 60   *IF NOT COMPARE ERROR                     D44009J
   B5 = 470                  *WORD COUNT FOR COMPARE                     D44009J
   COMPARE IB TO OB FOR B5, ABT 54                                       D44009J
   GOTO 60                   *IF COMPARE IS OK                           D44009J
54 MSG 22 TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
   B3 = B4 + 4               *LINE TERMINATION VALUE                     D44009J
55 B2 = IB(B5).XOR.OB(B5)    *LOGICAL DIFFERENCE                         D44009J
   IF(B2.EQ.0) GOTO 56       *IF WORDS COMPARE                           D44009J
   MSG 22(B5,IB(B5),OB(B5),B2) TO LINE B4                                D44009J
   GOTO 56 WHILE (B4+1.LE.B3)  *DO UP TO 4 ERRORS                        D44009J
   GOTO 60                                                               D44009J
56 GOTO 55 WHILE (B5+1.LT.470)  *COMPARE 470 WORDS                       D44009J
60 EXIT TO 98G                  *GO PROCESS STATUS                       D44009J
*                                                                        D44009J
*---------POST STATUS SUBROUTINE                                         D44009J
*                                                                        D44009J
70 MSG 11, 8D WORDS FROM SB(B3) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 12, 8D WORDS FROM SB(B3+10) TO LINE B4                            D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 13, 4 WORDS FROM SB(B3+20) TO LINE B4                             D44009J
   B4 = B4 + 1                                                           D44009J
   RETURN                                                                D44009J
   END 30                                                                D44009J
COMPILE   - D4498F -                                                     D44009J
   MODULE D4498G,844FT(2,3,4,5)LOCK  -STATUS ANALYSIS                    D44009J
 1 FORMAT SC100- COUPLER IS RESERVED TO OPPOSITE ACCESS 
 2 FORMAT SC101- DSU IS RESERVED TO OPPOSITE ACCESS 
 3 FORMAT SC300- DSU IS NOT ON-LINE 
 4 FORMAT SC301- DSU IS NOT SELECTED
 5 FORMAT SC302- DSU POWER SUPPLY TEMPERATURE IS ABNORMAL 
 6 FORMAT SC303- DSU LOGIC TEMPERATURE IS ABNORMAL
 7 FORMAT SC304- DSU POSITIVE VOLTAGE IS ABNORMAL 
10 FORMAT SC305- DSU NEGATIVE VOLTAGE IS ABNORMAL 
11 FORMAT SC306- DSU DOES NOT HAVE A DISK PACK MOUNTED
12 FORMAT SC307- DSU SECTOR BLOCK IS NOT IN POSITION (LID)
13 FORMAT SC308- DSU START SWITCH IS NOT ON 
14 FORMAT SC309- DSU SPINDLE MOTOR IS NOT ON
15 FORMAT SC310- DSU BRUSH CYCLE IS STILL IN PROGRESS 
16 FORMAT SC311- DSU HEADS ARE NOT LOADED BUT PACK IS SAFE
17 FORMAT SC312- DSU HEADS UNLOADED DUE TO PACK UNSAFE
20 FORMAT SC313- DSU SEEK ERROR BUT IT IS ON CYLINDER 
21 FORMAT SC314- DSU SEEK ERROR AND NOT ON CYLINDER 
22 FORMAT SC315- DSU WRITE AND READ ATTEMPTED AT SAME TIME
23 FORMAT SC102- DSC CHANNEL PARITY ERROR 
24 FORMAT SC201- DSC DETECTED ILLEGAL COMMAND/PARAMETER 
25 FORMAT SC321- DSU INTERLOCK PROBLEM
26 FORMAT SC322- DSU IS BUSY
27 FORMAT SC323- DSU HUNG BUSY ON A SEEK TO CYLINDER *OCT 
31 FORMAT --------------------------------------------------             D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
40 B3 = 0                    *SET TO ANALYZE LAST STATUS                 D44009J
   IF(SB(52).EQ.0) GOTO 41   *IF NO RECOVERY                             D44009J
   B3 = 25                   *ANALYZE FIRST TAKEN STATUS                 D44009J
41 IF(SB(B3).AND.BIT10.NE.0) ERROR 1/0, GOTO 70    *COUPLER              D44009J
   IF(SB(B3).AND.BIT3.NE.0) ERROR 2/0, GOTO 70     *DSU RES.             D44009J
   IF(SB(B3+4).AND.BIT10.NE.0) GOTO 62   *IF FMD
   IF(SB(B3+3).AND.144.EQ.144) GOTO 64   *IF WRITE VERIFY ERROR 
   GOTO 63
62 IF(SB(B3+3).AND.140.NE.140) GOTO 64   *IF NOT WRITE VERIFY ERROR 
   IF(SB(B3+16D).AND.BIT0.NE.0) GOTO 64     *IF WRITE VERIFY ERROR
63 IF(SB(B3).AND.BIT11.NE.0) GOTO 42        *ABNORMAL 
   IF(EC.AND.77.EQ.27) ERROR 27/0, GOTO 70  *BUSY ON SEEK 
   IF(SB(B3).AND.BIT1.NE.0) ERROR 26/0, GOTO 70    *BUSY                 D44009J
   B3 = 7777                 *TERMINATION VALUE                          D44009J
64 EXIT TO 98I               *PROCESS ERRORS
42 IF(SB(B3+4).AND.BIT10.EQ.0) GOTO 43             *NOT FMD 
   IF(SB(B3+3).AND.BIT3.NE.0)ERROR 24/0,GOTO 70    *COMMAND 
   IF(SB(B3+3).AND.BIT2.NE.0)ERROR 24/0,GOTO 70    *PARAM 
   GOTO 44
43 IF(SB(B3+3).AND.BIT0.NE.0)ERROR 23/0,GOTO 70    *PARITY
   IF(SB(B3+7).AND.BIT11.NE.0)ERROR 24/0, GOTO 70   *COMMAND             D44009J
44 IF(SB(B3+9D).AND.BIT6.EQ.0)ERROR 3/0,GOTO 70    *OFFLINE 
   IF(SB(B3+9D).AND.BIT8.EQ.0) ERROR 4/0, GOTO 70   *SELECT              D44009J
   IF(SB(B3+9D).AND.BIT5.EQ.0) GOTO 45   *SINGLE DENSITY
   IF(SB(B3+11D).AND.BIT11.EQ.0)ERROR 6/0,GOTO 70  *TEMP
   GOTO 46
45 IF(SB(B3+11D).AND.BIT11.EQ.0)ERROR 5/0,GOTO 70  *TEMP
   IF(SB(B3+10D).AND.BIT0.EQ.0) ERROR 6/0, GOTO 70   *TEMP.              D44009J
46 IF(SB(B3+10D).AND.BIT5.NE.0)ERROR 7/0,GOTO 70   *+V
   IF(SB(B3+10D).AND.BIT6.NE.0) ERROR 10/0, GOTO 70  *-V                 D44009J
   IF(SB(B3+11D).AND.BIT4.EQ.0)ERROR 11/0, GOTO 70   *PACK               D44009J
   IF(SB(B3+11D).AND.BIT5.NE.0) GOTO 47  *BLOCK OK
   IF(SB(B3+9D).AND.BIT5.EQ.0)ERROR 12/0,GOTO 70   *BLOCK 
   ERROR 25/0,GOTO 70     *DOUBLE DENSITY INTERLOCK PROBLEM 
47 IF(SB(B3+11D).AND.BIT8.EQ.0)ERROR 13/0,GOTO 70  *START 
   IF(SB(B3+11D).AND.BIT10.EQ.0)ERROR 14/0, GOTO 70  *SPIN               D44009J
   IF(SB(B3+11D).AND.BIT7.NE.0)ERROR 15/0, GOTO 70   *BRUSH              D44009J
   IF(SB(B3+11D).AND.BIT6.NE.0) GOTO 50            *LOADED
   IF(SB(B3+10D).AND.BIT9.EQ.0)ERROR 16/0, GOTO 70   *SAFE               D44009J
   ERROR 17/0, GOTO 70                               *UNSAFE             D44009J
50 IF(SB(B3+10D).AND.BIT7.NE.0) GOTO 51      *SEEK ERROR
   IF(SB(B3+10D).AND.BIT10.EQ.0)GOTO 52      *NO SEEK ERROR 
51 IF(SB(B3+10D).AND.BIT11.NE.0)ERROR 20/0,GOTO 70  *SEEK 
   ERROR 21/0, GOTO 70     *SEEK ERROR AND NOT ON CYLINDER               D44009J
52 IF(SB(B3+10D).AND.BIT3.NE.0)ERROR 22/0,GOTO 70  *WR/RD 
   EXIT TO 98H             *CONTINUE STATUS ANALYSIS                     D44009J
*                                                                        D44009J
70 MSG EM (B7) TO LINE B4                                                D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498G -                                                     D44009J
   MODULE D4498H,844FT(2,3,4,5) LOCK   - STATUS ANALYSIS                 D44009J
 1 FORMAT SC316- DSU CURRENT FAULT
 2 FORMAT SC317- DSU DATA TRANSFER WHILE NOT ON CYLINDER
 3 FORMAT SC318- DSU DISK PACK IS UNSAFE
 4 FORMAT SC319- DSU NOT READY
 5 FORMAT SC320- DSU MALFUNCTION BUT NO CAUSE DETERMINED
 6 FORMAT SC200- DSC MEMORY PARITY ERROR
 7 FORMAT SC202- DSC DEADMAN TIMER EXPIRED
10 FORMAT SC203- DSC DETECTED HARDWARE ERROR
11 FORMAT SC230- DSC LOST DSU CLOCK 
12 FORMAT SC231- DSC PROCESSOR TIMEOUT
13 FORMAT SC232- DSC BUFFER MEMORY PARITY ERROR 
14 FORMAT SC233- DSC DETECTED DATA PARITY ERROR 
15 FORMAT SC204- TRACK FLAW 
16 FORMAT SC205- SECTOR FLAW
17 FORMAT SC206- ADDRESS SYNC ERROR 
20 FORMAT SC207- CORRECTABLE ADDRESS CHECKWORD ERROR
21 FORMAT SC208- UNCORRECTABLE ADDRESS CHECKWORD ERROR
22 FORMAT SC209- ADDRESS COMPARE ERROR - INCORRECT CYLINDER 
23 FORMAT SC210- ADDRESS COMPARE ERROR - INCORRECT TRACK
24 FORMAT SC211- ADDRESS COMPARE ERROR - INCORRECT SECTOR 
25 FORMAT SC212- ADDRESS COMPARE ERROR - CAUSE NOT DEFINED
26 FORMAT SC213- DATA SYNC ERROR
31 FORMAT --------------------------------------------------             D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
40 IF(SB(B3+10D).AND.BIT4.NE.0)ERROR 1/0,GOTO 70    *CURRENT
   IF(SB(B3+10D).AND.BIT2.NE.0)ERROR 2/0,GOTO 70    *XFER 
   IF(SB(B3+10D).AND.BIT9.NE.0)ERROR 3/0,GOTO 70    *UNSAFE 
   IF(SB(B3+9D).AND.BIT7.EQ.0) ERROR 4/0,GOTO 70    *NOT RDY
   IF(SB(B3).AND.BIT4.NE.0)ERROR 5/0,GOTO 70  *MALFUNCTION
   IF(SB(B3+4).AND.BIT10.NE.0)GOTO 41    *FMD CONTROLLER
   IF(SB(B3+7).AND.BIT7.NE.0) ERROR 6/0,GOTO 70  *MEM PE
   IF(SB(B3+7).AND.BIT1.NE.0) ERROR 7/0,GOTO 70  *DEADMAN 
   IF(SB(B3+7).AND.BIT6.NE.0)ERROR 10/0,GOTO 70  *HARDWARE
   IF(SB(B3+6).AND.BIT3.NE.0)ERROR 15/0,GOTO 70  *TRACK 
   IF(SB(B3+6).AND.BIT4.NE.0)ERROR 16/0,GOTO 70  *SECTOR
   IF(SB(B3+7).AND.BIT8.NE.0)ERROR 17/0,GOTO 70  *SYNC
   GOTO 42
41 IF(SB(B3+17D).AND.BIT3.NE.0)ERROR 7/0,GOTO 70  *DEADMAN
   IF(SB(B3+16D).AND.BIT11.NE.0)ERROR 11/0,GOTO 70  *CLOCK
   IF(SB(B3+16D).AND.BIT5.NE.0)ERROR 12/0,GOTO 70  *TIMEOUT 
   IF(SB(B3+16D).AND.BIT1.NE.0)ERROR 13/0,GOTO 70  *BFR PE
   IF(SB(B3+16D).AND.BIT6.NE.0)ERROR 14/0,GOTO 70  *DATA PE 
   IF(SB(B3+6).AND.BIT3.NE.0)ERROR 15/0,GOTO 70  *TRACK 
   IF(SB(B3+6).AND.BIT4.NE.0)ERROR 16/0,GOTO 70  *SECTOR
   IF(SB(B3+17D).AND.BIT8.EQ.0) GOTO 42  *NO SYNC ERROR 
   IF(SB(B3+17D).AND.BIT0.NE.0)ERROR 17/0,GOTO 70  *SYNC
42 IF(SB(B3+2).AND.BIT11.EQ.0) GOTO 43    *NO ADDR CKWD ERR 
   IF(SB(B3+2).AND.BIT10.EQ.0)ERROR 20/0,GOTO 70   *CORR
   ERROR 21/0,GOTO 70    *UNCORRECTABLE ADDRESS CKWD ERROR
43 IF(SB(B3+1).AND.BIT3.EQ.0)GOTO 44  *NO ADDR COMPARE ERR
   IF(SB(B3+1).AND.BIT2.NE.0)ERROR 22/0,GOTO 70  *CYLINDER
   IF(SB(B3+1).AND.BIT1.NE.0)ERROR 23/0,GOTO 70  *TRACK 
   IF(SB(B3+1).AND.BIT0.NE.0)ERROR 24/0,GOTO 70  *SECTOR
   ERROR 25/0,GOTO 70    *UNDEFINED ADDR COMPARE ERROR
44 IF(SB(B3+4).AND.BIT10.EQ.0)GOTO 45  *NOT FMD CONTROLLER
   IF(SB(B3+17D).AND.BIT8.EQ.0)GOTO 46  *NO FMD DATA SYNC 
   IF(SB(B3+17D).AND.BIT1.EQ.0)GOTO 46  *NO DATA FIELD ERR
   ERROR 26/0,GOTO 70    *FMD CONTROLLER DATA SYNC ERROR
45 IF(SB(B3+7).AND.BIT2.NE.0)ERROR 26/0,GOTO 70  *DATA SYNC 
46 EXIT TO 98I           *CONTINUE STATUS ANALYSIS
70 MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
   MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498H -                                                     D44009J
   MODULE D4498I,844FT(2,3,4,5)LOCK   - STATUS ANALYSIS                  D44009J
 1 FORMAT SC214- CORRECTABLE DATA CHECKWORD ERROR 
 2 FORMAT SC215- UNCORRECTABLE DATA CHECKWORD ERROR 
 3 FORMAT SC216- LOST DATA
 4 FORMAT SC217- SECTOR LENGTH ERROR (SEE WT REGISTER)
 5 FORMAT SC218- WRITE ERROR
 6 FORMAT SC103- WRITE VERIFY ERROR (NEXT MSG TRUE DISK ADD)
 7 FORMAT SC104- ADDRESS OR DATA FIELD COMPARE ERROR
10 FORMAT SC105- ABNORMAL TERMINATION, NO CAUSE DETECTED
11 FORMAT WRITE VERIFY DISK ADD CYL=*OCT TRK=*OCT SEC=*OCT               D44013J
26 FORMAT TYPE GO TO CONTINUE                                            D44009J
27 FORMAT IB(*OCT) - IB(*OCT) IS BELOW                                   D44009J
30 FORMAT      *OCT *OCT *OCT *OCT *OCT *OCT *OCT *OCT                   D44009J
31 FORMAT --------------------------------------------------             D44009J
*                                                                        D44009J
   EQUATE BIT0 TO 1, BIT1 TO 2, BIT2 TO 4, BIT3 TO 10                    D44009J
   EQUATE BIT4 TO 20, BIT5 TO 40, BIT6 TO 100, BIT7 TO 200               D44009J
   EQUATE BIT8 TO 400, BIT9 TO 1000, BIT10 TO 2000                       D44009J
   EQUATE BIT11 TO 4000                                                  D44009J
*                                                                        D44009J
40 IF(B3.EQ.7777) GOTO 71    *IF TESTING COMPLETE                        D44009J
   IF(SB(B3+2).AND.BIT9.EQ.0) GOTO 41   *NO DATA CHECKWORD               D44009J
   IF(SB(B3+2).AND.BIT8.EQ.0) ERROR 1/0, GOTO 70  *CORR.                 D44009J
   ERROR 2/0, GOTO 70        *UNCORRECTABLE DATA CHECKWORD               D44009J
41 IF(SB(B3+4).AND.BIT10.NE.0) GOTO 42  *FMD CONTROLLER 
   IF(SB(B3+7).AND.BIT9.NE.0)ERROR 3/0,GOTO 70    *LOST DATA
   IF(SB(B3+7).AND.BIT10.NE.0)ERROR 4/0, GOTO 70  *LENGTH                D44009J
   IF(SB(B3+10D).AND.BIT1.NE.0)ERROR 5/0,GOTO 70  *WRITE
   IF(SB(B3+3).AND.BIT2.NE.0) ERROR 6/0, GOTO 70  *VERIFY                D44009J
   IF(SB(B3+3).AND.BIT3.NE.0) ERROR 7/0, GOTO 70  *COMPARE               D44009J
   ERROR 10/0, GOTO 70       *UNEXPLAINED ABNORMAL                       D44009J
42 IF(SB(B3+17D).AND.BIT9.NE.0)ERROR 3/0,GOTO 70  *LOST DATA
   IF(SB(B3+17D).AND.BIT10.NE.0)ERROR 4/0,GOTO 70  *LENGTH
   IF(SB(B3+10D).AND.BIT1.NE.0)ERROR 5/0,GOTO 70  *WRITE
   IF(SB(B3+16D).AND.BIT0.NE.0)ERROR 6/0,GOTO 70  *VERIFY 
   ERROR 10/0,GOTO 70   *UNEXPLAINED ABNORMAL 
*                                                                        D44009J
70 MSG EM TO LINE B4                                                     D44009J
   B4 = B4 + 1                                                           D44009J
   IF(EM.NE.6) GOTO 71                                                   D44013J
   B9 = SB(B3+5) RS 3                                                    D44013J
   B10 = SB(B3+6) AND 1 LS 9D                                            D44013J
   B9 = B9 + B10                                                         D44013J
   B10 = SB(B3+5) AND 7 LS 2                                             D44013J
   B11 = SB(B3+6) RS 10D                                                 D44013J
   B10 = B10 + B11                                                       D44013J
   B11 = SB(B3+6) AND 1740 RS 5                                          D44013J
   MSG 11(B9,B10,B11) TO LINE B4                                         D44013J
   B4 = B4 + 1                                                           D44013J
   IB(502) = B11                                                         D44013J
   B6 = B10                                                              D44013J
71 MSG 31 TO LINE B4                                                     D44009J
   PICTURE                                                               D44009J
   HALT                                                                  D44009J
   BLANK                                                                 D44009J
   IF(B1.AND.7.NE.1) GOTO 77    *IF NOT COMPARE ERROR                    D44009J
   IF(P4.AND.BIT1.EQ.0)GOTO 77  *IF NO FULL BUFFER DUMP                  D44009J
   B2 = 0                       *BUFFER INDEX                            D44009J
   B3 = 77                      *LAST WORD OF BUFFER                     D44009J
   B4 = 0                       *LINE NUMBER                             D44009J
72 MSG 27(B2,B3) TO LINE B4                                              D44009J
   B4 = B4 + 1                                                           D44009J
73 MSG 30, 8D WORDS FROM IB(B2) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   GOTO 73 WHILE (B2+10.LT.B3)  *DO 64D WORDS (8 LINES)                  D44009J
   GOTO 72 WHILE (B3+100.LT.400)  *DO 400B WORDS                         D44009J
   PICTURE                                                               D44009J
   IF(ES.AND.TM.NE.0) GOTO 74   *IF TERMINAL MODE                        D44009J
   MSG 26 TO DISPLAY                                                     D44009J
   PAUSE                                                                 D44009J
74 BLANK                                                                 D44009J
   B3 = 501                     *LAST WORD OF BUFFER                     D44009J
   B4 = 0                       *LINE NUMBER                             D44009J
   MSG 27(B2,B3) TO LINE B4                                              D44009J
   B4 = B4 + 1                                                           D44009J
75 MSG 30, 8D WORDS FROM IB(B2) TO LINE B4                               D44009J
   B4 = B4 + 1                                                           D44009J
   GOTO 75 WHILE (B2+10.LT.500)                                          D44009J
   MSG 30, 2 WORDS FROM IB(B2) TO LINE B4                                D44009J
   PICTURE                                                               D44009J
   IF(ES.AND.TM.NE.0) GOTO 76   *IF TERMINAL MODE                        D44009J
   MSG 26 TO DISPLAY                                                     D44009J
   PAUSE                                                                 D44009J
76 BLANK                                                                 D44009J
77 B2 = IB(503)              *RESTORE REGISTERS                          D44009J
   B3 = IB(504)                                                          D44009J
   B4 = OB(502)                                                          D44009J
   B5 = IB(502)                                                          D44009J
   EXIT                                                                  D44009J
   END 40                                                                D44009J
COMPILE   - D4498I -                                                     D44009J
   MODULE D4499,844HT(02,03,04,05),LOCK 
/ 
/   PARAMETER DESCRIPTION.
/ 
/        P0 = LOWER CYLINDER  (RIGHT JUSTIFIED, ZERO FILLED)
/ 
/        P1 = UPPER CYLINDER  (RIGHT JUSTIFIED, ZERO FILLED)
/ 
/        P2 = (LLUU)   LL = LOWER/ UPPER TRACKS 
/ 
/        P3 = (LLUU)   LL = LOWER/ UPPER SECTORS
/ 
/        P4 = ENABLES 
/           BITS  0 - REPORT FLAWS
/                 1 - FULL INPUT BUFFER DUMP ON COMPARE 
/                     ERRORS. 
/                 2 - COMPARE DATA   (MODULES 30 THRU 32) 
/                                    (MODULES 37 AND 38)
/                 3 - CHANGE PATTERN ON TRACK BOUNDARIES. 
/                 4 - CHANGE PATTERN ON CYLINDER BOUNDARIES.
/                    *IF NEITHER TRACK OR CYLINDER
/                     BOUNDARIES ARE SET, THE PATTERN CHANGE
/                     WILL DEFAULT TO DISK BOUNDARIES 
/ 
/        P5 = DISABLES
/           BITS  0 - ADDRESS CODING
/                 1 - READ
/                 2 - WRITE 
/                 3 - RANDOM DATA IN BUFFER 
/                 4 - RESET COMMAND 
/ 
/        P6 = DATA CONTROL
/          (ZERO - AND RANDOM DATA SET (BIT 3 CLEAR IN P5)
/                  THE RANDOM START KEY WORD WILL COME FROM 
/                  THE REAL TIME CLOCK. 
/          (NON-ZERO) - AND RANDOM DATA SET (BIT 3 CLEAR IN 
/                       P5) THE RANDOM START WILL USE THIS
/                       DATA CONTROL WORD AS THE KEY START
/                       WORD. 
/          (NON-ZERO) - AND RANDOM DATA DISABLED (BIT 3 SET 
/                       IN P5) THE BUFFER WILL BE FILLED
/                       WITH THIS FIXED DATA CONTROL WORD.
/ 
/ 
/        P7 = (00XY) MARGINS
/ 
/                   Y = STROBES         X = OFFSETS 
/                  NORMAL  000X        NORMAL  00Y0 
/                  EARLY   001X        FORWARD 00Y1 
/                  LATE    002X        REVERSE 00Y2 
/ 
/        P8 = ITERATION COUNT 
/          (ITERATION COUNT TIMES 4096 IF RANDOM COUNT) 
/ 
20 PAUSE
   EXIT TO 99A                                                           D44010J
   END 20 
COMPILE,SOURCE
   MODULE D4499A,844HT(02,03,04,05),LOCK  - MODULES                      D44010J
/                                                                        D44010J
/  PART 1 - CONFIDENCE TEST                                              D44010J
/                                                                        D44010J
/    D4400 - CONNECT CONTROLLER TEST                                     D44010J
/    D4401 - GENERAL STATUS TEST                                         D44010J
/    D4402 - DETAIL STATUS TEST                                          D44010J
/    D4403 - DIAGNOSTIC READ, WRITE/READ TEST                            D44010J
/    D4404 - FIXED CYLINDER SEEK TEST                                    D44010J
/    D4405 - READ FLAW MAPS                                              D44010J
/    D4406 - READ INNERMOST CYLINDER                                     D44010J
/    D4407 - READ COUPLER BUFFER (7154 ONLY)                             D44010J
/    D4408 - WRITE FIRST 2 PREALLOCATED CYLINDERS                        D44010J
/    D4409 - READ FIRST 2 PREALLOCATED CYLINDERS                         D44010J
/    D4410 - ERROR CORRECTION TEST                                       D44010J
/    D4411 - WRITE VERIFY TEST                                           D44010J
/    D4412 - READ CHECKWORD TEST                                         D44010J
/    D4413 - CHECK MARGINS TEST (STROBES AND OFFSETS)                    D44010J
/    D4414 - RANDOM SEEKS TEST                                           D44010J
/    D4415 - WRITE CODED CYLINDER TEST                                   D44010J
/    D4416 - READ CODED CYLINDER TEST                                    D44010J
/                                                                        D44010J
/  PART 2 - PARAMETER DRIVEN MODULES                                     D44010J
/                                                                        D44010J
/ 
/                         ********* 
/                         *CAUTION* 
/                         ********* 
/ 
/    IN PARAMETER DRIVEN MODULES WITH AN ACCESS LEVEL OF
/    4, DATA CAN BE DESTROYED ANYWHERE ON THE PACK. IT IS 
/    ADVISABLE NOT TO SWAP PACKS WHILE RUNNING THE
/    DIAGNOSTIC.
/ 
/ 
/    D4417 - READ CHECKWORD, TRACK MODE 1/1 
/    D4430 - SEQUENTIAL WRITE/READ, TRACK MODE 2/1                       D44010J
/    D4431 - SEQUENTIAL WRITE/READ, CYLINDER MODE 2/1                    D44010J
/    D4432 - SEQUENTIAL WRITE/READ, TRACK MODE 1/1                       D44010J
/    D4433 - SEQUENTIAL WRITE/READ, CYLINDER MODE 1/1                    D44010J
/    D4434 - RANDOM WRITE/READ ONE CYL, TRK, SECTOR                      D44010J
/    D4435 - SURFACE TEST, TRACK MODE, 2/1                               D44010J
/    D4436 - SURFACE TEST, CYLINDER MODE, 1/1                            D44010J
/    D4437 - HEAD TEST, TRACK GROUPS, 2/1                                D44010J
/    D4438 - HEAD TEST, TRACK GROUPS, 1/1                                D44010J
/                                                                        D44010J
/  PART 3 - REPAIR MODULES (SCOPE LOOPS)                                 D44010J
/                                                                        D44010J
/ 
/                         ********* 
/                         *CAUTION* 
/                         ********* 
/ 
/    IN PARAMETER DRIVEN MODULES WITH AN ACCESS LEVEL OF
/    4, DATA CAN BE DESTROYED ANYWHERE ON THE PACK. IT IS 
/    ADVISABLE NOT TO SWAP PACKS WHILE RUNNING THE
/    DIAGNOSTIC.
/ 
/ 
/    D4440 - RESTART BUFFER CONTROLLER (SHORT AUTOLOAD)                  D44010J
/    D4441 - WRITE PROGRAM FOR MODULE 06                                 D44010J
/    D4442 - SEEK DISK ADDRESS                                           D44010J
/    D4443 - SEEK AND WRITE ONE SECTOR                                   D44010J
/    D4444 - SEEK AND READ ONE SECTOR                                    D44010J
/    D4445 - SEEK, WRITE AND READ ONE SECTOR                             D44010J
/    D4446 - TOGGLE TEST - READ ONE SECTOR, THEN ANOTHER                 D44010J
/    D4447 - DEADMAN TIMER TEST                                          D44010J
/    D4448 - READ AND PRINT FLAW MAPS 
/    D4450 - COARSE POSITION PLOT 
/    D4451 - VELOCITY GAIN TIMING PLOT
/    D4452 - INTEGRATOR GAIN ADJUSTMENT 
/    D4453 - FINE POSITION PLOT 
/                                                                        D44010J
/ 
20 PAUSE
   END 20 
COMPILE,SOURCE
