PCjs Machines

Home of the original IBM PC emulator for browsers.

Logo

DEC PDP-10 KA10 Basic Instruction Diagnostic #5

The PDP-10 KA10 Basic Instruction Diagnostic #5 (MAINDEC-10-DAKAE) test code has been extracted from DAKAEM.MAC [original] for use with the PDP-10 Test Machine with Debugger below.

This diagnostic “TESTS THE FWT, ADD/SUB, PC CHANGE AND COMPARE INSTRUCTIONS.”

Resources for this diagnostic include:

[PCjs Machine "testka10"]

Waiting for machine "testka10" to load....

The Debugger’s assemble (“a”) command can be used to test the new built-in MACRO-10 Mini-Assembler, which supports a subset of the MACRO-10 assembly language.

This command:

a 30706 DAKAE.MAC

will automatically read the DAKAE.MAC source file (a slightly modified copy of DAKAEM.MAC), assemble it, and then load the binary output at the specified address.


DAKAE.TXT

				IDENTIFICATION
				--------------

	PRODUCT CODE:       AH-6859C-DD

	DIAGNOSTIC CODE:    DAKAE

	PRODUCT NAME:       DAKAEC0 DECSYSTEM10 PDP-10 KA10 BASIC
	                    INSTRUCTION DIAGNOSTIC (5)

	VERSION:            0.3

	DATE RELEASED:      JANUARY 1979

	MAINTAINED BY:      DIAGNOSTIC ENGINEERING

	AUTHOR:             BILL SCORZELLI

		        COPYRIGHT (C) 1967, 1979

	        DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.

	THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR  USE  ONLY  ON  A
	SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLUSION
	OF THE ABOVE COPYRIGHT NOTICE.   THIS  SOFTWARE,  OR  ANY  OTHER
	COPIES  THEREOF, MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE
	TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH SYSTEM AND TO ONE WHO
	AGREES  TO  THESE  LICENSE TERMS.  TITLE TO AND OWNERSHIP OF THE
	SOFTWARE  SHALL  AT   ALL  TIMES  REMAIN  IN  DIGITAL  EQUIPMENT
	CORPORATION.

	THE INFORMATION IN THIS DOCUMENT IS SUBJECT  TO  CHANGE  WITHOUT
	NOTICE  AND  SHOULD  NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
	EQUIPMENT CORPORATION.

	DIGITAL EQUIPMENT CORPORATION ASSUMES NO  RESPONSIBILITY FOR THE
	USE  OR  RELIABILITY  OF  ITS SOFTWARE IN EQUIPMENT WHICH IS NOT
	SUPPLIED BY DIGITAL EQUIPMENT CORPORATION.
	
							MAINDEC-10-DAKAE.TXT
							PAGE 2


			TABLE OF CONTENTS
			-----------------

1.0	ABSTRACT

2.0	REQUIREMENTS

2.1	EQUIPMENT

2.2	STORAGE

2.3	PRELIMINARY PROGRAMS

3.0	PROGRAM PROCEDURES

3.1	LOADING PROCEDURE

3.2	STARTING PROCEDURE

3.3	OPERATING PROCEDURE

4.0	ERRORS

5.0	ITERATION COUNTER

6.0	CYCLE TIME

7.0	OPERATIONAL VARIATIONS

8.0	MISCELLANEOUS

9.0	LISTING

							MAINDEC-10-DAKAE.TXT
							PAGE 3


1.0	ABSTRACT

	THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE
	FIFTH IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS.
	THE DIAGNOSTIC TESTS THE FWT, ADD/SUB, PC CHANGE
	AND COMPARE INSTRUCTIONS.

2.0	REQUIREMENTS

2.1	EQUIPMENT

	A PDP-10 KA10 WITH A MINIMUM OF 32K OF MEMORY

	PAPER TAPE READER
	DECTAPE (OPTIONAL)
	CONSOLE TELETYPE

2.2	STORAGE

	THE PROGRAM RUNS WITHIN 32K OF MEMORY.

2.3	PRELIMINARY PROGRAMS

	CONSOLE FUNCTIONS WORKING PROPERLY
	PAPER-TAPE OR DECTAPE READ-IN WORKING PROPERLY
	PREVIOUS PROCESSOR DIAGNOSTICS

							MAINDEC-10-DAKAE.TXT
							PAGE 4


3.0	PROGRAM PROCEDURES

3.1	LOADING PROCEDURE

	PAPER TAPE - HARDWARE READ-IN (READER DEVICE CODE 104)
	DECTAPE - LOAD WITH DIAMON (DECTAPE DEVICE CODE 320)

3.2	STARTING PROCEDURE

	STAND-ALONE STARTING ADDRESS IS 30000.

	IF THE DIAGNOSTIC FAILS TO START CORRECTLY TRY STARTING AT THE
	FIRST TEST INSTEAD OF AT THE BEGINNING OF THE CONTROL SEQUENCE.
	(SEE LISTING).

3.3	OPERATING PROCEDURE

	ONCE STARTED THE PROGRAM WILL CYCLE CONTINUALLY UNTIL STOPPED
	OR AN ERROR OCCURS.

4.0	ERRORS

	ERRORS ARE IN THE FORM OF HALT INSTRUCTIONS.  THE LISTING
	SHOULD BE CONSULTED TO DETERMINE THE CAUSE OF THE ERROR.  A
	NO OPERATION (JUMP) INSTRUCTION FOLLOWS EACH HALT.  THIS
	MAY BE USEFUL IN CONSTRUCTING A SCOPE LOOP TO CYCLE ON THE
	FAILING INSTRUCTION.

5.0	ITERATION COUNTER

	THE ITERATION COUNT OF THE PROGRAM IS DISPLAYED IN THE MEM-
	ORY INDICATORS (MI).  THIS COUNT IS A DECREMENTING COUNT AND
	INITIALLY STARTS AT -1 IN STAND-ALONE OPERATION.

6.0	CYCLE TIME

	THE CYCLE TIME OF THE PROGRAM IS IN THE MILLISECOND RANGE AND
	IS THEREFORE SUITABLE FOR TAKING MARGINS, VIBRATION TESTS, ETC.

							MAINDEC-10-DAKAE.TXT
							PAGE 5


7.0	OPERATIONAL VARIATIONS

	A.  DIAGNOSTIC MONITOR

	    THE PROGRAM IS USABLE WITH THE DIAGNOSTIC MONITOR TO PRO-
	    VIDE RELIABILITY TESTS, ACCEPTANCE TESTS, AND/OR TO PRO-
	    VIDE A QUICK METHOD OF ISOLATION OF A FAULT TO A PARTICULAR
	    AREA OF THE PROCESSOR.  CERTAIN PROCEDURES ARE USED WHEN
	    THE PROGRAM IS USED IN THIS MANNER.  THEY ARE:

	    1.  THE DIAGNOSTIC MONITOR TRANSFERS CONTROL TO THE PRO-
		GRAM AND STARTS IT AT LOCATION 30002.

	    2.  MONCTL - LOCATION 30043 IS USED AS THE DIAGNOSTIC MON-
		ITOR CONTROL FLAG WORD.

	B.  USER MODE

	    THE PROGRAM WILL OPERATE IN USER MODE AND AS SUCH PROVIDES
	    ASSURANCE THAT THE PROCESSOR IS PERFORMING ALL FUNCTIONS
	    CORRECTLY.  USER MODE STARTING ADDRESS IS 30000.

	C.  SYSTEM EXERCISER

	    STARTING ADDRESS IS 30003.  NO DATA SWITCHES ARE USED BY
	    THIS PROGRAM.

8.0	MISCELLANEOUS

	NONE

9.0	LISTING

DAKAE.HST

    THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DAKAE

************************************************************************

ORIGINAL VERSION:   0.1

ORIGINAL AUTHOR:    RICHARD MALISKA

ORIGINAL RELEASE:   16-MAR-72

************************************************************************

PRODUCT CODE:       MAINDEC-10-DAKAE

PRODUCT NAME:       BASIC INSTRUCTION DIAGNOSTIC #5

DATE RELEASED:      JANUARY 1977

VERSION:            0.2

UPDATE AUTHOR:      JOHN R. KIRCHOFF

CHANGES MADE:

    1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE.
************************************************************************

PRODUCT CODE:       MAINDEC-10-DAKAE

PRODUCT NAME:       BASIC INSTRUCTION DIAGNOSTIC #5

DATE RELEASED:      JANUARY 1979

VERSION:            0.3

UPDATE AUTHOR:      BILL SCORZELLI

CHANGES MADE:

    1. THE COMPARE INSTRUCTION TESTS DID NOT CHECK THE COMPARE OF 2
    NEGATIVE NUMBERS WITH THE CONTENTS OF THE (AC) BEING LARGER
    THAN THE CONTENTS OF (E). ADDED TEST C52205.

************************************************************************

DAKAE.MAC

[Download]

;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