*DECK,CRE                                                                CRE
   MODULE,CRE00,3000(20),LOCK   CARD READER EXERCISER                    VER1058
*** CRE - 405 CARD READER REPAIR EXERCISER                               CRE
**                                                                       CRE
*                                                                        CRE
*   AUTHOR - J.E. SIPPER                                                 CRE
*            CONSULTANT - SOUTHEAST REGION                               CRE
*            ENGINEERING SERVICES                                        CRE
*                                                                        CRE
*   DATE   - 78/10/23                                                    CRE
*                                                                        CRE
*   OVERVIEW -                                                           CRE
*                                                                        CRE
*         CRE IS A 405 CARD READER EXERCISER THAT RUNS UNDER THE         CRE
*         MALET SOFTWARE SUBSYSTEM.  IT IS DESIGNED TO TEST ONE          CRE
*         CARD READER/CONTROLLER AT A TIME.  AN ACCESS LEVEL OF 10       VER1062
*         MUST BE SPECIFIED ON THE MALET ASSIGN DIRECTIVE IN ORDER       VER1062
*         TO EXECUTE CRE SINCE IT IS WRITTEN IN THE LOW-LEVEL MALET      VER1062
*         LANGUAGE.                                                      VER1062
*                                                                        CRE
*         THE GOAL IS TO INTRODUCE THE FIELD CUSTOMER ENGINEER TO        CRE
*         THE USE OF A SOFTWARE PRODUCT TO BE USED IN PLACE OF A         CRE
*         HARDWARE BLACK-BOX EXERCISER.  THIS TECHNIQUE IS CURRENTLY     CRE
*         PLANNED FOR FUTURE PERIPHERALS.                                CRE
*                                                                        CRE
*         CRE IS DESIGNED TO DRIVE A 405 CARD READER SUCH THAT           CRE
*         SCOPING, ADJUSTMENTS, SHOCK TESTING, ETC. CAN BE               CRE
*         PERFORMED WHILE IT IS EXECUTING TO ASSIST IN THE REPAIR        CRE
*         OF A FAILING READER OR CONTROLLER.  THIS MODULE PERFORMS       CRE
*         READING AND DATA COMPARES BASED ON PARAMETERS PROVIDED         CRE
*         IN MALET PARAMETER REGISTERS P0 - P9.                          CRE
*                                                                        CRE
*         VIA PARAMETER REGISTERS, THE USER CONTROLS THE SPEED OF        CRE
*         READING AND THE NUMBER OF CARDS TO READ.  IF DATA COMPARE      CRE
*         IS ENABLED, THE USER MUST DEFINE THE EXPECTED DATA             CRE
*         PATTERN.  CARD SEQUENCE NUMBER CHECKING CAN ALSO BE            CRE
*         ENABLED TO VERIFY THAT CARDS ARE NOT BEING LOST OR             CRE
*         SHUFFLED. (CARDS TO BE READ CAN BE PREPARED USING THE          CRE
*         CARD PUNCH EXERCISER, CPE).                                    CRE
*                                                                        CRE
*         A TYPICAL APPLICATION OF CRE IS TO SCOPE A FAILING DATA        CRE
*         BIT PROBLEM WHERE NO COMPARE ERROR EXISTS BUT THE DATA         CRE
*         READ IS INCORRECT.                                             CRE
*                                                                        CRE
*** CRE PARAMETERS                                                       CRE
**                                                                       CRE
*   PARAMETERS -                                                         CRE
*                                                                        CRE
*         DATA IN PARAMETER REGISTERS P0-P9 CONTROL THE ACTIONS          CRE
*         PERFORMED BY CRE AS FOLLOWS:                                   CRE
*                                                                        CRE
*         P0/P1 - THE USE OF P0 AND P1 DEPENDS UPON THE SETTING OF       CRE
*              BIT 0 OF P9.  IF THIS BIT IS A ZERO, THE CONTENTS         CRE
*              OF P0 WILL BE USED AS A RANDOM STARTER IN GENERATING      CRE
*              THE EXPECTED CARD IMAGE FOR COMPARING WITH DATA           CRE
*              ACTUALLY READ BY THE READER.  P1 WILL BE USED AS          CRE
*              A MASK TO THE RANDOM STARTER SO THAT THE USER CAN         CRE
*              ELIMINATE DATA WITHIN CERTAIN ROWS ON THE CARD IMAGE.     CRE
*              IF (P1) IS ZERO, THERE IS NO MASK.  IF (P0) IS ZERO,      CRE
*              EACH CARD CONTAINS A NEW RANDOM PATTERN WITH THE          CRE
*              STARTER CONTAINED WITHIN THE DATA READ BY THE READER      CRE
*              IN THE COLUMN SPECIFIED BY REGISTER P2 (FIRST COLUMN).    CRE
*                                                                        CRE
*              IF BIT 0 OF P9 IS A ONE, P0 AND P1 BECOME FIXED DATA      CRE
*              BYTES THAT ARE TO BE USED ALTERNATELY IN FORMING THE      CRE
*              EXPECTED CARD IMAGE FOR DATA COMPARES.                    CRE
*                                                                        CRE
*              THE USER SHOULD NOTE THAT THE CONTENTS OF PARAMETER       CRE
*              REGISTERS P0-P4 ARE IGNORED IF DATA COMPARE IS NOT        CRE
*              SELECTED.                                                 CRE
*                                                                        CRE
*         P2 - THE FIRST COLUMN TO START DATA CONSTRUCTION IN            CRE
*              WHEN BUILDING EXPECTED CARD IMAGE FOR DATA                CRE
*              COMPARES (1-80 DECIMAL). IF THE VALUE SPECIFIED           CRE
*              IN P2 IS ZERO OR GREATER THAN 80 DECIMAL, IT              CRE
*              DEFAULTS TO 1.                                            CRE
*                                                                        CRE
*              NOTE:  IT IS ILLEGAL TO SPECIFY A STARTING COLUMN OF      CRE
*                     80 IF CARD SEQUENCE NUMBERS ARE SELECTED IN P9     CRE
*                     SINCE SEQUENCE NUMBERS ARE PUNCHED IN COLUMN 80.   CRE
*                                                                        CRE
*         P3 - LAST COLUMN TO STORE DATA WHEN BUILDING EXPECTED          CRE
*              CARD IMAGE FOR DATA COMPARES (1-80 DECIMAL). IF           CRE
*              THE VALUE SPECIFIED IN P3 IS ZERO OR GREATER THAN         CRE
*              80, IT DEFAULTS TO 80.  NOTE THAT THE (P3) CAN BE         CRE
*              SMALLER THAN THE (P2).  IF THIS IS THE CASE, DATA         CRE
*              STARTS IN COLUMN P2 TO THE END OF THE CARD, THEN          CRE
*              FROM COLUMN 1 TO AND INCLUDING COLUMN P3.                 CRE
*                                                                        CRE
*         P4 - NUMBER OF BLANKS TO INSERT AFTER EACH COLUMN THAT         CRE
*              CONTAINS DATA WHEN BUILDING THE EXPECTED CARD IMAGE       CRE
*              (0-80 DECIMAL). IF THE VALUE IS ZERO OR GREATER THAN      CRE
*              80, NO BLANKS ARE INSERTED.  EXAMPLE:  IF (P4) IS 1,      CRE
*              EVERY-OTHER COLUMN BETWEEN P2 AND P3 WILL CONTAIN DATA    CRE
*              WITH BLANKS IN ALL OTHER COLUMNS.                         CRE
*                                                                        CRE
*         P5 - NOT USED                                                  CRE
***                                                                      CRE
**                                                                       CRE
*                                                                        CRE
*         P6 - MILLISECONDS TO DELAY AFTER EACH CARD READ.  IF P9 BIT    CRE
*              1 = 0, (P6) IS A FIXED DELAY.  IF P9 BIT 1 = 1, (P6)      CRE
*              IS A MASK TO USE WITH THE REAL TIME CLOCK TO ESTABLISH    CRE
*              A RANDOM DELAY BETWEEN READS.  (THE MAXIMUM DELAY IS      CRE
*              7777 OCTAL/4095 DECIMAL MILLISECONDS OR 4.095 SECONDS.    CRE
*                                                                        CRE
*         P7/P8 - NUMBER OF CARDS TO READ BEFORE TERMINATING.  BOTH      CRE
*              REGISTERS DEFAULT TO 0000 WHICH MEANS THAT 77777777       CRE
*              CARDS WILL BE READ BEFORE NORMAL TERMINATION.  P8 IS      CRE
*              THE LOWER 12 BITS OF THE COUNTER.                         CRE
*                                                                        CRE
*         P9 - CONTROL BITS FOR OPTIONS (DEFAULTS TO 0000)               CRE
*                                                                        CRE
*              BIT 0 (XXX1) - 0= GENERATE RANDOM DATA BASED ON THE       CRE
*                                CONTENTS OF P0-P4.                      CRE
*                             1= GENERATE FIXED DATA USING P0-P4.        CRE
*                                                                        CRE
*              BIT 1 (XXX2) - 0= (P6) IS A FIXED DELAY                   CRE
*                             1= (P6) IS A MASK FOR RANDOM DELAY         CRE
*                                                                        CRE
*              BITS 2-7     - NOT USED                                   CRE
*                                                                        CRE
*              BIT 8 (X4XX) - 0= CARD SEQUENCE NUMBERS ARE NOT IN        CRE
*                                COLUMN 80 OF CARDS BEING READ.          CRE
*                             1= CARD SEQUENCE NUMBERS ARE IN COLUMN     CRE
*                                80 OF CARDS BEING READ.                 CRE
*                                                                        CRE
*              BIT 9 (1XXX) - 0= DO NOT IGNORE COLUMN 80 WHEN COMPARING  CRE
*                                DATA.                                   CRE
*                             1= IGNORE COLUMN 80 WHEN COMPARING DATA.   CRE
*                                                                        CRE
*              BIT 10(2XXX) - 0= COMPARE DATA READ WITH EXPECTED IMAGE.  CRE
*                             1= DO NOT COMPARE DATA.                    CRE
*                                                                        CRE
*              BIT 11(4XXX) - 0= USE ONE-WORD-AT-A-TIME COMMAND FOR      CRE
*                                READING CARDS TO INSURE NO CHANNEL      CRE
*                                HANG OCCURS (IN COMMAND).               CRE
*                             1= USE HIGH SPEED INPUT COMMAND FOR        VER1059
*                                READING CARDS (INB COMMAND).            CRE
*                                                                        CRE
*** CRE DESCRIPTION                                                      CRE
**                                                                       CRE
*   DESCRIPTION -                                                        CRE
*                                                                        CRE
*         1. IF DATA COMPARE IS NOT SELECTED (P9 BIT 10=1) GO TO         CRE
*            STEP 3.                                                     CRE
*         2. GENERATE EXPECTED DATA PATTERN BASED ON (P0) - (P4) AND     CRE
*            P9 BIT 0 (RANDOM/FIXED DATA).                               CRE
*         3. BUILD STATUS DISPLAY.                                       CRE
*         4. POST WAIT RDY/NOT BUSY MESSAGE.                             CRE
*         5. CONNECT, GET STATUS AND GO TO STEP 7 IF READY/NOT BUSY.     CRE
*         6. RELEASE, REPORT CURRENT STATUS, DELAY 50 MSEC AND GO TO     CRE
*            STEP 5.                                                     CRE
*         7. POST READING CARDS MESSAGE.                                 CRE
*         8. CONNECT, GET STATUS AND GO TO STEP 10 IF NOT BUSY.          CRE
*         9. DELAY 1 MSEC AND GO TO STEP 8 IF 1 SECOND HAS NOT ELAPSED.  CRE
*            OTHERWISE, GO TO STEP 23 TO REPORT HUNG BUSY ERROR.         CRE
*        10. IF READER IS NOT READY, GO TO STEP 22 TO REPORT REASON.     CRE
*        11. SELECT BINARY (FUNC 1).                                     CRE
*        12. PERFORM A SLOW-SPEED INPUT (IN COMMAND) OF 80 WORDS IF      CRE
*            P9 BIT 11 = 0, OR A HIGH-SPEED INPUT (INB COMMAND) IF       CRE
*            P9 BIT 11 = 1.                                              CRE
*        13. BUMP EXPECTED SEQUENCE NUMBER IN CASE CARD SEQUENCE         CRE
*            NUMBERS ARE IN COLUMN 80.                                   CRE
*        14. RELEASE.                                                    CRE
*        15. BUMP NUMBER OF CARDS READ.                                  CRE
*        16. IF WORDS TRANSMITTED (WT) IS NOT 80, GO TO STEP 23 TO       CRE
*            REPORT WT ERROR.                                            CRE
*        17. IF STATUS INDICATE A COMPARE ERROR AND THERE IS NO DATA     CRE
*            COMPARE SELECTED (P9 BIT 10 = 1), GO TO STEP 23 TO REPORT   CRE
*            COMPARE ERROR - DATA NOT TESTED ERROR.                      CRE
*        18. VERIFY THAT COLUMN 80 CONTAINS THE CORRECT SEQUENCE NUMBER  CRE
*            IF SEQUENCE NUMBERS ARE SELECTED (P9 BIT 8 = 1) AND ARE     CRE
*            NOT TO BE IGNORED (P9 BIT 9 = 0).  IF IN ERROR, GO TO STEP  CRE
*            23 TO REPORT EXPECTED AND ACTUAL SEQUENCE NUMBERS.          CRE
*                                                                        CRE
*            NOTE: IF THERE IS AN ERROR, THE EXPECTED SEQUENCE NUMBER    CRE
*                  IS RESET TO ACTUAL TO TRY AND GET BACK INTO PROPER    CRE
*                  SYNC.  NO ERROR IS REPORTED IF THE SEQUENCE NUMBER    CRE
*                  READ FROM COLUMN 80 IS 0001 SINCE IT IS ASSUMED       CRE
*                  THAT THE USER HAS STARTED READING THE SAME GROUP OF   CRE
*                  CARDS AGAIN.                                          CRE
*                                                                        CRE
*        19. COMPARE DATA READ WITH EXPECTED IF SELECTED (P9 BIT 10      CRE
*            = 0). IF NOT, GO TO STEP 20.  IF RANDOM DATA IS SELECTED,   CRE
*            (P9 BIT 0 = 0), AND NO FIXED STARTER IS PROVIDED (P1=0),    CRE
*            THE EXPECTED PATTERN IS GENERATED USING THE DATA READ       CRE
*            FROM THE COLUMN SPECIFIED BY P2 (FIRST COLUMN) AS THE       CRE
*            RANDOM STARTER.  IF A DATA COMPARE ERROR IS DETECTED,       CRE
*            REPORT THE FIRST 3 COLUMNS THAT FAIL TO COMPARE (STARTING   CRE
*            AT COLUMN 1) AND GO TO STEP 23 TO REPORT THE ERROR.  ONE    CRE
*            OF TWO ERROR MESSAGES WILL BE REPORTED DEPENDING UPON THE   CRE
*            COMPARE ERROR STATUS FROM THE READER;  COMPARE ERROR AND    CRE
*            DATA ERROR OR NO COMPARE ERROR BUT DATA ERROR.              CRE
*                                                                        CRE
***                                                                      CRE
**                                                                       CRE
*        20. DELAY THE NUMBER OF MILLISECONDS SPECIFIED BY P6 AND P9     CRE
*            BIT 1 (FIXED OR RANDOM DELAY). A RELEASE IS PERFORMED IF    CRE
*            THE DELAY TIME EXCEEDS 20 MILLISECONDS.                     CRE
*                                                                        CRE
*        21. GO TO STEP 8 IF P7/P8 CARDS HAVE BEEN READ.  OTHERWISE,     CRE
*            UPDATE THE STATUS DISPLAY, TAKE A PICTURE OF THE FINAL      CRE
*            CONDITION OF COUNTERS AND EXIT.                             CRE
*                                                                        CRE
*        22. THIS STEP IS ENTERED WHEN THE READER DROPS READY.  IF       CRE
*            STATUS INDICATES TRAY EMPTY, GO TO STEP 23 TO REPORT        CRE
*            TRAY EMPTY.  IF STATUS INDICATES FAIL-TO-FEED, GO TO        CRE
*            STEP 23 TO REPORT FAIL-TO-FEED, JAM OR STACKER FULL.        CRE
*            OTHERWISE, GO TO STEP 23 TO REPORT READY DROP - NO CAUSE    CRE
*            DETECTED.                                                   CRE
*                                                                        CRE
*        23. THIS STEP IS ENTERED WHEN ANY ERROR IS DETECTED.  REPORT    CRE
*            THE ERROR MESSAGE, BUMP THE PROPER ERROR COUNTER AND        CRE
*            UPDATE THE STATUS DISPLAY.  IF STOP-ON-ERROR (SE) IS NOT    CRE
*            SELECTED, GO TO STEP 4.  OTHERWISE, TAKE A PICTURE OF THE   CRE
*            DISPLAY, HALT AND GO TO STEP 4 UPON OPERATOR GO.            CRE
*                                                                        CRE
*** CRE MESSAGES                                                         CRE
**                                                                       CRE
*   ERRORS REPORTED -                                                    CRE
*                                                                        CRE
*          1. ALL PRODUCT OVERLAY ERROR MESSAGES.                        CRE
*                                                                        CRE
*          2. P2=80 IS ILLEGAL WITH SEQUENCE NUMBERS SELECTED.           CRE
*          3. CRE - WAIT READER RDY/NOT BUSY.                            CRE
*          4. CRE - READER HUNG BUSY FOR 1 SECOND.                       CRE
*          5. CRE - READER DROPPED READY - NO CAUSE DETECTED.            CRE
*          6. CRE - COMPARE ERROR - DATA NOT TESTED.                     CRE
*          7. CRE - READER TRAY EMPTY.                                   CRE
*          8. CRE - READER FAIL-TO-FEED, JAM OR STACKER FULL.            CRE
*          9. CRE - READER COMPARE ERROR BUT DATA COMPARES.              CRE
*         10. CRE - NO COMPARE ERROR BUT DATA ERROR.                     CRE
*         11. CRE - COMPARE ERROR AND DATA ERROR.                        CRE
*         12. CRE - COMPARE ERROR BUT DATA OK.                           CRE
*         13. CRE - WT ERROR ON READ - EXP=0080  ACT=*DEC                CRE
*         14. CRE - SEQ. ERROR (COL.80) - EXP=*OCT  ACTUAL=*OCT          CRE
*                                                                        CRE
*         15. CRE - ABORT ON .CONN. COMMAND.                             CRE
*         16. CRE - ABORT ON .REL. COMMAND.                              CRE
*         17. CRE - ABORT ON .FUNC. COMMAND.                             CRE
*         18. CRE - ABORT ON .STATUS. COMMAND.                           CRE
*         19. CRE - ABORT ON .IN. COMMAND.                               CRE
*         20. CRE - ABORT ON .INB. COMMAND.                              CRE
*                                                                        CRE
*          IN ADDITION TO THE ABOVE ERROR MESSAGES, A DISPLAY IS         CRE
*          MAINTAINED IN THE FOLLOWING FORMAT TO DOCUMENT RUNNING        CRE
*          TOTALS OF ERRORS, STATUS AND OTHER STATISTICS.  ALL VALUES    CRE
*          ARE IN DECIMAL EXCEPT THE NUMBER OF CARDS READ, LAST ERROR    CRE
*          STATUS AND EXPECTED/ACTUAL DATA ARE DISPLAYED IN OCTAL.       CRE
*                                                                        CRE
*          CRE- OCTAL CARDS READ = XXXXXXXX                              CRE
*          CONN ABT-------XXXX   REL ABT--------XXXX                     CRE
*          FUNC ABT-------XXXX   STATUS ABT-----XXXX                     CRE
*          IN ABT---------XXXX   INB ABT--------XXXX                     CRE
*          READY DROPS----XXXX   HUNG BUSYS-----XXXX                     CRE
*          COMPARE ERRORS-XXXX   FEED,JAM,FULL--XXXX                     CRE
*          TRAY EMPTYS----XXXX   DATA ERRORS----XXXX                     VER1061
*          SEQUENCE ERRS--XXXX   CMPERR/DATA OK-XXXX                     CRE
*          WT ERRORS------XXXX                                           CRE
*          LAST ERR STS-668X=XXXX EQ=XXXX- LAST ERR BELOW                CRE
*                                                                        CRE
*          XXXXXXXXXX- ERROR MESSAGES -XXXXXXXXXXXXXXXXXX                CRE
*         --------------------------------------------------             VER1066
*                                                                        CRE
*** CRE - INTERNAL DOCUMENTATION                                         CRE
*                                                                        CRE
*   REGISTER USAGE -                                                     CRE
*                                                                        CRE
*         B0 = PRIMARY DATA BYTE                                         CRE
*            = BUFFER INDEX                                              CRE
*            = COLUMN COUNTER                                            CRE
*         B1 = ALTERNATE DATA BYTE                                       CRE
*            = BLANK COUNTER                                             CRE
*            = DATA COMPARE RESULT                                       CRE
*         B2 = STARTING/CURRENT COLUMN COUNTER                           CRE
*         B3 = LAST COLUMN                                               CRE
*         B4 = NUMBER OF BLANKS                                          CRE
*         B5 = BLANK COUNTER                                             CRE
*            = DATA MASK                                                 CRE
*            = ERROR COUNTER INDEX                                       CRE
*            = MESSAGE NUMBER                                            CRE
*            = BUFFER INDEX ON DATA COMPARES                             CRE
*         B6 = DATA STARTER                                              CRE
*            = BUFFER INDEX                                              CRE
*            = MESSAGE LINE NUMBER                                       CRE
*            = RETRY COUNTER                                             CRE
*            = CARDS READ COUNTER                                        CRE
*            = DELAY TIME                                                CRE
*            = MESSAGE NUMBER                                            CRE
*         B7 = CARD SEQUENCE NUMBER                                      CRE
*                                                                        CRE
*   BUFFER USAGE -                                                       CRE
*                                                                        CRE
*         IB(1-80)= CARD READ BUFFER                                     CRE
*         IB(200) = UPPER 12 BITS OF CARDS READ COUNTER                  CRE
*         IB(201) = LOWER 12 BITS OF CARDS READ COUNTER                  CRE
*         IB(202) = CONN ABT COUNTER                                     CRE
*         IB(203) = REL ABT COUNTER                                      CRE
*         IB(204) = FUNC ABT COUNTER                                     CRE
*         IB(205) = STATUS ABT COUNTER                                   CRE
*         IB(206) = IN ABT COUNTER                                       CRE
*         IB(207) = INB ABT COUNTER                                      CRE
*         IB(210) = READY DROPS COUNTER                                  CRE
*         IB(211) = HUNG BUSY COUNTER                                    CRE
*         IB(212) = COMPARE ERRORS COUNTER                               CRE
*         IB(213) = FEED,JAM,FULL COUNTER                                CRE
*         IB(214) = TRAY EMPTY COUNTER                                   CRE
*         IB(215) = DATA ERRORS COUNTER                                  CRE
*         IB(216) = SEQUENCE ERRORS COUNTER                              CRE
*         IB(217) = COMPARE ERRORS/DATA OK COUNTER                       CRE
*         IB(220) = WORDS TRANSMITTED ERROR COUNTER                      CRE
*                                                                        CRE
*   MODULES CALLED -                                                     VER1060
*                                                                        VER1060
*         CRE00A - PREPARE FOR MAIN LOOP                                 VER1060
*         CRE00B - MAIN LOOP                                             VER1060
*                                                                        VER1060
*                                                                        CRE
 1 FORMAT CRE - CARD READER EXERCISER                                    CRE
 2 FORMAT P0-P4 = *OCT  *OCT  *OCT  *OCT  *OCT                           CRE
 3 FORMAT P5-P9 = *OCT  *OCT  *OCT  *OCT  *OCT                           CRE
 4 FORMAT P2=80 IS ILLEGAL WITH SEQUENCE NUMBERS SELECTED                CRE
 5 FORMAT --------------------------------------------------             VER1066
20 MSG 1 TO DISPLAY                                                      CRE
   MSG 1 TO LINE 0                                                       CRE
   MSG 2 (P0,P1,P2,P3,P4) TO LINE 1                                      CRE
   MSG 3 (P5,P6,P7,P8,P9) TO LINE 2                                      CRE
   PICTURE AND BLANK                                                     CRE
   IF(P9.AND.2000.NE.0) GOTO 30  *EXIT IF NO DATA COMPARE                CRE
   B0 = P0                    *PRIMARY DATA BYTE                         CRE
   B1 = P1                    *ALTERNATE DATA BYTE                       CRE
   B2 = 1                     *DEFAULT STARTING COLUMN                   CRE
   IF(P2.EQ.0) GOTO 21        *IF NO STARTING COLUMN                     CRE
   IF(P2.GT.80D) GOTO 21      *IF COLUMN IS OUT OF RANGE                 CRE
   B2 = P2                    *USE USER SUPPLIED COLUMN                  CRE
21 B3 = 80D                   *DEFAULT LAST COLUMN                       CRE
   IF(P3.EQ.0) GOTO 22        *IF NO LAST COLUMN                         CRE
   IF(P3.GT.80D) GOTO 22      *IF COLUMN IS OUT OF RANGE                 CRE
   B3 = P3                    *USE USER SUPPLIED COLUMN                  CRE
22 B4 = 0                     *DEFAULT NUMBER OF BLANKS                  CRE
   IF(P4.EQ.0) GOTO 23        *IF NO BLANKS TO INSERT                    CRE
   IF(P4.GT.80D) GOTO 23      *IF OUT OF RANGE                           CRE
   B4 = P4                    *USE USER SUPPLIED VALUE                   CRE
23 IF(P9.AND.400.EQ.0) GOTO 24  *IF NO SEQUENCE NUMBERS                  CRE
   IF(B2.NE.80D) GOTO 24        *IF FIRST COLUMN IS LEGAL                CRE
   MSG 4 TO PRINT                                                        CRE
   GOTO 77                      *TERMINATE                               CRE
24 IF(P9.AND.1.EQ.0) GOTO 31  *IF RANDOM DATA IS SELECTED                CRE
25 OB(B2) = B0                *BUILD CARD IMAGE                          CRE
   B5 = B0                                                               CRE
   B0 = B1                                                               CRE
   B1 = B5                    *SWAP PRIMARY/ALTERNATE DATA               CRE
   B5 = 0                     *CLEAR BLANK COUNTER                       CRE
26 IF(B2.EQ.B3) GOTO 30       *IF CURRENT COLUMN = LAST                  CRE
   GOTO 27 WHILE (B2+1.LE.80D)  *IF NOT END OF CARD                      CRE
   B2 = 1                     *RESET CURRENT COLUMN TO 1                 CRE
27 GOTO 26 WHILE (B5+1.LE.B4)   *IF ALL BLANKS NOT INSERTED              CRE
   GOTO 25                    *CONTINUE STORING DATA                     CRE
30 B7 = 0                     *CLEAR PATTERN FLAG                        CRE
   MSG 5 TO LINE 12D                                                     VER1066
   EXIT TO 00A                *ENTER EXERCISER                           CRE
*                                                                        CRE
*---------RANDOM DATA IS SELECTED--------                                CRE
*                                                                        CRE
31 IF(P0.EQ.0) GOTO 30        *EXIT IF RANDOM DATA SELECTED              CRE
   B6 = P0                    *DATA STARTER                              CRE
   B5 = 7777                  *DEFAULT MASK                              CRE
   IF(P1.EQ.0) GOTO 32        *IF NO MASK PROVIDED                       CRE
   B5 = P1                                                               CRE
   B6 = P0.AND.P1             *USER SUPPLIED MASK                        CRE
32 RANDOM TO OB(200) FOR 80D, START B6                                   CRE
   B6 = 200                                                              CRE
33 OB(B2) = OB(B6).AND.B5                                                CRE
   B6 = B6 + 1                *BUMP INDEX TO DATA                        CRE
   B1 = 0                     *CLEAR BLANK COUNTER                       CRE
34 IF(B2.EQ.B3) GOTO 30       *EXIT IF CURRENT=LAST                      CRE
   GOTO 35 WHILE (B2+1.LE.80D)  *IF NOT END OF CARD                      CRE
   B2 = 1                     *RESET CURRENT COLUMN TO 1                 CRE
35 GOTO 34 WHILE (B1+1.LE.B4)  *IF ALL BLANKS NOT INSERTED               CRE
   GOTO 33                    *CONTINUE STORING DATA                     CRE
77 END 20                                                                CRE
COMPILE   - CRE00 -                                                      CRE
   MODULE,CRE00A,3000(20),LOCK                                           VER1058
 0 FORMAT CRE- NORMAL TERMINATION - FINAL COUNTS BELOW                   CRE
 1 FORMAT CRE- WAIT READER RDY/NOT BUSY                                  CRE
 2 FORMAT CRE- READER HUNG BUSY FOR 1 SECOND                             CRE
 3 FORMAT CRE- READER DROPPED READY - NO CAUSE DETECTED                  CRE
 4 FORMAT CRE- COMPARE ERROR - DATA NOT TESTED                           CRE
 5 FORMAT CRE- READER TRAY EMPTY                                         CRE
 6 FORMAT CRE- READER FAIL-TO-FEED, JAM OR STACKER FULL                  CRE
 7 FORMAT CRE- READER COMPARE ERROR BUT DATA COMPARES                    CRE
10 FORMAT CRE- ABORT ON .CONN. COMMAND                                   CRE
11 FORMAT CRE- OCTAL CARDS READ = *OCT*OCT                               CRE
12 FORMAT CONN ABT-------*DEC   REL ABT--------*DEC                      CRE
13 FORMAT FUNC ABT-------*DEC   STATUS ABT-----*DEC                      CRE
14 FORMAT IN ABT---------*DEC   INB ABT--------*DEC                      CRE
15 FORMAT READY DROPS----*DEC   HUNG BUSYS-----*DEC                      CRE
16 FORMAT COMPARE ERRORS-*DEC   FEED,JAM,FULL--*DEC                      CRE
17 FORMAT TRAY EMPTYS----*DEC   DATA ERRORS----*DEC                      CRE
20 FORMAT SEQUENCE ERRS--*DEC   CMPERR/DATA OK-*DEC                      CRE
21 FORMAT WT ERRORS------*DEC                                            CRE
22 FORMAT LAST ERR STS-668X=*OCT EQ=*OCT- LAST ERR BELOW                 CRE
23 FORMAT CRE- ABORT ON .STATUS. COMMAND                                 CRE
24 FORMAT CRE- ABORT ON .REL. COMMAND                                    CRE
25 FORMAT CRE- NO COMPARE ERROR BUT DATA ERROR                           CRE
26 FORMAT CRE- COMPARE ERROR AND DATA ERROR                              CRE
27 FORMAT CRE- COMPARE ERROR BUT DATA OK                                 CRE
*                                                                        CRE
*---------PREPARE FOR THE MAIN LOOP.  THIS CODE IS EXECUTED              CRE
*         INITIALLY AND EACH TIME A FAILURE IS DETECTED.                 CRE
*                                                                        CRE
30 GOSUB 60                        *BUILD STATUS DISPLAY                 CRE
31 B5 = 202                                                              VER1064
   CONN, ABT 64                                                          CRE
   B5 = 205                                                              CRE
   STATUS 1 WORDS TO SB(1), ABT 65                                       CRE
   IF(SB(1).AND.3.EQ.1) GOTO 33      *IF READY AND NOT BUSY              CRE
   B5 = 203                                                              CRE
   REL, ABT 66                       *RELEASE                            CRE
   MSG 1 TO DISPLAY                  *POST WAIT MESSAGE                  VER1064
   MSG 22, 2 WORDS FROM SB TO LINE 9D  *REPORT STATUS                    CRE
   DELAY 50D MSEC                                                        CRE
   GOTO 31                           *RETRY                              VER1064
*                                                                        CRE
*---------READER IS READY AND NOT BUSY, SO LETS GO                       CRE
*                                                                        CRE
33 CALL 00B                          *READ CARDS                         CRE
   GOTO 70                           *PROCESS THE EXIT                   CRE
*                                                                        CRE
*---------BUILD STATUS DISPLAY SUBROUTINE                                CRE
*                                                                        CRE
60 B6 = 0                            *LINE NUMBER                        CRE
   B5 = 11                           *MESSAGE NUMBER                     CRE
   B0 = 200                          *BUFFER INDEX                       CRE
61 MSG B5, 2 WORDS FROM IB(B0) TO LINE B6                                CRE
   B0 = B0 + 2                                                           CRE
   B5 = B5 + 1                                                           CRE
   GOTO 61 WHILE (B6+1.LE.8D)        *REPORT ALL COUNTERS                CRE
   MSG 22, 2 WORDS FROM SB TO LINE B6    *REPORT STATUS                  CRE
   RETURN                                                                CRE
*                                                                        CRE
*--------LOCAL ABORT PROCESSOR                                           CRE
*                                                                        CRE
64 MSG 10 TO LINE 10D                                                    CRE
   GOTO 74                                                               CRE
65 MSG 23 TO LINE 10D                                                    CRE
   GOTO 74                                                               CRE
66 MSG 24 TO LINE 10D                                                    CRE
   GOTO 74                                                               CRE
*                                                                        CRE
*---------ERROR PROCESSOR------------                                    CRE
*                                                                        CRE
70 IF(B5.EQ.0) GOTO 77               *IF ALL CARDS READ                  VER1072
   IF(EC.NE.210) GOTO 71             *IF NOT A READY ERROR               CRE
   IF(SB(1).AND.40.NE.0) ERROR 5/214, GOTO 71  *TRAY EMPTY               CRE
   IF(SB(1).AND.20.NE.0) ERROR 6/213, GOTO 71  *FEED FAIL                CRE
71 IF(EM.GT.77) GOTO 74              *IF COMMAND ABORT                   CRE
   B5 = EC                                                               CRE
   IF(B5.EQ.216) GOTO 75             *IF SEQUENCE ERROR                  CRE
   IF(B5.EQ.220) GOTO 75             *IF WT ERROR                        CRE
74 MSG EM TO LINE 11D                *REPORT ERROR                       CRE
   MSG EM TO DISPLAY                                                     VER1064
75 IB(B5) = IB(B5) + 1               *BUMP ERROR COUNTER                 CRE
   GOSUB 60                          *UPDATE STATUS DISPLAY              CRE
   IF(ES.AND.SE.EQ.0) GOTO 76       *IF NO STOP ON ERROR                 VER1072
   PICTURE                                                               CRE
   HALT                                                                  CRE
76 IF(IB(200).NE.P7) GOTO 31        *IF ALL CARDS NOT READ               VER1072
   IF(IB(201).NE.P8) GOTO 31        *IF ALL CARDS NOT READ               VER1072
77 GOSUB 60                         *UPDATE STATUS DISPLAY               VER1072
   MSG 0 TO PRINT                                                        CRE
   PICTURE                                                               CRE
   END 30                                                                CRE
COMPILE   - CRE00A -                                                     CRE
   MODULE,CRE00B,3000(20),LOCK                                           VER1058
 1 FORMAT                                                                CRE
 2 FORMAT CRE- ABORT ON .CONN. COMMAND                                   CRE
 3 FORMAT CRE- ABORT ON .REL. COMMAND                                    CRE
 4 FORMAT CRE- ABORT ON .FUNC. COMMAND                                   CRE
 5 FORMAT CRE- ABORT ON .STATUS. COMMAND                                 CRE
 6 FORMAT CRE- ABORT ON .IN. COMMAND                                     CRE
 7 FORMAT CRE- ABORT ON .INB. COMMAND                                    CRE
10 FORMAT CRE- WT ERROR ON READ - EXP=0080  ACT=*DEC                     CRE
11 FORMAT CRE- OCTAL CARDS READ = *OCT*OCT                               CRE
12 FORMAT CRE- READING CARDS                                             CRE
23 FORMAT LAST DATA ERR-COL=*DEC EXP=*OCT ACT=*OCT DIFF=*OCT             CRE
24 FORMAT CARD SEQ. ERROR (COL.80) - EXP=*OCT  ACTUAL=*OCT               CRE
*                                                                        CRE
*---------BEGIN MAIN LOOP TO READ CARDS                                  CRE
*                                                                        CRE
30 B6 = 0                            *CLEAR RETRY COUNTER                CRE
   MSG 12 TO DISPLAY                 *POST RUNNING MESSAGE               CRE
31 B5 = 202                                                              CRE
   CONN, ABT 70                                                          CRE
   B5 = 205                                                              CRE
   STATUS 1 WORDS TO SB(1), ABT 70                                       CRE
   IF(SB(1).AND.2.EQ.0) GOTO 32      *IF NOT BUSY                        CRE
   DELAY 1 MSEC                                                          CRE
   GOTO 31 WHILE (B6+1.NE.1000D)     *WAIT AT LEAST 1 SECOND             CRE
   ERROR 2/211, GOTO 70              *REPORT HUNG BUSY                   CRE
32 IF(SB(1).AND.1.EQ.0) ERROR 3/210, GOTO 70  *IF NOT READY              CRE
   B5 = 204                                                              CRE
   FUNC 1, ABT 70                    *SELECT BINARY                      CRE
   IF(P9.AND.4000.NE.0) GOTO 33      *IF HIGH-SPEED I/O                  CRE
   B5 = 206                                                              CRE
   IN 80D WORDS TO IB(1), ABT 70     *READ A CARD WORD MODE              CRE
   GOTO 34                                                               CRE
33 B5 = 207                                                              CRE
   INB 80D WORDS TO IB(1), ABT 70    *READ A CARD BLOCK MODE             CRE
34 B7 = B7 + 1                       *BUMP SEQUENCE NUMBER               CRE
   B5 = 203                                                              CRE
   REL, ABT 70                                                           CRE
   B6 = IB(201)+1.RS.12D        *BUMP CARDS READ COUNTER                 CRE
   IB(200) = IB(200) + B6       *BUMP UPPER IF OVERFLOW                  CRE
   IB(201) = IB(201) + 1        *BUMP LOWER                              CRE
   IF(WT.EQ.80D) GOTO 35                *IF WT OK                        CRE
   MSG 10 (WT) TO LINE 11D                                               CRE
   ERROR 0/220, GOTO 70                                                  CRE
35 IF(SB(1).AND.2000.EQ.0) GOTO 40  *IF NO COMPARE ERROR                 CRE
   IF(P9.AND.2000.NE.0) ERROR 4/212, GOTO 70  *NO DATA TEST              CRE
*                                                                        CRE
*---------COMPARE SEQUENCE NUMBER AND DATA IF SELECTED                   CRE
*                                                                        CRE
40 IF(P9.AND.400.EQ.0) GOTO 43  *IF NO SEQ. NUMBER IN COL 80             CRE
   IF(P9.AND.1000.NE.0)GOTO 43  *IF IGNORE SEQUENCE NUMBER               CRE
   IF(IB(80D).EQ.B7) GOTO 43    *IF SEQ. NUMBER COMPARES                 CRE
   IF(IB(80D).EQ.1) GOTO 41     *IF NUMBER RESTARTS AT ONE               CRE
   MSG 24 (B7,IB(80D)) TO LINE 11D                                       CRE
   B7 = IB(80D)                  *RESET SEQ. TO ACTUAL                   CRE
   ERROR 0/216, GOTO 70                                                  CRE
41 B7 = 1                       *SEQUENCE NUMBERS RESTART                CRE
43 IF(P9.AND.2000.NE.0)GOTO 60  *IF NO DATA COMPARE                      CRE
   IF(P9.AND.1.NE.0) GOTO 50    *IF NOT RANDOM PATTERN                   CRE
   IF(P0.NE.0) GOTO 50          *IF LOCK ON RANDOM PATTERN               CRE
   B0 = B2                      *STARTING COLUMN                         CRE
   RANDOM TO OB(200) FOR 80D, START IB(B2)                               CRE
   B6 = 200                                                              CRE
   B5 = 7777                    *DEFAULT MASK                            CRE
   IF(P1.EQ.0) GOTO 44          *IF NO MASK PROVIDED                     CRE
   B5 = P1                                                               CRE
44 OB(B0) = OB(B6).AND.B5       *GENERATE EXPECTED IMAGE                 CRE
   B6 = B6 + 1                  *BUMP INDEX TO DATA                      CRE
   B1 = 0                       *CLEAR BLANK COUNTER                     CRE
45 IF(B0.EQ.B3) GOTO 50         *IF CURRENT=LAST                         CRE
   GOTO 46 WHILE (B0+1.LE.80D)  *IF NOT END OF CARD                      CRE
   B0 = 1                       *RESET TO COLUMN 1                       CRE
46 GOTO 45 WHILE (B1+1.LE.B4)   *IF ALL BLANKS NOT INSERTED              CRE
   GOTO 44                      *CONTINUE STORING                        CRE
*                                                                        CRE
*----------DATA COMPARE - REPORT FIRST 3 ERRORS                          CRE
*                                                                        CRE
50 B0 = 79D                     *COLUMNS TO COMPARE                      CRE
   IF(P9.AND.1400.NE.0)GOTO 51  *SEQ. NUMBERS OR IGNORE                  CRE
   B0 = 80D                                                              CRE
51 B5 = 1                       *BUFFER INDEX                            CRE
   B6 = 12D                     *LINE NUMBER                             CRE
52 B1 = IB(B5).XOR.OB(B5)       *LOGICAL DIFFERENCE                      CRE
   IF(B1.EQ.0) GOTO 53          *IF WORDS COMPARE                        CRE
   MSG 23 (B5,OB(B5),IB(B5),B1) TO LINE B6                               CRE
   GOTO 53 WHILE (B6+1.LE.14D)  *IF 3 ERRORS NOT REPORTED                CRE
   GOTO 54                                                               CRE
53 GOTO 52 WHILE (B5+1.LE.B0)   *IF ALL WORDS NOT COMPARED               CRE
54 IF(B6.EQ.12D) GOTO 57        *IF NO ERRORS                            CRE
   IF(B6.GT.14D) GOTO 56        *IF 3 ERRORS REPORTED                    CRE
55 MSG 1 TO LINE B6             *BLANK UNREPORTED LINES                  CRE
   GOTO 55 WHILE (B6+1.LE.14D)                                           CRE
56 IF(SB(1).AND.2000.EQ.0) ERROR 25/215, GOTO 70  *NO CMPERR             CRE
   ERROR 26/212, GOTO 70        *COMPARE AND DATA ERRORS                 CRE
57 IF(SB(1).AND.2000.NE.0) ERROR 27/217,GOTO 70  *DATA OK                VER1068
*                                                                        CRE
*---------DELAY----------                                                CRE
*                                                                        CRE
60 B6 = P6                      *FIXED DELAY TIME                        CRE
   IF(P9.AND.2.EQ.0)GOTO 61     *IF FIXED DELAY                          CRE
   B6 = RT.AND.P6               *RANDOM DELAY                            CRE
61 IF(B6.LE.20D) GOTO 62        *SKIP DELAY IF .LT. 20 MSEC              CRE
   B6 = B6-20D                  *ADJUST DELAY DUE TO REL                 CRE
   DELAY B6 MSEC                                                         CRE
62 MSG 11, 2 WORDS FROM IB(200) TO LINE 0  *POST CARDS READ              CRE
   B5 = 0                        *INDICATE WE ARE DONE                   CRE
   IF(IB(200).NE.P7) GOTO 30     *IF NOT DONE, CONTINUE                  CRE
   IF(IB(201).NE.P8) GOTO 30     *IF NOT DONE, CONTINUE                  CRE
   EXIT                                                                  CRE
*                                                                        CRE
*---------ERROR PROCESSOR------------                                    CRE
*                                                                        CRE
70 B6 = 1                                                                CRE
   IF(EM.LT.100) GOTO 71           *IF NO ABORT                          CRE
   B6 = B5.AND.77                                                        CRE
71 MSG B6 TO LINE 10D              *ABORT/BLANK MESSAGE                  CRE
   EXIT                            *RETURN TO CREA                       CRE
   END 30                                                                CRE
COMPILE   - CRE00B -                                                     CRE
   MODULE,CRE99,3000(20),LOCK   CRE PARAMETERS                           VER1058
/                                                                        CRE
/         P0 - PRIMARY DATA BYTE IF P9 BIT 0= 1 (FIXED DATA)             CRE
/              RANDOM DATA STARTER IF P9 BIT 0= 0.                       CRE
/                                                                        CRE
/         P1 - SECONDARY DATA BYTE IF P9 BIT 0= 1.                       CRE
/              RANDOM DATA MASK IF P9 BIT 0= 0.                          CRE
/                                                                        CRE
/         P2 - FIRST COLUMN TO EXPECT DATA (DEFAULTS TO 1).              CRE
/                                                                        CRE
/         P3 - LAST COLUMN TO EXPECT DATA (DEFAULTS TO 80).              CRE
/                                                                        CRE
/         P4 - NUMBER OF BLANKS TO INSERT BETWEEN PRIMARY                CRE
/              AND SECONDARY DATA WORDS OR RANDOM DATA WORDS             CRE
/              (DEFAULTS TO 0 - NONE).                                   CRE
/                                                                        CRE
/         P5 - NOT USED                                                  CRE
/                                                                        CRE
/         P6 - MILLISECONDS TO DELAY AFTER EACH CARD READ.               CRE
/              (DEFAULTS TO 0 - SEE P9 BIT 1).                           CRE
/                                                                        CRE
/         P7/P8 - NUMBER OF CARDS TO READ (P8 IS LOWER BITS)             CRE
/              (DEFAULTS TO 77777777).                                   CRE
/                                                                        CRE
/         P9 - CONTROL BITS FOR OPTIONS                                  CRE
/                                                                        VER1070
/                      CLEAR          /       SET                        VER1070
/                                                                        VER1070
/              XXX1- RANDOM DATA      / FIXED DATA                       VER1070
/              XXX2- P6= FIXED DELAY  / P6 = DELAY MASK                  VER1070
/              XXX4-X2XX NOT USED                                        VER1070
/              X4XX- NO SEQ. NUMBERS  / SEQ. NUMBERS COL 80              VER1070
/              1XXX- TEST COLUMN 80   / IGNORE COLUMN 80                 VER1070
/              2XXX- COMPARE DATA     / DO NOT COMPARE DATA              VER1070
/              4XXX- WORD MODE INPUT  / BLOCK MODE INPUT                 VER1070
/                                                                        CRE
20 PAUSE                                                                 CRE
   END 20                                                                CRE
COMPILE,SOURCE   - CRE99 -                                               CRE
