Google
 

Trailing-Edge - PDP-10 Archives - klad_sources - klad.sources/dakbam.mac
There are no other files named dakbam.mac in the archive.
;INITIALIZE UUO HANDLER

START:	PGMINT			;INITIALIZE SUBROUTINES
	MOVE	0,RANDBS	;EXEC, SETUP RANDOM BASE
	SKIPE	USER		;USER, USE TIME OF DAY IN JIFFIES
	CALL	0,[SIXBIT/TIMER/]
	MOVEM	0,RAN		;SETUP RANDOM BASE

;INITIALIZE COMPLEXITY TABLE
	A=0
STARTA:	SETZM	CMPLXT		;STORE A TABLE OF POWERS OF 2
	MOVEI	1,1		;OR 0.
	SWITCH
	TLNN	RELIAB		;FAST CYCLE SWITCH SET ?
	SETZM	1		;YES, STORE ZERO'S
	REPEAT	7,
<	MOVEM	1,CMPLXT+1+A
	LSH	1,1
	A=A+1>
;INITIALIZE RUN TIME

	MOVEI	1,1
	TLNE	RELIAB		;FAST CYCLE SWITCH SET ?
	MOVEI	1,7		;NO, MULTIPLY RUNNING TIME
	MOVEM	1,RTIME		;STORE IN RTIME

	JRST	CAM1		;GO PERFORM DIAGNOSTIC

RENTR1:	DROPDV			;CLOSE LOGICAL OUTPUT FILE
	CALL	[SIXBIT .EXIT.]

PGMNAM:	ASCIZ/
PDP-10  KA10 BASIC INSTRUCTION RELIABILITY TEST 1 (DAKBA)
(COMPARES, SKIPS, EXCHANGES, BOOLE, ROTATES, TESTS, ETC.)
/
;CONSTANTS

RTIME:	0
CMPLXT:	BLOCK	20
SUBTTL	DIAGNOSTIC SECTION
	LALL

;TEST CAMN,CAME (SIMPLE)
;THE CONTENTS OF THE AC IS COMPARED WITH ITSELF
;AN ERROR WILL OCCUR IF CAMN SKIPS OR CAME FAILS TO SKIP
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)
;15 ACS ARE USED IN THE TEST

	AC=2
CAM1:	SETUP 20,0
	RANDOM
CAMNE1:	REPEAT ^D10,
<	MOVE	AC,RAN
	CAMN	AC,AC		;C(AC) = C(AC)
	CAME	AC,AC
	ERROR	AC,AC		;CHECK CAME,CAMN
	AC=<AC+1>&17
>
	AC=2
	LOOP CAMNE1-3,CAMNE1

;TEST MOVE TO AC,FURTHER TEST OF CAME
;THE C(AC) IS COMPARED WITH THE CONTENTS OF THE RANDOM
;NUMBER GENERATOR. 15 ACS ARE USED IN THE TEST
;ERRORS ARE PRINTED IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
MOVAC:	SETUP 20,0
	RANDOM
MOVAC1:	REPEAT ^D10,
<	MOVE AC,RAN		;MOVE RAN INTO AC.
	CAME AC,RAN		;RANDOM SHOULD EQUAL AC
	ERROR AC,RAN		;IF NOT MOVE FAILED
	CAME AC,RAN#		;IF  AC=RAN CAME FAILED
	ERROR AC,RAN#		;IF PREVIOUS WORKED,INHIBIT STORE
	AC=<AC+1>&17		;AC ON CAME FAILED
>
	AC=2
	LOOP MOVAC1-3,MOVAC1
;TEST THE SKIP INST FOR NO SKIP,ABILITY TO LOAD
;AN AC,AC SELECTION,AND AC0 LOGIC(NOT LOADING 0)
;ERRORS ARE PRESENTED IN THE FORM(PC,AC,C(AC),CORRECT)

	AC=5
SKP:	SETUP 30,0
	RANDOM
SKP1:	MOVE [0]		;DO NOT USE AC0 FOR SKIP
	REPEAT ^D8,
<	SKIP AC1,RAN#		;STORE IN AC,DO NOT SKIP,CHECK
	CAME AC1,AC		;NEW AC AGAINST PREVIOUSLY
	ERROR AC1,AC		;STORED AC. IF AC=AC+1(SKIP LOGIC)
	CAME [0]		;IF NOT= STORE CYCLE
	ERROR [0]		;IF 0 NONE ZERO ADDR/STORE
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=5
	LOOP SKP1-4,SKP1
;TEST SKIPA INST FOR PC INCREMENT,ABILITY TO LOAD AN AC,
;AC SELECTION AND AC0 LOGIC(NOT LOADING 0).ERRORS ARE
;PRESENTED IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=5
SKPA:	SETUP 30,0
	RANDOM
SKPA1:	MOVE [0]		;DO NOT USE AC0 FOR SKIPA
	REPEAT ^D8,
<	SKIPA AC1,AC		;LOAD AC1 AND SKIP
	ER AC,[ASCII /SKP/]	;FAILED TO SKIP.
	CAME AC,RAN		;C(E) GET CHANGED?
	ERROR AC,RAN		;YES.
	CAME AC1,RAN		;AC GET LOADED WITH RAN?
	ERROR AC1,RAN		;NO.
	CAME 0,[0]		;C(AC0) STILL = 0?
	ERROR [0]		;CHECK STORE CYCLE,AC ADDRESS
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=5
	LOOP SKPA1-4,SKPA1
	
;TEST EXCH. BOTH AC AND E ARE AC'S. CHECK FOR
;CORRECT DATA IN AC AND C(E).
;C(E) = -1, C(AC) = RAN NUM.

	AC=5
EXCH1:	SETUP 200,0
EXCH2:	RANDOM
EXCH3:	SETOB	AC1,RAN1	;MAKE C(E) = -1.
	EXCH	AC,AC1		;DO THE EXCH.
	CAME	AC,RAN1		;THE C(AC) SHOULD = ORIG C(E).
	ERR	RAN1,RAN	
	CAME	AC1,RAN		;THE C(E) SHOULD = ORIG C(AC).
	ERR	RAN1,RAN
	LOOP	EXCH2,EXCH3

;TEST SETCA FOR COMPLEMENT AC AND NOT STORING IN C(E)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)
;SETCA DOES NOT NORMALLY CHANGE THE CONTENTS OF "E"

	AC=10
BOLCA:	REPEAT 2,
<	SETUP 100,2
	RANDOM
	MOVE AC2,[0]		;CLEAR AC2, USED TO INSURE
	SETCA AC,AC2		;SETCA DOES NOT STORE IN C(E)
	CAMN AC,RAN#		;IF AC UNCHANGED CNTL PULSES
	ERROR AC,RAN		;FOR INST SETCA FAILED
	REPEAT 3,
<	SETCA AC,AC2>
	CAME AC,RAN#		;A TOTAL OF 4 COMPLEMENTS
	ERROR AC,RAN		;SHOULD PRODUCE ORIGINAL NUM
	CAME AC2,[0]		;IF SETCA STORED C(E)
	ERROR AC2,[0]		;C(AC2) WILL NO LONGER BE 0.
	LOOP .-16,.-15
	AC=AC+17
>
;TEST SETCAI ABILITY TO COMPLEMENT AC AND FAILURE TO FETCH C(E)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT
;SETCA IS INDEXED FOR NOISE PURPOSES

	AC=5
BOLCAI:	SETUP 40,0
BOLCA1:	RANDOM
BOLCA2:	REPEAT 4,
<	MOVE AC1,AC		;MOVE RANDOM TO AN AC
	SETCAI AC1,-1(AC)	;TWO COMP SHOULD PRODUCE 
	SETCAI AC1,777000(AC)	;ORIGINAL NUMBER
	CAME AC1,AC		;SETCAI FAILED
	ERROR AC1,AC
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=5
	LOOP BOLCA1,BOLCA2

;TEST XOR TO ZERO,XOR 0 TO N,N TO N,-1 TO N
;THREE ACS ARE USED IN THE TEST
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT

	AC=1
BOLX:	REPEAT 3,
<	SETUP 200,0
	RANDOM
	MOVE AC,[0]		;CLEAR THE AC
	XOR AC,RAN		;0 EXCLUSIVE ORED WITH
	CAME AC,RAN		;RANDOM SHOULD = RANDOM
	ERROR AC,RAN		;XOR FAILED
	XOR AC,[0]		;ANY NUMBER XORED
	CAME AC,RAN		;WITH THE NUMBER 0
	ERROR AC,RAN		;SHOULD  REMAIN UNCHANGED
	XOR AC,RAN		;ANY NUMBER XORED
	CAME AC,[0]		;WITH ITSELF SHOULD
	ERROR AC,[0]		;EQUAL 0
	XOR AC,[-1]		;SET AC TO ALL ONES
	XOR AC,RAN		;AC SHOULD CONTAIN COMP OF RAN
	XOR AC,[-1]		;RECOMPLEMENT AC TO ORIG
	CAME AC,RAN		;CHECK FOR RANDOM
	ERROR AC,RAN		;XOR FAILED
	LOOP .-22,.-21
	AC=AC+1
>

;TEST SETZI AND IOR. SETZI ABILITY TO CLEAR,IOR RAN TO 0,
;RANDOM TO RANDOM,RANDOM TO COMP RANDOM,0 TO RANDOM
;ERROR IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=5
BOLZI:	SETUP 100,0
	RANDOM
BOLZI1:	REPEAT 2,
<	MOVE AC,RAN#		;LOAD THE AC THEN
	SETZI AC,(AC)		;TRY TO CLEAR IT,INDEX REDUNDANT
	CAME AC,[0]		;IF NOT 0
	ERROR AC,[0]		;SETZI FAILED
	IOR AC,RAN		;INCLUSIVE OR OF A
	CAME AC,RAN		;NUMBER TO 0 SHOULD PRODUCE
	ERROR AC,RAN		;THE NUMBER
	IOR AC,RAN		;IOR SAME NUMBERS
	CAME AC,RAN		;SHOULD HAVE NO EFFECT
	ERROR AC,RAN		;ON AC.IOR FAILED
	IOR AC,[0]		;IOR OF NO BITS SHOULD DO NOTHING
	CAME AC,RAN
	ERROR AC,RAN		;IOR FAILED
	SETCA AC,0
	IOR AC,RAN		;INCLUSIVE OR OF COMP NUMBERS
	CAME AC,[-1]		;SHOULD SET ALL BITS
	ERROR AC,[-1]		;IOR FAILED
	IOR AC,[-1]		;ALL BITS TO ALL BITS
	CAME AC,[-1]		;PRODUCE ALL BITS
	ERROR AC,[-1]
	AC=<AC+1>&17
>
	AC=5
	LOOP BOLZI1-4,BOLZI1

;TEST AND FOR 0 TO 0,1 TO 1,0 TO 1,1 TO 0
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BOLA:	SETUP 400,0
	RANDOM
BOLA1:	AND AC,RAN		;NUMBER AND NUMBeR
	CAME AC,RAN		;SHOULD EQUAL NUMBER
	ERROR AC,RAN		;IF NOT, "AND" FAILED.
	AND AC,[-1]		;"AND" OF ALL BITS WITH
	CAME AC,RAN		;ANY NUMBER SHOULD 
	ERROR AC,RAN		;LEAVE THE NUMBER UNCHANGED
	SETCA AC,
	AND AC,RAN		;"AND" OF A NUMBER WITH ITS
	CAME AC,[0]		;COMPLEMENT SHOULD
	ERROR AC,[0]		;PRODUCE 0
	LOOP BOLA1-4,BOLA1
;TEST ORCA AND SETO. 1 TO 0,1 TO 1, 0 TO 0, 1 TO 0,0 TO 1
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)
;ONE AC IS USED FOR TESTING

	AC=12
BOLOS:	SETUP 300,0
	RANDOM
BOLOS1:	SETO AC,.		;WILL CHANGE THIS INST IF FETCH/STORE C(E).
	CAME AC,[-1]		;CHECK FOR ALL BITS SET
	ERROR AC,[-1]		;SETO FAILED
	ORCA AC,RAN		;-1 ORED TO RANDOM
	CAME AC,RAN		;SHOULD PRODUCE RANDOM
	ERROR AC,RAN		;IF AC COMP PROBELY
	ORCA AC,RAN		;RANDOM TO RANDOM SHOULD
	CAME AC,[-1]		;PRODUCE -1
	ERROR AC,[-1]		;IF AC COMPLEMENTED PROPERLY
	ORCA  AC,[0]		;WITH NO BITS EFFECT IC COMP AC
	ORCA AC,RAN
	CAME AC,[-1]		;NO BITS COMPLEMENTS TO PRODUCE
	ERROR AC,[-1]		;ALL ONES
	LOOP BOLOS1-4,BOLOS1

;TEST ANDCA.1 TO 1,0 TO 0, 0 TO 1,0 TO 0,1 TO 1,1 TO 0
;ERRORS ARE IN THE FORM(PC,AC,C(AC),CORRECT
;ONE AC IS USED 

	AC=13
BOLAC:	SETUP 200,1
	RANDOM
BOLAC1:	ANDCA AC,RAN		;ANDCA OF LIKE NUMBERS
	CAME AC,[0]		;SHOULD PRODUCE 0
	ERROR AC,[0]		;ANDCA FAILED
	ANDCA AC,RAN
	CAME AC,RAN		;ANDCA OF ZERO AND NUMBER
	ERROR AC,RAN		;SHOULD PRODUCE NUMBER
	SETO AC,.		;SET ALL BITS
	ANDCA AC,RAN
	CAME AC,[0]		;ANDCA OF ALL BITS WITH NUMBER
	ERROR AC,[0]		;SHOULD PRODUCE 0
	LOOP BOLAC1-4,BOLAC1

;TEST EQV,1 TO 1,0 TO 0,1 TO 0,0 TO 1. EQV =(SET ALL LIKE BITS)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=14
BOLEQ:	SETUP 200,2
	RANDOM
BOLEQ1:	EQV AC,RAN		;WHEN NUMBERS ARE EQUAL
	CAME AC,[-1]		;EQV SHOULD PRODUCE ALL
	ERROR AC,[-1]		;BITS SET.EQV FAILED
	EQV AC,RAN#		
	CAME AC,RAN		;WITH AC SET,EQV SHOULD
	ERROR AC,RAN		;PRODUCE C(E) IN THE AC
	SETZI AC,-1
	EQV AC,RAN		;WHEN AC=0 EQV SHOULD
	SETCA AC,.		;PRODUCE COMPLEMENT OF
	CAME AC,RAN		;C(E)
	ERROR AC,RAN		;EQV FAILED
	LOOP BOLEQ1-3,BOLEQ1

;TEST SETM. SET THE CONTENTS OF MEMORY TO THE AC
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BOLSM:	SETUP 100,0
	RANDOM
BOLSM1:	REPEAT 2,
<	SETM AC1,RAN		;THE NET RESULT OF SETM
	CAME AC1,AC		;IS THE SAME AS MOVE
	ERROR AC1,RAN		;SETM FAILED
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=10
	LOOP BOLSM1-4,BOLSM1
;TEST SETCM. (MOVE THE COMPLEMENT OF MEMORY TO AC)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=14
BOLCM:	SETUP 100,0
	RANDOM
BOLCM1:	SETCM AC1,RAN		;COMP OF RANDOM TO AC
	SETCM AC2,AC1		;RECOMP TO AC2
	CAME AC2,RAN
	ERROR AC2,RAN		;SETCM 1 OR 2 FAILED
	LOOP BOLCM1-3,BOLCM1

;TEST ORCM. (INCLUSIVE OR THE CONTENTS OF COMPLEMENTED MEMORY
;TO THE CONTENTS OF AC.) ERRORS ARE IN THE FORM (PC,AC,
;C(AC),CORRECT

	AC=5
BOLOC:	SETUP 140,0
	RANDOM
BOLOC1:	ORCM AC,RAN		;LIKE NUMBERS SHOULD PRODUCE
	CAME AC,[-1]		;ALL BITS SET
	ERROR AC,[-1]
	ORCM AC,RAN		;ANY NUMBER ORED WITH ALL
	CAME AC,[-1]		;ONES SHOULD PRODUCE 
	ERROR AC,[-1]		;ALL ONES
	SETZI AC,-1
	ORCM AC,RAN		;THE RANDOM NUMBER IS
	SETCA AC,.		;ORED TO 0. THIS SHOULD
	CAME AC,RAN		;PRODUCE THE  COMPLEMENT
	ERROR AC,RAN		;OF RANDOM
	ORCM AC,[-1]
	CAME AC,RAN		;ORING -1 SHOULD LEAVE
	ERROR AC,RAN		;AC UNCHANGED
	LOOP BOLOC1-3,BOLOC1

;TEST ANDCM (AND WITH THE COMP OF MEMORY)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BOLAX:	SETUP 140,0
	RANDOM
BOLAX1:	ANDCM AC,RAN		;LIKE NUMBERS SHOULD
	CAME AC,[0]		;PRODUCE 0
	ERROR AC,[0]		;ANDCM FAILED
	ANDCM AC,RAN		;ANYTHING ANDED TO
	CAME AC,[0]		;ZERO SHOULD = 0
	ERROR AC,[0]
	SETO	AC,
	ANDCM AC,RAN		;AC SHOULD - COMP OF MEMORY
	ANDCM AC,[0]		;AC SHOULD REMAIN UNCHANGED
	XOR AC,[-1]		;COMP AC
	CAME AC,RAN		;AFTER COMP SHOULD EQUAL
	ERROR AC,RAN		;RANDOM. ANDCM FAILED
	LOOP BOLAX1-3,BOLAX1

;TEST ORCB (INCLUSIVE OR THE COMPLEMENT OF AC AND C(E))
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=1
BOLOB:	SETUP 140,0
	RANDOM
BOLOB1:	ORCB AC,RAN		;PRODUCE COMP OF RAN
	ORCB AC,[-1]		;COMP AC
	CAME AC,RAN		;CHECK ORCB
	ERROR AC,RAN
	ORCB AC,[-1]		;COMP AC
	ORCB AC,RAN		;ANY TWO COMPLEMENTED NUMBERS
	CAME AC,[-1]		;SHOULD PRODUCE ALL ONES
	ERROR AC,[-1]			
	ORCB AC,[0]		;AC COMPLEMENTS TO 0
	CAME AC,[-1]		
	ERROR AC,[-1]		;ORCB FAILED
	LOOP BOLOB1-4,BOLOB1

;TEST ANDCB (AND WITH BOTH OPERANDS COMPLEMENTED)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
BOLAB:	SETUP 140,0
	RANDOM
BOLAB1:	ANDCB AC,RAN		;PRODUCE COMP OF RAN
	ANDCB AC,[0]		;COMP AC
	CAME AC,RAN		;CHECK FOR ORIGIONAL NUMBER
	ERROR AC,RAN		;ANDCB FAILED
	ANDCB AC,[0]		;COMPLEMENT AC
	ANDCB AC,[0]		;RECOMPLEMENT AC
	CAME AC,RAN		;SHOULD PRODUCE ORIGIONAL
	ERROR AC,RAN		;ANDCB FAILED
	ANDCB AC,[-1]		;RESULT SHOULD BE 0 IF
	CAME AC,[0]		;CONTENTS OF E
	ERROR AC,[0]		;CONTAINS NO BITS AFTER COMP
	ANDCB AC,RAN		;AC SHOULD EQUAL COMP OF RAN
	ANDCB AC,[0]		;COMP AC
	CAME AC,RAN		;THE AND TO 0
	ERROR AC,RAN		;FAILED
	LOOP BOLAB1-3,BOLAB1

;TEST SETA (EFFECTIVELY A NO OPERATION IN THIS MODE)
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=3
BOLSA:	SETUP 100,0
	RANDOM
		;DO 7 SETA'S.
BOLSA1:	REPEAT 7,<
	SETA AC,.>
	CAME AC,RAN		;C(AC) SHOULD = ORIG. C(AC)
	ERROR AC,RAN
	LOOP BOLSA1-3,BOLSA1

;TEST IORM, WHERE E IS AN AC. THE INST IS TESTED
;FOR NOT STORING IN AC AS WELL AS STORING PROPERLY
;IN E.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=11
BMIOR:	SETUP 100,1
BMIOR1:	RANDOM
BMIOR2:	MOVS AC1,AC		;AC=C(E) ORIG
	CAMN AC,AC1		;HALVES SAME?
	JRST BMIOR1		;YES. REJECT.
	SETCM AC		;SIM AN
	AND AC1			;IOR
	XOR	AC		;INST
	IORM AC,AC1		;RESULT TO AC1
	CAMN AC,AC1		;BOTH SAME?
	ERROR AC,AC1		;YES. STORED IN AC.
	CAME AC1,0		;C(E) = SIM. ANS?
	ERROR AC,0		;NO. IORM FAILED.
	LOOP BMIOR1,BMIOR2

;TEST ORCAM, WHERE E IS AN AC. THE INSTRUCTION IS TESTED
;FOR NOT STORING IN AC AS WELL AS STORING PROPERLY IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=12
BMICA:	SETUP 100,1
BMICA1:	RANDOM
BMICA2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETCM AC2,AC1		;MOVE COMPLEMENT OF NUMBER
	SETCM	AC		;SIMULATE
	AND	AC2		;THE INSTRUCTION
	XOR	AC		;IN AC0.
	ORCAM AC1,AC		;RESULT TO C(E)
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. STORED IN AC.
	CAME AC,0		;C(E) = SIM. ANS?
	ERROR AC,0		;NO. ORCAM FAILED.
	LOOP BMICA1,BMICA2

;TEST ORCMM, WHERE E IS AN AC. THE INSTRUCTION
;IS TESTED FOR NOT STORING IN AC AS WELL AS THE
;CORRECT ANSWER IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=13
BMICM:	SETUP 100,0
BMICM1:	RANDOM
BMICM2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETCM AC2,AC		;SIMULATE
	SETCM	AC1		;THE
	AND	AC2		;INSTRUCTION
	XOR	AC1		;IN AC0
	CAMN	0,AC1		;IS SIMULATED ANS
	JRST	BMICM1		;= C(AC)?...REJECT.
	ORCMM AC1,AC		;IF AC1 = AC, STORE INHIBIT
	CAMN AC1,AC
	ERROR AC1,AC		;FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;ORCMM FAILED.
	LOOP BMICM1,BMICM2

;TEST ORCBM, WHERE E IS AN AC. THE INSTRUCTION
;IS TESTED FOR NOT STORING IN AC AS WELL AS THE
;CORRECT ANSWER IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=14
BMICB:	SETUP 200,0
BMICB1:	RANDOM
BMICB2:	MOVS AC1,AC		;AC1= 0101,0011
	SETCM AC2,AC		;AC2= 1100,1010
	SETCM	AC2		;AC0 = 0011,0101
	ANDCM	AC1		;AC0 = 0010,0100
	XOR	AC2		;AC0 = 1110,1110
	ORCBM AC1,AC		;SHOULD PRODUCE SAME LOGIC
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;ORCBM FAILED.
	LOOP BMICB1,BMICB2

;TEST XORM, WHERE E IS AN AC. THE INSTRUCTION IS
;TESTED FOR NOT STORING AC AS WELL AS CONTENTS
;OF E CORRECTNESS.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BMX:	SETUP 200,1
BMX1:	RANDOM
BMX2:	JUMPE AC,BMX1		;REJECT IF RAN = 0.
	MOVS AC1,AC		;SECOND RANDOM NUMBER.
	SETCM	AC
	ANDCA	AC1		;PERFORM
	MOVE AC2,AC		;A PSEUDO
	IOR AC2,AC1		;EXCLUSIVE
	ANDCA	AC2		;OR INSTRUCTION
	XORM AC1,AC		;DO THE XOR
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;XORM FAILED.
	LOOP BMX1,BMX2

;TEST EQVM, WHERE E IS AN AC. THE INSTRUCTION
;IS TESTED FOR NOT STORING AC AS WELL AS
;CORRECTNESS OF C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BMEQ:	SETUP 100,0
BMEQ1:	RANDOM
BMEQ2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETCM AC1		;EQV IS SAME LOGIC
	XOR AC			;AS XOR WITH COMP AC
	EQVM AC1,AC		;EQV SETS ALL LIKE BITS
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;EQVM FAILED.
	LOOP BMEQ1,BMEQ2


;TEST ANDM, WHERE E IS AN AC. THE INSTRUCTION IS
;TESTED FOR NOT STORING IN AC AS WELL AS STORING
;PROPERLY IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=3
BMAN:	SETUP 100,0
BMAN1:	RANDOM
BMAN2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	MOVE	AC		;SIMULATE
	IOR	AC1		;AN "AND"
	XOR	AC1		;INSTRUCTION.
	XOR AC			;IN AC0
	CAMN AC1,AC		;REJECT THE NUMBER
	JRST BMAN1		;IF EQUAL.
	ANDM AC1,AC		;THE INSTRUCTION
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;AND FAILED.
	LOOP BMAN1,BMAN2


;TEST ANDCAM, WHERE E IS AN AC. THE INSTRUCTION IS
;TESTED FOR NOT STORING IN AN AC AS WELL AS
;STORING C(E) PROPERLY.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=4
BMACA:	SETUP 100,0
BMACA1:	RANDOM
BMACA2:	JUMPE AC,BMACA1		;REJECT IF RAN = 0.
	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETM	AC		;SIMULATE
	ORCA	AC1		;ANDCA
	SETCA			;LOGIC
	ANDCAM AC1,AC		;THE INSTRUCTION
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;ANDCA FAILED.
	LOOP BMACA1,BMACA2

;TEST ANDCMM, WHERE E IS AN AC. THE INSTRUCTION IS
;TESTED FOR NOT STORING IN AN AC AS WELL AS
;STORING C(E) PROPERLY.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=5
BMACM:	SETUP 100,0
BMACM1:	RANDOM
BMACM2:	JUMPE AC,BMACM1		;REJECT IF RAN = 0.
	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETAM AC1,0		;AC1 TO AC0.
	IOR	AC		;SIMULATE
	XOR	AC		;THE INSTUCTION
	CAMN	0,AC1		;SIM ANS = C(AC)?
	JRST	BMACM1		;YES. REJECT.
	ANDCMM AC1,AC		;DO AN ANDCMM INSTRUCTION.
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;ANDCMM FAILED.
	LOOP BMACM1,BMACM2

;TEST ANDCBM, WHERE E IS AN AC. THE INSTRUCTION
;IS TESTED FOR NOT STORING IN AC AS WELL AS STORING
;PROPERLY IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=7
BMACB:	SETUP 100,0
BMACB1:	RANDOM
BMACB2:	MOVS AC1,AC		;SECOND RANDOM NUMBER.
	SETCM	AC1		;SIMULATE
	SETCM 1,AC		;AN
	AND	1		;ANDCBM INST.
	ANDCBM	AC1,AC		;DO AN ANDCBM.
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;ANDCBM FAILED.
	LOOP BMACB1,BMACB2

;TEST SETCAM, WHERE E IS AN AC. THE INSTRUCTION
;IS TESTED FOR NOT STORING IN AC AS WELL AS
;PROPER C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BMCMM:	SETUP 200,0
BMCMM1:	RANDOM
BMCMM2:	MOVS AC1,AC		;CHECK FOR NO CHANGE
	CAMN	AC1,AC		;IN 8 COMPLEMENTS
	JRST BMCMM1		;REJECT IF HALF SAME.

	REPEAT 10,<
	SETCMM AC1,AC>
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,RAN		;C(E) SHOULD = ORIG. C(E).
	ERROR AC,RAN		;SETCMM FAILED.
	LOOP BMCMM1,BMCMM2

 ;TEST SETCAM, WHERE E IS AN AC. TEST FOR NOT
;STORING IN AC AS WELL AS PROPER STORAGE IN C(E).
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=11
BMCAM:	SETUP 100,0
BMCAM1:	RANDOM
BMCAM2:	MOVS AC1,AC		;SECOND RANDOM NUMBER.
	SETCM	AC1		;SIMULATE SETCAM.
	SETCAM AC1,AC		;DO SETCAM.
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,0		;C(E) SHOULD = SIM. ANS.
	ERROR AC,0		;SETCAM FAILED.
	LOOP BMCAM1,BMACM2

;TEST SETAM, WHERE E IS AN AC.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BMSA:	SETUP 100,0
BMSA1:	RANDOM
BMSA2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	CAMN AC1,AC
	JRST BMSA1		;REJECT IF SAME.
	SETAM AC,AC1		;C(AC) TO C(AC1)
	CAME AC,AC1		;EQUAL?
	ERROR AC,AC1		;NO.
	CAME AC1,RAN		;C(E) SHOULD = ORIG C(AC).
	ERROR AC1,RAN		;SETAM FAILED.
	LOOP BMSA1,BMSA2

;TEST SETOM, WHERE E IS AN AC.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
BMSM:	SETUP 100,0
BMSM1:	RANDOM
BMSM2:	MOVS AC1,AC		;SECOND RANDOM NUMBER
	SETOM AC1,AC		;DO SETOM INST.
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,[-1]		;C(E) SHOULD = A -1.
	ERROR AC,[-1]		;SETOM FAILED.
	LOOP BMSM1,BMSM2

;TEST SETMM, WHERE E IS AN AC.
;ERRORS ARE IN THE FORM (PC, AC,C(AC),CORRECT)

	AC=10
BMSMM:	SETUP 100,0
BMSMM1:	RANDOM
BMSMM2:	MOVS AC1,AC		;A SECOND RANDOM NUMBER
	CAMN AC,AC1		;REJECT IF
	JRST BMSMM1		;HALF SAME
		;DO 8 SETMM...SHOULD NOT CHANGE C(E).
	REPEAT 10,<
	SETMM AC1,AC>
	CAMN AC1,AC		;EQUAL?
	ERROR AC1,AC		;YES. INHIBIT STORE AC FAILED.
	CAME AC,RAN		;C(E) SHOULD = ORIG. C(E).
	ERROR AC,RAN		;SETMM FAILED.
	LOOP BMSMM1,BMSMM2

;TEST SETZM, WHERE E IS AN AC. TESTS FOR NOT STORING
;IN AC AS WELL AS STORING IN C(E) PROPERLY.

	AC=10
SETZM1:	SETUP 40,0
SETZM2:	RANDOM
SETZM3:	JUMPE AC,SETZM2		;REJECT IF C(AC) = 0.
	SETOB AC1,RAN1		;SET C(AC) TO ALL ONES.
	SETZM AC1,AC		;DO SETZM
	CAME AC,[0]		;DID AC GET CLEARED?
	EERR	,RAN1		;NO.
	CAME AC1,[-1]		;DOES C(AC1) STILL = -1?
	EERR	,RAN1		;NO.
	LOOP SETZM2,SETZM3

;TEST ROT LEFT 3X(2X18). CHECKING FOR AC1 NOT CHANGED
;AS WELL AS C(AC) BEING THE PROPER NUMBER.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
ROTL2:	SETUP 200,2
ROTL2A:	RANDOM
ROTL2B:	SETOB AC1,RAN1		;SET AC+1 TO ALL ONES.
		;DO 6 X (ROT LEFT 18 PLACES).
	REPEAT 3,<
	ROT AC,22
	ROT AC,22>
	CAME AC,RAN		;C(AC)SHOULD = C(AC) BEFORE ROT.
	EERRI	,22
	CAME AC1,[-1]		;AC1 SHOULD NOT HAVE CHANGED.
	ERR	RAN1,22
	LOOP ROTL2A,ROTL2B

;TEST ROT RIGHT 3X(2X18)..CHECKING FOR AC1 NOT
;CHANGED AS WELL AS C(AC) ENDING UP BEING
;THE SAME AS IT WAS BEFORE THE ROT.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=10
ROTR2:	SETUP 300,2
ROTR2A:	RANDOM
ROTR2B:	SETOB AC1,RAN1		;SET AC+1 TO ALL ONES.
		;DO 6 X (ROT RIGHT 18 PLACES).
	REPEAT 3,<
	ROT AC,-22
	ROT AC,-22>
	CAME AC,RAN		;C(AC) SHOULD = C(AC) BEFORE ROT.
	EERR	,-22
	CAME AC1,[-1]		;C(AC1) SHOULD STILL = -1.
	ERRI	RAN1,-22
	LOOP ROTR2A,ROTR2B

;TEST ROT LEFT 3X36. CHECKING FOR AC1 NOT
;CHANGED AND C(AC) = WHAT IT WAS BEFORE
;ROT.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
RTL36:	SETUP 300,2
RTL36A:	RANDOM
RTL36B:	SETOB	AC1,RAN1	;SET AC+1 TO ALL ONES.
		;DO 3 X (ROT LEFT 36 PLACES).
	REPEAT 3,<
	ROT AC,44>
	CAME AC,RAN		;C(AC) SHOULD = C(AC) BEFORE ROT.
	EERRI	,44
	CAME AC1,[-1]		;C(AC1) SHOULD STILL = -1.
	ERRI	RAN1,44
	LOOP RTL36A,RTL36B

;TEST ROT RIGHT 3X36. CHECKING FOR AC1 NOT
;CHANGED AND C(AC) = WHAT IT DID BEFORE ROT.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
RTR36:	SETUP 300,2
RTR36A:	RANDOM
RTR36B:	SETOB AC1,RAN1		;SET AC+1 TO ALL ONES.
		;DO 3 X (ROT RIGHT 36 PLACES).
	REPEAT 3,<
	ROT AC,-44>
	CAME AC,RAN		;C(AC) SHOULD = RAN.
	EERRI	,-44
	CAME AC1,[-1]		;C(AC1) SHOULD STILL = -1.
	ERRI	RAN1,-44
	LOOP RTR36A,RTR36B

;TEST ROTC LEFT 3X36 THROUGH ALL AC'S CHECKING
;FOR C(AC) AND C(AC1) BEING EXCHANGED
;AFTER THE ROTC.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)
  
	AC=2
RTCL:	SETUP 100,2
RTCLA:	RANDOM

RTCLB:	REPEAT ^D10,<
	MOVE AC,RAN		;MOVE A RAN NUM INTO AN AC.
	SETOB	AC1,RAN1	;SET AC+1 TO ALL ONES.
		;DO 3 X (ROTC LEFT 36 PLACES).
	REPEAT 3,<
	ROTC AC,44>
	CAME AC1,RAN		;C(AC1) SHOULD = RAN.
	EERRI	,44
	CAME AC,[-1]		;C(AC) SHOULD = A -1.
	ERRI	RAN1,44
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=2
	LOOP RTCLA,RTCLB

;TEST ROTC RIGHT 3X36 THROUGH ALL AC'S. CHECKING
;FOR C(AC) AND C(AC1) BEING EXCHANGED.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
RTCR:	SETUP 100,2
RTCRA:	RANDOM

RTCRB:	REPEAT ^D10,<
	MOVE AC,RAN		;MOVE A RAN NUM INTO AN AC.
	SETOB AC1,RAN1		;SET AC+1 TO ALL ONES.
		;DO 3 X (ROTC RIGHT 36 PLACES).
	REPEAT 3,<
	ROTC AC,-44>
	CAME AC1,RAN		;C(AC1) SHOULD = C(AC) BEFORE ROTC.
	EERRI	,-44
	CAME AC,[-1]		;C(AC) SHOULD = C(AC1) BEFORE ROTC.
	ERRI	RAN1,-44
	AC=<AC+1>&17
	AC1=<AC+1>&17
>
	AC=2
	LOOP RTCRA,RTCRB

;TEST ROT. ROT A RANDOM NUMBER A RANDOM NUMBER OF TIMES
;IN ONE DIRECTION AND THEN THE SAME NUMBER OF TIMES
;IN THE OPPOSITE DIRECTION.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT).

	AC=2
ROTLR:	SETUP 100,4
ROTLR1:	RANDOM
	MOVE AC3,RAN		;CHECK TO SEE
	AND AC3,[377]		;THAT THE RIGHT MOST 8 BITS
	JUMPE AC3,ROTLR1	;DO NOT = 0..REJECT IF THEY DO.
ROTLR2:	MOVN AC2,RAN		;PUT 2'S COMP OF RAN INTO AC2.
	SETOB AC1,RAN1		;SET AC+1 TO ALL ONES.
	ROT AC,(AC)		;ROT AC A RANDOM NUMBER OF TIMES.
	ROT AC,(AC2)		;ROT AC THE SAME NUM OF TIMES
				;IN THE OPPOSITE DIRECTION.
	CAME AC,RAN		;C(AC) SHOULD STILL = C(RAN).
	ERROR AC,RAN
	CAME AC1,[-1]		;C(AC1) SHOULD STILL = -1.
	ERROR AC1,[-1]
	LOOP ROTLR1,ROTLR2

;TEST ROTC. DO A ROTC WITH A RANDOM NUMBER A RANDOM
;NUMBER OF TIMES IN ONE DIRECTION AND THEN THE SAME
;NUMBER OF TIMES IN THE OPPOSITE DIRECTION.
;REPEAT THIS TEST FOR ALL AC'S.
;ERRORS ARE IN THE FORM (PC,AC,C(AC),CORRECT)

	AC=2
RTCLR:	SETUP 200,3
RTCLR1:	RANDOM
	MOVE AC3,RAN		;CHECK TO SEE
	AND AC3,[377]		;THAT THE RIGHT MOST 8 BITS
	JUMPE AC3,RTCLR1	;DO NOT = 0..REJECT IF THEY DO.

RTCLR2:	REPEAT ^D10,<
	MOVE AC,RAN		;MOVE A RAN NUM INTO AN AC.
	MOVN AC2,RAN		;MOVE THE 2'S COMP INTO ANOTHER AC.
	SETO AC1,		;SET AC1 TO ALL ONES.
	ROTC AC,(AC)		;ROTC AC A RANDOM NUMBER OF
				;TIMES IN ONE DIRECTION.
	ROTC AC,(AC2)		;ROTC AC THE SAME NUMBER OF
				;TIMES IN THE OPPOSITE DIRECTION.
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN.
	ERROR AC,RAN
	CAME AC1,[-1]		;C(AC1) SHOULD STILL =-1
	ERROR AC1,[-1]
	AC=<AC+1>&17
	AC1=<AC+1>&17
	AC2=<AC+2>&17

>
	AC=2
	LOOP RTCLR1,RTCLR2

;TEST OVERFLOW ON A ROT LEFT...AROV SHOULD NOT COME UP.

	AC=2
ROTOV:	SETUP 20,0
ROTOV1:	RANDOM
ROTOV2:	JUMPE AC,ROTOV1		;REJECT IF RAN = 0.
	CAMN AC,[-1]		;ALSO REJECT IF RAN = -1.
	JRST ROTOV1
	JFCL 10,.+1		;CLEAR OV FLAG.
	ROT AC,256		;ROT C(AC) 256 TIMES.
	JFCL 10,.+2		;OV FLAG GET SET?
	JRST .+2		;NO.
	ER AC,[ASCII /OV/]	;YES. SHOULD NOT SET ON A ROT.
	LOOP ROTOV1,ROTOV2

;TEST OVERFLOW FLAG ON A ROT RIGHT...SHOULD NEVER GET SET.

	AC=3
RTROV:	SETUP 20,0
RTROV1:	RANDOM
RTROV2:	JUMPE AC,RTROV1		;REJECT IF RAN = 0.
	CAMN AC,[-1]		;ALSO REJECT IF RAN = -1.
	JRST RTROV1
	JFCL 10,.+1		;CLEAR OVERFLOW FLAG.
	ROT AC,-256		;ROT AC RIGHT 256 TIMES.
	JFCL 10,.+2		;OVERFLOW FALG GET SET?
	JRST .+2		;NO.
	ER AC,[ASCII /OV/]
	LOOP RTROV1,RTROV2

;TEST MOVEM. AFTER <MOVEM AC,AC1> FOLLOWED BY
;<MOVEM AC1,AC>, C(AC) SHOULD = ORIG C(AC).
;RAN TO RAN1.

	AC=2
MVEM1:	SETUP 30,0
MVEM2:	RANDOM
		;DO 3 SETS OF MOVEM'S.
MVEM3:	REPEAT 3,<
	MOVEM AC,AC1
	MOVEM AC1,AC>
	CAME	AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERROR	AC,RAN
	CAME AC1,RAN		;C(AC1) SHOULD ALSO = ORIG. C(AC).
	ERROR AC1,RAN
	LOOP MVEM2,MVEM3

;TEST MOVES. AFTER 6 MOVES IN A ROW, THE C(E)
;SHOULD = ORIG C(E).

	AC=2
MVES1:	SETUP 200,1
MVES2:	RANDOM
		;DO 6 MOVE INSTRUCTIONS.
MVES3:	REPEAT 3,<
	MOVES	AC1,AC
	MOVES	AC1,AC>
	CAME	AC1,AC		;C(AC) SHOULD = C(E).
	ERROR	AC1,AC
	CAME	AC,RAN		;C(E) SHOULD = ORIG C(E).
	ERROR	AC,RAN
	LOOP MVES2,MVES3

;TEST MOVS INSTRUCTION...TWO MOVS SHOULD GIVE SAME NUMBER.

	AC=4
MOVSA:	SETUP 200,2
MOVSB:	RANDOM
		;DO 6 MOVS INSTRUCTIONS.
MOVSC:	REPEAT 3,<
	MOVS AC,AC
	MOVS AC,AC>
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN.
	EERR	,RAN
	LOOP MOVSB,MOVSC

;TEST MOVS INSTRUCTION...MOVS FOLLOWED BY ROT SHOULD GIVE
;SAME NUMBER.

	AC=5
MOVS1:	SETUP 200,1
MOVS2:	RANDOM
MOVS3:	MOVS AC,AC		;DO MOVS INSTRUCTION.
	ROT AC,22		;ROT LEFT 18 PLACES.
	CAME AC,RAN		;C(AC) SHOULD NOW = RAN.
	EERR	,RAN
	LOOP MOVS2,MOVS3

;TEST MOVSM....TWO MOVSM SHOULD GIVE THE ORIG. NUM.

	AC=6
MOVSMA:	SETUP 300,1
MOVSMB:	RANDOM

MOVSMC:	REPEAT 3,<
	MOVSM AC,AC1
	MOVSM AC1,AC>
	CAME AC,RAN		;C(AC) SHOULD NOW BE = TO RAN.
	ERROR AC,RAN
	LOOP MOVSMB,MOVSMC

;TEST MOVSS...TWO MOVSS SHOULD GIVE THE ORIGINAL NUMBER.

	AC=7
MOVSSA:	SETUP 200,0
MOVSSB:	RANDOM
MOVSSC:	SETZB 0,RAN1		;CLEAR AC0.

	REPEAT 3,<
	MOVSS	AC
	MOVSS	AC>
	CAME AC,RAN		;C(AC) SHOULD NOW BE = TO RAN.
	EERR	,RAN1
	CAME	[0]		;C(AC0) SHOULD STILL = 0.
	EERR	,RAN1
	LOOP MOVSSB,MOVSSC

;TEST MOVSI.

	AC=10
MOVSIA:	SETUP 100,0
MOVSIB:	RANDOM
	MOVE AC2,RAN		;PUT RAN INTO AN AC.
MOVSIC:	ANDI AC,-1		;SIMULATE
	ROT AC,22		;A MOVSI INST.
	MOVSI AC1,(AC2)		;DO MOVSI.
	CAME AC1,AC		;C(AC1) SHOULD = SIM. ANS.
	ERROR AC1,AC
	LOOP MOVSIB,MOVSIC

;TEST LSH. SIMULATE A LSH 18 PLACES WITH A MOVSI.

	AC=11
LSHA:	SETUP 200,1
LSHB:	RANDOM
LSHC:	SETO	AC1,		;SET AC+1 TO ALL ONES.
	MOVSI AC2,(AC)		;SIMULATE LSH 18 PLACES.
	LSH AC,22		;DO LSH
	CAME AC,AC2		;C(AC) SHOULD = SIM. ANS.
	ERROR AC,AC2
	CAME AC1,[-1]		;AC1 GET CHANGED?
	ERROR AC1,[-1]		;YES.
	LOOP LSHB,LSHC

;TEST LSH RIGHT 18 PLACES.

	AC=10
LSH1:	SETUP 200,1
LSH2:	RANDOM
LSH3:	SETOB AC1,RAN1		;SET C(AC+1) TO ALL ONES.
	LSH AC,-22		;DO LSH RIGHT 18 PLACES.
	MOVS AC2,RAN		;SIMULATE
	ANDI AC2,-1		;LSH.
	CAME AC,AC2		;C(AC) SHOULD = SIM. ANS.
	EERRI	,-22
	CAME AC1,[-1]		;C(AC+1) GET CHANGED?
	ERRI	RAN1,-22
	LOOP LSH2,LSH3

;TEST ASH ABILITY TO SET OR NOT SET OVERFLOW FLAG.

	AC=10
ASHOV:	SETUP 30,0
ASHOV1:	SETO	AC,		;SET AC TO ALL ONES..1,1 CONDITION.
	JFCL	10,.+1		;CLEAR OV FLAG.
	ASH AC,1		;DO ASH.
	JFCL 10,.+2		;OVERFLOW FLAG GET SET?
	JRST .+2		;NO.
	ER AC,[ASCII /OV/]	;YES. 1,1 CONDITION SHOULD NOT SET IT.
	JFCL 10,.+1		;CLEAR OV FLAG.
	SETZ AC,		;CLEAR AC...0,0 CONDITION.
	ASH AC,1		;DO ASH.
	JFCL 10,.+2		;OVERFLOW FLAG GET SET?
	JRST .+2		;NO.
	ER AC,[ASCII /OV/]	;YES. 0,0 COND. SHOULDN'T SET IT.
	JFCL 10,.+1		;CLEAR OV FLAG.
	MOVSI AC,377777		;SET AC FOR 0,1 CONDITION.
	ASH AC,1		;DO ASH.
	JFCL 10,.+2		;OVERFLOW FLAG GET SET?
	ER AC,[ASCII /OV/]	;NO. 0,1 COND. SHOULD SET IT.
	JFCL 10,.+1		;CLEAR OV FLAG.
	MOVSI AC,400000		;SET AC FOR 1,0 CONDITION.
	ASH AC,1		;DO ASH.
	JFCL 10,.+2		;OV FLAG GET SET?
	ER AC,[ASCII /OV/]	;NO. 1,0 COND. SHOULD SET IT.
	LOOP ASHOV1,ASHOV1

;TEST ASH. DO ASH RIGHT 36 PLACES WITH ORIG.
;C(AC) = 400000000000. AFTER ASH THE C(AC) SHOULD = A -1.

	AC=10
ASH1:	SETUP 20,0
ASH2:	MOVE AC,[XWD 400000,0]	;MAKE C(AC) = ALL 0'S WITH SIGN BIT SET.
	ASH AC,-44		;DO ASH RIGHT 36 PLACES...SIGN
	CAME AC,[-1]		;BIT SHOULD HAVE SET ALL BITS TO A ONE.
	ERROR AC,[-1]
	LOOP ASH2,ASH2

;TEST ASH. DO ASH LEFT 36 PLACES WITH ORIG. C(AC) =
;TO A -1. AFTER ASH THE C(AC) SHOULD = THE SIGN
;BIT SET AND THE REST ZEROS.

	AC=11
ASH3:	SETUP 20,0
ASH4:	MOVE AC,[-1]		;MAKE C(AC) = A -1.
	ASH AC,44		;DO ASH LEFT 36 PLACES..0'S GOING
	CAME AC,[XWD 400000,0]	;INTO BIT 35 SHOULD JUST LEAVE SIGN BIT SET.
	ERROR AC,[0]
	LOOP ASH4,ASH4

;TEST ADD. RAN TO 0 CONDITION.

	AC=10
ADD1:	SETUP 100,0
ADD2:	RANDOM
ADD3:	SETZ AC,		;CLEAR AC.
	ADD AC,RAN		;ADD RAN TO 0.
	CAME AC,RAN		;C(AC) SHOULD = RAN NUM.
	ERROR AC,RAN
	LOOP ADD2,ADD3

; TEST ADD. 0 TO RAN CONDITION.

	AC=10
ADD1A:	SETUP 100,0
ADD2A:	RANDOM
		;ADD A CONSTANT 0 TO RAN 5 TIMES.
ADD3A:	REPEAT 5,<
	ADD AC,[0]>
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN NUM.
	ERROR AC,RAN
	LOOP ADD2A,ADD3A

;TEST ADD. ADD 1'S COMP OF RAN TO RAN.
;SHOULD GET A -1.

	AC=10
ADD1B:	SETUP 100,0
ADD2B:	RANDOM
ADD3B:	SETCM AC1,RAN		;1'S COMP OF RAN TO AC1.
	ADD AC,AC1		;ADD IT TO RAN.
	CAME AC,[-1]		;C(AC) SHOULD = -1.
	ERROR AC,[-1]
	LOOP ADD2B,ADD3B

;TEST ADD. CHECK CRY0,CRY1,AND OV FLAGS.
;ADD, TO A RANDOM NUMBER, A -1 AND THEN A +1.
;CRY0 AND CRY1 SHOULD BOTH GET SET AND AROV SHOULD NOT GET SET.

	AC=10
ADD1C:	SETUP 400,2
ADD2C:	RANDOM
ADD3C:	JFCL 17,.+1		;CLEAR ALL FLAGS.
	ADD AC,[-1]		;ADD A -1 TO RAN.
	ADD AC,[1]		;ADD A +1 TO ANS OF ADDITION OF RAN AND A -1.
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERROR AC,RAN
	JFCL 4,CRY0A
	JFCL 2,.+2
	JRST	BOTHF
	ER	AC,[ASCII /CRY0/];CRY0 FAILED TO GET SET.
CRY0A:	JFCL	2,.+2
	ER	AC,[ASCII /CRY1/];CRY1 FAILED TO GET SET.
	JRST	AROVA
BOTHF:	ER	AC,[ASCII /CRY01/];BOTH CRY0 + CRY1 FAILED TO GET SET.
AROVA:	JFCL	10,.+2
	JRST	ADD4C
	ER	AC,[ASCII /OV/]	;AROV GOT SET.
ADD4C:	LOOP ADD2C,ADD3C

;TEST ADDM. WHERE E IS AN AC.
;RAN TO 0 CONDITION.

	AC=4
ADDM1:	SETUP 100,0
ADDM2:	RANDOM
	MOVE AC2,RAN		;SAVE RAN IN AN AC.
ADDM3:	SETZB AC1,RAN1		;MAKE C(E) = 0.
	ADDM AC,AC1		;DO ADDM.
	CAME AC2,AC1		;C(E) SHOULD =ORIG C(AC).
	ERRM RAN1,RAN
	LOOP ADDM2,ADDM3

;TEST ADDM. WHERE E IS AN AC.
;0 TO RAN CONDITION.

	AC=5
ADDM1A:	SETUP 100,0
ADDM2A:	RANDOM
	MOVE	AC2,RAN		;SAVE RAN IN AN AC.
ADDM3A:	SETZB AC1,RAN1		;MAKE C(AC) = 0.
	ADDM AC1,AC		;DO ADDM.
	CAME AC2,AC		;C(E) SHOULD = ORIG C(E).
	EERRM	,RAN1
	LOOP ADDM2A,ADDM3A

;TEST ADDM. WHERE E IS AN AC.
;1'S COMP RAN TO RAN.

	AC=6
ADDM1B:	SETUP 100,0
ADDM2B:	RANDOM
ADDM3B:	SETCM AC1,AC		;MAKE C(AC) = 1'S COMP OF C(E).
	MOVE RAN1,AC1		;SAVE C(AC) IN CASE OF ERROR.
	ADDM AC1,AC		;DO ADDM.
	CAME AC,[-1]		;C(E) SHOULD = A -1.
	EERRM	,RAN1
	LOOP ADDM2B,ADDM3B

;TEST ADDI. CHECK C(AC) FOR CORRECT DATA.
;0 TO RAN CONDITION.

	AC=2
ADDI1:	SETUP 20,0
ADDI2:	RANDOM
ADDI3:	ADDI AC,0		;DO ADDI.
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	EERRI	,0
	LOOP ADDI2,ADDI3

;TEST ADDI. CHECK FOR CORRECT DATA IN AC.
;RAN TO 0 CONDITION.

	AC=2
ADDI1A:	SETUP 100,0
ADDI2A:	RANDOM
ADDI3A:	SETZB AC1,RAN1		;CLEAR C(AC).
	MOVEI AC2,(AC)		;SIMULATE ADDI.
	ADDI AC1,(AC)		;DO ADDI.
	CAME AC1,AC2		;C(AC) SHOULD = SIM. ANS.
	ERRI	RAN1,(AC)
	LOOP ADDI2A,ADDI3A

;TEST ADDI. CHECK FOR CORRECT DATA IN AC.
;1'S COMP RAN TO RAN.

	AC=3
ADDI1B:	SETUP 40,0
ADDI2B:	RANDOM
ADDI3B:	SETCM AC1,AC		;MAKE C(AC) = 1'S COMP OF E.
	MOVE AC2,AC1		;SIMULATE
	IORI AC2,-1		;ADDI INST.
	MOVE RAN1,AC1		;SAVE C(AC) IN CASE OF ERROR.
	ADDI AC1,(AC)		;DO ADDI.
	CAME AC1,AC2		;C(AC) SHOULD = SIM. ANS.
	ERRI RAN1,(AC)
	LOOP ADDI2B,ADDI3B

;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT
;DATA IN AC FOR 0 TO RAN CONDITION.

	AC=4
ADDB1:	SETUP 100,0
ADDB2:	RANDOM
ADDB3:	SETZB AC1,RAN1		;CLEAR C(E).
	ADDB AC,AC1		;DO ADDB.
	CAME AC,AC1		;C(AC) SHOULLD = C(E).
	ERR RAN1,RAN
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR RAN1,RAN
	LOOP ADDB2,ADDB3

;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT
;DATA IN AC FOR RAN TO 0 CONDITION.

	AC=5
ADDB1A:	SETUP 100,0
ADDB2A:	RANDOM
ADDB3A:	SETZB AC1,RAN1		;CLEAR C(AC).
	ADDB AC1,AC		;DO ADDB.
	CAME AC1,AC		;C(AC) SHOULD = C(E).
	EERR	,RAN1
	CAME AC1,RAN		;C(AC) SHOULD = ORIG C(E).
	EERR	,RAN1
	LOOP ADDB2A,ADDB3A

;TEST ADDB. CHECK FOR C(AC) = C(E), AND CORRECT DATA
;IN AC FOR NOT RAN TO RAN CONDITION.

	AC=6
ADDB1B:	SETUP 100,0
ADDB2B:	RANDOM
ADDB3B:	SETCM AC1,AC		;MAKE C(E) = 1'S COMP OF C(AC).
	MOVE RAN1,AC1		;SAVE C(E) IN CASE OF ERROR.
	ADDB AC,AC1		;DO ADDB.
	CAME AC,AC1		;C(AC) SHOULD = C(E).
	ERR	RAN1,RAN
	CAME AC,[-1]		;C(AC) SHOULD = A -1.
	ERR RAN1,RAN
	LOOP ADDB2B,ADDB3B

;TEST SUB. CHECK C(AC) FOR CORRECT DATA.
;0 TO RAN CONDITION.

	AC=2
SUB1:	SETUP 100,0
SUB2:	RANDOM
SUB3:	SETZB AC1,RAN1		;CLEAR C(E).

	REPEAT 3,<
	SUB AC,AC1>
	CAME AC,RAN		;C(AC) SHOULD STILL = ORIG C(AC).
	ERR RAN1,RAN
	LOOP SUB2,SUB3

;TEST SUB. CHECK C(AC) FOR CORRECT DATA.
;RAN TO 0 CONDITION.

	AC=2
SUB1A:	SETUP 100,0
SUB1B:	RANDOM
SUB1C:	SETZB AC1,RAN1		;CLEAR C(AC).
	MOVN AC2,RAN		;ANY NUM FROM 0 = 2'S COMP OF THAT NUM.
	SUB AC1,AC		;SUBTRACT RAN FROM 0.
	CAME AC1,AC2		;C(AC) SHOULD = SIM. ANS.
	EERR	,RAN1
	LOOP SUB1B,SUB1C

;TEST SUB. CHECK C(AC) FOR CORRECT DATA.
;SUB RAN FROM RAN.

	AC=2
SUB2A:	SETUP 100,0
SUB2B:	RANDOM
SUB2C:	MOVE AC1,AC		;MAKE C(E) = C(AC).
	SUB AC,AC1		;SUB RAN FROM RAN.
	CAME AC,[0]		;C(AC) SHOULD = 0.
	EERR	,RAN
	LOOP SUB2B,SUB2C

;TEST SUBM. WHERE E IS AN AC.
;RAN TO 0 CONDITION.

	AC=7
SUBM1:	SETUP 100,0
SUBM2:	RANDOM
SUBM3:	SETZB AC1,RAN1		;CLEAR C(AC).
	MOVN AC2,AC		;SIM SUB..RAN FROM 0 = 2'S COMP RAN.
	SUBM AC1,AC		;DO SUBM.
	CAME AC2,AC		;C(E) SHOULD = SIM. ANS.
	EERRM	,RAN1
	LOOP SUBM2,SUBM3

;TEST SUBM. SHERE E IS AN AC.
;0 TO RAN CONDITION.

	AC=10
SUBM1A:	SETUP 100,0
SUBM2A:	RANDOM
	MOVE AC2,RAN		;SAVE RAN IN AN AC.
SUBM3A:	SETZB AC1,RAN1		;CLEAR C(E).
	SUBM AC,AC1		;DO SUBM...0 FROM RAN = RAN.
	CAME AC2,AC1		;C(E) SHOULD = ORIG C(AC).
	ERRM RAN1,RAN
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERRM RAN1,RAN
	LOOP SUBM2A,SUBM3A

;TEST SUBM. WHERE E IS AN AC.
;RAN TO RAN CONDITION.

	AC=11
SUBM1B:	SETUP 100,0
SUBM2B:	RANDOM
SUBM3B:	MOVE AC1,AC		;MAKE C(E) = C(AC).
	SUBM AC,AC1		;DO SUBM.
	CAME AC1,[0]		;C(E) SHOULD = 0.
	EERRM	,RAN
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	EERRM	,RAN
	LOOP SUBM2B,SUBM3B

;TEST SUBI. CHECK C(AC) FOR CORRECT DATA.
;0 TO RAN CONDITION.

	AC=10
SUBI1:	SETUP 20,0
SUBI2:	RANDOM
SUBI3:	SUBI	AC,0		;DO SUBI..0 FROM RAN = RAN.
	CAME	AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	EERRI	,0
	LOOP	SUBI2,SUBI3

;TEST SUBI. CHECK C(AC) FOR CORRECT DATA.
;RAN TO 0 CONDITION.

	AC=10
SUBI1A:	SETUP 20,0
SUBI2A:	RANDOM
SUBI3A:	SETZB	AC1,RAN1	;CLEAR C(AC).
	MOVNI	AC2,(AC)	;SIM SUB..RAN FROM 0 = 2'S COMP RAN.
	SUBI	AC1,(AC)	;DO SUBI.
	CAME	AC1,AC2		;C(AC) SHOULD = SIM ANS.
	ERRI	RAN1,(AC)
	LOOP	SUBI2A,SUBI3A

;TEST SUBI. CHECK C(AC) FOR CORRECT DATA.
;RAN TO RAN CONDITION.

	AC=10
SUBI1B:	SETUP 20,0
SUBI2B:	RANDOM
	MOVE	RAN1,AC		;SAVE C(AC) IN CASE OF ERROR.
SUBI3B:	MOVE	AC1,AC		;SIMULATE A
	AND	AC1,[XWD -1,0]	;SUBI RAN FROM RAN.
	SUBI	AC,(AC)		;DO SUBI.
	CAME	AC,AC1		;C(AC) SHOULD = SIM. ANS.
	ERRI	RAN1,(RAN1)
	LOOP	SUBI2B,SUBI3B

;TEST SUBB. CHECK THAT C(AC) = C(E) AND C(AC)
;= CORRECT DATA.
;0 TO RAN.

	AC=10
SUBB1:	SETUP 20,0
SUBB2:	RANDOM
SUBB3:	SETZB	AC1,RAN1	;CLEAR C(E).
	SUBB	AC,AC1		;DO SUBB..0 FROM RAN = RAN.
	CAME	AC,AC1		;C(AC) SHOULD = C(E).
	ERR	RAN1,RAN
	CAME	AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR	RAN1,RAN
	LOOP	SUBB2,SUBB3

;TEST SUBB. CHECK C(AC) = C(E) AND C(AC) FOR
;CORRECT DATA.
;RAN TO 0 CONDITION.

	AC=10
SUBB1A:	SETUP 20,0
SUBB2A:	RANDOM
SUBB3A:	SETZB	AC1,RAN1	;CLEAR C(AC).
	MOVN	AC2,AC		;SIMULATE SUB...RAN FROM 0 = 2'S COMP RAN.
	SUBB	AC1,AC		;DO SUBB.
	CAME	AC1,AC		;C(AC) SHOULD = C(E).
	EERR	,RAN1
	CAME	AC1,AC2		;C(AC) SHOULD = SIM. ANS.
	EERR	,RAN1
	LOOP	SUBB2A,SUBB3A

;TEST SUBB. CHECK C(AC) = C(E) AND FOR
;CORRECT DATA IN AC.
;RAN TO RAN CONDITION.

	AC=10
SUBB1B:	SETUP 40,0
SUBB2B:	RANDOM
SUBB3B:	MOVE	AC1,AC		;MAKE C(E) = C(AC).
	SUBB	AC,AC1		;DO SUBB..RAN FROM RAN = 0.
	CAME	AC,AC1		;C(AC) SHOULD = C(E).
	EERR	,RAN
	CAME	AC,[0]		;C(AC) SHOULD = 0.
	EERR	,RAN
	LOOP	SUBB2B,SUBB3B


;TEST MOVEI. CHECK C(AC) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=2
MVEI1:	SETUP 20,0
MVEI2:	RANDOM
	MOVE AC2,RAN		;SAVE RAN IN AN AC.
MVEI3:	MOVSS RAN1,AC		;MAKE C(AC) = SEC RAN NUM.
	MOVE AC1,RAN		;SIMULATE
	LSH AC1,22		;A
	LSH AC1,-22		;MOVEI.
	MOVEI AC,(AC2)		;DO A MOVEI.
	CAME AC,AC1		;C(AC) SHOULD = SIM. ANS.
	ERRI RAN1,(AC2)
	LOOP MVEI2,MVEI3

;TEST MOVN. TWO MOVN INSTRUCTIONS SHOULD NOT CHANGE C(AC).

	AC=2
MOVN1:	SETUP 200,0
MOVN2:	RANDOM
		;DO 6 X (MOVN RAN TO RAN).
MOVN3:	REPEAT 3,<
	MOVN AC,AC
	MOVN AC,AC>
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN NUM.
	ERROR AC,RAN
	LOOP MOVN2,MOVN3

;TEST MOVNI. CHECK C(AC) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=2
MVNI1:	SETUP 40,0
MVNI2:	RANDOM
	MOVE AC2,RAN		;SAVE RAN IN AN AC.
MVNI3:	MOVSS RAN1,AC		;C(AC) = SEC RAN NUM.
	MOVEI	AC1,(AC2)	;SIMULATE
	SETCA AC1,		;A
	ADD AC1,[1]		;MOVNI INST.
	MOVNI AC,(AC2)		;DO A MOVNI.
	CAME AC,AC1		;C(AC) SHOULD = SIM. ANS.
	ERRI RAN1,(AC2)
	LOOP MVNI2,MVNI3

;TEST MOVNM. WHERE E IS AN AC.
;CHECK C(E) FOR CORRECT DATA.
;RAN TO RAN.

	AC=2
MVNM1:	SETUP 100,0
MVNM2:	RANDOM
	MOVE RAN1,RAN		;SAVE RAN IN AN AC.
MVNM3:	MOVE AC1,AC		;MAKE C(E) = C(AC).
		;DO 3 X 2(MOVNM).
	REPEAT 3,<
	MOVNM AC,AC1
	MOVNM AC1,AC>
	CAME RAN1,AC		;C(E) SHOULD = ORIG C(E).
	EERRM	,RAN
	LOOP MVNM2,MVNM3

;TEST MOVNS. WHERE E IS AN AC.
;CHECK PROPER STORING OF C(E) INTO AC.
;TWO MOVNS = ORIG NUMBER.
;C(E) = RAN.

	AC=3
MVNS1:	SETUP 100,0
MVNS2:	RANDOM
	MOVE AC2,RAN		;PUT C(RAN) INTO AC2 FOR FUTURE COMPARE.
MVNS3:	SETOB AC1,RAN1		;MAKE C(AC) = -1.
		;DO 3 X 2(MOVNS).
	REPEAT 3,<
	MOVNS AC1,AC
	MOVNS AC1,AC>
	CAME AC1,AC		;C(AC) SHOULD = C(E).
	EERRM	,RAN1
	CAME AC2,AC		;C(E) SHOULD = ORIG. C(E).
	EERRM	,RAN1
	LOOP MVNS2,MVNS3

;TEST MOVNS. WHERE E IS AN AC.
;CHECK FOR NOT LOADING C(E) INTO AC WHEN AC= 0.
;TWO MOVNS = ORIGINAL NUM.
;C(E) = RAN.

	AC=10
MVNSA:	SETUP 40,0
MVNSB:	RANDOM
	MOVE AC2,RAN		;SAVE RAN IN AN AC.
MVNSC:	SETOB RAN1		;MAKE C(AC) = -1.
		;DO 3 X 2(MOVNS).
	REPEAT 3,<
	MOVNS AC
	MOVNS AC>
	CAMN AC		;C(AC) SHOULD NOT = C(E).
	EERRM	,RAN1
	CAME AC2,AC		;C(AC) SHOULD = ORIG C(AC).
	EERRM	,RAN1
	LOOP MVNSB, MVNSC

;TEST MOVM. CHECK F(AC) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=7
MVM1:	SETUP 40,0
MVM2:	RANDOM
MVM3:	MOVSS	RAN1,AC		;C(AC) = SEC RAN NUM.
	MOVE	AC1,RAN		;C(E) = 1ST RAN NUM.
	SETCM	AC2,AC1		;SIMULATE
	TLNN	AC1,400000	;A
	MOVE	AC2,AC1		;MOVM
	TLNE	AC1,400000	;INST.
	ADD	AC2,[1]
	MOVM	AC,AC1		;DO A MOVM.
	CAME	AC,AC2		;C(AC) SHOULD = SIM. ANS.
	EERR	,RAN1
	LOOP	MVM2, MVM3

;TEST MOVMI. CHECK C(AC) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=10
MVMI1:	SETUP 40,0
MVMI2:	RANDOM
MVMI3:	MOVEI	AC1,AC		;SIMULATE A MOVMI INST...MOVEI.
	MOVSS	RAN1,AC		;C(AC) = SEC RAN NUM.
	MOVMI	AC,(AC1)	;DO MOVMI.
	CAME	AC,AC1		;C(AC) SHOULD = SIM ANS.
	ERRI	RAN1,(AC1)
	LOOP	MVMI2, MVMI3

;TEST MOVMM. CHECK C(AC) + C(E) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=11
MVMM1:	SETUP 200,0
MVMM2:	RANDOM
MVMM3:	MOVSS	RAN1,AC		;C(AC) = SEC RAN NUM.
	MOVE	AC1,RAN		;C(E) = RAN.
	SETCM	AC2,AC		;SIMULATE
	TLNN	AC,400000	;A
	MOVE	AC2,AC		;MOVMM
	TLNE	AC,400000	;INST
	ADD	AC2,[1]
	MOVMM	AC,AC1		;DO A MOVMM INST.
	CAME	AC,RAN1		;C(AC) SHOULD = ORIG C(AC).
	EERRM	,RAN1
	CAME	AC1,AC2		;C(E) SHOULD = SIM. ANS.
	EERRM	,RAN1
	LOOP	MVMM2, MVMM3

;TEST MOVMS. CHECK C(E) FOR CORRECT DATA.
;RAN TO RAN1.

	AC=10
MVMS1:	SETUP 200,0
MVMS2:	RANDOM
MVMS3:	MOVSS	RAN1,AC		;C(AC) = SEC RAN NUM.
	MOVE	AC1,RAN		;C(E) = RAN.
	SETCM	AC2,RAN		;SIMULATE
	TLNN	AC1,400000	;A
	MOVE	AC2,AC1		;MOVMS
	TLNE	AC1,400000	;INST.
	ADD	AC2,[1]	
	MOVMS	AC,AC1		;DO A MOVMS.
	CAME	AC,AC1		;C(AC) SHOULD = C(E).
	EERRM	,RAN1
	CAME	AC1,AC2		;C(E) SHOULD = SIM. ANS.
	EERRM	,RAN1
	LOOP	MVMS2, MVMS3

;TEST LSH. A LSH LEFT AND A LSH RIGHT SHOULD
;GIVE THE SAME NUMBER WITH A ZERO SIGN BIT.

	AC=2
LSH1P:	SETUP 40,0
LSH1PA:	RANDOM
LSH1PB:	AND AC,[XWD 377777,-1]	;SIMULATE A LSH LEFT THEN RIGHT.
	MOVE AC1,RAN		;MOVE RANDOM NUM INTO AN AC
		;AND DO 3(LSH LEFT 1 PLACE THEN RIGHT 1 PLACE).
	REPEAT 3,<
	LSH AC1,1
	LSH AC1,-1>
	CAME AC1,AC		;C(AC1) = SIM. ANS?
	ERROR AC1,AC		;NO. LSH FAILED.
	LOOP LSH1PA,LSH1PB

;TEST TDN,TDNA. CHECK FOR SKIP/NO SKIP AND
;NO DATA CHANGE IN AC FOR RAN1 TO RAN CONDITION.

	AC=2
TDN1:	SETUP 100,0
TDN2:	RANDOM
TDN3:	MOVS AC1,AC		;PUT SECOND RAN. NUM. INTO "E".
	TDN AC,AC1		;NO SKIP, NO DATA CHANGE.
	JRST	.+2		;HERE..GO AROUND ERR UUO.
	ER	AC,[ASCII /TST/];TDN SKIPPED.
	TDNA AC,AC1		;SKIP, NO DATA CHANGE.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR	AC1,RAN
	LOOP TDN2,TDN3

;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE IN AC FOR RAN TO 0 CONDITION.

	AC=3
TDNE1A:	SETUP 100,0
TDNE2A:	RANDOM
TDNE3A:	SETZB AC1,RAN1		;CLEAR C(AC).
	TDNN AC1,AC		;C(E) + C(AC) =0..NO SKIP.
	JRST	.+2
	ER	AC1,[ASCII /TST/];TDNN SKIPPED.
	TDNE AC1,AC		;C(E) + C(AC) = 0. SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,[0]		;C(AC) SHOULD STILL = 0.
	ERR	AC,RAN1
	LOOP TDNE2A,TDNE3A

;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE FOR 0 TO RAN CONDITION.

	AC=4
TDNE1B:	SETUP 40,0
TDNE2B:	RANDOM
TDNE3B:	SETZ AC1,		;CLEAR C(E).
	TDNN AC,AC1		;C(E) + C(AC) = 0. NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDNN SKIPPED.
	TDNE AC,AC1		;C(E) + C(AC) = 0. SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR	AC1,RAN
	LOOP TDNE2B,TDNE3B

;TEST TDNN,TDNE. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE IN AC FOR RAN TO -1 CONDITION.

	AC=5
TDNE1C:	SETUP 40,0
TDNE2C:	RANDOM
	JUMPE AC,TDNE2C		;REJECT IF RAN = 0.
TDNE3C:	SETOB AC1,RAN1		;SET C(AC) TO ALL ONES.
	TDNE AC1,AC		;C(E) + C(AC) NOT = 0..NO SKIP.
	JRST	.+2
	ER	AC1,[ASCII /TST/];TDNE SKIPPED.
	TDNN AC1,AC		;C(E) + C(AC) NOT = 0..SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,[-1]		;C(AC) SHOULD = ORIG C(AC).
	ERR AC,RAN1
	LOOP TDNE2C,TDNE3C

;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE IN AC FOR -1 TO RAN CONDITION.

	AC=6
TDNE1D:	SETUP 40,0
TDNE2D:	RANDOM
	JUMPE AC,TDNE2D		;REJECT IF RAN = 0.
TDNE3D:	SETO AC1,		;SET C(E) TO ALL ONES.
	TDNE AC,AC1		;C(E) + C(AC) NOT = 0..NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDNE SKIPPED.
	TDNN AC,AC1		;C(E) + C(AC) NOT = 0..SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR AC1,RAN
	LOOP TDNE2D,TDNE3D

;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE IN AC FOR RAN TO RAN CONDITION.

	AC=7
TDNE1E:	SETUP 20,0
TDNE2E:	RANDOM
	JUMPE AC,TDNE2E		;REJECT IF RAN = 0.
TDNE3E:	MOVE AC1,AC		;MAKE C(E) = C(AC).
	TDNE AC,AC1		;C(E) + C(AC) NOT = 0..NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDNE SKIPPED.
	TDNN AC,AC1		;C(E) + C(AC) NOT = 0. SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR AC1,RAN
	LOOP TDNE2E,TDNE3E

;TEST TDNE,TDNN. CHECK FOR SKIP/ NO SKIP AND
;NO DATA CHANGE IN AC FOR NOT RAN TO RAN CONDITON.

	AC=10
TDNE1F:	SETUP 20,0
TDNE2F:	RANDOM
TDNE3F:	SETCM AC1,AC		;MAKE C(E) = 1'S COMP OF C(AC).
	TDNN AC,AC1		;C(E) + C(AC) = 0..NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDNN SKIPPED.
	TDNE AC,AC1		;C(E) + C(AC) = 0..SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR AC1,RAN
	LOOP TDNE2F,TDNE3F

;TEST TDZ,TDZA. CHECK FOR SKIP/ NO SKIP AND
;CORRECT DATA IN AC FOR NOT RAN TO RAN CONDITION.

	AC=11
TDZA1:	SETUP 100,0
TDZA2:	RANDOM
TDZA3:	SETCM AC1,AC		;MAKE C(E) 1'S COMP OF C(AC).
	TDZ AC,AC1		;SHOULD NOT SKIP.
	JRST	.+2
	ER	AC,[ASCII/TST/]	;TDZ SKIPPED.
	TDZA AC,AC1		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN NUM.
	ERR AC1,RAN
	CAMN AC1,RAN		;C(E) SHOULD NOT = RAN.
	ERR AC1,RAN
	LOOP TDZA2,TDZA3

;TEST TDZ,TDZA. CHECK FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO RAN CONDITION.

	AC=10
TDZAA:	SETUP 100,1
TDZAB:	RANDOM
TDZAC:	TDZ AC,AC		;SHOULD NOT SKIP.
	CAME AC,[0]		;SHOULD CLEAR C(AC).
	EERR	,RAN
	MOVE AC,RAN		;RESTORE AC.
	TDZA AC,AC		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,[0]		;C(AC) SHOULD BE CLEARED.
	EERR	,RAN
	LOOP TDZAB,TDZAC


;TEST TDZ,TDZA. CHECK FOR SKIP/ NO SKIP AND
;CORRECT DATA IN AC FOR RAN1 TO RAN CONDITION.

	AC=10
TDZB1:	SETUP 100,0
TDZB2:	RANDOM
TDZB3:	MOVS AC1,AC		;MAKE C(E) A DIFF. RAN. NUM.
	MOVE AC2,AC1		;SIMULATE
	XOR AC2,AC		;A
	AND AC2,AC		;TDZ.
	TDZ AC,AC1		;TDZ SHOULD NOT SKIP.
	CAME AC,AC2		;C(AC) SHOULD = SIM. ANS.
	ERR AC1,RAN
	MOVE AC,RAN		;RESTORE AC.
	TDZA AC,AC1		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;C(AC) SHOULD = SIM. ANS.
	ERR AC1,RAN
	LOOP TDZB2,TDZB3

;TEST TDZE, TDZN. CHECK FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR FLOATING ONE IN C(E) AND
;THAT BIT CLEARED IN RANDOM NUM. IN AC.

	AC=10
TDZE1:	SETUP 100,0
	MOVEI AC1,1		;SETUP AC1 TO CONTAIN A MASK BIT.
TDZE2:	RANDOM
	ROT AC1,1		;ROT TO TEST NEXT BIT.
TDZE3:	ANDCM AC,AC1		;CLEAR MASK BIT IN AC.
	MOVE AC2,AC		;SAVE FOR FUTURE COMPARE.
	TDZN AC,AC1		;C(E) + C(AC) = 0...NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/]	;TDZN SKIPPED.
	TDZE AC,AC1		;C(E) + C(AC) = 0...SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;C(AC) SHOULD = ORIG C(AC).
	ERR AC1,AC2
	LOOP TDZE2,TDZE3

;TEST TDZE, TDZN. CHECK FOR SKIP/ NO SKIP AND
;CORRECT DATA IN AC FOR FLOATING ONE IN C(E)
;AND THAT BIT SET IN RAN. NUM. IN C(AC).

	AC=10
TDZEA:	SETUP 100,0
	MOVEI AC1,1		;SET MASK BIT IN C(E).
TDZEB:	RANDOM
	ROT AC1,1		;ROT MASK BIT TO TEST NEXT BIT.
TDZEC:	IOR AC,AC1		;SET MASK BIT IN AC.
	MOVE	RAN1,AC		;SAVE C(AC) IN CASE OF ERROR.
	MOVE AC2,AC		;SIMULATE
	ANDCM AC2,AC1		;A TDZ.
	TDZE AC,AC1		;C(E) + C(AC) NOT = 0...NO SKIP.
	CAME AC,AC2		;C(AC) SHOULD = SIM. ANS.
	ERR AC1,RAN1
	IOR AC,AC1		;RESET MASK BIT IN AC.
	TDZN AC,AC1		;C(E) + C(AC) NOT = 0...SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;AND C(AC) SHOULD = SIM. ANS.
	ERR AC1,RAN1
	LOOP TDZEB,TDZEC

;TEST TDZE,TDZN. SET AND ROT A MASK BIT IN AC
;AND CHECK SKIP/NO SKIP AND PROPER C(AC)
;FOR MASK BIT IN AC ANS RANDOM NUMBER IN E.

	AC=10
TDZNA:	SETUP 100,0
	MOVEI AC1,1		;SETUP AC1 FOR MASK BIT.
TDZNB:	RANDOM
	ROT AC1,1		;ROT AC1 TO TEST NEXT BIT.
	MOVE AC2,AC1		;SAVE MASK BIT.
TDZNC:	MOVE AC1,AC2		;RESTORE MASK BIT IF ERROR.
	ANDCM AC,AC1		;CLEAR MASK BIT IN RAN NUM.
	TDZN AC1,AC		;C(E) + C(AC) =0..SHOULDN'T SKIP.
	JRST	.+2
	ER	AC1,[ASCII /TST/];TDZN SKIPPED.
	TDZE AC1,AC		;C(E) + C(AC) = 0..SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,AC2		;C(AC1) SHOULD NOT HAVE CHANGED.
	ERR AC,AC2
	LOOP TDZNB,TDZNC

;TEST TDZE,TDZN. SET AND ROT A MASK BIT IN AC
;AND CHECK SKIP/NO SKIP AND PROPER C(AC)
;FOR MASK BIT IN AC AND RANDOM NUMBER IN E.
;RANDOM NUMBER HAS MASK BIT SET.

	AC=10
TDZN1:	SETUP 40,0
	MOVEI AC1,1		;SETUP AC1 FOR MASK BIT.
TDZN2:	RANDOM
	ROT AC1,1		;ROT AC1 TO TEST NEXT BIT.
TDZN3:	MOVE AC2,AC1		;SAVE MASK BIT.
	IOR AC,AC1		;SET MASK BIT IN RAN.
	TDZE AC1,AC		;C(E) + C(AC) NOT = 0...NO SKIP.
	CAME AC1,[0]		;C(AC) SHOULD = 0.
	ERR AC,AC2
	MOVE AC1,AC2		;RESTORE MASK BIT.
	TDZN AC1,AC		;C(E) + C(AC) NOT = 0...SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,[0]		;AC1 SHOULD HAVE GOTTEN CLEARED OUT.
	ERR AC,AC2
	MOVE AC1,AC2		;RESTORE MASK BIT.
	LOOP TDZN2,TDZN3

;TEST TDO TDOA. CHECK FOR SKIP/NO SKIP ANS CORRECT DATA
;IN AC FOR RAN TO NOT RAN.

	AC=10
TDOA1:	SETUP 100,0
TDOA2:	RANDOM
TDOA3:	SETCM AC1,AC		;MAKE "C(E)" = COMP OF RAN.
	TDO AC,AC1		;SHOULD NOT SKIP.
	CAME AC,[-1]		;AC SHOULD HAVE ALL BITS SET.
	ERR AC1,RAN
	MOVE AC,RAN		;RESTORE AC.
	TDOA AC,AC1		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,[-1]		;AC SHOULD HAVE ALL BITS SET.
	ERR AC1,RAN
	LOOP TDOA2,TDOA3

;TEST TDO,TDOA. CHECK SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO RAN CONDITION.

	AC=2
TDOAA:	SETUP 40,0
TDOAB:	RANDOM
TDOAC:	TDO AC,AC		;SHOULD NOT SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/] ;TDO SKIPPED.
	TDOA AC,AC		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD NOT HAVE CHANGED.
	EERR	,RAN
	LOOP TDOAB,TDOAC

;TEST TDO, TDOA. CHECK FOR SKIP/NO SKIP
;AND CORRECT DATA IN AC FOR RAN1 TO RAN CONDITION.

	AC=2
TDOB1:	SETUP 400,3
TDOB2:	RANDOM
TDOB3:	MOVS AC1,AC		;MAKE AC1 ANOTHER RAN NUM.
	MOVE AC2,AC		;SIMULATE
	XOR AC2,AC1		;A
	IOR AC2,AC		;TDO INST.
	TDO AC,AC1		;SHOULD NOT SKIP.
	CAME AC,AC2		;C(AC) = SIM. ANS?
	ERR AC1,RAN		;NO.
	MOVE AC,RAN		;RESTORE AC.
	TDOA AC,AC1		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;C(AC) = SIM ANS?
	ERR AC1,RAN		;NO.
	LOOP TDOB2,TDOB3

;TEST TDOE,TDON. ROT A MASK BIT IN E AND SET THAT 
;BIT IN AC BEFORE TDO. CHECK FOR SKIP/NO SKIP
;AND PROPER DATA IN AC.

	AC=2
TDOE1:	SETUP 40,0
	MOVEI AC1,1		;SETUP A MASK BIT IN "E".
TDOE2:	RANDOM
	ROT AC1,		;ROT MASK BIT TO TEST NEXT BIT.
TDOE3:	IOR AC,AC1		;SET MASK BIT IN AC.
	MOVE AC2,AC		;SAVE AC IN AC2.
	TDOE AC,AC1		;C(E) + C(AC) NOT = 0. NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDOE SKIPPED.
	TDON AC,AC1		;C(E) + C(AC) NOT = 0..SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;C(AC) SHOULD NOT CHANGE.
	ERR AC1,AC2
	LOOP TDOE2,TDOE3

;TEST TDOE,TDON. ROT A MASK BIT IN E AND CLEAR THAT
;BIT IN AC BEFORE TDO. CHECK FOR SKIP/NO SKIP
;AND PROPER DATA IN AC.

	AC=3
TDOEA:	SETUP 40,0
	MOVEI AC1,1		;SETUP MASK BIT IN"E".
TDOEB:	RANDOM
	ROT AC1,1		;ROT MASK BIT TO TEST NEXT BIT.
TDOEC:	ANDCM AC,AC1		;CLEAR MASK BIT IN AC.
	MOVE RAN1,AC		;SAVE AC.
	MOVE AC2,AC		;SIMULATE
	IOR AC2,AC1		;A TDO.
	TDOE AC,AC1		;C(E) + C(AC) = 0. SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,AC2		;C(AC) = SIM ANS?
	ERR AC1,RAN1		;NO.
	MOVE AC,RAN1		;RESTORE AC.
	TDON AC,AC1		;C(E) + C(AC) = 0..NO SKIP.
 	CAME AC,AC2		;C(AC) = SIM. ANS?
	ERR AC1,RAN1		;NO.
	LOOP TDOEB,TDOEC

;TEST TDOE,TDON. ROT A MASK BIT IN AC AND CLEAR THAT
;BIT IN E BEFORE TDO. CHECK FOR SKIP/NO SKIP
;AND PROPER DATA IN AC.

	AC=4
TDONA:	SETUP 40,0
	MOVEI AC1,1		;SETUP  A MASK BIT IN AC.
TDONB:	RANDOM
	ROT AC1,1		;ROT BIT TO TEST NEXT BIT.
	MOVE AC2,AC1		;SAVE MASK BIT SO IN CASE
TDONC:	MOVE AC1,AC2		;OF ERROR IT CAN BE RESTORED.
	ANDCM AC,AC1		;CLEAR MASK BIT IN E.
	JUMPE AC,TDONB		;REJECT IF C(AC) = 0.
	MOVE AC3,AC		;SIMULATE
	IOR AC3,AC1		;TDO.
	TDOE AC1,AC		;C(E) + C(AC) = 0...SKIP.
	ER	AC1,[ASCII /TST/];TDOE DID NOT SKIP.
	CAME	AC1,AC3		;C(AC) SHOULD = SIM. ANS.
	ERR	AC,AC2
	TDON AC1,AC		;C(E) + C(AC) NOT = 0...SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,AC3		;C(AC) SHOULD = SIM. ANS.
	ERR AC,AC2
	MOVE AC1,AC2		;RESTORE AC.
	LOOP TDONB,TDONC

;TEST TDOE,TDON. ROT A MASK BIT IN AC  AND SET
;THAT BIT IN E BEFORE TDO. CHECK FOR SKIP/ NO SKIP
;AND CORRECT DATA IN AC.

	AC=5
TDON1:	SETUP 40,0
	MOVEI AC1,1		;SETUP AC TO CONTAIN A MASK BIT.
TDON2:	RANDOM
	ROT AC1,1		;ROT TO TEST NEXT BIT.
	MOVE AC2,AC1		;SAVE C(AC) SO IT CAN BE
TDON3:	MOVE AC1,AC2		;RESTORED IN CASE OF ERROR.
	IOR AC,AC1		;SET MASK BIT IN E.
	TDOE AC1,AC		;C(E) + C(AC) NOT = 0...NO SKIP.
	JRST	.+2
	ER	AC1,[ASCII /TST/];TDOE SKIPPED.
	TDON AC1,AC		;C(E) + C(AC) NOT = 0...SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,AC		;C(AC) SHOULD = C(E).
	ERR AC,AC2
	MOVE AC1,AC2		;RESTORE AC.
	LOOP TDON2,TDON3

;TEST TDC. CHECK FOR SKIP/NO SKIP AND CORRECT
;DATA FOR NOT RAN TO RAN CONDITION.

	AC=6
TDC1:	SETUP 100,0
TDC2:	RANDOM
TDC3:	SETCM AC1,RAN		;MAKE C("E") = COMP. OF RAN.
	TDC AC,AC1		;NO SKIP.
	CAME AC,[-1]		;C(AC) SHOULD = A -1.
	ERR AC1,RAN
	SETO RAN1,		;SET RAN1 FOR ERROR MESSAGE.
	TDC AC,AC1		;NO SKIP.
	CAME AC,RAN		;C(AC) SHOULD = RAN AGAIN.
	ERR AC1,RAN1
	LOOP TDC2,TDC3

;TEST TDCA. CHECKING FOR SKIP/ NO SKIP AND
;CORRECT DATA IN AC FOR NOT RAN TO RAN CONDITION.

	AC=10
TDCA1:	SETUP 100,0
TDCA2:	RANDOM
TDCA3:	SETCM AC1,RAN		;MAKE C("E") = COMP OF RAN.
	TDC AC,AC1		;SHOULD NOT SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDC SKIPPED.
	TDCA AC,AC1		;SHOULD SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;TWO TDC'S SHOULD RETURN C(AC)
				;TO IT'S ORIGINAL VALUE.
	ERR AC1,RAN
	LOOP TDCA2,TDCA3

;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO 0 CONDITION.

	AC=11
TDCE1:	SETUP 100,0
TDCE2:	RANDOM
TDCE3:	SETZB AC1,RAN1		;CLEAR BOTH AC AND RAN1.
	TDCE AC1,AC		;C(E) + C(AC) = 0. SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,RAN		;C(AC) SHOULD = RAN.
	EERR	,RAN1
	LOOP TDCE2,TDCE3

;TEST TDCE,TDCN. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR 0 TO RAN CONDITION.

	AC=11
TDCEA:	SETUP 100,0
TDCEB:	RANDOM
TDCEC:	SETZ AC1,		;CLEAR C(E).
	TDCN AC,AC1		;C(E) + C(AC) = 0...NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDCN SKIPPED.
	TDCE AC,AC1		;C(E) + C(AC) = 0. SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD STILL = RAN.
	ERR AC1,RAN
	LOOP TDCEB,TDCEC

;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO -1 CONDITION.

	AC=10
TDCE4:	SETUP 100,0
TDCE5:	RANDOM
	JUMPE AC,TDCE5		;REJECT IF RAN = 0.
TDCE6:	SETOB AC1,RAN1		;SET C(AC) TO ALL ONES.
	SETCM AC2,AC		;SIMULATE A TDC.
	TDCE AC1,AC		;C(E) + C(AC) NOT = 0. NO SKIP.
	CAME  AC1,AC2		;C(AC) = SIM.. ANS?
	ERR AC,RAN1		;NO.
	LOOP TDCE5,TDCE6

;TEST TDCE,TDCN. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR -1 TO RAN CONDITION.

	AC=10
TDCED:	SETUP 100,0
TDCEE:	RANDOM
	JUMPE AC,TDCEE		;REJECT IF RAN = 0.
	CAMN AC,[-1]		;C(AC) = -1?
	JRST	TDCEE		;YES. REJECT.
TDCEF:	SETOB AC1,RAN1		;SET C(E) TO ALL ONES.
	TDCE AC,AC1		;C(E) + C(AC) NOT = 0. NO SKIP.
	JRST	.+2
	ER	AC,[ASCII /TST/];TDCE SKIPPED.
	TDCN AC,AC1		;C(E) + C(AC) NOT = 0..SKIP.
	ER AC,[ASCII /TST/]
	CAME AC,RAN		;C(AC) SHOULD = ORIG C(AC).
	ERR RAN1,RAN
	LOOP TDCEE,TDCEF

;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO RAN CONDITION.

	AC=10
TDCE7:	SETUP 100,0
TDCE8:	RANDOM
	JUMPE AC,TDCE8		;REJECT IF RAN = 0.
TDCE9:	MOVE AC1,RAN		;MAKE C("AC") = C("E").
	TDCE AC1,AC		;C(E) + C(AC) NOT = 0. NO SKIP.
	CAME AC1,[0]		;C(AC) SHOULD = 0.
	ERR AC,AC
	LOOP TDCE8,TDCE9

;TEST TDCE. CHECKING FOR SKIP/NO SKIP AND
;CORRECT DATA IN AC FOR RAN TO NOT RAN.

	AC=10
TDCEG:	SETUP 100,0
TDCEH:	RANDOM
TDCEI:	SETCM AC1,AC		;MAKE C("AC") = TO COMP OF RAN.
	MOVE RAN1,AC1		;SAVE C(AC) IN CASE OF ERROR.
	TDCE AC1,AC		;C(E) + C(AC) = 0. SKIP.
	ER AC1,[ASCII /TST/]
	CAME AC1,[-1]		;C(AC) SHOULD = -1.
	ERR AC,RAN1
	LOOP TDCEH,TDCEI



	JRST	BEGEND		;REPEAT TEST