DAKAC.MAC.txt

;MACROS

; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1)
;	 TO A (JUMPA X) TO CYCLE ON FAILING INSTRUCTION

DEFINE	STOP	(A)<
	HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
	JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1)
				;TO JUMPA X(X IS THE ADDRESS OF THE FIRST
				;INSTRUCTION IN THE SUBTEST) TO LOOP ON ERROR
				;AND CHANGE HALT INSTRUCTION TO JUMPA .+1>

SUBTTL	DIAGNOSTIC SECTION

	LALL

START:	;SETZM	USER#
	;JSP	0,.+1		;GET FLAGS
	;TLNE	USERF		;IN USER MODE
	;SETOM	USER		;YES SET USER CONTROLL WORD
	;SKIPN	MONFLG		;SPECIAL USER MODE
	;SETZM	USER		;YES CLEAR USER CONTROLL WORD
	;SKIPN	USER
	;JRST	STARTA
	;SKIPL	MONCTL
	;TTCALL	3,PGMNAM		;MENTION OUR NAME
	JRST	STARTA

PGMNAM:	ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (3) [DAKAC]
/
STARTA:	JRST	.+1
SUBTTL	TEST OF LOGICAL TEST INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT TDN DOES NOT MODIFY THE AC BECAUSE
;TDN IS A NO-OP
;FIRST, THE AC IS PRELOADED WITH 0.  THEN,
;TDN IS EXECUTED.  THE AC IS THEN CHECKED FOR
;NO MODIFICATION.  IF C(AC) IS UNALTERED, THE TEST PASSES
B12600:	SETZ			;PRELOAD AC WITH 0
	TDN	[-1]		;*TDN IS A NO-OP
	CAM			;CAM IS A NO-OP.  IT IS HERE IN CASE TDN SKIPS
	CAIE			;PASS TEST IF C(AC) IS UNMODIFIED BY TDN
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD FM + EN

;**********

;THIS TEST VERIFIES THAT TSN DOES NOT MODIFY THE AC BECAUSE
;TSN IS A NO-OP
;FIRST, THE AC IS PRELOADED WITH -1.  THEN,
;TSN IS EXECUTED.  THE AC IS THEN CHECKED FOR
;NO MODIFICATION.  IF C(AC) IS UNALTERED, THIS TEST PASSES

B12700:	SETO			;PRELOAD AC WITH -1,,-1
	TSN	[XWD -1,0]	;*TSN IS A NO-OP
	CAM			;CAM IS A NO-OP.  IT IS HERE IN CASE TSN SKIPS
	CAME	[-1]		;PASS TEST IF C(AC) IS UNMODIFIED BY TSN
	STOP

;**********
;THIS TEST VERIFIES THAT TRN DOE NOT MODIFY THE AC BECAUSE
;TRN IS A NO-OP.
;FIRST, THE AC IS PRELOADED WITH 0.  THEN,
;TRN IS EXECUTED.  THE AC IS THEN CHECKED FOR
;NO MODIFICATION.  IF C(AC) IS UNALTERED, THIS TEST PASSES

B13000:	SETZ			;PRELOAD AC WITH 0
	TRN	123456		;*TRN IS A NO-OP
	CAM			;CAM IS A NO-OP.  IT IS HERE IN CASE TRN SKIPS
	CAIE			;PASS TEST IF C(AC) IS UNMODIFIED BY TRN
	STOP

;**********

;THIS TEST VERIFIES THAT TLN DOES NOT MODIFY THE AC BECAUSE
;TLN IS A NO-OP.
;FIRST,THE AC IS PRELOADED WITH -1,,-1.  THEN,
;TRN IS EXECUTED.  THE AC IS THEN CHECKED FOR
;NO MODIFICATION.  IF C(AC) IS UNALTERED, THIS TEST PASSES

B13100:	SETO			;PRELOAD AC WITH -1,,-1
	TLN	123456		;*TRN IS A NO-OP
	CAM			;CAM IS A NO-OP.  IT IS HERE IN CASE TRN SKIPS
	CAME			;PASS TEST IF C(AC) IS UNMODIFIED BY TRN
	STOP

;**********
;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC) -1,,-1, THE TEST PASSES.

B13200:	SETZ			;PRELOAD AC WITH 0
	TDO	[-1]		;*TDO SHOULD PLACE ALL ONES IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO SKIPS
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;E				SW: FCE
;0				SW: ET1
;0				ET1: BR AR EN
;0				ET1: AD BR - EN
;0				ET1: AD EQV

;**********

;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THIS AC IS CHECKED FOR ZERO.  IF C(AC) IS ZERO, THE TEST PASSES.

B13300:	SETZ			;PRELOAD AC WITH 0
	TDO			;*TDO SHOULD PLACE ALL ZERO IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO SKIPS
	SKIPE			;PASS TEST IF C(AC) ZERO
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				ET1: AD AR + EN

;**********
;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC,
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR ITS CONTENTS ZERO.  IF C(AC) IS ZERO, THE TEST PASSES.

B13400:	SETZ			;PRELOAD AC WITH 0
	TDO	[0]		;*TDO SHOULD PLACE ALL ZERO IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO SKIPS
	SKIPE			;PASS TEST IF C(AC) IS ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1.
;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

B13600:	SETO			;PRELOAD AC WITH -1,,-1
	TDO			;*TDO SHOULD PLACE ALL ONES IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO SKIPS
	CAME	[-1]		;PASS TEST IF C(AC) -1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

B14000:	SETO			;PRELOAD AC WITH -1,,-1
	TDO	[0]		;*TDO SHOULD PLACE ALL ONES IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO SKIPS
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET1: AD FM - EN
;0				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC) 0, THE TEST PASSES.

B14100:	SETZ			;PRELOAD AC WITH 0
	TDZ			;*TDZ SHOULD PLACE ALL ZERO IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD FM + EN

;**********
;THIS TEST VERIFIES THAT TDZ PLACES ZERO IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1,,-1 AND C(E)=-1,,0.
;HENCE, THE RESULT IN THE AC SHOULD BE 0,,-1.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)= 0,,-1, THE TEST PASSES.

B14200:	SETO			;PRELOAD AC WITH -1,,-1
	TDZ	[XWD -1,0]	;*TDZ SHOULD PLACE 0,,-1 IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO
	CAME	[0,-1]		;PASS TEST IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-E				SW: FCE
;-1,,-1				FC: AD AR -EN
;-1,,0				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

B14400:	SETO			;PRELOAD AC WITH -1,,-1
	TDZ			;*TDZ SHOULD PLACE ALL ZERO IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

B14500:	SETZ			;PRELOAD AC WITH 0
	TDZ	[-1]		;*TDZ SHOULD PLACE ALL ZEROS IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO
	SKIPE			;PASS TEST IS C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT TDZ PLACES ZEROS IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1.
;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

B14600:	SETO			;PRELOAD AC WITH -1,,-1
	TDZ	[0]		;*TDZ SHOULD PLACE ALL ONES IN THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDO
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP
;**********
;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=-1 AND C(E)=0,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,0.
;THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES

B14700:	SETO			;PRELOAD AC WITH -1,,-1
	TDC	[XWD 0,-1]	;*TDC SHOULD PLACE -1,,0 INTO THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDC SKIPS
	CAME	[-1,,0]		;PASS TEST IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-E				SW: FCE
;0				FC: AD AR - EN
;0,,-1				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B15000:	SETZ			;PRELOAD AC, E WITH 0
	TDC			;*TDC SHOULD PLACE 0 INTO THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDC SKIPS
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC:AD FM + EN

;**********
;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, AC=E AND C(AC)= C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST FAILS

B15400:	SETO			;PRELOAD AC WITH -1,,-1
	TDC			;*TDC SHOULD PLACE 0 INTO THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDC SKIPS
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B15500:	SETZ			;PRELOAD AC WITH 0
	TDC	[-1]		;*TDC SHOULD PLACE -1,,-1 INTO THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDC SKIPS
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				FC: AD EQV

;**********
;THIS TEST VERIFIES THAT TDC COMPLEMENTS THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT AFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE, C(AC)=-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B15600:	SETO			;PRELOAD AC WITH -1,,-1
	TDC	[0]		;*TDC SHOULD PLACE -1,,-1 INTO THE AC
	CAI			;CAI IS A NO-OP.  IT IS HERE IN CASE TDC SKIPS
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT
;SEQUENTIAL INSTRUCTION.  IF TDNA DOES NOT
;SKIP, THIS TEST FAILS.

B15700:	SETZ			;PRESET AC, E TO 0
	TDNA			;*TDNA SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: ET1
;0				FC: AB PC EN
;0				ET1: BR AR EN
;0				ET1: PC CLOCK
;0				ET2: MC INST FETCH EN

;**********
;THIS TEST VERIFIES THAT TDN NEVER SKIPS
;NEXT SEQUENTIAL INSTRUCTION.
;THIS TEST FAILS IF TDN SKIPS.

B16000:	SETO			;PRESET AC, E TO -1,,-1
	TDN			;*TDN SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDN PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE
;NEXT SEQUENTIAL INSTRUCTION.
;THIS TEST FAILS IF TDN SKIPS.

B16100:	SETZ			;PRESET AC, E TO 0
	TDN			;*TDN SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDN PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED
;BY C(E), ARE ZERO.
;IN THIS TEST C(AC) = -1..0 AND C(E) = 707070..707070.
;HENCE, TDNE SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION.
;IF TDNE SKIPS, THIS TEST FAILS

B16200:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1..0
	TDNE	[707070707070]	;*TDNE SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDNE PASSES
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				SW:FCE
;-1,,0				SW: PC CHANGE
;-1,,-1				FC: AD AR + EN
;E				ET2: MC INST FETCH EN

;**********

;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED
;BY C(E), ARE ZERO.
;IN THIS CASE, AC=E AND C(AC)=0.
;HENCE, TDNE SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION
;IF TDNE DOES NOT SKIP, THIS TEST FAILS.

B16300:	SETZ			;PRELOAD AC, E WITH 0
	TDNE			;*TDNE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: ET1
;0				ET1: PC CLOCK

;**********
;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED
;BY C(E) ARE ZERO.
;IN THIS TEST AC=E AND C(AC)=C(E)=0.  HENCE TDNN
;SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION
;IF TDNN SKIPS, THE TEST FAILS.

B16400:	SETZ			;PRELOAD AC,E WITH 0
	TDNN			;*TDNN SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT IF TDNE PASSES
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: PC CHANGE
;0				FC: AB PC EN
;0				ET2: MC INST FETCH EN

;**********

;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT
;SEQUENTIAL INSTRUCTION.  IF TDNA DOES NOT
;SKIP, THIS TEST FAILS.

B16500:	SETO			;PRESET AC, E TO 0
	TDNA			;*TDNA SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E),
;ARE ZERO
;IN THIS TEST C(AC)=-1,,0 AND C(E)=707070,,707070.  HENCE, TDNN
;SHOULD SKIP THE NEXT INSTRUCTION.  IF IT DOES NOT SKIP, THIS TEST FAILS.

B16600:	MOVE	[XWD -1,0]	;PRESET AC TO -1,,0
	TDNN	[707070707070]	;*TDNN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				SW: FCE
;-1,,0				SW: ET1
;-1,,0				ET1: PC CLOCK

;**********

;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED
;BY C(E), ARE ZERO.
;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0.  HENCE, TDNE SHOULD SKIP
;THE NEXT SEQUENTIAL INSTRUCTION.
;IF TDNE DOES NOT SKIP, THIS TEST FAILS

B16700:	SETO			;PRESET AC TO ALL ONES
	TDNE	[0]		;*TDNE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED
;BY C(E), ARE ZERO.
;IN THIS TEST C(AC)=0 AND C(E)=-1,,-1, HENCE, TDNE SHOULD SKIP
;THE NEXT SEQUENTIAL INSTRUCTION.
;IF TDNE DOES NOT SKIP, THIS TEST FAILS

B17000:	SETZ			;PRESET AC TO 0
	TDNE	[-1]		;*TDNE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				FC: AD FM + EN

;**********

;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION.
;THIS TEST FAILS IF TDN SKIPS

B17300:	SETO			;PRESET AC TO -1,,-1
	TDN	[0]		;*TDN SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDN PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT TDN NEVER SKIPS THE NEXT SEQUENTIAL INSTRUCTION.
;THIS TEST FAILS IF TDN SKIPS

B17400:	SETZ			;PRESET AC TO 0
	TDN	[-1]		;*TDN SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDN PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION
;THIS TEST FAILS IF TDNA DOES NOT SKIP

B17700:	SETO			;PRESET AC TO -1,,-1
	TDNA	[0]		;*TDNA SHOULD SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT TDNA ALWAYS SKIPS THE NEXT SEQUENTIAL INSTRUCTION
;THIS TEST FAILS IF TDNA DOES NOT SKIP

B20000:	SETZ			;PRESET AC TO 0
	TDNA	[-1]		;*TDNA SHOULD SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT TDNE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO.
;IN THIS TEST AC=E AND C(AC)=C(E)=-1,,-1.  HENCE TDNE SHOULD NOT SKIP.
;IF TDNE SKIPS, THIS TEST FAILS.

B20400:	SETO			;PRESET AC,E TO -1,,-1
	TDNE			;*TDNE SHOULD NOT SKIP
	SKIPA			;SKIP HALT IF TDNE PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO.
;IN THIS TEST, AC=E AND C(AC)=C(E)=-1,,-1.  HENCE TDNN SHOULD SKIP
;IF TDNN DOES NOT SKIP, THIS TEST FAILS

B20600:	SETO			;PRESET AC,E TO -1,,-1
	TDNN			;*TDNN SHOULD SKIP THE NEXT SEQUENTIAL INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO.
;IN THIS TEST, C(AC)=0 AND C(E)=-1,,-1.  HENCE TDNN SHOULD NOT SKIP
;IF TDNN SKIPS, THIS TEST FAILS

B20700:	SETZ			;PRESET AC TO 0
	TDNN	[-1]		;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION
	SKIPA			;SKIP HALT IF TDNN PASSES
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				FC: AD FM + EN

;**********
;THIS TEST VERIFIES THAT TDNN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN NOT ALL OF THE BITS OF THE AC, WHICH ARE MASKED BY C(E), ARE ZERO.
;IN THIS TEST, C(AC)=-1,,-1 AND C(E)=0.  HENCE TDNN SHOULD NOT SKIP
;IF TDNN SKIPS, THIS TEST FAILS

B21000:	SETO			;PRESET AC TO -1,,-1
	TDNN	[0]		;*TDNN SHOULD NOT SKIP THE NEXT SEQUENTIAL INSTRUCTION
	SKIPA			;SKIP HALT IF TDNN PASSES
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD AR + EN

;**********

;THIS TEST VERIFIES THAT TDO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY C(E) AND DOES NOT EFFECT THE UNMASKED BITS OF THE AC.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES

B21100:	SETZ			;PRELOAD AC WITH 0
	TDO	[XWD -1,0]	;*TDO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE,
;THE RESULT IN THE AC SHOULD BE 0,,-1.  THE AC IS
;CHECKED FOR 0,,-1.  THIS TEST PASSES IF C(AC)=0,,-1

B21400:	SETZ			;PRESET AC WITH 0
	TSO	[XWD -1,0]	;*TSO SHOULD PLACE 0,,-1 INTO THE AC
	CAME	[XWD 0,-1]	;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;0				SW: ET0
;0				SW: ET1
;0				FC: AD FM + EN
;0				FC: AD AR + EN
;0				ET0: AR SWAP
;0				ET0: AD FM + EN
;0				ET0: AD AR + EN
;0				ET1: BR AR EN
;0				ET1: AD BR - EN
;-1,,-1				ET1: AD AR + EN
;0				ET1: AD EQV

;**********

;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,0.  THE AC IS
;CHECKED FOR -1,,0.  THIS TEST PASSES IF C(AC)=-1,,0

B21500:	SETZ			;PRESET AC WITH 0
	TSO	[XWD 0,-1]	;*TSO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,0.  THE AC IS
;CHECKED FOR ITS CONTENTS NON-ZERO.  THIS TEST PASSES IF C(AC) IS NON-ZERO

B21600:	SETZ			;PRELOAD AC,E WITH 0
	TSO			;*TSO SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,-1.  THE AC IS
;CHECKED FOR -1,,-1.  THIS TEST PASSES IF C(AC) -1,,-1

B21700:	SETO			;PRELOAD AC,E WITH -1,,-1
	TSO			;*TSO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,0.  THE AC IS
;CHECKED FOR -1,,0.  THIS TEST PASSES IF C(AC)=-1,,0

B22200:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	TSO	[XWD 0,-1]	;*TSO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0.  HENCE,
;THE RESULT IN THE AC SHOULD BE 0,,-1.  THE AC IS
;CHECKED FOR 0,,-1.  THIS TEST PASSES IF C(AC)=0,,-1

B22300:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	TSO	[0]		;*TSO SHOULD PLACE 0,,-1 INTO THE AC
	CAME	[XWD 0,-1]	;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET1: AD FM - EN
;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MASKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,0.  THE AC IS
;CHECKED FOR -1,,0.  THIS TEST PASSES IF C(AC)=-1,,0

B22400:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	TSO	[0]		;*TSO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,-1.  THE AC IS
;CHECKED FOR -1,,-1.  THIS TEST PASSES IF C(AC)=-1,,-1

B22500:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	TSO	[-1]		;*TSO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT TSO PLACES ONES IN THE BITS OF THE AC
;WHICH ARE MARKED BY BOTH HALVES OF C(E) SWAPPED.
;THE UNMASKED BITS OF THE AC ARE NOT AFFECTED
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1.  HENCE,
;THE RESULT IN THE AC SHOULD BE -1,,-1.  THE AC IS
;CHECKED FOR -1,,-1.  THIS TEST PASSES IF C(AC)=-1,,-1

B22600:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	TSO	[-1]		;*TSO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
SUBTTL	TEST OF HWT INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B22700:	SETZ			;PRELOAD AC,E WITH 0
	HLL			;*HLL SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC: AD AR + EN
;0,,-1				FC: AD RT FM + EN

;**********

;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1,
;THIS TEST PASSES.

B23000:	SETO			;PRELOAD AC WITH -1,,-1
	HLL	[0]		;*HLL SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				SW: FCE
;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B23200:	SETO			;PRELOAD AC,E WITH -1,,-1
	HLL			;*HLL SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0,
;THIS TEST PASSES

B23400:	SETZ			;PRELOAD AC WITH 0
	HLL	[-1]		;*HLL SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0,
;THIS TEST PASSES.

B23600:	SETZ			;PRELOAD AC WITH 0
	HLL	[XWD -1,0]	;*HLL SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT HLL PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1,
;THIS TEST PASSES.

B23700:	SETO			;PRELOAD AC WITH -1,,-1
	HLL	[XWD 0,-1]	;*HLL SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B24000:	SETZ			;PRELOAD AC,E WITH 0
	HLLZ			;*HLLZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC: AD LT AR + EN

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B24300:	SETO			;PRELOAD AC WITH -1,,-1
	HLLZ	[-1]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;-1,,-1				ET2: AR LT AD EN

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO
;IF C(AC) IS NON-ZERO, THIS TEST PASSES.

B24400:	SETZ			;PRELOAD AC WITH -1,,-1
	HLLZ	[-1]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR ZERO
;IF C(AC) IS ZERO, THIS TEST PASSES.

B24500:	SETO			;PRELOAD AC WITH -1,,-1
	HLLZ	[0]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	SKIPE			;PASS IF C(AC) IS ZERO.
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR ZERO
;IF C(AC) IS ZERO, THIS TEST PASSES.

B24600:	SETZ			;PRELOAD AC WITH 0
	HLLZ	[0]		;*HLLZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC) IS ZERO.
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC.
;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B24700:	SETO			;PRELOAD AC WITH -1,,-1
	HLLZI	-1		;*HLLZI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC: AD LT AR + EN
;0,,-1				ET2: AR LT AD EN

;**********
;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC.
;IN THIS CASE C(AC)=0 AND E=0,,-1.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B25000:	SETZ			;PRELOAD AC WITH 0
	HLLZI	-1		;*HLLZI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B25100:	SETO			;PRELOAD AC WITH -1,,-1
	HLLZ	[XWD -1,0]	;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0.
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0 THIS TEST PASSES.

B25200:	SETZ			;PRELOAD AC WITH 0
	HLLZ	[XWD -1,0]	;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B25300:	MOVEI	-1		;PRELOAD AC WITH -1,,-1
	HLLZ	[-1]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0 THIS TEST PASSES.

B25400:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLLZ	[-1]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0.
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR ZERO.
;IF C(AC) IS ZERO, THIS TEST PASSES.

B25500:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HLLZ	[0]		;*HLLZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC) IS ZERO.
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR ZERO.
;IF C(AC) IS ZERO, THIS TEST PASSES.

B25600:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLLZ	[0]		;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	SKIPE			;PASS IF C(AC) IS ZERO.
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B25700:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HLLZ	[XWD -1,0]	;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC.
;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B26000:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HLLZI	-1		;*HLLZI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HLLZ PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B26100:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLLZ	[XWD -1,0]	;*HLLZ SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLLZI ALWAYS CLEARS THE AC.
;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B26200:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLLZI	-1		;*HLLZI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B26300:	SETZ			;PRELOAD AC WITH 0
	HRR			;*HRR SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				FC: AD RT AR + EN
;-1,,0				FC: AD LT FM + EN

;**********
;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B26500:	SETO			;PRELOAD AC WITH -1,,-1
	HRR			;*HRR SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				SW: FCE

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B26600:	SETO			;PRELOAD AC WITH -1,,-1
	HRR	[XWD -1,0]	;*HRR SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HRRI PLACES E INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B26700:	SETO			;PRELOAD AC WITH -1,,-1
	HRRI	-1		;*HRRI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B27000:	SETO			;PRELOAD AC WITH -1,,-1
	HRR	[0]		;*HRR SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B27100:	SETZ			;PRELOAD AC WITH 0
	HRR	[0]		;*HRR SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B27200:	SETZ			;PRELOAD AC WITH 0
	HRR	[-1]		;*HRR SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRI PLACES E INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE C(AC)=0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B27300:	SETZ			;PRELOAD AC WITH 0
	HRRI	-1		;*HRRI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD LT FM + EN

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B27400:	SETZ			;PRELOAD AC WITH 0
	HRR	[XWD -1,0]	;*HRR SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B27500:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRR	[XWD -1,0]	;*HRR SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRRI PLACES E INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE C(AC)=-1,,0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B27600:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRRI	-1		;*HRRI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRI PLACES E INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B27700:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRRI	-1		;*HRRI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRR PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B30000:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRR	[XWD -1,0]	;*HRR SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B30100:	SETZ			;PRELOAD AC,E WITH 0
	HRRZ			;*HRRZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				FC: AD RT AR + EN

;**********

;THIS TEST VERIFIES THAT HRRZI PLACES E INTO
;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES

B30400:	SETO			;PRELOAD AC WITH -1,,-1
	HRRZI	-1		;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZI PLACES E INTO
;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B30500:	SETO			;PRELOAD AC WITH -1,,-1
	HRRZI	0		;*HRRZI SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				FC: AD RT AR + EN

;**********

;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B30600:	SETO			;PRELOAD AC WITH -1,,-1
	HRRZ	[XWD -1,0]	;*HRRZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;E				SW: FCE
;-1,,0				ET2: AR RT AD EN

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B30700:	SETO			;PRELOAD AC WITH -1,,-1
	HRRZ	[-1]		;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B31000:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRRZ	[-1]		;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=0,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B31100:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRRZ	[0]		;*HRRZ SHOULD PLACE 0 INTO THE AC
	CAIE	0		;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B31200:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRRZ	[-1]		;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B31300:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRRZ	[0]		;*HRRZ SHOULD PLACE 0 INTO THE AC
	CAIE	0		;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=0,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B31400:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRRZ	[XWD -1,0]	;*HRRZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B31500:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRRZ	[XWD 0,-1]	;*HRRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRRZI PLACES E INTO
;THE RIGHT HALF OF THE AC AND CLEARS THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=0,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES

B31600:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRRZI	-1		;*HRRZI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRZ PLACES THE RIGHT HALF OF C(E) INTO
;RIGHT HALF OF THE AC AND PLACES ZEROS INTO THE LEFT HALF OF THE AC
;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B31700:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRRZ	[XWD -1,0]	;*HRRZ SHOULD PLACE 0 INTO THE AC,0]
	CAIE	0		;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B32000:	SETZ			;PRELOAD AC WITH 0
	HRL			;*HRL SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B32100:	SETO			;PRELOAD AC WITH -1,,-1
	HRL	[-1]		;*HRL SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;E,,-1				SW: FCE
;0,,-1				FC: AD RT FM + EN
;0,,-1				ET2: AR LT AR RT EN
;-1,,0				ET2: AR RT AD EN

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B32200:	SETO			;PRELOAD AC WITH -1,,-1
	HRL	[0]		;*HRL SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B32300:	SETO			;PRELOAD AC WITH -1,,-1
	HLR	[0]		;*HLR SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B32600:	SETZ			;PRELOAD AC WITH 0
	HRL	[-1]		;*HRL SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B32700:	SETZ			;PRELOAD AC WITH 0
	HLR	[-1]		;*HLR SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;-1,,-1				FC: AD LT FM + EN
;0				ET2: AR RT AR LT EN

;**********

;THIS TEST VERIFIES THAT HRLI PLACES E INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B33000:	SETZ			;PRELOAD AC WITH -1,,-1
	HRLI	-1		;*HRLI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD RT FM + EN
;0				ET2: AR LT AR RT EN

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B33100:	SETZ			;PRELOAD AC WITH -1,,-1
	HLR	[XWD -1,0]	;*HLR SHOULD PLACE -1,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B33200:	SETZ			;PRELOAD AC WITH 0
	HRL	[XWD -1,0]	;*HRL SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF
;OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0
;IF C(AC)=0, THIS TEST PASSES.

B33300:	SETZ			;PRELOAD AC WITH 0
	HLRI	-1		;*HLRI SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC:AD LT FM + EN

;**********

;THIS TEST VERIFIES THAT HRLI PLACES E INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE C(AC)=-1,,-1 AND E=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B33400:	SETO			;PRELOAD AC WITH -1,,-1
	HRLI	-1		;*HRLI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				ET2: AR RT AD EN


;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B33500:	SETO			;PRELOAD AC WITH -1,,-1
	HLR	[XWD -1,0]	;*HLR SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B33600:	SETO			;PRELOAD AC WITH -1,,-1
	HRL	[XWD -1,0]	;*HRL SHOULD PLACE 0,,-1 INTO THE AC
	CAME	[XWD 0,-1]	;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF
;OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0
;IF C(AC)=-1,,0, THIS TEST PASSES.

B33700:	SETO			;PRELOAD AC WITH -1,,-1
	HLRI	-1		;*HLRI SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B34000:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRL	[0]		;*HRL SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLRI ALWAYS CLEARS THE RIGHT HALF
;OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=0,,-1 AND E=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0
;IF C(AC)=0, THIS TEST PASSES.

B34100:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HLRI			;*HLRI SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B34200:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRL	[-1]		;*HRL SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B34300:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HLR	[-1]		;*HLR SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B34400:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRL	[0]		;*HRL SHOULD PLACE 0 INTO THE AC
	CAIE	0		;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B34500:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLR	[0]		;*HLR SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT HRL PLACES THE RIGHT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC.  THE RIGHT HALF OF THE AC IS UNAFFECTED
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B34600:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HRL	[-1]		;*HRL SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLR PLACES THE LEFT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC.  THE LEFT HALF OF THE AC IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=-1,,-1  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B34700:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLR	[-1]		;*HLR SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO
;THE LEFT HALF OF E.  THE RIGHT HALF OF E IS UNAFFECTED.
;IN THIS CASE, AC=E AND C(AC)= C(E)=0.  HENCE, THE RESULT IN E
;SHOULD BE 0.  E IS CHECKED FOR 0.  IF C(E)=0, THIS TEXT PASSES.

B35000:	SETZ			;PRELOAD AC,E WITH 0
	HLLM			;*HLLM SHOULD PLACE 0 INTO E
	SKIPE			;PASS IF C(E)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0		0		FC: AD FM + EN
;0,,-1		0,,-1		ET0: AD RT BR + EN
;B35000		0,,-1		ET0: BR AR EN
;-1,,0		0,,-1		ET0: AD LT AR + EN

;**********
;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO
;THE LEFT HALF OF E.  THE RIGHT HALF OF E IS UNAFFECTED.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN E
;SHOULD BE 0,,-1.  E IS CHECKED FOR 0,,-1. IF C(E)=0,,-1, THIS TEST PASSES.

B35500:	SETZ			;PRELOAD AC WITH 0
	SETO	1,		;PRELOAD E WITH -1,,-1
	HLLM	1		;*HLLM SHOULD PLACE 0,,-1 INTO E
	CAIE	1,- 1		;PASS IF C(E) =0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0		-1,,-1		SW: FCE PSE
;0		0		SW: ET0
;0		-1,,-1		ET0: AR AD EN
;0		0		ET2: AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HLLM PLACES THE LEFT HALF OF C(AC) INTO
;THE LEFT HALF OF E.  THE RIGHT HALF OF E IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN E
;SHOULD BE -1,,0.  E IS CHECKED FOR -1,,0. IF C(E)=-1,,0, THIS TEST PASSES

B35600:	SETO			;PRELOAD AC WITH -1,,-1
	SETZ	1,		;PRELOAD E WITH 0
	HLLM	1		;*HLLM SHOULD PLACE -1,,0 INTO E
	CAME	1,[XWD -1,0]	;PASS IF C(E) = -1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO
;THE RIGHT HALF OF E.  THE LEFT HALF OF E IS UNAFFECTED.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN E
;SHOULD BE -1,,0.  E IS CHECKED FOR -1,,0
;IF C(E) = -1,,0, THIS TEST PASSES.

B35700:	SETZ			;PRELOAD AC WITH 0
	SETO	1,		;PRELOAD E WITH -1,,-1
	HRRM	1		;*HRRM SHOULD PLACE -1,,0 INTO E
	CAME	1,[XWD -1,0]	;PASS IF C(E) = -1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0		-1,,-1		SW: FCE PSE
;0		0		SW: ET0
;0		-1,,-1		FC: AD FM + EN
;-1,,-1		-1,,-1		ET0: AD LT BR + EN
;0		-1,,-1		ET0: AD RT AR + EN
;0		0		ET0: BR AR EN
;0		-1,,-1		ET0: AR AD EN
;0		0		ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT HRRM PLACES THE RIGHT HALF OF C(AC) INTO
;THE RIGHT HALF OF E.  THE LEFT HALF OF E IS UNAFFECTED.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN E
;SHOULD BE 0,,-1.  E IS CHECKED FOR = 0,,-1
;IF C(E) = 0,,-1, THIS TEST PASSES.

B36000:	SETO			;PRELOAD AC WITH -1,,-1
	SETZ	1,		;PRELOAD E WITH 0
	HRRM	1		;*HRRM SHOULD PLACE 0,,-1 INTO E
	CAIE	1,-1		;PASS IF C(E) = 0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B36100:	SETO			;PRELOAD AC WITH -1,,-1
	HLLO			;*HLLO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS OF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,-1				SW: FCE

;**********

;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B36200:	SETZ			;PRELOAD AC WITH 0
	HLLO	[XWD 0,-1]	;*HLLO SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD LT AR + EN

;**********
;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B36300:	SETO			;PRELOAD AC,E WITH -1,,-1
	HRRO			;*HRRO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				SW: FCE

;**********

;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B36400:	SETZ			;PRELOAD AC WITH 0
	HRRO	[XWD -1,0]	;*HRRO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD RT AR + EN

;**********
;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B36500:	SETZ			;PRELOAD AC WITH 0
	HLLO	[0]		;*HLLO SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HRRO PLACES THE RIGHT HALF OF C(E) INTO
;THE RIGHT HALF OF THE AC AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES.

B36600:	SETZ			;PRELOAD AC WITH 0
	HRRO	[0]		;*HRRO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC.
;IN THIS CASE, C(AC)=0 AND E=0.
;THE RESULT IN THE AC SHOULD BE 0,,-1.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES

B37100:	SETZ			;PRELOAD AC WITH 0
	HLLOI			;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD LT AR + EN
;0				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND E=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1, THIS TEST PASSES

B37200:	SETZ			;PRELOAD AC WITH 0
	HRROI			;*HRROI SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,-1				FC: AD RT AR + EN
;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B37300:	SETZ			;PRELOAD AC WITH 0
	HLLO	[XWD -1,0]	;*HLLO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B37400:	SETZ			;PRELOAD AC WITH 0
	HRROI	-1		;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLLOI ALWAYS PLACES 0,,-1 INTO THE AC.
;IN THIS CASE, C(AC)=0 AND E=0.
;THE RESULT IN THE AC SHOULD BE 0,,-1.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES

B37500:	SETO			;PRELOAD AC WITH -1,,-1
	HLLOI			;*HLLOI SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND E=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES

B37600:	SETO			;PRELOAD AC WITH -1,,-1
	HRROI			;*HRRIO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B37700:	SETO			;PRELOAD AC WITH -1,,-1
	HLLO	[XWD -1,0]	;*HLLO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B40000:	SETO			;PRELOAD AC WITH -1,,-1
	HRROI	-1		;*HRRIO SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRROI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES ONES INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0,,-1 AND E=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0, THIS TEST PASSES

B40100:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRROI			;*HRRIO SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT HLLO PLACES THE LEFT HALF OF C(E) INTO
;THE LEFT HALF OF THE AC AND PLACES ONES INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B40200:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	HLLO	[XWD 0,-1]	;*HLLO SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRLZ PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC.
;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=0. HENCE, THE FINAL RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B40300:	SETZ			;PRELOAD AC WITH 0
	HRLZ			;*HRLZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B40400:	SETZ			;PRELOAD AC WITH 0
	HLRZ			;*HLRZ SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC
;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND E=0,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0
;IF C(AC)=-1,,0, THIS TEST PASSES.

B40700:	SETZ			;PRELOAD AC WITH 0
	HRLZI	-1		;*HRLZI SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0.
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				ET2: AR LT AR RT EN

;**********

;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B41000:	SETZ			;PRELOAD AC WITH 0
	HLRZ	[XWD -1,0]	;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;-1,,0				ET2: AR RT AR LT EN

;**********
;THIS TEST VERIFIES THAT HRLZI PLACES E INTO THE LEFT HALF OF THE AC
;AND PLACES ZEROS INTO THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE -1,,0.  THE AC IS CHECKED FOR -1,,0.
;IF C(AC)=-1,,0, THIS TEST PASSES.

B41100:	SETO			;PRELOAD AC WITH -1,,-1
	HRLZI	-1		;*HRLZI SHOULD PLACE -1,,0 INTO THE AC
	CAME	[XWD -1,0]	;PASS IF C(AC)=-1,,0.
	STOP

;**********

;THIS TEST VERIFIES THAT HLRZ PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES ZEROS INTO THE LEFT HALF OF THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST PASSES.

B41200:	SETO			;PRELOAD AC WITH -1,,-1
	HLRZ	[XWD -1,0]	;*HLRZ SHOULD PLACE 0,,-1 INTO THE AC
	CAIE	-1		;PASS IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B41500:	SETZ			;PRELOAD AC WITH 0
	HLLE			;*HLLE SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC: AD LT AR + EN

;**********

;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B41600:	SETZ			;PRELOAD AC WITH 0
	HLLE	[-1]		;*HLLE SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[XWD -1,-1]	;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;-1,,-1				ET2: AR LT AD EN
;-1,,0				ET2: AR0(1): AR RT AD EN

;**********
;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC.
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B42000:	SETZ			;PRELOAD AC WITH 0
	HRRE	[-1]		;*HRRE SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1,,-1]	;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT HLLE PLACES THE LEFT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B42200:	SETZ			;PRELOAD AC WITH 0
	HLLE	[XWD -1,0]	;*HLLE SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC.
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC.
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B42300:	SETZ			;PRELOAD AC,E WITH 0
	HRRE			;*HRRE SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;E				SW: FCE
;-1,,0				ET2: AR RT AD EN
;0,,-1				ET2: AR18(1): AR LT AD EN
;0,,-1				FC: AR RT AR + EN

;**********

;THIS TEST VERIFIES THAT HRRE PLACES THE RIGHT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC.
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC.
;IN THIS CASE C(AC)=0 AND C(E)=-1,,0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES.

B42500:	SETZ			;PRELOAD AC WITH 0
	HRRE	[XWD -1,0]	;*HRRE SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HRREI PLACES E INTO THE RIGHT HALF OF THE AC
;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(AC)=0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES.

B42700:	SETZ			;PRELOAD AC WITH 0
	HRREI	-1		;*HRREI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				ET2: AR RT AD EN
;0,,-1				ET2: AR18(1): AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,-1.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THIS TEST PASSES.

B43000:	SETO			;PRELOAD AC WITH -1,,-1
	HLLEI	-1		;*HLLEI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				FC: AD LT AR + EN
;0,,-1				ET2: AR LT AD EN

;**********
;THIS TEST VERIFIES THAT HLLEI ALWAYS CLEARS THE AC.
;IN THIS CASE, C(AC)=-1,,-1 AND E=0,,400000.
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.
;IF C(AC) = ZERO, THIS TEST PASSES.

B43100:	SETO			;PRELOAD AC WITH -1,,-1
	HLLEI	400000		;*HLLEI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0.
	STOP

;**********

;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST FAILS

B43400:	SETZ			;PRELOAD AC WITH 0
	HRLE			;*HRLE SHOULD PLACE 0 INTO THE AC
	SKIPE			;FAIL IF C(AC)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HRLEI PLACES E INTO THE LEFT HALF OF THE AC
;AND PLACES THE LEFTMOST BIT OF E INTO ALL BITS OF THE RIGHT HALF OF THE AC
;IN THIS CASE, C(AC)=0 AND E=0,,-1.  HENCE, THE RESULT IN THE AC SHOULD -1,,-1
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=1,,-1, THIS TEST PASSES.

B43500:	SETZ			;PRELOAD AC WITH 0
	HRLEI	-1		;*HRLEI SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[XWD -1,-1]	;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				ET2: AR LT AR RT EN
;-1,,0				ET2: AR 18(1): AR RT AD EN

;**********

;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST FAILS

B43600:	HRLE	[0]		;*HRLE SHOULD PLACE 0 INTO THE AC
	SKIPE			;FAIL IF C(AC)=0,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;E,,0				SW: FCE

;**********
;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST FAILS

B43700:	HRLE	[-1]		;PRELOAD AC WITH 0
	CAME	[-1]		;*HRLE SHOULD PLACE 0 INTO THE AC
	STOP			;FAIL IF C(AC)=0,,-1

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;-1,,0				ET2: AR LT AR RT EN
;-1,,0				ET2: AR18(1): AR RT AD EN

;**********

;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST FAILS

B44000:	HRLE	[XWD -1,0]	;PRELOAD AC WITH 0
	SKIPE			;*HRLE SHOULD PLACE 0 INTO THE AC
	STOP			;FAIL IF C(AC)=0,,-1

;**********
;THIS TEST VERIFIES THAT HRLE PLACES THE RIGHT HALF OF C(E)
;INTO THE LEFT HALF OF THE AC
;AND PLACES BIT 18 OF C(E) INTO ALL BITS OF THE RIGHT HALF OF THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THIS TEST FAILS

B44100:	HRLE	[XWD 0,-1]	;PRELOAD AC WITH 0
	CAME	[-1]		;*HRLE SHOULD PLACE 0 INTO THE AC
	STOP			;FAIL IF C(AC)=0,,-1

;**********

;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(AC=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES


B44200:	SETZ			;PRELOAD AC WITH 0
	HLRE			;*HLRE SHOULD PLACE 0 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(AC=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES


B44300:	SETZ			;PRELOAD AC WITH 0
	HLRE	[-1]		;*HLRE SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0				SW: FCE
;-1,,0				ET2: AR RT AR LT EN
;0,,-1				ET2: AR0(1): AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HLREI CLEARS THE AC
;IN THIS CASE C(AC)=-1,,-1 AND E=0,,-1
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THEN TEST PASSES

B44500:	SETO			;PRELOAD AC WITH -1,,-1
	HLREI	-1		;*HLREI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0,,1				ET2: AR RT AR LT EN

;**********
;THIS TEST VERIFIES THAT HLREI CLEARS THE AC
;IN THIS CASE C(AC)=0 AND E=0
;THE RESULT IN THE AC SHOULD BE 0
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES

B44600:	HLREI			;*HLREI SHOULD CLEAR THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(E)=-1,,0.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES


B44700:	HLRE	[XWD -1,0]	;*HLRE SHOULD PLACE -1,,0 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(E)=0,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

B45000:	HLRE	[XWD 0,-1]	;*HLRE SHOULD PLACE 0,,-1 INTO THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT HLRE PLACES THE LEFT HALF OF C(E)
;INTO THE RIGHT HALF OF THE AC
;AND PLACES BIT 0 OF C(E) INTO ALL BITS OF THE LEFT HALF OF THE AC
;IN THIS CASE, C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THIS TEST PASSES

B45100:	HLRE	[-1]		;*HLRE SHOULD PLACE -1,,-1 INTO THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT HLREM PLACES THE LEFT HALF OF C(AC)
;INTO THE RIGHT HALF OF E
;AND PLACES BIT 0 OF C(AC) INTO ALL BITS OF THE LEFT HALF OF E.
;IN THIS CASE, C(AC)=1,,0 AND C(E)=0.  HENCE, THE RESULT IN E SHOULD BE -1,,-1.
;E IS CHECKED FOR -1,,-1.  IF C(E)=-1,,-1, THIS TEST PASSES

B45200:	SETZ			;PRELOAD E WITH 0
	MOVE	1,[XWD -1,0]	;PRELOAD AC WITH -1,,0
	HLREM	1,		;*HLREM SHOULD PLACE -1,,-1 INTO E
	CAME	[-1]		;PASS IF C(E)=-1,,-1
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0		-1,,0		SW: SCE
;0		-1,,0		SW: ET0
;0		-1,,0		ET0: AR AD EN
;-1,,0		-1,,0		ET2: AR RT AR + EN
;0,,-1		-1,,0		ET2: AR0(1): AR LT AD EN

;**********

;THIS TEST VERIFIES THAT HRLM PLACES THE RIGHT HALF OF C(AC) INTO THE LEFT HALF OF E.
;THE RIGHT HALF OF E IS UNAFFECTED
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=0.  HENCE, THE RESULT IN E SHOULD BE -1,,0.
;E IS CHECKED FOR -1,,0.  IF C(E)=-1,,0, THIS  TEST PASSES.

B45400:	SETZ			;PRELOAD E WITH 0
	MOVEI	1,-1		;PRELOAD AC WITH 0,,-1
	HRLM	1,		;*HRLM SHOULD PLACE -1,,0 INTO E
	CAME	[XWD -1,0]	;PASS IF C(E)=-1,,0
	STOP

;*****     FAILURE ANALYSIS     *****
;C(AC0)		C(AC1)		FAILING SIGNAL

;0		0,,-1		SW: FCE PSE
;0,,-1		0,,-1		SW: ET0
;-1,,-1		0,,-1		ET0: AD RT BR + EN
;-1,,B45400	0,,-1		ET0: BR AR EN
;0		0,,-1		ET0: AR AD EN
;0		0,,-1		ET2: AR LT AR RT EN

;**********
SUBTTL	SUPPLEMENTARY ADDER TESTS - FLT 1 + 0

;**********

SN=45500
	XX=0

B45500:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE
;IS THE FLOATING ONE.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=XX+XX
	IFE	XX,<XX=1>
	HRRZI	XX		;PRELOAD AC WITH FLOATING ONE
	ADD	[0]		;ADD ZERO TO A FLOATING ONE
	CAME	[XX]		;CHECK ADDER UPON FAILURE
	STOP

;**********
>
PAGE
	XX=0

	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A ZERO ADDED TO A FLOATING ONE
;IS THE FLOATING ONE.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=XX+XX
	IFE	XX,<XX=1>
	HRLZI	XX		;PRELOAD AC WITH FLOATING ONE
	ADD	[0]		;ADD ZERO TO A FLOATING ONE
	CAME	[XX,,0]		;CHECK ADDER UPON FALIRE
	STOP

;**********
>
SUBTTL	SUPPLEMENTARY ADDER TESTS - O + FLT 0

;**********

SN=45600
B45600:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO
;IS THE FLOATING ZERO.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=<XX+XX+1>&777777
	IFE	<XX-1>,<XX=777776>
	SETZ			;PRELOAD AC WITH 0
	ADD	[-1,,XX]	;ADD A FLOATING ZERO TO ZERO
	CAME	[-1,,XX]	;CHECK ADDER UPON FAILURE
	STOP

;**********
>
PAGE
	XX=0

	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO ADDED TO A ZERO
;IS THE FLOATING ZERO.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=<XX+XX+1>&777777
	IFE	<XX-1>,<XX=777776>
	SETZ			;PRELOAD AC WITH 0
	ADD	[XX,,-1]	;ADD A FLOATING ZERO TO ZERO
	CAME	[XX,,-1]	;CHECK ADDER UPON FAILURE
	STOP

;**********
>
SUBTTL	SUPPLEMENTARY ADDER TESTS - FLT 1 + FLT 1

;**********

SN=45700
	XX=0

B45700:	REPEAT	^D17,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE
;ADDED TO A FLOATING ONE IS A FLOATING ONE
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=XX+XX
	IFE	XX,<XX=1>
	HRRZI	XX		;PRELOAD AC WITH A FLOATING ONE
	ADD	[XX]		;ADD A FLOATING ONE TO ITSELF
	CAME	[XX+XX]		;CHECK ADDER UPON FAILURE
	STOP

;**********
>
PAGE
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE
;ADDED TO A FLOATING ONE IS A FLOATING ONE
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.
SN=SN+1
	XX=XX+XX
	HRRZI	XX		;PRELOAD AC WITH A FLOATING ONE
	ADD	[XX]		;ADD A FLOATING ONE TO ITSELF
	CAME	[1,,0]		;CHECK ADDRESS UPON FAILURE
	STOP

;**********

	XX=0

	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ONE
;ADDED TO A FLOATING ONE IS A FLOATING ONE
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ONE.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ONE THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=XX+XX
	IFE	XX,<XX=1>
	HRLZI	XX		;PRELOAD AC WITH A FLOATING ONE
	ADD	[XX,,0]		;ADD A FLOATING ONE TO ITSELF
	CAME	[XX+XX,,0]	;CHECK ADDER UPON FAILURE
	STOP

;**********
>
SUBTTL	SUPPLEMENTARY ADDER TESTS - FLT 0 + 0FLT

;**********

SN=46000
	XX=0

B46000:	REPEAT	^D17,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO
;ADDED TO A FLOATING ZERO IS A FLOATING ZERO
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=<XX+XX+1>&777777
	IFE	<XX-1>,<XX=777776>
	HRROI	XX		;PRELOAD AC WITH A FLOATING ZERO
	ADD	[-1,,XX]	;ADD A FLOATING ZERO TO ITSELF
	CAME	[-1,,<XX+XX>&777777]	;CHECK ADDER UPON FAILURE
	STOP

;**********
>
PAGE
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO
;ADDED TO A FLOATING ZERO IS A FLOATING ZERO
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=<XX+XX+1>&777777
	HRROI	XX		;PRELOAD AC WITH A FLOATING ZERO
	ADD	[-1,,XX]	;ADD A FLOATING ZERO TO ITSELF
	CAME	[-2,,-2]	;CHECK ADDER UPON FAILURE
	STOP

;**********

	XX=0

	REPEAT	^D18,<
;THIS TEST VERIFIES THAT THE RESULT OF A FLOATING ZERO
;ADDED TO A FLOATING ZERO IS A FLOATING ZERO
;PLACED ONE BIT POSITION LEFT OF THE ORIGINAL FLOATING ZERO.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A ZERO THRU ALL 36 BITS OF THE ADDER.
;THIS TEST IS DESIGNED TO TEST THE ADDER AND RELATED DATA PATHS ONLY.

SN=SN+1
	XX=<XX+XX+1>&777777
	IFE	<XX-1>,<XX=777776>
	HRLOI	XX		;PRELOAD AC WITH A FLOATING ZERO
	ADD	[XX,,-1]	;ADD A FLOATING ZERO TO ITSELF
	CAME	[XX+XX+1,,-2]	;CHECK ADDER UPON FAILURE
	STOP

;**********
>
	;JRST	BEGEND