---
layout: page
title: PDP-10 KA10 Basic Instruction Diagnostic #1
permalink: /apps/pdp10/tapes/diags/klad/dakaa/
machines:
  - id: testka10
    type: pdp10
    config: /devices/pdp10/machine/ka10/test/debugger/machine.xml
    debugger: true
---

PDP-10 KA10 Basic Instruction Diagnostic #1
-------------------------------------------

The *PDP-10 KA10 Basic Instruction Diagnostic #1* (MAINDEC-10-DAKAA-B-D) test code has been extracted from
[DAKAA.MAC](DAKAA.MAC) [[original file](http://pdp-10.trailing-edge.com/klad_sources/01/klad.sources/dakaam.mac.html)]
for use with the [PDP-10 Test Machine with Debugger](/devices/pdp10/machine/ka10/test/debugger/) below.

Resources for this test include:

- [DAKAA.TXT](#dakaatxt)
- [DAKAA.MAC](#dakaamac)
- [DAKAA.SEQ](#dakaaseq)

{% include machine.html id="testka10" %}

The Debugger's assemble ("a") command can be used to test the new built-in
[MACRO-10 mini-assembler](/modules/pdp10/lib/macro10.js), which supports a subset
of the [MACRO-10](http://archive.pcjs.org/pubs/dec/pdp10/tops10/02_1973AsmRef_macro.pdf) assembly language.
This command:

	a 30724 /apps/pdp10/tapes/diags/klad/dakaa/TEST.MAC

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

---

DAKAA.TXT
---------

```
MAINDEC-10-DAKAA






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

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

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

	FUNCTION:	BASIC INSTRUCTIONS

	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-DAKAA.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-DAKAA.TXT
							PAGE 3


1.0	ABSTRACT

	THIS PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC IS THE FIRST IN A
	SERIES OF PDP-10 KA10 PROCESSOR DIAGNOSTICS.  IT IS THE MOST
	BASIC OF THE PROCESSOR DIAGNOSTICS.  THIS DIAGNOSTIC
	ASSUMES THE HALT INSTRUCTION AND THE COMPUTER CONSOLE
	TO BE OPERATIVE.  IT MAKES NO FURTHER ASSUMPTIONS EXCEPT
	THAT IT IS LOADED INTO MEMORY CORRECTLY.

	THE DIAGNOSTIC TESTS SOME OF THE MOVE AND SKIP INSTRUCTIONS.
	IT ALSO TESTS THE ADDERS AND OTHER LOGIC WITH AND, XOR, EQV,
	AND ALL BOOLE 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 
							MAINDEC-10-DAKAA.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-DAKAA.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

```

DAKAA.MAC
---------

```
SUBTTL	DIAGNOSTIC SECTION

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

PGMNAM:	ASCIZ/
PDP-10 KA10 BASIC INSTRUCTION DIAGNOSTIC (1) [DAKAA]
/

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


STARTA:	JRST	.+1
SUBTTL	TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS

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

;THIS TEST VERIFIES THAT SKIPA ALWAYS SKIPS THE NEXT INSTRUCTION

A00=.
A12500:	SKIPA			;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
	HALT			;IF PROGRAM HALTS, SKIPA DID NOT SKIP

;IF PROGRAM HANGS UP ON SKIPA INSTRUCTION, CHECK AB PC EN [ABC], AB PC F/F [ABC],
;AB PC B [ABC OR AB], AB PC (FETCH) EN [ABC], IR SKIPS [IR3], IR SKIPX [IR1],
;IR 3XX [IR1], IR BITS 00 - 08 [IR1], F CYC ACT EN C [FI], FT6 F/F [F2],
;PC CLOCK EN [PCC],  ET2 J F/F [E], PC CLK (ET2) EN [PCC], ADZ COND P [ADZ] AND
;ADZ COND R [ADZ], PC CLOCK A [PCC], PC CLOCK B [PCC]

;IF PROGRAM HALTED ON HALT INSTRUCTION, CHECK ST1 COND [ST2]

;**********

;THIS TEST VERIFIES THAT JUMP NEVER JUMPS

A15000:	JUMP	.+1		;*JUMP SHOULD NEVER JUMP
	SKIPA			;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
	HALT			;HALT IF JUMP FAILS

;IF PROGRAM HANGS UP ON JUMP .+1 INSTRUCTION, THE JUMP INSTRUCTION
;MAY HAVE FAILED.  CHECK ST1 COND [ST2], ST INST FET ST1 EN [ST2], ET2 D F/F [E],
;IR JUMPS [IR1], IR JUMPX [IR1]

;**********
;THIS TEST VERIFIES THAT JUMP NEVER JUMPS

A15100:	JUMP	.+2		;*JUMP SHOULD NEVER JUMP
	SKIPA			;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
	HALT			;HALT IF JUMP FAILS

;AB PC EN [ABC]

;**********

;THIS TEST VERIFIES THAT JUMPA .+1 ALWAYS JUMPS TO THE NEXT INSTRUCTION

A12700:	JUMPA	.+1		;*JUMPA .+1 SHOULD NEVER JUMP
	SKIPA			;SKIP HALT INSTRUCTION IF JUMPA IS SUCCESSFUL
	HALT			;HALT IF JUMPA .+1 FAILED

;**********

;THIS TEST VERIFIES THAT JUMPA JUMPS TO THE LOCATION SPECIFIED BY E WHEN E=.+2

A12600:	JUMPA	.+2		;*JUMPA .+2 SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
	HALT			;PROGRAM HALTS HERE IF JUMPA .+2 FAILS

;ST1 COND [ST2]

;**********
;THIS TEST VERIFIES THAT SKIPA IS DATA INDEPENDENT.  HENCE, IT ALWAYS SKIPS THE NEXT
;INSTRUCTION.
;THE MOVE [0] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.

A100:	MOVE	[0]		;PRESET LOCATION 0 TO ALL ZEROS
	SKIPA			;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST INSURES THAT SKIPA IS DATA INDEPENDENT.  HENCE, IT ALWAYS SKIPS THE NEXT
;INSTRUCTION.
;THE MOVE [-1] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.

A200:	MOVE	[-1]		;PRESET LOCATION 0 TO ALL ONES
	SKIPA			;*SKIPA SKOULD ALWAYS SKIP THE NEXT INSTRUCTION
	STOP

;COND P [ADZ]

;**********
;THIS TEST VERIFIES THAT SKIPGE SKIPS THE NEXT INSTRUCTION WHEN C(E)
;IS ALL ZEROS.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH ALL ZEROS.

A300:	MOVE	[0]		;PRESET E TO ALL ZEROS
	SKIPGE			;*SKIPGE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;COND R [ADZ], AD00 S-A-1, AD AR + EN [ADAP], AD LT AR + EN [ADAP],
;AD RT AR + EN [ADAP], AD AR + EN C [ADAP], F CYC ACT EN A [F1]

;**********

;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT.  HENCE, SKIP NEVER SKIPS.  IT ALWAYS
;CONTINUES ON TO THE NEXT INSTRUCTION.

A400:	MOVE	[-1]		;PRESET E TO ALL ONES
	SKIP			;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;PC CHANGE [PCC], PC CHANGE A [PCC], SEE MEMORY CONTROL DWGS [MC1-4]

;**********
;THIS TEST VERIFIES THAT SKIPGE WILL NOT SKIP THE NEXT INSTRUCTION WHEN C(E) IS
;NEGATIVE.  THE MOVE INSTRUCTION LOADS E WITH -1, A NEGATIVE NUMBER.

A500:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NEGATIVE NUMBER
	SKIPGE			;*SKIPGE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;IF MOVE INSTRUCTION FAILED, CHECK MOVX-: FCE [F1], -IR XXXI [IR1], -IR XXXM [IR1],
;IR HWTFWT [IR3], IR FWT [IR2], IR2XX [IR1]

;IF SKIPGE FAILED, CHECK SKIPX: FCE [F1]

;**********

;THIS TEST VERIFIES THAT SKIPN WILL NOT SKIP THE NEXT INSTRUCTION WHEN
;C(E) IS ZERO.  THE MOVE INSTRUCTION  LOADS E WITH ALL ZEROS.

A600:	MOVE	[0]		;PRESET E WITH ALL ZEROS
	SKIPN			;*SKIPN SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT SHOULD SKIP
;THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO.  THE MOVE INSTRUCTION LOADS
;E WITH -1, A NON-ZERO NUMBER.

A700:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT.  HENCE, IT SHOULD NOT
;SKIP THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO.  THE MOVE INSTRUCTION LOADS E
;WITH -1, A NON-ZERO NUMBER.

A1000:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
	SKIPE			;*SKIPE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT.  HENCE, IT SHOULD SKIP
;THE NEXT INSTRUCTION WHEN C(E) IS ZERO.  THE MOVE INSTRUCTION LOADS ALL
;ZEROS INTO E.

A1100:	MOVE	[0]		;PRESET E TO ALL ZEROS
	SKIPE			;*SKIPE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT.  HENCE, IT NEVER SKIPS.  IT ALWAYS
;CONTINUES ON TO THE NEXT INSTRUCTION.

A1200:	MOVE	[0]		;PRESET E TO ALL ZEROS
	SKIP			;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NOT NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH ALL ZEROS, A NON-NEGATIVE NUMBER.

A1300:	MOVE	[0]		;PRESET E T0 ZERO, A NON-NEGATIVE NUMBER
	SKIPL			;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH -1,
;A NEGATIVE NUMBER.

A1400:	MOVE	[-1]		;PRESET E TO -1, A NEGATIVE NUMBER
	SKIPL			;*SKIPL SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS GREATER THAN ZERO.  THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH A NON-ZERO POSITIVE NUMBER.

A1500:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A NON-ZERO POSITIVE NUMBER
	SKIPG			;*SKIPG SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NOT GREATER THAN ZERO.  THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH -1, A NUMBER NOT GREATER THAN ZERO.

A1600:	MOVE	[-1]		;PRESET E TO -1, A NEGATIVE NUMBER
	SKIPG			;*SKIPG SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPL IS DATA  DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS NON-NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH
;377777777777, A NON-NEGATIVE NUMBER.

A1700:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A NON-NEGATIVE NUMBER
	SKIPL			;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN C(E) IS ZERO.  THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS.

A2000:	MOVE	[0]		;PRESET E TO ALL ZEROS
	SKIPLE			;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NEGATIVE NUMBER.  THE MOVE INSTRUCTION IS USED TO LOAD
;E WITH 400000000000, A NEGATIVE NUMBER.

A2100:	MOVE	[XWD 400000,0]	;PRESET E TO 400000000000, A NEGATIVE NUMBER.
	SKIPLE			;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A POSITIVE NUMBER.  THE MOVE INSTRUCTION LOADS
;E WITH 377777777777, A POSITIVE NUMBER.

A2200:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A POSITIVE NUMBER
	SKIPLE			;*SKIPLE SHOULD NOT SKIP THE NEXT INSTRUCTION
	SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
	STOP

;*********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION ;WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD 777000000000, A NON-ZERO NUMBER INTO E.

A2300:	MOVE	[XWD 777000,0]	;PRESET E WITH 777000000000, A NON-ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD A NON-ZERO NUMBER, 377000000 INTO E.

A2400:	MOVE	[XWD 377,0]	;PRESET E TO 377000000, A NON ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH A NON-ZERO NUMBER, 177000.

A2500:	MOVE	[177000]	;PRESET E WITH 177000, A NON ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD 777, A NON-ZERO NUMBER INTO E.

A2600:	MOVE	[777]		;PRESET E WITH 777, A NON-ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH 600000, A NON-ZERO NUMBER.

A2700:	MOVE	[600000]	;PRESET E WITK 600000, A NON-ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
;LOAD E WITH 400000000, A NON-ZERO NUMBER.

A3000:	MOVE	[XWD 400,000]	;PRESET E WITH 400000000, A NON-ZERO NUMBER
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
SN=3100
	ZZ=0

A3100:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
	SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
	STOP

;**********
>
SUBTTL	TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS

;THIS TEST VERIFIES THAT MOVEI LOADS E INTO THE AC.  SKIPG IS USED TO CHECK THAT
;THE AC WAS INDEED MODIFIED BY MOVEI.

A3200:	MOVEI	[-1]		;*MOVEI SHOULD LOAD A POSITIVE NUMBER INTO AC0
	SKIPG			;SKIP HALT INSTRUCTION IF MOVEI LOADED AC CORRECTLY
	STOP

;IF PROGRAM HANGS UP ON MOVEI INSTRUCTION, CHECK AD FM +EN [ADFP], AD FM + EN A [ADFP],
;AD FM + F/F [ADFP], F CYC ACT EN C [F1]

;**********

;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE DATA IN E AND NOT SENSITIVE TO
;THE DATA IN THE AC.  HENCE, SKIPL WILL SKIP THE NEXT INSTRUCTION ONLY IF
;C(E) IS LESS THAN ZERO.  E IS SET TO -1, A NEGATIVE NUMBER; AND
;THE AC IS SET TO 0 IN THIS TEST.  THEREFORE SKIPL SHOULD SKIP.

A3300:	MOVE	[0]		;SET THE AC TO ALL ZEROS
	SKIPL	[-1]		;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
	STOP

;**********

;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE SIGN BIT IN E.  SKIPL SHOULD
;SKIP THE NEXT INSTRUCTION WHEN AND ONLY WHEN THE SIGN BIT IS SET.  IN THIS
;TEST, C(AC) IS PRESET TO ALL ZEROS, THEN SKIPL IS EXECUTED WITH C(E)=400000,,0.
;A FAILURE UCCURS IF SKIPL DOES NOT SKIP.

A13100:	MOVE	[0]		;SET THE AC TO ALL ZEROS
	SKIPL	[400000,,0]	;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
	STOP

;**********
;THIS TEST VERIFIES THAT THE CAM INSTRUCTION DOES NOT MODIFY C(AC).  THE AC IS
;INITIALLY LOADED WITH ALL ZEROS; THEN CAM IS EXECUTED WITH C(E) NON-ZERO.
;THE AC IS THEN CHECKED FOR ALL ZEROS.  THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.

A3400:	MOVE	[0]		;PRESET THE AC TO ALL ZEROS
	CAM	[1234]		;*CAM SHOULD NOT MODIFY THE AC
	MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION SERVES AS A NO-OP.
				;IT IS A PROGRAM FILLER IN CASE CAM SKIPS.)
	SKIPE			;SKIP HALT INSTRUCTION IF AC WAS NOT MODIFIED BY CAM
	STOP

;IF TEST HANGS ON CAM INSTRUCTION, AB PC EN [ABC], AB PC (FETCH) EN [ABC],
;IR CAXX [IR3]

;IF TEST LOOPS ON CAM INSTRUCTION, MC INSTR FETCH EN [MC1], MC INST FET ET2 EN [MC1],
;ET2 J F/F [E], IR CAXX [IR3]

;IF TEST HALTS AT HALT INSTRUCTION, SAC INH [ST2], IR CAXX [IR3], IR CAMX [IR1]

;**********

;THIS TEST VERIFIES THAT THE CAI INSTRUCTION DOES NOT MODIFY C(AC).  THE AC IS
;INITIALLY LOADED WITH ALL ZEROS; THEN CAI IS EXECUTED WITH E NON-ZERO.  THE AC IS
;THEN CHECKED FOR ALL ZEROS.  THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.

A3500:	MOVE	[0]		;PRESET THE AC TO ALL ZEROS
	CAI	[1234]		;*CAI SHOULD NOT MODIFY THE AC
	MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A PROGRAM FILLER
				;IN CASE CAI MODIFIES THE AC.  IT SERVES AS A NO-OP)
	SKIPE			;SKIP HALT INSTRUCTION IF CAI DID NOT MODIFY THE AC
	STOP

;**********
;THIS TEST VERIFIES THAT CAI DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
;SPECIFIED BY THE CAI INSTRUCTION.
;THIS IS THE FIRST TEST THAT USES AN AC OTHER THAN AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAI INSTRUCTION IS EXECUTED WITH
;A NON-ZERO E.  AC 0 IS THEN TESTED F0R ALL ZEROS.

A3600:	MOVE	[0]		;LOAD AC0 WITH ALL ZEROS
	CAI	17,[1234]	;*CAI SHOULD NOT MODIFY AC0
	MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
				;CAI SKIPS THE NEXT INSTRUCTION.  IT ACTS AS A NO-OP)
	SKIPE			;SKIP HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
	STOP

;**********

;THIS TEST VERIFIES THAT CAM DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
;SPECIFIED BY THE CAM INSTRUCTION.
;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAM INSTRUCTION IS EXECUTED WITH
;A NON-ZERO E.  AC 0 IS THEN TESTED F0R ALL ZEROS.

A3700:	MOVE	[0]		;PRESET C(AC0) TO ALL ZEROS
	CAM	17,[1234]	;*CAM SHOULD NOT MODIFY AC0
	MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
				;CAM SKIPS THE NEXT INSTRUCTION.  IT SERVES AS A NO-OP)
	SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY CAM
	STOP

;**********
;THIS TEST VERIFIES THAT MOVE WILL PLACE C(E) INTO THE AC.  AC, E AND C(E) ARE NON-ZERO
;IN THIS TEST.  THIS TEST PASSES IF  FINAL C(AC) OF THE MOVE INSTRUCTION IS NON-ZERO.

A4500:	MOVE	1,[0]		;LOAD THE AC WITH ALL ZEROS
	MOVE	1,[-1]		;*MOVE SHOULD PLACE ALL ONES IN THE AC
	SKIPN	1		;SKIP HALT INSTRUCTION IF MOVE MODIFIED THE AC
	STOP

;**********

;THIS TEST VERIFIES THAT THE MOVE INSTRUCTION WILL PLACE C(E) INTO THE AC.
;AC, E ARE NON-ZERO AND C(E)=0.
;THIS TEST FAILS IF THE FINAL C(AC) IS NOT EQUAL TO ZERO, THE ORIGINAL C(E)

A4600:	MOVE	1,[0]		;*PLACE ALL ZEROS INTO THE AC
	SKIPE	1		;SKIP HALT INSTRUCTION IF MOVE PLACED ALL ZEROS INTO AC
	STOP

;IF JUMP .+1 OF PREVIOUS TEST FAILED, CHECK JUMPS: AD FM + EN [ADFP], IR JUMPS [IR1],
;IR JUMPX [IR1], AR AD EN [ARMA], AR AD EN A [ARMA], AR LT AD EN A [ARMA],
;AR LT ADD EN B [ARMA], AR RT AD EN A [ARMA],
;AR RT AD EN B [ARMA], AR A CLK INPUT [ARMA],
;ET2 C F/F [E], AR AD ET2 EN [ARMA], AR AD BR (ET2) B [ARMA]

;**********
;THIS TEST VERIFIES THAT SOS DOES NOT MODIFY C(AC) WHEN THE AC IS AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS AND E IS LOADED WITH A POSITIVE NUMBER;
;THEN, SOS IS EXECUTED.  SOS SHOULD SUBTRACT ONE FROM C((E)
;AND EXECUTE THE NEXT INSTRUCTION.  IT SHOULD NOT MODIFY AC0.
;THE TEST PASSES IF AC0 WAS NOT MODIFIED.

A4000:	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
	MOVE	7,[1234]	;PRESET E WITH A POSITIVE NUMBER
	SOS	7		;*SOS SHOULD NOT MODIFY C(AC0)
	MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
				;SOS SKIPS THE NEXT INSTRUCTION.  IT SERVES AS A NO-OP)
	SKIPE			;SKIP THE HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
	STOP

;**********
SN=4100
	AC=0

A4100:	REPEAT	4,
<;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.

SN=SN+1
	AC=AC+AC
	IFE	AC,<AC=1>
	MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
	MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
	SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
	SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
	STOP
	SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
	STOP

;**********
>
SUBTTL	TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS

;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL NOT MODIFY THE CONTENTS OF AC0.
;FIRST, AC0 IS LOADED WITH ALL ZEROS;  THEN,
;THE SKIP INSTRUCTION IS EXECUTED WITH C(E)=-1 AND AC0.  AC0 IS THEN TESTED FOR ALL
;ZEROS.  THE TEST FAILS IF AC0 WAS MODIFIED BY THE SKIP INSTRUCTION.

A4200:	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
	SKIP	[-1]		;*SKIP SHOULD NOT MODIFY AC0
	SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY SKIP
	STOP

;AC=0: SAC INH, IR BIT 9, 10, 11 OR 12 S-A-1

;**********

;THIS TEST VERIFIES THAT MOVSS DOES NOT MODIFY C(AC0) WHEN AC0 IS SPECIFIED AS THE AC.
;FIRST, E IS LOADED WITH ALL ONES AND THE AC (AC0)
;IS LOADED WITH ALL ZEROS; THEN, MOVSS IS EXECUTED.  MOVSS SHOULD NOT MODIFY AC0.
;AC0 IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED BY MOVSS.

A4300:	MOVE	7,[-1]		;LOAD E OF THE MOVSS INSTRUCTION WITH ALL ONES
	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
	MOVSS	7		;*MOVSS SHOULD NOT MODIFY AC0
	SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS INTACT
	STOP

;MOVX & AC=0: SAC INH [ST2], IR XXXS [IR1]

;**********
;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY C(AC0) WHEN AC0 IS THE SPECIFIED AC.
;FIRST, E IS LOADED WITH ALL ONES AND AC0 IS LOADED WITH ALL ZEROS;
;THEN, HRRS IS EXECUTED WITH AC=AC0.  AC0 IS THEN CHECKED FOR ALL ZEROS.
;IF AC0 WAS MODIFIED BY THE HRRS INSTRUCTION, THE TEST FAIL.

A4400:	MOVE	7,[-1]		;PRESET E OF THE HRRS INSTRUCTION TO ALL ONES
	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
	HRRS	7		;*HRRS SHOULD NOT MODIFY THE AC WHEN THE AC IS AC0
	SKIPE			;SKIP THE HALT INSTRUCTION IF AC0 WAS INTACT
	STOP

;(HXXXS&AC=0): SAC INH [ST2], IR HWTFWT [IR3], IR XXXS [IR1], IR HWT [IR1],
;IR BITS S-A-1

;**********
;THIS TEST VERIFIES THAT THE JUMP INSTRUCTION DOES NOT MODIFY C(AC).
;THE AC IS FIRST LOADED WITH ALL ZEROS;
;THEN JUMP .+1 IS EXECUTED.  THE AC IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED
;BY JUMP.  THE TEST FAILS IF THE AC WAS MODIFIED

A4700:	MOVE	[0]		; PRESET THE AC TO ALL ZEROS
	JUMP	.+1		;*JUMP SHOULD NOT MODIFY THE AC
	SKIPE			;SKIP HALT INSTRUCTION IF AC WAS INTACT
	STOP

;**********

;THIS TEST VERIFIES THAT MOVS WILL NOT PICK UP ANY ONES WHEN SWAPPING A WORD
;OF ALL ZEROS.  FIRST, E IS LOADED WITH A WORD OF ALL ZEROS;
;THEN, MOVS IS EXECUTED.  THE AC IS THEN CHECKED TO INSURE THAT THE RESULT DOES NOT
;CONTAIN ANY ONES.

A5000:	MOVE	[0]		;PRESET E WITH ALL ZEROS
	MOVS			;*MOVS SHOULD RESULT WITH AN AC 0F ALL ZEROS
	SKIPE			;SKIP HALT INSTRUCTION IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
;RESULTS IN A NON-ZERO NUMBER IN THE AC.  FIRST A NON-ZERO WORD
;IS LOADED INTO E; THEN, MOVS IS EXECUTED.  THE AC IS CHECKED FOR A NON-ZERO RESULT.
;IF C(AC)=0, THE TEST FAILS.

A5100:	MOVE	[XWD 0,-1]	;LOAD E WITH A NON-ZERO VALUE
	MOVS			;*MOVS SHOULD RESULT IN C(AC) NON-ZERO
	SKIPN			;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
	STOP

;**********
;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
;RESULTS IN A NON-ZERO NUMBER IN THE AC.  FIRST A NON-ZERO WORD
;IS LOADED INTO E; THEN, MOVS IS EXECUTED.  THE AC IS CHECKED FOR A NON-ZERO
;RESULT.  IF C(AC)=0, THE TEST FAILS.

A5200:	MOVE	[XWD -1,0]	;LOAD E OF MOVS WITH A NON-ZERO NUMBER
	MOVS			;*MOVS SHOULD RESULT WITH C(AC) NON-ZERO
	SKIPN			;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 188 OF E
;AND STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-0.  FIRST, A WORD
;WITH BIT 0 SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E.  THEN, MOVS
;IS EXECUTED.  THE AC IS THEN CHECKED FOR A 0 IN BIT 0, WHICH IS THE
;CORRECT RESULT.

A5300:	MOVE	[XWD -1,0]	;LOAD E OF MOVS WITH 777777000000
	MOVS			;*MOVS SHOULD RESULT WITH AC BIT 0 EQUAL TO 0
	SKIPG			;SKIP HALT INSTRUCTION IF BIT 0 OF AC IS 0
	STOP

;MOVSX: AR SWAP [ARMB], AR LT AR RT A [ARMB], AR LT AR RT B [ARMB],
;AR RT AR LT A [ARMB], AR RT AR LT B [ARMB], ET2 A F/F [E], IR MOVSX [IR1],
;IR MOV(E,S)X [IR1]

;**********

;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 18 OF E AND
;STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-1.  FIRST, A WORD WITH BIT 0
;SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E.  THEN, MOVS IS EXECUTED.
;THE AC IS CHECKED FOR A ZERO IN BIT ZERO, WHICH IS THE CORRECT RESULT.

A5400:	MOVE	[XWD 0,-1]	;LOAD E OF MOVS WITH 777777
	MOVS			;*MOVS SHOULD RESULT WITH BIT 0 OF THE AC SET
	SKIPL			;PASS IF AC BIT 0 IS SET
	STOP

;**********
SN=5500
	ZZ=0

A5500:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[0]		;CLEAR AC
	MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
	SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
	STOP

;**********
>
SN=5600

A5600:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
;HALF OF THE AC IS TESTED WITH A 1.

SN=SN+1
	ZZ=ZZ+ZZ
	MOVE	[0]		;CLEAR AC
	MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
	SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
	STOP

;**********
>
SUBTTL	TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)

;THIS TEST VERIFIES THAT SETM LOADS AC FROM E.  THE AC IS FIRST SET
;TO ZERO; THEN, SETM IS EXECUTED WITH ALL ONES IN E.  BIT 0 OF THE AC
;IS THEN CHECKED FOR A 1.

A5700:	MOVE	[0]		;PRELOAD AC WITH ALL ZEROS
	SETM	[-1]		;*SETM SHOULD LOAD AC WITH ALL ONES
	SKIPL			;PASS TEST IF AC BIT 0 IS A ONE
	STOP
;FCE [F1], IR BOOLE [IR1], IRXX(0,5,12,17) [IR2]

;**********

;THIS TEST VERIFIES THAT SETM LOADS AC FROM E.  THE AC IS FIRST SET TO
;ALL ONES; THEN, SETM IS EXECUTED WITH ALL ZEROS IN E.  THE AC IS CHECKED
;FOR ALL ZEROS

A6000:	MOVE	[-1]		;PRESET AC TO ALL ONES
	SETM	[0]		;*SETM SHOULD LOAD AC WITH ALL ONES
	SKIPE			;PASSES TEST IF C(AC) = 0
	STOP

;AD AR + EN [ADAP], AD AR + EN C[ADAP],
;F CYC ACT EN A[F1], IR BOOLE AD A +F[IR2],
;IR BOOLE [IR1], IRXX(1-3,6,11,15,16) [IR2]

;**********

;THIS TEST VERIFIES THAT SETZ LOADS TH AC WITH ALL ZEROS.  FIRST, A WORD
;OF ALL ZEROS IS LOADED INTO THE AC VIA A MOVE INSTC. THEN, SETZ IS
;EXECUTED.  THE AC IS CHECKED FOR ALL ZEROS.
;IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.

A6100:	MOVE	[0]		;RESET AC TO ALL ZEROS
	SETZ			;*SETZ SHOULD CLEAR THE AC
	SKIPE			;PASS TEST IF C(AC) = 0
	STOP

;AD MASK GEN EN [ADC1], AD MASK GEN F/F'S [ADC1]
;AD MASK EN B; F CYC ACT EN B[F1]; IRXX00 [IR1];
;IR BOOLE [IR1]

;**********
;THIS TEST VERIFIES THAT SETZ LOADS THE AC WITH ALL ZEROS.  FIRST,
;THE AC IS SET TO ALL ONES; THEN, SETZ IS EXECUTED.  THE AC IS THEN
;CHECKED FOR ALL ZEROS.  IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.

A6200:	MOVE	[-1]		;PRESET AC TO ALL ONES
	SETZ	.		;*SETZ SHOULD CLEAR THE AC
	SKIPE			;PASS TEST IF C(AC) = 0
	STOP

;AR AD EN [ARMA], AR AD ET2 EN [ARMA], IR BOOLE [IR]

;**********

;THIS TEST VERIFIES THAT THE AND INSTRUCTION OPERATING ON AN AC
;CONTAINING ALL ZEROS AND AN E CONTAINING ALL ZEROS RESULTS IN AN AC
;OF ALL ZEROS.  THE AC AND E ARE THE SAME IN THIS TEST.
;AC, E ARE LOADED WITH ZEROS; THEN, AND IS EXECUTED.  THE AC IS THEN
;CHECKED FOR ALL ZEROS.  IF ANY BITS IN THE AC ARE SET BY THE AND INSTRUCTION,
;THE TEST FAILS.


A6300:	MOVE	[0]		;PRESET AC, E TO ALL ZEROS
	AND			;*AND SHOULD RESULT IN C(AC) = 0
	SKIPE			;PASS TEST IF C(AC) = 0
	STOP

;**********
SN=6400
	ZZ=0

A6400:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.

SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	SETZ			;PRESET E TO ALL ZEROS
	MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
				;WHERE X VARIES FROM 0 THRU 35
	AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
	SKIPE	1		;FAIL IF C(AC) NON-ZERO
	STOP
	SKIPE	0		;FAIL IF C(0) IS NON-ZERO
	STOP
;**********
>
SN=6500
	ZZ=0

A6500:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
	AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
				;POSITION WITH ITSELF SHOULD RESULT WITH
				;C(AC) NONZERO
	SKIPN			;PASS TEST IF C(AC) NONZERO
	STOP

;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE
;C(AC)=0 AND C(E)=0 AND E OUTSIDE OF THE AC RANGE IS ALL ZEROS IN THE AC.
;FIRST, THE AC IS CLEARED; THEN, THE C(AC) IS ANDED WITH C(E) WHEN
;E GREATER THAN 20 AND C(E)=0. THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.

A6600:	MOVE	[0]		;PRESET AC TO ALL ZEROS
	AND	[0]		;*AND OF TWO WORDS OF ALL ZEROS
				;SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(AC)=0
;AND C(E) IS ALL ONES IS AN AC CONTAINING ALL ZEROS.  FIRST, THE AC IS
;CLEARED; THEN THE C(AC) IS ANDED WITH AN E CONTAINING ALL ONES, WHERE
;E IS BEYOND THE AC RANGE.  THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.

A6700:	MOVE	[0]		;PRESET AC TO ALL ZEROS
	AND	[-1]		;*AND OF TWO WORDS WHERE C(AC)=0 SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;AD FM+EN [ADFP],AD FM+EN A [ADFP],
;F CYC ACT EN C [F1],IR BOOLE AD FM+F [IR2],
;IR BOOLE [IR1],IRXX(1,4,5,11,13,16) [IR2]

;**********
;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E)=0
;AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE
;AC IS SET TO ALL ONES; THEN, THE AC IS ANDED WITH AN E CONTAINING ALL
;ZEROS, WHERE E IS BEYOND THE AC RANGE.  THE RESULT SHOULD BE C(AC)=0.
;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.

A7000:	MOVE	[-1]		;PRESET AC TO ALL ONES
	AND	[0]		;*AND OF TWO WORDS WHERE C(E)=0 SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E) IS
;ALL ONES AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ONES.  FIRST, THE
;AC IS SET TO ALL ONES; THEN, C(AC) IS ANDED WITH AN E CONTAINING ALL
;ONES.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
;IF C(AC) IS ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.

A7100:	MOVE	[-1]		;PRELOAD AC WITH ALL ONES
	AND	[-1]		;*AND OF TWO WORDS OF ALL ONES SHOULD
				;RESULT IN C(AC)=ALL ONES
	SKIPN			;PASS TEST IF C(AC) IS NON ZERO
	STOP

;**********

;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHERE CONTENTS IS NON-ZERO.
;FIRST, THE AC IS CLEARED, THEN, XOR IS EXECUTED WHERE C(E) IS NON-ZERO.
;THE AC IS THEN CHECKED FOR NON-ZERO CONTENTS.
A7200:	MOVE	[0]		;CLEAR AC
	XOR	[707070707070]	;*XOR WITH C(AC)=0 AND C(E)=7070707070 SHOULD
				;RESTULT IN C(AC)=707070707070
	SKIPN			;PASS TEST IF C(AC) NON-ZERO
	STOP

;**********
SN=7300
	ZZ=0

A7300:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[0]		;CLEAR AC
	XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
				;RESULT IN C(AC) NONZERO
	SKIPN			;PASS TEST IF C(AC) NON-ZERO
	STOP

;**********
>
SN=7400
	ZZ=0

A7400:	REPEAT	^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
	XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
				;RESULT IN C(AC) NON-ZERO
	SKIPN			;PASS TEST IF C(AC) NON-ZERO
	STOP

;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]

;**********
>
SN=7500
	ZZ=0

A7500:	REPEAT ^D36,
<;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
;INDICATE AN ILLEGAL CARRY GENERATION.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
	XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION WHERE
;C(AC)=C(E)=0 IS AN AC CONTAINING ALL ZEROS; FIRST THE AC IS CLEARED; THEN
;XOR IS EXECUTED WITH C(E)=0.  THE RESULT IN THE AC IS CHECKED FOR ALL ZEROS

A7600:	MOVE	[0]		;INITIALIZE AC TO ALL ZEROS
	XOR	[0]		;*XOR WITH C(AC)=C(E)=0 SHOULD RESULT INC(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) ALL ONES IS AN AC CONTAINING ALL ZEROS SINCE
;THE EQUIVALENCE FUNCTION SHOULD SET ONLY LIKE BITS.  FIRST, THE AC
;SHOULD BE CLEARED; THEN, EQV IS EXECUTED WITH E CONTAINING ALL ONES.
;THE AC IS THEN CHECKED FOR ALL ZEROS

A7700:	MOVE	[0]		;CLEAR THE AC
	EQV	[-1]		;*EQV WITH C(AC)=0 AND C(E) ALL ONES SHOULD
				;RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
SN=10000
	ZZ=0

A10000:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE
;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
SN=SN+1
	ZZ=ZZ+ZZ+1
	IFE	<ZZ-1>,<ZZ=-2>
	MOVE	[0]		;PRESET AC TO ALL ZEROS
	EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
				;RESULT IN C(AC) NON-ZERO
	SKIPN			;PASS TEST IF C(AC) NON-ZERO
	STOP

;**********
>
SN=10100
	ZZ=0

A10100:	REPEAT	^D18,
<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE
;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
SN=SN+1
	ZZ=ZZ+ZZ+1
	IFE	<ZZ-1>,<ZZ=-2>
	MOVE	[0]		;PRESET AC TO ALL ZEROS
	EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
				;RESULT IN C(AC) NON-ZERO
	SKIPN			;PASS TEST IF C(AC) NON-ZERO
	STOP

;**********
>
;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ZEROS
;EQUIVALENCED WITH AN E CONTAINING ALL ZEROS IS AN AC CONTAINING ALL
;ONES; AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES IS EQUIVALANCED
;WITH AN E CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC
;SHOULD BE ALL ZEROS.  FIRST, THE AC IS INITIALIZED TO ALL ZEROS, THEN,
;THIS AC IS EQUIVALENCED TWICE WITH AN E CONTAINING ALL ZEROS.  THE AC IS
;THEN CHECKED FOR ALL ZEROS

A10200:	MOVE	[0]		;CLEAR THE AC
	EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=ALL ONES
	EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********

;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ONES
;EQUIVALENCED WITH AN E CONTAINING ALL ONES IS AN AC CONTAINING ALL ONES;
;AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES ISEQUIVALENCED WITH AN E
;CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC SHOULD BE ALL ZEROS.
;FIRST, THE AC IS INITIALIZED TO ALL ONES; THEN, THIS AC IS
;EQUIVALENCED WITH AN E OF ALL ONES.  NEXT, THIS SAME AC IS EQUIVALENCED
;WITH AN E OF ALL ZEROS.  THE AC IS THEN CHECKED FOR ALL ZEROS.

A10300:	MOVE	[-1]		;SET C(AC) TO ALL ONES
	EQV	[-1]		;*EQV SHOULD RESULT IN C(AC) OF ALL ONES
	EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
SN=13000
	ZZ=0

A13000:	REPEAT	^D36,
<;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
SN=SN+1
	ZZ=ZZ+ZZ
	IFE	ZZ,<ZZ=1>
	MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
	AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
	EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
	EQV	[0]		;RESULTS IN C(AC)=0
	SKIPE			;PASS TEST IF C(AC)=0
	STOP

;**********
>
ENDXX:	JRST	BEGEND		;LOOP PROGRAM

```

DAKAA.SEQ
---------

To view the contents of **DAKAA.SEQ** (a combination of [DAKAA.TXT](#dakaatxt), a MACRO-10 assembly listing, and run data),
click [here](DAKAA.SEQ.txt).