;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	STARTA
	;SKIPL	MONCTL
	;TTCALL	3,PGMNAM	;MENTION OUR NAME
	JRST	STARTA

PGMNAM:	ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (5) [DAKAE]
/


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

STARTA:	JRST	.+1
SUBTTL	TEST OF JSR INSTRUCTION

;**********

;THIS TEST VERIFIES THAT JSR STORES THE FLAGS AND PC IN LOCATION E.
;IN THIS CASE, E IS CLEARED, CRY0 IS SET AND JSR IS EXECUTED.
;NEXT, E IS CHECKED FOR ITS CONTENTS NON-ZERO.  IF C(E) IS NON-ZERO,
;THIS TEST PASSES.

C23000:	SFLAG	CRY0		;SET CRY0 FLAG
	SETZM	.+2		;PRELOAD E WITH 0
	JSR	.+1		;*JSR SHOULD PLACE FLAGS AND PC INTO AC
	0			;E: PRESET TO 0, SHOULD RECEIVE FLAGS AND PC FROM JSR
	SKIPN	.-1		;PASS IF C(E) IS NON-ZERO.
	STOP

;**********

;THIS TEST VERIFIES THAT JSR IGNORES THE AC FIELD;
;HENCE, IT DOES NOT MODIFY THE SPECIFIED AC.
;IN THIS CASE, CRY0 IS SET.  THE AC IS PRELOADED WITH -1,,-1 AND JSR IS EXECUTED.
;THE AC IS THEN CHECKED.  IF C(AC)=-1,,-1, THIS TEST PASSES.

C23100:	SFLAG	CRY0		;SET CRY0
	SETO	1,		;PRELOAD AC WITH -1,,-1
	JSR	1,.+1		;*JSR SHOULD NOT MODIFY THE AC
	0			;STORE PC + FLAGS HERE
	CAME	1,[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT JSR STORES THE FLAGS IN E-LEFT HALF.
;IN THIS TEST, CRY0 IS SET, E IS CLEARED AND JSR IS EXECUTED.
;NEXT, C(E-LEFT) ARE PLACED INTO AC0 AND AC0 IS CHECKED FOR ITS CONTENTS NON-ZERO.
;IF C(AC0) ARE NON-ZERO, THIS TEST PASSES.

C23200:	SFLAG	CRY0		;SET CRY0
	SETZM	.+2		;CLEAR E
	JSR	.+1		;*JSR SHOULD STORE FLAGS IN E
	0			;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST)
	HLLZ	.-1		;PUT FLAGS INTO AC0
	SKIPN			;PASS IF C(AC0) NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT JSR TRANSFERS CONTROL TO E+1.
;IN THIS CASE, CRY0 IS SET AND E  AND AC0 CLEARED; THEN, JSR IS EXECUTED.
;IF JSR RESUMES CONTROL AT E INSTEAD OF E+1, AC0 WILL BE MODIFIED;
;HENCE, THE TEST WILL FAIL WHEN AC0 IS CHECKED FOR 0 BECAUSE
;C(E) IS DECODED AS A MOVE INSTRUCTION.

C23300:	SFLAG	CRY0		;SET CRY0
	SETZB	.+2		;CLEAR AC0 AND E
	JSR	.+1		;*JSR SHOULD RESUME CONTROL AT E+1
	0			;STORE FLAGS HERE (CRY0 MAKES THIS A MOVE INST)
	SKIPE	0		;PASS IF C(AC0)=0
	STOP

;**********
;THIS TEST VERIFIES THAT JSR JUMPS TO E+1
;IN THIS CASE, AC0 IS CLEARED AND CRY0 IS SET; THEN, JSR .+2 IS EXECUTED.
;IF JSR DID NOT JUMP, ONES ARE LOADED WITH AC0; AND THE TEST FAILS.
;OTHERWISE, AC0 REMAINS CLEAR AND THE TEST PASSES

C23400:	SFLAG	CRY0		;SET CRY0
	SETZ			;CLEAR AC0
	JSR	.+2		;*JSR SHOULD JUMP
	SETO			;LOAD AC0 WITH ONES IF JSR FAILED TO JUMP
	0			;STORE FLAGS HERE
	SKIPE			;PASS  IF JSR JUMPED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF.  THE PC
;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION.
;THIS TEST WILL FAIL IF JSR STORES E INSTEAD OF PC IN E - RIGHT HALF.
;IN CASE OF FAILURE, AR PC EN AT ET2 WAS FAULTY.

C23500:	SFLAG	0		;CLEAR ALL FLAGS
	JSR	.+2		;*JSR SHOULD STORE PC+1 IN E - RIGHT
	HALT	.		;JSR SHOULD SKIP OVER THIS HALT
	0			;STORE FLAGS AND PC HERE
	HRRZ	.-1		;PUT STORED CONTENTS OF E - RIGHT INTO AC0
	CAIN	.-2		;FAIL IF C(AC0)=E
	STOP

;**********
;THIS TEST VERIFIES THAT JSR STORES THE PC IN E - RIGHT HALF.  THE PC
;IS ONE GREATER THAN THE LOCATION OF THE JSR INSTRUCTION.
;THIS TEST WILL PASS IF JSR STORES PC IN E - RIGHT HALF.

C23600:	JSR	.+2		;*JSR SHOULD STORE PC+1 IN E - RIGHT
	HALT	.		;JSR SHOULD SKIP OVER THIS HALT
	0			;STORE FLAGS AND PC HERE
	HRRZ	.-1		;PUT STORED CONTENTS OF E - RIGHT INTO AC0
	CAIE	C23600+1	;PASS IF C(AC0)=C23600+1 [PC]
	STOP

;**********
SUBTTL	TEST OF JSA INSTRUCTION

;**********

;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1.
;IN THIS TEST, AC1 IS CLEARED AND A CAM 0,0 IS LOADED
;INTO THE AC OF THE JSA INSTRUCTION.
;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH ONES.  AC1 IS CHECKED FOR ZEROS.
;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP.

C23700:	SETZ	1,		;CLEAR AC1
	MOVE	[CAM]		;LOAD CAM INTO AC0
	JSA	.+2		;*JSA SHOULD JUMP TO E+1
	SETO	1		;JSA SHOULD JUMP OVER THIS INSTRUCTION
	0			;PASS IF JSA JUMPED
	SKIPE	1
	STOP

;**********

;THIS TEST VERIFIES THAT JSA JUMPS TO LOCATION E+1.
;IN THIS TEST, AC1 IS CLEARED AND A MOVEI 1,1234 IS LOADED
;INTO THE AC OF THE JSA INSTRUCTION.
;IF JSA DOES NOT JUMP, AC1 WILL BE LOADED WITH 0,,1234.  AC1 IS CHECKED FOR ZEROS.
;IF C(AC1)=0, THE TEST PASSES; OTHERWISE, THIS TEST FAILS BECAUSE JSA DID NOT JUMP.

C24000:	SETZ	1,		;CLEAR AC1
	MOVE	[MOVEI 1,1234]	;LOAD MOVEI 1,1234 INTO AC
	JSA	.+1		;*JSA SHOULD JUMP TO E+1
	0			;JSA SHOULD JUMP OVER THIS LOCATION
	CAIN	1,1234		;FAIL IF JSA DID NOT JUMP OVER PREVIOUS INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT JSA LOADS PC OF LOC OF JSA+1 INTO AC RIGHT.
;THIS TEST WILL FAIL IF JSA LOADS E INTO AC RIGHT INSTEAD OF PC.

C24100:	JSA	.+2		;*JSA SHOULD LOAD PC INTO AC RIGHT
	HALT	.		;JSA SHOULD JUMP OVER THIS LOCATION
	0			;JSA SHOULD JUMP OVER THIS LOCATION
	HRRZM	1		;PUT C(AC-RIGHT) INTO AC1
	CAIN	1,.-2		;FAIL IF E WAS LOADED INTO AC-RIGHT INSTEAD OF PC
	STOP

;**********

;THIS TEST VERIFIES THAT JSA PLACES C(AC) INTO E
;THIS TEST WILL FAIL IF EITHER 0,,E OR 0,,PC IS LOADED
;INTO E INSTEAD OF C(AC)

C24200:	SETZB	.+2		;CLEAR AC,E
	JSA	.+1		;*JSA SHOULD LOAD C(AC) [ZEROS] INTO E
	0			;JSA SHOULD PLACE ZEROS HERE
	MOVE	1,.-1		;SAVE C(AC)
	CAIN	1,.-2		;FAIL IF JSA LOADED 0,,E OR 0,,PC INTO E
	STOP

;**********
;THIS TEST VERIFIES THAT JSA PLACES PC INTO AC-RIGHT
;THIS TEST WILL FAIL IF PC IS NOT LOADED INTO AC-RIGHT

C24300:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	JSA	.+1		;*JSA SHOULD PLACE E,,PC INTO THE AC
	0			;JSA SHOULD PLACE C(AC) HERE
	TRNN	-1		;FAIL IF AR LT AR RT EN FAILED
	STOP

;**********

;THIS TEST VERIFIES THAT JSA PLACES THE PC OF THE LOCATION OF JSA+1 IN AC-RIGHT
;THIS TEST FAILS IF A PC WAS NOT LOADED INTO AC RIGHT

C24400:	SETZ			;CLEAR AC
	JSA	.+1		;*JSA SHOULD LOAD PC INTO AC - RIGHT
	0			;JSA SHOULD PLACE C(AC) HERE
	TRNN	-1		;PASS IF AC - RIGHT IS NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT JSA PLACES IN AC-LEFT
;THIS TEST FAILS IF JSA LOADS PC INSTEAD OF E INTO AC-LEFT

C24500:	JSA	.+2		;*JSA SHOULD LOAD E INTO AC-LEFT
	HALT	.		;JSA SHOULD JUMP OVER THIS INSTRUCTION
	0			;E:
	HLRZM	1		;SAVE C(AC - LEFT)
	CAIN	1,.-3		;FAIL IF JSA LOADED PC INSTEAD OF E INTO AC-LEFT
	STOP

;**********

;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC
;FIRST, THE AC IS PRELOADED WITH -1,,-1; THEN, JSA IS EXECUTED.
;THE AC IS CHECKED FOR E,,PC.  IF C(AC)=E,,PC, THIS TEST PASSES

C24600:	SETO			;PRELOAD AC WITH -1,,-1
	JSA	.+2		;*JSA SHOULD PLACE E,,PC INTO THE AC
	HALT	.		;JSA SHOULD JUMP OVER HERE, PC:
	0			;JSA SHOULD STORE C(AC) HERE, E:
	CAME	[XWD .-1,.-2]	;PASS IF C(AC)=E,,PC
	STOP

;**********
;THIS TEST VERIFIES THAT JSA LOADS E,,PC INTO THE AC
;FIRST, THE AC IS PRELOADED WITH 0 JSA IS EXECUTED.
;THE AC IS CHECKED FOR E,,PC.  IF C(AC)=E,,PC, THIS TEST PASSES

C24700:	SETZ			;PRELOAD AC WITH 0
	JSA	.+2		;*JSA SHOULD PLACE E,,PC INTO THE AC
	HALT	.		;JSA SHOULD JUMP OVER HERE, PC:
	0			;JSA SHOULD STORE C(AC) HERE, E:
	CAME	[XWD .-1,.-2]	;PASS IF C(AC)=E,,PC
	STOP

;**********

;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E.
;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES;
;THEN JSA IS EXECUTED.  E IS CHECKED FOR ZEROS.  IF C(E)=0,
;THIS TEST PASSES.

C25000:	SETZ			;CLEAR AC
	SETOM	.+2		;PRELOAD E WITH -1,,-1
	JSA	.+1		;*JSA SHOULD PLACE C(AC) INTO E
	0			;E: SHOULD GET C(AC) FROM JSA
	SKIPE	.-1		;PASS IF C(E)=0
	STOP

;**********
;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E.
;AC IS FIRST PRELOADED WITH -1,,-1 AND E IS CLEARED;
;THEN, JSA IS EXECUTED.  E IS CHECKED FOR -1,,-1.  IF C(E)=-1,,-1,
;THIS TEST PASSES.

C25100:	SETOB	1		;PRELOAD AC -1,,-1
	SETZM	.+2		;PRELOAD E WITH 0
	JSA	.+1		;*JSA SHOULD PLACE C(AC) INTO E
	0			;E: SHOULD GET C(AC) FROM JSA
	CAME	1,.-1		;PASS IF C(E)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT JSA LOADS C(AC) INTO E.
;AC IS FIRST CLEARED AND E IS PRELOADED WITH ONES;
;THEN JSA IS EXECUTED.  E IS CHECKED FOR ZEROS.  IF C(E)=0,
;THIS TEST PASSES.

C25200:	MOVEI	-1		;PRELOAD AC WITH 0,,-1
	JSA	.+1		;*JSA SHOULD PLACE C(AC) INTO E
	0			;E: SHOULD GET C(AC) FROM JSA
	MOVE	1,.-1		;PASS IF C(E)=0,,-1
	CAIE	1,-1
	STOP

;**********
;THIS TEST VERIFIES THAT JSA DOES NOT MODIFY AC+1
;IN THIS TEST, AC+1 IS PRELOADED WITH -1,,-1; THEN JSA IS EXECUTED
;AC+1 IS THEN CHECKED FOR ITS ORIGINAL CONTENTS, -1,,-1.
;IF C(AC+1)=-1,,-1, THIS TEST PASSES

C25300:	SETOM	1		;PRELOAD AC+1 WITH -1,,-1
	JSA	.+1		;*JSA SHOULD NOT MODIFY AC+1
	CAM			;JSA SHOULD JUMP OVER THIS, E:PC:
	CAME	1,[-1]		;PASS IF AC+1 WAS NOT MODIFIED BY JSA
	STOP

;**********
SUBTTL	TEST OF JRA INSTRUCTION

;**********

;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E
;THIS TEST FAILS IF JRA DOES NOT JUMP TO E.

C25400:	MOVE	[JRST .+4]	;PRELOAD AC0 WITH JRST .+4
	MOVSI	1,.+2		;PRELOAD AC WITH E,,0
	JRA	1,.+1		;*JRA SHOULD JUMP TO NEXT INSTRUCTION
	SKIPA			;PASS IF JRA JUMPS TO E
	STOP

;**********

;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E
;THIS TEST FAILS IF JRA DOES NOT JUMP TO E.

C25500:	MOVSI	.+3		;PRELOAD AC WITH E+1
	JRA	.+1		;*JRA SHOULD JUMP TO NEXT SEQUENTIAL INSTRUCTION
	SKIPA			;PASS IF JRA JUMPS TO E
	STOP

;**********
;THIS TEST VERIFIES THAT JRA TRANSFERS CONTROL TO LOCATION E
;THIS TEST FAILS IF JRA DOES NOT JUMP TO E.

C25600:	SETZB	1		;PRELOAD AC0, AC1 WITH ZEROS
	JRA	.+2		;*JRA SHOULD JUMP OVER NEXT SEQUENTIAL INSTRUCTION
	SETO	1,		;LOAD AC1 WITH ONES IF JRA DOES NOT JUMP
	SKIPE	1		;PASS IF JRA JUMPED
	STOP

;**********

;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC AND JUMPS TO E
;THIS TEST FAILS IF JRA JUMPS TO E+1 OR DOES NOT LOAD THE AC CORRECTLY.

C25700:	SETZ			;CLEAR AC
	JRA	.+1		;*JRA SHOULD PLACE 0 INTO THE AC AND JUMP .+1
	SKIPE			;PASS IF AC WAS LOADED CORRECTLY
				;AND JRA JUMPED CORRECTLY.
	STOP

;**********
;THIS TEST VERIFIES THAT JRA PLACES C(C(AC-LEFT)) INTO THE AC
;FIRST, THE AC IS PRELOADED WITH 1,,2 AND AC1 AND AC2 ARE
;INITIALIZED WITH THEIR RESPECTIVE ADDRESSES; JRA IS EXECUTED, AND
;THE AC IS CHECKED FOR 0,,1, THE ORIGINAL C(C(AC-LEFT)). IF C(AC)=0,,1,
;THIS TEST PASSES

C26200:	MOVE	[XWD 1,2]	;PRELOAD AC WITH 1,,2
	MOVEI	1,1		;INITIALIZE AC1 WITH 0,,1
	MOVEI	2,2		;INITIALIZE AC2 WITH 0,,2
	JRA	.+1		;*JRA SHOULD PLACE 0,,1 INTO THE AC
	CAIE	1		;PASS IF C(AC)=0,,1
	STOP

;**********

;THIS TEST VERIFIES THAT JRA CAN RESTORE AC0 FROM AC0 WHEN AC0 IS THE
;SPECIFIED AC AND C(AC0-LEFT)=0.
;FIRST, AC0 IS PRELOADED AND JRA IS EXECUTED.  THEN, AC0 IS CHECKED FOR
;ITS INITIAL CONTENTS.  IF THE RESULT IN AC0, IS CORRECT, THIS TEST PASSES.

C26300:	HRRZI	[135531,,246642]	;PRELOAD AC0 WITH 0,, LITERAL ADDRESS
	JRA	.+1		;*JRA SHOULD PLACE C(AC0) INTO AC0
	CAIE	[135531,,246642] ;PASS IF JRA PLACED C(AC0) INTO AC0
	STOP

;**********
;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE
;SPECIFIED AC.
;FIRST, AC0 IS PRELOADED WITH [LITERAL ADDRESS ,,0] AND JRA IS EXECUTED.  THEN,
;AC0 IS CHECKED FOR THE SPECIFIED LITERAL, 135246,,246135.  IF
;C(AC0)=135246,,246135, THE TEST PASSES.

C26400:	HRLZI	[135246,,246135] ;PRELOAD AC0 WITH [LITERAL ADDRESS ,,0]
	JRA	.+1		;*JRA SHOULD PLACE 135246,,246135 INTO AC0
	CAME	[135246,,246135];PASS IF C(AC0)=135246,,246135
	STOP

;**********

;THIS TEST VERIFIES THAT JRA CAN RESOTRE AC0 FROM MEMORY WHEN AC0 IS THE
;SPECIFIED AC.
;FIRST, AC0 IS PRELOADED WITH [-1,, ADDRESS OF JCA INSTRUCTION] AND JRA IS EXECUTED.
;THEN, AC0 IS CHECKED FOR THE JRA INSTRUCTION.  IF
;C(AC0)= THE JRA INSTRUCTION, THE TEST PASSES.

C26500:	HRLOI	.+1		;PRELOAD AC WITH -1,, ADDRESS OF JRA INSTRUCTION
	JRA	.+1		;*JRA SHOULD PLACE ITSELF INTO AC0
	CAME	.-1		;PASS IF AC CONTAINS JRA INSTRUCTION
	STOP

;**********
SUBTTL	TESTS OF BIS FLAG

;**********

;THIS TEST VERIFIES THAT JRST 2, CAN CLEAR BIS
;FIRST, BIS IS SET VIA JRST 2, ;THEN, BIS IS CLEARED VIA JRST 2,.
;THE FLAGS ARE SAVED AND BIS IS CHECKED.  THIS TEST PASSES IF BIS IS RESET;
;OTHERWISE JRST 2, FAILED TO RESET BIS.

C26600:	SFLAG	BIS		;SET BIS FLAG
	SFLAG			;*RESET BIS FLAG
	JSP	.+1		;SAVE FLAGS
	TLNE	BIS+37		;PASS IF BIS FLAG IS RESET
	STOP

;**********

;THIS TEST VERIFIES THAT JRST 2, CAN SET BIS.
;FIRST, BIS IS SET VIA JRST 2, AND THE FLAGS ARE SAVED.
;BIS IS THEN CHECKED.  IF BIS IS SET, THIS TEST PASSES.

C26700:	SFLAG	BIS		;*SET BIS FLAG VIA JRST
	JSP	.+1		;SAVE FLAGS
	TLNN	BIS		;PASS IF BIS FLAG IS SET
	STOP

;**********
;THIS TEST VERIFIES THAT JSR ALWAYS RESETS BIS.
;FIRST BIS IS SET; THEN JSR IS EXECUTED.  THE FLAGS ARE
;THEN SAVED AND CHECKED.  IF BIS WAS RESET VIA JSR, THIS TEST PASSES.

C27000:	SFLAG	BIS		;SET BIS
	JSR	.+1		;*JSR SHOULD RESET BIS
	0			;JSR SAVES FLAGS HERE
	JSP	.+1		;SAVE FLAGS
	TLNE	BIS		;PASS IF BIS FLAG IS RESET
	STOP

;**********

;THIS TEST VERIFIES THAT JSP ALWAYS RESETS BIS.
;FIRST BIS IS SET; THEN JSP IS EXECUTED.  THE FLAGS ARE
;THEN SAVED AND CHECKED.  IF BIS WAS RESET VIA JSP, THIS TEST PASSES.

C27001:	SFLAG	BIS		;SET BIS
	JSP	.+1		;*JSP SHOULD RESET BIS
	JSP	.+1		;SAVE FLAGS
	TLNE	BIS		;PASS IF BIS FLAG IS RESET
	STOP

;**********
;THIS TEST VERIFIES THAT THE BITS IN POSITIONS 8, 9 AND 10 ARE CLEARABLE.
;FIRST, THE ARITHMETIC FLAGS ARE CLEARED;
;THEN, BITS 8, 9 AND 10 OF THE PC-WORD IS EXAMINED.
;IF ANY OF THESE BITS ARE SET, THIS TEST FAILS BECAUSE THEY SHOULD BE CLEAR.

C27100:	SFLAG			;CLEAR ARITHMETIC FLAGS
	JSP	.+1		;SAVE FLAGS
	TLNE	1600		;PASS IF THESE BITS ARE CLEAR
	STOP

;**********
SUBTTL	TEST OF MSCL FWT INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT MOVEM PLACES C(AC) INTO E AND DOES
;NOT MODIFY C(AC).
;IN THIS CASE, C(AC)=252525,,252525 ANS C(E)=707070,,707070.
;HENCE, THE RESULT IN E SHOULD BE 252525,,252525.
;THE AC IS CHECKED FOR 252525,,252525.  IF ANY OTHER NUMBER IS
;FOUND IN THE AC, IT WAS CLOBBERED BY MOVEM, AND THIS TEST FAILS.
;E IS CHECKED FOR 252525,,252525.  IF ANY OTHER NUMBER IS FOUND
;IN E, IT WAS UPDATED INCORRECTLY BY MOVEM.

C50000:	MOVE	[252525,,252525]	;PRELOAD AC WITH 252525,,252525
	MOVE	1,[707070,,707070]	;PRELOAD E WITH 707070,,707070
	MOVEM	0,1			;*MOVEM SHOULD PLACE 252525,,252525
					;INTO E AND NOT AFFECT THE AC
	CAME	0,[252525,,252525]	;PASS IF C(AC) IS NOT CLOBBERED
	STOP
	CAME	1,[252525,,252525]	;PASS IF E WAS UPDATED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT MOVES PLACES C(E) INTO THE AC IF AC IS NON-ZERO.
;IN THIS CASE, C(AC)=707070,,707070 AND C(E)=123456,,123456.  HENCE, BOTH
;THE AC AND E SHOULD CONTAIN 123456,,123456 AFTER MOVES IS EXECUTED.
;BOTH AC AND E ARE CHECKED FOR 123456,,123456.  IF EITHER AC OR E
;CONTAIN A DIFFERENT RESULT, THIS TEST FAILS

C50100:	MOVE	2,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	MOVE	1,[123456,,123456]	;PRELOAD E WITH 123456,,123456
	MOVES	2,1			;*MOVES SHOULD PLACE 123456,,123456
					;INTO BOTH AC AND E
	CAME	2,[123456,,123456]	;PASS IF C(AC)=123456,,123456
	STOP
	CAME	1,[123456,,123456]	;PASS IF C(E)=123456,,123456
	STOP

;**********
;THIS TEST VERIFIES THAT MOVES IS A NO-OP IF AC=0
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=707070,,707070
;AFTER MOVES IS EXECUTED, AC AND E ARE CHECKED FOR THEIR ORIGINAL DATA.
;IF EITHER C(AC) OR C(E) CHANGED AS A RESULT OF MOVES, THIS TEST FAILS.

C50110:	MOVE	1,[707070,,707070]	;PRELOAD E WITH 707070,,707070
	SETO				;PRELOAD AC WITH -1,,-1
	MOVES	0,1			;*MOVES SHOULD FUNCTION AS A NO-OP
	CAME	0,[-1,,-1]		;PASS IF C(AC) WAS NOT MODIFIED
	STOP
	CAME	1,[707070,,707070]	;PASS IF C(E) WAS NOT MODIFIED
	STOP

;**********

;THIS TEST VERIFIES THAT MOVSI LOADS THE WORD E,0 INTO THE AC.
;IN THIS CASE, C(AC)=707070,,707070 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.

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

;**********
;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC)
;INTO E.  IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3.
;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT
;IN E SHOULD BE 0,,1

C50300:	SETO	1,			;PRELOAD AC WITH -1,,-1
	MOVE	2,[-1,,-3]		;PRELOAD E WITH -1,,-3
	MOVNM	1,2			;*MOVNM SHOULD PLACE 0,,1 INTO E
					;AND NOT AFFTECT C(AC)
	CAME	1,[-1]			;PASS IF C(AC)=-1,,-1
	STOP
	CAIE	2,1			;PASS IF C(E)=0,,1
	STOP

;**********

;THIS TEST VERIFIES THAT MOVNM PLACES THE NEGATIVE OF C(AC)
;INTO E.  IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-3.
;HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1 AND THE RESULT
;IN E SHOULD BE 0,,1

C50301:	SETO	1,			;PRELOAD AC WITH -1,,-1
	MOVE	2,[-1,,-3]		;PRELOAD E WITH -1,,-3
	MOVEM	2,E50301
	MOVNM	1,E50301		;*MOVNM SHOULD PLACE 0,,1 INTO E
					;AND NOT AFFTECT C(AC)
	CAME	1,[-1]			;PASS IF C(AC)=-1,,-1
	STOP
	MOVE	2,E50301
	CAIE	2,1			;PASS IF C(E)=0,,1
	STOP

	SKIPA				;GO TO NEXT TEST
E50301:	0				;TESTED MEMORY LOCATION

;**********
;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E
;AND INTO THE AC IF THE AC IS NON-ZERO.  IN THIS CASE, AC=0,
;C(AC)=0 AND C(E)=0,,1
;HENCE, THE RESULT IN THE AC SHOULD BE 0
;AND THE RESULT IN E SHOULD BE -1,,-1

C50400:	SETZ				;CLEAR AC
	MOVEI	2,1			;PRELOAD E WITH 0,,1
	MOVNS	0,2			;*MOVNS SHOULD PLACE -1,,-1 INTO E
					;AND SHOULD NOT AFFECT THE AC
	SKIPE				;PASS IF THE AC IS UNALTERED
	STOP
	CAME	2,[-1]			;PASS IF C(E)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E
;AND INTO THE AC IF THE AC IS NON-ZO.  IN THIS CASE, AC=0,
;C(AC)=0 AND C(E)=0,,1
;HENCE, THE RESULT IN THE AC SHOULD BE 0
;AND THE RESULT IN E SHOULD BE -1,,-1

C50401:	SETZ				;CLEAR AC
	MOVEI	2,1			;PRELOAD E WITH 0,,1
	MOVEM	2,E50401
	MOVNS	0,E50401		;*MOVNS SHOULD PLACE -1,,-1 INTO E
					;AND SHOULD NOT AFFECT THE AC
	SKIPE				;PASS IF THE AC IS UNALTERED
	STOP
	MOVE	2,E50401
	CAME	2,[-1]			;PASS IF C(E)=-1,,-1
	STOP

	SKIPA				;GO TO NEXT TEST
E50401:	0				;TESTED MEMORY LOCATION

;**********
;THIS TEST VERIFIES THAT MOVNS PLACES THE NEGATIVE OF C(E) INTO E
;AND INTO THE AC IF THE AC IS NON-ZERO.  IN THIS CASE, AC=1,
;C(AC=0 AND C(E)=3
;HENCE, THE RESULT IN THE AC SHOULD BE -1,,3
;AND THE RESULT IN E SHOULD BE -1,,3.

C50410:	SETZ	1,			;CLEAR AC
	MOVEI	2,3			;PRELOAD WITH 0,,3
	MOVNS	1,2			;*MOVNS SHOULD PLACE -1,,-3 INTO E
					;AND -1,,-3 INTO THE AC
	CAME	1,[-1,,-3]		;PASS IF C(AC)=-1,,-3
	STOP
	CAME	2,[-1,,-3]		;PASS IF C(E)=-1,,-3
	STOP

;**********

;THIS TEST VERIFIES THAT MOVMI MOVES THE WORD 0,,E INTO THE AC.
;IN THIS CASE, C(AC)=0 AND E=0,,-2.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-2.

C50500:	SETZ	1,			;CLEAR AC
	MOVMI	1,-2			;*MOVMI SHOULD PLACE 0,,-2 INTO AC
	CAIE	1,-2			;PASS IF C(AC)=0,,-2
	STOP

;**********
;THIS TEST VERIFIES THAT MOVM MOVES THE MAGNITUDE OF C(E) NTO THE AC.
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-2.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,2.

C50501:	SETZ	1,			;CLEAR AC
	MOVE	3,[-2]			;PRELOAD E WITH -1,,-2
	MOVM	1,3			;*MOVM SHOULD PLACE 0,,2 INTO AC
	CAIE	1,2			;PASS IF C(AC)=0,,2
	STOP

;**********
;THIS TEST VERIFIES THAT MOVMM PLACES THE MAGNITUDE OF C(AC)
;INTO E.  IN THIS CASE, C(AC)=-1,,-2 AND C(E)=0.  HENCE, THE
;RESULT IN E SHOULD BE 0,,2 AND C(AC) SHOULD REMAIN UNCHANGED.

C50600:	MOVE	1,[-1,,-2]		;PRELOAD AC WITH -1,,-2
	SETZ	2,			;CLEAR E
	MOVMM	1,2			;*MOVMM SHOULD PLACE 0,,2 INTO E
					;AND SHOULD NOT CHANGE C(AC)
	CAME	1,[-1,,-2]		;PASS IF C(AC) IS NOT ALTERED
	STOP
	CAIE	2,2			;PASS IF C(E)=0,,2
	STOP

;**********

;THIS TEST VERIFIES THAT MONMS PLACES THE MAGNITUDE OF C(E) INTO E
;AND INTO THE AC IF THE AC IS NON-ZERO.  IN THIS CASE, AC=0, C(AC)=0
;AND C(E)=-1,,-2.
;HENCE, THE RESULT IN THE AC SHOULD BE 0 AND THE RESULT IN
;E SHOULD BE 0,,2.

C50700:	SETZ			;CLEAR AC
	MOVE	2,[-1,,-2]		;PRELOAD E WITH -1,,-1
	MOVMS	0,2			;*MOVMS	SHOULD PLACE 0,,1 INTO E
					;AND SHOULD NOT CHANGE C(AC)
	SKIPE				;PASS IF C(AC) IS UNALTERED
	STOP
	CAIE	2,2			;PASS IF C(E)=0,,2
	STOP

;**********
;THIS TEST VERIFIES THAT MOVMS PLACES THE MAGNITUDE OF C(E) INTO E
;AND INTO THE AC IF THE AC IS NON-ZERO.  IN THIS CASE, AC=1, C(AC)=-1,,-1
;AND C(E)=-1,,-2.
;HENCE, THE RESULT IN THE AC SHOULD BE 0,,2 AND THE RESULT
;IN E SHOULD BE 0,,2.

C50710:	SETO	1,			;PRELOAD AC WITH -1,,-1
	MOVE	2,[-1,,-2]		;PRELOAD E WITH -1,,-2
	MOVMS	1,2			;*MOVMS SHOULD PLACE 0,,2 INTO E
					;AND SHOULD PLACE 0,,2 INTO THE AC
	CAIE	1,2			;PASS IF C(AC)=0,,2
	STOP
	CAIE	2,2			;PASS IF C(E)=0,,2
	STOP

;**********
SUBTTL	TEST OF MSCL ADD/SUB INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT SUBI SUBTRACTS THE WORD 0,,E FROM C(AC)
;AND PLACES THE RESULT INTO THE AC.  IN THIS CASE, C(AC)=70 AND
;E=0,,2.  HENCE, THE RESULT IN THE AC SHOULD BE 66.

C51000:	MOVEI	1,70			;PRELOAD AC WITH 70
	SUBI	1,2			;*SUBI SHOULD PLACE 66 INTO AC
	CAIE	1,66			;PASS IF C(AC)=66
	STOP

;**********

;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND
;PLACES THE RESULT INTO E.  THE AC IS UNAFFECTED.  IN THIS CASE,
;C(AC)=100 AND C(E)=37.  HENCE, THE RESULTS IN AC AND
;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY.

C51100:	MOVEI	1,100			;PRELOAD AC WITH 0,,100
	MOVEI	2,37			;PRELOAD E WITH 0,,37
	SUBM	1,2			;*SUBM SHOULD PLACE
					;0,,41 INTO E AND NOT CHANGE C(AC)
	CAIE	1,100			;PASS IF C(AC) IS UNCHANGED
	STOP
	CAIE	2,41			;PASS IF C(E)=0,,41
	STOP

;**********
;THIS TEST VERIFIES THAT SUBM SUBTRACTS C(E) FROM C(AC) AND
;PLACES THE RESULT INTO E.  THE AC IS UNAFFECTED.  IN THIS CASE,
;C(AC)=100 AND C(E)=37.  HENCE, THE RESULTS IN AC AND
;E SHOULD BE 0,,100 AND 0,,41 RESPECTIVELY.

C51101:	MOVEI	1,100			;PRELOAD AC WITH 0,,100
	MOVEI	2,37			;PRELOAD E WITH 0,,37
	MOVEM	2,E51101
	SUBM	1,E51101		;*SUBM SHOULD PLACE
					;0,,41 INTO E AND NOT CHANGE C(AC)
	CAIE	1,100			;PASS IF C(AC) IS UNCHANGED
	STOP
	MOVE	2,E51101
	CAIE	2,41			;PASS IF C(E)=0,,41
	STOP

	SKIPA				;GO TO NEXT TEST
E51101:	0				;TEST WORD MEMORY

;**********
;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND
;PLACES THE RESULT INTO BOTH AC AND E.  IN THIS CASE,
;C(AC)=0,,100 AND C(E)=0,,37.  HENCE, THE RESULT IN BOTH
;AC AND E SHOULD BE 0,,41.

C51200:	MOVEI	1,100			;PRELOAD AC WITH 0,,100
	MOVEI	2,37			;PRELOAD E WITH O,,37
	SUBB	1,2			;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC  AND E
	CAIE	1,41			;PASS IF C(AC)=0,,41
	STOP
	CAIE	2,41			;PASS IF C(E)=0,,41
	STOP

;**********

;THIS TEST VERIFIES THAT SUBB SUBTRACTS C(E) FROM C(AC) AND
;PLACES THE RESULT INTO BOTH AC AND E.  IN THIS CASE,
;C(AC)=0,,100 AND C(E)=0,,37.  HENCE, THE RESULT IN BOTH
;AC AND E SHOULD BE 0,,41.

C51201:	MOVEI	1,100			;PRELOAD AC WITH 0,,100
	MOVEI	2,37			;PRELOAD E WITH O,,37
	MOVEM	2,E51201
	SUBB	1,E51201		;*SUBB SHOULD PLACE 0,,41 INTO BOTH AC  AND E
	CAIE	1,41			;PASS IF C(AC)=0,,41
	STOP
	MOVE	2,E51201
	CAIE	2,41			;PASS IF C(E)=0,,41
	STOP

	SKIPA				;GO TO NEXT TEST
E51201:	0				;TEST WORD MEMORY

;**********
SUBTTL	TEST OF MSCL CAIX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E.
;IN THIS CASE, C(AC)=0,,1 AND E=0,,2
;HENCE, CAIL SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIL SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C51300:	MOVEI	1,1			;PRELOAD AC WITH 0,,1
	CAIL	1,2			;*CAIL SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E.
;IN THIS CASE, C(AC)=0,,2 AND E=0,,2.
;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES.

C51310:	MOVEI	1,2			;PRELOAD AC WITH 0,,2
	CAIL	1,2			;*CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA				;PASS IF CAIL DOES NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT CAIL COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN E
;IN THIS CASE, C(AC)=0,,3 AND E=0,,2
;HENCE, CAIL SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIL DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES.

C51320:	MOVEI	1,3			;PRELOAD AC WITH 0,,3
	CAIL	1,2			;*CAIL SHOULD SKIP THE NEXT INSTRUCTION
	SKIPA				;PASS IF CAIL DOES NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E
;IN THIS CASE, C(AC)=-1,,-1 AND E=0
;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION
;IF CAILE SKIPS THE NEXT INSTRUCTION, THE TEST PASSES

C51400:	SETO	1,			;PRELOAD AC WITH -1,,-1
	CAILE	1,0			;*CAILE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E
;IN THIS CASE, C(AC)=0	AND E=0
;HENCE, CAILE SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAILE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C51410:	SETZ	1,			;PRELOAD AC WITH 0
	CAILE	1,0			;*CAILE SHOULD SKIP THE NEXT INSTRUCTION.
	STOP

;**********

;THIS TEST VERIFIES THAT CAILE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO E
;IN THIS CASE, C(AC)=0,,1 AND E=0
;HENCE, CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAILE DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES

C51420:	MOVEI	1,1			;PRELOAD AC WITH 0,,1
	CAILE	1,0			;*CAILE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA				;PASS IF CAILE DOES NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS
;SKIPS THE NEXT INSTRUCTION
;IN THIS CASE, C(AC)=-1,,-1 AND E=0
;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION
;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C51500:	SETO	1,			;PRELOAD AC WITH -1,,-1
	CAIA	1,0			;*CAIA SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS
;SKIPS THE NEXT INSTRUCTION
;IN THIS CASE, C(AC)=0 AND E=0
;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C51510:	SETZ	1,			;PRELOAD AC WITH 0
	CAIA	1,0			;*CAIA SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT CAIA COMPARES C(AC) WITH E AND ALWAYS
;SKIPS THE NEXT INSTRUCTION
;IN THIS CASE, C(AC)=0,,1 AND E=0
;HENCE, CAIA SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIA SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C51520:	MOVEI	1,1			;PRELOAD AC WITH 0,,1
	CAIA	1,0			;*CAIA SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E.
;IN THIS CASE, C(AC)=0,,5 AND E=0,,6
;HENCE, CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIGE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES

C51600:	MOVEI	2,5			;PRELOAD AC WITH 0,,5
	CAIGE	2,6			;*CAIGE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA				;PASS IF CAIGE DOES NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E
;IN THIS CASE, C(AC)=0,,6 AND E=0,,6
;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C51610:	MOVEI	2,6			;PRELOAD AC WITH 0,,6
	CAIGE				;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIGE COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN OR EQUAL TO E.
;IN THIS CASE, C(AC)=0,,7 AND E=0,,6
;HENCE, CAIGE SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIGE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C51620:	MOVEI	2,7		;PRELOAD AC WITH 0,,7
	CAIGE	2,6		;*CAIGE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIRIES THAT CAIN COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E.
;IN THIS CASE, C(AC)=0 AND E=0,,1
;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C51700:	SETZ	6,		;PRELOAD AC WITH 0
	CAIN	6,1		;*CAIN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E.
;IN THIS CASE, C(AC)=0,,1 AND E=0,,1
;HENCE, CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIN DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES

C51710:	MOVE	6,1		;PRELOAD AC WITH 0,,1
	CAIN	6,1		;*CAIN SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;PASS IF CAIN SKIPS
	STOP

;**********
;THIS TEST VERIFIES THAT CAIN COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS NOT EQUAL TO E.
;IN THIS CASE, C(AC)=0,,2 AND E=0,,1
;HENCE, CAIN SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIN SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C51720:	MOVEI	6,2		;PRELOAD AC WITH
	CAIN	6,1		;*CAIN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E.
;IN THIS CASE, C(AC)=0,,2 AND E=0,,3.
;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES

C52000:	MOVEI	11,2		;PRELOAD AC WITH 0,,2
	CAIG	11,3		;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;PASS IF CAIG DID NOT SKIP
	STOP

;**********
;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E.
;IN THIS CASE, C(AC)=0,,3 AND E=0,,3.
;HENCE, CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAIG DOES NOT SKIP THE NEXT INSTRUCTION, THE TEST PASSES.

C52010:	MOVEI	11,3		;PRELOAD AC WITH 0,,3
	CAIG	11,3		;*CAIG SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;PASS IF CAIG DID NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT CAIG COMPARES C(AC) WITH E AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN E.
;IN THIS CASE, C(AC)=0,,4 AND E=0,,3.
;HENCE, CAIG SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAIG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C52020:	MOVEI	11,4		;PRELOAD AC WITH 0,,4
	CAIG	11,3		;*CAIG SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
SUBTTL	TEST OF MSCL CAMX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAT OR EQUAL TO C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0
;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C52100:	SETO	1,		;PRELOAD AC WITH -1,,-1
	SETZ	2,		;PRELOAD E WITH 0
	CAMLE	1,2		;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=0
;HENCE, CAMLE SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAMLE SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES

C52110:	SETZ	1,		;CLEAR AC
	CAMLE	1,[0]		;*CAMLE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT CAMLE COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS LESS THAN OR EQUAL TO C(E).
;IN THIS CASE, C(AC)=0,,1 AND C(E)=0
;HENCE, CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAMLE DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES.

C52120:	MOVEI	1,1		;PRELOAD AC WITH 0,,1
	SETZ	2,		;PRELOAD E WITH 0
	CAMLE	1,2		;*CAMLE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;PASS IF CAMLE DOES NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E).
;IN THIS CASE, C(AC)=-1,,-2 AND C(E)=-1,,-1.
;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES.

C52200:	HRROI	10,-2		;PRELOAD AC WITH -1,,-2
	CAMG	10,[-1,,-1]	;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION.
	SKIPA			;PASS IF CAMG DOES NOT SKIP
	STOP
;**********

;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-2.
;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION.

C52205:	HRROI	10,-1		;PRELOAD AC WITH -1,,-1
	CAMG	10,[-1,,-2]	;*CAMG SHOULD SKIP THE NEXT INSTRUCTION.
	STOP
;**********
;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1.
;HENCE, CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION.
;IF CAMG DOES NOT SKIP THE NEXT INSTRUCTION, THIS TEST PASSES.
C52210:	SETO	10,		;PRELOAD AC WITH -1,,-1.
	CAMG	10,[-1,,-1]	;*CAMG SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;PASS IF CAMG DOES NOT SKIP
	STOP

;**********

;THIS TEST VERIFIES THAT CAMG COMPARES C(AC) WITH C(E) AND
;SKIPS THE NEXT INSTRUCTION IF C(AC) IS GREATER THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.
;HENCE, CAMG SHOULD SKIP THE NEXT INSTRUCTION.
;IF CAMG SKIPS THE NEXT INSTRUCTION, THIS TEST PASSES.

C52220:	SETZ	10,		;PRELOAD AC WITH 0
	CAMG	10,[-1,,-1]	;*CAMG SHOULD SKIP THE NEXT INSTRUCTION
	STOP

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

;**********

;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND
;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR
;EQUAL TO 0.  IN THIS CASE, C(AC)=-1,,-1.  HENCE, JUMPLE SHOULD JUMP.

C52300:	SETO	17,		;PRELOAD AC WITH -1,,-1
	JUMPLE	17,.+2		;*JUMPLE SHOULD JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND
;JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR
;EQUAL TO 0.  IN THIS CASE, C(AC)=0.  HENCE, JUMPLE SHOULD JUMP.

C52310:	SETZ	17,		;PRELOAD AC WITH 0
	JUMPLE	17,.+2		;*JUMPLE SHOULD JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT JUMPLE COMPARES C(AC) WITH 0 AND JUMPS
;TO THE LOCATION SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO
;0.  IN THIS CASE, C(AC)=0,,1.  HENCE, JUMPLE SHOULD NOT JUMP.

C52320:	MOVEI	17,1		;PRELOAD AC WITH 0,,1
	JUMP	17,.+2		;*JUMPLE SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPLE DOES NOT JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO
;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC)=-1,,-1.  HENCE, JUMPGE SHOULD NOT JUMP.

C52400:	SETO	16,		;PRELOAD AC WITH -1,,-1
	JUMPGE	16,.+2		;*JUMPGE SHOULD NOT JUMP
	SKIPA			;PASS IF JUMPGE DOES NOT JUMP
	STOP

;**********
;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH O AND JUMPS TO
;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC)=0.  HENCE, JUMPGE SHOULD JUMP.

C52410:	SETZ	16,		;PRELOAD AC WITH 0
	JUMPGE	16,.+2		;*JUMPGE SHOULD JUMP
	STOP

;**********

;THIS TEST VERIFIES THAT JUMPGE COMPARES C(AC) WITH 0 AND JUMPS TO
;THE LOCATION SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC)=0,,1.  HENCE, JUMPGE SHOULD JUMP.

C52420:	MOVEI	16,1		;PRELOAD AC WITH 0,,1
	JUMPGE	16,.+2		;*JUMPGE SHOULD JUMP
	STOP

;**********
SUBTTL	TEST OF MSCL AOJX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND PLACES
;THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS COMPARED
;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC)
;IS LESS THAN 0.  IN THIS CASE, C(AC)=-1,,-2 BEFORE INCREMENTING.
;HENCE, AOJL SHOULD JUMP.

C52500:	HRROI	15,-2		;PRELOAD AC WITH -1,,-2
	AOJL	15,.+2		;*AOJL SHOULD ADD 0,,1 TO C(AC) AND JUMP
	STOP
	CAME	15,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJ SHOULD NOT JUMP

C52510:	SETO	15,		;PRELOAD AC WITH
	AOJL	15,.+2		;*AOJL SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJL DID NOT JUMP
	STOP
	CAIE	15,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJL INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJL SHOULD NOT JUMP

C52520:	SETZ	15,		;PRELOAD AC WITH 0
	AOJL	15,.+2		;*AOJL SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJL DID NOT JUMP
	STOP
	CAIE	15,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0
;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING
;HENCE, AOJE SHOULD NOT JUMP

C52600:	HRROI	14,-2		;PRELOAD AC WITH -1,,-2
	AOJE	14,.+2		;*AOJE SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJE DID NOT JUMP
	STOP
	CAME	14,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING.
;HENCE, AOJE SHOULD JUMP

C52610:	SETO	14,		;PRELOAD AC WITH -1,,-1
	AOJE	14,.+2		;*AOJ SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	14,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0.
;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJE SHOULD NOT JUMP

C52620:	SETZ	14,		;PRELOAD AC WITH 0
	AOJE	14,.+2		;*AOJE SHOULD ADD 0,11 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJE DID NOT JUMP
	STOP
	CAIE	14,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO TLE$EC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJLE SHOULD

C52700:	HRROI	13,-2		;PRELOAD AC WITH -1,,-2
	AOJLE	13,.+2		;*AOJLE SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAME	13,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJLE SHOULD JUMP.

C52710:	SETO	13,		;PRELOAD AC WITH -1,,-1
	AOJLE	13,.+2		;*AOJLE SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	13,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJLE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC) IS 0
;HENCE, AOJLE SHOULD NOT JUMP.

C52720:	SETZ	13,		;PRELOAD AC WITH 0
	AOJLE	13,.+2		;*AOJLE SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJLE DID NOT JUMP
	STOP
	CAIE	13,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E.
;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING
;HENCE, AOJA SHOULD JUMP

C53000:	HRROI	12,-2		;PRELOAD AC WITH -1,,-2
	AOJA	12,.+2		;*AOJA SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAME	12,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJA SHOULD JUMP

C53010:	SETO	12,		;PRELOAD AC WITH -1,,-1
	AOJA	12,.+2		;*AOJA SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	12,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJA INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E.
;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJA SHOULD JUMP

C53020:	SETZ	12,		;PRELOAD AC WITH 0
	AOJA	12,.+2		;*AOJA SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	12,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0
;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING
;HENCE, AOJGE SHOULD NOT JUMP

C53100:	HRROI	11,-2		;PRELOAD AC WITH -1,,-2
	AOJGE	11,.+2		;*AOJGE SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJGE DID NOT JUMP
	STOP
	CAME	11,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJ SHOULD JUMP

C53110:	SETO	11,		;PRELOAD AC WITH -1,,-1
	AOJGE	11,.+2		;*AOJGE SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	11,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJGE INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0
;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJGE SHOULD JUMP

C53120:	SETZ	11,		;PRELOAD AC WITH 0
	AOJGE	11,.+2		;*AOJGE SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	11,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0.
;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INCREMENTING
;HENCE, AOJN SHOULD JUMP

C53200:	HRROI	10,-2		;PRELOAD AC WITH -1,,-2
	AOJN	10,.+2		;*AOJN SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAME	10,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJ SHOULD NOT JUMP.

C53210:	SETO	10,		;PRELOAD AC WITH -1,,-1
	AOJN	10,.+2		;*AOJN SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJN DID NOT JUMP
	STOP
	CAIE	10,0		;PASS IF C(AC) INCREMENTED CORRRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJN INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS NOT EQUAL TO 0.
;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJN SHOULD JUMP.

C53220:	SETZ	10,		;PRELOAD AC WITH 0
	AOJN	10,.+2		;*AOJN SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	10,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE REAULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0
;IN THIS CASE, C(AC) IS -1,,-2 BEFORE INC
;HENCE, AOJG SHOULD NOT JUMP

C53300:	HRROI	7,-2		;PRELOAD AC WITH -1,,-2
	AOJG	7,.+2		;*AOJG SHOULD ADD 0,11 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJG DID NOT JUMP
	STOP
	CAME	7,[-1]		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0.
;IN THIS CASE, C(AC) IS -1,,-1 BEFORE INCREMENTING
;HENCE, AOJG SHOULD NOT JUMP.

C53310:	SETO	7,		;PRELOAD AC WITH -1,,-1
	AOJG	7,.+2		;*AOJG SHOULD ADD 0,,1 TO C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF AOJG DID NOT JUMP
	STOP
	CAIE	7,0		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT AOJG INCREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0.
;IN THIS CASE, C(AC) IS 0 BEFORE INCREMENTING
;HENCE, AOJG SHOULD JUMP

C53320:	SETZ	7,		;PRELOAD AC WITH 0
	AOJG	7,.+2		;*AOJG SHOULD ADD 0,,1 TO C(AC)
				;AND JUMP
	STOP
	CAIE	7,1		;PASS IF C(AC) INCREMENTED CORRECTLY
	STOP

;**********
SUBTTL	TEST OF MSCL AOSX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSL SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C53400:	MOVE	6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	7,-2		;PRELOAD E WITH -1,,-2
	AOSL	6,7		;*AOSL SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	7,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	6,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSL SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C53401:	MOVE	6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	7,-2		;PRELOAD E WITH -1,,-2
	MOVEM	7,E53401
	AOSL	6,E53401	;*AOSL SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	MOVE	7,E53401
	CAME	7,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	6,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

	SKIPA			;GO TO NEXT TEST
E53401:	0			;TEST WORD MEMORY

;**********
;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) ISLESS THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSL SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C53410:	MOVE	6,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETO	7,		;PRELOAD E WITH -1,,-1
	AOSL	6,7		;*AOSL SHOULD ADD 00,1 TO C(E)
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSL DID NOT SKIP
	STOP
	CAME	7,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	6,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSL INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSL SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY

C53420:	MOVE	6,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETZ	7,		;PRELOAD E WITH 0
	AOSL	6,7		;*AOSL SHOULD ADD 0,,1 TO C(E).
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSL DID NOT SKIP
	STOP
	CAME	7,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	6,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSE SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C53500:	MOVE	5,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	HRROI	6,-2		;PRELOAD E WITH -1,,-2
	AOSE	5,6		;*AOSE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSE DID NOT SKIP
	STOP
	CAME	6,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	5,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSE SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C53510:	MOVE	5,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETO	6,		;PRELOAD E WITH -1,,-1
	AOSE	5,6		;*AOSE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	6,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	5,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(AC)=0
;BEFORE INCREMENTING.  HENCE, AOSE SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C53520:	MOVE	5,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETZ	6,		;PRELOAD E WITH 0
	AOSE	5,6		;*AOSE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSE DID NOT SKIP
	STOP
	CAME	6,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	5,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSLE SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C53600:	MOVE	4,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	HRROI	5,-2		;PRELOAD E WITH -1,,-2
	AOSLE	4,5		;*AOSLE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP ZERO
	STOP
	CAME	5,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	4,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSLE SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C53610:	MOVE	4,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETOM	5,		;PRELOAD E WITH -1,,-1
	AOSLE	4,5		;*AOSLE SHOULD ADD 0,,1 TO C(E)
				;UPDATE AC AND SKIP
	STOP
	CAME	5,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	4,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSLE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSLE SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C53620:	MOVE	4,[707070,,707070]	;PRELOAD AC WITH 707070,,707070
	SETZ	5		;PRELOAD E WITH 0
	AOSLE	4,5		;*AOSLE SHOULD ADD 0,,1 TO C(E)
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSLE DID NOT SKIP
	STOP
	CAME	5,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	4,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSA SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C53700:	MOVE	3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	4,-2		;PRELOAD E WITH -1,,-2
	AOSA	3,4		;*AOSA SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	4,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	3,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSA INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSA SHOULD SKIP AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY

C53710:	MOVE	3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETO	4,		;PRELOAD E WITH -1,,-1
	AOSA	3,4		;*AOSA SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	4,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	3,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOS INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSA SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY

C53720:	MOVE	3,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETZ	4,		;PRELOAD E WITH 0
	AOSA	3,4		;*AOSA SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	4,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	3,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSGE SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY

C54000:	MOVE	2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	3,-2		;PRELOAD E WITH -1,,-2
	AOSGE	2,3		;*AOSGE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSGE DID NOT SKIP
	STOP
	CAME	3,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	2,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSGE SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY

C54010:	MOVE	2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETO	3,		;PRELOAD E WITH 0
	AOSGE	2,3		;*AOSGE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	3,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	2,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSGE INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=2, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSGE SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY

C54020:	MOVE	2,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETZ	3,		;PRELOAD E WITH 0
	AOSGE	2,3		;*AOSGE SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	3,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	2,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSN SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY

C54100:	MOVE	1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	2,-2		;PRELOAD E WITH -1,,-2
	AOSN	1,2		;*AOSN SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	2,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	1,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSN SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY

C54110:	MOVE	1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETO	2,		;PRELOAD E WITH -1,,-1
	AOSN	1,2		;*AOSN SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF AOSN DID NOT SKIP
	STOP
	CAME	2,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	1,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT AOSN INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=1, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSN SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY

C54120:	MOVE	1,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETZ	2,		;PRELOAD E WITH 0
	AOSN	1,2		;*AOSN SHOULD ADD 0,,1 TO C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	2,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	1,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEST INSTRUCTION IF C(E) IS GREATER THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-2
;BEFORE INCREMENTING.  HENCE, AOSG SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1
;RESPECTIVELY

C54200:	MOVE	0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	HRROI	1,-2		;PRELOAD E WITH -1,,-2
	AOSG	0,1		;*AOSG SHOULD ADD 0,,1 TO C(E),
				;AND NOT SKIP
	SKIPA			;PASS IF AOSG DID NOT SKIP
	STOP
	CAME	1,[-1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

;**********

;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=-1,,-1
;BEFORE INCREMENTING.  HENCE, AOSG SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0
;RESPECTIVELY

C54210:	MOVE	0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETO	1,		;PRELOAD E WITH -1,,-1
	AOSG	0,1		;*AOSG SHOULD ADD 0,,1 TO C(E),
				;AND NOT SKIP
	SKIPA			;PASS IF AOSG DID NOT SKIP
	STOP
	CAME	1,[0]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

;***********
;THIS TEST VERIFIES THAT AOSG INCREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, AOSG SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1
;RESPECTIVELY

C54220:	MOVE	0,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	SETZ	1,		;PRELOAD E WITH 0
	AOSG	0,1		;*AOSG SHOULD ADD 0,,1 TO C(E),
				;AND SKIP
	STOP
	CAME	1,[1]		;PASS IF E INCREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070] ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

;**********
SUBTTL	TEST OF MSCL SOJX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESTULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN 0.
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE, SOJL
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1

C54300:	MOVEI	17,0		;PRELOAD AC WITH 0
	SOJL	17,.+2		;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	17,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;***********

;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN 0.
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJL
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0.

C54310:	MOVEI	17,1		;PRELOAD AC WITH 0,,1
	SOJL	17,.+2			;*SOJL SHOULD SUBTRACT 0,,1 FROM C(AC)
	SKIPA			;PASS IF SOJL DID NOT JUMP
	STOP
	CAME	17,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJL DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN 0
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJ
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1

C54320:	MOVEI	17,2		;PRELOAD AC WITH 0,,2
	SOJL	17,.+2		;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJL DID NOT JUMP
	STOP
	CAME	17,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0.
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE, SOJE
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1

C54400:	MOVEI	16,0		;PRELOAD AC WITH 0
	SOJE	16,.+2		;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJE DID NOT JUMP
	STOP
	CAME	16,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJ
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0

C54410:	MOVEI	16,1		;PRELOAD AC WITH 0,,1
	SOJE	16,.+2		;*SOJE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	16,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS EQUAL TO 0.
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJE
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1

C54420:	MOVEI	16,2		;PRELOAD AC WITH 0,,2
	SOJE	16,.+2		;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJE DID NOT JUMP
	STOP
	CAME	16,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE, SOJLE
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1

C54500:	MOVEI	15,0		;PRELOAD AC WITH 0
	SOJLE	15,.+2		;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	15,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUALTO 0.
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJLE
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0

C54510:	MOVEI	15,1		;PRELOAD AC WITH 0,,1
	SOJLE	15,.+2		;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	15,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJLE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS LESS THAN OR EQUAL TO 0.
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJLE
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1

C54520:	MOVEI	15,2		;PRELOAD AC WITH 0,,2
	SOJLE	15,.+2		;*SOJLE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF SOJLE DID NOT JUMP
	STOP
	CAME	15,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE, SOJA
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1

C54600:	MOVEI	14,0		;PRELOAD AC WITH 0
	SOJA	14,.+2		;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	14,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJA
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0

C54610:	MOVEI	14,1		;PRELOAD AC WITH 0,,1
	SOJA	14,.+2		;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	14,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJA DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM ALWAYS JUMPS TO THE LOCATION
;SPECIFIED BY E
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJA
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1

C54620:	MOVEI	14,2		;PRELOAD AC WITH 0,,2
	SOJA	14,.+2		;*SOJA SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	14,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE  RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE, SOJGE
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1

C54700:	MOVEI	13,0		;PRELOAD A C WITH 0
	SOJGE	13,.+2		;*SOJGE SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP
	SKIPA			;PASS IF SOJGE DID NOT JUMP
	STOP
	CAME	13,[-1]	;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN OR EQUAL TO 0
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJGE
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0

C54710:	MOVEI	13,1		;PRELOAD AC WITH 0,,1
	SOJGE	13,.+2		;*SOJ SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP
	STOP
	CAME	13,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIRIES THAT SOJGE DECREMENTS C(AC) BY 0,,1 AND PLACES THE
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS COMPARED
;TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED BY E IF C(AC IS
;GREATER THAN OR EQUAL TO 0.  IN THIS CASE, C(AC = 0,,2 BEFORE
;DECREMENTING.  HENCE, SOJGE SHOULD JUMP AND THE RESULT IN THE AC SHOULD
;BE 0,,1.

C54720:	MOVEI	13,2		;PRELOAD AC WITH 0,,2
	SOJGE	13,.+2		;*SOJGE SHOULD SUBTRACT0,,1 FROM C(AC)
				;AND JUMP.
	STOP
	CAME	13,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS NON-ZERO.
;IN THIS CASE, C(AC)=0 BEFORE DECREMENTING.  HENCE,SOJN
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1.

C55000:	MOVEI	12,0		;PRELOAD AC WITH 0
	SOJN	12,.+2		;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP.
	STOP
	CAME	12,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIRIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION SPECIFIED
;BY E IF C(AC) IS NON-ZERO.
;IN THIS CASE, C(AC) = 0,,1 BEFORE DECREMENTING.  HENCE, SOJN
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0.

C55010:	MOVEI	12,1		;PRELOAD AC WITH 0,,1
	SOJN	12,.+2		;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJN DID NOT JUMP
	STOP
	CAME	12,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIFIES THAT SOJN DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS NON-ZERO.
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJN
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1.

C55020:	MOVEI	12,2		;PRELOAD AC WITH 0,,2
	SOJN	12,.+2		;*SOJN SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND JUMP.
	STOP
	CAME	12,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0.
;IN THIS CASE, C(AC) = 0 BEFORE DECREMENTING.  HENCE, SOJG
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE -1,,-1.

C55100:	MOVEI	11,0		;PRELOAD AC WITH 0
	SOJG	11,.+2		;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJG DID NOT JUMP
	STOP
	CAME	11,[-1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
;THIS TEST VERIRIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0.
;IN THIS CASE, C(AC)=0,,1 BEFORE DECREMENTING.  HENCE, SOJG
;SHOULD NOT JUMP AND THE RESULT IN THE AC SHOULD BE 0.

C55110:	MOVEI	11,1		;PRELOAD AC WITH 0,,1
	SOJG	11,.+2		;*SOJG SHOULD SUBTRACT 0,,1 FROM C(AC)
				;AND NOT JUMP.
	SKIPA			;PASS IF SOJG DID NOT JUMP
	STOP
	CAME	11,[0]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********

;THIS TEST VERIFIES THAT SOJG DECREMENTS C(AC) BY 0,,1 AND
;PLACES THE RESULT BACK INTO THE AC.  THE RESULT IN THE AC IS
;COMPARED TO 0 AND THE PROGRAM JUMPS TO THE LOCATION
;SPECIFIED BY E IF C(AC) IS GREATER THAN 0.
;IN THIS CASE, C(AC)=0,,2 BEFORE DECREMENTING.  HENCE, SOJG
;SHOULD JUMP AND THE RESULT IN THE AC SHOULD BE 0,,1.

C55120:	MOVEI	11,2		;PRELOAD AC WITH 0,,2
	SOJG	11,.+2		;*SOJG SHOULD SUBTRACT O,,1 FROM C(AC)
				;AND JUMP.
	STOP
	CAME	11,[1]		;PASS IF C(AC) DECREMENTED CORRECTLY
	STOP

;**********
SUBTTL	TEST OF MSCL SOSX INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSL SHOULD SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND -1,,-1
;RESPECTIVELY.

C55200:	MOVE	0,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	1,0		;PRELOAD E WITH 0
	SOSL	0,1		;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E)
				;AND SKIP
	STOP
	CAME	1,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070]  ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

;**********

;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSL SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0
;RESPECTIVELY.

C55210:	MOVE	0,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	1,1		;PRELOAD E WITH 0,,1
	SOSL	0,1		;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E),
				;AND NOT SKIP.
	SKIPA			;PASS IF SOSL DID NOT SKIP
	STOP
	CAME	1,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070]  ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

;**********
;THIS TEST VERIFIES THAT SOSL DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSL SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0
;RESPECTIVELY.

C55211:	MOVE	0,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	1,1		;PRELOAD E WITH 0,,1
	MOVEM	1,E55211
	SOSL	0,E55211	;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E),
				;AND NOT SKIP.
	SKIPA			;PASS IF SOSL DID NOT SKIP
	STOP
	MOVE	1,E55211
	CAME	1,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070]  ;PASS IF C(AC) WAS NOT MODIFIED
	STOP

	SKIPA			;GO TO NEXT TEST
E55211:	0			;TEST WORD MEMORY

;**********
;THIS TEST VERIFIES THAT SOS DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=0, C(AC)=707070,,707070 AND C(E) 0,,2
;BEFORE INCREMENTING.  HENCE, SOSL SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0,,1
;RESPECTIVELY.

C55220:	MOVE	0,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	1,2		;PRELOAD E WITH 0,,2
	SOSL	0,1		;*SOSL SHOULD SUBTRACT 0,,1 FROM C(E),
				;AND NOT SKIP

	SKIPA			;PASS IF SOSL DID NOT SKIP
	STOP
	CAME	1,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	0,[707070,,707070]  ;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSE SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C55300:	MOVE	10,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	11,0		;PRELOAD E WITH 0
	SOSE	10,11		;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP

	SKIPA			;PASS IF SOSE DID NOT SKIP
	STOP
	CAME	11,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	10,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSE SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 707070,,707070 AND 0
;RESPECTIVELY.

C55310:	MOVE	10,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	11,1		;PRELOAD E WITH 0,,1
	SOSE	10,11		;*SOS SHOULD SUBTRACT 0,,1 FROM C(E)
				;UPDATE AC AND SKIP
	STOP
	CAME	11,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	10,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSE DECREMENTS C(E) BY 0,11 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=10, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING. HENCE, SOSE SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C55320:	MOVE	10,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	MOVEI	11,2		;PRELOAD E WITH 0,,2
	SOSE	10,11		;*SOSE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP

	SKIPA			;PASS IF SOSE DID NOT SKIP
	STOP
	CAME	11,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	10,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSLE SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C55400:	MOVE	7,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	10,0		;PRELOAD E WITH 0
	SOSLE	7,10		;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	10,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	7,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E. THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=7, C(AC)=070707,,070707 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSLE SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C55410:	MOVE	7,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	MOVEI	10,1		;PRELOAD E WITH 0,,1
	SOSLE	7,10		;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	10,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	7,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSLE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS LESS THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=7, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING.  HENCE, SOSLE SHOULD NOT SKIP; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C55420:	MOVE	7,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	10,2		;PRELOAD E WITH 0,,2
	SOSLE	7,10		;*SOSLE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF SOSLE DID NOT SKIP
	STOP
	CAME	10,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	7,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING. HENCE, SOSA SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C55500:	MOVE	6,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	7,0		;PRELOAD E WITH 0
	SOSA	6,7		;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	7,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	6,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THEAC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSA SHOULD BE 0 AND 0
;RESPECTIVELY.

C55510:	MOVE	6,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	7,1		;PRELOAD E WITH 0,,1
	SOSA	6,7		;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	7,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	6,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSA DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND ALWAYS SKIPS
;THE NEXT INSTRUCTION.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=6, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING.  HENCE, SOSA SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C55520:	MOVE	6,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	MOVEI	7,2		;PRELOAD E WITH 0,,2
	SOSA	6,7		;*SOSA SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	7,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	6,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSGE SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C55600:	MOVE	5,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	6,0		;PRELOAD E WITH 0
	SOSGE	5,6		;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF SOSGE DID NOT SKIP
	STOP
	CAME	6,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	5,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSGE SHOULD SKIP ; AND THE
;FINAL RESULTS IN ACAND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C55610:	MOVE	5,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	6,1		;PRELOAD E WITH 0,,1
	SOSGE	5,6		;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	6,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	5,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSGE DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN OR EQUAL TO 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=5, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING.  HENCE, SOSGE SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY.

C55620:	MOVE	5,[707070,,707070] ;PRELOAD AC WITH 707070,,707070
	MOVEI	6,2		;PRELOAD E WITH 0,,2
	SOSGE	5,6		;*SOSGE SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	6,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	5,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES SOSN DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSN SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C55700:	MOVE	4,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	5,0		;PRELOAD E WITH 0
	SOSN	4,5		;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	5,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	4,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC
;IN THIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSN SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C55710:	MOVE	4,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	5,1		;PRELOAD E WITH 0,,1
	SOSN	4,5		;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF SOSN DID NOT SKIP
	STOP
	CAME	5,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	4,[0]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSN DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS NON-ZERO
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;INtTHIS CASE, AC=4, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING.  HENCE, SOSN SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 0,,1
;RESPECTIVELY

C55720:	MOVE	4,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	5,2		;PRELOAD E WITH 0,,2
	SOSN	4,5		;*SOSN SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	5,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	4,[1]		;PASS IF ACWAS UPDATED IF AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIESTHAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0
;BEFORE INCREMENTING.  HENCE, SOSG SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE -1,,-1 AND -1,,-1
;RESPECTIVELY.

C56000:	MOVE	3,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	4,0		;PRELOAD E WITH 0
	SOSG	3,4		;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF SOSG DID NOT SKIP
	STOP
	CAME	4,[-1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	3,[-1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0.
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,1
;BEFORE INCREMENTING.  HENCE, SOSG SHOULD NOT SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0 AND 0
;RESPECTIVELY.

C56010:	MOVE	3,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	4,1		;PRELOAD E WITH 0,,1
	SOSG	3,4		;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND NOT SKIP
	SKIPA			;PASS IF SOSG DID NOT SKIP
	STOP
	CAME	4,[0]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	3,[0]		;PASS IF AC WAS UPDATED IS AC NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT SOSG DECREMENTS C(E) BY 0,,1 AND PLACES
;THE RESULT INTO E.  THE RESULT IN E IS COMPARED TO 0 AND SKIPS
;THE NEXT INSTRUCTION IF C(E) IS GREATER THAN 0
;IF THE AC IS NON-ZERO, THE RESULT IS ALSO PLACED INTO THE AC.
;IN THIS CASE, AC=3, C(AC)=707070,,707070 AND C(E)=0,,2
;BEFORE INCREMENTING.  HENCE, SOSG SHOULD SKIP ; AND THE
;FINAL RESULTS IN AC AND E SHOULD BE 0,,1 AND 011,
;RESPECTIVELY.

C56020:	MOVE	3,[707070,,707070]  ;PRELOAD AC WITH 707070,,707070
	MOVEI	4,2		;PRELOAD E WITH 0,,2
	SOSG	3,4		;*SOSG SHOULD SUBTRACT 0,,1 FROM C(E),
				;UPDATE AC AND SKIP
	STOP
	CAME	4,[1]		;PASS IF E DECREMENTED CORRECTLY
	STOP
	CAME	3,[1]		;PASS IF AC WAS UPDATED IF AC NON-ZERO
	STOP

;**********

	;JRST	BEGEND