SUBTTL	DIAGNOSTIC PARAMETERS

;ACCUMULATOR ASSIGNMENTS

;CONTROL WORDS

AROV=400000		;ARITHMETIC OVERFLOW
CRY0=200000		;CARRY 0
CRY1=100000		;CARRY 1
FOV=40000		;FLOATING OVERFLOW
BIS=20000		;BYTE INTERRUPT
USERF=10000		;USER MODE FLAG
EXIOT=4000		;USER PRIV I/O FLAG
FXU=100			;FLOATING UNDERFLOW
DCK=40			;DIVIDE CHECK


;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>

; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET REQUESTED FLAG

DEFINE	SFLAG	(A)<
	MOVSI	1,A
	JFCL	17,.+1		;RESET ALL FLAGS
	JRST	2,.+1(1)	;SET A FLAG>
SUBTTL	DIAGNOSTIC SECTION

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

PGMNAM:	ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (4) [DAKAD]
/

;BASIC INSTRUCTION TEST (3)
;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF
;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES
;IN THE FIELD.

STARTA:	JRST	.+1
C00:
;TESTING BEGINS HERE

;IF ANY LOADING PROBLEMS OCCUR, START PROGRAM HERE.

;NOTE:	AN "*" IN THE COMMENT FIELD OF AN INSTRUCTION INDICATES THAT
;	IT IS THE TESTED INSTRUCTION.

SUBTTL	TEST OF AC HARDWARE AND INDEX REGISTERS

;**********

;THIS TEST VERIFIES THAT AC1 IS ACCESSABLE
;IN THIS CASE, AC1 IS PRELOADED WITH 1.
;C(AC1) IS THEN CHECKED FOR A1.  THIS TEST PASSES IF C(AC1)=1.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY

C100:	SETZ			;CLEAR AC0
	MOVEI	1,1		;PRELOAD AC1 WITH 1
	CAIE	1,1		;PASS IF C(AC1)=1
	STOP

;**********

;THIS TEST VERIFIES THAT AC2 IS ACCESSABLE.
;IN THIS CASE, AC2 IS PRELOADED WITH 2.
;C(AC2) IS THEN CHECKED FOR 2.  THIS TEST PASSES IF C(AC2)=2.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY

C200:	MOVEI	2,2		;PRELOAD AC2 WITH 2
	CAIE	2,2		;PASS IF C(AC2)=2
	STOP

;**********
;THIS TEST VERIFIES THAT AC4 IS ACCESSABLE.
;IN THIS CASE, AC4 IS PRELOADED WITH 4.
;C(AC4) IS THEN CHECKED FOR 4.  THIS TEST PASSES IF C(AC4)=4.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY

C300:	MOVEI	4,4		;PRELOAD AC4 WITH 4
	CAIE	4,4		;PASS IF C(AC4)=4
	STOP

;**********

;THIS TEST VERIFIES THAT AC10 IS ACCESSABLE.
;IN THIS CASE, AC10 IS PRELOADED WITH 10.
;C(AC10) IS THEN CHECKED FOR 10.  THIS TEST PASSES IF C(AC10)=10.
;IF THIS TEST FAILS, THE AC HARDWARE IS PROBABLY FAULTY

C400:	MOVEI	10,10		;PRELOAD AC10 WITH 10
	CAIE	10,10		;PASS IF C(AC10)=10
	STOP

;**********
SN=500
	ZZ=-1

;THIS TEST VERIFIES THAT ALL ACS EXIST
;FIRST, EACH AC IS PRELOADED WITH ITS OWN ADDRESS;
;THEN, THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS

C500:	REPEAT	^D16,
<	ZZ=ZZ+1
	MOVEI	ZZ,ZZ		;PRELOAD EACH AC WITH ITS ADDR>
PAGE
	ZZ=20

	REPEAT	^D16,<
;THIS TEST VERIFIES THAT ALL ACS EXIST.
;FIRST, EACH AC IS PRELOADED WITH ITS OWN ADDRESS;
;THEN, THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS

SN=SN+1
	ZZ=ZZ-1
	CAIE	ZZ,ZZ		;CHECK THAT EACH AC CONTAINS ITS OWN ADDRESS
	STOP
				;IN CASE OF FAILURE, LOOP TO C500 ADDRESS

;**********
>
SN=600
	ZZ=0

;THIS TEST VERIFIES THAT AN ADDRESS WITHIN THE AC RANGE MAY BE ACCESSED AS
;EITHER AN AC OR A MEMORY LOCATION AND THAT EITHER REFERENCE REFERS TO THE
;SAME HARDWARE.  EACH AC IS PRELOADED WITH ITS ADDRESS; THEN THE CONTENTS OF EACH
;AC IS CHECKED FOR ITS ADDRESS.  IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS.

C600:	REPEAT	^D15,
<	ZZ=ZZ+1
	MOVEI	ZZ		;PRELOAD EACH AC WITH ITS ADDRESS
	MOVEM	ZZ		;BY REFERENCING EACH AC AS MEMORY.>

	ZZ=20

	REPEAT	^D15,<
;THIS TEST VERIFIES THAT AN ADDRESS WITHIN THE AC RANGE MAY BE ACCESSED AS
;EITHER AN AC OR A MEMORY LOCATION AND THAT EITHER REFERENCE REFERS TO THE
;SAME HARDWARE.  EACH AC IS PRELOADED WITH ITS ADDRESS
;THEN THE CONTENTS OF EACH AC IS CHECKED FOR ITS ADDRESS.
;IF ANY AC DOES NOT CONTAIN ITS ADDRESS, THIS TEST FAILS.

SN=SN+1
	ZZ=ZZ-1
	CAIE	ZZ,ZZ		;CHECK THAT EACH AC CONTAINS ITS OWN ADDRESS
	STOP
				;IN CASE OF FAILURE, LOOP TO C600 ADDRESS

;**********
>
SN=700
	ZZ=0

C700:	REPEAT	^D15,<
;THIS TEST VERIFIES THAT THE INDEX REGISTERS ARE ACCESSABLE.
;FIRST, AN INDEX REGISTER IS PRELOADED WITH ITS ADDRESS; THEN,
;IT IS REFERENCED AS AN INDEX REGISTER.  IF IT CONTAINS ITS ADDRESS, THIS TEST PASSES.
;THIS TEST IS REPEATED 15 TIMES IN ORDER TO TEST EACH INDEX REGISTER.

SN=SN+1
	ZZ=ZZ+1
	MOVEI	ZZ,ZZ		;PRELOAD INDEX REGISTER WITH ITS ADDRESS
	CAIE	ZZ,(ZZ)		;PASS IF INDEX REGISTER CONTAINS ITS ADDRESS
	STOP

;**********
>
SN=1000
	ZZ=0

C1000:	REPEAT	^D15,<
;THIS TEST VERIFIES THAT ALL INDEX REGISTERS INDEX CORRECTLY.
;FIRST, BOTH HALVES OF THE INDEX REGISTER ARE PRELOADED WITH ITS ADDRESS.
;THEN, THE INDEX REGISTER IS REFERENCED.  IT IS THEN CHECKED FOR ITS ADDRESS IN BOTH HALVES.
;IF IT CONTAINS ITS ADDRESS IN BOTH HALVES THIS TEST PASSES.
;THIS TEST IS REPEATED 15 TIMES IN ORDER TO TEST EACH INDEX REGISTER

SN=SN+1
	ZZ=ZZ+1
	MOVEI	ZZ,ZZ		;PRELOAD BOTH HALVES OF INDEX REG WITH ITS ADDRESS
	HRLI	ZZ,ZZ		;PASS IF INDEX REGISTER CONTAINS ITS ADDRESS
	CAME	ZZ,(ZZ)		;IN BOTH HALVES
	STOP

;**********
>
SUBTTL	TEST OF INDEX REGISTER ADDRESSING

;**********

;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A 0,
;THE FINAL RESULT IN AC3 SHOULD BE 0.  IF C(AC3)=0, THIS TEST PASSES.

C1100:	SETOM	3		;PRELOAD AC3 WITH -1,,1
	SETZM	1		;PRELOAD AC1 WITH 0
	MOVEI	2,1		;SETUP INDEX REGISTER 2 WITH 1
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	SKIPE	3		;TEST INDEXING
	STOP

;**********

SN=1200
	ZZ=0

C1200:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 1.  THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 1.
;IF C(AC3)=A FLOATING 1, THIS TEST PASSES.

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	SETOM	3		;PRELOAD AC3 WITH -1,,-1
	MOVEI	1,ZZ		;PRELOAD AC1 WITH FLOATING 1
	MOVEI	2,1		;SETUP INDEX REGISTER
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	CAIE	3,ZZ		;TEST INDEXING
	STOP

;**********
>
SN=1300
	ZZ=0

C1300:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 1, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 1.
;IF C(AC3)=A FLOATING 1, THIS TEST PASSES.

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	SETOM	3		;PRELOAD AC3 WITH -1,,-1
	MOVSI	1,ZZ		;PRELOAD AC1 WITH FLOATING 1
	MOVEI	2,1		;SETUP INDEX REGISTER
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	CAME	3,[ZZ,,0]	;TEST INDEXING
	STOP

;**********
>
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH -1,,-1,
;THE FINAL RESULT IN AC3 SHOULD BE -1,,-1.  IF C(AC3)=-1,,-1, THIS TEST PASSES.

C1400:	SETZM	3		;PRELOAD AC3 WITH 0
	SETOM	1		;PRELOAD AC1 WITH -1,,-1
	MOVEI	2,1		;SETUP INDEX REGISTER
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	CAME	3,[-1,,-1]	;TEST INDEXING
	STOP

;**********

SN=1500
	ZZ=0

C1500:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 0, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 0.
;IF C(AC3)=A FLOATING 0, THIS TEST PASSES.

SN=SN+1
	ZZ=<ZZ+ZZ+1>&777777
	IFE	<ZZ-1>,<ZZ=777776>
	SETZM	3		;PRELOAD AC3 WITH 0
	HRROI	1,ZZ		;PRELOAD AC1 WITH FLOATING 0
	MOVEI	2,1		;SETUP INDEX REGISTER
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	CAME	3,[-1,,ZZ]	;TEST INDEXING
	STOP

;**********
>
SN=1600
	ZZ=0

C1600:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, A MOVE INSTRUCTION USING INDEXING IS EXECUTED.  THE MOVE INSTRUCTION
;SHOULD PLACE THE CONTENTS OF THE LOCATION SPECIFIED BY INDEX REGISTER 2 INTO AC3.
;SINCE INDEX REGISTER 2 WAS PRELOADED WITH A 1 AND AC1 WAS PRELOADED WITH A
;FLOATING 0, THE FINAL RESULT IN AC3 SHOULD BE A FLOATING 0.
;IF C(AC3)=A FLOATING 0, THIS TEST PASSES.

SN=SN+1
	ZZ=<ZZ+ZZ+1>&777777
	IFE	<ZZ-1>,<ZZ=777776>
	SETZM	3		;PRELOAD AC3 WITH 0
	HRLOI	1,ZZ		;PRELOAD AC1 WITH FLOATING 0
	MOVEI	2,1		;SETUP INDEX REGISTER
	MOVE	3,(2)		;*FWT FROM INDEXED LOCATION
	CAME	3,[ZZ,,-1]	;TEST INDEXING
	STOP

;**********
>
;VERIFY INDEXING WHERE 'E' IS NON-ZERO

SN=1700
	ZZ=-1
	XX=-10

;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, THE INDEX REG IS SET-UP WITH MOVEI ZZ+1,ZZ-XX,
;WHERE ZZ+1 IS THE INDEX REG.  THE AC IS PRELOADED WITH ITS OWN ADDRESS, 0,,ZZ.
;CAIE IS USED TO TEST THE INDEXING OPERATION.
;IF THE RESULT IN C(AC)=XX+C(ZZ+1 - RIGHT), THIS TEST PASSES.
;XX+C(ZZ+1 - RIGHT) SHOULD = ZZ.

C1700:	REPEAT	^D15,
<SN=SN+1
	ZZ=ZZ+1
	XX=XX+3
	MOVEI	ZZ+1,ZZ-XX	;SETUP INDEX REGISTER
	MOVEI	ZZ,ZZ		;PRELOAD AC WITH 0,,ZZ
	CAIE	ZZ,XX(ZZ+1)	;*TEST INDEXING
	STOP

;**********
>
PAGE
SN=2000
	ZZ=-1
	XX=-20

;THIS TEST VERIFIES THAT INDEX REGISTER ADDRESSING FUNCTIONS CORRECTLY.
;IN THIS TEST, THE INDEX REG IS SET-UP WITH MOVEI ZZ+1,ZZ-XX,
;WHERE ZZ+1 IS THE INDEX REG.  INDEXING IS TESTED BY LOADING
;THE AC VIA MOVEI ZZ,XX(ZZ+1), WHERE XX+C(ZZ+1)=ZZ.
;IF THE RESULT IN THE AC EQUALS 0,,ZZ, THIS TEST PASSES.

C2000:	REPEAT	^D15,
<SN=SN+1
	ZZ=ZZ+1
	XX=XX+5
	MOVEI	ZZ+1,ZZ-XX	;SETUP INDEX REGISTER
	MOVEI	ZZ,XX(ZZ+1)	;*TEST INDEXING
	CAIE	ZZ,ZZ		;PASS IF C(AC)=0,,ADDRESS OF AC
	STOP

;**********
>
SUBTTL	TEST OF EXCH INSTRUCTION

;**********

;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, AC=E=0 AND C(AC)=C(E).  HENCE, THE FINAL RESULT
;IN AC0 SHOULD BE 0.  IF C(AC)=0, THE TEST PASSES.

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

;**********

;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, AC=E=-1,,-1 AND C(AC)=C(E).  HENCE, THE FINAL RESULT
;IN AC0 SHOULD BE -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

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

;**********
;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0,,-1.  HENCE, THE FINAL RESULT
;IN THE AC SHOULD BE 0,,-1 AND THE RESULT IN E SHOULD BE -1,,0,
;IF THESE RESULTS OCCUR, THE TEST PASSES.

C2400:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	MOVEI	1,-1		;PRELOAD E WITH 0,,-1
	EXCH	1		;*EXCH SHOULD PLACE 0,,-1 INTO THE AC AND -1,,0 INTO E
	CAME	1,[-1,,0]	;PASS IF C(E)=-1,,0
	STOP
C2410:	CAME	0,[0,,-1]	;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT EXCH MOVES C(E) INTO AC AND
;MOVES C(AC) INTO E.
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,0.  HENCE, THE FINAL RESULT
;IN THE AC SHOULD BE -1,,0 AND THE RESULT IN E SHOULD BE 0,,-1.
;IF THESE RESULTS OCCUR, THE TEST PASSES.

C2700:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	MOVSI	1,-1		;PRELOAD E WITH -1,,0
	EXCH	1		;*EXCH SHOULD PLACE -1,,0 INTO THE AC AND 0,,-1 INTO E
	CAIE	1,-1		;PASS IF C(E)=0,,-1
	STOP
C2710:	CAME	,[XWD -1,0]	;PASS IF C(AC)=-1,,0
	STOP

;**********
;THIS TEST IS A RELIABILITY CHECK OF EXCH.
;FIRST, AC, E ARE PRELOADED WITH 252525,,252525.  THERE, EXCH IS
;EXECUTED 7 TIMES.  THE AC IS THEN CHECKED FOR 252525,,252525.
;IF C(AC)=C(E)=252525,,252525, THIS TEST PASSES.
;IN THIS TEST AC=E=AC0

C3000:	MOVE	[252525252525]	;PRELOAD AC,E WITH 252525,,252525
	REPEAT	7,
<	EXCH			;*EXCH SHOULD PLACE 252525,,252525 INTO AC0>
	CAME	[252525252525]	;PASS IF C(AC0)=252525,,252525
	STOP

;**********
PAGE
;THIS TEST VERIFIES THAT EXCH MOVES C(AC) INTO E AND C(E) INTO THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  EXCH IS EXECUTED 7 TIMES; THEN,
;THE AC IS CHECKED FOR -1,,-1 AND E IS CHECKED FOR 0.  IF EITHER OF THESE
;RESULTS ARE NOT FOUND, THIS TEST FAILS.

C3100:	SETZ			;PRELOAD AC WITH 0
	SETO	1,0		;PRELOAD E WITH -1,,-1
	REPEAT	7,
<	EXCH	1		;*EXCH SHOULD EXCHANGE C(AC) AND C(E)>
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP
C3110:	CAME	1,[0]		;PASS IF C(E)=0
	STOP

;**********
SUBTTL	TEST OF MOVEM INSTRUCTION

;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES NOT MODIFY C(AC)
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN AC AND E SHOULD
;BE -1,,-1.  IF C(AC) AND C(E)=-1,,-1, THIS TEST PASSES

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

;**********
SUBTTL	TEST OF JFCL INSTRUCTION AND ARITHMETIC FLAGS

;**********

;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS RETURNS TO THE NEXT SEQUENTIAL INSTRUCTION
;IF JFCL SKIPS THE NEXT INSTRUCTION, THIS TEST FAILS

C3300:	MOVE	[HALT .+3]	;THIS INSTRUCTION SHOULD NOT AFFECT THE TEST
	JFCL	17,.+1		;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
	CAIA			;SKIP HALT INSTRUCTION IF JFCL PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE CRY0 FLAG.
;ADDI IS USED TO SET CRY0.  THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR CRY0.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER CRY0 WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR CRY0

C3400:	MOVE	[-1]		;PRELOAD AC WITH -1,,-1
	ADDI	1		;SET CRY0 FLAG
	JFCL	17,.+1		;*CLEAR ARITHMETIC FLAGS
	JFCL	4,.+2		;PASS IF CRY0 WAS RESET BY PREVIOUS INSTRUCTION
	SKIPA			;SKIP HALT IF CRY0 WAS CLEARED
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE CRY1 FLAG.
;ADDI IS USED TO SET CRY1.  THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR CRY1.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER CRY1 WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR CRY1

C3500:	MOVE	[-1]		;PRELOAD AC WITH -1,,-1
	ADDI	1		;SET CRY1 FLAG
	JFCL	17,.+1		;*CLEAR ARITHMETIC FLAGS
	JFCL	2,.+2		;PASS IF CRY1 WAS RESET BY PREVIOUS INSTRUCTION
	SKIPA			;SKIP HALT IF CRY1 WAS CLEARED
	STOP

;**********

;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE AROV FLAG.
;ADDI IS USED TO SET AROV.  THEN, JFCL 17,.+1 IS EXECUTED TO CLEAR AROV.
;JFCL 4,.+2 IS EXECUTED TO DETERMINE WHETHER AROV WAS RESET BY THE PREVIOUS JFCL.
;THIS TEST FAILS IF JFCL 17,.+1 DID NOT CLEAR AROV

C3600:	MOVSI	400000		;PRELOAD AC WITH -1,,-1
	ADD	[XWD 400000,0]	;SET AROV FLAG
	JFCL	17,.+1		;*CLEAR ARITHMETIC FLAGS
	JFCL	10,.+2		;PASS IF AROV WAS RESET BY PREVIOUS INSTRUCTION
	SKIPA			;SKIP HALT IF AROV WAS CLEARED
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 0, IS A NO-OP.
;IN THIS TEST, ADD IS USED TO SET CRY0.  THEN JFCL 0,.+2 IS EXECUTED.
;IF JFCL 0,.+2 DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES

C3700:	MOVSI	400000		;PRELOAD AC WITH MOST NEGATIVE NUMBER
	ADD	[-1]		;SET CRY0 FLAG
	JFCL	.+2		;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
	SKIPA			;PASS IF JFCL DID NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT JFCL 0, IS A NO-OP.
;IN THIS TEST, ADD IS USED TO SET CRY1.  THEN JFCL 0,.+2 IS EXECUTED.
;IF JFCL 0,.+2 DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES

C4000:	MOVSI	200000		;PRELOAD AC WITH MOST NEGATIVE NUMBER
	ADD	[XWD 200000,0]	;SET CRY1 FLAG
	JFCL	.+2		;*JFCL SHOULD RETURN TO NEXT SEQUENTIAL INSTRUCTION
	SKIPA			;PASS IF JFCL DID NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1.  THEN, JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET

C4100:	MOVE	[-1]		;PRELOAD AC WITH ALL ONES
	ADDI	1		;*ADDI SHOULD SET CRY0/1 FLAGS
	JFCL	17,.+2		;*JFCL SHOULD JUMP BECAUSE FLAGS ARE SET
	STOP

;**********

;THIS TEST VERIFIES THAT CAI DOES NOT CLEAR ANY ARITHMETIC FLAGS.
;FIRST, CRY0 AND CRY1 ARE SET BY ADDI; THEN CAI IS EXECUTED.
;JFCL SHOULD JUMP BECAUSE FLAGS ARE SET.  IF JFCL DOES NOT JUMP,
;THE FLAGS WERE CLEARED BY CAI.  HENCE, CAI FAILED

C4200:	MOVE	[-1]		;PRELOAD AC WITH -1,,-1
	ADDI	1		;SET CYR0/1 FLAGS
	CAI	17,17		;*CAI SHOULD NOT CLEAR FLAGS
	JFCL	17,.+2		;PASS IF CAI CLEARED FLAGS
	STOP

;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1.  THEN JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET

C4300:	MOVE	[-1]		;PRELOAD AC WITH ALL ONES
	ADDI	1		;*ADDI SHOULD SET CRY1 FLAGS
	JFCL	2,.+2		;*JFCL SHOULD JUMP BECAUSE CRY1 FLAG IS SET
	STOP

;**********

;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;IN THIS TEST, ADDI SHOULD SET CRY0 AND CRY1.  THEN, JFCL SHOULD SKIP
;BECAUSE A FLAG WAS SET BY ADDI
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET

C4400:	MOVE	[-1]		;PRELOAD AC WITH ALL ONES
	ADDI	1		;*ADDI SHOULD SET CRY0 FLAG
	JFCL	4,.+2		;*JFCL SHOULD JUMP BECAUSE CRY0 FLAG IS SET
	STOP

;**********
;THIS TEST VERIFIES THAT ADDI HAS THE ABILITY TO SET AN ARITHMETIC FLAG AND
;THAT 'JFCL 17,.+2' JUMPS WHENEVER ANY ARITHMETIC FLAG IS SET.
;BECAUSE A FLAG WAS SET BY ADD
;IF THIS TEST FAILS, ADDI COULD HAVE FAILED TO SET A FLAG OR
;JFCL COULD HAVE FAILED TO JUMP WHEN A FLAG WAS SET

C4500:	MOVSI	400000		;PRELOAD AC WITH ALL ONES
	ADD	[XWD 400000,0]	;*ADD SHOULD SET AROV FLAG
	JFCL	10,.+2		;*JFCL SHOULD JUMP BECAUSE AROV FLAG IS SET
	STOP

;**********

;THIS TEST VERIFIES THAT JFCL 17,.+1 ALWAYS CLEARS THE FLOATING OVERFLOW FLAG (FOV).
;FIRST JFCL 17,.+1 IS EXECUTED TO CLEAR FOV.  THEN, JFCL 1,.+2 IS EXECUTED TO DETERMINE
;WHETHER FOV WAS CLEARED.  IF FOV WAS CLEAR, THIS TEST PASSES

C4600:	JFCL	17,.+1		;*CLEAR ARITHMETIC FLAGS
	JFCL	1,.+2		;PASS IF FOV WAS CLEARED
	SKIPA			;SKIP HALT IF TEST PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 13, DOES NOT RESET CRY0.
;FIRST CRY0 AND CRY1 ARE SET BY ADDI; THEN, JFCL 13,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT CRY0.
;THIS TEST PASSES IF JFCL 13,.+1 DID NOT RESET CRY0.

C4700:	MOVE	[-1]		;RELOAD AC WITH -1,,-1
	ADDI	1		;SET CRY0/1
	JFCL	13,.+1		;*JFCL 13, SHOULD NOT RESET CRY0
	JFCL	4,.+2		;FAIL IF CRY 0 WAS RESET
	STOP

;**********

;THIS TEST VERIFIES THAT JFCL 15, DOES NOT RESET CRY1.
;FIRST CRY0 AND CRY1 ARE SET BY ADDI; THEN, JFCL15,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT CRY1.
;THIS TEST PASSES IF JFCL 15,.+1 DID NOT RESET CRY1.

C5000:	MOVE	[-1]		;PRELOAD AC WITH -1,,-1
	ADDI	1		;SET CRY0/1
	JFCL	15,.+1		;*JFCL15, SHOULD NOT RESET CRY0
	JFCL	2,.+2		;FAIL IF CRY1 WAS RESET
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 17, DOES NOT RESET AROV.
;FIRST AROV IS SET BY ADD; THEN, JFCL 17,.+2 IS EXECUTED
;TO CLEAR ALL ARITHMETIC FLAGS EXCEPT AROV.
;THIS TEST PASSES IF JFCL 17,.+1 DID NOT RESET AROV.

C5100:	MOVSI	400000		;PRELOAD AC WITH -1,,-1
	ADD	[XWD 400000,0]	;SET AROV
	JFCL	7,.+1		;*JFCL 17, SHOULD NOT RESET AROV
	JFCL	10,.+2		;FAIL IF AROV WAS RESET
	STOP

;**********

;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET AROV.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;AROV IS THEN CHECKED.  IF AROV IS SET, THIS TEST FAILS.

C5200:	JFCL	17,.+1		;RESET ARITHMETIC FLAGS
	SETZ			;PRELOAD AC,E WITH 0
	ADD			;*ADD SHOULD NOT SET AROV
	JFCL	10,.+2		;PASS IF AROV WAS RESET
	SKIPA			;SKIP HALT IF ADD PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET CRY0.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;CRY0 IS THEN CHECKED.  IF CRY0 IS SET, THIS TEST FAILS.


C5300:	SETZ			;RESET ARITHMETIC FLAGS
	JFCL	17,.+1		;PRELOAD AC,E WITH 0
	ADD			;*ADD SHOULD NOT SET CRY0
	JFCL	4,.+2		;PASS IF CRY0 WAS RESET
	SKIPA			;SKIP HALT IF ADD PASSED
	STOP

;**********

;THIS TEST VERIFIES THAT ADD OF 0 TO 0 WILL NOT SET CRY1.
;FIRST, ALL FLAGS ARE RESET, THEN 0 IS ADDED TO 0 VIA ADD.
;CRY1 IS THEN CHECKED.  IF CRY1 IS SET, THIS TEST FAILS.

C5400:	SETZ			;RESET ARITHMETIC FLAGS
	JFCL	17,.+1		;PRELOAD AC,E WITH 0
	ADD			;*ADD SHOULD NOT SET CRY1
	JFCL	2,.+2		;PASS IF CRY1 WAS RESET
	SKIPA			;SKIP HALT IF ADD PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT THE 30X AND THE 31X INSTRUCTION GROUPS DO NOT AFFECT
;THE ARITHMETIC FLAGS.  FIRST, THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, CAI
;AND CAM ARE EXECUTED.  THE FLAGS ARE THEN CHECKED.  IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND CAI OR CAM IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS

C5500:	JFCL	17,.+1		;CLEAR ALL FLAGS
	SETZ			;CLEAR AC,0
	CAI			;*CAI SHOULD NOT SET ANY ARITHMETIC FLAG
	CAM	[-1]		;*CAM SHOULD NOT SET ANY ARITHMETIC FLAG
	JFCL	17,.+2		;FAIL IF ANY FLAG WAS SET
	SKIPA			;SKIP HALT IF TEST PASSED
	STOP

;**********

;THIS TEST VERIFIES THAT THE BOOLEAN INSTRUCTION GROUPS DO NOT AFFECT
;THE ARITHMETIC FLAGS.  FIRST THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, XOR [0]
;AND XOR [-1] ARE EXECUTED.  THE FLAGS ARE THEN CHECKED.  IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND XOR IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS

C5600:	JFCL	17,.+1		;CLEAR ALL FLAGS
	SETO			;CLEAR AC,0
	XOR	[0]		;*XOR SHOULD NOT SET ANY ARITHMETIC FLAG
	XOR	[-1]		;*XOR SHOULD NOT SET ANY ARITHMETIC FLAG
	JFCL	17,.+2		;FAIL IF ANY FLAG WAS SET
	SKIPA			;SKIP HALT IF TEST PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT THE AOBJX INSTRUCTION GROUP DOES DO NOT AFFECT
;THE ARITHMETIC FLAGS.  FIRST THE FLAGS ARE CLEARED AND AC0 IS CLEARED; THEN, AOBJN
;AND AOBJP ARE EXECUTED.  THE FLAGS ARE THEN CHECKED.  IF ANY OF THE FLAGS ARE SET,
;THIS TEST FAILS AND AOBJN OR AOBJP IS CONSIDERED TO HAVE ERRONEOUSLY SET THE FLAGS

C5700:	SETO			;CLEAR ALL FLAGS
	JFCL	17,.+1		;CLEAR AC,0
	AOBJN	.+1		;*AOBJN SHOULD NOT SET ANY ARITHMETIC ARITHMETIC
	AOBJP	.+1		;*AOBJP SHOULD NOT SET ANY ARITHMETIC FLAG
	JFCL	17,.+2		;FAIL IF ANY FLAG WAS SET
	SKIPA			;SKIP HALT IF TST PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT SKIP DOES NOT AFFECT THE FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; THEN, SKIP IS EXECUTED.
;IF SKIP SETS AROV, CRYO, CRY1 OR FOV, THIS TEST FAILS.

C5701:	JFCL	17,.+1		;CLEAR ALL FLAGS
	SKIP	0,[-1]		;*SKIP SHOULD NOT SET ANY FLAGS
	JFCL	17,.+2		;FAIL IF ANY FLAG IS SET
	SKIPA			;PASS IF NO FLAG IS SET
	STOP

;**********

;THIS TEST VERIFIES THAT JUMP DOES NOT AFFECT THE FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE CLEARED; THEN, JUMP IS EXECUTED.
;IF JUMP SETS AROV, CRYO, CRY1 OR FOV, THIS TEST FAILS.

C5702:	JFCL	17,.+1		;CLEAR ALL FLAGS
	JUMP	0,[-1]		;*JUMP SHOULD NOT SET ANY FLAGS
	JFCL	17,.+2		;FAIL IF ANY FLAG IS SET
	SKIPA			;PASS IF NO FLAG IS SET
	STOP

;**********
SUBTTL	TEST OF JRST INSTRUCTION AND ARITHMETIC FLAGS

;**********

;THIS TEST VERIFIES THAT 'JRST, 0' DOES NOT SET ANY FLAGS.
;FIRST THE ARITHMETIC FLAGS ARE RESET; THEN, 'JRST 0,.+1' IS EXECUTED
;THE AROV,CRY0 AND CRY1 FLAGS ARE THEN CHECKED. IF ANY
;OF THESE FLAGS ARE SET, THIS TEST FAILS

C6000:	JFCL	17,.+1		;RESET ALL FLAGS
	JRST	.+1		;*JRST SHOULD NOT SET ANY FLAGS
	JFCL	16,.+2		;PASS IF NO FLAGS ARE SET
	SKIPA			;SKIP HALT IF JRST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT 'MOVE 2,2' DOES NOT SET ANY FLAGS.
;FIRST, THE ARITHMETIC FLAGS ARE RESET; THEN, 'MOVE 2,2' IS EXECUTED.
;THE FOV,AROV,CRY0 AND CRY1 FLAGS ARE THEN CHECKED.  IF ANY
;OF THESE FLAGS ARE SET, THIS TEST FAILS

C6100:	JFCL	17,.+1		;RESET ALL FLAGS
	MOVE	2,2		;*MOVE SHOULD NOT SET ANY FLAGS
	JFCL	17,.+2		;PASS IF NO FLAGS ARE SET
	SKIPA			;SKIP HALT IF MOVE PASSED
	STOP

;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 SPECIFIES THE CRY0 FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 IS SET TO SPECIFY CRY0.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET CRY0.  CRY0 IS THEN CHECKED.  IF
;CRY0 IS SET, THIS TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6200:	JFCL	17,.+1		;CLEAR ALL FLAGS
	SFLAG	CRY0		;SET CRY0 FLAG
	JFCL	4,.+2		;PASS IF CRY0 IS SET
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 CONTAIN 0.  HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS.  FIRST, THE CRY0/1, FLAGS ARE SET BY ADDI;
;THEN THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1.  IF CRY1 WAS CLEARED, THE
;TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6300:	MOVE	[-1]		;PRELOAD AC0 WITH -1,,-1
	ADDI	1		;SET CRY0/1 FLAGS
	SFLAG	0		;RESET ALL ARITHMETIC FLAGS
	JFCL	2,.+2		;PASS IF CRY1 IS RESET
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSED
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 CONTAIN 0.  HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS.  FIRST, THE CRY0/1, FLAGS ARE SET BY ADD
;THEN THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1.  IF AROV WAS CLEARED, THE
;TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6400:	MOVSI	400000		;PRELOAD AC0 WITH -1,,-1
	ADD	[-1]		;SET CRY0 AND AROV FLAGS
	SFLAG	0		;RESET ALL ARITHMETIC FLAGS
	JFCL	10,.+2		;PASS IF AROV IS RESET
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSED
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 SPECIFIES THE AROV FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY AROV.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET AROV.  AROV IS THEN CHECKED.  IF
;AROV IS SET, THIS TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6500:	SFLAG	AROV		;SET AROV FLAG
	JFCL	10,.+2		;PASS IF AROV WAS SET
	STOP

;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 SPECIFIES THE CRY1 FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY CRY1.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET CRY1.  CRY1 IS THEN CHECKED.  IF
;CRY1 IS SET, THIS TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6600:	SFLAG	CRY1		;SET CRY1 FLAG
	JFCL	2,.+2		;PASS IF CRY1 WAS SET
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 SPECIFIES THE FOV FLAG.
;FIRST, ALL FLAGS ARE RESET; THEN AC1 SET TO SPECIFY FOV.
;NEXT, JRST 2,.+1(1) IS EXECUTED TO SET FOV.  FOV IS THEN CHECKED.  IF
;FOV IS SET, THIS TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C6700:	SFLAG	FOV		;SET FOV FLAG
	JFCL	1,.+2		;PASS IF FOV WAS SET
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 0, SHOULD NEVER JUMP.
;FIRST, FOV IS SET VIA JRST2, ;THEN JFCL 0,
;IS EXECUTED.  IF JFCL 0, DOES NOT SKIP, THIS TEST PASSES

C7000:	SFLAG	FOV		;SET FOV FLAG
	JFCL	,.+2		;*JFCL SHOULD NOT JUMP
	SKIPA			;PASS IF JFCL DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 CONTAINS 0.  HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS.  FIRST, THE CRY0, FLAG IS SET BY JRST 2,.+1(1)
;WITH C(AC1)=CRY0.  THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1 WITH C(AC1)=0.
;IF CRY0 WAS CLEARED, THE TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C7100:	SFLAG	CRY0		;SET CRY0 FLAGS
	SETZ	1,		;SETUP MASK TO CLEAR ARITHMETIC FLAGS
	JRST	2,.+1(1)	;*RESET ARITHMETIC FLAGS
	JFCL	4,.+2		;PASS IF CRY0 FLAG WAS RESET
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PSSED
	STOP

;**********
;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 CONTAINS 0.  HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS.  FIRST, THE FOV, FLAG IS SET BY JRST 2,.+1(1)
;WITH C(AC1)=FOV.  THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1 WITH C(AC1)=0.
;IF FOV WAS CLEARED, THE TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C7200:	SFLAG	FOV		;SET FOV FLAG
	SETZ	1,		;SETUP MASK TO CLEAR ARITHMETIC FLAGS,
	JRST	2,.+1(1)	;*RESET ARITHMETIC FLAGS
	JFCL	1,.+2		;PASS IF FOV FLAG WAS RESET
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PSSED
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2,.+1(1) WILL SET THE ARITHMETIC FLAG
;SPECIFIED IN AC1.  IN THIS CASE, AC1 CONTAINS 0.  HENCE, JRST 2,.+1(1)
;SHOULD RESET THE ARITHMETIC FLAGS.  FIRST, THE ARITHMETIC FLAGS ARE RESET BY
;JFCL 17,.+1.  THEN, THE FLAGS SHOULD BE CLEARED BY JRST 2,.+1.
;IF ALL THE ARITHMETIC FLAGS WERE CLEARED,
;THE TEST PASSES.  OTHERWISE, JRST 2,.+1 IS FAULTY

C7300:	JFCL	17,.+1		;CLEAR FLAGS
	SETZ	1,		;SETUP MASK TO CLEAR ARITMETIC FLAGS
	JRST	2,.+1(1)	;*RESET ARITHMETIC FLAGS
	JFCL	17,.+2		;PASS IF ALL FLAGS ARE RESET
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSED
	STOP

;**********
SUBTTL	TEST OF JSP INSTRUCTION

;**********

;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS AND PC IN THE AC.
;IN THIS CASE, THE FLAGS ARE RESET; THEN, JSP IS EXECUTED.  THE AC IS THEN
;CHECKED FOR ITS CONTENTS NON-ZERO.  IF C(AC)=0, IT INDICATES
;THAT NEITHER THE FLAGS NOR THE PC WAS SAVED.  HENCE, THIS TEST FAILS.

C7400:	SETZB	1		;CLEAR AC AND SETUP MASK TO RESET FLAGS
	JRST	2,.+1(1)	;RESET FLAGS
	JSP	.+1		;*JSP SHOULD STORE FLAGS AND PC IN THE AC
	SKIPN			;PASS IF C(AC) IS NON-ZERO
	STOP			;IT DID NOT STORE ANY FLAGS OR PC

;**********

;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE PC IN THE RIGHT HALF OF THE AC.
;IN THIS CASE, THE AC IS CLEARED, THEN, JSP IS EXECUTED.  THE RIGHT HALF OF
;THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO.  IF C(AC RIGHT HALF)
;IS NON-ZERO, IT INDICATED THAT THE PC WAS SAVED; AND THIS TEST PASSES.

C7500:	SETZ			;CLEAN AC
	JSP	.+1		;*JSP SHOULD STORE THE PC IN THE AC
	TRNN	-1		;PASS IF C(AC) IN NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIST, THE AC IS CLEARED; THEN, SOME FLAGS ARE SET AND JSP IS EXECUTED.
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE FLAGS WERE SAVED.  IF C(AC-LEFT) IS NON-ZERO, THIS TEST PASSES

C7600:	SETZM	0		;CLEAR AC
	MOVSI	1,740000	;SET UP MASK TO SET FLAGS
	JRST	2,.+1(1)	;SET SOME ARITHMETIC FLAGS
	JSP	.+1		;*JSP SHOULD STORE FLAGS IN THE AC
	TLNN	-1		;PASS IF C(AC) IS NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE AROV FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE AROV FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE AROV FLAG WAS SAVED.  IF THE AROV FLAG BIT OF THE AC IS SET, THIS TEST PASSES

C7700:	SETZM	0		;CLEAR THE AC
	SFLAG	AROV		;SET AROV FLAG
	JSP	.+1		;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
	TLNN	AROV		;PASS IF AROV WAS SAVED
	STOP

;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE CRY0 FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE CRY0 FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE CRY0 FLAG WAS SAVED.  IF THE CRY0 FLAG BIT OF THE AC IS SET, THIS TEST PASSES

C10000:	SETZM	0		;CLEAR THE AC
	SFLAG	CRY0		;SET CRY0 FLAG
	JSP	.+1		;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
	TLNN	CRY0		;PASS IF CRY0 WAS SAVED
	STOP

;**********

;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE CRY1 FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE CRY1 FLAG BIT OF
;THE LEFT HALF OF THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO TO DETERMINE
;WHETHER THE FLAG WAS SAVED.  IF THE CRY1 FLAG BIT OF THE AC IS SET, THIS TEST PASSES

C10100:	SETZ			;CLEAR AC
	SFLAG	CRY1		;SET CRY1 FLAG
	JSP	.+1		;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
	TLNN	CRY1		;PASS IF AROV WAS SAVED
	STOP

;**********
;THIS TEST VERIFIES THAT JSP ALWAYS STORES THE FLAGS IN THE LEFT HALF OF THE AC.
;FRIST, THE AC IS CLEARED; THEN, THE FOV FLAG IS SET AND JSP IS EXECUTED.
;THEN, THE FOV FLAG BIT OF THE LEFT HALF OF THE AC IS CHECKED FOR
;ITS CONTENTS NON-ZERO TO DETERMINE WHETHER THE FOV FLAG WAS SAVED.
;IF THE FOV FLAG BIT OF THE AC IS SET, THIS TEST PASSES

C10200:	SETZ			;CLEAR THE AC
	SFLAG	FOV		;SET FOV FLAG
	JSP	.+1		;*JSP SHOULD SAVE THE FLAGS IN THE AC-LEFT
	TLNN	FOV		;PASS IF FOV WAS SAVED
	STOP

;**********

;THIS TEST VERIFIES THAT JSP WILL STORE ONLY FLAGS THAT EXIST.
;I.E. RESET FLAGS WILL NOT BE SET IN THE AC.  ONLY FLAGS THAT ARE
;CLEARABLE BY JRSTF WILL BE CHECKED HERE.  FIRST ALL CLEARABLE
;FLAGS ARE RESET BY JRSTF;  THEN JSP IS EXECUTED.  THE AC IS THEN CHECKED.
;IF ANY CLEARABLE FLAGS ARE SET IN THE AC, THIS TEST FAILS.

C10300:	SFLAG	0		;CLEAR ALL CLEARABLE FLAGS
	JSP	.+1		;*JSP SHOULD NOT STORE CLEARABLE FALGS
	TLNE	761777		;FAIL IF ANY CLEARABLE FLAG IS SET
	STOP

;**********
;THIS TEST VERIFIES THAT JSP ALWAYS JUMPS.
;IN THIS TEST, JSP .+2 IS EXECUTED.  IF JSP JUMPS, THE TEST PASSES;
;OTHERWISE, THIS TEST HALTS

C10400:	JSP	.+2		;*JSP SHOULD ALWAYS JUMP
	STOP

;**********
SUBTTL	TEST JRST INSTRUCTION

;**********

;THIS TEST VERIFIES THAT JRST ALWAYS JUMPS.
;IN THIS TEST, JRST .+2 IS EXECUTED.  IF JRST JUMPS, THE TEST PASSES;
;OTHERWISE, THIS TEST HALTS

C10500:	JRST	.+2		;*JRST 0, SHOULD ALWAYS JUMP
	STOP

;**********
SUBTTL	TEST OF AOBJX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT AOBJN ALWAYS ADDS 1 TO BOTH HALVES OF THE AC.
;FIRST, THE AC IS CLEARED; THEN, AOBJN IS EXECUTED AND THE AC IS CHECKED
;FOR 1,,1.  IF C(AC)=1,,1, THIS TEST PASSES.

C11200:	SETZ			;CLEAR THE AC
	AOBJN	.+1		;*AOBJN SHOULD ADD 1 TO BOTH HALVES OF THE AC
	CAME	[XWD 1,1]	;PASS IF C(AC)=1,,1
	STOP

;**********

;THIS TEST VERIFIES THAT AOBJP ALWAYS ADDS 1 TO BOTH HALVES OF THE AC.
;FIRST, THE AC IS CLEARED; THEN AOBJP IS EXECUTED AND THE AC IS CHECKED
;FOR 1,,1.  IF C(AC)=1,,1, THIS TEST PASSES.

C11300:	MOVE	[XWD 377777,377777]	;PRELOAD AC WITH 377777,,377777
	AOBJP	.+1			;*AOBJP SHOULD ADD, TO BOTH HALVES OF THE AC
	CAME	[XWD 400000,400000]	;PASS IF C(AC)=400000,400000
	STOP

;**********
;THIS TEST VERIFIES THAT AOBJN WILL NOT JUMP WHEN C(AC) IS POSITIVE
;FIRST, THE AC IS CLEARED; AND AOBJN IS EXECUTED.  AOBJN SHOULD NOT JUMP
;BECAUSE C(AC) IS POSITIVE.  IF AOBJN JUMPS, THIS TEST FAILS

C11400:	SETZ			;CLEAR THE AC
	AOBJN	.+2		;*AOBJN SHOULD NOT JUMP WHEN C(AC) IS POSITIVE
	SKIPA			;PASS IF AOBJN DOES NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT AOBJP WILL JUMP WHEN C(AC) IS POSITIVE
;FIRST, THE AC IS CLEARED; AND AOBJP IS EXECUTED.  AOBJP SHOULD JUMP
;BECAUSE C(AC) IS POSITIVE.  IF AOBJP DOES NOT JUMP, THIS TEST FAILS

C11500:	SETZ			;CLEAR THE AC
	AOBJP 	.+2		;*AOBJP SHOULD JUMP BECAUSE C(AC) IS POSITIVE
	STOP

;**********
;THIS TEST VERIFIES THAT AOBJN WILL JUMP WHEN C(AC) IS NEGATIVE
;FIRST, THE AC IS PRELOADED WITH 400000,,0; AND AOBJN IS EXECUTED.  AOBJN SHOULD JUMP
;BECAUSE C(AC) IS NEGATIVE.  IF AOBJN DOES NOT JUMP, THIS TEST FAILS

C11600:	MOVE	[XWD 400000,400000]	;PRELOAD AC WITH 400000,,400000
	AOBJN	.+2		;*AOBJN SHOULD JUMP BECAUSE C(AC) IS NEGATIVE
	STOP

;**********

;THIS TEST VERIFIES THAT AOBJP WILL NOT JUMP WHEN C(AC) IS NEGATIVE.  FIRST,
;THE AC IS PRELOADED WITH 400000,,0; AND AOBJP IS EXECUTED.  AOBJP SHOULD NOT JUMP
;BECAUSE C(AC) IS NEGATIVE.  IF AOBJP JUMPS, THIS TEST FAILS

C11700:	MOVE	[XWD 400000,400000]	;PRELOAD AC WITH 400000,,400000
	AOBJP	.+2		;*AOBJP SHOULD NOT JUMP BECAUSE C(AC) IS NEGATIVE
	SKIPA			;PASS IF AOBJP DOES NOT JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT THERE IS A CARRY FROM BIT 18 TO BIT 17 OF THE AC ON AOBJN.
;THE AC IS PRELOADED WITH -1,,-1; THEN AOBJN IS EXECUTED. AOBJN SHOULD ADD ONE
;TO BOTH HALVES OF THE AC, GENERATING A CARRY FROM BIT 18 TO BIT 17. IF A
;CARRY WAS GENERATED, THIS TEST PASSES

C12000:	SETO			;PRELOAD AC WITH -1,, -1
	AOBJN	.+1		;*AOBJN SHOULD GENERATE A CARRY FROM BIT 18 TO 17
	CAME	[1,,0]		;PASS IF C(AC)=1,,0 (CARRY WAS GENERATED)
	STOP

;**********
SUBTTL	TEST SETTING OF ARITHMETIC FLAGS VIA MOVNX AND MOVMX

;THIS TEST VERIFIES THAT MOVNI SETS CRY0 AND CRY1 FLAGS ONLY WHEN THE DATA IS 0.
;FIRST, THE ARITHMETIC FLAGS ARE RESET; THEN, MOVNI IS EXECUTED WITH DATA OF ZEROS.
;THE ARITHMETIC FLAGS ARE CHECKED.
; CRY0/1 ARE SET AND AROV AND FOV RESET, THIS TEST PASSES.

C12100:	JFCL	17,.+1		;CLEAR FLAGS
	MOVNI	0		;* MOVNI 0 SHOULD SET CRY0/1
	JCRY0	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY1 IS SET
	STOP
	JOV	.+2		;PASS IF AROV RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV RESET
	SKIPA
	STOP

;**********

;THIS TEST VERIFIES THAT MOVN WILL NOT SET ARITHMETIC FLAGS WHEN THE DATA IS -1,,-1.
;FIRST, THE FLAGS ARE RESET; THEN, MOVN [-1,,-1] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF ANY ARITHMETIC FLAG IS SET, THIS TEST FAILS.

C12200:	JFCL	17,.+1		;CLEAR FLAGS
	MOVN	[-1]		;*MOVN [-1,,-1] SHOULD SET ARITHMETIC FLAGS
	JFCL	17,.+2		;FAIL IF AN ARITHMETIC FLAG IS SET
	SKIPA			;SKIP HALT INSTRUCTION IF MOVN PASSED.
	STOP

;**********
;THIS TEST VERIFIES THAT MOVN WILL SET THE AROV AND
;CRY1 FLAGS ONLY WHEN THE DATA IS 400000,,0
;FIRST, THE FLAGS ARE RESET; THEN, MOVN [400000,,0] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF AROV AND CRY1 ARE SET AND CRY0 AND FOV ARE RESET, THIS TEST PASSES.

C12300:	JFCL	17,.+1		;CLEAR ARITHMETIC FLAGS
	MOVN	[XWD 400000,0]	;*MOVN [400000,,0] SHOULD SET AROV AND CRY1 ONLY
	JOV	.+2		;PASS IF AROV IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY0	.+2		;PASS IF CRY0 IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********

;THIS TEST VERIFIES THAT MOVM WILL SET THE AROV AND
;CRY1 FLAGS ONLY WHEN THE DATA IS 400000,,0
;FIRST, THE FLAGS ARE RESET; THEN, MOVM [400000,,0] IS EXECUTED.
;THE ARITHMETIC FLAGS ARE CHECKED.
;IF AROV AND CRY1 ARE SET AND CRY0 AND FOV ARE RESET, THIS TEST PASSES.

C12301:	JFCL	17,.+1		;CLEAR ARITHMETIC FLAGS
	MOVM	[XWD 400000,0]	;*MOVM [400000,,0] SHOULD SET AROV AND CRY1 ONLY
	JOV	.+2		;PASS IF AROV IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY0	.+2		;PASS IF CRY0 IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********
SUBTTL	TEST OF AOS AND SOS INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT AOS ADDS 1 TO MEMORY AND DOES NOT SKIP.
;FIRST, E IS CLEARED; THEN, AOS IS EXECUTED. NEXT E IS CHECKED FOR 1.
;IF C(E) IS NOT 1 OR AOS SKIPPED, THIS TEST FAILS

C12600:	SETZ			;CLEAR E
	AOS			;*AOS SHOULD ADD 1 TO C(E) AND NOT SKIP
	CAIE	1		;PASS IF C(E)=0,,1 ANDAOS DID NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT AOS ADDS 1 TO MEMORY AND DOES NOT SKIP.
;FIRST, E IS PRELOADED WITH -1,,-1; THEN, AOS IS EXECUTED. NEXT E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR AOS SKIPPED, THIS TEST FAILS

C12700:	SETO			;PRELOAD E WITH -1,,-1
	AOS			;*AOS SHOULD ADD 1 TO C(E) AND NOT SKIP
	CAIE			;PASS IF C(E)=0,,0 AND AOS DID NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT SOS SUBTRACTS 1 FROM MEMORY AND DOES NOT SKIP.
;FIRST, E IS CLEARED; THEN, SOS IS EXECUTED. NEXT E IS CHECKED FOR -1,,-1.
;IF C(E) IS NOT -1,,-1 OR SOS SKIPPED, THIS TEST FAILS

C13100:	SETZ			;CLEAR E
	SOS			;*SOS SHOULD SUBTRACT 1 FROM C(E) AND NOT SKIP
	CAME	[-1]		;PASS IF C(E)=-1,,-1 AND SOS DID NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT SOS SUBTRACTS 1 FROM MEMORY AND DOES NOT SKIP.
;FIRST, E IS PRELOADED WITH A; THEN, SOS IS EXECUTED. NEXT E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR SOS SKIPPED, THIS TEST FAILS

C13200:	MOVEI	1		;PRELOAD E WITH 1
	SOS			;*SOS SHOULD SUBTRACT 1 FROM C(E) AND DID NOT SKIP
	CAIE	0		;PASS IF C(E)=0 AND SOS DID NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT SOS SETS CRY0/1 FLAGS IF C(E) IS A NON-ZERO NUMBER OTHER
;THAN 400000,,0.  IN THIS CASE, C(E)=1.  FIRST THE FLAGS ARE RESET; THEN
;SOS IS EXECUTED.  THE  FLAGS ARE CHECKED.  IF CRY0 AND CRY1 ARE SET
;AND AROV AND FOV ARE RESET, THIS TEST PASSES.

C13300:	JFCL	17,.+1		;RESET ARITHMETIC FLAGS
	MOVEI	1		;PRELOAD E WITH 1
	SOS			;*SOS SHOULD SET CRY0/1
	JCRY0	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY1 IS SET
	STOP
	JOV	.+2		;PASS IF AROV IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********

;THIS TEST VERIFIES THAT AOS SETS CRY0 AND CRY1 FLAG IF C(E) IS -1,,-1
;FIRST THE FLAGS ARE RESET; THEN
;AOS IS EXECUTED.  THE FLAGS ARE CHECKED.
;IF CRY0 AND CRY1 ARE SET AND AROV AND FOV ARE RESET, THIS TEST PASSES.

C13400:	JFCL	17,.+1		;RESET ARITHMETIC FLAGS
	SETO			;PRELOAD E WITH 1
	AOS			;*AOS SHOULD SET CRY0 AND CRY1
	JCRY0	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY1 IS SET
	STOP
	JOV	.+2		;PASS IF AROV IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********
SUBTTL	TEST OF INTERACTION OF JFCL, JRST, AND JSP WITH ARITHMETIC FLAGS

;**********

;THIS TEST VERIFIES THAT JFCL 1, WILL ALWAYS CLEAR FOV FLAG.
;FIRST, FOV IS SET VIA JRST 2, ;THEN JFCL 1,.+1 IS EXECUTED TO CLEAR FOV.
;IF FOV WAS CLEARED, THIS TEST PASSES.

C13600:	SFLAG	FOV		;SET FOV FLAG
	JFCL	1,.+1		;*JFCL SHOULD RESET FOV
	JFCL	1,.+2		;PASS IF FOV IS RESET
	SKIPA			;SKIP HALT IF JFCL 1,.+1 PASSED
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2, CAN SET FXU AND JSP CAN SAVE FXU IN THE AC.
;FIRST, FXU IS SET VIA JRST 2, ;THEN, JSP IS EXECUTED. THE AC IS CHECKED
;FOR FXU.  IF FXU IS SET, THIS TEST PASSES; OTHERWISE, EITHER JRST 2, OR JSP FAILED.

C13700:	SFLAG	FXU		;*SET FXU FLAG
	JSP	.+1		;*STORE FXU FLAG IN AC
	TLNN	FXU		;PASS IF FXU IS SET IN THE AC
	STOP

;**********
;THIS TEST VERIFIES THAT JRST 2, CAN RESET FXU AND JSP CAN SAVE FXU IN THE AC.
;FIRST, FXU IS SET; THEN, FXU IS RESET VIA JRST 2,.  NEXT, JSP IS EXECUTED; AND
;THE AC IS CHECKED FOR FXU RESET.  IF FXU IS RESET IN THE AC, THIS TEST PASSES;
;OTHERWISE, JRST 2, FAILED TO CLEAR FXU OR JSP STORED FXU INCORECTLY.

C14000:	SFLAG	FXU		;SET FXU FLAG
	SFLAG			;*RESET FXU FLAG
	JSP	.+1		;*STORE FXU FLAG IN THE AC
	TLNE	FXU		;PASS IF FXU IS RESET IN THE AC
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2, CAN SET DCK AND JSP CAN SAVE DCK IN THE AC.
;FIRST, DCK IS SET VIA JRST 2, ;THEN JSP IS EXECUTED.  THE AC IS CHECKED
;FOR DCK.  IF DCK IS SET, THIS TEST PASSES, OTHERWISE JRST 2, OR JSP FAILED.

C14100:	SFLAG	DCK		;*SET DCK FLAG
	JSP	.+1		;*STORE FXU FLAG IN AC
	TLNN	DCK		;PASS IF FXU IS SET IN THE AC
	STOP

;**********
;THIS TEST VERIFIES THAT JRST 2, CAN RESET DCK AND JSP CAN SAVE DCK IN THE AC.
;FIRST, FXU IS SET; THEN, DCK IS RESET VIA JRST 2,.  NEXT, JSP IS EXPECTED; AND
;THE AC IS CHECKED FOR DCK RESET.  IF DCK IS RESET IN THE AC, THIS TEST PASSES;
;OTHERWISE, JRST 2, FAILED TO CLEAR DCK OR JSP STORED DCK INCORRECTLY.

C14200:	SFLAG	DCK		;SET DCK FLAG
	SFLAG			;*RESET DCK FLAG
	JSP	.+1		;*STORE DCK FLAG IN THE AC
	TLNE	DCK		;PASS IF DCK IS RESET IN THE AC
	STOP

;**********
SUBTTL	TEST OF JUMPX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT JUMPL IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS NEGATIVE.  IN THIS TEST, THE AC CONTAINS -1,,-1.  HENCE,
;JUMPL SHOULD JUMP.  IF JUMPL JUMPS, THIS TEST PASSES.

C14500:	SETO			;PRELOAD AC WITH -1,,-1
	JUMPL	.+2		;*JUMPL SHOULD JUMP BECAUSE C(AC) IS NEGATIVE
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPL IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS NEGATIVE.  IN THIS TEST, THE AC CONTAINS 0.  HENCE,
;JUMPL SHOULD NOT JUMP.  IF JUMPL DOES NOT JUMP, THIS TEST PASSES.

C14600:	SETZ			;PRELOAD AC WITH 0
	JUMPL	.+2		;*JUMPL SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPL DOES NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPE IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC)=0.  IN THIS TEST, THE AC CONTAINS 0.  HENCE,
;JUMPE SHOULD JUMP.  IF JUMPE JUMPS, THIS TEST PASSES.

C14700:	SETZ			;PRELOAD AC WITH 0
	JUMPE	.+2		;*JUMPE SHOULD JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT JUMPN IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS NON-ZERO.  IN THIS TEST, THE AC CONTAINS 1.  HENCE,
;JUMPN SHOULD JUMP.  IF JUMPN JUMPS, THIS TEST PASSES.

C15000:	MOVEI	1		;PRELOAD AC WITH 1
	JUMPN	.+2		;*JUMPN SHOULD JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPE IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC)=0.  IN THIS TEST, THE AC CONTAINS 2.  HENCE,
;JUMPL SHOULD NOT JUMP.  IF JUMPE DOES NOT JUMP, THIS TEST PASSES.

C15100:	MOVEI	2		;PRELOAD AC WITH 2
	JUMPE	.+2		;*JUMPE SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPE DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPN IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS NON-ZERO.  IN THIS TEST, THE AC CONTAINS 0.  HENCE,
;JUMPN SHOULD NOT JUMP.  IF JUMPN DOES NOT JUMP, THIS TEST PASSES.

C15200:	SETZ			;PRELOAD AC WITH 0
	JUMPN	.+2		;*JUMPN SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPN DID NOT JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT JUMPG IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS GREATER THAN 0.  IN THIS TEST, THE AC CONTAINS 1.  HENCE,
;JUMPG SHOULD JUMP.  IF JUMPG JUMPS, THIS TEST PASSES.

C15300:	MOVEI	1		;PRELOAD  AC WITH 1
	JUMPG	.+2		;*JUMPG SHOULD JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPG IS DATA DEPENDENT.  IT WILL JUMP IF AND ONLY IF
;C(AC) IS GREATER THAN 0.  IN THIS TEST, THE AC CONTAINS -1,,0.  HENCE,
;JUMPG SHOULD NOT JUMP.  IF JUMPG DOES NOT JUMP, THIS TEST PASSES.

C15400:	MOVSI	-1		;PRELOAD AC WITH -1,,0
	JUMPG	.+2		;*JUMPG SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPG DID NOT JUMP
	STOP

;**********
SUBTTL	TEST OF AOJ AND SOJ INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT AOJ ADDS 1 TO THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0; THEN, AOJ IS EXECUTED.  NEXT, THE
;AC IS CHECKED FOR 1.  IF C(AC) IS NOT 1 OR AOJ SKIPPED, THIS TEST FAILS.

C15500:	SETZ			;PRELOAD AC WITH 0
	AOJ	.+2		;*AOJ SHOULD ADD 1 TO THE AC AND NOT JUMP
	CAIE	1		;PASS IF C(AC)=1 AND AOJ DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT AOJ ADDS 1 TO THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, AOJ IS EXECUTED.  NEXT, THE
;AC IS CHECKED FOR 0.  IF C(AC) IS NOT 0 OR AOJ SKIPPED, THIS TEST FAILS.

C15600:	SETO			;PRELOAD AC WITH 0
	AOJ	.+2		;*AOJ SHOULD ADD 1 TO THE AC AND NOT JUMP
	CAIE	0		;PASS IF C(AC)=1 AND AOJ DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0; THEN, SOJ IS EXECUTED.  NEXT, THE
;AC IS CHECKED FOR -1,,-1.  IF C(AC) IS NOT -1,,-1 OR SOJ SKIPPED, THIS TEST FAILS.

C15700:	SETZ			;PRELOAD AC WITH 0
	SOJ	.+2		;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
	CAME	[-1]		;PASS IF C(AC)=-1,,-1 AND SOJ DID NOT JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, SOJ IS EXECUTED.  NEXT, THE
;AC IS CHECKED FOR -1,,-2.  IF C(AC) IS NOT -1,,-2 OR SOJ SKIPPED, THIS TEST FAILS.

C16000:	SETO			;PRELOAD AC WITH -1,,-1
	SOJ	.+2		;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
	CAME	[-2]		;PASS IF C(AC)=-1,,-2 AND SOJ DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT SOJ SUBTRACTS 1 FROM THE AC AND DOES NOT JUMP.
;FIRST, THE AC IS PRELOADED WITH 0,,1; THEN, SOJ IS EXECUTED.  NEXT, THE
;AC IS CHECKED FOR 0.  IF C(AC) IS NOT 0 OR SOJ SKIPPED, THIS TEST FAILS.

C16100:	MOVEI	1		;PRELOAD AC WITH 1
	SOJ	.+2		;*SOJ SHOULD SUBTRACT 1 FROM THE AC AND NOT JUMP
	CAIE	0		;PASS IF C(AC)=0 AND SOJ DID NOT JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT SOJ AC, FOLLOWED BY AOJ AC, HAS NO NET EFFECT ON C(AC).
;IN THIS CASE, THE AC IS PRELOADED WITH 0; THEN, SOJ AC, FOLLOWED BY AOJ.
;AC, IS REPEATED 7 TIMES.  THE AC IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, 0.
;IF C(AC)=0, THIS TEST PASSES; OTHERWISE AOJ OR SOJ FAILED.

C16200:	AC=17
	SETZ	AC,		;PRELOAD AC WITH 0
	REPEAT	^D10,<
	SOJ	AC,.		;*SOJ SHOULD SUBTRACT 1 FROM THE AC
	AOJ	AC,.		;*AOJ SHOULD ADD 1 TO THE AC>
	SKIPE	AC		;PASS IF C(AC) IS UNCHANGED. I.E. C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT SOJ SETS CRY0/1 FLAGS IF C(E) IS A NON-ZERO NUMBER OTHER
;THAN 400000,,0.  IN THIS CASE, C(E)=1.  FIRST THE FLAGS ARE RESET; THEN
;SOJ IS EXECUTED.  THE  FLAGS ARE CHECKED.  IF CRY0 AND CRY1 ARE SET
;AND AROV AND FOV ARE RESET, THIS TEST PASSES.

C16201:	JFCL	17,.+1		;RESET ARITHMETIC FLAGS
	MOVEI	1		;PRELOAD E WITH 1
	SOJ			;*SOJ SHOULD SET CRY0/1
	JCRY0	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY1 IS SET
	STOP
	JOV	.+2		;PASS IF AROV IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********

;THIS TEST VERIFIES THAT AOJ SETS CRY0 AND CRY1 FLAG IF C(E) IS -1,,-1
;FIRST THE FLAGS ARE RESET; THEN
;AOJ IS EXECUTED.  THE FLAGS ARE CHECKED.
;IF CRY0 AND CRY1 ARE SET AND AROV AND FOV ARE RESET, THIS TEST PASSES.

C16202:	JFCL	17,.+1		;RESET ARITHMETIC FLAGS
	SETO			;PRELOAD E WITH 1
	AOJ			;*AOJ SHOULD SET CRY0 AND CRY1
	JCRY0	.+2		;PASS IF CRY0 IS SET
	STOP
	JCRY1	.+2		;PASS IF CRY1 IS SET
	STOP
	JOV	.+2		;PASS IF AROV IS RESET
	SKIPA
	STOP
	JFOV	.+2		;PASS IF FOV IS RESET
	SKIPA
	STOP

;**********
SUBTTL	TEST OF MEMORY, BOTH AND SELF MODE INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT ADDM DOES NOT MODIFY C(AC)
;BOTH AC AND E ARE PRELOADED WITH -1,,-1.  THEN ADDM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED

C16400:	SETOB	1		;PRELOAD AC, E WITH -1,,-1
	ADDM	1		;*ADDM SHOULD NOT AFFECT C(AC)
	CAME	[-1]		;PASS IF C(AC) IS UNMODIFIED BY ADDM
	STOP

;**********

;THIS TEST VERIFIES THAT HRREM DOES NOT MODIFY C(AC)
;THE AC IS PRELOADED WITH 0,,-1.  THEN HRRM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED

C16500:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	HRREM	1		;*HRRM SHOULD NOT AFFECT C(AC)
	CAIE	-1		;PASS IF C(AC) IS UNMODIFIED BY HRRM
	STOP

;**********
;THIS TEST VERIFIES THAT MOVSM DOES NOT MODIFY C(AC)
;THE AC IS PRELOADED WITH 0,,-1.  THEN MOVSM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED

C16600:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	MOVSM	1		;*MOVSM SHOULD NOT AFFECT C(AC)
	CAIE	-1		;PASS IF C(AC) IS UNMODIFIED BY MOVSM
	STOP

;**********

;THIS TEST VERIFIES THAT XORM DOES NOT MODIFY C(AC)
;BOTH AC AND E ARE PRELOADED WITH -1,,-1.  THEN XORM IS EXECUTED.
;THIS TEST PASSES IF C(AC) ARE UNCHANGED

C16700:	SETOB	1		;PRELOAD AC, E WITH -1,,-1
	XORM	1		;*XORM SHOULD NOT AFFECT C(AC)
	CAME	[-1]		;PASS IF C(AC) IS UNMODIFIED BY XORM
	STOP

;**********
;THIS TEST VERIFIES THAT ADDB ADDS C(AC) TO C(E) AND PLACES THE
;RESULT IN BOTH AC AND E.  IN THIS TEST, BOTH AC AND E ARE PRELOADED
;WITH -1,,-1, THEN, ADDB IS EXECUTED.  C(AC) IS THEN COMPARED TO C(E);
;AND C(AC) IS THEN COMPARED TO -2.  IF BOTH OF THESE COMPARISONS SUCCEED, THIS
;TEST PASSES; OTHERWISE, ADDB FAILED

C17000:	SETOB	1		;PRELOAD AC, E WITH -1,,-1
	ADDB	1		;*ADDB SHOULD ADD C(AC) TO C(E) AND PLACE RESULT
				;INTO BOTH AC AND E
	CAME	1		;PASS IF C(AC)=C(E)
	STOP
	CAME	[-2]		;PASS IF C(AC)=-2
	STOP

;**********

;THIS TEST VERIFIES THAT ADDM ADDS C(AC) TO C(E) AND PLACES THE RESULT IN E
;IN THIS CASE, AC, E ARE BOTH PRELOADED WITH -1; THEN, ADDM IS EXECUTED.
;E IS THEN CHECKED FOR -2.  IF C(E)=-2, THIS TEST PASSES; OTHERWISE, ADDM FAILED

C17100:	SETOB	1		;PRELOAD AC, E WITH -1,,-1
	ADDM	1		;*ADDM SHOULD ADD C(AC) TO C(E)
	CAME	1,[-2]		;PASS IF C(E)=-2
	STOP

;**********
;THIS TEST VERIFIES THAT HLLOS PLACES ONES ON THE RIGHT HALF OF E
;BUT DOES NOT AFFECT THE LEFT HALF OF E.  IN THIS CASE,
;E IS PRELOADED WITH 0; THE, HLLOS IS EXECUTED.  THE RESULT
;IN E SHOULD BE 0,,-1.  IF C(E)=0,,-1, THIS TEST PASSES

C17200:	SETZM	1		;PRELOAD E WITH 0
	HLLOS	1		;*HLLOS SHOULD PLACE 0,,-1 INTO E
	CAIE	1,-1		;PASS IF C(E)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT MOVSS SWAPS BOTHS HALVES OF E AND
;PLACES THE RESULT IN E.  IN THIS CASE, E IS PRELOADED WITH
;-1,,0; THEN, MOVSS IS EXECUTED.  THE RESULT IN E SHOULD BE 0,,-1.
;IF C(E)=0,,-1, THIS TEST PASSES

C17300:	MOVSI	1,-1		;PRELOAD E WITH -1,,0
	MOVSS	1		;*MOVSS SHOULD PLACE 0,,-1 INTO E
	CAIE	1,-1		;PASS IF C(E)=0,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT AOS ADDS ONE TO MEMORY BUT DOES NOT SKIP
;FIRST, E IS PRELOADED WITH -1,-1; THEN, AOS IS EXECUTED.  NEXT, E IS CHECKED FOR 0.
;IF C(E) IS NOT 0 OR AOS SKIPPED, THIS TEST FAILS

C17400:	SETOB	1		;PRELOAD E WITH -1,,-1
	AOS	1		;*AOS SHOULD ADD TO C(E) AND NOT SKIP
	CAIE	1,0		;PASS IF C(E)=0,,0 AND AOS DID NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT HRLM PLACES C(AC-RIGHT) INTO E-LEFT AND DOES
;NOT MODIFY E-RIGHT.  IN THIS CASE, AC IS PRELOADED WITH 0 AND E IS PRELOADED
;WITH -1,,-1.  THEN, HRLM IS EXECUTED.  E IS THEN CHECKED FOR 0,,-1.  IF
;C(E)=0,,-1, THIS TEST PASSES

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

;**********
;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY E
;E IS PRELOADED WITH 0 AND AC IS PRELOADED WITH -1,,-1.
;HRRS IS EXECUTED; THEN E IS CHECKED.  IF C(E) DOES
;NOT CHANGE, THIS TEST PASSES

C17600:	SETO			;PRELOAD AC WITH -1,,-1
	SETZ	1,		;PRELOAD E WITH 0,,0
	HRRS	1		;*HRRS SHOULD PLACE 0,,0 INTO E
	SKIPE	1
	STOP

;**********

;THIS TEST VERIFIES THAT HRRZM PLACES C(AC-RIGHT) INTO E-RIGHT AND PLACES
;ZEROS INTO E-LEFT.  IN THIS CASE, AC=E=AC1 AND C(AC)=C(E)=-1,,0.  HRRZM
;IS EXECUTED AND AC1 IS CHECKED FOR 0.  IF AC1=0, THIS TEST PASSES.

C17700:	SETO			;PRELOAD AC0 WITH -1,,-1
	MOVSI	1,-1		;PRELOAD AC1 WITH -1,,0
	HRRZM	1,1		;*HRRZM SHOULD PLACE 0 INTO AC1
	SKIPE	1		;PASS IF C(AC1)=0
	STOP

;**********
;THIS TEST VERIFIES THAT JFCL 17,.+1 NEVER JUMPS AND DOES NOT MODIFY C(AC0).
;FIRST, AC0 IS PRELOADED; THEN, JFCL IS EXECUTED.  IF AC0 IS MODIFIED
;OR JFCL SKIPS, THIS TEST FAILS

C20000:	SETZ			;CLEAR AC0
	JFCL	17,.+1		;*JFCL SHOULD NOT JUMP OR MODIFY C(AC0).
	SKIPE			;PASS IF C(AC0)=0 AND JFCL DID NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT XORM PERFORMS THE LOGICAL EXCLUSIVE OR FUNCTION
;BETWEEN C(AC) AND C(E) AND PLACES THE RESULT INTO E
;IN THIS CASE, AC AND E ARE PRELOADED WITH -1,,-1; THEN, XORM IS
;EXECUTED.  IF THE RESULT IN E IS 0, THE TEST PASSES

C20100:	SETOB	1		;PRELOAD AC,E WITH -1,,-1
	XORM	1		;*XORM SHOULD PLACE 0 INTO E
	CAIE	1,0		;PASS IF C(E)=0
	STOP

;**********
;THIS TEST VERIFIES THAT SETZB PLACES ZEROS INTO BOTH AC AND E.
;AFTER SETZB IS EXECUTED, BOTH AC AND E ARE CHECKED
;FOR 0.  IF EITHER AC OR E CONTAINS ANY ONES, THIS TEST FAILS

C20200:	SETZB	1		;*SETZB SHOULD PLACE ZEROES IN BOTH AC AND E
	CAMN	[0]		;FAIL IF C(AC) IS NON-ZERO
	CAME	1		;FAIL IF C(E) IS NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SETAB PLACES C(AC) INTO BOTH AC AND E.
;FIRST, AC IS PRELOADED WITH -1,,-1 AND E IS PRELOADED WITH 0;
;THEN, SETAB IS EXECUTED.  BOTH AC AND E ARE CHECKED FOR -1,,-1
;IF EITHER AC OR E CONTAIN ANY ZEROS, THIS TEST FAILS.

C20300:	SETZ	1,		;PRELOAD E WITH 0
	SETO			;PRELOAD AC WITH -1,,-1
	SETAB	1		;*SETAB SHOULD PLACE -1,,-1 INTO BOTH AC AND E
	CAMN	[-1]		;FAIL IF C(AC) IS NOT -1,-1
	CAME	1		;FAIL IF C(E) IS NOT -1,,-1
	STOP

;**********
SUBTTL	XCT INSTRUCTION - BASIC TESTS

;**********

;THIS TEST VERIFIES THAT XCT WILL EXECUTE THE INSTRUCTION SPECIFIED BY C(E)
;IN THIS CASE, C(E) SPECIFIES A MOVEI INSTRUCTION
;AFTER EXECUTING MOVEI, CONTROL SHOULD RETURN TO
;THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING XCT.
;THIS TEST PASSES IF CONTROL RETURNS TO THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING XCT

C20400:	SETZB	1		;CLEAR AC0 AND AC1
	XCT	[MOVEI 1,.+2]	;*XCT SHOULD RETURN CONTROL TO NEXT INSTRUCTION
	SKIPA
	STOP

;**********

;THIS TEST VERIFIES THAT XCT WILL EXECUTE THE INSTRUCTION SPECIFIED BY C(E)
;IN THIS CASE, C(E) SPECIFIES A MOVEI INSTRUCTION.
;AFTER EXECUTING MOVEI, THE AC SPECIFIED BY MOVEI IS CHECKED FOR
;0,,1 (THE EXPECTED RESULT).  IF C(AC)=0,,1, THIS TEST PASSES

C20500:	SETZB	1		;CLEAR AC
	XCT	[MOVEI 1,1]	;*XCT OF MOVEI SHOULD PLACE 1 IN THE AC
	CAIE	1,1		;PASS IF C(AC)=1
	STOP

;**********
;THIS TEST VERIFIES THAT A NEST OF XCT INSTRUCTIONS WILL EXECUTE
;THE INSTRUCTION SPECIFIED BY THE MOST NESTED XCT AND RETURN CONTROL TO
;THE NEXT SEQUENTIAL INSTRUCTION FOLLOWING THE FIRST XCT.
;IN THIS CASE, THE EXECUTED INSTRUCTION IS MOVEI.  AFTER EXECUTING THE MOVEI,
;C(AC) IS CHECKED FOR 0,,-1 (THE EXPECTED RESULT).  IF C(AC)=0,,-1, THIS TEST PASSES

C20600:	SETZB	1		;CLEAR AC
	XCT	[XCT[XCT[XCT[XCT[MOVEI 1,-1]]]]] ;*NESTED XCT OF MOVEI
				;SHOULD PLACE 0,,-1 INTO AC
	CAIE	1,-1		;PASS IF C(AC)=0,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT XCT WILL NOT MODIFY AN AC WHICH IS NOT SPECIFIED BY THE
;EXECUTED INSTRUCTION.  IN THIS CASE, AC0 IS CLEARED AND THEN CHECKED FOR ZERO AFTER
;THE XCT INSTRUCTION IS EXECUTED.  AC0 SHOULD NOT BE MODIFIED.

C20700:	SETZB	1		;CLEAR AC0,AC1
	XCT	[MOVE 1,[-1]]	;*XCT SHOULD NOT MODIFY AC0
	SKIPE			;PASS IF AC0 WAS NOT MODIFIED
	STOP

;**********
;THIS TEST VERIFIES THAT XCT OF SKIPA SHOULD RETURN CONTROL TO THE
;SECOND SEQUENTIAL INSTRUCTION FOLLOWING XCT

C21000:	XCT	[SKIPA]		;XCT OF SKIPA SHOULD RETURN CONTROL TO .+2
	STOP

;**********
SUBTTL	INDIRECT ADDRESSING - BASIC TESTS

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 0,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS

C21100:	SETOM	1		;PRELOAD AC WITH -1,,-1
	MOVEI	7,3		;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
	SETZM	3		;PRELOAD INDIRECT ADDRESS WITH 0
	MOVE	1,@7		;*FWT FROM INDIRECT ADDRESSS SHOULD
				;PLACE 0 INTO THE AC
	SKIPE	1		;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR -1,,-1,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS

C21200:	SETZM	1		;PRELOAD AC WITH -1,,-1
	MOVEI	7,3		;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
	SETOM	3		;PRELOAD INDIRECT ADDRESS WITH -1,,-1
	MOVE	1,@7		;*FWT FROM INDIRECT ADDRESS SHOULD
				;PLACE -1,,-1 INTO THE AC
	CAME	1,[-1,,-1]	;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE WITHIN THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 707070,,707070,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS

C21300:	SETZM	1		;PRELOAD AC WITH 0
	MOVEI	7,3		;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
	MOVE	3,[707070,,707070] ;PRELOAD INDIRECT ADDRESS WITH 707070,,707070
	MOVE	1,@7		;*FWT FROM INDIRECT ADDRESS SHOULD
				;PLACE 707070,,707070 INTO THE AC
	CAME	1,[707070,,707070]	;PASS IF C(AC)=707070,,707070
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN E IS WITHIN THE AC RANGE
;AND @E IS BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 707070,,707070,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS

C21400:	JRST	.+2
	XWD	707070,707070	;INDIRECT ADDRESS AND ITS DATA
	SETZM	1		;PRELOAD AC WITH 0
	MOVEI	7,C21400+1	;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
	MOVE	1,@7		;*FWT FROM INDIRECT ADDRESS SHOULD
				;PLACE 707070,,707070 INTO AC
	CAME	1,C21400+1	;PASS IF C(AC)=707070,,707070
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A MOVE.
;AFTER MOVE IS EXECUTED, C(AC) IS CHECKED FOR 202020,,202020,
;THE INITIAL CONTENTS OF THE INDIRECT ADDRESS

C21500:	JRST	.+3
		.+1		;DIRECT ADDRESS AND ITS DATA
	XWD	202020,202020	;INDIRECT ADDRESS AND ITS DATA
	SETZM	1		;PRELOAD AC WITH 0
	MOVE	1,@C21500+1	;*FWT FROM INDIRECT ADDRESS SHOULD
				;PLACE 202020,,202020 INTO AC
	CAME	1,C21500+2	;PASS IF C(AC)=202020,,202020
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN BOTH E AND @E
;ARE BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A CAME.

C21600:	JRST	.+3
		.+1		;DIRECT ADDRESS AND ITS DATA
	XWD	272727,272727	;INDIRECT ADDRESS AND ITS DATA
	MOVE	1,C21600+2	;PRELOAD AC
	CAME	1,@C21600+1	;*CAME OF DATA FROM INDIRECT ADDRESS - NON-AC RANGE
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING WORKS WHEN E IS WITHIN THE AC RANGE
;AND @E IS BEYOND THE AC RANGE.
;THE INSTRUCTION SPECIFYING INDIRECT ADDRESSING IS A CAME.

C21700:	JRST	.+2
	XWD	252525,252525	;INDIRECT ADDRESS AND ITS DATA
	MOVEI	7,C21700+1	;SETUP DIRECT ADDRESS WITH INDIRECT ADDRESS
	MOVE	1,C21700+1	;SETUP AC
	CAME	1,@7		;*CAME IF DATA FROM INDIRECT ADDRESS - AC RANGE
	STOP

;**********
SUBTTL	TEST INDIRECT ADDRESSING WITH INDEXING

;SETUP INDEX REGISTERS

	MOVEI	1,-4
	MOVEI	3,2
	MOVEI	4,10
	MOVEI	5,1
	MOVEI	6,5
	MOVEI	7,7
	MOVEI	10,4
	MOVEI	11,-6
	MOVEI	12,5
	MOVEI	13,2

	JRST	C22000		;RESUME TEST

;INDIRECT ADDRESSING/INDEXING TEST TABLE

;;;;;;;;;;;          ;;;;;;;;;;          ;;;;;;;;;;

;DO NOT MODIFY THIS TABLE OR TESTS C21700 THRU C22600 INDEPENDENTLY !

;;;;;;;;;;          ;;;;;;;;;;          ;;;;;;;;;;

E217:		E217A(3)
E220:		@E220A
E220B:	220220,,220220
E217A:		@E221A		;E221-4
E221B:	221221,,221221
E222A:	217217,,217217		;E217A+2
E220A:		E220B
E221:		E221
E221A:		E221B
E222:		E221
E223A:	223223,,223223
E224A:		E224A(4)	;E223-6
	222222,,222222		;E222A+7
E225:		E225
		E222A(7)	;E222+5
		@E225A		;E225+2
E225B:	225225,,225225
E223:		E223
E225A:		E225B
	224224,,224224		;E224A+10
E226B:	226226,,226226
		E223A		;E223+4
E226A:		@E226A(5)	;E223+5
		E226B		;E226A+1
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E217 IS TESTED WHERE C(E217)=E217A(3) AND C(3)=0,,2.
;HENCE, THE RESULT IN THE AC SHOULD BE C(E217A+2)=217217,,217217

C22000:	SETOM	2		;INITIALIZE AC
	MOVE	2,@E217		;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E217A+2	;PASS IF C(AC)=217217,,217217
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E220 IS TESTED WHERE C(E220)=@E220A AND C(E220A)=E220B.
;HENCE, THE RESULT IN THE AC SHOULD BE C(E220B)=220220,,220220

C22100:	SETZM	2		;INITIALIZE AC
	MOVE	2,@E220		;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E220B		;PASS IF C(AC)=220220,,220220
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE,E221(1) 2,@E217 IS TESTED WHERE C(1)=-4 AND E221-4=E217A
;HENCE, THE RESULT IN THE AC SHOULD BE C(E217A)=@E221A=20,,E221A

C22200:	SETOM	2		;INITIALIZE AC
	MOVE	2,E221(1)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E217A		;PASS IF C(AC)=@E221A=20,,E221A
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,E222(6) IS TESTED WHERE C(6)=5
;HENCE, THE RESULT IN THE AC SHOULD BE C(E222+5)=E222A(7)=7,,E222A

C22300:	SETZM	2		;INITIALIZE AC
	MOVE	2,E222(6)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E222+5	;PASS IF C(AC)=E222A(7)=7,,E222A
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(10) IS TESTED WHERE C(10)=4 AND C(E223+4)=E223A
;HENCE, THE RESULT IN THE AC SHOULD BE C(E223A)=223223,,223223

C22400:	SETOM	2		;INITIALIZE AC
	MOVE	2,@E223(10)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E223A		;PASS IF C(AC)=223223,,223223
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(11) IS TESTED WHERE C(11)=-6, C(E223-6)=E224A(4) AND C(4)=10
;HENCE, THE RESULT IN THE AC SHOULD BE C(E224A+10)=224224,,224224

C22500:	SETZM	2		;INITIALIZE AC
	MOVE	2,@E223(11)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E224A+10	;PASS IF C(AC)=224224,,224224
	STOP

;**********
;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E225(13) IS TESTED WHERE C(13)=2, C(E225+2)=@E225A
;AND C(E225A)=E225B
;HENCE, THE RESULT IN THE AC SHOULD BE C(E225B)=225225,,225225

C22600:	SETOM	2		;INITIALIZE AC
	MOVE	2,@E225(13)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E225B		;PASS IF C(AC)=225225,,225225
	STOP

;**********

;THIS TEST VERIFIES THAT INDIRECT ADDRESSING IN COMBINATION WITH INDEXING FUNCTIONS CORRECTLY.
;IN THIS CASE, MOVE 2,@E223(12) IS TESTED WHERE C(12)=5, C(E223+5)=@E226A(5),
;C(5)=1 AND C(E226A+1)=E226B
;HENCE, THE RESULT IN THE AC SHOULD BE C(E226B)=226226,,226226

C22700:	SETZM	2		;INITIALIZE AC
	MOVE	2,@E223(12)	;TEST INDIRECT ADDRESSING WITH INDEXING
	CAME	2,E226B		;PASS IF C(AC)=226226,,226226
	STOP

;**********

	JRST	BEGEND