01 0001  	; *** This is the CPU DIAGNOSTIC for the FOONLY F2 and F3 computers.
01 0002  	 ***
?ERROR - garbage token" *** "ignored
01 0003  	CFDEF-IN:
01 0004  	;;;.REPEAT CFDEF-IN < 1 [       ;ONLY IF NOT ALREADY IN...
01 0005  0 	F2SW = 0        ; this must be defined...
01 0006  	XLIST
01m0007                               	LIST
01m0007                               	
01m0007                               	: 2000  ; START ASSEMBLING INTO THIS ADDRESS
01m0007                               	;;;];REPEAT CFDEF-IN = 0
01m0007                               	
01m0007                               	START:
01m0007                               	        ; FIRST, TEST JUMP TO SEE IF IT HANDLES TRUE/FALSE AND OBUS=0
01m0007                               	        ; CONDITIONS PROPERLY.
01m0007                               	
01m0007 02000 000140000571000440002001	        JUMP [. + 1] $          ; ... HELP OPERATOR START FROM SWITCHES ...
01m0007 02001 020140000571000440002001	        JUMP [.] COND [FALSE] $         ; FAILS IF COND FALSE DOESNT WORK
01m0007 02002 000140000571000440002004	        JUMP [. + 2] COND [TRUE] $
01m0007 02003 000140000571000440002003	        JUMP [.] $                      ; HERE IF PREVIOUS INST FALLS THRU
01m0007 02004 010140000741000440002004	        ALU [-1] COND [OBUS=0] JUMP [.] $       ; TEST OBUS=0 CONDITION
01m0007 02005 030140000741000440002007	        ALU [-1] COND [-OBUS=0] JUMP [. + 2] $
01m0007 02006 000140000571000440002006	        JUMP [.] $              ; PREV INST FALLS THRU IF -OBUS=0 DONT WORK
01m0007 02007 030140000615000440002007	        ALU [0] COND [-OBUS=0] JUMP [.] $
01m0007 02010 010140000615000440002012	        ALU [0] COND [OBUS=0] JUMP [. + 2] $
01m0007 02011 000140000571000440002011	        JUMP [.] $
01m0007                               	
01m0007                               	        ; NOW, TEST Q REG TO SEE IF IT CAN HOLD ANYTHING
01m0007                               	
01m0007 02012 000700000215000440000000	        ALU [0] DEST [Q] $      ; LOAD 0 INTO Q REG
01m0007 02013 030140000555000440002013	        ALU [Q] COND [-OBUS=0] JUMP [.] $       ; HALTS IF Q/=0
01m0007 02014 000700000341000440000000	        ALU [-1] DEST [Q] $     ; LOAD -1 INTO Q
01m0007 02015 010140000555000440002015	        ALU [Q] COND [OBUS=0] JUMP [.] $        ; HALTS IF Q=0
01m0007                               	
01m0007                               	        ; TRY USING THE ALU TO OPERATE ON CONTENTS OF Q
01m0007                               	        ; AT THIS POINT Q=-1
01m0007                               	
01m0007 02016 000700000355000440000000	        ALU [NOTQ] DEST [Q] $                   ; THIS ZEROS Q
01m0007 02017 030140000555000440002017	        ALU [Q] COND [-OBUS=0] JUMP [.] $       ; CHECK TO BE SURE ITS 0
01m0007 02020 000700000355000440000000	        ALU [NOTQ] DEST [Q] $                   ; THIS SETS Q=-1
01m0007 02021 030140000755000440002021	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $    ; NOT Q SHOULD NOW BE ZERO
01m0007                               	
01m0007 02022 000700000017000440000000	        ALU [Q+1] DEST [Q] $
01m0007 02023 030140000555000440002023	        ALU [Q] COND [-OBUS=0] JUMP [.] $       ; SHOULD BE 0
01m0007 02024 000700000055000440000000	        ALU [Q-1] DEST [Q] $                    ; SHOULD BE -1
01m0007 02025 030140000755000440002025	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; THIS TIME, TRY ARITHMETICALLY MODIFYING Q
01m0007                               	
01m0007                               	; SEE IF MASKER IS ALIVE.
01m0007                               	; FIRST JUST SEE IF MASK FIELD IS SOMEWHAT READABLE.
01m0007 02026 030140014571000000002026	        ALU [D] D [CONST 0] COND [-OBUS=0] JUMP [.] $
01m0007 02027 010140014571000770002027	        ALU [D] D [CONST 77] COND [OBUS=0] JUMP [.] $
01m0007                               	
01m0007                               	; NOW SEE IF MASKER CAN BE READ AT ALL
01m0007 02030 030140010571000000002030	        ALU [D] D [MASK 0] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; FIRST TRY A ZERO MASK
01m0007 02031 010140010571000440002031	        ALU [D] D [MASK 44] COND [OBUS=0] JUMP [.] $
01m0007                               	                        ; TRY -1 MASK. HALTS IF ITS A ZERO
01m0007 02032 030140010771000440002032	        ALU [NOTD] D [MASK 44] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; TRY -1 MASK. COMPLEMENT RESULT TO MAKE SURE ITS -1
01m0007                               	
01m0007                               	
01m0007                               	; NOW TRY LOADING VARIOUS REGISTERS TO SEE IF THEY ARE ALIVE AT ALL
01m0007                               	
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 02033 000710000615000440000000	        ALU [0] DEST [AR] $                             ; TEST AR
01m0007 02034 030140000571000440002034	        ALU [D] D [AR] COND [-OBUS=0] JUMP [.] $
01m0007 02035 000710000741000440000000	        ALU [-1] DEST [AR] $
01m0007 02036 010140000571000440002036	        ALU [D] D [AR] COND [OBUS=0] JUMP [.] $
01m0007 02037 030140000771000440002037	        ALU [NOTD] D [AR] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007 02040 000720000615000440000000	        ALU [0] DEST [MA] $                             ;TEST MA
01m0007 02041 030140024571000440002041	        ALU [D] D [MA] COND [-OBUS=0] JUMP [.] $
01m0007 02042 000720000741000440000000	        ALU [-1] DEST [MA] $
01m0007 02043 010140024571000440002043	        ALU [D] D [MA] COND [OBUS=0] JUMP [.] $
01m0007                               	        ; (CAN'T DO 'NOTD' THING YET SINCE MA NOT A 36 BIT REG, AND
01m0007                               	        ; WE DON'T YET KNOW IF THE MASKER IS WORKING THAT WELL! )
01m0007                               	
01m0007                               	
01m0007 02044 000704400615000440000000	        ALU [0] DEST [HOLD] $                   ; TEST HOLD REG
01m0007 02045 030140004571000440002045	        ALU [D] D [MEM] COND [-OBUS=0] JUMP [.] $
01m0007 02046 000704400741000440000000	        ALU [-1] DEST [HOLD] $
01m0007 02047 010140004571000440002047	        ALU [D] D [MEM] COND [OBUS=0] JUMP [.] $
01m0007 02050 030140004771000440002050	        ALU [NOTD] D [MEM] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007                               	
01m0007 02051 000705400615000440000000	        ALU [0] DEST [CRYOV] $          ; LOAD ALL FLAGS IN PC WORD
01m0007 02052 000704600615000440000000	        ALU [0] DEST [PC] $             ; ZERO THE PC
01m0007 02053 030140020571000440002053	        ALU [D] D [PC] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; MAKE SURE FLAGS,,PC = 0
01m0007 02054 000704600741000440000000	        ALU [-1] DEST [PC] $
01m0007 02055 010140020571000440002055	        ALU [D] D [PC] COND [OBUS=0] JUMP [.] $
01m0007                               	                                ; SHOULD BE NONZERO NOW
01m0007                               	
01m0007 02056 000705400741000440000000	        ALU [-1] DEST [CRYOV] $
01m0007 02057 010140020571000440002057	        ALU [D] D [PC] COND [OBUS=0] JUMP [.] $
01m0007                               	                                ; SHOULD STILL BE NONZERO
01m0007 02060 000704600615000440000000	        ALU [0] DEST [PC] $
01m0007 02061 010140020571000440002061	        ALU [D] D [PC] COND [OBUS=0] JUMP [.] $
01m0007                               	                                ; THERE SHOULD STILL BE FLAGS ON
01m0007 02062 000705400615000440000000	        ALU [0] DEST [CRYOV] $  ; LEAVE IT ZERO, IN CASE OF ?
01m0007                               	
01m0007                               	
01m0007                               	; ITS ABOUT TIME TO CHECK OUT THE CONSTANT (=MASK) FIELD THOROUGHLY.
01m0007                               	
01m0007 02063 000700000215000440000000	        ALU [0] DEST [Q] $
01m0007 02064 000700000017000440000000	        ALU [Q+1] DEST [Q] $    ; SET Q=1
01m0007                               	; TRY A BIT IN ALL POSITIONS. 
01m0007       1	XX = 1
01m0007                               	.REPEAT 6 [     D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007                               	                XX = XX * 2
01m0007                               	                ALU [LSHQ] $
01m0007                               	          ]
01m0007 02065 030140014735000010002065	[       D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       2	                XX = XX * 2
01m0007 02066 000700003145000020000000	                ALU [LSHQ] $
01m0007 02067 030140014735000020002067	          ][    D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       4	                XX = XX * 2
01m0007 02070 000700003145000020000000	                ALU [LSHQ] $
01m0007 02071 030140014735000040002071	          ][    D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       10	                XX = XX * 2
01m0007 02072 000700003145000020000000	                ALU [LSHQ] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02073 030140014735000100002073	          ][    D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       20	                XX = XX * 2
01m0007 02074 000700003145000020000000	                ALU [LSHQ] $
01m0007 02075 030140014735000200002075	          ][    D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       40	                XX = XX * 2
01m0007 02076 000700003145000020000000	                ALU [LSHQ] $
01m0007 02077 030140014735000400002077	          ][    D [CONST XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007       100	                XX = XX * 2
01m0007 02100 000700003145000020000000	                ALU [LSHQ] $
01m0007                               	          ]
01m0007                               	; NOW MAKE SURE THE MASKER CAN BE OPERATED FROM THE MASK FIELD
01m0007 02101 000700000215000440000000	        ALU [0] DEST [Q] $
01m0007       0	XX = 0
01m0007                               	.REPEAT 44 [    D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007                               	                ALU [LSHQ] $
01m0007                               	                ALU [Q+1] DEST [Q] $
01m0007                               	                XX = XX + 1
01m0007                               	           ]
01m0007 02102 030140010735000000002102	[       D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02103 000700003145000020000000	                ALU [LSHQ] $
01m0007 02104 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       1	                XX = XX + 1
01m0007 02105 030140010735000010002105	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02106 000700003145000020000000	                ALU [LSHQ] $
01m0007 02107 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       2	                XX = XX + 1
01m0007 02110 030140010735000020002110	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02111 000700003145000020000000	                ALU [LSHQ] $
01m0007 02112 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       3	                XX = XX + 1
01m0007 02113 030140010735000030002113	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02114 000700003145000020000000	                ALU [LSHQ] $
01m0007 02115 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       4	                XX = XX + 1
01m0007 02116 030140010735000040002116	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02117 000700003145000020000000	                ALU [LSHQ] $
01m0007 02120 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       5	                XX = XX + 1
01m0007 02121 030140010735000050002121	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02122 000700003145000020000000	                ALU [LSHQ] $
01m0007 02123 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       6	                XX = XX + 1
01m0007 02124 030140010735000060002124	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02125 000700003145000020000000	                ALU [LSHQ] $
01m0007 02126 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       7	                XX = XX + 1
01m0007 02127 030140010735000070002127	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02130 000700003145000020000000	                ALU [LSHQ] $
01m0007 02131 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       10	                XX = XX + 1
01m0007 02132 030140010735000100002132	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02133 000700003145000020000000	                ALU [LSHQ] $
01m0007 02134 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       11	                XX = XX + 1
01m0007 02135 030140010735000110002135	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02136 000700003145000020000000	                ALU [LSHQ] $
01m0007 02137 000700000017000440000000	                ALU [Q+1] DEST [Q] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007       12	                XX = XX + 1
01m0007 02140 030140010735000120002140	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02141 000700003145000020000000	                ALU [LSHQ] $
01m0007 02142 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       13	                XX = XX + 1
01m0007 02143 030140010735000130002143	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02144 000700003145000020000000	                ALU [LSHQ] $
01m0007 02145 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       14	                XX = XX + 1
01m0007 02146 030140010735000140002146	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02147 000700003145000020000000	                ALU [LSHQ] $
01m0007 02150 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       15	                XX = XX + 1
01m0007 02151 030140010735000150002151	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02152 000700003145000020000000	                ALU [LSHQ] $
01m0007 02153 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       16	                XX = XX + 1
01m0007 02154 030140010735000160002154	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02155 000700003145000020000000	                ALU [LSHQ] $
01m0007 02156 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       17	                XX = XX + 1
01m0007 02157 030140010735000170002157	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02160 000700003145000020000000	                ALU [LSHQ] $
01m0007 02161 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       20	                XX = XX + 1
01m0007 02162 030140010735000200002162	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02163 000700003145000020000000	                ALU [LSHQ] $
01m0007 02164 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       21	                XX = XX + 1
01m0007 02165 030140010735000210002165	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02166 000700003145000020000000	                ALU [LSHQ] $
01m0007 02167 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       22	                XX = XX + 1
01m0007 02170 030140010735000220002170	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02171 000700003145000020000000	                ALU [LSHQ] $
01m0007 02172 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       23	                XX = XX + 1
01m0007 02173 030140010735000230002173	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02174 000700003145000020000000	                ALU [LSHQ] $
01m0007 02175 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       24	                XX = XX + 1
01m0007 02176 030140010735000240002176	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02177 000700003145000020000000	                ALU [LSHQ] $
01m0007 02200 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       25	                XX = XX + 1
01m0007 02201 030140010735000250002201	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02202 000700003145000020000000	                ALU [LSHQ] $
01m0007 02203 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       26	                XX = XX + 1
01m0007 02204 030140010735000260002204	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02205 000700003145000020000000	                ALU [LSHQ] $
01m0007 02206 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       27	                XX = XX + 1
01m0007 02207 030140010735000270002207	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02210 000700003145000020000000	                ALU [LSHQ] $
01m0007 02211 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       30	                XX = XX + 1
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02212 030140010735000300002212	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02213 000700003145000020000000	                ALU [LSHQ] $
01m0007 02214 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       31	                XX = XX + 1
01m0007 02215 030140010735000310002215	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02216 000700003145000020000000	                ALU [LSHQ] $
01m0007 02217 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       32	                XX = XX + 1
01m0007 02220 030140010735000320002220	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02221 000700003145000020000000	                ALU [LSHQ] $
01m0007 02222 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       33	                XX = XX + 1
01m0007 02223 030140010735000330002223	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02224 000700003145000020000000	                ALU [LSHQ] $
01m0007 02225 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       34	                XX = XX + 1
01m0007 02226 030140010735000340002226	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02227 000700003145000020000000	                ALU [LSHQ] $
01m0007 02230 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       35	                XX = XX + 1
01m0007 02231 030140010735000350002231	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02232 000700003145000020000000	                ALU [LSHQ] $
01m0007 02233 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       36	                XX = XX + 1
01m0007 02234 030140010735000360002234	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02235 000700003145000020000000	                ALU [LSHQ] $
01m0007 02236 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       37	                XX = XX + 1
01m0007 02237 030140010735000370002237	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02240 000700003145000020000000	                ALU [LSHQ] $
01m0007 02241 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       40	                XX = XX + 1
01m0007 02242 030140010735000400002242	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02243 000700003145000020000000	                ALU [LSHQ] $
01m0007 02244 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       41	                XX = XX + 1
01m0007 02245 030140010735000410002245	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02246 000700003145000020000000	                ALU [LSHQ] $
01m0007 02247 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       42	                XX = XX + 1
01m0007 02250 030140010735000420002250	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02251 000700003145000020000000	                ALU [LSHQ] $
01m0007 02252 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       43	                XX = XX + 1
01m0007 02253 030140010735000430002253	           ][   D [MASK XX] ALU [Q#D] COND [-OBUS=0] JUMP [.] $
01m0007 02254 000700003145000020000000	                ALU [LSHQ] $
01m0007 02255 000700000017000440000000	                ALU [Q+1] DEST [Q] $
01m0007       44	                XX = XX + 1
01m0007                               	           ]
01m0007                               	; ***  SOME BRUTE FORCE REGISTER DATA TESTS ***
01m0007                               	
01m0007                               	; FIRST TEST AR REGISTER (BY COMPARING CONTENTS WITH Q REG)
01m0007                               	
01m0007                               	;  LONELY BIT IN ALL POSITIONS:
01m0007 02256 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02257 000710000555000440000000	L3:     ALU [Q] DEST [AR] $
01m0007 02260 030140000735000440002260	        ALU [Q#D] D [AR] COND [-OBUS=0] JUMP [.] $      ; COMPARE Q TO AR
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 02261 000700003145000020000000	        ALU [LSHQ] $
01m0007 02262 030140000555000440002257	        ALU [Q] COND [-OBUS=0] JUMP L3 $        ; LOOP UNTIL BIT FALLS OFF
01m0007                               	
01m0007                               	;  LONELY HOLE IN ALL POSITIONS:
01m0007 02263 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02264 000710000755000440000000	L4:     ALU [NOTQ] DEST [AR] $
01m0007 02265 030140000775000440002265	        ALU [D/#Q] D [AR] COND [-OBUS=0] JUMP [.] $
01m0007 02266 000700003145000020000000	        ALU [LSHQ] $
01m0007 02267 030140000555000440002264	        ALU [Q] COND [-OBUS=0] JUMP L4 $        ; LOOP UNTIL BIT FALLS OFF
01m0007                               	
01m0007                               	; NOW TEST OUT THE HOLD REGISTER
01m0007                               	;  FIRST, LONELY BIT:
01m0007 02270 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02271 000704400555000440000000	L5:     ALU [Q] DEST [HOLD] $
01m0007 02272 030140004735000440002272	        ALU [D#Q] D [MEM] COND [-OBUS=0] JUMP [.] $     ; COMPARE Q TO HOLD
01m0007 02273 000700003145000020000000	        ALU [LSHQ] $
01m0007 02274 030140000555000440002271	        ALU [Q] COND [-OBUS=0] JUMP L5 $        ; LOOP UNTIL BIT FALLS OFF.
01m0007                               	
01m0007                               	;  NOW, LONELY HOLE:
01m0007 02275 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02276 000704400755000440000000	L6:     ALU [NOTQ] DEST [HOLD] $
01m0007 02277 030140004775000440002277	        ALU [D/#Q] D [MEM] COND [-OBUS=0] JUMP [.] $
01m0007 02300 000700003145000020000000	        ALU [LSHQ] $
01m0007 02301 030140000555000440002276	        ALU [Q] COND [-OBUS=0] JUMP L6 $
01m0007                               	
01m0007                               	; NOW A MORE THOROUGH MASKER/ROTATOR TEST...
01m0007                               	; FIRST GIVE THE ROTATOR A GOOD SHAKE
01m0007                               	; THE FIRST TEST TRIES A LONELY BIT ROTATED TO ALL POSITIONS
01m0007                               	
01m0007                               	; NOTE THAT CERTAIN REGISTERS (AR, HOLD) ARE ASSUMED TO WORK IN ORDER TO
01m0007                               	; TEST THE ROTATOR.  THEY SHOULD WORK DUE TO THE ABOVE TESTS.
01m0007                               	
01m0007                               	; THE FOLLOWING ROTATOR TESTS USE THE ROT SIZE REGISTER, WITH VALUES
01m0007                               	; FROM 1 TO 35.
01m0007                               	
01m0007                               	; ROTATED BIT TEST:
01m0007 02302 000710000215000440000000	        ALU [0] DEST [Q AR] $
01m0007 02303 000700000017000440000000	        ALU [Q+1] DEST [Q] $    ; SET Q=1. Q USED FOR COMPARISON IN LOOP
01m0007 02304 000704400555000440000000	        ALU [Q] DEST [HOLD] $   ; SET HOLD=1. WILL BE DATA FOR THE TEST.
01m0007 02305 000701200571000440000000	L1:     D [AR] DEST [ROTR] $    ; LOAD ROTATION COUNT REGISTER
01m0007 02306 030140004735200440002306	        D [MEM] ROT [R] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; COMPARE ROTATED BIT TO CONTENTS OF Q.
01m0007 02307 000710000433000440000000	        ALU [D+1] D [AR] DEST [AR] $    ; INCREMENT ROTATE COUNTER
01m0007 02310 000700003145000020000000	        ALU [LSHQ] $
01m0007 02311 030140000555000440002305	        ALU [Q] COND [-OBUS=0] JUMP L1 $
01m0007                               	                        ; KEEP LOOPING UNTIL BIT GETS SHIFTED OFF XEND OF Q
01m0007                               	
01m0007                               	; NOW TRY A ROTATING LONELY HOLE
01m0007 02312 000710000215000440000000	        ALU [0] DEST [Q AR] $
01m0007 02313 000700000017000440000000	        ALU [Q+1] DEST [Q] $    ; SET Q=1
01m0007 02314 000704400741000440000000	        ALU [-1] DEST [HOLD] $  ; USE HOLD FOR DATA, SINCE ITS 36 BITS.
01m0007 02315 000704404531000440000000	        ALU [D-1] D [MEM] DEST [HOLD] $ ;INIT HOLD TO -2
01m0007 02316 000701200571000440000000	L2:     D [AR] DEST [ROTR] $    ; LOAD ROTATION COUNT REGISTER
01m0007 02317 030140004775200440002317	        D [MEM] ROT [R] ALU [D/#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02320 000710000433000440000000	        ALU [D+1] D [AR] DEST [AR] $    ; INCREMENT SHIFT COUNT
01m0007 02321 000700003145000020000000	        ALU [LSHQ] $
01m0007 02322 030140000555000440002316	        ALU [Q] COND [-OBUS=0] JUMP L2 $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007                               	                        ; KEEP LOOPING UNTIL BIT GETS SHIFTED OFF XEND OF Q
01m0007                               	
01m0007                               	
01m0007                               	; NOW WE TRY OUT THE MASK GENERATOR, USING THE MASK SIZE REGISTER.
01m0007                               	
01m0007 02323 000704400215000440000000	        ALU [0] DEST [Q HOLD] $ ; INITIALIZE
01m0007 02324 000701404571000440000000	L7:     D [MEM] DEST [MASKR] $  ; LOAD MASK REGISTER
01m0007 02325 030140010735001000002325	        D [2] MASK [R] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; SEE IF MASK MATCHES CONTENTS OF Q.
01m0007 02326 010140000755000440000000	        ALU [NOTQ] COND [OBUS=0] JUMP L7X $     ; EXIT FROM LOOP WHEN DONE.
01m0007 02327 000704404433000440000000	        ALU [D+1] D [MEM] DEST [HOLD] $         ; INCREMENT MASK SIZE
01m0007 02330 000700003145000020000000	        ALU [LSHQ] $
01m0007 02331 000140000017000440002324	        ALU [Q+1] DEST [Q] JUMP L7 $
01m0007                               	                                ; ADD ONE TO Q.  THIS MAKES Q INTO A MASK
01m0007                               	                                ; THEN LOOP
01m0007                               	L7X:
01m0007                               	
01m0007                               	; NOW DO THE SAME TEST, BUT ACTUALLY USING THE MASKER AS WELL AS THE
01m0007                               	; MASK GENERATOR.
01m0007                               	
01m0007 02332 000704400215000440000000	        ALU [0] DEST [Q HOLD] $ ; INITIALIZE                            
01m0007 02333 000710000741000440000000	        ALU [-1] DEST [AR] $    ; USE AR TO HOLD TEST DATA
01m0007 02334 000701404571000440000000	L8:     D [MEM] DEST [MASKR] $  ; LOAD MASK REGISTER
01m0007 02335 030140000735001000002335	        D [AR] ALU [D#Q] MASK [R] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; SEE IF MASKED DATA MATCHES CONTENTS OF Q.
01m0007 02336 010140000755000440000000	        ALU [NOTQ] COND [OBUS=0] JUMP L8X $     ; EXIT FROM LOOP WHEN DONE.
01m0007 02337 000704404433000440000000	        ALU [D+1] D [MEM] DEST [HOLD] $         ; INCREMENT MASK SIZE
01m0007 02340 000700003145000020000000	        ALU [LSHQ] $
01m0007 02341 000140000017000440002334	        ALU [Q+1] DEST [Q] JUMP L8 $
01m0007                               	                                ; ADD ONE TO Q.  THIS MAKES Q INTO A MASK
01m0007                               	                                ; THEN LOOP
01m0007                               	L8X:
01m0007                               	
01m0007                               	
01m0007                               	; OK, NOW THE MASKER AND ROTATOR ARE KNOWN TO BE AT LEAST REASONABLY HEALTHY.
01m0007                               	; NOW WE CAN USE THEM TO TEST THE OTHER REGISTERS.
01m0007                               	
01m0007                               	; *** MORE REGISTER TESTS ***
01m0007                               	; TEST PC
01m0007                               	
01m0007                               	;  LONELY BIT TEST
01m0007 02342 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02343 000704600555000440000000	L9:     ALU [Q] DEST [PC] $     
01m0007 02344 030140020735000220002344	        D [PC] ALU [D#Q] MASK [22] COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; COMPARE PC TO Q, HANG UP IF NOT THE SAME
01m0007 02345 000700003145000020000000	        ALU [LSHQ] $
01m0007 02346 030140010635000220002343	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L9 $
01m0007                               	                                ; LOOP WHILE BIT IS IN RIGHT HALF OF Q.
01m0007                               	
01m0007                               	;  LONELY HOLE TEST
01m0007 02347 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02350 000704600755000440000000	L10:    ALU [NOTQ] DEST [PC] $  
01m0007 02351 000704420775000440000000	        D [PC] ALU [D/#Q] DEST [HOLD] $
01m0007 02352 030140004571000220002352	        D [MEM] MASK [22] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; COMPARE PC WITH Q
01m0007 02353 000700003145000020000000	        ALU [LSHQ] $
01m0007 02354 030140010635000220002350	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L10 $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007                               	                                ; LOOP WHILE BIT IS IN RIGHT HALF OF Q.
01m0007                               	
01m0007                               	; THE PC STILL NEEDS TO BE TESTED FOR INCREMENTING PROPERLY, BUT THAT CAN WAIT.
01m0007                               	
01m0007                               	; TEST MA (LOW ORDER 18. BITS ANYWAY; THIS IS A F2/F3 INCOMPATIBILITY)
01m0007                               	;  LONELY BIT TEST
01m0007 02355 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02356 000720000555000440000000	L11:    ALU [Q] DEST [MA] $     
01m0007 02357 030140024735000220002357	        D [MA] ALU [D#Q] MASK [22] COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; COMPARE MA TO Q, HANG UP IF NOT THE SAME
01m0007 02360 000700003145000020000000	        ALU [LSHQ] $
01m0007 02361 030140010635000220002356	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L11 $
01m0007                               	                                ; LOOP WHILE BIT IS IN RIGHT HALF OF Q.
01m0007                               	
01m0007                               	;  LONELY HOLE TEST
01m0007 02362 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02363 000720000755000440000000	L12:    ALU [NOTQ] DEST [MA] $  
01m0007 02364 000704424775000440000000	        D [MA] ALU [D/#Q] DEST [HOLD] $
01m0007 02365 030140004571000220002365	        D [MEM] MASK [22] COND [-OBUS=0] JUMP [.] $
01m0007                               	                                ; COMPARE MA WITH Q
01m0007 02366 000700003145000020000000	        ALU [LSHQ] $
01m0007 02367 030140010635000220002363	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L12 $
01m0007                               	                                ; LOOP WHILE BIT IS IN RIGHT HALF OF Q.
01m0007                               	
01m0007                               	; NOW A TEST OF THE IR (GULP)
01m0007                               	
01m0007 02370 000704400615000440000000	        ALU [0] DEST [HOLD] $   ; THIS PRESUMABLY WORKS BY NOW.
01m0007 02371 000700600615000440000000	        ALU [0] DEST [IR-ALL] $
01m0007 02372 030140034571000440002372	        ALU [D] D [IR] COND [-OBUS=0] JUMP [.] $
01m0007 02373 000700200741000440000000	        ALU [-1] DEST [IR-ADR] $
01m0007 02374 010140034571000440002374	        ALU [D] D [IR] COND [OBUS=0] JUMP [.] $
01m0007 02375 000704400741000440000000	        ALU [-1] DEST [HOLD] $
01m0007 02376 010140034571000440002376	        ALU [D] D [IR] COND [OBUS=0] JUMP [.] $
01m0007 02377 000700600615000440000000	        ALU [0] DEST [IR-ALL] $ ; NOTE: THIS DOES NOT ZERO IR! JUST RIGHT HALF
01m0007 02400 010140034571000440002400	        ALU [D] D [IR] COND [OBUS=0] JUMP [.] $
01m0007 02401 000704400615000440000000	        ALU [0] DEST [HOLD] $
01m0007 02402 000700200615000440000000	        ALU [0] DEST [IR-ADR] $         ; STILL SHOULDN'T ZERO THE IR
01m0007 02403 010140034571000440002403	        ALU [D] D [IR] COND [OBUS=0] JUMP [.] $
01m0007 02404 000700600615000440000000	        ALU [0] DEST [IR-ALL] $         ; THIS ZEROS IT.
01m0007 02405 030140034571000440002405	        ALU [D] D [IR] COND [-OBUS=0] JUMP [.] $
01m0007 02406 000704400741000440000000	        ALU [-1] DEST [HOLD] $
01m0007 02407 000700400615000440000000	        ALU [0] DEST [IR-23] $          ; THIS SHOULD UN-ZERO THE IR AGAIN
01m0007 02410 010140034571000440002410	        ALU [D] D [IR] COND [OBUS=0] JUMP [.] $
01m0007                               	
01m0007                               	; NOW TEST THE IR MORE CAREFULLY
01m0007                               	
01m0007 02411 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02412 000704400615000440000000	        ALU [0] DEST [HOLD] $
01m0007 02413 000700600555000440000000	L15:    ALU [Q] DEST [IR-ALL] $
01m0007 02414 030140034735000440002414	        D [IR] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02415 000700003145000020000000	        ALU [LSHQ] $
01m0007 02416 030140010635000220002413	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L15 $
01m0007                               	
01m0007 02417 000704400555000440000000	L16:    ALU [Q] DEST [HOLD] $           ;AT THIS POINT Q=1,,0
01m0007 02420 000700600615000440000000	        ALU [0] DEST [IR-ALL] $
01m0007 02421 030140034735000440002421	        D [IR] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02422 000704404571002440000000	        D [MEM] ROT [1] DEST [HOLD]  $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 02423 000700003145000020000000	        ALU [LSHQ] $
01m0007 02424 030140000555000440002417	        ALU [Q] COND [-OBUS=0] JUMP L16 $
01m0007                               	
01m0007                               	; NOW THE LEGENDARY HOLE TEST...
01m0007 02425 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 02426 000704400741000440000000	        ALU [-1] DEST [HOLD] $
01m0007 02427 000700600755000440000000	L17:    ALU [NOTQ] DEST [IR-ALL] $      ; LOADS IR WITH HOLE IN RIGHT HALF
01m0007 02430 030140034775000440002430	        D [IR] ALU [D/#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02431 000700003145000020000000	        ALU [LSHQ] $
01m0007 02432 030140010635000220002427	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L17 $
01m0007                               	
01m0007 02433 000704400755000440000000	L18:    ALU [NOTQ] DEST [HOLD] $                ;AT THIS POINT Q=1,,0
01m0007 02434 000700600741000440000000	        ALU [-1] DEST [IR-ALL] $        ; LOADS IR WITH HOLE IN LEFT HALF
01m0007 02435 030140034775000440002435	        D [IR] ALU [D/#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02436 000704404571002440000000	        D [MEM] ROT [1] DEST [HOLD] $   ; SHIFT THE HOLE LEFT
01m0007 02437 000700003145000020000000	        ALU [LSHQ] $
01m0007 02440 030140000555000440002433	        ALU [Q] COND [-OBUS=0] JUMP L18 $
01m0007                               	
01m0007                               	
01m0007                               	
01m0007                               	; *** TEST AC SELECTION ***
01m0007                               	;   FIRST, LOAD EACH AC WITH ITS ADDRESS.
01m0007       0	XX = 0
01m0007                               	.REPEAT 20 [    D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007                               	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007                               	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007                               	                XX = XX + 1                             ;INC. AC #
01m0007                               	           ]
01m0007 02441 000704414571056000000000	[       D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02442 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02443 000700015571000000000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       1	                XX = XX + 1                             ;INC. AC #
01m0007 02444 000704414571056010000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02445 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02446 000700015571000010000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       2	                XX = XX + 1                             ;INC. AC #
01m0007 02447 000704414571056020000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02450 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02451 000700015571000020000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       3	                XX = XX + 1                             ;INC. AC #
01m0007 02452 000704414571056030000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02453 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02454 000700015571000030000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       4	                XX = XX + 1                             ;INC. AC #
01m0007 02455 000704414571056040000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02456 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02457 000700015571000040000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       5	                XX = XX + 1                             ;INC. AC #
01m0007 02460 000704414571056050000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02461 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02462 000700015571000050000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       6	                XX = XX + 1                             ;INC. AC #
01m0007 02463 000704414571056060000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02464 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02465 000700015571000060000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       7	                XX = XX + 1                             ;INC. AC #
01m0007 02466 000704414571056070000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02467 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02470 000700015571000070000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       10	                XX = XX + 1                             ;INC. AC #
01m0007 02471 000704414571056100000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02472 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02473 000700015571000100000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       11	                XX = XX + 1                             ;INC. AC #
01m0007 02474 000704414571056110000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02475 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02476 000700015571000110000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       12	                XX = XX + 1                             ;INC. AC #
01m0007 02477 000704414571056120000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02500 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02501 000700015571000120000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       13	                XX = XX + 1                             ;INC. AC #
01m0007 02502 000704414571056130000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02503 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02504 000700015571000130000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       14	                XX = XX + 1                             ;INC. AC #
01m0007 02505 000704414571056140000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02506 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02507 000700015571000140000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       15	                XX = XX + 1                             ;INC. AC #
01m0007 02510 000704414571056150000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02511 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02512 000700015571000150000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       16	                XX = XX + 1                             ;INC. AC #
01m0007 02513 000704414571056160000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02514 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02515 000700015571000160000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       17	                XX = XX + 1                             ;INC. AC #
01m0007 02516 000704414571056170000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $       ;MOVE AC# INTO HOLD REG
01m0007 02517 000700600571000440000000	                DEST [IR-ALL] $                         ;LOAD IR (ESP AC FIELD)
01m0007 02520 000700015571000170000000	                ACSEL [AC] D [CONST XX] DEST [AC] $     ;STORE AC# IN AC
01m0007       20	                XX = XX + 1                             ;INC. AC #
01m0007                               	           ]
01m0007                               	;   NEXT, TRY READING THEM BACK:  USE ALL POSSIBLE MEANS OF ADDRESSING
01m0007                               	;    FIRST, USE AC FIELD OF IR:
01m0007       0	XX = 0
01m0007                               	.REPEAT 20 [    D [CONST XX] ROT 27 DEST [HOLD] $
01m0007                               	                DEST [IR-ALL] $
01m0007                               	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007                               	                XX = XX + 1
01m0007                               	           ]
01m0007 02521 000704414571056000000000	[       D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02522 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02523 030140014721000000002523	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       1	                XX = XX + 1
01m0007 02524 000704414571056010000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02525 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02526 030140014721000010002526	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       2	                XX = XX + 1
01m0007 02527 000704414571056020000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02530 000700600571000440000000	                DEST [IR-ALL] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02531 030140014721000020002531	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       3	                XX = XX + 1
01m0007 02532 000704414571056030000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02533 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02534 030140014721000030002534	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       4	                XX = XX + 1
01m0007 02535 000704414571056040000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02536 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02537 030140014721000040002537	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       5	                XX = XX + 1
01m0007 02540 000704414571056050000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02541 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02542 030140014721000050002542	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       6	                XX = XX + 1
01m0007 02543 000704414571056060000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02544 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02545 030140014721000060002545	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       7	                XX = XX + 1
01m0007 02546 000704414571056070000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02547 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02550 030140014721000070002550	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       10	                XX = XX + 1
01m0007 02551 000704414571056100000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02552 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02553 030140014721000100002553	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       11	                XX = XX + 1
01m0007 02554 000704414571056110000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02555 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02556 030140014721000110002556	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       12	                XX = XX + 1
01m0007 02557 000704414571056120000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02560 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02561 030140014721000120002561	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       13	                XX = XX + 1
01m0007 02562 000704414571056130000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02563 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02564 030140014721000130002564	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       14	                XX = XX + 1
01m0007 02565 000704414571056140000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02566 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02567 030140014721000140002567	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       15	                XX = XX + 1
01m0007 02570 000704414571056150000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02571 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02572 030140014721000150002572	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007       16	                XX = XX + 1
01m0007 02573 000704414571056160000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02574 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02575 030140014721000160002575	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       17	                XX = XX + 1
01m0007 02576 000704414571056170000000	           ][   D [CONST XX] ROT 27 DEST [HOLD] $
01m0007 02577 000700600571000440000000	                DEST [IR-ALL] $
01m0007 02600 030140014721000170002600	                ACSEL [AC] ALU [D#AC] D [CONST XX] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; CHECKS TO MAKE SURE EACH AC CONTAINS ITS NUMBER.
01m0007       20	                XX = XX + 1
01m0007                               	           ];    2ND, USE INDEX FIELD OF IR
01m0007       0	XX = 0
01m0007                               	.REPEAT 20 [    D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007                               	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007                               	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007                               	           ]
01m0007 02601 000704414571044000000000	[       D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02602 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02603 030140014720400000002603	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       1	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02604 000704414571044010000000	
01m0007 02605 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02606 030140014720400010002606	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       2	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02607 000704414571044020000000	
01m0007 02610 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02611 030140014720400020002611	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       3	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02612 000704414571044030000000	
01m0007 02613 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02614 030140014720400030002614	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       4	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02615 000704414571044040000000	
01m0007 02616 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02617 030140014720400040002617	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       5	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02620 000704414571044050000000	
01m0007 02621 000700600571000440000000	                DEST [IR-ALL] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02622 030140014720400050002622	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       6	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02623 000704414571044060000000	
01m0007 02624 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02625 030140014720400060002625	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       7	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02626 000704414571044070000000	
01m0007 02627 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02630 030140014720400070002630	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       10	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02631 000704414571044100000000	
01m0007 02632 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02633 030140014720400100002633	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       11	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02634 000704414571044110000000	
01m0007 02635 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02636 030140014720400110002636	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       12	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02637 000704414571044120000000	
01m0007 02640 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02641 030140014720400120002641	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       13	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02642 000704414571044130000000	
01m0007 02643 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02644 030140014720400130002644	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       14	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02645 000704414571044140000000	
01m0007 02646 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02647 030140014720400140002647	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       15	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02650 000704414571044150000000	
01m0007 02651 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02652 030140014720400150002652	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       16	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02653 000704414571044160000000	
01m0007 02654 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02655 030140014720400160002655	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       17	           ][   D [CONST XX] ROT 22 DEST [HOLD] $       ; LOAD INDEX FIELD
01m0007 02656 000704414571044170000000	
01m0007 02657 000700600571000440000000	                DEST [IR-ALL] $
01m0007                               	                ACSEL [MA] OP [R#S] SOURCE [D,A] D [CONST XX]
01m0007 02660 030140014720400170002660	                        COND [-OBUS=0] JUMP [.] $
01m0007                               	                ; ACSEL MA =>  'A' ADDRESS COMES FROM INDEX FIELD OF IR.
01m0007                               	                XX = XX + 1 
01m0007       20	           ]
01m0007                               	;    3RD, USE LOW ORDER BITS OF MA
01m0007       0	XX = 0
01m0007                               	.REPEAT 20 [    D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007                               	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007                               	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007                               	                XX = XX + 1
01m0007                               	           ]
01m0007 02661 000720014571000000000000	[       D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02662 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02663 030140014735000000002663	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       1	                XX = XX + 1
01m0007 02664 000720014571000010000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02665 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02666 030140014735000010002666	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       2	                XX = XX + 1
01m0007 02667 000720014571000020000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02670 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02671 030140014735000020002671	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       3	                XX = XX + 1
01m0007 02672 000720014571000030000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02673 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02674 030140014735000030002674	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       4	                XX = XX + 1
01m0007 02675 000720014571000040000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02676 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02677 030140014735000040002677	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       5	                XX = XX + 1
01m0007 02700 000720014571000050000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02701 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02702 030140014735000050002702	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       6	                XX = XX + 1
01m0007 02703 000720014571000060000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 02704 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02705 030140014735000060002705	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       7	                XX = XX + 1
01m0007 02706 000720014571000070000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02707 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02710 030140014735000070002710	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       10	                XX = XX + 1
01m0007 02711 000720014571000100000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02712 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02713 030140014735000100002713	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       11	                XX = XX + 1
01m0007 02714 000720014571000110000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02715 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02716 030140014735000110002716	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       12	                XX = XX + 1
01m0007 02717 000720014571000120000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02720 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02721 030140014735000120002721	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       13	                XX = XX + 1
01m0007 02722 000720014571000130000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02723 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02724 030140014735000130002724	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       14	                XX = XX + 1
01m0007 02725 000720014571000140000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02726 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02727 030140014735000140002727	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       15	                XX = XX + 1
01m0007 02730 000720014571000150000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02731 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02732 030140014735000150002732	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       16	                XX = XX + 1
01m0007 02733 000720014571000160000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02734 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02735 030140014735000160002735	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       17	                XX = XX + 1
01m0007 02736 000720014571000170000000	           ][   D [CONST XX] DEST [MA] $        ; LOAD MA WITH AC #
01m0007 02737 000700000150400440000000	                ACSEL [MA] ALU [AC] DEST [Q] $  ; LOAD Q WITH (AC)
01m0007 02740 030140014735000170002740	                D [CONST XX] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007                               	                        ; COMPARE Q (=AC) WITH AC #
01m0007       20	                XX = XX + 1
01m0007                               	           ]
01m0007                               	;    LAST, USE AC CNT REGISTER
01m0007       0	XX = 0
01m0007 02741 000701000615000440000000	                ALU [0] DEST [AC-SEL] $
01m0007                               	.REPEAT 20 [    D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007                               	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007                               	                XX = XX + 1
01m0007                               	           ]
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007                               	[       D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02742 030147014720000000002742	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       1	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02743 030147014720000010002743	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       2	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02744 030147014720000020002744	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       3	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02745 030147014720000030002745	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       4	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02746 030147014720000040002746	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       5	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02747 030147014720000050002747	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       6	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02750 030147014720000060002750	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       7	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02751 030147014720000070002751	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       10	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02752 030147014720000100002752	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       11	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02753 030147014720000110002753	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       12	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02754 030147014720000120002754	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       13	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02755 030147014720000130002755	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       14	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02756 030147014720000140002756	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       15	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02757 030147014720000150002757	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       16	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02760 030147014720000160002760	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       17	                XX = XX + 1
01m0007                               	           ][   D [CONST XX] ACSEL [REG] DEST [A-MEM-CNTR&INC]
01m0007 02761 030147014720000170002761	                        ALU [D#AC] COND [-OBUS=0] JUMP [.] $
01m0007       20	                XX = XX + 1
01m0007                               	           ]
01m0007                               	
01m0007                               	; **** NOW TEST A-MEM ****
01m0007                               	; FIRST A SPOT CHECK USING LITERAL ADDRESSING
01m0007                               	
01m0007                               	; WRITE BLOCK NUMBER + 1 IN ZEROTH WORD OF EACH 8-WORD BLOCK IN A-MEM
01m0007 02762 000702414171000400000000	        D [CONST 40] DEST [Q CLR-DEV-FROM-INTR] $
01m0007 02763 000701600455000440000000	L40:    ALU [Q-1] DEST [DEV-ADR] $
01m0007 02764 000700000555000443000000	        ALU [Q] DEST [0] SPEC [DEST-A-MEM] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 02765 030140000055000440002763	        ALU [Q-1] DEST [Q] COND [-OBUS=0] JUMP L40 $
01m0007                               	; NOW TRY READING IT BACK
01m0007 02766 000700014171000400000000	        D [CONST 40] DEST [Q] $
01m0007 02767 000701600455000440000000	L41:    ALU [Q-1] DEST [DEV-ADR] $
01m0007 02770 030140040735000440002770	        D [10] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007 02771 030140000055000440002767	        ALU [Q-1] DEST [Q] COND [-OBUS=0] JUMP L41 $
01m0007                               	
01m0007                               	; WRITE  NOT(BLOCK NUMBER+1) IN FOURTH WORD OF EACH 8-WORD BLOCK IN A-MEM
01m0007 02772 000702414171000400000000	        D [CONST 40] DEST [Q CLR-DEV-FROM-INTR] $
01m0007 02773 000701600455000440000000	L42:    ALU [Q-1] DEST [DEV-ADR] $
01m0007 02774 000701000755000443000000	        ALU [NOTQ] DEST [4] SPEC [DEST-A-MEM] $
01m0007 02775 030140000055000440002773	        ALU [Q-1] DEST [Q] COND [-OBUS=0] JUMP L42 $
01m0007                               	; NOW TRY READING IT BACK
01m0007 02776 000700014171000400000000	        D [CONST 40] DEST [Q] $
01m0007 02777 000701600455000440000000	L43:    ALU [Q-1] DEST [DEV-ADR] $
01m0007 03000 030140060775000440003000	        D [14] ALU [D/#Q] COND [-OBUS=0] JUMP [.] $
01m0007 03001 030140000055000440002777	        ALU [Q-1] DEST [Q] COND [-OBUS=0] JUMP L43 $
01m0007                               	
01m0007                               	;;Special A-MEM addressing test suggested by TVR, adapted to fact that each
01m0007                               	;;12-bit chunk of 36-bit A-MEM word is on separate card.  MLB 15 NOV 79
01m0007                               	
01m0007                               	;The following 12-bit pattern is triplicated in each word of A-MEM:
01m0007                               	;         00   01   02   03   04   05   06   07   08   09   10   11
01m0007                               	;BITS:    12   13   14   15   16   17   18   19   20   21   22   23
01m0007                               	;         24   25   26   27   28   29   30   31   32   33   34   35
01m0007                               	;       !------------!------------!------------!------------!
01m0007                               	;       ! comp. word   ! word         ! 0   8 wd block number /    !
01m0007                               	;       ! number       ! number       !      device address        !
01m0007                               	;       !------------!------------!------------!------------!
01m0007                               	;       (eg word number 5 in block 16 contains 251625162516)
01m0007                               	;This routine keeps a copy of the 12-bit pattern in AR and uses Q as a temp.
01m0007                               	
01m0007 03002 000702400215000440000000	        ALU[0] DEST[Q CLR-DEV-FROM-INTR] $      ;Init Q, clear dev num
01m0007                               	AMWLP:  ;Loop to write pattern into A-MEM, Q has device number at this point
01m0007       0	AMWORD = 0
01m0007                               	.REPEAT 8 [     ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007                               	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007                               	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007                               	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007                               	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007                               	AMWORD = AMWORD + 1
01m0007                               	]
01m0007                               	[       ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03003 000710014175014700000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03004 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03005 000700000575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03006 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       1	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03007 000710014175014610000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03010 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 03011 000700200575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03012 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       2	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03013 000710014175014520000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03014 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03015 000700400575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03016 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       3	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03017 000710014175014430000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03020 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03021 000700600575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03022 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       4	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03023 000710014175014340000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03024 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03025 000701000575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03026 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       5	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03027 000710014175014250000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03030 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03031 000701200575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03032 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       6	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03033 000710014175014160000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03034 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03035 000701400575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03036 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       7	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word create pattern and write it
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03037 000710014175014070000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03040 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[AMWORD]
01m0007 03041 000701600575060443000000	                SPEC[DEST-A-MEM] $              ;Write full pattern into A-MEM
01m0007 03042 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       10	AMWORD = AMWORD + 1
01m0007 03043 000702400017000440000000	]       ALU[Q+1] DEST[Q CLR-DEV-FROM-INTR] $    ;Incr Q for next device
01m0007                               	        D[CONST 37] ALU[D&Q] DEST[Q]            ;Mask to get device number
01m0007 03044 030140014235000370003003	                COND[-OBUS=0] JUMP AMWLP $      ;Loop if not all dev nums done
01m0007                               	AMRLP:  ;Loop to read and test pattern in A-MEM, Q has device number here
01m0007       0	AMWORD = 0
01m0007                               	.REPEAT 8 [     ;For each word recreate pattern and test it against A-MEM 
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007                               	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007                               	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007                               	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007                               	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007                               	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007                               	AMWORD = AMWORD + 1
01m0007                               	]
01m0007                               	[       ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03045 000710014175014700000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03046 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03047 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03050 030140040735000440003050	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03051 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       1	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03052 000710014175014610000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03053 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03054 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03055 030140044735000440003055	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03056 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       2	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03057 000710014175014520000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03060 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03061 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03062 030140050735000440003062	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03063 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       3	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03064 000710014175014430000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03065 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03066 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03067 030140054735000440003067	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03070 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       4	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03071 000710014175014340000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03072 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03073 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03074 030140060735000440003074	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03075 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       5	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03076 000710014175014250000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03077 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03100 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03101 030140064735000440003101	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03102 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       6	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03103 000710014175014160000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03104 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03105 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03106 030140070735000440003106	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03107 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       7	AMWORD = AMWORD + 1
01m0007                               	][      ;For each word recreate pattern and test it against A-MEM 
01m0007                               	        D[CONST 7 * ( 8 - AMWORD ) ]            ;This gives comp-word:word num
01m0007 03110 000710014175014070000000	                ROT[6] ALU[DORQ] DEST[Q AR] $   ;Q AR _ 12-bit pattern  
01m0007 03111 000701600175030440000000	        D[AR] ROT[14] ALU[DORQ] DEST[Q DEV-ADR] $       ;copy patt, set dev num
01m0007 03112 000700000175060440000000	        D[AR] ROT[30] ALU[DORQ] DEST[Q] $               ;Q _ 36-bit pattern
01m0007 03113 030140074735000440003113	        D[10 + AMWORD] ALU[D#Q] COND[-OBUS=0] JUMP[.] $ ;HANGS HERE ON LOSSAGE
01m0007 03114 000700000155000370000000	        D[AR] MASK[37] ALU[Q] DEST[Q] $         ;Q _ just device number
01m0007       10	AMWORD = AMWORD + 1
01m0007 03115 000702400017000440000000	]       ALU[Q+1] DEST[Q CLR-DEV-FROM-INTR] $    ;Incr Q for next device
01m0007                               	        D[CONST 37] ALU[D&Q] DEST[Q]            ;Mask to get device number
01m0007 03116 030140014235000370003045	                COND[-OBUS=0] JUMP AMRLP $      ;Loop if not all dev nums done
01m0007                               	
01m0007                               	
01m0007                               	; NOW AN EXTENSIVE TEST USING THE AC CNT REG.
01m0007                               	
01m0007                               	; WRITE BLOCKNUM,,WORDNUM INTO EACH WORD OF A-MEM
01m0007                               	; BLOCKNUM IS NUMBER OF NTH 16.-WORD BLOCK
01m0007                               	; WORDNUM IS INDEX OF WORD IN BLOCK
01m0007                               	
01m0007 03117 000712414571000170000000	        D [CONST 17] DEST [AR CLR-DEV-FROM-INTR] $      ;INIT BLOCKNUM
01m0007 03120 000701600571002440000000	L20:    D [AR] ROT [1] DEST [DEV-ADR] $                 ; LOAD DEV ADR
01m0007 03121 000701000215000440000000	        ALU [0] DEST [Q AC-SEL] $                       ;INIT WORDNUM
01m0007                               	
01m0007                               	L200:   D [AR] ROT [22] ALU [DORQ] DEST [A-MEM-CNTR&INC]
01m0007 03122 000707000575044443000000	                SPEC [DEST-A-MEM] $                     ;AMEM = BLK,,WORD
01m0007 03123 000700000017000440000000	        ALU [Q+1] DEST [Q] $
01m0007 03124 030140014735000200003122	        D [CONST 20] ALU [D#Q] COND [-OBUS=0] JUMP L200 $
01m0007                               	
01m0007 03125 010140000571000440000000	        D [AR] COND [OBUS=0] JUMP L20X $
01m0007 03126 000150000531000440003120	        D [AR] ALU [D-1] DEST [AR] JUMP L20 $
01m0007                               	L20X:
01m0007                               	
01m0007                               	; NOW TRY TO READ IT BACK
01m0007 03127 000704414571000170000000	        D [CONST 17] DEST [HOLD] $                      ;INIT BLOCKNUM
01m0007 03130 000701604571002440000000	L21:    D [MEM] ROT [1] DEST [DEV-ADR] $                ;LOAD DEV ADR REG
01m0007 03131 000701000215000440000000	        ALU [0] DEST [Q AC-SEL] $                       ;INIT WORDNUM
01m0007                               	
01m0007 03132 000700004175044440000000	L210:   D [MEM] ROT [22] ALU [DORQ] DEST[Q] $           ;Q=BLK,,WORD
01m0007 03133 000717240571000440000000	        DEST [AR A-MEM-CNTR] D [10] $           ;AR =A-MEM (AC CNT)
01m0007 03134 030140000735000440003134	        D [AR] ALU [D#Q] COND [-OBUS=0] JUMP [.] $      ;COMPARE Q TO AR
01m0007 03135 000707000741000443000000	        ALU [-1] SPEC [DEST-A-MEM] DEST [A-MEM-CNTR&INC] $
01m0007                               	                        ;OVERWRITE A-MEM DATA TO MAKE TEST HARDER!
01m0007                               	
01m0007 03136 000700010235000220000000	        D [MASK 22] ALU [D&Q] DEST [Q] $                ;Q=WORD
01m0007 03137 000700000017000440000000	        ALU [Q+1] DEST [Q] $                            ;Q=Q+1
01m0007 03140 030140014735000200003132	        D [CONST 20] ALU [D#Q] COND [-OBUS=0] JUMP L210 $ ;Q=20?
01m0007                               	
01m0007 03141 010140004571000440000000	        D [MEM] COND [OBUS=0] JUMP L21X $
01m0007 03142 000144404531000440003130	        D [MEM] ALU [D-1] DEST [HOLD] JUMP L21 $
01m0007                               	L21X:
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007                               	
01m0007                               	
01m0007                               	; **** NOW TEST SOME OF THE "SPECIAL" FUNCTIONS ****
01m0007                               	
01m0007                               	
01m0007                               	;  MAKE SURE SPEC [MA_PC] WORKS...
01m0007                               	
01m0007 03143 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 03144 000704600555000440000000	L50:    ALU [Q] DEST [PC] $
01m0007 03145 000720000615000440600000	        ALU [0] DEST [MA] SPEC [MA_PC] $
01m0007 03146 030140024735000440003146	        D [MA] ALU [D#Q] COND [-OBUS=0] JUMP [.] $
01m0007 03147 000700003145000020000000	        ALU [LSHQ] $
01m0007 03150 030140010635000220003144	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L50 $
01m0007                               	
01m0007 03151 000700014171000010000000	        D [CONST 1] DEST [Q] $
01m0007 03152 000704600755000440000000	L51:    ALU [NOTQ] DEST [PC] $
01m0007 03153 000720000615000440600000	        ALU [0] DEST [MA] SPEC [MA_PC] $
01m0007 03154 000704424775000440000000	        D [MA] ALU [D/#Q] DEST [HOLD] $
01m0007 03155 030140004571000220003155	        D [MEM] MASK [22] COND [-OBUS=0] JUMP [.] $
01m0007 03156 000700003145000020000000	        ALU [LSHQ] $
01m0007 03157 030140010635000220003152	        D [MASK 22] ALU [D&Q] COND [-OBUS=0] JUMP L51 $
01m0007                               	
01m0007                               	; TEST SPEC [LEFT]      ; (FORCES MASK=-1,,0)
01m0007 03160 000700010171044000200000	        D [MASK 0] SPEC [LEFT] ROT [22] DEST [Q] $      ;Q=777777, THE HARD WAY
01m0007 03161 030140010735000220003161	        D [MASK 22] ALU [D#Q] COND [-OBUS=0] JUMP [.] $ ;NOW MAKE SURE ...
01m0007                               	
01m0007                               	; TEST SPEC [PC+1]
01m0007 03162 000705400615000440000000	        ALU [0] DEST [CRYOV] $
01m0007 03163 000704600741000440000000	        ALU [-1] DEST [PC] $
01m0007 03164 000700000571000442000000	        SPEC [PC+1] $
01m0007 03165 030140020571000440003165	        D [PC] COND [-OBUS=0] JUMP [.] $
01m0007 03166 000700000571000442000000	        SPEC [PC+1] $
01m0007 03167 030140020531000440003167	        D [PC] ALU [D-1] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007                               	; TEST MORE JUMP CONDITIONS:
01m0007                               	;  TRY OUT COND [AC=0]  (TRUE IF IR AC=0)
01m0007                               	;  AND COND [MEM-IDX-IND]  (TRUE IF IR IDX OR IND/=0)
01m0007                               	
01m0007 03170 000704414571044010000000	                D [CONST 1] ROT [22] DEST [HOLD] $
01m0007                               	.REPEAT 5 [     ALU [0] DEST [IR-ALL] $
01m0007                               	                COND [-AC=0] JUMP [.] $
01m0007                               	                COND [AC=0] JUMP [. + 2] $
01m0007                               	                JUMP [.] $
01m0007                               	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007                               	                JUMP [.] $
01m0007                               	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007                               	                D [MEM] ROT [1] DEST [HOLD] $
01m0007                               	          ]
01m0007 03171 000700600615000440000000	[       ALU [0] DEST [IR-ALL] $
01m0007 03172 023140000571000440003172	                COND [-AC=0] JUMP [.] $
01m0007 03173 003140000571000440003175	                COND [AC=0] JUMP [. + 2] $
01m0007 03174 000140000571000440003174	                JUMP [.] $
01m0007 03175 004140000571000440003177	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007 03176 000140000571000440003176	                JUMP [.] $
01m0007 03177 024140000571000440003177	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007 03200 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03201 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 03202 023140000571000440003202	                COND [-AC=0] JUMP [.] $
01m0007 03203 003140000571000440003205	                COND [AC=0] JUMP [. + 2] $
01m0007 03204 000140000571000440003204	                JUMP [.] $
01m0007 03205 004140000571000440003207	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007 03206 000140000571000440003206	                JUMP [.] $
01m0007 03207 024140000571000440003207	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007 03210 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03211 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03212 023140000571000440003212	                COND [-AC=0] JUMP [.] $
01m0007 03213 003140000571000440003215	                COND [AC=0] JUMP [. + 2] $
01m0007 03214 000140000571000440003214	                JUMP [.] $
01m0007 03215 004140000571000440003217	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007 03216 000140000571000440003216	                JUMP [.] $
01m0007 03217 024140000571000440003217	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007 03220 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03221 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03222 023140000571000440003222	                COND [-AC=0] JUMP [.] $
01m0007 03223 003140000571000440003225	                COND [AC=0] JUMP [. + 2] $
01m0007 03224 000140000571000440003224	                JUMP [.] $
01m0007 03225 004140000571000440003227	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007 03226 000140000571000440003226	                JUMP [.] $
01m0007 03227 024140000571000440003227	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007 03230 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03231 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03232 023140000571000440003232	                COND [-AC=0] JUMP [.] $
01m0007 03233 003140000571000440003235	                COND [AC=0] JUMP [. + 2] $
01m0007 03234 000140000571000440003234	                JUMP [.] $
01m0007 03235 004140000571000440003237	                COND [MEM-IDX-IND] JUMP [. + 2] $
01m0007 03236 000140000571000440003236	                JUMP [.] $
01m0007 03237 024140000571000440003237	                COND [-MEM-IDX-IND] JUMP [.] $
01m0007 03240 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007                               	          ]
01m0007                               	; TEST BIT IN EACH POSITION OF IR AC FIELD
01m0007                               	.REPEAT 4 [     ALU [0] DEST [IR-ALL] $
01m0007                               	                COND [AC=0] JUMP [.] $
01m0007                               	                COND [-AC=0] JUMP [. + 2] $
01m0007                               	                JUMP [.] $
01m0007                               	                COND [MEM-IDX-IND] JUMP [.] $
01m0007                               	                COND [-MEM-IDX-IND] JUMP [. + 2] $
01m0007                               	                JUMP [.] $
01m0007                               	                D [MEM] ROT [1] DEST [HOLD] $
01m0007                               	          ]
01m0007 03241 000700600615000440000000	[       ALU [0] DEST [IR-ALL] $
01m0007 03242 003140000571000440003242	                COND [AC=0] JUMP [.] $
01m0007 03243 023140000571000440003245	                COND [-AC=0] JUMP [. + 2] $
01m0007 03244 000140000571000440003244	                JUMP [.] $
01m0007 03245 004140000571000440003245	                COND [MEM-IDX-IND] JUMP [.] $
01m0007 03246 024140000571000440003250	                COND [-MEM-IDX-IND] JUMP [. + 2] $
01m0007 03247 000140000571000440003247	                JUMP [.] $
01m0007 03250 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03251 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03252 003140000571000440003252	                COND [AC=0] JUMP [.] $
01m0007 03253 023140000571000440003255	                COND [-AC=0] JUMP [. + 2] $
01m0007 03254 000140000571000440003254	                JUMP [.] $
01m0007 03255 004140000571000440003255	                COND [MEM-IDX-IND] JUMP [.] $
01m0007 03256 024140000571000440003260	                COND [-MEM-IDX-IND] JUMP [. + 2] $
01m0007 03257 000140000571000440003257	                JUMP [.] $
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 03260 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03261 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03262 003140000571000440003262	                COND [AC=0] JUMP [.] $
01m0007 03263 023140000571000440003265	                COND [-AC=0] JUMP [. + 2] $
01m0007 03264 000140000571000440003264	                JUMP [.] $
01m0007 03265 004140000571000440003265	                COND [MEM-IDX-IND] JUMP [.] $
01m0007 03266 024140000571000440003270	                COND [-MEM-IDX-IND] JUMP [. + 2] $
01m0007 03267 000140000571000440003267	                JUMP [.] $
01m0007 03270 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007 03271 000700600615000440000000	          ][    ALU [0] DEST [IR-ALL] $
01m0007 03272 003140000571000440003272	                COND [AC=0] JUMP [.] $
01m0007 03273 023140000571000440003275	                COND [-AC=0] JUMP [. + 2] $
01m0007 03274 000140000571000440003274	                JUMP [.] $
01m0007 03275 004140000571000440003275	                COND [MEM-IDX-IND] JUMP [.] $
01m0007 03276 024140000571000440003300	                COND [-MEM-IDX-IND] JUMP [. + 2] $
01m0007 03277 000140000571000440003277	                JUMP [.] $
01m0007 03300 000704404571002440000000	                D [MEM] ROT [1] DEST [HOLD] $
01m0007                               	          ]
01m0007                               	; TEST COND [MA-AC]     (NUMBER IN MA IS AN AC ADDR)
01m0007 03301 000720000615000440000000	        ALU [0] DEST [MA] $
01m0007 03302 002140000571000440003304	L60:    COND [MA-AC] JUMP [. + 2] $
01m0007 03303 000140000571000440003303	        JUMP [.] $
01m0007 03304 022140000571000440003304	        COND [-MA-AC] JUMP [.] $
01m0007 03305 000720024033000440000000	        D [MA] ALU [D+1] DEST [MA Q] $
01m0007 03306 030140014735000200003302	        D [CONST 20] ALU [D#Q] COND [-OBUS=0] JUMP L60 $
01m0007                               	
01m0007                               	; AT THIS POINT MA=20
01m0007                               	; NOW ROTATE THE BIT INTO ALL POSITIONS, TO BE SURE THE CONDITION DOESNT
01m0007                               	; BECOME TRUE SPURIOUSLY.
01m0007 03307 002140000571000440003307	L61:    COND [MA-AC] JUMP [.] $
01m0007 03310 000720024171002440000000	        D [MA] ROT [1] DEST [MA Q] $
01m0007 03311 010140014735000010003307	        D [CONST 1] ALU [D#Q] COND [OBUS=0] JUMP [L61] $
01m0007                               	
01m0007                               	; NOW TRY ALL AC BITS ON, BUT EXTRA BITS ON TOO.
01m0007 03312 000700014171000200000000	        D [CONST 20] DEST [Q] $
01m0007 03313 000720014575000170000000	L62:    D [CONST 17] ALU [DORQ] DEST [MA] $
01m0007 03314 002140000571000440003314	        COND [MA-AC] JUMP [.] $
01m0007 03315 022140000571000440003317	        COND [-MA-AC] JUMP [. + 2] $
01m0007 03316 000140000571000440003316	        JUMP [.] $
01m0007 03317 000700003145000020000000	        ALU [LSHQ] $
01m0007 03320 030140014635044010003313	        D [CONST 1] ROT[22] ALU [D&Q] COND [-OBUS=0] JUMP L62 $
01m0007                               	
01m0007                               	; TEST COND [OBUS18]
01m0007 03321 033140014571042010003321	        D [CONST 1] ROT [21] COND [-OBUS18] JUMP [.] $
01m0007 03322 013140014571042010003324	        D [CONST 1] ROT [21] COND [OBUS18] JUMP [. + 2] $
01m0007 03323 000140000571000440003323	        JUMP [.] $
01m0007 03324 013140000615000440003324	        ALU [0] COND [OBUS18] JUMP [.] $
01m0007 03325 033140000615000440003327	        ALU [0] COND [-OBUS18] JUMP [. + 2] $
01m0007 03326 000140000571000440003326	        JUMP [.] $
01m0007                               	
01m0007                               	; TEST COND [OBUS<0]
01m0007 03327 031140014571106010003327	        D [CONST 1] ROT [43] COND [-OBUS<0] JUMP [.] $
01m0007 03330 011140014571106010003332	        D [CONST 1] ROT [43] COND [OBUS<0] JUMP [. + 2] $
01m0007 03331 000140000571000440003331	        JUMP [.] $
01m0007 03332 011140000615000440003332	        ALU [0] COND [OBUS<0] JUMP [.] $
01m0007 03333 031140000615000440003335	        ALU [0] COND [-OBUS<0] JUMP [. + 2] $
01m0007 03334 000140000571000440003334	        JUMP [.] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 03335 011140010571000430003335	        D [MASK 43] COND [OBUS<0] JUMP [.] $
01m0007 03336 031140010571000430003340	        D [MASK 43] COND [-OBUS<0] JUMP [. + 2] $
01m0007 03337 000140000571000440003337	        JUMP [.] $
01m0007                               	
01m0007                               	.repeat 0 [     ;I'm afraid that's not what Q0-35 means.  It has to do with shifting
01m0007                               	; COND [Q0-35]          LOW ORDER BIT OF Q REGISTER
01m0007                               	        ALU [0] DEST [Q] $              ;FIRST TRY IT WITH A 0
01m0007                               	        COND [Q0-35] JUMP [.] $
01m0007                               	        COND [-Q0-35] JUMP [. + 2] $
01m0007                               	        JUMP [.] $
01m0007                               	        D [CONST 1] DEST [Q] $          ;THEN TRY IT WITH A 1
01m0007                               	        COND [Q0-35] JUMP [. + 2] $
01m0007                               	        JUMP [.] $
01m0007                               	        COND [-Q0-35] JUMP [.] $
01m0007                               	];repeat 0
01m0007                               	
01m0007                               	; COND[USER]
01m0007 03340 640145400615000440003341	        ALU[0] DEST[CRYOV] NORM JUMP[. + 1] $
01m0007                               	                ;Clear all flags
01m0007 03341 665140000571000440003343	        COND[-USER] NORM JUMP[. + 2] $
01m0007                               	                ;User on?
01m0007 03342 000140000571000440003342	        JUMP[.] $
01m0007                               	                ;USER always true
01m0007 03343 640705400741000440000000	        ALU[-1] DEST[CRYOV] NORM $
01m0007                               	                ;Try setting all flags
01m0007 03344 645140000571000440003346	        COND[USER] NORM JUMP[. + 2] $
01m0007                               	                ;User on?
01m0007 03345 000140000571000440003345	        JUMP[.] $
01m0007                               	                ;USER is never true
01m0007 03346 640705414571074010000000	        D[CONST 1] ROT[44 - 6] DEST[CRYOV] NORM $
01m0007                               	                ;Now, try user bit itself
01m0007 03347 645140000571000440003351	        COND[USER] NORM JUMP[. + 2] $
01m0007 03350 000140000571000440003350	        JUMP[.] $
01m0007                               	                ;USER is connected to wrong bit
01m0007 03351 640705414771074010000000	        D[CONST 1] ROT[44 - 6] ALU[NOTD] DEST[CRYOV] NORM $
01m0007 03352 665140000571000440003354	        COND[-USER] NORM JUMP[. + 2] $
01m0007 03353 000140000571000440003353	        JUMP[.] $
01m0007                               	                ;USER is conditioned by something other than the user bit
01m0007                               	        
01m0007                               	
01m0007                               	; **** SEQUENCER TESTS ****
01m0007                               	
01m0007                               	;  CHECK OUT PUSHJ
01m0007                               	.REPEAT 5 [     JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007                               	          ]
01m0007 03354 000340000571000440003355	[       JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007 03355 000340000571000440003356	          ][    JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007 03356 000340000571000440003357	          ][    JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007 03357 000340000571000440003360	          ][    JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007 03360 000340000571000440003361	          ][    JPOP [. + 1] $  ; MAKE DAMN SURE STACK IS EMPTY BEFORE TEST!
01m0007                               	          ]
01m0007                               	;   THIS TEST MAKES SURE THE ROUTINE GETS CALLED EXACTLY THE RIGHT NUMBER
01m0007                               	;   OF TIMES.
01m0007                               	
01m0007 03361 000700014171000100000000	        D [CONST 10] DEST [Q] $
01m0007                               	.REPEAT 10 [    PUSHJ [ROUT1] $
01m0007                               	           ]
SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- DIAG4

01m0007 03362 000040000571000440000000	[       PUSHJ [ROUT1] $
01m0007 03363 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03364 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03365 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03366 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03367 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03370 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03371 000040000571000440000000	           ][   PUSHJ [ROUT1] $
01m0007 03372 030140000555000440003372	           ]    ALU [Q] COND [-OBUS=0] JUMP [.] $
01m0007 03373 000140000571000440000000	        JUMP PJ $
01m0007                               	
01m0007 03374 000300000055000440000000	ROUT1:  ALU [Q-1] DEST [Q] POPJ $
01m0007 03375 000140000571000440003375	        JUMP [.] $
01m0007                               	
01m0007                               	; FURTHER PUSHJ CHECK... TRY NESTED ROUTINES.
01m0007                               	
01m0007 03376 000700000215000440000000	PJ:     ALU [0] DEST [Q] $
01m0007 03377 000040000571000440000000	        PUSHJ R1 $
01m0007 03400 030140014735000370003400	        ALU [D#Q] D [CONST 37] COND [-OBUS=0] JUMP [.] $
01m0007 03401 000140000571000440000000	        JUMP LOOP0 $
01m0007                               	
01m0007 03402 000040014175000010000000	R1:     D [CONST 1] ALU [DORQ] DEST [Q] PUSHJ R2 $
01m0007 03403 000300000571000440000000	        POPJ $
01m0007 03404 000140000571000440003404	        JUMP [.] $
01m0007                               	
01m0007 03405 000040014175000020000000	R2:     D [CONST 2] ALU [DORQ] DEST [Q] PUSHJ R3 $
01m0007 03406 000300000571000440000000	        POPJ $
01m0007 03407 000140000571000440003407	        JUMP [.] $
01m0007                               	
01m0007 03410 000040014175000040000000	R3:     D [CONST 4] ALU [DORQ] DEST [Q] PUSHJ R4 $
01m0007 03411 000300000571000440000000	        POPJ $
01m0007 03412 000140000571000440003412	        JUMP [.] $
01m0007                               	
01m0007 03413 000040014175000100000000	R4:     D [CONST 10] ALU [DORQ] DEST [Q] PUSHJ R5 $
01m0007 03414 000300000571000440000000	        POPJ $
01m0007 03415 000140000571000440003415	        JUMP [.] $
01m0007                               	
01m0007 03416 000300014175000200000000	R5:     D [CONST 20] ALU [DORQ] DEST [Q] POPJ $
01m0007 03417 000140000571000440003417	        JUMP [.] $
01m0007                               	
01m0007                               	
01m0007                               	; CHECK LOOP, INCLUDING R REGISTER IN SEQUENCER, AND LLOAD
01m0007                               	
01m0007 03420 000140000571000440003420	LUPERR: JUMP [.] $      ; THE FIRST LOOP TEST COMES HERE IF IT LOSES
01m0007                               	
01m0007                               	; THE PUSHJ TEST COMES HERE AFTER ITS DONE.
01m0007                               	LOOP0:
01m0007 03421 000740000215000440000000	        ALU [0] DEST [Q] LLOAD $
01m0007 03422 000240000055000440003420	        ALU [Q-1] DEST [Q] LOOP [LUPERR] $      ; SHOULD JUST FALL THROUGH
01m0007 03423 030140000755000440003423	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $    ; Q SHOULD BE -1
01m0007                               	
01m0007 03424 000740014171000010000000	        D [CONST 1] DEST [Q] LLOAD $            ; R=Q=1
01m0007 03425 000240000055000440003425	        ALU [Q-1] DEST [Q] LOOP [.] $
01m0007 03426 030140000755000440003426	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007 03427 000740014171006010000000	        D [CONST 1] ROT [3] DEST [Q] LLOAD $    ; R=Q=10
01m0007 03430 000240000055000440003430	        ALU [Q-1] DEST [Q] LOOP [.] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007 03431 030140000755000440003431	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007 03432 000740014171014010000000	        D [CONST 1] ROT [6] DEST [Q] LLOAD $    ; R=Q=100
01m0007 03433 000240000055000440003433	        ALU [Q-1] DEST [Q] LOOP [.] $
01m0007 03434 030140000755000440003434	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007 03435 000740014171026010000000	        D [CONST 1] ROT [11.] DEST [Q] LLOAD $  ; R=Q=4000
01m0007 03436 000240000055000440003436	        ALU [Q-1] DEST [Q] LOOP [.] $
01m0007 03437 030140000755000440003437	        ALU [NOTQ] COND [-OBUS=0] JUMP [.] $
01m0007                               	
01m0007                               	;
01m0007                               	;Test the MAP for its function as a memory
01m0007                               	;
01m0007                               	
01m0007                               	;Will it hold bits?
01m0007 03440 640165400615000440003441	        ALU[0] DEST[MA CRYOV] NORM JUMP[. + 1] $
01m0007                               	                ;Use map location 0, EXEC space
01m0007 03441 640040000615000440000000	        ALU[0] DEST[STO-MAP] NORM PUSHJ[MAPRD] $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;See which bits stick on
01m0007 03442 010140000555000440003442	        ALU[Q] COND[OBUS=0] JUMP[.] $
01m0007                               	                ;These bits should be zero.
01m0007                               	                ;(Caution: Bit 9, NO MAP ENTRY, is inverted.)
01m0007 03443 640040000741000440000000	        ALU[-1] DEST[STO-MAP] NORM PUSHJ[MAPRD] $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;Set which bits don't come on
01m0007 03444 000140010735022220003444	        D[MASK 22] ROT[9.] ALU[D#Q] JUMP[.] $
01m0007                               	                ;Bits shown here should be one, but read back as zero.
01m0007                               	                ;(Caution: Bit 9, NO MAP ENTRY, is inverted.)
01m0007 03445 640705414571076010000000	        D[CONST 1] ROT[44 - 5] DEST[CRYOV] NORM $
01m0007                               	                ;Try USER part of map
01m0007 03446 640040000615000440000000	        ALU[0] DEST[STO-MAP] NORM PUSHJ[MAPRD] $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;See which bits stick on in user map
01m0007 03447 010140000555000440003447	        ALU[Q] COND[OBUS=0] JUMP[.] $
01m0007                               	                ;These bits should be zero.
01m0007                               	                ;(Caution: Bit 9, NO MAP ENTRY, is inverted.)
01m0007 03450 640040000741000440000000	        ALU[-1] DEST[STO-MAP] NORM PUSHJ[MAPRD] $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;Set which bits don't come on in user map
01m0007 03451 000140010735022220003451	        D[MASK 22] ROT[9.] ALU[D#Q] JUMP[.] $
01m0007                               	                ;Bits shown here should be one, but read back as zero.
01m0007                               	                ;(Caution: Bit 9, NO MAP ENTRY, is inverted.)
01m0007                               	
01m0007                               	;Simple addressing test
01m0007 03452 640165400215000440003453	        ALU[0] DEST[Q MA CRYOV] NORM JUMP[. + 1] $
01m0007                               	                ;Start with a clear slate
01m0007 03453 640700000555000440000000	MPADL1: ALU[Q] DEST[STO-MAP] NORM $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;Set contents to address
01m0007 03454 000700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] $
01m0007                               	                ;Advance to next page
01m0007 03455 670160010635000220003453	        D[MASK 22] ALU[D&Q] DEST[MA] NORM COND[-OBUS=0] JUMP[MPADL1] $
01m0007                               	                ;Check for XEND of EXEC/USER space
01m0007 03456 640705414571066010000000	        D[CONST 1] ROT[44 - 9] DEST[CRYOV] SHORT $
01m0007                               	                ;Set user mode
01m0007 03457 010140014735044010003453	        D[CONST 1] ROT[22] ALU[D#Q] COND[OBUS=0] JUMP[MPADL1] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

01m0007                               	                ;Jump if at XEND of EXEC pass
01m0007 03460 640165400215000440003461	        ALU[0] DEST[Q MA CRYOV] NORM JUMP[. + 1] $
01m0007                               	                ;Start again, this time reading
01m0007 03461 640050000555000440000000	MPADL2: ALU[Q] DEST[AR] NORM PUSHJ[MAPRD] $
01m0007                               	                ;Save data and fetch map location
01m0007 03462 670140000735000440003462	        D[AR] ALU[Q#D] NORM COND[-OBUS=0] JUMP[.] $
01m0007                               	                ;Lights show bits in error
01m0007 03463 640700000171000440000000	        D[AR] DEST[Q] SHORT $           ;Restore Q
01m0007 03464 000700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] $
01m0007                               	                ;Advance to next page
01m0007 03465 030160010635000220003461	        D[MASK 22] ALU[D&Q] DEST[MA] COND[-OBUS=0] JUMP[MPADL2] $
01m0007                               	                ;Check for XEND of EXEC/USER space
01m0007 03466 640705414571066010000000	        D[CONST 1] ROT[44 - 9] DEST[CRYOV] SHORT $
01m0007                               	                ;Set user mode
01m0007 03467 650140014735044010003461	        D[CONST 1] ROT[22] ALU[D#Q] NORM COND[OBUS=0] JUMP[MPADL2] $
01m0007                               	                ;Jump if at XEND of EXEC pass
01m0007                               	
01m0007                               	;Try single bits
01m0007                               	        D[CONST 1,,1] DEST[AR] NORM JUMP[. + 1]
01m0007 03470 640175414615001000003471	MPBTL0: ALU[0] DEST[MA CRYOV] NORM JUMP[. + 1] $
01m0007 03471 640710000571002220000000	MPBTL1: D[AR] ROT[1] MASK[22] DEST[AR] NORM $
01m0007                               	                ;Rotate right one, each half
01m0007 03472 640700000571022440000000	        D[AR] ROT[9] DEST[STO-MAP] NORM $
?ERROR - STO-MAP not a valid subfield of dest
01m0007                               	                ;Put single bit into map
01m0007                               	                ;Note, extra bit from left half should have no effect
01m0007 03473 640700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] SHORT $
01m0007 03474 670160010635000220003471	        D[MASK 22] ALU[D&Q] DEST[MA] NORM COND[-OBUS=0] JUMP[MPBTL1] $
01m0007                               	                ;Repeat for each map entry in this space
01m0007 03475 640710000571104440000000	        D[AR] ROT[42] DEST[AR] NORM $
01m0007                               	                ;Backup to beginning of this iteration. (1024=18*57-2)
01m0007                               	;Now, try reading it back
01m0007 03476 640165400615000440003477	        ALU[0] DEST[MA CRYOV] NORM JUMP[. + 1] $
01m0007 03477 640050000571002220000000	MPBTL2: D[AR] ROT[1] MASK[22] DEST[AR] NORM PUSHJ[MAPRD] $
01m0007                               	                ;Rotate right one, each half
01m0007 03500 640700000335022440000000	        D[AR] ROT[9] ALU[D#Q] DEST[Q] SHORT $
01m0007                               	                ;Do comparison, ignore extra junk for the momemnt
01m0007 03501 670140010635022220003501	        D[MASK 22] ROT[9] ALU[D&Q] NORM COND[-OBUS=0] JUMP[.] $
01m0007                               	                ;Bits in error show in lights.  AR contains what
01m0007                               	                ;it should be, ignoring bits 0:8, 27:35.  Note:
01m0007                               	                ;that bit 9 (NO MAP ENTRY) is complemented by map.
01m0007 03502 000700024171000440000000	        D[MA] DEST[Q] $
01m0007 03503 640700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] SHORT $
01m0007 03504 670160010635000220003477	        D[MASK 22] ALU[D&Q] DEST[MA] NORM COND[-OBUS=0] JUMP[MPBTL2] $
01m0007                               	                ;Repeat for each map entry in this space
01m0007 03505 025145414571066010003477	        D[CONST 1] ROT[44 - 9] DEST[CRYOV] COND[EXEC] JUMP[MPBTL2] $
01m0007                               	                ;Set user mode and repeat test if previously in exec.
01m0007 03506 640710000171106440000000	        D[AR] ROT[43] DEST[AR Q] NORM $
01m0007                               	                ;Let AR rotated left one from previous iteration
01m0007                               	                ;(1024=18*57-2, we're doing -1 this time)
01m0007 03507 670140014735001000003470	        D[CONST 1,,1] ALU[D#Q] NORM COND[-OBUS=0] JUMP[MPBTL0] $
01m0007                               	                ;Repeat this test 18 times.
01m0007                               	        
01m0007                               	;Do lonesome holes
01m0007                               	        D[CONST 1,,1] DEST[AR] NORM JUMP[. + 1]
01m0007                               	
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

02m0007                               	
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

03m0007 03510 640175414615001000003511	MPHLL0: ALU[0] DEST[MA CRYOV] NORM JUMP[. + 1] $
03m0007 03511 640710000571002220000000	MPHLL1: D[AR] ROT[1] MASK[22] DEST[AR] NORM $
03m0007                               	
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

04m0007                               	
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

05m0007                               	                ;Rotate right one, each half
05m0007 03512 640700000771022440000000	        D[AR] ROT[9] ALU[NOTD] DEST[STO-MAP] NORM $
?ERROR - STO-MAP not a valid subfield of dest
05m0007                               	                ;Put single bit into map
05m0007                               	                ;Note, extra bit from left half should have no effect
05m0007 03513 640700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] SHORT $
05m0007 03514 670160010635000220003511	        D[MASK 22] ALU[D&Q] DEST[MA] NORM COND[-OBUS=0] JUMP[MPHLL1] $
05m0007                               	                ;Repeat for each map entry in this space
05m0007 03515 640710000571104440000000	        D[AR] ROT[42] DEST[AR] NORM $
05m0007                               	                ;Backup to beginning of this iteration. (1024=18*57-2)
05m0007                               	;Now, try reading it back
05m0007 03516 640165400615000440003517	        ALU[0] DEST[MA CRYOV] NORM JUMP[. + 1] $
05m0007 03517 640050000571002220000000	MPHLL2: D[AR] ROT[1] MASK[22] DEST[AR] NORM PUSHJ[MAPRD] $
05m0007                               	                ;Rotate right one, each half
05m0007 03520 640700000375022440000000	        D[AR] ROT[9] ALU[D/#Q] DEST[Q] SHORT $
05m0007                               	                ;Do comparison, ignore extra junk for the momemnt
05m0007 03521 670140010635022220003521	        D[MASK 22] ROT[9] ALU[D&Q] NORM COND[-OBUS=0] JUMP[.] $
05m0007                               	                ;Bits in error show in lights.  AR contains complement
05m0007                               	                ;of what it should be, ignoring bits 0:8, 27:35.
05m0007                               	                ;Note that bit 9 (NO MAP ENTRY) is complemented by map.
05m0007 03522 000700024171000440000000	        D[MA] DEST[Q] $
05m0007 03523 640700014035022010000000	        D[CONST 1] ROT[9] ALU[D+Q] DEST[Q] SHORT $
05m0007 03524 670160010635000220003517	        D[MASK 22] ALU[D&Q] DEST[MA] NORM COND[-OBUS=0] JUMP[MPHLL2] $
05m0007                               	                ;Repeat for each map entry in this space
05m0007 03525 025145414571066010003517	        D[CONST 1] ROT[44 - 9] DEST[CRYOV] COND[EXEC] JUMP[MPHLL2] $
05m0007                               	                ;Set user mode and repeat test if previously in exec.
05m0007 03526 640710000171106440000000	        D[AR] ROT[43] DEST[AR Q] NORM $
05m0007                               	                ;Let AR rotated left one from previous iteration
05m0007                               	                ;(1024=18*57-2, we're doing -1 this time)
05m0007 03527 670140014735001000003510	        D[CONST 1,,1] ALU[D#Q] NORM COND[-OBUS=0] JUMP[MPHLL0] $
05m0007                               	                ;Repeat this test 18 times.
05m0007                               	        
05m0007                               	        JUMP[MPTSTEND]
05m0007                               	;Still need to be written:
05m0007                               	;       Test for CLR-MAP
05m0007                               	;       Tests page faults
05m0007                               	
05m0007                               	;Subroutine to fetch map entry
05m0007 03530 640141614571000013400000	MAPRD:  D[CONST 1] DEST[DEV-ADR] NORM SPEC[IOB-IN] $
05m0007                               	                ;Set to map and start a read
05m0007 03531 140700030171000440040000	        MAPF[4] D[IOD] DEST[Q] CYLEN[IOB-IN] $
05m0007                               	                ;Read map at current MA
05m0007 03532 640700014335066010000000	        D[CONST 1] ROT[44 - 9] ALU[D#Q] DEST[Q] SHORT $
05m0007                               	                ;Fix backward bit
05m0007 03533 640300010235022220000000	        D[MASK 22] ROT[9] ALU[D&Q] DEST[Q] NORM POPJ $
05m0007                               	                ;Get rid of extra crud and return
05m0007                               	
05m0007                               	MPTSTEND:
05m0007                               	                ;End of map test
05m0007                               	
05m0007                               	
05m0007                               	
05m0007 03534 000140000571000440002000	        JUMP START $
05m0007                               	        
05m0007                               	;Test USER/EXEC shift register
05m0007 03535 000170000215000440003536	        ALU[0] DEST[Q AR MA] JUMP[. + 1] $
05m0007 03536 000705600571022440000000	USRSH1: D[AR] ROT[9] DEST[MAP-EXEC-SR] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

05m0007                               	                ;Set USER shift register from OBUS
05m0007 03537 000740014571000040000000	        D[CONST 4] LLOAD $
05m0007 03540 670140000571000010000000	USRSH2: D[AR] MASK[1] NORM COND[-OBUS=0] JUMP[USRSH3] $
05m0007                               	                ;Jump if user expected
05m0007 03541 665140000571000440000000	        COND[-USER] NORM JUMP[USRSH4] $
05m0007                               	                ;Should be in exec mode here
05m0007 03542 000140000571000440003542	        JUMP[.] $
05m0007                               	                ;Failure in USER shift register.
05m0007 03543 645140000571000440000000	USRSH3: COND[USER] NORM JUMP[USRSH4] $
05m0007                               	                ;Should be in user mode here
05m0007 03544 000140000571000440003544	        JUMP[.] $
05m0007                               	                ;Failure in USER shift register
05m0007 03545 640704200571000440000000	USRSH4: DEST[MEMSTO] NORM $
05m0007                               	                ;As a side effect, advances user shift register
05m0007 03546 640240000571106040003540	        D[AR] ROT[43] MASK[4] NORM LOOP[USRSH2] $
05m0007                               	                ;Repeat for each position in shifter
05m0007 03547 000710000017000440000000	        ALU[Q+1] DEST[Q AR] $
05m0007                               	                ;Try next case
05m0007 03550 030140000571000040003536	        D[AR] MASK[4] COND[-OBUS=0] JUMP[USRSH1] $
05m0007                               	                ;Repeat for each pattern
05m0007                               	
05m0007                               	
05m0007                               	;-----------------------------------------------------------------------
05m0007                               	;This is a simple loop which copies the switches into the lights
05m0007                               	;It is here so that it can be patched to make special purpose
05m0007                               	;diagnostics, as well and providing a simple test for the switches,
05m0007                               	;lights and the FBUS.
05m0007                               	;-----------------------------------------------------------------------
05m0007 03551 640141600615000440003552	SWLOOP: ALU[0] DEST[DEV-ADR] NORM JUMP[. + 1] $
05m0007 03552 640702400571000443400000	        DEST[CLR-DEV-FROM-INTR] NORM SPEC[IOB-IN] $
05m0007                               	                ;Setup to read switches.  Make sure we get them!
05m0007 03553 140700030171000443420000	        MAPF[2] D[IOD] DEST[Q] CYLEN[IOB-IN] SPEC[IOB-IN] $
05m0007                               	                ;This gets the data switches, also get address switches
05m0007 03554 140730030571000440040000	        MAPF[4] D[IOD] DEST[MA AR] CYLEN[IOB-IN] $
05m0007                               	.REPEAT 20[
05m0007                               	        CONT $  ]       [
05m0007 03555 000700000571000440000000	        CONT $  ][
05m0007 03556 000700000571000440000000	        CONT $  ][
05m0007 03557 000700000571000440000000	        CONT $  ][
05m0007 03560 000700000571000440000000	        CONT $  ][
05m0007 03561 000700000571000440000000	        CONT $  ][
05m0007 03562 000700000571000440000000	        CONT $  ][
05m0007 03563 000700000571000440000000	        CONT $  ][
05m0007 03564 000700000571000440000000	        CONT $  ][
05m0007 03565 000700000571000440000000	        CONT $  ][
05m0007 03566 000700000571000440000000	        CONT $  ][
05m0007 03567 000700000571000440000000	        CONT $  ][
05m0007 03570 000700000571000440000000	        CONT $  ][
05m0007 03571 000700000571000440000000	        CONT $  ][
05m0007 03572 000700000571000440000000	        CONT $  ][
05m0007 03573 000700000571000440000000	        CONT $  ][
05m0007 03574 000700000571000440000000	        CONT $  ];Plenty of space for special hacks
05m0007 03575 640141600615000440003576	        ALU[0] DEST[DEV-ADR] NORM JUMP[. + 1] $
05m0007                               	                ;Don't trust anyone!
05m0007 03576 640702200555000443600000	        ALU[Q] DEST[IOD] NORM SPEC[IOB-OUT] $
05m0007                               	                ;Display results in lights.  (Did you turn off SEE OBUS?)
05m0007 03577 440140000555000440023551	        MAPF[2] ALU[Q] CYLEN[IOB-OUT] JUMP[SWLOOP] $
SLOE   Jan ***, 1859 00:00:03  file DSK:DIAG4.SLO  --  of -- DIAG4

05m0007                               	
05m0007                               	]
?ERROR - conditions out of phase - ] seen, should be already at top level 
05m0007                               	
%Warn    no-@  is an undefined label 
