PCjs Machines

a 30724 DAKAB.MAC

MAINDEC-10-DAKAB.TXT





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

	PRODUCT CODE:   MAINDEC-10-DAKAB-B-D

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

	FUNCTION:       BASIC INSTRUCTIONS 2

	VERSION:        0.2

	DATE RELEASED:  JANUARY 1977

	MAINTAINED BY:  DIAGNOSTIC ENGINEERING GROUP

	AUTHOR:         JOHN R. KIRCHOFF

COPYRIGHT(C) 1976,1977
DIGITAL EQUIPMENT CORPORATION
MARLBORO, MASS. 01752

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 EXECPT 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 DEC.

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

DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.

							MAINDEC-10-DAKAB.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-DAKAB.TXT
							PAGE 3


1.0	ABSTRACT

	THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE
	SECOND IN A SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS.
	THE DIAGNOSTIC TESTS SOME FOLLOWING INSTRUCTIONS.
	MOVE, COMPARE, TEST, HALF WORD AND BOOLE.
	IT ALSO TESTS THE ADDERS USING ADD 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-DAKAB.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-DAKAB.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

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

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

PRODUCT CODE:       MAINDEC-10-DAKAB

PRODUCT NAME:       BASIC INSTRUCTION DIAGNOSTIC #2

DATE RELEASED:      JANUARY 1977

VERSION:            0.2

UPDATE AUTHOR:      JOHN R. KIRCHOFF

CHANGES MADE:

    1. UPGRADE TO ALLOW COMPATABILITY WITH THE SUBROUTINE PACKAGE.

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

ORIGINAL VERSION:   0.1

ORIGINAL AUTHOR:    RICHARD MALISKA

ORIGINAL RELEASE:   16-MAR-72

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

;MACROS

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

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

SUBTTL	DIAGNOSTIC SECTION
	LALL

START:	;SETZM	USER#		;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	B00
	;SKIPL	MONCTL
	;TTCALL	3,PGMNAM		;MENTION OUR NAME
	JRST	STARTA		; GO START

PGMNAM:	ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (2) [DAKAB]
/

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


STARTA:	JRST	.+1

B00:
SUBTTL	TEST OF THE ADD INSTRUCTION

;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED
;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS,
;THE RESULT IS A NON-ZERO NUMBER IN THE AC.  FIRST, THE AC IS CLEARED;
;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD
;INSTRUCTION.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

	A10400:	MOVE	[0]		;PRESET AC TO ALL ZEROS
	ADD	[123456765432]	;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL
				;ZEROS SHOULD RESULT
				;IN AN AC CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
	STOP

;AD ADD [ADC1], AD ADD EN [ADC1],
;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP],
;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1]

;**********

;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

A10500:	MOVE	[123456765432]	;PRESET AC WITH A NON-ZERO NUMBER
	ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC
				;CONTAINING A NON-ZERO NUMBER
				;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
	STOP

;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E],
;AR AD ET2 EN [ARMA], IR ADSUB [IR1]

;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

A10600:	MOVE	[XWD 123456,0]	;PRESET AC WITH A NON-ZERO NUMBER
	ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
				;A NON-ZERO NUMBER SHOULD RESULT IN AN AC
				;CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
	STOP

;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E],
;AR AD ET2 EN [ARMA], IR AD SUB [IR1]

;*********

;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

A10700:	MOVE	[123456]	;PRESET AC WITH A NON-ZERO NUMBER
	ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
				;A NON-ZERO NUMBER
				;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IS C(AC) IS NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
;IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

A13300:	MOVE	[0]		;PRESET AC WITH ALL ZEROS
	ADD	[123456,,0]	;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
				;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
;IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO

A13400:	MOVE	[0]		;PRESET AC WITH ALL ZEROS
	ADD	[123456]	;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
				;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
	SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
	STOP

;**********
;ADD ZERO TO A RIPPLED ONE

SN=11000
	ZZ=0

A11000:	REPEAT	^D36,
<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
;A WORD OF ALL ZEROS IS ADDED TO AN
;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
;EVERY BIT OF THE AC.
;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
	ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
	EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
	EQV	[0]		;RESULTS IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
;IR ADDX [IR1], IR ADSUB [IR1]

;**********
PAGE
>
;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF
;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN
;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD
;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN
;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0

A11100:	MOVE	[0]		;PRESET AC TO ZERO
	ADD	[0]		;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;FCE[F1], IR AD SUB [IR1]
;AD FM + EN [ADFP], AD FM + EN A [ADFP],
;F CYC ACT EN C[F1], IR ADSUB [IR1]

;**********
;ADD ZERO TO A RIPPLED ONE

SN=13200
	ZZ=0

A13200:	REPEAT	^D36,
<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
;TO AN AC  OF ALL ZEROS IS ADDED A
;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
;EVERY BIT OF THE AC.
;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[0]		;LOAD AC WITH ALL ZEROS
	ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
	EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
	EQV	[0]		;RESULTS IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
PAGE
;ADD A RIPPLED ONE TO A RIPPLED ONE

SN=11200
	ZZ=0

A11200:	REPEAT	^D35,
<;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
;RESULT IN THE AC WILL BE ZERO AND THE TEST
;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
;SO THAT A ONE WILL BE FLOATED THROUGH
;BITS 1 THRU 35 OF BOTH AC AND E
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
	ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
	EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
	EQV	[0]		;RESULTS IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
SN=11300
	ZZ=0
	YY=0

A11300:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
;FORMER VALUE PLUS THE CURRENT C(AC)
SN=SN+1
	YY=YY/2
	ZZ=ZZ+YY
	IFE	YY,<YY=400000>
	IFE	ZZ,<ZZ=400000>
	MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
	ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
				;POWER SHOULD RESULT IN C(AC)=0.
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
PAGE
SN=11400
	ZZ=0
	YY=0

A11400:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
;FORMER VALUE PLUS THE CURRENT C(AC)
SN=SN+1
	YY=YY/2
	ZZ=ZZ+YY
	IFE	YY,<YY=400000>
	IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
	MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
				;POWER SHOULD RESULT IN C(AC)=0.
	ADD	[YY]		;PASS TEST IF C(AC)=0
	SKIPE
	STOP

;**********
>
SUBTTL	SPECIAL KI10 FOUR BIT ADDER TEST

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32.

A13500:	MOVE	[-1,,-5]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32
	EQV	[-1,,-4]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28.

A13600:	MOVE	[-1,,-101]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28
	EQV	[-1,,-100]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24.

A13700:	MOVE	[-1,,-2001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24
	EQV	[-1,,-2000]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20.

A14000:	MOVE	[-1,,-40001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20
	EQV	[-1,,-40000]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17.

A14100:	MOVE	[-1,,-400001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17
	EQV	[-1,,400000]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13.

A14200:	MOVE	[-11,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13
	EQV	[-10,,0]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9.

A14300:	MOVE	[-201,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9
	EQV	[-200,,0]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5.

A14400:	MOVE	[-4001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5
	EQV	[-4000,,0]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1.

A14500:	MOVE	[-100001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1
	EQV	[-100000,,0]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0.

A14600:	MOVE	[-200001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0
	EQV	[600000,,0]	;RESULT IN AC=ALL ONES
	EQV	[0]		;RESULT IN AC=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35.

A14700:	MOVE	[-1,,-1]	;PRESET AC WITH ALL ONES
	ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
SUBTTL	TEST OF SUB AND COMPARE INSTRUCTIONS

;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS
;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC
;IS NEGATIVE

A11500:	MOVE	[0]		;PRESET AC TO ZERO
	SUB	[XWD 0,-1]	;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS
				;SHOULD RESULT IN C(AC) NEGATIVE
	SKIPL			;PASS TEST IF C(AC) IS NEGATIVE
	STOP

;AD AR- EN D [ADAM], F CYC ACT ENB [F1],
;IR SUBX[IR1], IR ADSUB[IR1]

;**********

;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS
;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT
;IS AN AC OF ZEROS.

A11600:	MOVE	[0]		;PRESET AC TO ZERO
	SUB	[0]		;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP
;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1]

;**********
PAGE
SN=11700
	ZZ=0

A11700:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT IF A RIPPLED ONE
;IS SUBTRACTED FROM ITSELF, THE RESULT IS
;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
;TIMES IN ORDER TO TEST ALL 36 BITS.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
	SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
PAGE
;THIS TEST VERIFIES THAT IF A WORD OF ALL
;ONES IS SUBTRACTED FROM ITSELF, THE RESULT
;IN THE AC IS ZERO.

A12000:	MOVE	[-1]		;PRESET AC TO ALL ONES
	SUB	[-1]		;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE
;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC
;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS.

A12100:	MOVE	[0]		;PRESET AC, E TO ZERO
	CAMA			;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION,
				;OTHERWISE THIS TEST FAILS
	STOP

;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR],
;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR],
;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3],
;ADZ COND P[ADZ] AND ADZ COND Z[ADZ]

;**********

;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY
;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND
;C(AC)=C(E)=0. HENCE, CAME MUST
;SKIP THE NEXT INSTRUCTION
;IN THIS TEST

A12200:	MOVE	[0]		;PRESET AC, E TO ZERO
	CAME			;*CAME SHOULD SKIP SINCE E=AC
	STOP

;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3]

;**********
;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE
;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF
;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0;
;BUT, E IS NOT WITHIN THE AC RANGE.
;HENCE, CAME MUST SKIP
;THE NEXT INSTRUCTION IN THIS TEST.

A12300:	MOVE	[0]		;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0
	CAME	[0]
	STOP

;CAMX: FCE[F1], IR CAMX[IR1]

;**********

;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF
;C(AC)=C(E). IN THIS TEST C(AC)=0 AND
;C(E)=-1. HENCE, CAME SHOULD NOT
;SKIP THE NEXT INSTRUCTION IN THIS TEST.

A12400:	MOVE	[0]		;PRESET AC TO ZERO
	CAME	[-1]		;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=-
	SKIPA			;SKIP HALT INSTRUCTION IF CAME PASSES TEST
	STOP

;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1],
;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP],
;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1]

;**********
SUBTTL	TEST OF COMPARE (CAMX) INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP.  OTHERWISE,THE
;PROGRAM HALTS.

B100:	MOVE	[-1]		;PRELOAD AC WITH -1
	CAML	[0]		;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
	STOP

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

;				FC: AB PC EN
;				ET0: COND Q: PC CLK EN

;**********

;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
;THE PROGRAM HALTS.

B200:	MOVE	[0]		;PRELOAD AC WITH 0
	CAML	[-1]		;*CAML SHOULD NOT SKIP BECAUSE
				;C(AC) IS GREATER THAN C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
	STOP

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

;				SW: FCE
;				FC: PC CHANGE

;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=400000,,0 (THE MOST
;NEGATIVE NUMBER) AND C(E)=377777,,-1
;(THE MOST POSITIVE NUMBER); HENCE,
;CAML SHOULD SKIP.  OTHERWISE, THE
;PROGRAM HALTS

B300:	MOVE	[XWD 400000,0]	;PRELOAD AC WITH 400000,,0
	CAML	[XWD 377777,-1]	;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
	STOP

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

;				FC: AD ADD

;**********

;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEGATIVE NUMBER)
;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE, THE PROGRAM HALTS.

B400:	MOVE	[XWD 377777,-1]	;PRELOAD AC WITH 377777,,-1
	CAML	[XWD 400000,0]	;*CAML SHOULD NOT SKIP BECAUSE
				;C(AC) IS GREATER THAN C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1;
;HENCE, CAML SHOULD SKIP.  OTHERWISE, THE PROGRAM HALTS

B500:	MOVE	[XWD 400000,0]	;PRELOAD AC WITH 400000,,0
	CAML	[-1]		;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
	STOP

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

;				FC: AD FM + EN

;**********

;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
;THE PROGRAM HALTS.

B600:	SETZ			;PRELOAD AC WITH 0
	CAML	[-1]		;*CAML SHOULD NOT SKIP BECAUSE
				;C(AC) IS GREATER THAN C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES.
	STOP

;**********
;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
;THE PROGRAM HALTS.

B700:	SETZ			;PRELOAD AS WITH 0
	CAML	[0]		;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
	STOP

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

;				FC: AD CRY 36

;**********

;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS LESS THAN C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER);
;HENCE CAML SHOULD NOT SKIP.  OTHERWISE, THE PROGRAM HALTS.

B1000:	SETZ			;PRELOAD AC WITH 0
	CAML	[XWD 400000,0]	;*CAML SHOULD NOT SKIP BECAUSE
				;C(AC) IS GREATER THAN C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT.  IT NEVER SKIPS
;THE NEXT SEQUENTIAL INSTRUCTION
;IN THIS CASE, C(AC)=-1 AND C(E)=0
;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS

B1100:	MOVE	[-1]		;PRELOAD AC WITH -1
	CAM	[0]		;*CAM SHOULD NEVER SKIP
	SKIPA			;SKIP HALT INSTRUCTION IF CAM PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E).
;IN THIS CASE, C(AC)=-1 AND C(E)=0;  HENCE, CAMGE SHOULD NOT SKIP.
;OTHERWISE, THE PROGRAM HALTS.

B1200:	MOVE	[-1]		;PRELOAD AC WITH-1
	CAMGE	[0]		;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E)
	SKIPA			;SKIP HALT INSTRUCTION IF CAMGE PASSES.
	STOP

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

;				FC: PC CHANGE
;				FC: AB PC EN

;**********
;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=-1;  HENCE CAMGE SHOULD SKIP.
;OTHEWISE, THE PROGRAM HALTS.

B1300:	SETZ			;PRELOAD AC WITH 0
	CAMGE	[-1]		;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E)
	STOP

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

;				SW: FCE
;				ET0: COND Q: PC CLK EN

;**********

;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
;IN THIS CASE C(AC)=0 AND C(E)=-1;  HENCE CAMN SHOULD SKIP.
;OTHERWISE, THE PROGRAM HALTS

B1400:	SETZ			;PRELOAD AC WITH 0
	CAMN	[-1]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
	STOP

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

;				FC:AD FM + EN
;				FC: AD AR - EN
;				FC: AD CRY 36
;				FC: AD ADD
;				FC: AB PC EN
;				ET0: PC CLK EN

;**********
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=0;  HENCE CAMN SHOULD NOT SKIP.
;OTHERWISE, THE PROGRAM HALTS

B1500:	SETZ			;PRELOAD AC WITH 0
	CAMN	[0]		;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E).
	SKIPA			;SKIP HALT INSTRUCTION IF CAMN PASSES
	STOP

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

;				SW: FCE
;				FC: PC CHANGE

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

B1600:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
	CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)
	CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
	STOP

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

;				ET0: COND P

;**********
>
	ZZ=0

	REPEAT	^D18,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
	CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)
	CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
	STOP

;**********
>
SN=1700
	ZZ=0

B1700:	REPEAT	^D36,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	SETZ			;PRELOAD AC WITH 0
	CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
	STOP

;**********
>
SN=2000
	ZZ=0

B2000:	REPEAT	^D36,<
;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1
	CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
	STOP

;**********
>
SUBTTL	TEST OF MOVS INSTRUCTION

;**********

SN=2100
	ZZ=0

B2100:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
				;AND MOVE RESULT INTO AC
	CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
	STOP

;**********
>
SN=2200
	ZZ=0

B2200:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF

SN=SN+1
	ZZ=ZZ+ZZ+1
	IFE	<ZZ-1>,<ZZ=-2>
	MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
				;AND MOVE RESULT INTO AC
	CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
	STOP

;**********
>
SN=2300
	ZZ=0
	YY=0

B2300:	REPEAT	^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU THE LEFT HALF OF E
;AND A 0 IS RIPPLED THRU THE RIGHT HALF
;OF E [C(E)=ZZ,,YY, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0].
;THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF
;THE LEFT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E

SN=SN+1
	ZZ=ZZ+ZZ
	YY=YY+YY+1
	IFE	ZZ,<ZZ=1>
	IFE	<YY-1>,<YY=-2>
	MOVS	[XWD ZZ,YY]	;*MOVS SHOULD SWAP HALVES OF C(E)
				;AND MOVE RESULT INTO AC
	CAME	[XWD YY,ZZ]	;PASS TEST IF AC CONTAINS YY,,ZZ
	STOP

;**********
>
SN=2400
	ZZ=0
	YY=0

B2400:	REPEAT	 ^D18,<
;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU THE LEFT HALF OF E
;AND A 1 IS RIPPLED THRU THE RIGHT HALF
;OF E [C(E)=YY,,ZZ, WHERE ZZ IS A FLOATING 1 AND YY IS A FLOATING 0].
;THEN, C(AC) IS CHECKED.
;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF
;THE RIGHT HALF AND A 0 THRU ALL 18 BITS OF THE RIGHT HALF OF E

SN=SN+1
	ZZ=ZZ+ZZ
	YY=YY+YY+1
	IFE	ZZ,<ZZ=1>
	IFE	<YY-1>,<YY=-2>
	MOVS	[XWD YY,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
				;AND MOVE RESULT INTO AC
	CAME	[XWD ZZ,YY]	;PASS TEST IF C(AC)=ZZ,,YY
	STOP

;**********
>
SUBTTL	TEST OF COMPARE (CAXX) INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=E
;IN THIS CASE C(AC)=E=0;  HENCE, CAIE SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS

B2500:	SETZ			;PRELOAD AC TO 0
	CAIE			;*CAIE SHOULD SKIP BECAUSE C(AC)=E
	STOP

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

;				SW: PC CHANGE
;				FC: AD FM ; EN
;				FC: AD CRY 36
;				FC: AB PC EN
;				ET0: COND P: PC CLK EN

;**********

;THIS TEST VERIFIES THAT CAIE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=E
;IN THIS CASE C(AC)=E=1.  HENCE, CAIE SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS

B2600:	MOVE	[1]		;PRELOAD AC TO 1
	CAIE	1		;*CAIE SHOULD SKIP BECAUSE C(AC)=E
	STOP

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

;				FC: AD AR - EN

;**********

;THIS TEST VERIFIES THAT CAME SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN
;AND ONLY WHEN C(AC)=C(E)
;IN THIS CASE C(AC)=C(E)=1;  HENCE, CAME SHOULD SKIP
;OTHERWISE THE PROGRAM HALTS

B2700:	MOVEI	1		;PRELOAD AC TO 1
	CAME	[1]		;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)
	STOP

;**********
SUBTTL	TEST OF BOOLEAN INSTRUCTIONS

;**********

;THIS TEST VERIFIES THAT SETCA IGNORES THE ADDRESS FIELD OF THE INSTUCTION WORD.
;IN THIS CASE C(AC)=0,,-1;  HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES.

B3000:	MOVEI	-1		;PRELOAD AC TO 0,,-1
	SETCA	[-1]		;*SETCA SHOULD PUT -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS TEST IF C(AC)=-1,,0
	STOP

;**********

;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(AC)=0,,-1;  HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES

B3100:	MOVEI	-1		;PRELOAD AC TO 0,,-1
	SETCA			;*SETCA SHOULD PUT -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS TEST IF C(AC) =-1,,0
	STOP

;**********
;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC,
;IN THIS CASE C(AC)=0,,0  HENCE, THE RESULT IN THE AC SHOULD BE,-1
;IF THE RESULT IN THE AC IS -1,,-1, THE TEST PASSES

B3200:	MOVEI	0		;PRELOAD AC TO 0,,0
	SETCA			;*SETCA SHOULD PUT -1,,-1 INTO THE AC
	CAME	[-1]		;PASS TEST IF C(AC) =-1,,-1
	STOP

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

;0				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT SETCA COMPLEMENTS C(AC), THEN PLACES THE
;RESULT IN THE AC,
;IN THIS CASE C(AC)=-1,,-1;  HENCE, THE RESULT IN THE AC SHOULD BE 0,,0
;IF THE RESULT IN THE AC IS ZERO, THE TEST PASSES

B3300:	MOVE	[-1]		;PRELOAD AC TO -1,,-1
	SETCA			;*SETCA SHOULD PUT 0,,0 INTO THE AC
	CAME	[0]		;PASS TEST IF C(AC) IS ZERO
	STOP

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

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

;**********
;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE AC=E AND C(E)=C(AC)=0,,-1;  HENCE, THE RESULT IN THE AC SHOULD BE -1,,0
;IF THE RESULT IN THE AC IS -1,,0, THE TEST PASSES

B3500:	MOVEI	-1		;PRELOAD AC TO 0,,-1
	SETCM			;*SETCM SHOULD PUT -1,,0 INTO THE AC
	CAME	[-1,,0]		;PASS TEST IF C(AC) =-1,,0
	STOP

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

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

;**********

;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(E)=-1,,-1;  HENCE, THE RESULT IN THE AC SHOULD BE 0,,0
;IF THE RESULT IN THE AC IS ZERO,THE TEST PASSES

B3600:	SETCM	[-1]		;*SETCM SHOULD PUT 0 INTO THE AC
	SKIPE			;PASS TEST IF C(AC0)=0
	STOP

;**********
;THIS TEST VERIFIES THAT SETCM COMPLEMENTS C(E), THEN PLACES THE
;RESULT IN THE AC.
;IN THIS CASE C(E)=0,,0;  HENCE, THE RESULT IN THE AC SHOULD BE -1,,-1
;IF THE RESULT IN THE AC IS -1,,-1,THE TEST PASSES

B3700:	SETCM	[0]		;*SETCM SHOULD PUT -1,,-1 INTO THE AC
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT SETO SETS C(AC) TO -1,,-1.  SETO IGNORES
;THE ADDRESS FIELD OF THE INSTRUCTION WORD.
;FIRST C(AC) IS SET TO 0,,0; THEN SETO IS EXECUTED.
;THE AC IS THEN CHECKED FOR ALL ONES.  IF C(AC) IS ALL ONES,
;THE TEST PASSES

B4300:	MOVEI	0		;PRELOAD AC WITH 0,,0
	SETO			;*SETO SHOULD LOAD THE AC WITH -1,,-1
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

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

;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0.
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS NON-ZERO.
;IF C(AC) IS NOT=0, THE TEST PASSES

B4400:	MOVEI	0		;PRELOAD AC,E WITH 0
	ORCM			;*ORCM SHOULD PUT ALL ONES INTO AC0
	SKIPN			;PASS IF C(AC) IS NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=0
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1
;IF C(AC0)=-1,,-1, THE TEST PASSES

B4500:	MOVEI	0		;PRELOAD AC,E WITH 0
	ORCM			;*ORCM SHOULD PUT ALL ONES INTO AC0
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

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

;0				SW: ET0
;0				FC: AD AR + EN
;0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=MEMORY=AC0 AND C(AC)=C(E)=-1,,-1
;HENCE THE RESULT IN THE AC SHOULD BE ALL ONES.
;THE AC IS CHECKED FOR ITS FINAL CONTENTS EQUAL TO -1,,-1
;IF C(AC0)=-1,,-1, THE TEST PASSES

B4600:	MOVE	[-1]		;PRELOAD AC,E WITH -1,,-1
	ORCM			;*ORCM SHOULD PUT ALL ONES INTO AC0
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

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

;0				FC: AD FM - EN
;0				ET0: AR AD EN

;**********

;THIS TEST VERIFIES THAT ORCM CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1; HENCE, THE RESULT
;IN THE AC SHOULD BE 0.  THE AC IS CHECKED FOR ITS INAL CONTENTS=0.
;IF C(AC)=0, THE TEST PASSES

B4700:	MOVEI	0		;PRELOAD AC WITH 0
	ORCM	[-1]		;*ORCM SHOULD PLACE ALL ZEROS INTO THE AC
	SKIPE			;PASS IF C(AC)=0,,0
	STOP

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

;-E				SW: FCE

;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=0,,0.  HENCE THE
;RESULT IN THE AC SHOULD BE 0,,0.
;THE AC IS CHECKED FOR 0,,0.  IF C(AC)=0,,0, THIS TEST PASSES

B5000:	MOVEI	0		;PRELOAD AC,E WITH 0,,0
	IOR			;*IOR SHOULD PUT 0 INTO AC
	SKIPE			;PASS TEST IF C(AC)=0,,0
	STOP

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

;-1,,-1				SW: ET0
;-1,,-1				ET0: AR AD EN
;-1,,-1				ET0: AD AR - EN
;-1,,-1				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1.
;THE AC IS CHECKED FOR -1,,-1
;IF C(AC) =-1,,-1 THE TEST PASSES.

B5100:	MOVEI	0		;PRELOAD AC WITH 0
	IOR	[-1]		;*IOR SHOULD PUT -1,,-1 INTO AC
	CAME	[-1]		;PASS TEST IF C(AC)  =-1,,-1
	STOP

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

;E				SW: FCE
;0				FC: AD AR - EN

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

;0				FC: AD FM - EN

NB5300:;**********
;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES
;IF C(AC)=-1, THE TEST PASSES

B5200:	SETO			;PRELOAD AC WITH -1,,-1
	IOR	[-1]		;*IOR SHOULD PUT -1,,-1 INTO AC
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT IOR CHANGES C(AC) TO THE LOGICAL
;INCLUSIVE OR OF C(AC) WITH C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE
;RESULT IN THE AC SHOULD BE -1,,-1
;THE AC IS CHECKED FOR ITS CONTENTS = ALL ONES
;IF C(AC)=-1,,-1, THE TEST PASSES

B5300:	SETO			;PRELOAD AC WITH -1,,-1
	IOR	[0]		;*IOR SHOULD PUT -1,,-1 INTO AC
	CAME	[-1]		;PASS TEST IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=-1,,0.  HENCE, THE RESULT
;IN THE AC SHOULD BE 0,,-1
;THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1, THE TEST PASSES

B5500:	SETO			;PRELOAD AC WITH ALL ONES
	ANDCM	[XWD -1,0]	;*ANDCM SHOULD PLACE 0,,-1 IN THE AC
	CAME	[0,,-1]		;IF C(AC)=0,,-1, THE TEST PASSES
	STOP

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

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

;**********

;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0.  HENCE,
;THE RESULT IN THE AC SHOULD BE 0.  THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES.

B5600:	SETO			;PRELOAD AC WITH ALL ONES
	ANDCM			;*ANDCM SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES.
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=-1,,-1, AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE ALL ONES.  THE AC IS CHECKED FOR -1,,-1.
;IF C(AC)=-1,,-1, THE TEST PASSES

B5700:	SETO			;PRELOAD AC WITH 0
	ANDCM	[0]		;*ANDCM SHOULD PLACE -1,,-1 IN THE AC
	CAME	[-1]		;IF C(AC)=-1,,-1, THE TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES

B6000:	MOVEI	0		;PRELOAD AC WITH 0
	ANDCM			;*ANDCM SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES.
	STOP

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

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

;**********
;THIS TEST VERIFIES THAT ANDCM CHANGES C(AC) TO THE LOGICAL AND
;OF C(AC) AND THE COMPLEMENT OF C(MEMORY).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1. HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.
;IF C(AC)=0, THE TEST PASSES

B6100:	SETZ			;PRELOAD AC WITH 0
	ANDCM	[-1]		;*ANDCM SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR ZERO.  IF C(AC) IS
;EQUAL TO ZERO, THE TEST PASSES.

B6200:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	ANDCA	[0]		;*ANDCA SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES.
	STOP

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

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

;**********

;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070.  HENCE, THE
;RESULT IN THE AC SHOULD BE 0,,707070.  THE AC IS CHECKED
;FOR 0,,707070.  IF C(AC)=0,,707070, THE TEST PASSES.

B6300:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	ANDCA	[707070707070]	;*ANDCA SHOULD PLACE 0,,707070 IN THE AC
	CAME	[XWD 0,707070]	;IF C(AC)=0,,707070, THE TEST PASSES
	STOP

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

;707070,,707070			FC: AD FM - EN
;707070,,707070			ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=0. HENCE, THE RESULT
;IN THE AC SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC=0,
;THE TEST PASSES.

B6400:	SETZ			;CLEAR THE AC AND E
	ANDCA			;*ANDCA SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR ALL ONES.
;IF C(AC)=-1,,-1, THE TEST PASSES.

B6500:	SETZ			;CLEAR THE AC
	ANDCA	[-1]		;*ANDCA SHOULD PLACE ALL ONES IN THE AC
	CAME	[-1]		;IF C(AC)=ALL ONES, THE TEST PASSES.
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE AC=E=AC0 AND C(AC)=C(E)=-1,,-1. HENCE, THE RESULT
;IN THE AC SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0,
;THE TEST PASSES.

B6600:	SETO			;PRESET AC TO ALL ONES
	ANDCA			;*ANDCA SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT ANDCA CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0,
;THE TEST PASSES.

B6700:	SETO			;PRESET AC TO ALL ONES
	ANDCA	[0]		;*ANDCA SHOULD PLACE 0 IN THE AC
	SKIPE			;IF C(AC)=0, THE TEST PASSES.
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0; HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1,
;THIS TEST PASSES.

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

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

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

;**********

;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION
;OF THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=-1,,-1; HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0,
;THIS TEST PASSES.

B7100:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	ANDCB	[-1]		;*ANDCB SHOULD PLACE 0 IN AC
	SKIPE			;PASS IF C(AC)=0
	STOP

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

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

;**********

;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE ALL ONES.  THE AC IS CHECKED FOR ALL ONES.  IF C(AC)=-1,,-1,
;THE TEST PASSES.

B7200:	SETZ			;PRELOAD AC,E WITH ZEROES
	ANDCB			;*ANDCB SHOULD PLACE ALL ONES IN THE AC
	CAME	[-1]		;PASS IF C(AC) IS ALL ONES
	STOP

;**********

;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE AC=E AND C(AC)=C(E)=-1,,-1.  HENCE THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

B7300:	SETO			;PRELOAD AC,E WITH ONES
	ANDCB			;*ANDCB SHOULD PLACE ALL ZEROS IN THE AC
	SKIPE			;PASS IF C(AC)=0
	STOP

;**********
;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

B7400:	SETZ			;PRELOAD AC WITH 0
	ANDCB	[-1]		;*ANDCB SHOULD PLACE 0 IN THE AC
	CAIE			;PASS IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT ANDCB CHANGES C(AC) TO THE LOGICAL AND FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

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

;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0,,-1.  THE AC IS CHECKED FOR 0,,-1.  IF C(AC)=0,,-1,
;THIS TEST FAILS.

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

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

;-1,,0				SW: ET0
;-1,,0				FC: AD AR - EN
;0				FC: AD FM + EN
;-1,,-1				ET0: AR AD EN
;-1,,-1				ET0: AD AR - EN
;-1,,0				ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,0 AND C(E)=707070,,707070.  HENCE, THE RESULT IN THE AC
;SHOULD BE 707070,,-1.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0,
;THIS TEST FAILS.

B10000:	MOVE	[XWD -1,0]	;PRELOAD AC WITH -1,,0
	ORCA	[707070707070]	;*ORCA SHOULD PLACE 707070,,-1 IN THE AC
	CAME	[XWD 707070,-1]	;PASS IF C(AC)=707070,,-1
	STOP

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

;0,,-1				SW: FCE

;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, AC=E AND C(AC)=C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

B10100:	SETZ			;PRELOAD AC,E WITH 0
	ORCA			;*ORCA SHOULD PLACE -1,,-1 IN THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********

;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OF FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE, AC=E AND C(AC)=C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

B10200:	SETO			;PRELOAD AC,E WITH 0
	ORCA			;*ORCA SHOULD PLACE -1,,-1 IN THE AC
	CAME	[-1]		;PASS IF C(AC)=-1,,-1
	STOP

;**********
;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESUTL IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES.

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

;**********

;THIS TEST VERIFIES THAT ORCA CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND C(E).
;IN THIS CASE C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES.

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

;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=-1,,0 AND C(E)=707070,,707070.  HENCE THE RESULT
;IN THE AC 070707,,-1.  THE AC IS CHECKED FOR 070707,,-1.  IF C(AC)=070707,,-1,
;THIS TEST PASSES

B10500:	MOVE	[XWD -1,0]	;PRELOAD THE AC WITH -1,,0
	ORCB	[707070707070]	;*ORCB SHOULD PLACE 070707,,-1 IN THE AC
	CAME	[XWD 070707,-1]	;PASS IF C(AC)=070707,,-1
	STOP

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

;-1,,-1				SW: FCE
;707070,,0			SW: ET0
;0,,-1				FC: AD AR + EN
;070707,,070707			FC: AD FM + EN
;070707,,070707			ET0: AR AD EN
;-1,,-1				ET0: AD AR - EN
;707070,,0			ET2: AR AD EN

;**********

;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=0,,-1 AND C(E)=-1,,-1.  HENCE THE RESULT
;IN THE AC -1,,0.  THE AC IS CHECKED FOR -1,,0.  IF C(AC)=-1,,0,
;THIS TEST PASSES

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

;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=0 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)-1,,-1, THE TEST PASSES

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

;**********

;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE 0.  THE AC IS CHECKED FOR 0.  IF C(AC)=0, THE TEST PASSES

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

;**********
;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E)
;IN THIS CASE, C(AC)=0 AND C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES

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

;**********

;THIS TEST VERIFIES THAT ORCB CHANGES C(AC) TO THE LOGICAL OR FUNCTION OF
;THE COMPLEMENT OF C(AC) AND THE COMPLEMENT OF C(E).
;IN THIS CASE, C(AC)=-1,,-1 AND C(E)=0.  HENCE, THE RESULT IN THE AC
;SHOULD BE -1,,-1.  THE AC IS CHECKED FOR -1,,-1.  IF C(AC)=-1,,-1, THE TEST PASSES

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

;**********
SUBTTL	TEST OF MOVN INSTRUCTION

;**********

;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC
;IN THIS CASE C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0, THE NEGATIVE OF 0.  IF C(AC)=0, THIS TEST PASSES

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

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

;E				SW: FCE
;-1,,-1				FC: AD FM + EN
;-1,,-1				FC: AD CRY 36

;**********

;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC.
;IN THIS CASE C(E)=-1,,0.  HENCE, THE RESULT IN THE AC SHOULD BE 1,,0
;THE AC IS CHECKED FOR 1,,0.  IF C(AC)=1,,0, THE TEST PASSES

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

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

;0				FC: AD ADD
;0				FC: AD FM - EN
;0				FC: AD AR - EN
;-1,,0				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC.
;IN THIS CASE C(E) =707070,,707070.  HENCE, THE RESULT IN THE AC SHOULD BE
;070707,,070710.  THE AC IS CHECKED FOR 070707,,070710.  IF C(AC)=
;070707,,070710, THE TEST PASSES

B11700:	SETZ			;PRELOAD AC WITH 0
	MOVN	[707070707070]	;*MOVN SHOULD PLACE 070707,,070710 INTO THE AC
	CAME	[070707070710]	;PASS IF C(AC) 070707,,070710
	STOP

;**********

;THIS TEST VERIFIES THAT MOVN PLACES THE NEGATIVE OF C(E) INTO THE AC
;IN THIS CASE C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0,,1.
;THE AC IS CHECKED FOR 0,,1, THE NEGATIVE OF -1,,-1.  IF C(AC)=1, THIS TEST PASSES

B12100:	MOVN	[-1]		;*MOVN SHOULD PLACE 0,,1 INTO THE AC
	CAIE	1		;PASS OF C(AC)=0,,1
	STOP

;**********
SUBTTL	TEST OF MOVM INSTRUCTION

;**********

;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC.
;IN THIS CASE, C(E)=0.  HENCE, THE RESULT IN THE AC SHOULD BE 0.
;THE AC IS CHECKED FOR 0.  IF C(AC)=0, THIS TEST PASSES

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

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

;E				SW: FCE

;**********

;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=-1,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE 0,,1.
;THE AC IS CHECKED FOR 0,,1.  IF C(AC)=0,,1, THIS TEST PASSES

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

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

;0				FC: AD FM + EN
;0				FC: AD ADD
;0				FC: AD CRY 36
;0				FC: AD AR - EN
;-1,,-1				ET2: AR AD EN

;**********
;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=400000,,0.  HENCE, THE RESULT IN THE AC SHOULD BE
;400000,,0.  THE AC IS CHECKED FOR 400000,,0.
;IF C(AC)=400000,,0, THIS TEST PASSES.

B12400:	SETZ
	MOVM	[XWD 400000,0]	;*MOVM SHOULD PLACE 400000,,0 INTO THE AC
	CAME	[XWD 400000,0]	;PASS IF C(AC)=400000,,0
	STOP

;**********

;THIS TEST VERIFIES THAT MOVM PLACES THE MAGNITUDE OF C(E) INTO THE AC
;IN THIS CASE, C(E)=377777,,-1.  HENCE, THE RESULT IN THE AC SHOULD BE
;377777,,-1.  THE AC IS CHECKED FOR 377777,,-1.
;IF C(AC)=377777,,-1, THIS TEST PASSES.

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

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