Google
 

Trailing-Edge - PDP-10 Archives - klad_sources - klad.sources/dfkaa.seq
There are no other files named dfkaa.seq in the archive.
MAINDEC-10-DFKAA.TXT
                                                                                                                           SEQ 0001





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


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

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

	FUNCTION:	BASIC INSTRUCTIONS

	VERSION:	0.2

	DATE RELEASED:	JANUARY 31,1977

	MAINTAINED BY:	DIAGNOSTIC ENGINEERING GROUP

	AUTHOR:		JOHN R. KIRCHOFF

COPYRIGHT(C) 1975,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-DFKAA.TXT
							PAGE 2                                                             SEQ 0002


			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-DFKAA.TXT
							PAGE 3                                                             SEQ 0003


1.0	ABSTRACT

	THIS PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC IS THE FIRST IN A
	SERIES OF PDP-10 KL10 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 THE BASIC FUNCTIONALITY OF THE PROCESSOR
	AND MICRO-CODE.

2.0	REQUIREMENTS

2.1	EQUIPMENT

	EITHER OF:
	A PDP-10 KL10 WITH A MINIMUM OF 32K OF MEMORY

	CONSOLE PROCESSOR
	CONSOLE TELETYPE

2.2	STORAGE

	THE PROGRAM RUNS WITHIN 32K OF MEMORY.

2.3	PRELIMINARY PROGRAMS

	CONSOLE FUNCTIONS WORKING PROPERLY
							MAINDEC-10-DFKAA.TXT
							PAGE 4                                                             SEQ 0004


3.0	PROGRAM PROCEDURES

3.1	LOADING PROCEDURE

	LOAD VIA CONSOLE PROCESSOR

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 PRINTED BY THE CONSOLE
	PROCESSOR.

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-DFKAA.TXT
							PAGE 5                                                             SEQ 0005


7.0	OPERATIONAL VARIATIONS

	A.  DIAGNOSTIC MONITOR

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

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

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

	B.  USER MODE

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

	C.  SYSTEM EXERCISER

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

8.0	MISCELLANEOUS

	NONE

9.0	LISTING
	THIS IS A HISTORY OF THE DEVELOPMENT OF MAINDEC-10-DFKAA
                                                                                                                           SEQ 0006
************************************************************************

PRODUCT CODE:		MAINDEC-10-DFKAA

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

DATE RELEASED:		JANUARY 31,1977

VERSION:		0.2

UPDATE AUTHOR:		JOHN R. KIRCHOFF

CHANGES MADE:

	1. UPGRADE MADE TO ALLOW PROGRAM TO RUN WITH ANY FRONT-END
	   THAT PERFORMED THE PROGRAM LOAD.

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

DATE RELEASED:		AUGUST 25,1975

VERSION:		0.1

INITIAL AUTHOR:		JOHN R. KIRCHOFF

	INTIAL RELEASE OF THIS PROGRAM FOR THE KL10 PROCESSOR.

************************************************************************
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
DFKAAT	MAC	31-JAN-77 09:14		DIAGNOSTIC PARAMETERS                                                              SEQ 0007

     1					;DFKAA
     2
     3
     4			000000		MCNVER==0
     5			000002		DECVER==2
     6
     7
     8						XLIST
     9						LIST
    10						LALL
    11
    12						NAME	\MCNVER,\DECVER^
    13
    14					TITLE	DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2
    15					^
    16
    17					;TEST DESIGNED FOR INITIAL DEBUGGING OF PROCESSOR HARDWARE
    18					;AND TO DETECT (SOLID) FAILURES IN THE FIELD.
    19
    20					;COPYRIGHT 1975,1977
    21					;DIGITAL EQUIPMENT CORPORATION
    22					;MARLBORO, MASS. 01752
    23
    24					;JOHN R. KIRCHOFF
    25
    26	000137					LOC	137
    27	000137	000000	000002			MCNVER,,DECVER
    28
    29						NOSYM
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
DFKAAT	MAC	31-JAN-77 09:14		DIAGNOSTIC PARAMETERS                                                              SEQ 0008

    30					SUBTTL	DIAGNOSTIC PARAMETERS
    31
    32					;PARAMETER DEFINITIONS
    33
    34			000001		EXCASB==1
    35			000001		USRASB==1
    36			000001		KI10==1
    37			000001		KL10==1
    38			000001		KL10P0==1
    39			000001		PGMEND==1
    40			030000		MODDVL==BEGIN
    41			030000		MODDVU==BEGIN
    42
    43					;FLAG DEFINITIONS
    44
    45			010000		USERF=10000		;USER MODE FLAG
    46
    47
    48					;MACROS
    49
    50					; STOP - USED FOR SCOPE LOOP, IF INSTRUCTION FAILS, CHANGE (JUMPA .+1)
    51					;	 TO A (JUMPA .-X) TO CYCLE ON FAILING INSTRUCTION
    52
    53					DEFINE	STOP	(A)<
    54						HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
    55						JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
    56									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
    57									;IN THE SUBTEST) TO LOOP ON ERROR>
    58
    59					; SFLAG - USED TO CLEAR ALL FLAGS THEN TO SET SELECTED FLAG
    60
    61					DEFINE	SFLAG	(A)<
    62						MOVSI	1,A
    63						JFCL	17,.+1	;RESET ALL FLAGS
    64						JRST	2,.+1(1)		;SET A FLAG>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
DFKAAT	MAC	31-JAN-77 09:14		DIAGNOSTIC PARAMETERS                                                              SEQ 0009

    65					;SPECIAL FEATURE PARAMETERS
    66
    67			030742		SADR1=STARTA
    68			030742		SADR2=STARTA
    69			030742		SADR3=STARTA
    70			030742		SADR4=STARTA
    71		254000	030742		SADR5=JRST STARTA
    72		254000	030742		SADR6=JRST STARTA
    73		254000	030742		SADR7=JRST STARTA
    74		254000	030742		SADR8=JRST STARTA
    75		254000	030742		SADR9=JRST STARTA
    76		254000	030742		SADR10=JRST STARTA
    77		254000	030742		SADR11=JRST STARTA
    78
    79			000000		PAREA0=0
    80			000000		PAREA1=0
    81			000000		PAREA2=0
    82		444653	414100		PAREA3=SIXBIT/DFKAA/
    83		645560	000000		PAREA4=SIXBIT/TMP/
    84			000000		PAREA5=0
    85			000000		PAREA6=0
    86			001000		ITERAT==1000
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
PARAM	KLM	18-JAN-77 11:38		*PARAM*	CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977                               SEQ 0010

    87					SUBTTL	*PARAM*	CONSOLE DATA SWITCH ASSIGNMENTS, JAN 18,1977
    88
    89					DEFINE	S,<;*********************************************************************>
    90
    91					S^;*********************************************************************^
    92					;*DATA SWITCHES (READ FROM CONSOLE IN EXEC MODE OR TYPED IN IN USER MODE)
    93					;*LEFT HALF SWITCHES ARE PRE-ASSIGNED FOR SUBROUTINE PACKAGE USE
    94					;*AND CONTROL LOOPING, PRINTING (TTY OR OTHER DEVICE) AND MISC. FUNCTIONS
    95					S^;*********************************************************************^
    96
    97			400000		ABORT==	400000			;ABORT PROGRAM ON PASS COMPLETION
    98			200000		RSTART==200000			;RESTART TEST, PRINT TOTALS
    99			100000		TOTALS==100000			;PRINT TOTALS, CONTINUE
   100
   101			040000		NOPNT==	040000			;INHIBIT ALL PRINT/TYPE OUT (EXCEPT FORCED)
   102			020000		PNTLPT==020000			;PRINT ALL DATA ON LPT (LOGICAL DEVICE, USER MODE)
   103			010000		DING==	010000			;RING BELL ON ERROR
   104
   105			004000		LOOPER==004000			;ENTER EXERCISE/CHECK LOOP ON ERROR
   106			002000		ERSTOP==002000			;HALT ON TEST ERROR
   107			001000		PALERS==001000			;PRINT ALL ERRORS
   108
   109			000400		RELIAB==000400			;RELIABILITY MODE
   110			000200		TXTINH==000200			;INHIBIT ERROR TEXT
   111			000100		INHPAG==000100			;INHIBIT PAGING
   112
   113			000040		MODDVC==000040			;MODIFY DEVICE CODE
   114			000020		INHCSH==000020			;INHIBIT CACHE
   115			000010		OPRSEL==000010			;OPERATOR SELECTION
   116
   117			000004		CHAIN==	000004			;CHAIN CONTROL SWITCH
   118
   119			000002		KAHZ50==000002			;KA10 50 HERTZ POWER
   120
   121									;SWITCH 17 RESERVED !!!
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
PARAM	KLM	18-JAN-77 11:38		*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977                                 SEQ 0011

   122					SUBTTL	*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977
   123
   124					S^;*********************************************************************^
   125					;*SPECIAL SUBPROGRAM LINKAGES
   126					S^;*********************************************************************^
   127
   128			027772		FSELNK=	27772	;FILE SELECT LINK
   129			027773		FRDLNK=	27773	;FILE READ LINK
   130			027774		LDLNK=	27774	;LOAD LINKAGE ADDRESS
   131			027775		DDTLNK=	27775	;DDT LINKAGE ADDRESS
   132			027776		MODLNK=	27776	;OPERATIONAL MODE CHECK LINKAGE ADDRESS
   133			027777		SUBLNK=	27777	;SUBROUTINE LINKAGE ADDRESS
   134
   135					S^;*********************************************************************^
   136					;*SPECIAL SUBROUTINE FATAL HALTS
   137					;*USED TO REPORT ERRORS THAT CAUSE THE SUBROUTINES TO BE UNUSABLE
   138					S^;*********************************************************************^
   139
   140					;ADDRESS   TAG	REASON
   141					;---------------------
   142
   143					; 1010 	NOEXEC	;PROGRAM NOT CODED FOR EXEC MODE OPERATION
   144					; 1011  PLERR	;FATAL PUSH LIST POINTER ERROR
   145					; 1012  PLERR1	;INITIAL PUSH LIST POINTER ERROR
   146					; 1013  MUOERR	;MUUO WITH LUUO HANDLER WIPED OUT
   147					; 1014  DTEBER	;DTE20 INTERRUPT WITHOUT DOORBELL
   148					; 1015  DTECER	;DTE20 CLOCK INTERRUPT WITHOUT FLAG SET
   149					; 1016  CPIERR	;CPU INITIALIZATION ERROR
   150					; 1017  EOPERR	;END OF PROGRAM ERROR
   151					; 1020  LUOERR	;INTERRUPT WITH LUUO HANDLER WIPED OUT
   152
   153					S^;*********************************************************************^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
PARAM	KLM	18-JAN-77 11:38		*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977                                 SEQ 0012

   154					S^;*********************************************************************^
   155					;OPERATOR DEFINITIONS (NON-UUO'S)
   156					S^;*********************************************************************^
   157
   158		260740	000000		OPDEF	GO	[PUSHJ	P,]	;SUBROUTINE CALL
   159		263740	000000		OPDEF	RTN	[POPJ	P,]	;SUBROUTINE RETURN 
   160		261740	000000		OPDEF	PUT	[PUSH	P,]	;PUT DATA ON PUSH LIST
   161		262740	000000		OPDEF	GET	[POP	P,]	;GET DATA FROM PUSH LIST 
   162		254000	000000		OPDEF	PJRST	[JRST	]	;JRST TO ROUTINE THAT RTN'S
   163		254200	000000		OPDEF	HALT	[JRST	4,]	;DEFINITION FOR DDT
   164		254100	000000		OPDEF	JRSTF	[JRST	2,]	;DEFINITION FOR DDT
   165		254500	000000		OPDEF	JEN	[JRST	12,]	;DEFINITION FOR DDT
   166
   167					S^;*********************************************************************^
   168					;*SUBROUTINE INITIALIZATION CALL
   169					S^;*********************************************************************^
   170
   171		265000	030011		OPDEF	PGMINT	[JSP	0,SBINIT]	;SUBROUTINE INITIALIZATION
   172
   173					S^;*********************************************************************^
   174					;*HALTING UUO'S (A MORE GRACEFUL HALT THAN SIMPLY USING THE HALT INSTRUCTION).
   175					S^;*********************************************************************^
   176
   177		037640	000004		OPDEF	FATAL	[37B8!15B12!4]	;FATAL PROGRAMMING HALT
   178		037600	000004		OPDEF	ERRHLT	[37B8!14B12!4]	;PROGRAM ERROR HALT
   179
   180					S^;*********************************************************************^
   181					;*TERMINAL INPUT UUO'S
   182					;*ALWAYS COME FROM THE CONSOLE TERMINAL IN EXEC MODE OR THE
   183					;*CONTROLLING TERMINAL (REAL TERMINAL OR PTY) IN USER MODE.
   184					S^;*********************************************************************^
   185
   186		037000	000003		OPDEF	TTICHR 	[37B8!0B12!3]	;TTY, INPUT ANY CHARACTER
   187		037040	000003		OPDEF	TTIYES	[37B8!1B12!3]	;TTY, NORMAL RETURN Y
   188		037100	000003		OPDEF	TTINO	[37B8!2B12!3]	;TTY, NORMAL RETURN N
   189		037140	000003		OPDEF	TTIOCT	[37B8!3B12!3]	;TTY, INPUT OCTAL WORD
   190		037200	000003		OPDEF	TTIDEC	[37B8!4B12!3]	;TTY, INPUT DECIMAL WORD
   191		037240	000003		OPDEF	TTICNV	[37B8!5B12!3]	;TTY, INPUT CONVERTABLE WORD
   192		037300	000003		OPDEF	TTLOOK	[37B8!6B12!3]	;TTY, KEYBOARD CHECK
   193		037340	000003		OPDEF	TTALTM	[37B8!7B12!3]	;TTY, ALT-MODE CHECK
   194		037400	000003		OPDEF	TTSIXB	[37B8!10B12!3]	;TTY, INPUT SIXBIT WORD
   195		037440	000003		OPDEF	TTYINP	[37B8!11B12!3]	;TTY, IMAGE MODE INPUT
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4
PARAM	KLM	18-JAN-77 11:38		*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977                                 SEQ 0013

   196					;*TERMINAL OUTPUT UUO'S.
   197
   198		037000	000000		OPDEF	PNTA	[37B8!0B12!0]	;PRINT ASCII WORD
   199		037000	000001		OPDEF	PNTAF	[37B8!0B12!1]	;PRINT ASCII WORD FORCED
   200		037740	000000		OPDEF	PNTAL	[37B8!17B12!0]	;PRINT ASCIZ LINE
   201		037740	000001		OPDEF	PNTALF	[37B8!17B12!1]	;PRINT ASCIZ LINE FORCED
   202		037600	000003		OPDEF	PSIXL	[37B8!14B12!3]	;PRINT SIXBIT'Z LINE
   203		037640	000003		OPDEF	PSIXLF	[37B8!15B12!3]	;PRINT SIXBIT'Z LINE FORCED
   204		037000	000000		OPDEF	PNTMSG	[37B8!0B12!0]	;PRINT MESSAGE IMMEDIATE
   205		037040	000000		OPDEF	PNTMSF	[37B8!1B12!0]	;PRINT MESSAGE IMMEDIATE FORCED
   206		037100	000000		OPDEF	PSIXM	[37B8!2B12!0]	;PRINT SIXBIT'Z MSG IMMEDIATE
   207		037200	000000		OPDEF	PSIXMF	[37B8!4B12!0]	;PRINT SIXBIT'Z MSG IMM FORCED
   208		037000	000000		OPDEF	PNTCI	[37B8!0B12!0]	;PRINT CHARACTER IMMEDIATE
   209		037040	000000		OPDEF	PNTCIF	[37B8!1B12!0]	;PRINT CHARACTER IMMEDIATE FORCED
   210		037500	000000		OPDEF	PNTCHR	[37B8!12B12!0]	;PRINT CHARACTER
   211		037500	000001		OPDEF	PNTCHF	[37B8!12B12!1]	;PRINT CHARACTER FORCED
   212		037040	000000		OPDEF	PNT1	[37B8!1B12!0]	;PRINT ONE OCTAL DIGIT
   213		037040	000001		OPDEF	PNT1F	[37B8!1B12!1]	;PRINT 1 OCTAL DIGIT FORCED	
   214		037100	000000		OPDEF	PNT2	[37B8!2B12!0]	;PRINT TWO OCTAL DIGITS
   215		037100	000001		OPDEF	PNT2F	[37B8!2B12!1]	;PRINT 2 OCTAL DIGITS FORCED	
   216		037140	000000		OPDEF	PNT3	[37B8!3B12!0]	;PRINT THREE OCTAL DIGITS
   217		037140	000001		OPDEF	PNT3F	[37B8!3B12!1]	;PRINT THREE OCTAL DIGITS FORCED	
   218		037200	000000		OPDEF	PNT4	[37B8!4B12!0]	;PRINT FOUR OCTAL DIGITS
   219		037200	000001		OPDEF	PNT4F	[37B8!4B12!1]	;PRINT FOUR OCTAL DIGITS FORCED
   220		037240	000000		OPDEF	PNT5	[37B8!5B12!0]	;PRINT FIVE OCTAL DIGITS
   221		037240	000001		OPDEF	PNT5F	[37B8!5B12!1]	;PRINT FIVE OCTAL DIGITS FORCED
   222		037300	000000		OPDEF	PNT6	[37B8!6B12!0]	;PRINT SIX OCTAL DIGITS
   223		037300	000001		OPDEF	PNT6F	[37B8!6B12!1]	;PRINT SIX OCTAL DIGITS FORCED
   224		037340	000000		OPDEF	PNT7	[37B8!7B12!0]	;PRINT 7 OCTAL DIGITS
   225		037340	000001		OPDEF	PNT7F	[37B8!7B12!1]	;PRINT 7 OCTAL DIGITS FORCED
   226		037440	000000		OPDEF	PNT11	[37B8!11B12!0]	;PRINT 11 OCTAL DIGITS
   227		037440	000001		OPDEF	PNT11F	[37B8!11B12!1]	;PRINT 11 OCTAL DIGITS FORCED.
   228		037400	000000		OPDEF	PNTADR	[37B8!10B12!0]	;PRINT PHYSICAL ADDRESS
   229		037400	000001		OPDEF	PNTADF	[37B8!10B12!1]	;PRINT PHYSICAL ADDRESS FORCED
   230		037600	000000		OPDEF	PNTOCT  [37B8!14B12!0]	;PRINT FULL WORD OCTAL
   231		037600	000001		OPDEF	PNTOTF	[37B8!14B12!1]	;PRINT FULL WORD OCTAL FORCED
   232		037540	000000		OPDEF	PNTHW	[37B8!13B12!0]	;PRINT OCTAL HALF WORDS, 6 SP 6
   233		037540	000001		OPDEF	PNTHWF	[37B8!13B12!1]	;PRINT OCTAL HALF WORDS, 6 SP 6 FORCED
   234		037700	000003		OPDEF	PNTOCS	[37B8!16B12!3]	;PRINT OCTAL, SUPPRESS LEADING 0'S
   235		037740	000003		OPDEF	PNTOCF	[37B8!17B12!3]	;PRINT OCTAL, SUPPRESS LEADING 0'S FORCED
   236		037640	000000		OPDEF	PNTDEC	[37B8!15B12!0]	;PRINT DECIMAL, SUPRESS LEADING 0'S
   237		037640	000001		OPDEF	PNTDCF	[37B8!15B12!1]	;PRINT DECIMAL, SUPRESS LEADING 0'S FORCED
   238		037700	000000		OPDEF	PNTDS	[37B8!16B12!0]	;PRINT DECIMAL, SPACES FOR LD 0'S
   239		037700	000001		OPDEF	PNTDSF	[37B8!16B12!1]	;PRINT DECIMAL, SPACES FOR LD 0'S FORCED
   240		037200	000002		OPDEF	PNTNM	[37B8!4B12!2]	;PRINT PROGRAM NAME
   241		037000	000002		OPDEF	PNTSIX	[37B8!0B12!2]	;PRINT SIXBIT WORD
   242		037040	000002		OPDEF	PNTSXF	[37B8!1B12!2]	;PRINT SIXBIT WORD FORCED
   243		037240	000002		OPDEF	DROPDV	[37B8!5B12!2]	;CLOSE LOGICAL FILE, USER MODE
   244		037100	000002		OPDEF	PNTCW	[37B8!2B12!2]	;PRINT DF10 CONTROL WORD
   245		037140	000002		OPDEF	PNTCWF	[37B8!3B12!2]	;PRINT DF10 CONTROL WORD FORCED
   246		037000	030242		OPDEF	PCRL	[37B8!0B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED
   247		037040	030242		OPDEF	PCRLF	[37B8!1B12!CRLF] ;PRINT CARRIAGE RETURN/LINE FEED FORCED
   248		037000	000040		OPDEF	PSP	[37B8!0B12!40]	;PRINT SPACE
   249		037040	000040		OPDEF	PSPF	[37B8!1B12!40]	;PRINT SPACE FORCED
   250		037000	030243		OPDEF	PCRL2	[37B8!0B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE)
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-1
PARAM	KLM	18-JAN-77 11:38		*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977                                 SEQ 0014

   251		037040	030243		OPDEF	PCRL2F	[37B8!1B12!CRLF2] ;PRINT CARRIAGE RETURN/LINE FEED (TWICE) FORCED
   252		037040	000007		OPDEF	PBELL	[37B8!1B12!7]	;PRINT TTY BELL
   253
   254		037040	000026		OPDEF	PFORCE	[37B8!1B12!26]	;PRINT FORCE, CONTROL O OVERRIDE
   255
   256					DEFINE	PMSG	(ARG),<
   257						PSIXM	[SIXBIT\ARG'_\]>
   258
   259					DEFINE	PMSGF	(ARG),<
   260						PSIXMF	[SIXBIT\ARG'_\]>
   261
   262					;*SIXBTZ -- MACRO TO GENERATE SIXBIT DATA FOR PRINTING
   263					;*	CONSERVES CORE OVER ASCIZ
   264
   265					DEFINE	SIXBTZ	(ARG),<	[SIXBIT\ARG'_\]>
   266
   267					;*CONSOLE SWITCH INPUT UUO.
   268					;*READS CONSOLE SWITCHES IF IN EXEC MODE OR ASKS FOR THEM IF
   269					;* USER MODE.
   270
   271		037400	000002		OPDEF	SWITCH	[37B8!10B12!2]	;INPUT CONSOLE SWITCHES
   272
   273					;*CLOCK INITIALIZATION UUO - TO SET DESIRED CLOCK OPERATION
   274					;*EITHER IGNORE CLOCK, ONLY LET IT TICK OR CAUSE INTERRUPT TO OCCUR.
   275
   276		037540	000004		OPDEF	CLOKOP	[37B8!13B12!4]	;CLOCK OPERATION UUO - PDP-11 CLOCK
   277		037200	000004		OPDEF	MTROP	[37B8!4B12!4]	;CLOCK OPERATION UUO - DK20 METER
   278
   279					;*KL10 ONLY CACHE OPERATION UUO'S
   280
   281		037040	000004		OPDEF	CINVAL	[37B8!1B12!4]	;CACHE INVALIDATE
   282		037100	000004		OPDEF	CFLUSH	[37B8!2B12!4]	;CACHE FLUSH
   283		037140	000004		OPDEF	CWRTBI	[37B8!3B12!4]	;CACHE WRITE-BACK & INVALIDATE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 5
PARAM	KLM	18-JAN-77 11:38		*PARAM* PROGRAM/SUBROUTINE PARAMETERS, JAN 18,1977                                 SEQ 0015

   284					;*END OF PASS/PROGRAM UUOS
   285
   286					;PERFORMS THE END OF PASS FUNCTIONS. INCREMENT PASS COUNT,
   287					;*DECREMENT ITERATION COUNT, CHECK IF FINISHED WITH THIS PROGRAM ETC.
   288
   289		037500	000004		OPDEF	ENDUUO	[37B8!12B12!4]	;UUO TO DISPLAY LIGHTS
   290		037700	000004		OPDEF	EOPUUO	[37B8!16B12!4]	;END OF PROGRAM UUO
   291
   292					;*MEMORY MANAGEMENT UUO'S
   293					;*UUO'S TO PERFORM VARIOUS MEMORY FUNCTIONS. MAPPING, ZEROING, PAGING,
   294					;*ADDRESS CONVERSION, ETC...
   295
   296		037000	000004		OPDEF	MAPMEM	[37B8!0B12!4]	;MAP MEMORY
   297		037500	000002		OPDEF	MEMZRO	[37B8!12B12!2]	;ZERO MEMORY
   298		037440	000002		OPDEF	MEMSEG	[37B8!11B12!2]	;SETUP MEMORY SEGMENT
   299		037540	000002		OPDEF	MAPADR	[37B8!13B12!2]	;VIRTUAL TO PHYSICAL ADR CONVERT
   300		037640	000002		OPDEF	MAPCNK	[37B8!15B12!2]	;MAP MEMORY CHUNK
   301		037600	000002		OPDEF	MAPSET	[37B8!14B12!2]	;SET KI10 EXEC PAGE MAP
   302		037740	000002		OPDEF	MAPPNT	[37B8!17B12!2]	;PRINT MEMORY MAP
   303
   304					;*DEVICE CODE MODIFICATION UUO
   305					;*ALLOWS THE MODIFICATION OF IOT'S TO ONE DEVICE TO BE CHANGED TO
   306					;*IOT'S TO A DIFFERENT DEVICE CODE.
   307
   308		037340	000002		OPDEF	MODPCU	[37B8!7B12!2]	;MODIFY PERHIPERAL CODE, USER
   309		037300	000002		OPDEF	MODPCP	[37B8!6B12!2]	;MODIFY PERHIPERAL CODE, PROGRAM
   310
   311						IFNDEF	MODDVL,<MODDVL==BEGIN>
   312						IFNDEF	MODDVU,<MODDVU==BEGIN>
   313
   314					;*"DIAMON" FILE SELECTION AND READ UUOS
   315
   316		037240	000004		OPDEF	FSELECT	[37B8!5B12!4]	;FILE SELECTION
   317		037300	000004		OPDEF	FREAD	[37B8!6B12!4]	;FILE READ - ASCII DATA
   318		037340	000004		OPDEF	FRD36	[37B8!7B12!4]	;FILE READ - 36 BIT DATA
   319		037400	000004		OPDEF	FRD8	[37B8!10B12!4]	;FILE READ - 8 BIT DATA
   320
   321					;*KI10 ONLY UUO FOR PRINTING MARGIN VALUES
   322
   323		037700	000002		OPDEF	PNTMGN	[37B8!16B12!2]	;PRINT MARGIN VALUE
   324
   325						XLIST
   326					IFNDEF	KLOLD,<LIST
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6
PARAM	KLM	18-JAN-77 11:38		ERROR HANDLING UUO DEFINITIONS, JAN 18,1977                                        SEQ 0016

   327					SUBTTL	ERROR HANDLING UUO DEFINITIONS, JAN 18,1977
   328
   329					S^;*********************************************************************^
   330					;*ERROR HANDLER PARAMETERS
   331					S^;*********************************************************************^
   332
   333		036000	000000		OPDEF	ERUUO	[36B8]		;ERROR CALL UUO
   334		035000	000000		OPDEF	ERLOOP	[35B8]		;ERROR LOOP, CHECKS PC,REPT,REPT1,ERROR
   335		035040	000000		OPDEF	ERLP1	[35B8!1B12]	;ERROR LOOP IF PC'S MATCH
   336		035100	000000		OPDEF	ERLP2	[35B8!2B12]	;ERROR LOOP IF ANY ERROR
   337		034000	000000		OPDEF	REPTUO	[34B8]		;REPEAT LOOP UUO
   338
   339					;*THE ERROR HANDLER MACROS
   340
   341					;*A MACRO TO REPORT AN ERROR AND LOOP
   342
   343						DEFINE	ERROR	(ADR,FORMAT,CORECT,ACTUAL,F,D,ERR)<
   344						SALL
   345						ERUUO	FORMAT,[T,,[SIXBIT\F'_\]
   346							   CORECT,,ACTUAL
   347							   [SIXBIT\D'_\],,ERR]
   348						XALL
   349					
   350						ERLOOP	ADR		;IF ERROR, LOOP TO ADR
   351					>
   352
   353					;*A MACRO TO REPORT AN ERROR AND NOT LOOP
   354
   355						DEFINE	ERROR1	(FORMAT,CORECT,ACTUAL,F,D,ERR)<
   356						SALL
   357						ERUUO	FORMAT,[T,,[SIXBIT\F'_\]
   358							   CORECT,,ACTUAL
   359							   [SIXBIT\D'_\],,ERR]
   360						XALL	>
   361
   362					>;END OF KLOLD CONDITIONAL
   363
   364						XLIST
   365						LIST
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0017

   366					SUBTTL	*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977
   367
   368	030000					LOC	30000
   369
   370					S^;*********************************************************************^
   371					;*PROGRAM STARTING ADDRESSES
   372					;*THESE ADDRESSES CALL VARIOUS SPECIAL START ROUTINES AND OR OPTIONS
   373					;*NORMAL START ADDRESS IS 30000 ALL OTHERS ARE SPECIAL. INVOKED BECAUSE
   374					;*OF END OF PASS, POWER FAILURE, DDT START, RE-ENTERING(TYPICALLY USER
   375					;*MODE), OR ANY NUMBER OF SPECIAL FEATURE TESTS.
   376					S^;*********************************************************************^
   377
   378	030000	254 00 1 00 027776 	BEGIN:	JRST	@MODLNK		;STAND-ALONE START
   379	030001	254 00 0 00 030712 	$START:	JRST	START		;MODE CHECK STARTING ADDRESS
   380
   381	030002	254 00 1 00 027774 	DIAGMN:	JRST	@LDLNK		;DIAGNOSTIC MONITOR START
   382
   383	030003	254 00 1 00 027774 	SYSEXR:	JRST	@LDLNK		;SYSTEM EXERCISER START
   384
   385	030004	254 00 0 00 030742 	SFSTRT:	JRST	SADR1		;SPECIAL FEATURE START
   386
   387	030005	254 00 0 00 030742 	PFSTRT:	JRST	SADR2		;POWER FAIL RESTART
   388
   389	030006	254 00 0 00 030742 	REENTR:	JRST	SADR3		;REENTER START(USUALLY USER MODE ONLY)
   390
   391	030007				SRTDDT:				;COMMONLY MISTAKEN NAME FOR "DDTSRT"
   392	030007	254 00 1 00 027775 	DDTSRT:	JRST	@DDTLNK		;DDT START
   393
   394	030010	254 00 0 00 030742 	BEGIN1:	JRST	STARTA		;LOOP START(END OF PASS COMES HERE)
   395	030011	254 00 1 00 027777 	SBINIT:	JRST	@SUBLNK		;PMGINT LINKAGE
   396	030012	000000	000000		RETURN:	0			;RETURN ADDRESS STORAGE
   397
   398	030013	254000	030742		START1:	SADR7			;OPTIONAL STARTING ADR/INSTRUCTIONS
   399	030014	254000	030742		START2:	SADR8			; "
   400	030015	254000	030742		START3:	SADR9			; "
   401	030016	254000	030742		START4:	SADR10			; "
   402	030017	254000	030742		START5:	SADR11			; "
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0018

   403					S^;*********************************************************************^
   404					;*PROGRAM FIXED PARAMETER AREA
   405					S^;*********************************************************************^
   406
   407	030020	444653	414100		PNTNAM:	PAREA3		;SIXBIT PROGRAM NAME
   408	030021	645560	000000		PNTEXT:	PAREA4		;SIXBIT PROGRAM EXTENSION
   409	030022	000000	000000		RANDBS:	PAREA1		;RANDOM BASE NUMBER
   410	030023	000000	000000		SWTEXR:	PAREA2		;SYSTEM EXERCISER SWITCHES
   411	030024	000000	001000		ITRCNT:	ITERAT		;PROGRAM ITERATIONS
   412	030025	000000	030725		$PNAME:	PGMNAM		;POINTER TO PROGRAMS NAME
   413	030026	000000	000002		$PVER:	MCNVER,,DECVER	;MCN & DEC VERSION LEVEL
   414	030027	000000	030000		$MODVL:	MODDVL		;DEVICE CODE CHANGE LOWER LIMIT
   415	030030	000000	030000		$MODVU:	MODDVU		;DEVICE CODE CHANGE UPPER LIMIT
   416	030031	777777	777777		$EMODE:	IFNDEF EXCASB,<0> IFDEF EXCASB,<-1>	;EXEC ALLOWED
   417	030032	777777	777777		$UMODE:	IFNDEF USRASB,<0> IFDEF USRASB,<-1>	;USER ALLOWED
   418	030033	000000	000000		$DSKUP:	IFNDEF DSKUPD,<0> IFDEF DSKUPD,<-1>	;DISK UPDATE MODE
   419	030034	000000	000000		$MMAP:	IFNDEF MEMMAP,<0> IFDEF MEMMAP,<-1>	;ALLOW MEMORY RTNS
   420	030035	000000	000000		PAREA7:	PAREA5		;OPTIONAL PARAMETER
   421	030036	000000	000000		PAREA8:	PAREA6		;OPTIONAL PARAMETER
   422
   423					S^;*********************************************************************^
   424					;*PROGRAM VARIABLE PARAMETER AREA
   425					S^;*********************************************************************^
   426
   427	030037	000000	000000		USER:	0		; 0 = EXEC, -1 = USER MODE FLAG
   428	030040	000000	000000		KAIFLG:	0		;PROCESSOR TYPE, 0 = KA10, -1 = KI10
   429	030041	000000	000000		KLFLG:	0		;PROCESSOR TYPE, 0 = KA/KI, -1 = KL10
   430	030042	777777	777777		MONFLG:	-1		;DIAG MONITOR SPECIAL USER FLAG
   431	030043	000000	000000		MONCTL:	0		;DIAG MON/SYS EXR FLAG
   432	030044	000000	000000		MONTEN:	0		;-1= LOADED BY 10
   433	030045	000000	000000		CLOCKF:	0		;CLOCK TICKED FLAG
   434	030046	000000	000000		CONSW:	0		;CONSOLE SWITCH SETTINGS
   435	030047	000000	000000		PASCNT:	0		;PROGRAM PASS COUNT
   436	030050	000000	000000		RUNFLG:	0		;PROGRAM RUN FLAG
   437	030051	000000	000000		TESTPC:	0		;SUBTEST PC
   438	030052	000000	000000		ERRPC:	0		;ERROR PC
   439	030053	000000	000000		ERRTLS:	0		;ERROR TOTALS
   440	030054	000000	000000		TICKS:	0		;PROGRAM RUNNING TIME
   441	030055	000000	000000		MARGIN:	0		;KI10 MARGIN WORD VALUE
   442	030056	000000	000000		$ONETM:	0		;SUBROUTINE INITIALIZATION FLAG
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0019

   443					S^;*********************************************************************^
   444					;*SPECIAL PROGRAM DISPATCH ADDRESSES
   445					S^;*********************************************************************^
   446
   447	030057	037 12 0 00 000004 	BEGEND:	ENDUUO		;END OF PASS
   448	030060	254 00 0 00 030010 	$BEND1:	JRST	BEGIN1	;KEEP RUNNING PROGRAM
   449	030061	037 16 0 00 000004 	$BEND2:	EOPUUO		;END OF PROGRAM - NO RETURN
   450	030062	254000	030742		CNTLC:	SADR5		;CONTROL C XFER ADDRESS
   451	030063	254000	030742		ALTMGO:	SADR6		;ALTMODE XFER ADDRESS
   452	030064				CPOPJ1:			;SKIP RETURN
   453	030064	350 00 0 17 000000 	UUOSKP:	AOS	(P)	;SKIP RETURN FROM UUO
   454	030065				CPOPJ:			;NON-SKIP REGULAR RETURN
   455	030065	263 17 0 00 000000 	UUOEXT:	RTN		;UUO RETURN
   456	030066	255 00 0 00 000000 	UUORTN:	JFCL		;ADDITIONAL USERS UUO ROUTINE
   457	030067	255 00 0 00 000000 	$UORTX:	JFCL		;ADDITIONAL UUO LINKAGE
   458	030070	255 00 0 00 000000 	$UUOER:	JFCL		;INITED AS (JRST $UOERX)
   459	030071	255 00 0 00 000000 	$ITRHL:	JFCL		;ADDITIONAL INTERRUPT LINKAGE
   460	030072	255 00 0 00 000000 	$ITRX1:	JFCL		; "
   461	030073	255 00 0 00 000000 	$USRHL:	JFCL		; "
   462	030074	255 00 0 00 000000 	$RSRTX:	JFCL		;ADDITIONAL POWER FAIL LINKAGE
   463	030075	255 00 0 00 000000 	$RSRTY:	JFCL		; "
   464	030076	255 00 0 00 000000 	RESRT1:	JFCL		; INITED AS (JRST RESRTX)
   465	030077	255 00 0 00 000000 	RESRT2:	JFCL		; "
   466	030100	255 00 0 00 000000 	$PARER:	JFCL		;ADDITIONAL PARITY ERROR LINKAGE
   467	030101	255 00 0 00 000000 	ERMORE:	JFCL		;ADDITIONAL ERROR HANDLER LINKAGE
   468	030102	254 04 0 00 030102 		HALT	.	;IMPROPER TRANSFER HALT
   469
   470	030103	000000	000000		$PSHER:	0		;INITED AS (JRST PSHERR)
   471	030104	000000	000000		ITRCH1:	0		;PC & FLAGS OF CURRENT INTERRUPT
   472	030105	000000	000000			0		;INITED AS (JRST $ITRC1)
   473
   474					S^;*********************************************************************^
   475					;*PROCESSOR CONTROL STORAGE
   476					S^;*********************************************************************^
   477
   478	030106	000000	000000		$ACC0:	0		;INTERRUPT SAVED AC0
   479	030107	000000	000000		$SVPI:	0		;INTERRUPT SAVED PI
   480	030110	000000	000000		$SVAPR:	0		;INTERRUPT SAVED APR
   481	030111	000000	000000		$SVPAG:	0		;INTERRUPT SAVED PAG (DATAI)
   482	030112	000000	000000		$SPAG1:	0		;INTERRUPT SAVED PAG (CONI)
   483
   484	030113	000000	000000		$SVUUO:	0		;CURRENT USERS UUO
   485	030114	000000	000000		$SVUPC:	0		;PC OF CURRENT USERS UUO
   486
   487	030115	000000	000000		REPTU:	0		;REPEAT UUO ITERATIONS
   488	030116	000000	000000		SCOPE:	0		;ERROR HANDLER SCOPE LOOP FLAG
   489	030117	000000	000000		%CORFLG:0		; " CORRECT FLAG
   490	030120	000000	000000		%COREC:	0		; " CORRECT DATA
   491	030121	000000	000000		%ACTFL:	0		; " ACTUAL FLAG
   492	030122	000000	000000		%ACTUL:	0		; " ACTUAL DATA
   493	030123	000000	000000		%DISCR:	0		; " DISCREPENCY DATA
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0020

   494					S^;*********************************************************************^
   495					;*UUO DISPATCH TABLE
   496					S^;*********************************************************************^
   497						XLIST
   498						LIST
   499	030124	030070	030070		UUODIS:	LUUO1,,$UUOER
   500	030125	030070	030070			LUUO3,,LUUO2
   501	030126	030070	030070			LUUO5,,LUUO4
   502	030127	030070	030070			LUUO7,,LUUO6
   503	030130	030070	030070			LUUO11,,LUUO10
   504	030131	030070	030070			LUUO13,,LUUO12
   505	030132	030070	030070			LUUO15,,LUUO14
   506	030133	030070	030070			LUUO17,,LUUO16
   507	030134	030070	030070			LUUO21,,LUUO20
   508	030135	030070	030070			LUUO23,,LUUO22
   509	030136	030070	030070			LUUO25,,LUUO24
   510	030137	030070	030070			LUUO27,,LUUO26
   511	030140	030070	030070			LUUO31,,LUUO30
   512	030141	030070	030070			LUUO33,,LUUO32
   513
   514					S^;*********************************************************************^
   515					;*MEMORY MANAGMENT STORAGE
   516					S^;*********************************************************************^
   517
   518	030142	000000	000000		DF22F:	0		;DF10 CONTROL FLAG, 0 = 18, -1 = 22 BIT
   519	030143	000000	000000		MAPNEW:	0		;MEMORY MAPPING CONTROL FLAG, -1 = 4096K MAPPING
   520	030144	000000	000000		MEMTOT:	0		;TOTAL MEMORY SIZE IN K (1024.)
   521	030145	000000	000000		MEMLOW:	0		;LOWEST USABLE MEMORY
   522	030146				MEMSIZ:	BLOCK ^D41	;MEMORY SEGMENT POINTER TABLE
   523
   524					S^;*********************************************************************^
   525					;*PRINT CONTROL STORAGE
   526					S^;*********************************************************************^
   527
   528	030217	000000	000000		PNTFLG:	0		;PRINT FLAG, -1 WHILE IN PRINT ROUTINE
   529	030220	000000	000000		PNTENB:	0		;PRINT ENABLE
   530	030221	000000	000000		PDISF:	0		;PRINT DISABLED FLAG
   531	030222	000000	000000		PNTINH:	0		;INHIBIT PRINT INPUT CHECKS
   532	030223	000000	000000		PNTSPC:	0		;PRINT SPACE CONTROL
   533	030224	000000	000000		OPTIME:	0		;TYPE-IN WAIT TIME
   534	030225	000000	000000		$TWCNT:	0		;TIME WAITED
   535	030226	000000	000000		$DVOFF:	0		;LOGICAL DEVICE INITED FLAG
   536	030227	000000	000000		TTYFIL:	0		;TTY EXEC FILLERS FLAG
   537	030230	000000	000000		TTYSPD:	0		;TTY EXEC BAUD RATE
   538	030231	000000	000000		$TTCHR:	0		;ACTUAL TYPED IN CHAR
   539	030232	000000	000000		$CHRIN:	0		;UPPER CASED & PARITY STRIPPED CHAR
   540	030233	000000	000000		$TYPNB:	0		;TYPED IN NUMBER
   541	030234	000000	000000		$CRLF:	0		;FREE CR/LF FLAG
   542	030235	000000	000000		$TABF:	0		;TAB CONVERSION FLAG
   543	030236	000000	000000		$FFF:	0		;FORM FEED CONVERSION FLAG
   544	030237	000000	000000		$VTF:	0		;VERTICAL TAB CONVERSION FLAG
   545	030240	000000	000000		USRLFF:	0		;USER LF FILLERS
   546	030241	000000	000000		USRCRF:	0		;USER CR FILLERS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 5
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0021

   547					S^;*********************************************************************^
   548					;*THE FOLLOWING MISCELLANEOUS PRINT CHARACTERS ARE INCLUDED
   549					;*TO FACILITATE PRINTING AND ARE CALLED AS FOLLOWS:
   550					;*	MOVEI	NAME
   551					;*	PNTA		;OR PNTAF
   552					S^;*********************************************************************^
   553
   554	030242				CRLF:	ASCII/
   555	030242	015 012 000 000 000 	/
   556	030243				CRLF2:	ASCII/
   557
   558	030243	015 012 015 012 000 	/
   559	030244	054 000 000 000 000 	COMMA:	ASCII/,/
   560	030245	056 000 000 000 000 	PERIOD:	ASCII/./
   561	030246	040 000 000 000 000 	SPACE:	ASCII/ /
   562	030247	011 000 000 000 000 	TAB:	ASCII/	/
   563	030250				MINUS:
   564	030250	055 000 000 000 000 	HYPEN:	ASCII/-/
   565	030251	053 000 000 000 000 	PLUS:	ASCII/+/
   566	030252	052 000 000 000 000 	AST:	ASCII/*/
   567	030253	100 000 000 000 000 	ATSIN:	ASCII/@/
   568	030254	050 000 000 000 000 	LFP:	ASCII/(/
   569	030255	051 000 000 000 000 	RTP:	ASCII/)/
   570	030256	007 0000000000 		BELL:	BYTE (7) 007
   571	030257	077 000 000 000 000 	QUEST:	ASCII/?/
   572	030260	057 000 000 000 000 	SLASH:	ASCII!/!
   573	030261	044 000 000 000 000 	DOLLAR:	ASCII/$/
   574	030262	000000	000012		RADIX:	^D10			;DECIMAL PRINT RADIX
   575	030263	000000	000040		RADLSP:	40			;DECIMAL PRINT LEADING CHAR
   576	030264	000000	000012		RADLSC:	^D10			;DECIMAL PRINT LEADING CHAR COUNT
   577
   578					S^;*********************************************************************^
   579					;*USER MODE OUTPUT FILE INFORMATION
   580					S^;*********************************************************************^
   581
   582	030265				$OBUF:	BLOCK	3		;LOGICAL FILE OUTPUT BUFFER HEADER
   583	030270	60 62 51 56 64 00 	$OUTNM:	SIXBIT	/PRINT/		;FILE NAME
   584	030271	60 56 64 00 00 00 	$OUTEX:	SIXBIT	/PNT/		;FILE NAME EXTENSION
   585	030272					BLOCK	2
   586
   587					S^;*********************************************************************^
   588					;*DISK UPDATE MODE FILE INFORMATION
   589					S^;*********************************************************************^
   590
   591	030274				$IBUF:	BLOCK	3
   592	030277	60 62 51 56 64 00 	$INNM:	SIXBIT	/PRINT/
   593	030300	60 56 64 00 00 00 	$INEXT:	SIXBIT	/PNT/
   594	030301					BLOCK	2
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0022

   595					S^;*********************************************************************^
   596					;*PUSHDOWN LIST CONTROL INFORMATION
   597					S^;*********************************************************************^
   598
   599	030303	777577	030303		PLIST:	PLIST-PLISTE,,PLIST
   600	030304				PLISTS:	BLOCK	200
   601	030504	000000	000000		PLISTE:	0		;END OF PUSHDOWN LIST
   602
   603					S^;*********************************************************************^
   604					;*POWER LINE CLOCK FREQUENCY FLAG
   605					S^;*********************************************************************^
   606
   607	030505	000000	000000		CYCL60:	0	;0 = 60, -1 = 50 CYCLE
   608
   609					S^;*********************************************************************^
   610					;*KL10 CACHE CONTROL FLAGS
   611					S^;*********************************************************************^
   612
   613	030506	000000	000000		CSHFLG:	0	;ALLOW CACHE IF 0
   614	030507	000000	000000		CSHMEM:	0	;CACHE MEMORY SEGMENTS IF 0
   615
   616					S^;*********************************************************************^
   617					;*NUMBER INPUT DIGIT FLAG
   618					S^;*********************************************************************^
   619
   620	030510	000000	000000		TTNBRF:	0	;-1 IF ANY DIGIT TYPED
   621
   622					S^;*********************************************************************^
   623					;*KL10 & KI10 "INHPAG" SWITCH PAGING PREVENTION
   624					S^;*********************************************************************^
   625
   626	030511	000000	000000		PVPAGI:	0	;IF NON-ZERO, OVERRIDE "INHPAG" SWITCH ACTION
   627
   628					S^;*********************************************************************^
   629					;*ERROR REPORTING ROUTINE ADDITIONAL USERS CONTROL INSTRUCTIONS
   630					S^;*********************************************************************^
   631
   632	030512	000000	000000		%ERHI1:	0	;IF NON-ZERO, XCT'D AT START OF %ERUUO
   633	030513	000000	000000		%ERHI2:	0	;IF NON-ZERO, XCT'D AT END OF %ERUUO
   634	030514	000000	000000		%ERHI3:	0	;IF NON-ZERO, XCT'D AFTER "PC" OF %ERUUO
   635
   636					S^;*********************************************************************^
   637					;*SPECIAL USERS UUO INTERCEPT INSTRUCTION
   638					S^;*********************************************************************^
   639
   640	030515	000000	000000		$$UUO:	0	;IF NON-ZERO, XCT'D AT START OF $UORTN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7
FIXED	KLM	18-JAN-77 11:39		*FIXED* FIXED CONTROL AND DISPATCH STORAGE, JAN 18,1977                            SEQ 0023

   641					S^;*********************************************************************^
   642					;*KL10 PROCESSOR TYPE FLAG, 0=P0, 1=BBD NEW, 2=BBD OLD
   643					S^;*********************************************************************^
   644
   645	030516	000000	000000		KLTYP:	0
   646
   647					S^;*********************************************************************^
   648					;*SPECIAL USERS MUUO INTERCEPT INSTRUCTION
   649					S^;*********************************************************************^
   650
   651	030517	000000	000000		$$MUUO:	0	;IF NON-ZERO, XCT'D AT START OF MUUOER
   652
   653					S^;*********************************************************************^
   654					;*SPECIAL USERS USER MODE OUTPUT ERROR INTERCEPT INSTUCTION
   655					S^;*********************************************************************^
   656
   657	030520	000000	000000		$$OUTER:0	;IF NON-ZERO, XCT'D AT END OF USER MODE ERROR
   658
   659					S^;*********************************************************************^
   660					;*"SWITCH" CALL USAGE CONTROL
   661					S^;*********************************************************************^
   662
   663	030521	000000	000000		$$TOGGLE:0	;IF NON-ZERO, USE C(CONSW) FOR SWITCHES
   664
   665					S^;*********************************************************************^
   666					;*SPECIAL USERS ALTMODE SWITCH CALL INTERCEPT INSTRUCTIONS
   667					S^;*********************************************************************^
   668
   669	030522	000000	000000		$$TAX1:	0	;IF NON-ZERO, XCT'D AT START OF ALTMODE SWITCH CALL
   670	030523	000000	000000		$$TAX2:	0	;IF NON-ZERO, XCT'D AT END OF ALTMODE SWITCH CALL
   671
   672					S^;*********************************************************************^
   673					;*SPECIAL FUTURE EXPANSION ROOM
   674					;*IF ANY FIXED AREA TAGS ARE ADDED, REDUCE THE SIZE OF
   675					;*THIS BLOCK STATEMENT ACCORDINGLY.  THIS MUST BE DONE
   676					;*SO THAT PREVIOUS FIXED ASSIGNMENTS DO NOT CHANGE.
   677					S^;*********************************************************************^
   678
   679	030524					BLOCK	53	;HOPEFULLY THIS IS ENOUGH FOREVER
   680
   681					S^;*********************************************************************^
   682					;*END OF FIXED STORAGE
   683					S^;*********************************************************************^
   684
   685			030577			$ENDFX=<PLISTE+100>&<777700>-1
   686	030577					LOC	$ENDFX
   687	030577	000000	000000		ENDFIX:	0		;END OF FIXED STORAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
SPCCPU	KLM	26-FEB-76 05:50		*SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76                            SEQ 0024

   688					SUBTTL	*SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76
   689
   690					;NEW DEFINITIONS USED BY THE KL10 SUBROUTINE PACKAGE
   691
   692			000000		AC0=	0
   693			030000		DIAGNOS=30000		;PDP-10 DIAGNOSTIC START ADDRESS
   694			010000		DDT=	10000		;PDP-10 DDT START ADDRESS
   695			020000		DIAMON=	20000		;PDP-10 DIAMON LOADER START ADDRESS
   696			020000		DONG11=	1B22		;11 DOORBELL (FROM THE 10)
   697
   698					;DTE20 DEVICE CODES
   699
   700			000200		DTE==	200		;DTE0
   701			000204		DTE0==	204
   702			000204		DTE1==	204
   703			000210		DTE2==	210
   704			000214		DTE3==	214
   705
   706					;KL10 EPT COMMUNICATION AREA
   707
   708			000440		$STD=	440		;PDP-10 DIAGNOSTIC START ADDRESS
   709			000441		$DDT=	441		;PDP-10 DDT START ADDRESS
   710			000442		$STL=	442		;PDP-10 LOADER START ADDRESS
   711			000443		$STM=	443		;PDP-10 MONITOR START ADDRESS
   712
   713			000444		$DTFLG=	444		;DTE20 OPERATION COMPLETE FLAG
   714			000445		$DTCLK=	445		;DTE20 CLOCK INTERRUPT FLAG
   715			000446		$DTCI=	446		;DTE20 CLOCK INTERRUPT INSTRUCTION
   716			000447		$DTT11=	447		;DTE20 10 TO 11 ARGUMENT
   717			000450		$DTF11=	450		;DTE20 11 TO 10 ARGUMENT
   718			000451		$DTCMD=	451		;DTE20 TO 11 COMMAND WORD
   719			000452		$DTSEQ=	452		;DTE20 OPERATION SEQUENCE NUMBER
   720			000453		$DTOPR=	453		;DTE20 OPERATIONAL DTE #
   721			000454		$DTCHR=	454		;DTE20 LAST TYPED CHARACTER
   722			000455		$DTMTD=	455		;DTE20 MONITOR TTY OUTPUT COMPLETE FLAG
   723			000456		$DTMTI=	456		;DTE20 MONITOR TTY INPUT FLAG
   724
   725			000457		$DTSWR=	457		;DTE20 CONSOLE SWITCH REGISTER
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
SPCCPU	KLM	26-FEB-76 05:50		*SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76                            SEQ 0025

   726					;SPECIAL "FIXED" REASSIGNMENTS
   727
   728			030600			$$LOC=.			;SAVE CURRENT LOCATION
   729
   730	030000					LOC	30000
   731	030000	254 00 0 00 030600 	$$BEGIN:JRST	$$START		;SETUP SPECIAL START
   732	030001	254 00 0 00 030600 		JRST	$$START		;"DIAMON" CHAIN START ADDRESS
   733
   734	000440					LOC	440
   735	000440	254 00 0 00 030000 	$STD:	JRST	BEGIN		;SETUP FOR "STD"
   736	000443					LOC	443
   737	000443	254 00 0 00 030636 	$STM:	JRST	$SPEC		;SIMPLE RUN CONTROL
   738
   739	030057					LOC	30057
   740	030057	254 00 0 00 030641 	$BEGEND:JRST	$SPBEND		;SETUP SPECIAL "BEGEND"
   741
   742					;SPECIAL MUUO, TRAP & PAGE FAIL SETUP
   743
   744	000420					LOC	420
   745	000420	254 04 0 00 000420 	$$420:	HALT	.		;KI10 PAGE FAIL
   746	000421	255 00 0 00 000000 	$$421:	JFCL			;OVERFLOW
   747	000422	254 04 0 00 000422 	$$422:	HALT	.		;PUSHDOWN OVERFLOW
   748	000423	254 04 0 00 000423 	$$423:	HALT	.		;TRAP 3
   749	000424	000000	000000		$$424:	0			;MMUO
   750	000425	000000	000000		$$425:	0			;MMUO PC
   751	000426	000000	000000		$$426:	0			;KI10-PAGE FAIL, KL10-PROCESS CONTEXT
   752	000427	254 04 0 00 000427 	$$427:	HALT	.
   753	000430	000000	000427		$$430:	427			;MMUO NEW PC'S
   754	000431	000000	000427		$$431:	427
   755	000432	000000	000427		$$432:	427
   756	000433	000000	000427		$$433:	427
   757	000434	000000	000427		$$434:	427
   758	000435	000000	000427		$$435:	427
   759	000436	000000	000427		$$436:	427
   760	000437	000000	000427		$$437:	427
   761
   762	000500					LOC	500
   763	000500	000000	000000		$$500:	0			;KL10 PAGE FAIL WORD
   764	000501	000000	000000		$$501:	0			;KL10 PAGE FAIL PC
   765	000502	000000	000503		$$502:	503			;KL10 PAGE FAIL NEW PC
   766	000503	254 04 0 00 000503 	$$503:	HALT	.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
SPCCPU	KLM	26-FEB-76 05:50		*SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76                            SEQ 0026

   767	030600					LOC	$$LOC		;RESET CURRENT LOCATION
   768
   769					;SPECIAL STARTUP SEQUENCE
   770
   771	030600	402 00 0 00 030037 	$$START:SETZM	USER
   772	030601	265 00 0 00 030602 		JSP	0,.+1		;IN USER MODE ?
   773	030602	603 00 0 00 010000 		TLNE	0,USERF
   774	030603	476 00 0 00 030037 		SETOM	USER		;YES, SET CONTROL WORD
   775	030604	336 00 0 00 030042 		SKIPN	MONFLG		;SPECIAL USER MODE ?
   776	030605	402 00 0 00 030037 		SETZM	USER		;YES, RUN AS EXEC
   777	030606	332 00 0 00 030037 		SKIPE	USER
   778	030607	254 00 0 00 030712 		JRST	START		;USER MODE, DON'T NEED CPU TYPE
   779
   780	030610	336 00 0 00 030044 	$STKIL:	SKIPN	MONTEN		;LOADED BY "DIAMON" ?
   781	030611	476 00 0 00 030024 		SETOM	ITRCNT		;NO, RUN FOREVER
   782	030612	402 00 0 00 030516 		SETZM	KLTYP
   783	030613	402 00 0 00 030041 		SETZM	KLFLG		;ASSUME KI10
   784	030614	200 01 0 00 070251 		MOVE	1,[1,,1]
   785	030615	251 01 0 00 000001 		BLT	1,1		;HOPE THIS WORKS
   786	030616	316 01 0 00 070251 		CAMN	1,[1,,1]	;IF AC NE 1,,1 AFTER BLT, KL10
   787	030617	254 00 0 00 030712 		JRST	START		;KI10, NO ADDITIONAL SETUP
   788
   789	030620	7 000 20 0 00 010040 	$STKL:	CONO	APR,10040	;SET BBD NOT BIT
   790	030621	7 000 24 0 00 000000 		CONI	APR,0
   791	030622	7 000 20 0 00 020040 		CONO	APR,20040	;CLEAR BBD NOT BIT
   792	030623	606 00 0 00 000040 		TRNN	0,40		;IF SET, KL10
   793	030624	350 00 0 00 030516 		AOS	KLTYP		;IF NOT, BBD
   794	030625	402 00 0 00 000444 		SETZM	$DTFLG
   795	030626	402 00 0 00 000445 		SETZM	$DTCLK
   796	030627	200 00 0 00 000453 		MOVE	$DTOPR		;GET DTE #
   797	030630	436 00 0 00 030670 		ORM	$$DTE0		;INSERT IN DTE I/O INSTS
   798	030631	436 00 0 00 030672 		ORM	$$DTE1
   799	030632	436 00 0 00 030704 		ORM	$$DTE2
   800	030633	436 00 0 00 030706 		ORM	$$DTE3
   801	030634	476 00 0 00 030041 		SETOM	KLFLG		;SET KL10 CONTROL FLAG
   802	030635	254 00 0 00 030712 		JRST	START
   803
   804	030636	200 00 0 00 070252 	$SPEC:	MOVE	[JRST STARTA]	;SIMPLE RUN CONTROL
   805	030637	202 00 0 00 030643 		MOVEM	$SPB1
   806	030640	254 00 0 00 030712 		JRST	START
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4
SPCCPU	KLM	26-FEB-76 05:50		*SPCCPU* SPECIAL BASIC CPU PROCESSOR CONTROL, 26-FEB-76                            SEQ 0027

   807					;SPECIAL "BEGEND" ROUTINE
   808
   809	030641	350 00 0 00 030047 	$SPBEND:AOS	PASCNT		;INCREMENT PASS COUNT
   810	030642	370 00 0 00 030024 		SOS	ITRCNT		;DECREMENT ITERATION COUNT
   811	030643	336 00 0 00 030037 	$SPB1:	SKIPN	USER
   812	030644	254 00 0 00 030652 		JRST	$SPBEX		;EXEC MODE
   813
   814	030645	332 00 0 00 030024 	$SPBUS:	SKIPE	ITRCNT		;USER MODE, COMPLETED ?
   815	030646	254 00 0 00 030742 		JRST	STARTA		;NO, KEEP RUNNING
   816	030647	336 00 0 00 030044 		SKIPN	MONTEN		;DONE, LOADED BY "DIAMON" ?
   817	030650	047 00 0 00 000012 		EXIT			;NO, RETURN TO MONITOR
   818	030651	254 00 1 00 030012 		JRST	@RETURN		;YES, RETURN TO "DIAMON"
   819
   820	030652	332 00 0 00 030041 	$SPBEX:	SKIPE	KLFLG
   821	030653	254 00 0 00 030660 		JRST	$SPBKL		;KL10 & EXEC
   822	030654	7 004 14 0 00 030024 		DATAO	PI,ITRCNT	;KI10 & EXEC, DISPLAY ITER COUNT
   823	030655	332 00 0 00 030024 		SKIPE	ITRCNT
   824	030656	254 00 0 00 030742 		JRST	STARTA		;NOT COMPLETED YET
   825	030657	254 00 1 00 030012 		JRST	@RETURN		;DONE
   826
   827	030660	336 00 0 00 030024 	$SPBKL:	SKIPN	ITRCNT
   828	030661	254 00 0 00 030676 		JRST	$SPKLD		;KL10, EXEC & COMPLETED
   829
   830	030662	335 00 0 00 030043 		SKIPGE	MONCTL
   831	030663	254 00 0 00 030742 		JRST	STARTA		;"DIAMON" CONTROL
   832	030664	201 00 0 00 000404 		MOVEI	0,404		;NOTIFY PDP-11 OF END OF PASS
   833	030665	202 00 0 00 000451 		MOVEM	0,$DTCMD
   834	030666	402 00 0 00 000444 		SETZM	$DTFLG
   835	030667	336 00 0 00 030516 		SKIPN	KLTYP
   836	030670	7 200 20 0 00 020000 	$$DTE0:	CONO	DTE,DONG11
   837	030671	332 00 0 00 030516 		SKIPE	KLTYP
   838	030672	7 200 20 0 00 010000 	$$DTE1:	CONO	DTE,10000
   839	030673	336 00 0 00 000444 		SKIPN	$DTFLG		;WAIT TILL 11 RESPONDS
   840	030674	254 00 0 00 030673 		JRST	.-1
   841	030675	254 00 0 00 030742 		JRST	STARTA		;KEEP RUNNING
   842
   843					;SPECIAL KL10 COMPLETED ROUTINE
   844
   845	030676	332 00 0 00 030044 	$SPKLD:	SKIPE	MONTEN
   846	030677	254 00 1 00 030012 		JRST	@RETURN		;LOADED BY "DIAMON"
   847
   848	030700	201 00 0 00 000403 		MOVEI	0,403		;NOTIFY PDP-11 OF COMPLETION
   849	030701	202 00 0 00 000451 		MOVEM	0,$DTCMD
   850	030702	402 00 0 00 000444 		SETZM	$DTFLG
   851	030703	336 00 0 00 030516 		SKIPN	KLTYP
   852	030704	7 200 20 0 00 020000 	$$DTE2:	CONO	DTE,DONG11
   853	030705	332 00 0 00 030516 		SKIPE	KLTYP
   854	030706	7 200 20 0 00 010000 	$$DTE3:	CONO	DTE,10000
   855	030707	336 00 0 00 000444 		SKIPN	$DTFLG		;SHOULD NEVER HAPPEN
   856	030710	254 00 0 00 030707 		JRST	.-1		;11 NEVER RETURNS ON END OF PROGRAM
   857	030711	254 04 0 00 030000 		HALT	BEGIN		;IF IT DOES, HALT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
DFKAA1	MAC	31-JAN-77 09:33		DIAGNOSTIC SECTION                                                                 SEQ 0028

   858					SUBTTL	DIAGNOSTIC SECTION
   859
   860	030712	402 00 0 00 030037 	START:	SETZM	USER#		;CLEAR USER CONTROL WORD
   861	030713	265 00 0 00 030714 		JSP	0,.+1		;GET FLAGS
   862	030714	603 00 0 00 010000 		TLNE	USERF		;IN USER MODE?
   863	030715	476 00 0 00 030037 		SETOM	USER		;YES, SET USER CONTROL WORD
   864	030716	336 00 0 00 030042 		SKIPN	MONFLG		;SPECIAL USER MODE?
   865	030717	402 00 0 00 030037 		SETZM	USER		;YES, CLEAR USER CONTROL WORD
   866	030720	336 00 0 00 030037 		SKIPN	USER
   867	030721	254 00 0 00 030742 		JRST	STARTA
   868	030722	331 00 0 00 030043 		SKIPL	MONCTL
   869	030723	051 03 0 00 030725 		TTCALL	3,PGMNAM
   870	030724	254 00 0 00 030742 		JRST	STARTA
   871
   872	030725				PGMNAM:	ASCIZ/
   873	030725	015 012 104 105 103 	DECSYSTEM10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) [DFKAA]
   874	030726	123 131 123 124 105 
   875	030727	115 061 060 040 113 
   876	030730	114 061 060 040 102 
   877	030731	101 123 111 103 040 
   878	030732	111 116 123 124 122 
   879	030733	125 103 124 111 117 
   880	030734	116 040 104 111 101 
   881	030735	107 116 117 123 124 
   882	030736	111 103 040 050 061 
   883	030737	051 040 133 104 106 
   884	030740	113 101 101 135 015 
   885	030741	012 000 000 000 000 	/
   886
   887					;BASIC INSTRUCTION TEST (1)
   888					;THE TEST IS DESIGNED FOR INITIAL DEBUGGING OF
   889					;PROCESSOR HARDWARE AND TO DETECT (SOLID) FAILURES
   890					;IN THE FIELD.
   891
   892
   893	030742	254 00 0 00 030743 	STARTA:	JRST	.+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0029

   894					SUBTTL	TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS
   895
   896					;NOTE: AN "*" IN THE COMMENT FIELD OF AN INSTRUCTION INDICATES THAT IT IS THE TESTED
   897					;INSTRUCTION.
   898					;**********
   899
   900					;THIS TEST VERIFIES THAT SKIPA ALWAYS SKIPS THE NEXT INSTRUCTION
   901
   902			030743		A00=.
   903	030743	334 00 0 00 000000 	A12500:	SKIPA			;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
   904	030744	254 04 0 00 000000 		HALT			;IF PROGRAM HALTS, SKIPA DID NOT SKIP
   905
   906					;IF PROGRAM HANGS UP ON SKIPA INSTRUCTION, CHECK AB PC EN [ABC], AB PC F/F [ABC],
   907					;AB PC B [ABC OR AB], AB PC (FETCH) EN [ABC], IR SKIPS [IR3], IR SKIPX [IR1],
   908					;IR 3XX [IR1], IR BITS 00 - 08 [IR1], F CYC ACT EN C [FI], FT6 F/F [F2],
   909					;PC CLOCK EN [PCC],  ET2 J F/F [E], PC CLK (ET2) EN [PCC], ADZ COND P [ADZ] AND
   910					;ADZ COND R [ADZ], PC CLOCK A [PCC], PC CLOCK B [PCC]
   911
   912					;IF PROGRAM HALTED ON HALT INSTRUCTION, CHECK ST1 COND [ST2]
   913
   914					;**********
   915
   916					;THIS TEST VERIFIES THAT JUMP NEVER JUMPS
   917
   918	030745	320 00 0 00 030746 	A15000:	JUMP	.+1		;*JUMP SHOULD NEVER JUMP
   919	030746	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
   920	030747	254 04 0 00 000000 		HALT			;HALT IF JUMP FAILS
   921
   922					;IF PROGRAM HANGS UP ON JUMP .+1 INSTRUCTION, THE JUMP INSTRUCTION
   923					;MAY HAVE FAILED.  CHECK ST1 COND [ST2], ST INST FET ST1 EN [ST2], ET2 D F/F [E],
   924					;IR JUMPS [IR1], IR JUMPX [IR1]
   925
   926					;**********
   927					;THIS TEST VERIFIES THAT JUMP NEVER JUMPS
   928
   929	030750	320 00 0 00 030752 	A15100:	JUMP	.+2		;*JUMP SHOULD NEVER JUMP
   930	030751	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF JUMP IS SUCCESSFUL
   931	030752	254 04 0 00 000000 		HALT			;HALT IF JUMP FAILS
   932
   933					;AB PC EN [ABC]
   934
   935					;**********
   936
   937					;THIS TEST VERIFIES THAT JUMPA .+1 ALWAYS JUMPS TO THE NEXT INSTRUCTION
   938
   939	030753	324 00 0 00 030754 	A12700:	JUMPA	.+1		;*JUMPA .+1 SHOULD NEVER JUMP
   940	030754	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF JUMPA IS SUCCESSFUL
   941	030755	254 04 0 00 000000 		HALT			;HALT IF JUMPA .+1 FAILED
   942
   943					;**********
   944
   945					;THIS TEST VERIFIES THAT JUMPA JUMPS TO THE LOCATION SPECIFIED BY E WHEN E=.+2
   946
   947	030756	324 00 0 00 030760 	A12600:	JUMPA	.+2		;*JUMPA .+2 SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
   948	030757	254 04 0 00 000000 		HALT			;PROGRAM HALTS HERE IF JUMPA .+2 FAILS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0030

   949
   950					;ST1 COND [ST2]
   951
   952					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0031

   953					;THIS TEST VERIFIES THAT SKIPA IS DATA INDEPENDENT.  HENCE, IT ALWAYS SKIPS THE NEXT
   954					;INSTRUCTION.
   955					;THE MOVE [0] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.
   956
   957	030760	200 00 0 00 070253 	A100:	MOVE	[0]		;PRESET LOCATION 0 TO ALL ZEROS
   958	030761	334 00 0 00 000000 		SKIPA			;*SKIPA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION
   959						STOP^
   960	030762	254 04 0 00 030763 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
   961	030763	324 00 0 00 030764 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
   962									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
   963									;IN THE SUBTEST) TO LOOP ON ERROR^
   964
   965					;**********
   966					;THIS TEST INSURES THAT SKIPA IS DATA INDEPENDENT.  HENCE, IT ALWAYS SKIPS THE NEXT
   967					;INSTRUCTION.
   968					;THE MOVE [-1] INSTRUCTION IS USED TO TEST THE DATA INDEPENDENCE OF SKIPA.
   969
   970	030764	200 00 0 00 070254 	A200:	MOVE	[-1]		;PRESET LOCATION 0 TO ALL ONES
   971	030765	334 00 0 00 000000 		SKIPA			;*SKIPA SKOULD ALWAYS SKIP THE NEXT INSTRUCTION
   972						STOP^
   973	030766	254 04 0 00 030767 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
   974	030767	324 00 0 00 030770 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
   975									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
   976									;IN THE SUBTEST) TO LOOP ON ERROR^
   977
   978					;COND P [ADZ]
   979
   980					;**********
   981					;THIS TEST VERIFIES THAT SKIPGE SKIPS THE NEXT INSTRUCTION WHEN C(E)
   982					;IS ALL ZEROS.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH ALL ZEROS.
   983
   984	030770	200 00 0 00 070253 	A300:	MOVE	[0]		;PRESET E TO ALL ZEROS
   985	030771	335 00 0 00 000000 		SKIPGE			;*SKIPGE SHOULD SKIP THE NEXT INSTRUCTION
   986						STOP^
   987	030772	254 04 0 00 030773 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
   988	030773	324 00 0 00 030774 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
   989									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
   990									;IN THE SUBTEST) TO LOOP ON ERROR^
   991
   992					;COND R [ADZ], AD00 S-A-1, AD AR + EN [ADAP], AD LT AR + EN [ADAP],
   993					;AD RT AR + EN [ADAP], AD AR + EN C [ADAP], F CYC ACT EN A [F1]
   994
   995					;**********
   996
   997					;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT.  HENCE, SKIP NEVER SKIPS.  IT ALWAYS
   998					;CONTINUES ON TO THE NEXT INSTRUCTION.
   999
  1000	030774	200 00 0 00 070254 	A400:	MOVE	[-1]		;PRESET E TO ALL ONES
  1001	030775	330 00 0 00 000000 		SKIP			;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
  1002	030776	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1003						STOP^
  1004	030777	254 04 0 00 031000 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1005	031000	324 00 0 00 031001 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1006									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1007									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0032

  1008
  1009					;PC CHANGE [PCC], PC CHANGE A [PCC], SEE MEMORY CONTROL DWGS [MC1-4]
  1010
  1011					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0033

  1012					;THIS TEST VERIFIES THAT SKIPGE WILL NOT SKIP THE NEXT INSTRUCTION WHEN C(E) IS
  1013					;NEGATIVE.  THE MOVE INSTRUCTION LOADS E WITH -1, A NEGATIVE NUMBER.
  1014
  1015	031001	200 00 0 00 070254 	A500:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NEGATIVE NUMBER
  1016	031002	335 00 0 00 000000 		SKIPGE			;*SKIPGE SHOULD NOT SKIP THE NEXT INSTRUCTION
  1017	031003	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1018						STOP^
  1019	031004	254 04 0 00 031005 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1020	031005	324 00 0 00 031006 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1021									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1022									;IN THE SUBTEST) TO LOOP ON ERROR^
  1023
  1024					;IF MOVE INSTRUCTION FAILED, CHECK MOVX-: FCE [F1], -IR XXXI [IR1], -IR XXXM [IR1], 
  1025					;IR HWTFWT [IR3], IR FWT [IR2], IR2XX [IR1]
  1026
  1027					;IF SKIPGE FAILED, CHECK SKIPX: FCE [F1]
  1028
  1029					;**********
  1030
  1031					;THIS TEST VERIFIES THAT SKIPN WILL NOT SKIP THE NEXT INSTRUCTION WHEN
  1032					;C(E) IS ZERO.  THE MOVE INSTRUCTION  LOADS E WITH ALL ZEROS.
  1033
  1034	031006	200 00 0 00 070253 	A600:	MOVE	[0]		;PRESET E WITH ALL ZEROS
  1035	031007	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD NOT SKIP THE NEXT INSTRUCTION
  1036	031010	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1037						STOP^
  1038	031011	254 04 0 00 031012 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1039	031012	324 00 0 00 031013 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1040									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1041									;IN THE SUBTEST) TO LOOP ON ERROR^
  1042
  1043					;**********
  1044
  1045					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT SHOULD SKIP
  1046					;THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO.  THE MOVE INSTRUCTION LOADS
  1047					;E WITH -1, A NON-ZERO NUMBER.
  1048
  1049	031013	200 00 0 00 070254 	A700:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
  1050	031014	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1051						STOP^
  1052	031015	254 04 0 00 031016 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1053	031016	324 00 0 00 031017 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1054									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1055									;IN THE SUBTEST) TO LOOP ON ERROR^
  1056
  1057					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0034

  1058					;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT.  HENCE, IT SHOULD NOT
  1059					;SKIP THE NEXT INSTRUCTION WHEN C(E) IS NON-ZERO.  THE MOVE INSTRUCTION LOADS E
  1060					;WITH -1, A NON-ZERO NUMBER.
  1061
  1062	031017	200 00 0 00 070254 	A1000:	MOVE	[-1]		;PRESET E WITH ALL ONES, A NON-ZERO NUMBER
  1063	031020	332 00 0 00 000000 		SKIPE			;*SKIPE SHOULD NOT SKIP THE NEXT INSTRUCTION
  1064	031021	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1065						STOP^
  1066	031022	254 04 0 00 031023 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1067	031023	324 00 0 00 031024 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1068									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1069									;IN THE SUBTEST) TO LOOP ON ERROR^
  1070
  1071					;**********
  1072
  1073					;THIS TEST VERIFIES THAT SKIPE IS DATA DEPENDENT.  HENCE, IT SHOULD SKIP
  1074					;THE NEXT INSTRUCTION WHEN C(E) IS ZERO.  THE MOVE INSTRUCTION LOADS ALL
  1075					;ZEROS INTO E.
  1076
  1077	031024	200 00 0 00 070253 	A1100:	MOVE	[0]		;PRESET E TO ALL ZEROS
  1078	031025	332 00 0 00 000000 		SKIPE			;*SKIPE SHOULD SKIP THE NEXT INSTRUCTION
  1079						STOP^
  1080	031026	254 04 0 00 031027 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1081	031027	324 00 0 00 031030 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1082									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1083									;IN THE SUBTEST) TO LOOP ON ERROR^
  1084
  1085					;**********
  1086
  1087					;THIS TEST VERIFIES THAT SKIP IS DATA INDEPENDENT.  HENCE, IT NEVER SKIPS.  IT ALWAYS
  1088					;CONTINUES ON TO THE NEXT INSTRUCTION.
  1089
  1090	031030	200 00 0 00 070253 	A1200:	MOVE	[0]		;PRESET E TO ALL ZEROS
  1091	031031	330 00 0 00 000000 		SKIP			;*SKIP SHOULD NEVER SKIP THE NEXT INSTRUCTION
  1092	031032	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1093						STOP^
  1094	031033	254 04 0 00 031034 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1095	031034	324 00 0 00 031035 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1096									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1097									;IN THE SUBTEST) TO LOOP ON ERROR^
  1098
  1099					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0035

  1100					;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
  1101					;INSTRUCTION WHEN C(E) IS NOT NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD
  1102					;E WITH ALL ZEROS, A NON-NEGATIVE NUMBER.
  1103
  1104	031035	200 00 0 00 070253 	A1300:	MOVE	[0]		;PRESET E T0 ZERO, A NON-NEGATIVE NUMBER
  1105	031036	331 00 0 00 000000 		SKIPL			;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
  1106	031037	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1107						STOP^
  1108	031040	254 04 0 00 031041 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1109	031041	324 00 0 00 031042 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1110									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1111									;IN THE SUBTEST) TO LOOP ON ERROR^
  1112
  1113					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0036

  1114					;THIS TEST VERIFIES THAT SKIPL IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1115					;INSTRUCTION WHEN C(E) IS NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH -1,
  1116					;A NEGATIVE NUMBER.
  1117
  1118	031042	200 00 0 00 070254 	A1400:	MOVE	[-1]		;PRESET E TO -1, A NEGATIVE NUMBER
  1119	031043	331 00 0 00 000000 		SKIPL			;*SKIPL SHOULD SKIP THE NEXT INSTRUCTION
  1120						STOP^
  1121	031044	254 04 0 00 031045 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1122	031045	324 00 0 00 031046 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1123									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1124									;IN THE SUBTEST) TO LOOP ON ERROR^
  1125
  1126					;**********
  1127
  1128					;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1129					;INSTRUCTION WHEN C(E) IS GREATER THAN ZERO.  THE MOVE INSTRUCTION IS USED TO LOAD
  1130					;E WITH A NON-ZERO POSITIVE NUMBER.
  1131
  1132	031046	200 00 0 00 070255 	A1500:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A NON-ZERO POSITIVE NUMBER
  1133	031047	337 00 0 00 000000 		SKIPG			;*SKIPG SHOULD SKIP THE NEXT INSTRUCTION
  1134						STOP^
  1135	031050	254 04 0 00 031051 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1136	031051	324 00 0 00 031052 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1137									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1138									;IN THE SUBTEST) TO LOOP ON ERROR^
  1139
  1140					;**********
  1141
  1142					;THIS TEST VERIFIES THAT SKIPG IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
  1143					;INSTRUCTION WHEN C(E) IS NOT GREATER THAN ZERO.  THE MOVE INSTRUCTION IS USED TO
  1144					;LOAD E WITH -1, A NUMBER NOT GREATER THAN ZERO.
  1145
  1146	031052	200 00 0 00 070254 	A1600:	MOVE	[-1]		;PRESET E TO -1, A NEGATIVE NUMBER
  1147	031053	337 00 0 00 000000 		SKIPG			;*SKIPG SHOULD NOT SKIP THE NEXT INSTRUCTION
  1148	031054	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1149						STOP^
  1150	031055	254 04 0 00 031056 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1151	031056	324 00 0 00 031057 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1152									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1153									;IN THE SUBTEST) TO LOOP ON ERROR^
  1154
  1155					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0037

  1156					;THIS TEST VERIFIES THAT SKIPL IS DATA  DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
  1157					;INSTRUCTION WHEN C(E) IS NON-NEGATIVE.  THE MOVE INSTRUCTION IS USED TO LOAD E WITH
  1158					;377777777777, A NON-NEGATIVE NUMBER.
  1159
  1160	031057	200 00 0 00 070255 	A1700:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A NON-NEGATIVE NUMBER
  1161	031060	331 00 0 00 000000 		SKIPL			;*SKIPL SHOULD NOT SKIP THE NEXT INSTRUCTION
  1162	031061	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1163						STOP^
  1164	031062	254 04 0 00 031063 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1165	031063	324 00 0 00 031064 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1166									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1167									;IN THE SUBTEST) TO LOOP ON ERROR^
  1168
  1169					;**********
  1170
  1171					;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1172					;INSTRUCTION WHEN C(E) IS ZERO.  THE MOVE INSTRUCTION LOADS E WITH ALL ZEROS.
  1173
  1174	031064	200 00 0 00 070253 	A2000:	MOVE	[0]		;PRESET E TO ALL ZEROS
  1175	031065	333 00 0 00 000000 		SKIPLE			;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
  1176						STOP^
  1177	031066	254 04 0 00 031067 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1178	031067	324 00 0 00 031070 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1179									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1180									;IN THE SUBTEST) TO LOOP ON ERROR^
  1181
  1182					;**********
  1183
  1184					;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1185					;INSTRUCTION WHEN E CONTAINS A NEGATIVE NUMBER.  THE MOVE INSTRUCTION IS USED TO LOAD
  1186					;E WITH 400000000000, A NEGATIVE NUMBER.
  1187
  1188	031070	200 00 0 00 070256 	A2100:	MOVE	[XWD 400000,0]	;PRESET E TO 400000000000, A NEGATIVE NUMBER.
  1189	031071	333 00 0 00 000000 		SKIPLE			;*SKIPLE SHOULD SKIP THE NEXT INSTRUCTION
  1190						STOP^
  1191	031072	254 04 0 00 031073 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1192	031073	324 00 0 00 031074 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1193									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1194									;IN THE SUBTEST) TO LOOP ON ERROR^
  1195
  1196					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0038

  1197					;THIS TEST VERIFIES THAT SKIPLE IS DATA DEPENDENT.  HENCE, IT WILL NOT SKIP THE NEXT
  1198					;INSTRUCTION WHEN E CONTAINS A POSITIVE NUMBER.  THE MOVE INSTRUCTION LOADS
  1199					;E WITH 377777777777, A POSITIVE NUMBER.
  1200
  1201	031074	200 00 0 00 070255 	A2200:	MOVE	[XWD 377777,-1]	;PRESET E TO 377777777777, A POSITIVE NUMBER
  1202	031075	333 00 0 00 000000 		SKIPLE			;*SKIPLE SHOULD NOT SKIP THE NEXT INSTRUCTION
  1203	031076	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF TEST PASSES
  1204						STOP^
  1205	031077	254 04 0 00 031100 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1206	031100	324 00 0 00 031101 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1207									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1208									;IN THE SUBTEST) TO LOOP ON ERROR^
  1209
  1210					;*********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0039

  1211					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1212					;INSTRUCTION ;WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1213					;LOAD 777000000000, A NON-ZERO NUMBER INTO E.
  1214
  1215	031101	200 00 0 00 070257 	A2300:	MOVE	[XWD 777000,0]	;PRESET E WITH 777000000000, A NON-ZERO NUMBER
  1216	031102	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1217						STOP^
  1218	031103	254 04 0 00 031104 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1219	031104	324 00 0 00 031105 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1220									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1221									;IN THE SUBTEST) TO LOOP ON ERROR^
  1222
  1223					;**********
  1224
  1225					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1226					;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1227					;LOAD A NON-ZERO NUMBER, 377000000 INTO E.
  1228
  1229	031105	200 00 0 00 070260 	A2400:	MOVE	[XWD 377,0]	;PRESET E TO 377000000, A NON ZERO NUMBER
  1230	031106	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1231						STOP^
  1232	031107	254 04 0 00 031110 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1233	031110	324 00 0 00 031111 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1234									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1235									;IN THE SUBTEST) TO LOOP ON ERROR^
  1236
  1237					;**********
  1238
  1239					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1240					;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1241					;LOAD E WITH A NON-ZERO NUMBER, 177000.
  1242
  1243	031111	200 00 0 00 070261 	A2500:	MOVE	[177000]	;PRESET E WITH 177000, A NON ZERO NUMBER
  1244	031112	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1245						STOP^
  1246	031113	254 04 0 00 031114 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1247	031114	324 00 0 00 031115 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1248									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1249									;IN THE SUBTEST) TO LOOP ON ERROR^
  1250
  1251					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0040

  1252					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1253					;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1254					;LOAD 777, A NON-ZERO NUMBER INTO E.
  1255
  1256	031115	200 00 0 00 070262 	A2600:	MOVE	[777]		;PRESET E WITH 777, A NON-ZERO NUMBER
  1257	031116	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1258						STOP^
  1259	031117	254 04 0 00 031120 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1260	031120	324 00 0 00 031121 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1261									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1262									;IN THE SUBTEST) TO LOOP ON ERROR^
  1263
  1264					;**********
  1265
  1266					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1267					;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1268					;LOAD E WITH 600000, A NON-ZERO NUMBER.
  1269
  1270	031121	200 00 0 00 070263 	A2700:	MOVE	[600000]	;PRESET E WITK 600000, A NON-ZERO NUMBER
  1271	031122	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1272						STOP^
  1273	031123	254 04 0 00 031124 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1274	031124	324 00 0 00 031125 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1275									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1276									;IN THE SUBTEST) TO LOOP ON ERROR^
  1277
  1278					;**********
  1279
  1280					;THIS TEST VERIFIES THAT SKIPN IS DATA DEPENDENT.  HENCE, IT WILL SKIP THE NEXT
  1281					;INSTRUCTION WHEN E CONTAINS A NON-ZERO NUMBER.  THE MOVE INSTRUCTION IS USED TO
  1282					;LOAD E WITH 400000000, A NON-ZERO NUMBER.
  1283
  1284	031125	200 00 0 00 070264 	A3000:	MOVE	[XWD 400,000]	;PRESET E WITH 400000000, A NON-ZERO NUMBER
  1285	031126	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1286						STOP^
  1287	031127	254 04 0 00 031130 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1288	031130	324 00 0 00 031131 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1289									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1290									;IN THE SUBTEST) TO LOOP ON ERROR^
  1291
  1292					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0041

  1293			003100		SN=3100
  1294			000000			ZZ=0
  1295
  1296					A3100:	REPEAT	^D36,
  1297					<;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1298					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1299					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1300					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1301					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1302					
  1303					SN=SN+1
  1304						ZZ=ZZ+ZZ
  1305						IFE	ZZ,<ZZ=1>
  1306						MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1307						SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1308						STOP
  1309					
  1310					;**********
  1311					>
  1312					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1313					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1314					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1315					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1316					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1317
  1318			003101		SN=SN+1
  1319			000000			ZZ=ZZ+ZZ
  1320			000001			IFE	ZZ,<ZZ=1>
  1321	031131	200 00 0 00 070265 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1322	031132	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1323						STOP^
  1324	031133	254 04 0 00 031134 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1325	031134	324 00 0 00 031135 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1326									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1327									;IN THE SUBTEST) TO LOOP ON ERROR^
  1328
  1329					;**********
  1330
  1331					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1332					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1333					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1334					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1335					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1336
  1337			003102		SN=SN+1
  1338			000002			ZZ=ZZ+ZZ
  1339						IFE	ZZ,<ZZ=1>
  1340	031135	200 00 0 00 070266 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1341	031136	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1342						STOP^
  1343	031137	254 04 0 00 031140 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1344	031140	324 00 0 00 031141 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1345									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1346									;IN THE SUBTEST) TO LOOP ON ERROR^
  1347
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0042

  1348					;**********
  1349
  1350					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1351					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1352					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1353					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1354					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1355
  1356			003103		SN=SN+1
  1357			000004			ZZ=ZZ+ZZ
  1358						IFE	ZZ,<ZZ=1>
  1359	031141	200 00 0 00 070267 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1360	031142	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1361						STOP^
  1362	031143	254 04 0 00 031144 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1363	031144	324 00 0 00 031145 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1364									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1365									;IN THE SUBTEST) TO LOOP ON ERROR^
  1366
  1367					;**********
  1368
  1369					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1370					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1371					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1372					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1373					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1374
  1375			003104		SN=SN+1
  1376			000010			ZZ=ZZ+ZZ
  1377						IFE	ZZ,<ZZ=1>
  1378	031145	200 00 0 00 070270 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1379	031146	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1380						STOP^
  1381	031147	254 04 0 00 031150 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1382	031150	324 00 0 00 031151 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1383									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1384									;IN THE SUBTEST) TO LOOP ON ERROR^
  1385
  1386					;**********
  1387
  1388					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1389					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1390					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1391					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1392					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1393
  1394			003105		SN=SN+1
  1395			000020			ZZ=ZZ+ZZ
  1396						IFE	ZZ,<ZZ=1>
  1397	031151	200 00 0 00 070271 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1398	031152	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1399						STOP^
  1400	031153	254 04 0 00 031154 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1401	031154	324 00 0 00 031155 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1402									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0043

  1403									;IN THE SUBTEST) TO LOOP ON ERROR^
  1404
  1405					;**********
  1406
  1407					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1408					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1409					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1410					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1411					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1412
  1413			003106		SN=SN+1
  1414			000040			ZZ=ZZ+ZZ
  1415						IFE	ZZ,<ZZ=1>
  1416	031155	200 00 0 00 070272 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1417	031156	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1418						STOP^
  1419	031157	254 04 0 00 031160 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1420	031160	324 00 0 00 031161 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1421									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1422									;IN THE SUBTEST) TO LOOP ON ERROR^
  1423
  1424					;**********
  1425
  1426					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1427					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1428					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1429					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1430					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1431
  1432			003107		SN=SN+1
  1433			000100			ZZ=ZZ+ZZ
  1434						IFE	ZZ,<ZZ=1>
  1435	031161	200 00 0 00 070273 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1436	031162	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1437						STOP^
  1438	031163	254 04 0 00 031164 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1439	031164	324 00 0 00 031165 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1440									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1441									;IN THE SUBTEST) TO LOOP ON ERROR^
  1442
  1443					;**********
  1444
  1445					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1446					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1447					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1448					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1449					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1450
  1451			003110		SN=SN+1
  1452			000200			ZZ=ZZ+ZZ
  1453						IFE	ZZ,<ZZ=1>
  1454	031165	200 00 0 00 070274 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1455	031166	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1456						STOP^
  1457	031167	254 04 0 00 031170 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0044

  1458	031170	324 00 0 00 031171 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1459									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1460									;IN THE SUBTEST) TO LOOP ON ERROR^
  1461
  1462					;**********
  1463
  1464					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1465					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1466					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1467					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1468					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1469
  1470			003111		SN=SN+1
  1471			000400			ZZ=ZZ+ZZ
  1472						IFE	ZZ,<ZZ=1>
  1473	031171	200 00 0 00 070275 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1474	031172	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1475						STOP^
  1476	031173	254 04 0 00 031174 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1477	031174	324 00 0 00 031175 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1478									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1479									;IN THE SUBTEST) TO LOOP ON ERROR^
  1480
  1481					;**********
  1482
  1483					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1484					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1485					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1486					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1487					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1488
  1489			003112		SN=SN+1
  1490			001000			ZZ=ZZ+ZZ
  1491						IFE	ZZ,<ZZ=1>
  1492	031175	200 00 0 00 070276 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1493	031176	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1494						STOP^
  1495	031177	254 04 0 00 031200 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1496	031200	324 00 0 00 031201 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1497									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1498									;IN THE SUBTEST) TO LOOP ON ERROR^
  1499
  1500					;**********
  1501
  1502					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1503					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1504					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1505					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1506					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1507
  1508			003113		SN=SN+1
  1509			002000			ZZ=ZZ+ZZ
  1510						IFE	ZZ,<ZZ=1>
  1511	031201	200 00 0 00 070277 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1512	031202	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0045

  1513						STOP^
  1514	031203	254 04 0 00 031204 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1515	031204	324 00 0 00 031205 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1516									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1517									;IN THE SUBTEST) TO LOOP ON ERROR^
  1518
  1519					;**********
  1520
  1521					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1522					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1523					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1524					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1525					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1526
  1527			003114		SN=SN+1
  1528			004000			ZZ=ZZ+ZZ
  1529						IFE	ZZ,<ZZ=1>
  1530	031205	200 00 0 00 070300 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1531	031206	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1532						STOP^
  1533	031207	254 04 0 00 031210 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1534	031210	324 00 0 00 031211 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1535									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1536									;IN THE SUBTEST) TO LOOP ON ERROR^
  1537
  1538					;**********
  1539
  1540					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1541					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1542					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1543					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1544					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1545
  1546			003115		SN=SN+1
  1547			010000			ZZ=ZZ+ZZ
  1548						IFE	ZZ,<ZZ=1>
  1549	031211	200 00 0 00 070301 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1550	031212	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1551						STOP^
  1552	031213	254 04 0 00 031214 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1553	031214	324 00 0 00 031215 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1554									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1555									;IN THE SUBTEST) TO LOOP ON ERROR^
  1556
  1557					;**********
  1558
  1559					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1560					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1561					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1562					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1563					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1564
  1565			003116		SN=SN+1
  1566			020000			ZZ=ZZ+ZZ
  1567						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0046

  1568	031215	200 00 0 00 070302 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1569	031216	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1570						STOP^
  1571	031217	254 04 0 00 031220 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1572	031220	324 00 0 00 031221 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1573									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1574									;IN THE SUBTEST) TO LOOP ON ERROR^
  1575
  1576					;**********
  1577
  1578					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1579					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1580					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1581					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1582					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1583
  1584			003117		SN=SN+1
  1585			040000			ZZ=ZZ+ZZ
  1586						IFE	ZZ,<ZZ=1>
  1587	031221	200 00 0 00 070303 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1588	031222	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1589						STOP^
  1590	031223	254 04 0 00 031224 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1591	031224	324 00 0 00 031225 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1592									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1593									;IN THE SUBTEST) TO LOOP ON ERROR^
  1594
  1595					;**********
  1596
  1597					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1598					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1599					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1600					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1601					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1602
  1603			003120		SN=SN+1
  1604			100000			ZZ=ZZ+ZZ
  1605						IFE	ZZ,<ZZ=1>
  1606	031225	200 00 0 00 070304 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1607	031226	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1608						STOP^
  1609	031227	254 04 0 00 031230 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1610	031230	324 00 0 00 031231 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1611									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1612									;IN THE SUBTEST) TO LOOP ON ERROR^
  1613
  1614					;**********
  1615
  1616					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1617					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1618					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1619					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1620					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1621
  1622			003121		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0047

  1623			200000			ZZ=ZZ+ZZ
  1624						IFE	ZZ,<ZZ=1>
  1625	031231	200 00 0 00 070305 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1626	031232	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1627						STOP^
  1628	031233	254 04 0 00 031234 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1629	031234	324 00 0 00 031235 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1630									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1631									;IN THE SUBTEST) TO LOOP ON ERROR^
  1632
  1633					;**********
  1634
  1635					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1636					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1637					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1638					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1639					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1640
  1641			003122		SN=SN+1
  1642			400000			ZZ=ZZ+ZZ
  1643						IFE	ZZ,<ZZ=1>
  1644	031235	200 00 0 00 070306 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1645	031236	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1646						STOP^
  1647	031237	254 04 0 00 031240 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1648	031240	324 00 0 00 031241 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1649									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1650									;IN THE SUBTEST) TO LOOP ON ERROR^
  1651
  1652					;**********
  1653
  1654					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1655					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1656					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1657					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1658					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1659
  1660			003123		SN=SN+1
  1661		000001	000000			ZZ=ZZ+ZZ
  1662						IFE	ZZ,<ZZ=1>
  1663	031241	200 00 0 00 070307 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1664	031242	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1665						STOP^
  1666	031243	254 04 0 00 031244 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1667	031244	324 00 0 00 031245 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1668									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1669									;IN THE SUBTEST) TO LOOP ON ERROR^
  1670
  1671					;**********
  1672
  1673					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1674					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1675					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1676					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1677					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0048

  1678
  1679			003124		SN=SN+1
  1680		000002	000000			ZZ=ZZ+ZZ
  1681						IFE	ZZ,<ZZ=1>
  1682	031245	200 00 0 00 070310 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1683	031246	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1684						STOP^
  1685	031247	254 04 0 00 031250 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1686	031250	324 00 0 00 031251 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1687									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1688									;IN THE SUBTEST) TO LOOP ON ERROR^
  1689
  1690					;**********
  1691
  1692					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1693					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1694					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1695					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1696					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1697
  1698			003125		SN=SN+1
  1699		000004	000000			ZZ=ZZ+ZZ
  1700						IFE	ZZ,<ZZ=1>
  1701	031251	200 00 0 00 070311 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1702	031252	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1703						STOP^
  1704	031253	254 04 0 00 031254 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1705	031254	324 00 0 00 031255 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1706									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1707									;IN THE SUBTEST) TO LOOP ON ERROR^
  1708
  1709					;**********
  1710
  1711					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1712					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1713					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1714					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1715					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1716
  1717			003126		SN=SN+1
  1718		000010	000000			ZZ=ZZ+ZZ
  1719						IFE	ZZ,<ZZ=1>
  1720	031255	200 00 0 00 070312 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1721	031256	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1722						STOP^
  1723	031257	254 04 0 00 031260 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1724	031260	324 00 0 00 031261 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1725									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1726									;IN THE SUBTEST) TO LOOP ON ERROR^
  1727
  1728					;**********
  1729
  1730					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1731					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1732					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0049

  1733					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1734					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1735
  1736			003127		SN=SN+1
  1737		000020	000000			ZZ=ZZ+ZZ
  1738						IFE	ZZ,<ZZ=1>
  1739	031261	200 00 0 00 070313 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1740	031262	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1741						STOP^
  1742	031263	254 04 0 00 031264 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1743	031264	324 00 0 00 031265 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1744									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1745									;IN THE SUBTEST) TO LOOP ON ERROR^
  1746
  1747					;**********
  1748
  1749					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1750					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1751					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1752					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1753					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1754
  1755			003130		SN=SN+1
  1756		000040	000000			ZZ=ZZ+ZZ
  1757						IFE	ZZ,<ZZ=1>
  1758	031265	200 00 0 00 070314 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1759	031266	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1760						STOP^
  1761	031267	254 04 0 00 031270 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1762	031270	324 00 0 00 031271 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1763									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1764									;IN THE SUBTEST) TO LOOP ON ERROR^
  1765
  1766					;**********
  1767
  1768					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1769					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1770					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1771					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1772					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1773
  1774			003131		SN=SN+1
  1775		000100	000000			ZZ=ZZ+ZZ
  1776						IFE	ZZ,<ZZ=1>
  1777	031271	200 00 0 00 070315 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1778	031272	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1779						STOP^
  1780	031273	254 04 0 00 031274 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1781	031274	324 00 0 00 031275 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1782									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1783									;IN THE SUBTEST) TO LOOP ON ERROR^
  1784
  1785					;**********
  1786
  1787					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0050

  1788					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1789					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1790					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1791					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1792
  1793			003132		SN=SN+1
  1794		000200	000000			ZZ=ZZ+ZZ
  1795						IFE	ZZ,<ZZ=1>
  1796	031275	200 00 0 00 070316 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1797	031276	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1798						STOP^
  1799	031277	254 04 0 00 031300 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1800	031300	324 00 0 00 031301 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1801									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1802									;IN THE SUBTEST) TO LOOP ON ERROR^
  1803
  1804					;**********
  1805
  1806					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1807					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1808					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1809					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1810					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1811
  1812			003133		SN=SN+1
  1813		000400	000000			ZZ=ZZ+ZZ
  1814						IFE	ZZ,<ZZ=1>
  1815	031301	200 00 0 00 070264 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1816	031302	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1817						STOP^
  1818	031303	254 04 0 00 031304 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1819	031304	324 00 0 00 031305 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1820									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1821									;IN THE SUBTEST) TO LOOP ON ERROR^
  1822
  1823					;**********
  1824
  1825					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1826					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1827					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1828					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1829					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1830
  1831			003134		SN=SN+1
  1832		001000	000000			ZZ=ZZ+ZZ
  1833						IFE	ZZ,<ZZ=1>
  1834	031305	200 00 0 00 070317 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1835	031306	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1836						STOP^
  1837	031307	254 04 0 00 031310 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1838	031310	324 00 0 00 031311 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1839									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1840									;IN THE SUBTEST) TO LOOP ON ERROR^
  1841
  1842					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0051

  1843
  1844					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1845					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1846					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1847					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1848					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1849
  1850			003135		SN=SN+1
  1851		002000	000000			ZZ=ZZ+ZZ
  1852						IFE	ZZ,<ZZ=1>
  1853	031311	200 00 0 00 070320 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1854	031312	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1855						STOP^
  1856	031313	254 04 0 00 031314 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1857	031314	324 00 0 00 031315 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1858									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1859									;IN THE SUBTEST) TO LOOP ON ERROR^
  1860
  1861					;**********
  1862
  1863					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1864					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1865					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1866					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1867					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1868
  1869			003136		SN=SN+1
  1870		004000	000000			ZZ=ZZ+ZZ
  1871						IFE	ZZ,<ZZ=1>
  1872	031315	200 00 0 00 070321 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1873	031316	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1874						STOP^
  1875	031317	254 04 0 00 031320 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1876	031320	324 00 0 00 031321 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1877									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1878									;IN THE SUBTEST) TO LOOP ON ERROR^
  1879
  1880					;**********
  1881
  1882					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1883					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1884					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1885					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1886					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1887
  1888			003137		SN=SN+1
  1889		010000	000000			ZZ=ZZ+ZZ
  1890						IFE	ZZ,<ZZ=1>
  1891	031321	200 00 0 00 070322 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1892	031322	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1893						STOP^
  1894	031323	254 04 0 00 031324 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1895	031324	324 00 0 00 031325 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1896									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1897									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0052

  1898
  1899					;**********
  1900
  1901					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1902					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1903					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1904					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1905					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1906
  1907			003140		SN=SN+1
  1908		020000	000000			ZZ=ZZ+ZZ
  1909						IFE	ZZ,<ZZ=1>
  1910	031325	200 00 0 00 070323 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1911	031326	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1912						STOP^
  1913	031327	254 04 0 00 031330 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1914	031330	324 00 0 00 031331 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1915									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1916									;IN THE SUBTEST) TO LOOP ON ERROR^
  1917
  1918					;**********
  1919
  1920					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1921					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1922					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1923					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1924					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1925
  1926			003141		SN=SN+1
  1927		040000	000000			ZZ=ZZ+ZZ
  1928						IFE	ZZ,<ZZ=1>
  1929	031331	200 00 0 00 070324 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1930	031332	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1931						STOP^
  1932	031333	254 04 0 00 031334 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1933	031334	324 00 0 00 031335 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1934									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1935									;IN THE SUBTEST) TO LOOP ON ERROR^
  1936
  1937					;**********
  1938
  1939					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1940					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1941					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1942					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1943					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1944
  1945			003142		SN=SN+1
  1946		100000	000000			ZZ=ZZ+ZZ
  1947						IFE	ZZ,<ZZ=1>
  1948	031335	200 00 0 00 070325 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1949	031336	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1950						STOP^
  1951	031337	254 04 0 00 031340 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1952	031340	324 00 0 00 031341 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF JUMP, JUMPA AND SKIPX INSTRUCTIONS                                         SEQ 0053

  1953									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1954									;IN THE SUBTEST) TO LOOP ON ERROR^
  1955
  1956					;**********
  1957
  1958					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1959					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1960					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1961					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1962					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1963
  1964			003143		SN=SN+1
  1965		200000	000000			ZZ=ZZ+ZZ
  1966						IFE	ZZ,<ZZ=1>
  1967	031341	200 00 0 00 070326 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1968	031342	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1969						STOP^
  1970	031343	254 04 0 00 031344 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1971	031344	324 00 0 00 031345 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1972									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1973									;IN THE SUBTEST) TO LOOP ON ERROR^
  1974
  1975					;**********
  1976
  1977					;THIS TEST VERIFIES THAT SKIPN IS SENSITIVE TO A ONE IN EVERY BIT POSITION.  THIS TEST
  1978					;IS REPEATED 36 TIMES.  EACH TIME A WORD OF ALL ZEROS EXCEPT FOR A ONE IN ONE
  1979					;BIT POSITION IS MOVED INTO E.  THEN SKIPN IS EXECUTED.  THIS TEST ALSO
  1980					;CHECKS ADDER GATING.  IF THIS TEST FAILS, CHECK C(E).
  1981					;IF C(E)=0, MOVE FAILED; OTHERWISE SKIPN FAILED.
  1982
  1983			003144		SN=SN+1
  1984		400000	000000			ZZ=ZZ+ZZ
  1985						IFE	ZZ,<ZZ=1>
  1986	031345	200 00 0 00 070256 		MOVE	[ZZ]		;MOVE THE CURRENT VALUE OF ZZ INTO E. ZZ IS NON-ZERO
  1987	031346	336 00 0 00 000000 		SKIPN			;*SKIPN SHOULD SKIP THE NEXT INSTRUCTION
  1988						STOP^
  1989	031347	254 04 0 00 031350 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  1990	031350	324 00 0 00 031351 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  1991									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  1992									;IN THE SUBTEST) TO LOOP ON ERROR^
  1993
  1994					;**********
  1995
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0054

  1996					SUBTTL	TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS
  1997
  1998					;THIS TEST VERIFIES THAT MOVEI LOADS E INTO THE AC.  SKIPG IS USED TO CHECK THAT
  1999					;THE AC WAS INDEED MODIFIED BY MOVEI.
  2000
  2001	031351	201 00 0 00 070254 	A3200:	MOVEI	[-1]		;*MOVEI SHOULD LOAD A POSITIVE NUMBER INTO AC0
  2002	031352	337 00 0 00 000000 		SKIPG			;SKIP HALT INSTRUCTION IF MOVEI LOADED AC CORRECTLY
  2003						STOP^
  2004	031353	254 04 0 00 031354 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2005	031354	324 00 0 00 031355 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2006									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2007									;IN THE SUBTEST) TO LOOP ON ERROR^
  2008
  2009					;IF PROGRAM HANGS UP ON MOVEI INSTRUCTION, CHECK AD FM +EN [ADFP], AD FM + EN A [ADFP],
  2010					;AD FM + F/F [ADFP], F CYC ACT EN C [F1]
  2011
  2012					;**********
  2013
  2014					;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE DATA IN E AND NOT SENSITIVE TO
  2015					;THE DATA IN THE AC.  HENCE, SKIPL WILL SKIP THE NEXT INSTRUCTION ONLY IF
  2016					;C(E) IS LESS THAN ZERO.  E IS SET TO -1, A NEGATIVE NUMBER; AND
  2017					;THE AC IS SET TO 0 IN THIS TEST.  THEREFORE SKIPL SHOULD SKIP.
  2018
  2019	031355	200 00 0 00 070253 	A3300:	MOVE	[0]		;SET THE AC TO ALL ZEROS
  2020	031356	331 00 0 00 070254 		SKIPL	[-1]		;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
  2021						STOP^
  2022	031357	254 04 0 00 031360 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2023	031360	324 00 0 00 031361 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2024									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2025									;IN THE SUBTEST) TO LOOP ON ERROR^
  2026
  2027					;**********
  2028
  2029					;THIS TEST VERIFIES THAT SKIPL IS SENSITIVE TO THE SIGN BIT IN E.  SKIPL SHOULD
  2030					;SKIP THE NEXT INSTRUCTION WHEN AND ONLY WHEN THE SIGN BIT IS SET.  IN THIS
  2031					;TEST, C(AC) IS PRESET TO ALL ZEROS, THEN SKIPL IS EXECUTED WITH C(E)=400000,,0.
  2032					;A FAILURE UCCURS IF SKIPL DOES NOT SKIP.
  2033
  2034	031361	200 00 0 00 070253 	A13100:	MOVE	[0]		;SET THE AC TO ALL ZEROS
  2035	031362	331 00 0 00 070256 		SKIPL	[400000,,0]	;*SKIPL SHOULD SKIP BECAUSE C(E) IS NEGATIVE
  2036						STOP^
  2037	031363	254 04 0 00 031364 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2038	031364	324 00 0 00 031365 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2039									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2040									;IN THE SUBTEST) TO LOOP ON ERROR^
  2041
  2042					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0055

  2043					;THIS TEST VERIFIES THAT THE CAM INSTRUCTION DOES NOT MODIFY C(AC).  THE AC IS
  2044					;INITIALLY LOADED WITH ALL ZEROS; THEN CAM IS EXECUTED WITH C(E) NON-ZERO.
  2045					;THE AC IS THEN CHECKED FOR ALL ZEROS.  THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.
  2046
  2047	031365	200 00 0 00 070253 	A3400:	MOVE	[0]		;PRESET THE AC TO ALL ZEROS
  2048	031366	310 00 0 00 070327 		CAM	[1234]		;*CAM SHOULD NOT MODIFY THE AC
  2049	031367	200 00 0 00 000000 		MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION SERVES AS A NO-OP.
  2050									;IT IS A PROGRAM FILLER IN CASE CAM SKIPS.)
  2051	031370	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF AC WAS NOT MODIFIED BY CAM
  2052						STOP^
  2053	031371	254 04 0 00 031372 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2054	031372	324 00 0 00 031373 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2055									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2056									;IN THE SUBTEST) TO LOOP ON ERROR^
  2057
  2058					;IF TEST HANGS ON CAM INSTRUCTION, AB PC EN [ABC], AB PC (FETCH) EN [ABC],
  2059					;IR CAXX [IR3]
  2060
  2061					;IF TEST LOOPS ON CAM INSTRUCTION, MC INSTR FETCH EN [MC1], MC INST FET ET2 EN [MC1],
  2062					;ET2 J F/F [E], IR CAXX [IR3]
  2063
  2064					;IF TEST HALTS AT HALT INSTRUCTION, SAC INH [ST2], IR CAXX [IR3], IR CAMX [IR1]
  2065
  2066					;**********
  2067
  2068					;THIS TEST VERIFIES THAT THE CAI INSTRUCTION DOES NOT MODIFY C(AC).  THE AC IS
  2069					;INITIALLY LOADED WITH ALL ZEROS; THEN CAI IS EXECUTED WITH E NON-ZERO.  THE AC IS
  2070					;THEN CHECKED FOR ALL ZEROS.  THIS TEST FAILS IF THE AC WAS MODIFIED BY CAM.
  2071
  2072	031373	200 00 0 00 070253 	A3500:	MOVE	[0]		;PRESET THE AC TO ALL ZEROS
  2073	031374	300 00 0 00 070327 		CAI	[1234]		;*CAI SHOULD NOT MODIFY THE AC
  2074	031375	200 00 0 00 000000 		MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A PROGRAM FILLER
  2075									;IN CASE CAI MODIFIES THE AC.  IT SERVES AS A NO-OP)
  2076	031376	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF CAI DID NOT MODIFY THE AC
  2077						STOP^
  2078	031377	254 04 0 00 031400 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2079	031400	324 00 0 00 031401 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2080									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2081									;IN THE SUBTEST) TO LOOP ON ERROR^
  2082
  2083					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 15
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0056

  2084					;THIS TEST VERIFIES THAT CAI DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
  2085					;SPECIFIED BY THE CAI INSTRUCTION.
  2086					;THIS IS THE FIRST TEST THAT USES AN AC OTHER THAN AC0.
  2087					;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAI INSTRUCTION IS EXECUTED WITH
  2088					;A NON-ZERO E.  AC 0 IS THEN TESTED F0R ALL ZEROS.
  2089
  2090	031401	200 00 0 00 070253 	A3600:	MOVE	[0]		;LOAD AC0 WITH ALL ZEROS
  2091	031402	300 17 0 00 070327 		CAI	17,[1234]	;*CAI SHOULD NOT MODIFY AC0
  2092	031403	200 00 0 00 000000 		MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
  2093									;CAI SKIPS THE NEXT INSTRUCTION.  IT ACTS AS A NO-OP)
  2094	031404	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
  2095						STOP^
  2096	031405	254 04 0 00 031406 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2097	031406	324 00 0 00 031407 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2098									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2099									;IN THE SUBTEST) TO LOOP ON ERROR^
  2100
  2101					;**********
  2102
  2103					;THIS TEST VERIFIES THAT CAM DOES NOT MODIFY C(AC0) WHEN AN AC OTHER THAN AC0 IS
  2104					;SPECIFIED BY THE CAM INSTRUCTION.
  2105					;FIRST, AC0 IS LOADED WITH ALL ZEROS; THEN, THE CAM INSTRUCTION IS EXECUTED WITH
  2106					;A NON-ZERO E.  AC 0 IS THEN TESTED F0R ALL ZEROS.
  2107
  2108	031407	200 00 0 00 070253 	A3700:	MOVE	[0]		;PRESET C(AC0) TO ALL ZEROS
  2109	031410	310 17 0 00 070327 		CAM	17,[1234]	;*CAM SHOULD NOT MODIFY AC0
  2110	031411	200 00 0 00 000000 		MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
  2111									;CAM SKIPS THE NEXT INSTRUCTION.  IT SERVES AS A NO-OP)
  2112	031412	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY CAM
  2113						STOP^
  2114	031413	254 04 0 00 031414 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2115	031414	324 00 0 00 031415 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2116									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2117									;IN THE SUBTEST) TO LOOP ON ERROR^
  2118
  2119					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 16
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0057

  2120					;THIS TEST VERIFIES THAT MOVE WILL PLACE C(E) INTO THE AC.  AC, E AND C(E) ARE NON-ZERO
  2121					;IN THIS TEST.  THIS TEST PASSES IF  FINAL C(AC) OF THE MOVE INSTRUCTION IS NON-ZERO.
  2122
  2123	031415	200 01 0 00 070253 	A4500:	MOVE	1,[0]		;LOAD THE AC WITH ALL ZEROS
  2124	031416	200 01 0 00 070254 		MOVE	1,[-1]		;*MOVE SHOULD PLACE ALL ONES IN THE AC
  2125	031417	336 00 0 00 000001 		SKIPN	1		;SKIP HALT INSTRUCTION IF MOVE MODIFIED THE AC
  2126						STOP^
  2127	031420	254 04 0 00 031421 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2128	031421	324 00 0 00 031422 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2129									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2130									;IN THE SUBTEST) TO LOOP ON ERROR^
  2131
  2132					;**********
  2133
  2134					;THIS TEST VERIFIES THAT THE MOVE INSTRUCTION WILL PLACE C(E) INTO THE AC.
  2135					;AC, E ARE NON-ZERO AND C(E)=0.
  2136					;THIS TEST FAILS IF THE FINAL C(AC) IS NOT EQUAL TO ZERO, THE ORIGINAL C(E)
  2137
  2138	031422	200 01 0 00 070253 	A4600:	MOVE	1,[0]		;*PLACE ALL ZEROS INTO THE AC
  2139	031423	332 00 0 00 000001 		SKIPE	1		;SKIP HALT INSTRUCTION IF MOVE PLACED ALL ZEROS INTO AC
  2140						STOP^
  2141	031424	254 04 0 00 031425 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2142	031425	324 00 0 00 031426 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2143									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2144									;IN THE SUBTEST) TO LOOP ON ERROR^
  2145
  2146					;IF JUMP .+1 OF PREVIOUS TEST FAILED, CHECK JUMPS: AD FM + EN [ADFP], IR JUMPS [IR1],
  2147					;IR JUMPX [IR1], AR AD EN [ARMA], AR AD EN A [ARMA], AR LT AD EN A [ARMA],
  2148					;AR LT ADD EN B [ARMA], AR RT AD EN A [ARMA],
  2149					;AR RT AD EN B [ARMA], AR A CLK INPUT [ARMA],
  2150					;ET2 C F/F [E], AR AD ET2 EN [ARMA], AR AD BR (ET2) B [ARMA]
  2151
  2152					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 17
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0058

  2153					;THIS TEST VERIFIES THAT SOS DOES NOT MODIFY C(AC) WHEN THE AC IS AC0.
  2154					;FIRST, AC0 IS LOADED WITH ALL ZEROS AND E IS LOADED WITH A POSITIVE NUMBER;
  2155					;THEN, SOS IS EXECUTED.  SOS SHOULD SUBTRACT ONE FROM C((E)
  2156					;AND EXECUTE THE NEXT INSTRUCTION.  IT SHOULD NOT MODIFY AC0.
  2157					;THE TEST PASSES IF AC0 WAS NOT MODIFIED.
  2158
  2159	031426	200 00 0 00 070253 	A4000:	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
  2160	031427	200 07 0 00 070327 		MOVE	7,[1234]	;PRESET E WITH A POSITIVE NUMBER
  2161	031430	370 00 0 00 000007 		SOS	7		;*SOS SHOULD NOT MODIFY C(AC0)
  2162	031431	200 00 0 00 000000 		MOVE			;MOVE C(0) INTO 0 (THIS INSTRUCTION IS A FILLER IN CASE
  2163									;SOS SKIPS THE NEXT INSTRUCTION.  IT SERVES AS A NO-OP)
  2164	031432	332 00 0 00 000000 		SKIPE			;SKIP THE HALT INSTRUCTION IF C(AC0) WAS NOT MODIFIED
  2165						STOP^
  2166	031433	254 04 0 00 031434 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2167	031434	324 00 0 00 031435 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2168									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2169									;IN THE SUBTEST) TO LOOP ON ERROR^
  2170
  2171					;**********
  2172			004100		SN=4100
  2173			000000			AC=0
  2174
  2175					A4100:	REPEAT	4,		
  2176					<;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
  2177					;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
  2178					;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
  2179					;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
  2180					;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
  2181					;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
  2182					;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
  2183					
  2184					SN=SN+1
  2185						AC=AC+AC
  2186						IFE	AC,<AC=1>
  2187						MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
  2188						MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
  2189						SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
  2190						SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
  2191						STOP
  2192						SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
  2193						STOP
  2194					
  2195					;**********
  2196					>
  2197					;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
  2198					;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
  2199					;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
  2200					;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
  2201					;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
  2202					;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
  2203					;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
  2204
  2205			004101		SN=SN+1
  2206			000000			AC=AC+AC
  2207			000001			IFE	AC,<AC=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 17-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0059

  2208	031435	200 00 0 00 070253 		MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
  2209	031436	200 01 0 00 070253 		MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
  2210	031437	330 01 0 00 070254 		SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
  2211	031440	336 00 0 00 000001 		SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
  2212						STOP^
  2213	031441	254 04 0 00 031442 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2214	031442	324 00 0 00 031443 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2215									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2216									;IN THE SUBTEST) TO LOOP ON ERROR^
  2217	031443	332 00 0 00 000000 		SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
  2218						STOP^
  2219	031444	254 04 0 00 031445 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2220	031445	324 00 0 00 031446 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2221									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2222									;IN THE SUBTEST) TO LOOP ON ERROR^
  2223
  2224					;**********
  2225
  2226					;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
  2227					;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
  2228					;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
  2229					;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
  2230					;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
  2231					;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
  2232					;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
  2233
  2234			004102		SN=SN+1
  2235			000002			AC=AC+AC
  2236						IFE	AC,<AC=1>
  2237	031446	200 00 0 00 070253 		MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
  2238	031447	200 02 0 00 070253 		MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
  2239	031450	330 02 0 00 070254 		SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
  2240	031451	336 00 0 00 000002 		SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
  2241						STOP^
  2242	031452	254 04 0 00 031453 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2243	031453	324 00 0 00 031454 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2244									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2245									;IN THE SUBTEST) TO LOOP ON ERROR^
  2246	031454	332 00 0 00 000000 		SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
  2247						STOP^
  2248	031455	254 04 0 00 031456 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2249	031456	324 00 0 00 031457 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2250									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2251									;IN THE SUBTEST) TO LOOP ON ERROR^
  2252
  2253					;**********
  2254
  2255					;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
  2256					;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
  2257					;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
  2258					;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
  2259					;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
  2260					;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
  2261					;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
  2262
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 17-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF MOVE, SKIP AND COMPARE INSTRUCTIONS                                        SEQ 0060

  2263			004103		SN=SN+1
  2264			000004			AC=AC+AC
  2265						IFE	AC,<AC=1>
  2266	031457	200 00 0 00 070253 		MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
  2267	031460	200 04 0 00 070253 		MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
  2268	031461	330 04 0 00 070254 		SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
  2269	031462	336 00 0 00 000004 		SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
  2270						STOP^
  2271	031463	254 04 0 00 031464 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2272	031464	324 00 0 00 031465 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2273									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2274									;IN THE SUBTEST) TO LOOP ON ERROR^
  2275	031465	332 00 0 00 000000 		SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
  2276						STOP^
  2277	031466	254 04 0 00 031467 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2278	031467	324 00 0 00 031470 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2279									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2280									;IN THE SUBTEST) TO LOOP ON ERROR^
  2281
  2282					;**********
  2283
  2284					;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL PLACE THE CONTENTS OF E INTO THE AC
  2285					;WHEN THE AC IS NOT AC0. THIS TEST IS PERFORMED FOR AC1, AC2, AC4 AND AC10.
  2286					;FIRST, THE AC IS LOADED WITH ALL ZEROS;  THEN, THE SKIP INSTRUCTION IS EXECUTED
  2287					;WITH AC1, AC2, AC4 OR AC10.  C(E) IS EQUAL TO -1.  THE SKIP INSTRUCTION SHOULD CAUSE
  2288					;THE AC TO CONTAIN -1.  THE AC IS THEN CHECKED FOR
  2289					;NON-ZERO CONTENTS.  THE TEST FAILS IF C(AC)=0.
  2290					;THIS TEST ALSO VERIFIES THAT 'SKIP AC,[-1]' DOES NOT CLOBBER AC0.
  2291
  2292			004104		SN=SN+1
  2293			000010			AC=AC+AC
  2294						IFE	AC,<AC=1>
  2295	031470	200 00 0 00 070253 		MOVE	0,[0]		;PRESET AC0 TO ALL ZEROS
  2296	031471	200 10 0 00 070253 		MOVE	AC,[0]		;PRESET THE AC TO ALL ZEROS
  2297	031472	330 10 0 00 070254 		SKIP	AC,[-1]		;*SKIP SHOULD PLACE -1 INTO THE AC
  2298	031473	336 00 0 00 000010 		SKIPN	AC		;SKIP THE HALT INSTRUCTION IF THE AC IS NON-ZERO
  2299						STOP^
  2300	031474	254 04 0 00 031475 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2301	031475	324 00 0 00 031476 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2302									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2303									;IN THE SUBTEST) TO LOOP ON ERROR^
  2304	031476	332 00 0 00 000000 		SKIPE	0		;VERIFY THAT AC0 DID NOT GET CLOBBERED BY SKIP
  2305						STOP^
  2306	031477	254 04 0 00 031500 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2307	031500	324 00 0 00 031501 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2308									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2309									;IN THE SUBTEST) TO LOOP ON ERROR^
  2310
  2311					;**********
  2312
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 18
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0061

  2313					SUBTTL	TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS
  2314
  2315					;THIS TEST VERIFIES THAT THE SKIP INSTRUCTION WILL NOT MODIFY THE CONTENTS OF AC0.
  2316					;FIRST, AC0 IS LOADED WITH ALL ZEROS;  THEN,
  2317					;THE SKIP INSTRUCTION IS EXECUTED WITH C(E)=-1 AND AC0.  AC0 IS THEN TESTED FOR ALL
  2318					;ZEROS.  THE TEST FAILS IF AC0 WAS MODIFIED BY THE SKIP INSTRUCTION.
  2319
  2320	031501	200 00 0 00 070253 	A4200:	MOVE	[0]		;PRESET AC0 TO ALL ZEROS
  2321	031502	330 00 0 00 070254 		SKIP	[-1]		;*SKIP SHOULD NOT MODIFY AC0
  2322	031503	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS NOT MODIFIED BY SKIP
  2323						STOP^
  2324	031504	254 04 0 00 031505 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2325	031505	324 00 0 00 031506 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2326									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2327									;IN THE SUBTEST) TO LOOP ON ERROR^
  2328
  2329					;AC=0: SAC INH, IR BIT 9, 10, 11 OR 12 S-A-1
  2330
  2331					;**********
  2332
  2333					;THIS TEST VERIFIES THAT MOVSS DOES NOT MODIFY C(AC0) WHEN AC0 IS SPECIFIED AS THE AC.
  2334					;FIRST, E IS LOADED WITH ALL ONES AND THE AC (AC0)
  2335					;IS LOADED WITH ALL ZEROS; THEN, MOVSS IS EXECUTED.  MOVSS SHOULD NOT MODIFY AC0.
  2336					;AC0 IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED BY MOVSS.
  2337
  2338	031506	200 07 0 00 070254 	A4300:	MOVE	7,[-1]		;LOAD E OF THE MOVSS INSTRUCTION WITH ALL ONES
  2339	031507	200 00 0 00 070253 		MOVE	[0]		;PRESET AC0 TO ALL ZEROS
  2340	031510	207 00 0 00 000007 		MOVSS	7		;*MOVSS SHOULD NOT MODIFY AC0
  2341	031511	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF AC0 WAS INTACT
  2342						STOP^
  2343	031512	254 04 0 00 031513 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2344	031513	324 00 0 00 031514 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2345									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2346									;IN THE SUBTEST) TO LOOP ON ERROR^
  2347
  2348					;MOVX & AC=0: SAC INH [ST2], IR XXXS [IR1]
  2349
  2350					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 19
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0062

  2351					;THIS TEST VERIFIES THAT HRRS DOES NOT MODIFY C(AC0) WHEN AC0 IS THE SPECIFIED AC.
  2352					;FIRST, E IS LOADED WITH ALL ONES AND AC0 IS LOADED WITH ALL ZEROS;
  2353					;THEN, HRRS IS EXECUTED WITH AC=AC0.  AC0 IS THEN CHECKED FOR ALL ZEROS.
  2354					;IF AC0 WAS MODIFIED BY THE HRRS INSTRUCTION, THE TEST FAIL.
  2355
  2356	031514	200 07 0 00 070254 	A4400:	MOVE	7,[-1]		;PRESET E OF THE HRRS INSTRUCTION TO ALL ONES
  2357	031515	200 00 0 00 070253 		MOVE	[0]		;PRESET AC0 TO ALL ZEROS
  2358	031516	543 00 0 00 000007 		HRRS	7		;*HRRS SHOULD NOT MODIFY THE AC WHEN THE AC IS AC0
  2359	031517	332 00 0 00 000000 		SKIPE			;SKIP THE HALT INSTRUCTION IF AC0 WAS INTACT
  2360						STOP^
  2361	031520	254 04 0 00 031521 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2362	031521	324 00 0 00 031522 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2363									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2364									;IN THE SUBTEST) TO LOOP ON ERROR^
  2365
  2366					;(HXXXS&AC=0): SAC INH [ST2], IR HWTFWT [IR3], IR XXXS [IR1], IR HWT [IR1],
  2367					;IR BITS S-A-1
  2368
  2369					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 20
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0063

  2370					;THIS TEST VERIFIES THAT THE JUMP INSTRUCTION DOES NOT MODIFY C(AC).
  2371					;THE AC IS FIRST LOADED WITH ALL ZEROS;
  2372					;THEN JUMP .+1 IS EXECUTED.  THE AC IS THEN CHECKED TO INSURE THAT IT WAS NOT MODIFIED
  2373					;BY JUMP.  THE TEST FAILS IF THE AC WAS MODIFIED
  2374
  2375	031522	200 00 0 00 070253 	A4700:	MOVE	[0]		; PRESET THE AC TO ALL ZEROS
  2376	031523	320 00 0 00 031524 		JUMP	.+1		;*JUMP SHOULD NOT MODIFY THE AC
  2377	031524	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF AC WAS INTACT
  2378						STOP^
  2379	031525	254 04 0 00 031526 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2380	031526	324 00 0 00 031527 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2381									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2382									;IN THE SUBTEST) TO LOOP ON ERROR^
  2383
  2384					;**********
  2385
  2386					;THIS TEST VERIFIES THAT MOVS WILL NOT PICK UP ANY ONES WHEN SWAPPING A WORD
  2387					;OF ALL ZEROS.  FIRST, E IS LOADED WITH A WORD OF ALL ZEROS;
  2388					;THEN, MOVS IS EXECUTED.  THE AC IS THEN CHECKED TO INSURE THAT THE RESULT DOES NOT
  2389					;CONTAIN ANY ONES.
  2390
  2391	031527	200 00 0 00 070253 	A5000:	MOVE	[0]		;PRESET E WITH ALL ZEROS
  2392	031530	204 00 0 00 000000 		MOVS			;*MOVS SHOULD RESULT WITH AN AC 0F ALL ZEROS
  2393	031531	332 00 0 00 000000 		SKIPE			;SKIP HALT INSTRUCTION IF C(AC)=0
  2394						STOP^
  2395	031532	254 04 0 00 031533 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2396	031533	324 00 0 00 031534 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2397									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2398									;IN THE SUBTEST) TO LOOP ON ERROR^
  2399
  2400					;**********
  2401
  2402					;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
  2403					;RESULTS IN A NON-ZERO NUMBER IN THE AC.  FIRST A NON-ZERO WORD
  2404					;IS LOADED INTO E; THEN, MOVS IS EXECUTED.  THE AC IS CHECKED FOR A NON-ZERO RESULT.
  2405					;IF C(AC)=0, THE TEST FAILS.
  2406
  2407	031534	200 00 0 00 070330 	A5100:	MOVE	[XWD 0,-1]	;LOAD E WITH A NON-ZERO VALUE
  2408	031535	204 00 0 00 000000 		MOVS			;*MOVS SHOULD RESULT IN C(AC) NON-ZERO
  2409	031536	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
  2410						STOP^
  2411	031537	254 04 0 00 031540 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2412	031540	324 00 0 00 031541 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2413									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2414									;IN THE SUBTEST) TO LOOP ON ERROR^
  2415
  2416					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 21
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0064

  2417					;THIS TEST VERIFIES THAT A MOVS EXECUTED ON AN E CONTAINING A NON-ZERO NUMBER
  2418					;RESULTS IN A NON-ZERO NUMBER IN THE AC.  FIRST A NON-ZERO WORD
  2419					;IS LOADED INTO E; THEN, MOVS IS EXECUTED.  THE AC IS CHECKED FOR A NON-ZERO
  2420					;RESULT.  IF C(AC)=0, THE TEST FAILS.
  2421
  2422	031541	200 00 0 00 070331 	A5200:	MOVE	[XWD -1,0]	;LOAD E OF MOVS WITH A NON-ZERO NUMBER
  2423	031542	204 00 0 00 000000 		MOVS			;*MOVS SHOULD RESULT WITH C(AC) NON-ZERO
  2424	031543	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF C(AC) OF MOVS IS NON-ZERO
  2425						STOP^
  2426	031544	254 04 0 00 031545 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2427	031545	324 00 0 00 031546 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2428									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2429									;IN THE SUBTEST) TO LOOP ON ERROR^
  2430
  2431					;**********
  2432
  2433					;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 188 OF E
  2434					;AND STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-0.  FIRST, A WORD
  2435					;WITH BIT 0 SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E.  THEN, MOVS
  2436					;IS EXECUTED.  THE AC IS THEN CHECKED FOR A 0 IN BIT 0, WHICH IS THE
  2437					;CORRECT RESULT.
  2438
  2439	031546	200 00 0 00 070331 	A5300:	MOVE	[XWD -1,0]	;LOAD E OF MOVS WITH 777777000000
  2440	031547	204 00 0 00 000000 		MOVS			;*MOVS SHOULD RESULT WITH AC BIT 0 EQUAL TO 0
  2441	031550	337 00 0 00 000000 		SKIPG			;SKIP HALT INSTRUCTION IF BIT 0 OF AC IS 0
  2442						STOP^
  2443	031551	254 04 0 00 031552 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2444	031552	324 00 0 00 031553 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2445									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2446									;IN THE SUBTEST) TO LOOP ON ERROR^
  2447
  2448					;MOVSX: AR SWAP [ARMB], AR LT AR RT A [ARMB], AR LT AR RT B [ARMB],
  2449					;AR RT AR LT A [ARMB], AR RT AR LT B [ARMB], ET2 A F/F [E], IR MOVSX [IR1],
  2450					;IR MOV(E,S)X [IR1]
  2451
  2452					;**********
  2453
  2454					;THIS TEST VERIFIES THAT THE MOVS INSTRUCTION SWAPS BITS 0 AND 18 OF E AND
  2455					;STORES THEM IN THE AC UNLESS AR BIT 0 IS S-A-1.  FIRST, A WORD WITH BIT 0
  2456					;SET TO A ONE AND BIT 18 CLEARED IS LOADED INTO E.  THEN, MOVS IS EXECUTED.
  2457					;THE AC IS CHECKED FOR A ZERO IN BIT ZERO, WHICH IS THE CORRECT RESULT.
  2458
  2459	031553	200 00 0 00 070330 	A5400:	MOVE	[XWD 0,-1]	;LOAD E OF MOVS WITH 777777
  2460	031554	204 00 0 00 000000 		MOVS			;*MOVS SHOULD RESULT WITH BIT 0 OF THE AC SET
  2461	031555	331 00 0 00 000000 		SKIPL			;PASS IF AC BIT 0 IS SET
  2462						STOP^
  2463	031556	254 04 0 00 031557 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2464	031557	324 00 0 00 031560 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2465									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2466									;IN THE SUBTEST) TO LOOP ON ERROR^
  2467
  2468					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0065

  2469			005500		SN=5500
  2470			000000			ZZ=0
  2471
  2472					A5500:	REPEAT	^D18,
  2473					<;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2474					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2475					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2476					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2477					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2478					SN=SN+1
  2479						ZZ=ZZ+ZZ
  2480						IFE	ZZ,<ZZ=1>
  2481						MOVE	[0]		;CLEAR AC
  2482						MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2483						SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2484						STOP
  2485					
  2486					;**********
  2487					>
  2488					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2489					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2490					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2491					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2492					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2493			005501		SN=SN+1
  2494			000000			ZZ=ZZ+ZZ
  2495			000001			IFE	ZZ,<ZZ=1>
  2496	031560	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2497	031561	204 00 0 00 070265 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2498	031562	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2499						STOP^
  2500	031563	254 04 0 00 031564 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2501	031564	324 00 0 00 031565 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2502									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2503									;IN THE SUBTEST) TO LOOP ON ERROR^
  2504
  2505					;**********
  2506
  2507					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2508					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2509					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2510					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2511					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2512			005502		SN=SN+1
  2513			000002			ZZ=ZZ+ZZ
  2514						IFE	ZZ,<ZZ=1>
  2515	031565	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2516	031566	204 00 0 00 070266 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2517	031567	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2518						STOP^
  2519	031570	254 04 0 00 031571 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2520	031571	324 00 0 00 031572 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2521									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2522									;IN THE SUBTEST) TO LOOP ON ERROR^
  2523
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0066

  2524					;**********
  2525
  2526					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2527					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2528					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2529					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2530					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2531			005503		SN=SN+1
  2532			000004			ZZ=ZZ+ZZ
  2533						IFE	ZZ,<ZZ=1>
  2534	031572	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2535	031573	204 00 0 00 070267 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2536	031574	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2537						STOP^
  2538	031575	254 04 0 00 031576 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2539	031576	324 00 0 00 031577 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2540									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2541									;IN THE SUBTEST) TO LOOP ON ERROR^
  2542
  2543					;**********
  2544
  2545					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2546					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2547					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2548					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2549					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2550			005504		SN=SN+1
  2551			000010			ZZ=ZZ+ZZ
  2552						IFE	ZZ,<ZZ=1>
  2553	031577	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2554	031600	204 00 0 00 070270 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2555	031601	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2556						STOP^
  2557	031602	254 04 0 00 031603 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2558	031603	324 00 0 00 031604 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2559									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2560									;IN THE SUBTEST) TO LOOP ON ERROR^
  2561
  2562					;**********
  2563
  2564					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2565					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2566					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2567					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2568					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2569			005505		SN=SN+1
  2570			000020			ZZ=ZZ+ZZ
  2571						IFE	ZZ,<ZZ=1>
  2572	031604	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2573	031605	204 00 0 00 070271 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2574	031606	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2575						STOP^
  2576	031607	254 04 0 00 031610 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2577	031610	324 00 0 00 031611 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2578									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0067

  2579									;IN THE SUBTEST) TO LOOP ON ERROR^
  2580
  2581					;**********
  2582
  2583					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2584					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2585					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2586					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2587					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2588			005506		SN=SN+1
  2589			000040			ZZ=ZZ+ZZ
  2590						IFE	ZZ,<ZZ=1>
  2591	031611	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2592	031612	204 00 0 00 070272 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2593	031613	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2594						STOP^
  2595	031614	254 04 0 00 031615 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2596	031615	324 00 0 00 031616 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2597									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2598									;IN THE SUBTEST) TO LOOP ON ERROR^
  2599
  2600					;**********
  2601
  2602					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2603					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2604					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2605					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2606					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2607			005507		SN=SN+1
  2608			000100			ZZ=ZZ+ZZ
  2609						IFE	ZZ,<ZZ=1>
  2610	031616	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2611	031617	204 00 0 00 070273 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2612	031620	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2613						STOP^
  2614	031621	254 04 0 00 031622 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2615	031622	324 00 0 00 031623 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2616									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2617									;IN THE SUBTEST) TO LOOP ON ERROR^
  2618
  2619					;**********
  2620
  2621					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2622					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2623					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2624					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2625					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2626			005510		SN=SN+1
  2627			000200			ZZ=ZZ+ZZ
  2628						IFE	ZZ,<ZZ=1>
  2629	031623	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2630	031624	204 00 0 00 070274 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2631	031625	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2632						STOP^
  2633	031626	254 04 0 00 031627 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0068

  2634	031627	324 00 0 00 031630 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2635									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2636									;IN THE SUBTEST) TO LOOP ON ERROR^
  2637
  2638					;**********
  2639
  2640					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2641					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2642					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2643					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2644					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2645			005511		SN=SN+1
  2646			000400			ZZ=ZZ+ZZ
  2647						IFE	ZZ,<ZZ=1>
  2648	031630	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2649	031631	204 00 0 00 070275 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2650	031632	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2651						STOP^
  2652	031633	254 04 0 00 031634 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2653	031634	324 00 0 00 031635 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2654									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2655									;IN THE SUBTEST) TO LOOP ON ERROR^
  2656
  2657					;**********
  2658
  2659					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2660					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2661					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2662					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2663					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2664			005512		SN=SN+1
  2665			001000			ZZ=ZZ+ZZ
  2666						IFE	ZZ,<ZZ=1>
  2667	031635	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2668	031636	204 00 0 00 070276 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2669	031637	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2670						STOP^
  2671	031640	254 04 0 00 031641 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2672	031641	324 00 0 00 031642 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2673									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2674									;IN THE SUBTEST) TO LOOP ON ERROR^
  2675
  2676					;**********
  2677
  2678					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2679					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2680					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2681					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2682					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2683			005513		SN=SN+1
  2684			002000			ZZ=ZZ+ZZ
  2685						IFE	ZZ,<ZZ=1>
  2686	031642	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2687	031643	204 00 0 00 070277 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2688	031644	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0069

  2689						STOP^
  2690	031645	254 04 0 00 031646 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2691	031646	324 00 0 00 031647 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2692									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2693									;IN THE SUBTEST) TO LOOP ON ERROR^
  2694
  2695					;**********
  2696
  2697					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2698					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2699					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2700					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2701					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2702			005514		SN=SN+1
  2703			004000			ZZ=ZZ+ZZ
  2704						IFE	ZZ,<ZZ=1>
  2705	031647	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2706	031650	204 00 0 00 070300 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2707	031651	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2708						STOP^
  2709	031652	254 04 0 00 031653 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2710	031653	324 00 0 00 031654 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2711									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2712									;IN THE SUBTEST) TO LOOP ON ERROR^
  2713
  2714					;**********
  2715
  2716					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2717					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2718					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2719					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2720					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2721			005515		SN=SN+1
  2722			010000			ZZ=ZZ+ZZ
  2723						IFE	ZZ,<ZZ=1>
  2724	031654	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2725	031655	204 00 0 00 070301 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2726	031656	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2727						STOP^
  2728	031657	254 04 0 00 031660 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2729	031660	324 00 0 00 031661 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2730									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2731									;IN THE SUBTEST) TO LOOP ON ERROR^
  2732
  2733					;**********
  2734
  2735					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2736					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2737					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2738					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2739					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2740			005516		SN=SN+1
  2741			020000			ZZ=ZZ+ZZ
  2742						IFE	ZZ,<ZZ=1>
  2743	031661	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0070

  2744	031662	204 00 0 00 070302 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2745	031663	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2746						STOP^
  2747	031664	254 04 0 00 031665 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2748	031665	324 00 0 00 031666 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2749									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2750									;IN THE SUBTEST) TO LOOP ON ERROR^
  2751
  2752					;**********
  2753
  2754					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2755					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2756					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2757					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2758					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2759			005517		SN=SN+1
  2760			040000			ZZ=ZZ+ZZ
  2761						IFE	ZZ,<ZZ=1>
  2762	031666	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2763	031667	204 00 0 00 070303 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2764	031670	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2765						STOP^
  2766	031671	254 04 0 00 031672 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2767	031672	324 00 0 00 031673 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2768									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2769									;IN THE SUBTEST) TO LOOP ON ERROR^
  2770
  2771					;**********
  2772
  2773					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2774					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2775					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2776					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2777					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2778			005520		SN=SN+1
  2779			100000			ZZ=ZZ+ZZ
  2780						IFE	ZZ,<ZZ=1>
  2781	031673	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2782	031674	204 00 0 00 070304 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2783	031675	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2784						STOP^
  2785	031676	254 04 0 00 031677 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2786	031677	324 00 0 00 031700 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2787									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2788									;IN THE SUBTEST) TO LOOP ON ERROR^
  2789
  2790					;**********
  2791
  2792					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2793					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2794					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2795					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2796					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2797			005521		SN=SN+1
  2798			200000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0071

  2799						IFE	ZZ,<ZZ=1>
  2800	031700	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2801	031701	204 00 0 00 070305 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2802	031702	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2803						STOP^
  2804	031703	254 04 0 00 031704 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2805	031704	324 00 0 00 031705 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2806									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2807									;IN THE SUBTEST) TO LOOP ON ERROR^
  2808
  2809					;**********
  2810
  2811					;THIS TEST VERIFIES THAT AR LT INPUT IS FUNCTIONING.  A WORD OF ALL ZER0S,
  2812					;EXCEPT FOR ONE ONE IN THE RIGHT HALF IS SWAPPED.
  2813					;THE AC IS CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES
  2814					;IF C(AC) IS NON-ZERO. THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT
  2815					;OF THE LEFT HALF OF THE AC IS TESTED WITH A 1.
  2816			005522		SN=SN+1
  2817			400000			ZZ=ZZ+ZZ
  2818						IFE	ZZ,<ZZ=1>
  2819	031705	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2820	031706	204 00 0 00 070306 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2821	031707	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2822						STOP^
  2823	031710	254 04 0 00 031711 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2824	031711	324 00 0 00 031712 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2825									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2826									;IN THE SUBTEST) TO LOOP ON ERROR^
  2827
  2828					;**********
  2829
  2830			005600		SN=5600
  2831
  2832					A5600:	REPEAT	^D18,
  2833					<;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2834					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2835					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2836					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2837					;HALF OF THE AC IS TESTED WITH A 1.
  2838					
  2839					SN=SN+1
  2840						ZZ=ZZ+ZZ
  2841						MOVE	[0]		;CLEAR AC
  2842						MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2843						SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2844						STOP
  2845					
  2846					;**********
  2847					>
  2848					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2849					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2850					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2851					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2852					;HALF OF THE AC IS TESTED WITH A 1.
  2853
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0072

  2854			005601		SN=SN+1
  2855		000001	000000			ZZ=ZZ+ZZ
  2856	031712	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2857	031713	204 00 0 00 070307 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2858	031714	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2859						STOP^
  2860	031715	254 04 0 00 031716 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2861	031716	324 00 0 00 031717 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2862									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2863									;IN THE SUBTEST) TO LOOP ON ERROR^
  2864
  2865					;**********
  2866
  2867					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2868					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2869					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2870					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2871					;HALF OF THE AC IS TESTED WITH A 1.
  2872
  2873			005602		SN=SN+1
  2874		000002	000000			ZZ=ZZ+ZZ
  2875	031717	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2876	031720	204 00 0 00 070310 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2877	031721	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2878						STOP^
  2879	031722	254 04 0 00 031723 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2880	031723	324 00 0 00 031724 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2881									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2882									;IN THE SUBTEST) TO LOOP ON ERROR^
  2883
  2884					;**********
  2885
  2886					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2887					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2888					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2889					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2890					;HALF OF THE AC IS TESTED WITH A 1.
  2891
  2892			005603		SN=SN+1
  2893		000004	000000			ZZ=ZZ+ZZ
  2894	031724	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2895	031725	204 00 0 00 070311 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2896	031726	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2897						STOP^
  2898	031727	254 04 0 00 031730 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2899	031730	324 00 0 00 031731 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2900									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2901									;IN THE SUBTEST) TO LOOP ON ERROR^
  2902
  2903					;**********
  2904
  2905					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2906					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2907					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2908					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0073

  2909					;HALF OF THE AC IS TESTED WITH A 1.
  2910
  2911			005604		SN=SN+1
  2912		000010	000000			ZZ=ZZ+ZZ
  2913	031731	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2914	031732	204 00 0 00 070312 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2915	031733	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2916						STOP^
  2917	031734	254 04 0 00 031735 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2918	031735	324 00 0 00 031736 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2919									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2920									;IN THE SUBTEST) TO LOOP ON ERROR^
  2921
  2922					;**********
  2923
  2924					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2925					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2926					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2927					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2928					;HALF OF THE AC IS TESTED WITH A 1.
  2929
  2930			005605		SN=SN+1
  2931		000020	000000			ZZ=ZZ+ZZ
  2932	031736	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2933	031737	204 00 0 00 070313 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2934	031740	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2935						STOP^
  2936	031741	254 04 0 00 031742 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2937	031742	324 00 0 00 031743 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2938									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2939									;IN THE SUBTEST) TO LOOP ON ERROR^
  2940
  2941					;**********
  2942
  2943					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2944					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2945					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2946					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2947					;HALF OF THE AC IS TESTED WITH A 1.
  2948
  2949			005606		SN=SN+1
  2950		000040	000000			ZZ=ZZ+ZZ
  2951	031743	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2952	031744	204 00 0 00 070314 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2953	031745	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2954						STOP^
  2955	031746	254 04 0 00 031747 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2956	031747	324 00 0 00 031750 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2957									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2958									;IN THE SUBTEST) TO LOOP ON ERROR^
  2959
  2960					;**********
  2961
  2962					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2963					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0074

  2964					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2965					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2966					;HALF OF THE AC IS TESTED WITH A 1.
  2967
  2968			005607		SN=SN+1
  2969		000100	000000			ZZ=ZZ+ZZ
  2970	031750	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2971	031751	204 00 0 00 070315 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2972	031752	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2973						STOP^
  2974	031753	254 04 0 00 031754 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2975	031754	324 00 0 00 031755 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2976									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2977									;IN THE SUBTEST) TO LOOP ON ERROR^
  2978
  2979					;**********
  2980
  2981					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  2982					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  2983					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  2984					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  2985					;HALF OF THE AC IS TESTED WITH A 1.
  2986
  2987			005610		SN=SN+1
  2988		000200	000000			ZZ=ZZ+ZZ
  2989	031755	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  2990	031756	204 00 0 00 070316 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  2991	031757	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  2992						STOP^
  2993	031760	254 04 0 00 031761 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  2994	031761	324 00 0 00 031762 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  2995									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  2996									;IN THE SUBTEST) TO LOOP ON ERROR^
  2997
  2998					;**********
  2999
  3000					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3001					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3002					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3003					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3004					;HALF OF THE AC IS TESTED WITH A 1.
  3005
  3006			005611		SN=SN+1
  3007		000400	000000			ZZ=ZZ+ZZ
  3008	031762	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3009	031763	204 00 0 00 070264 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3010	031764	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3011						STOP^
  3012	031765	254 04 0 00 031766 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3013	031766	324 00 0 00 031767 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3014									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3015									;IN THE SUBTEST) TO LOOP ON ERROR^
  3016
  3017					;**********
  3018
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0075

  3019					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3020					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3021					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3022					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3023					;HALF OF THE AC IS TESTED WITH A 1.
  3024
  3025			005612		SN=SN+1
  3026		001000	000000			ZZ=ZZ+ZZ
  3027	031767	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3028	031770	204 00 0 00 070317 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3029	031771	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3030						STOP^
  3031	031772	254 04 0 00 031773 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3032	031773	324 00 0 00 031774 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3033									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3034									;IN THE SUBTEST) TO LOOP ON ERROR^
  3035
  3036					;**********
  3037
  3038					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3039					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3040					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3041					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3042					;HALF OF THE AC IS TESTED WITH A 1.
  3043
  3044			005613		SN=SN+1
  3045		002000	000000			ZZ=ZZ+ZZ
  3046	031774	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3047	031775	204 00 0 00 070320 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3048	031776	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3049						STOP^
  3050	031777	254 04 0 00 032000 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3051	032000	324 00 0 00 032001 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3052									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3053									;IN THE SUBTEST) TO LOOP ON ERROR^
  3054
  3055					;**********
  3056
  3057					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3058					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3059					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3060					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3061					;HALF OF THE AC IS TESTED WITH A 1.
  3062
  3063			005614		SN=SN+1
  3064		004000	000000			ZZ=ZZ+ZZ
  3065	032001	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3066	032002	204 00 0 00 070321 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3067	032003	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3068						STOP^
  3069	032004	254 04 0 00 032005 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3070	032005	324 00 0 00 032006 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3071									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3072									;IN THE SUBTEST) TO LOOP ON ERROR^
  3073
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0076

  3074					;**********
  3075
  3076					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3077					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3078					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3079					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3080					;HALF OF THE AC IS TESTED WITH A 1.
  3081
  3082			005615		SN=SN+1
  3083		010000	000000			ZZ=ZZ+ZZ
  3084	032006	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3085	032007	204 00 0 00 070322 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3086	032010	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3087						STOP^
  3088	032011	254 04 0 00 032012 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3089	032012	324 00 0 00 032013 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3090									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3091									;IN THE SUBTEST) TO LOOP ON ERROR^
  3092
  3093					;**********
  3094
  3095					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3096					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3097					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3098					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3099					;HALF OF THE AC IS TESTED WITH A 1.
  3100
  3101			005616		SN=SN+1
  3102		020000	000000			ZZ=ZZ+ZZ
  3103	032013	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3104	032014	204 00 0 00 070323 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3105	032015	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3106						STOP^
  3107	032016	254 04 0 00 032017 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3108	032017	324 00 0 00 032020 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3109									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3110									;IN THE SUBTEST) TO LOOP ON ERROR^
  3111
  3112					;**********
  3113
  3114					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3115					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3116					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3117					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3118					;HALF OF THE AC IS TESTED WITH A 1.
  3119
  3120			005617		SN=SN+1
  3121		040000	000000			ZZ=ZZ+ZZ
  3122	032020	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3123	032021	204 00 0 00 070324 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3124	032022	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3125						STOP^
  3126	032023	254 04 0 00 032024 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3127	032024	324 00 0 00 032025 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3128									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0077

  3129									;IN THE SUBTEST) TO LOOP ON ERROR^
  3130
  3131					;**********
  3132
  3133					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3134					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3135					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3136					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3137					;HALF OF THE AC IS TESTED WITH A 1.
  3138
  3139			005620		SN=SN+1
  3140		100000	000000			ZZ=ZZ+ZZ
  3141	032025	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3142	032026	204 00 0 00 070325 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3143	032027	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3144						STOP^
  3145	032030	254 04 0 00 032031 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3146	032031	324 00 0 00 032032 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3147									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3148									;IN THE SUBTEST) TO LOOP ON ERROR^
  3149
  3150					;**********
  3151
  3152					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3153					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3154					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3155					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3156					;HALF OF THE AC IS TESTED WITH A 1.
  3157
  3158			005621		SN=SN+1
  3159		200000	000000			ZZ=ZZ+ZZ
  3160	032032	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3161	032033	204 00 0 00 070326 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3162	032034	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3163						STOP^
  3164	032035	254 04 0 00 032036 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3165	032036	324 00 0 00 032037 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3166									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3167									;IN THE SUBTEST) TO LOOP ON ERROR^
  3168
  3169					;**********
  3170
  3171					;THIS TEST VERIFIES THAT AR RT INPUT IS FUNCTIONING.  A WORD OF ALL
  3172					;ZEROS, EXCEPT FOR ONE ONE IN THE LEFT HALF IS SWAPPED.  THE AC IS
  3173					;CHECKED FOR ITS CONTENTS NON-ZERO.  THE TEST PASSES IF C(AC) IS
  3174					;NON-ZERO.  THIS TEST IS REPEATED 18 TIMES SO THAT EACH BIT OF THE RIGHT
  3175					;HALF OF THE AC IS TESTED WITH A 1.
  3176
  3177			005622		SN=SN+1
  3178		400000	000000			ZZ=ZZ+ZZ
  3179	032037	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  3180	032040	204 00 0 00 070256 		MOVS	[ZZ]		;*MOVS SHOULD RESULT WITH A NON-ZERO WORD IN THE AC
  3181	032041	336 00 0 00 000000 		SKIPN			;SKIP HALT INSTRUCTION IF SET BIT IS NOT LOST IN SWAP.
  3182						STOP^
  3183	032042	254 04 0 00 032043 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF SKIP, FULL WORD TRANSFER AND HALF WORD TRANSFER INSTRUCTIONS               SEQ 0078

  3184	032043	324 00 0 00 032044 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3185									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3186									;IN THE SUBTEST) TO LOOP ON ERROR^
  3187
  3188					;**********
  3189
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0079

  3190					SUBTTL	TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)
  3191
  3192					;THIS TEST VERIFIES THAT SETM LOADS AC FROM E.  THE AC IS FIRST SET
  3193					;TO ZERO; THEN, SETM IS EXECUTED WITH ALL ONES IN E.  BIT 0 OF THE AC
  3194					;IS THEN CHECKED FOR A 1.
  3195
  3196	032044	200 00 0 00 070253 	A5700:	MOVE	[0]		;PRELOAD AC WITH ALL ZEROS
  3197	032045	414 00 0 00 070254 		SETM	[-1]		;*SETM SHOULD LOAD AC WITH ALL ONES
  3198	032046	331 00 0 00 000000 		SKIPL			;PASS TEST IF AC BIT 0 IS A ONE
  3199						STOP^
  3200	032047	254 04 0 00 032050 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3201	032050	324 00 0 00 032051 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3202									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3203									;IN THE SUBTEST) TO LOOP ON ERROR^
  3204					;FCE [F1], IR BOOLE [IR1], IRXX(0,5,12,17) [IR2]
  3205
  3206					;**********
  3207
  3208					;THIS TEST VERIFIES THAT SETM LOADS AC FROM E.  THE AC IS FIRST SET TO
  3209					;ALL ONES; THEN, SETM IS EXECUTED WITH ALL ZEROS IN E.  THE AC IS CHECKED
  3210					;FOR ALL ZEROS
  3211
  3212	032051	200 00 0 00 070254 	A6000:	MOVE	[-1]		;PRESET AC TO ALL ONES
  3213	032052	414 00 0 00 070253 		SETM	[0]		;*SETM SHOULD LOAD AC WITH ALL ONES
  3214	032053	332 00 0 00 000000 		SKIPE			;PASSES TEST IF C(AC) = 0
  3215						STOP^
  3216	032054	254 04 0 00 032055 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3217	032055	324 00 0 00 032056 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3218									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3219									;IN THE SUBTEST) TO LOOP ON ERROR^
  3220
  3221					;AD AR + EN [ADAP], AD AR + EN C[ADAP],
  3222					;F CYC ACT EN A[F1], IR BOOLE AD A +F[IR2],
  3223					;IR BOOLE [IR1], IRXX(1-3,6,11,15,16) [IR2]
  3224
  3225					;**********
  3226
  3227					;THIS TEST VERIFIES THAT SETZ LOADS TH AC WITH ALL ZEROS.  FIRST, A WORD
  3228					;OF ALL ZEROS IS LOADED INTO THE AC VIA A MOVE INSTC. THEN, SETZ IS
  3229					;EXECUTED.  THE AC IS CHECKED FOR ALL ZEROS.
  3230					;IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.
  3231
  3232	032056	200 00 0 00 070253 	A6100:	MOVE	[0]		;RESET AC TO ALL ZEROS
  3233	032057	400 00 0 00 000000 		SETZ			;*SETZ SHOULD CLEAR THE AC
  3234	032060	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC) = 0
  3235						STOP^
  3236	032061	254 04 0 00 032062 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3237	032062	324 00 0 00 032063 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3238									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3239									;IN THE SUBTEST) TO LOOP ON ERROR^
  3240
  3241					;AD MASK GEN EN [ADC1], AD MASK GEN F/F'S [ADC1]
  3242					;AD MASK EN B; F CYC ACT EN B[F1]; IRXX00 [IR1];
  3243					;IR BOOLE [IR1]
  3244
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0080

  3245					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0081

  3246					;THIS TEST VERIFIES THAT SETZ LOADS THE AC WITH ALL ZEROS.  FIRST,
  3247					;THE AC IS SET TO ALL ONES; THEN, SETZ IS EXECUTED.  THE AC IS THEN
  3248					;CHECKED FOR ALL ZEROS.  IF ANY BITS IN THE AC ARE SET, THE TEST FAILS.
  3249
  3250	032063	200 00 0 00 070254 	A6200:	MOVE	[-1]		;PRESET AC TO ALL ONES
  3251	032064	400 00 0 00 032064 		SETZ	.		;*SETZ SHOULD CLEAR THE AC
  3252	032065	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC) = 0
  3253						STOP^
  3254	032066	254 04 0 00 032067 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3255	032067	324 00 0 00 032070 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3256									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3257									;IN THE SUBTEST) TO LOOP ON ERROR^
  3258
  3259					;AR AD EN [ARMA], AR AD ET2 EN [ARMA], IR BOOLE [IR]
  3260
  3261					;**********
  3262
  3263					;THIS TEST VERIFIES THAT THE AND INSTRUCTION OPERATING ON AN AC
  3264					;CONTAINING ALL ZEROS AND AN E CONTAINING ALL ZEROS RESULTS IN AN AC
  3265					;OF ALL ZEROS.  THE AC AND E ARE THE SAME IN THIS TEST.
  3266					;AC, E ARE LOADED WITH ZEROS; THEN, AND IS EXECUTED.  THE AC IS THEN
  3267					;CHECKED FOR ALL ZEROS.  IF ANY BITS IN THE AC ARE SET BY THE AND INSTRUCTION,
  3268					;THE TEST FAILS.
  3269
  3270
  3271	032070	200 00 0 00 070253 	A6300:	MOVE	[0]		;PRESET AC, E TO ALL ZEROS
  3272	032071	404 00 0 00 000000 		AND			;*AND SHOULD RESULT IN C(AC) = 0
  3273	032072	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC) = 0
  3274						STOP^
  3275	032073	254 04 0 00 032074 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3276	032074	324 00 0 00 032075 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3277									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3278									;IN THE SUBTEST) TO LOOP ON ERROR^
  3279
  3280					;**********
  3281			006400		SN=6400
  3282			000000			ZZ=0
  3283
  3284					A6400:	REPEAT	^D36,
  3285					<;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3286					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3287					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3288					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3289					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3290					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3291					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3292					
  3293					SN=SN+1
  3294						ZZ=ZZ+ZZ
  3295						IFE	ZZ,<ZZ=1>
  3296						SETZ			;PRESET E TO ALL ZEROS
  3297						MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3298									;WHERE X VARIES FROM 0 THRU 35
  3299						AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3300						SKIPE	1		;FAIL IF C(AC) NON-ZERO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0082

  3301						STOP
  3302						SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3303						STOP
  3304					;**********
  3305					>
  3306					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3307					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3308					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3309					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3310					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3311					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3312					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3313
  3314			006401		SN=SN+1
  3315			000000			ZZ=ZZ+ZZ
  3316			000001			IFE	ZZ,<ZZ=1>
  3317	032075	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3318	032076	200 01 0 00 070265 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3319									;WHERE X VARIES FROM 0 THRU 35
  3320	032077	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3321	032100	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3322						STOP^
  3323	032101	254 04 0 00 032102 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3324	032102	324 00 0 00 032103 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3325									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3326									;IN THE SUBTEST) TO LOOP ON ERROR^
  3327	032103	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3328						STOP^
  3329	032104	254 04 0 00 032105 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3330	032105	324 00 0 00 032106 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3331									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3332									;IN THE SUBTEST) TO LOOP ON ERROR^
  3333					;**********
  3334
  3335					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3336					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3337					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3338					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3339					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3340					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3341					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3342
  3343			006402		SN=SN+1
  3344			000002			ZZ=ZZ+ZZ
  3345						IFE	ZZ,<ZZ=1>
  3346	032106	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3347	032107	200 01 0 00 070266 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3348									;WHERE X VARIES FROM 0 THRU 35
  3349	032110	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3350	032111	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3351						STOP^
  3352	032112	254 04 0 00 032113 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3353	032113	324 00 0 00 032114 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3354									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3355									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0083

  3356	032114	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3357						STOP^
  3358	032115	254 04 0 00 032116 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3359	032116	324 00 0 00 032117 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3360									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3361									;IN THE SUBTEST) TO LOOP ON ERROR^
  3362					;**********
  3363
  3364					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3365					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3366					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3367					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3368					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3369					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3370					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3371
  3372			006403		SN=SN+1
  3373			000004			ZZ=ZZ+ZZ
  3374						IFE	ZZ,<ZZ=1>
  3375	032117	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3376	032120	200 01 0 00 070267 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3377									;WHERE X VARIES FROM 0 THRU 35
  3378	032121	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3379	032122	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3380						STOP^
  3381	032123	254 04 0 00 032124 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3382	032124	324 00 0 00 032125 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3383									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3384									;IN THE SUBTEST) TO LOOP ON ERROR^
  3385	032125	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3386						STOP^
  3387	032126	254 04 0 00 032127 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3388	032127	324 00 0 00 032130 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3389									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3390									;IN THE SUBTEST) TO LOOP ON ERROR^
  3391					;**********
  3392
  3393					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3394					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3395					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3396					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3397					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3398					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3399					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3400
  3401			006404		SN=SN+1
  3402			000010			ZZ=ZZ+ZZ
  3403						IFE	ZZ,<ZZ=1>
  3404	032130	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3405	032131	200 01 0 00 070270 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3406									;WHERE X VARIES FROM 0 THRU 35
  3407	032132	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3408	032133	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3409						STOP^
  3410	032134	254 04 0 00 032135 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0084

  3411	032135	324 00 0 00 032136 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3412									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3413									;IN THE SUBTEST) TO LOOP ON ERROR^
  3414	032136	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3415						STOP^
  3416	032137	254 04 0 00 032140 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3417	032140	324 00 0 00 032141 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3418									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3419									;IN THE SUBTEST) TO LOOP ON ERROR^
  3420					;**********
  3421
  3422					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3423					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3424					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3425					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3426					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3427					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3428					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3429
  3430			006405		SN=SN+1
  3431			000020			ZZ=ZZ+ZZ
  3432						IFE	ZZ,<ZZ=1>
  3433	032141	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3434	032142	200 01 0 00 070271 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3435									;WHERE X VARIES FROM 0 THRU 35
  3436	032143	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3437	032144	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3438						STOP^
  3439	032145	254 04 0 00 032146 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3440	032146	324 00 0 00 032147 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3441									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3442									;IN THE SUBTEST) TO LOOP ON ERROR^
  3443	032147	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3444						STOP^
  3445	032150	254 04 0 00 032151 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3446	032151	324 00 0 00 032152 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3447									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3448									;IN THE SUBTEST) TO LOOP ON ERROR^
  3449					;**********
  3450
  3451					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3452					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3453					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3454					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3455					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3456					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3457					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3458
  3459			006406		SN=SN+1
  3460			000040			ZZ=ZZ+ZZ
  3461						IFE	ZZ,<ZZ=1>
  3462	032152	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3463	032153	200 01 0 00 070272 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3464									;WHERE X VARIES FROM 0 THRU 35
  3465	032154	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0085

  3466	032155	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3467						STOP^
  3468	032156	254 04 0 00 032157 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3469	032157	324 00 0 00 032160 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3470									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3471									;IN THE SUBTEST) TO LOOP ON ERROR^
  3472	032160	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3473						STOP^
  3474	032161	254 04 0 00 032162 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3475	032162	324 00 0 00 032163 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3476									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3477									;IN THE SUBTEST) TO LOOP ON ERROR^
  3478					;**********
  3479
  3480					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3481					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3482					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3483					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3484					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3485					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3486					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3487
  3488			006407		SN=SN+1
  3489			000100			ZZ=ZZ+ZZ
  3490						IFE	ZZ,<ZZ=1>
  3491	032163	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3492	032164	200 01 0 00 070273 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3493									;WHERE X VARIES FROM 0 THRU 35
  3494	032165	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3495	032166	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3496						STOP^
  3497	032167	254 04 0 00 032170 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3498	032170	324 00 0 00 032171 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3499									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3500									;IN THE SUBTEST) TO LOOP ON ERROR^
  3501	032171	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3502						STOP^
  3503	032172	254 04 0 00 032173 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3504	032173	324 00 0 00 032174 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3505									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3506									;IN THE SUBTEST) TO LOOP ON ERROR^
  3507					;**********
  3508
  3509					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3510					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3511					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3512					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3513					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3514					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3515					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3516
  3517			006410		SN=SN+1
  3518			000200			ZZ=ZZ+ZZ
  3519						IFE	ZZ,<ZZ=1>
  3520	032174	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0086

  3521	032175	200 01 0 00 070274 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3522									;WHERE X VARIES FROM 0 THRU 35
  3523	032176	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3524	032177	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3525						STOP^
  3526	032200	254 04 0 00 032201 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3527	032201	324 00 0 00 032202 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3528									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3529									;IN THE SUBTEST) TO LOOP ON ERROR^
  3530	032202	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3531						STOP^
  3532	032203	254 04 0 00 032204 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3533	032204	324 00 0 00 032205 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3534									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3535									;IN THE SUBTEST) TO LOOP ON ERROR^
  3536					;**********
  3537
  3538					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3539					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3540					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3541					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3542					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3543					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3544					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3545
  3546			006411		SN=SN+1
  3547			000400			ZZ=ZZ+ZZ
  3548						IFE	ZZ,<ZZ=1>
  3549	032205	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3550	032206	200 01 0 00 070275 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3551									;WHERE X VARIES FROM 0 THRU 35
  3552	032207	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3553	032210	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3554						STOP^
  3555	032211	254 04 0 00 032212 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3556	032212	324 00 0 00 032213 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3557									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3558									;IN THE SUBTEST) TO LOOP ON ERROR^
  3559	032213	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3560						STOP^
  3561	032214	254 04 0 00 032215 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3562	032215	324 00 0 00 032216 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3563									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3564									;IN THE SUBTEST) TO LOOP ON ERROR^
  3565					;**********
  3566
  3567					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3568					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3569					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3570					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3571					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3572					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3573					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3574
  3575			006412		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0087

  3576			001000			ZZ=ZZ+ZZ
  3577						IFE	ZZ,<ZZ=1>
  3578	032216	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3579	032217	200 01 0 00 070276 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3580									;WHERE X VARIES FROM 0 THRU 35
  3581	032220	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3582	032221	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3583						STOP^
  3584	032222	254 04 0 00 032223 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3585	032223	324 00 0 00 032224 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3586									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3587									;IN THE SUBTEST) TO LOOP ON ERROR^
  3588	032224	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3589						STOP^
  3590	032225	254 04 0 00 032226 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3591	032226	324 00 0 00 032227 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3592									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3593									;IN THE SUBTEST) TO LOOP ON ERROR^
  3594					;**********
  3595
  3596					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3597					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3598					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3599					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3600					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3601					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3602					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3603
  3604			006413		SN=SN+1
  3605			002000			ZZ=ZZ+ZZ
  3606						IFE	ZZ,<ZZ=1>
  3607	032227	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3608	032230	200 01 0 00 070277 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3609									;WHERE X VARIES FROM 0 THRU 35
  3610	032231	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3611	032232	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3612						STOP^
  3613	032233	254 04 0 00 032234 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3614	032234	324 00 0 00 032235 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3615									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3616									;IN THE SUBTEST) TO LOOP ON ERROR^
  3617	032235	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3618						STOP^
  3619	032236	254 04 0 00 032237 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3620	032237	324 00 0 00 032240 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3621									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3622									;IN THE SUBTEST) TO LOOP ON ERROR^
  3623					;**********
  3624
  3625					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3626					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3627					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3628					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3629					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3630					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0088

  3631					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3632
  3633			006414		SN=SN+1
  3634			004000			ZZ=ZZ+ZZ
  3635						IFE	ZZ,<ZZ=1>
  3636	032240	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3637	032241	200 01 0 00 070300 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3638									;WHERE X VARIES FROM 0 THRU 35
  3639	032242	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3640	032243	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3641						STOP^
  3642	032244	254 04 0 00 032245 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3643	032245	324 00 0 00 032246 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3644									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3645									;IN THE SUBTEST) TO LOOP ON ERROR^
  3646	032246	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3647						STOP^
  3648	032247	254 04 0 00 032250 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3649	032250	324 00 0 00 032251 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3650									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3651									;IN THE SUBTEST) TO LOOP ON ERROR^
  3652					;**********
  3653
  3654					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3655					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3656					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3657					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3658					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3659					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3660					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3661
  3662			006415		SN=SN+1
  3663			010000			ZZ=ZZ+ZZ
  3664						IFE	ZZ,<ZZ=1>
  3665	032251	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3666	032252	200 01 0 00 070301 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3667									;WHERE X VARIES FROM 0 THRU 35
  3668	032253	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3669	032254	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3670						STOP^
  3671	032255	254 04 0 00 032256 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3672	032256	324 00 0 00 032257 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3673									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3674									;IN THE SUBTEST) TO LOOP ON ERROR^
  3675	032257	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3676						STOP^
  3677	032260	254 04 0 00 032261 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3678	032261	324 00 0 00 032262 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3679									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3680									;IN THE SUBTEST) TO LOOP ON ERROR^
  3681					;**********
  3682
  3683					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3684					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3685					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0089

  3686					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3687					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3688					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3689					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3690
  3691			006416		SN=SN+1
  3692			020000			ZZ=ZZ+ZZ
  3693						IFE	ZZ,<ZZ=1>
  3694	032262	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3695	032263	200 01 0 00 070302 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3696									;WHERE X VARIES FROM 0 THRU 35
  3697	032264	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3698	032265	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3699						STOP^
  3700	032266	254 04 0 00 032267 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3701	032267	324 00 0 00 032270 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3702									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3703									;IN THE SUBTEST) TO LOOP ON ERROR^
  3704	032270	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3705						STOP^
  3706	032271	254 04 0 00 032272 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3707	032272	324 00 0 00 032273 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3708									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3709									;IN THE SUBTEST) TO LOOP ON ERROR^
  3710					;**********
  3711
  3712					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3713					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3714					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3715					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3716					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3717					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3718					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3719
  3720			006417		SN=SN+1
  3721			040000			ZZ=ZZ+ZZ
  3722						IFE	ZZ,<ZZ=1>
  3723	032273	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3724	032274	200 01 0 00 070303 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3725									;WHERE X VARIES FROM 0 THRU 35
  3726	032275	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3727	032276	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3728						STOP^
  3729	032277	254 04 0 00 032300 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3730	032300	324 00 0 00 032301 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3731									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3732									;IN THE SUBTEST) TO LOOP ON ERROR^
  3733	032301	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3734						STOP^
  3735	032302	254 04 0 00 032303 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3736	032303	324 00 0 00 032304 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3737									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3738									;IN THE SUBTEST) TO LOOP ON ERROR^
  3739					;**********
  3740
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0090

  3741					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3742					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3743					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3744					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3745					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3746					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3747					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3748
  3749			006420		SN=SN+1
  3750			100000			ZZ=ZZ+ZZ
  3751						IFE	ZZ,<ZZ=1>
  3752	032304	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3753	032305	200 01 0 00 070304 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3754									;WHERE X VARIES FROM 0 THRU 35
  3755	032306	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3756	032307	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3757						STOP^
  3758	032310	254 04 0 00 032311 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3759	032311	324 00 0 00 032312 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3760									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3761									;IN THE SUBTEST) TO LOOP ON ERROR^
  3762	032312	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3763						STOP^
  3764	032313	254 04 0 00 032314 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3765	032314	324 00 0 00 032315 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3766									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3767									;IN THE SUBTEST) TO LOOP ON ERROR^
  3768					;**********
  3769
  3770					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3771					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3772					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3773					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3774					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3775					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3776					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3777
  3778			006421		SN=SN+1
  3779			200000			ZZ=ZZ+ZZ
  3780						IFE	ZZ,<ZZ=1>
  3781	032315	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3782	032316	200 01 0 00 070305 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3783									;WHERE X VARIES FROM 0 THRU 35
  3784	032317	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3785	032320	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3786						STOP^
  3787	032321	254 04 0 00 032322 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3788	032322	324 00 0 00 032323 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3789									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3790									;IN THE SUBTEST) TO LOOP ON ERROR^
  3791	032323	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3792						STOP^
  3793	032324	254 04 0 00 032325 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3794	032325	324 00 0 00 032326 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3795									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0091

  3796									;IN THE SUBTEST) TO LOOP ON ERROR^
  3797					;**********
  3798
  3799					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3800					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3801					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3802					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3803					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3804					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3805					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3806
  3807			006422		SN=SN+1
  3808			400000			ZZ=ZZ+ZZ
  3809						IFE	ZZ,<ZZ=1>
  3810	032326	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3811	032327	200 01 0 00 070306 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3812									;WHERE X VARIES FROM 0 THRU 35
  3813	032330	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3814	032331	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3815						STOP^
  3816	032332	254 04 0 00 032333 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3817	032333	324 00 0 00 032334 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3818									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3819									;IN THE SUBTEST) TO LOOP ON ERROR^
  3820	032334	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3821						STOP^
  3822	032335	254 04 0 00 032336 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3823	032336	324 00 0 00 032337 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3824									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3825									;IN THE SUBTEST) TO LOOP ON ERROR^
  3826					;**********
  3827
  3828					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3829					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3830					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3831					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3832					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3833					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3834					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3835
  3836			006423		SN=SN+1
  3837		000001	000000			ZZ=ZZ+ZZ
  3838						IFE	ZZ,<ZZ=1>
  3839	032337	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3840	032340	200 01 0 00 070307 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3841									;WHERE X VARIES FROM 0 THRU 35
  3842	032341	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3843	032342	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3844						STOP^
  3845	032343	254 04 0 00 032344 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3846	032344	324 00 0 00 032345 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3847									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3848									;IN THE SUBTEST) TO LOOP ON ERROR^
  3849	032345	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3850						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0092

  3851	032346	254 04 0 00 032347 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3852	032347	324 00 0 00 032350 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3853									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3854									;IN THE SUBTEST) TO LOOP ON ERROR^
  3855					;**********
  3856
  3857					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3858					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3859					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3860					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3861					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3862					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3863					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3864
  3865			006424		SN=SN+1
  3866		000002	000000			ZZ=ZZ+ZZ
  3867						IFE	ZZ,<ZZ=1>
  3868	032350	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3869	032351	200 01 0 00 070310 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3870									;WHERE X VARIES FROM 0 THRU 35
  3871	032352	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3872	032353	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3873						STOP^
  3874	032354	254 04 0 00 032355 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3875	032355	324 00 0 00 032356 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3876									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3877									;IN THE SUBTEST) TO LOOP ON ERROR^
  3878	032356	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3879						STOP^
  3880	032357	254 04 0 00 032360 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3881	032360	324 00 0 00 032361 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3882									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3883									;IN THE SUBTEST) TO LOOP ON ERROR^
  3884					;**********
  3885
  3886					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3887					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3888					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3889					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3890					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3891					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3892					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3893
  3894			006425		SN=SN+1
  3895		000004	000000			ZZ=ZZ+ZZ
  3896						IFE	ZZ,<ZZ=1>
  3897	032361	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3898	032362	200 01 0 00 070311 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3899									;WHERE X VARIES FROM 0 THRU 35
  3900	032363	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3901	032364	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3902						STOP^
  3903	032365	254 04 0 00 032366 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3904	032366	324 00 0 00 032367 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3905									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0093

  3906									;IN THE SUBTEST) TO LOOP ON ERROR^
  3907	032367	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3908						STOP^
  3909	032370	254 04 0 00 032371 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3910	032371	324 00 0 00 032372 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3911									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3912									;IN THE SUBTEST) TO LOOP ON ERROR^
  3913					;**********
  3914
  3915					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3916					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3917					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3918					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3919					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3920					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3921					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3922
  3923			006426		SN=SN+1
  3924		000010	000000			ZZ=ZZ+ZZ
  3925						IFE	ZZ,<ZZ=1>
  3926	032372	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3927	032373	200 01 0 00 070312 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3928									;WHERE X VARIES FROM 0 THRU 35
  3929	032374	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3930	032375	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3931						STOP^
  3932	032376	254 04 0 00 032377 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3933	032377	324 00 0 00 032400 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3934									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3935									;IN THE SUBTEST) TO LOOP ON ERROR^
  3936	032400	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3937						STOP^
  3938	032401	254 04 0 00 032402 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3939	032402	324 00 0 00 032403 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3940									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3941									;IN THE SUBTEST) TO LOOP ON ERROR^
  3942					;**********
  3943
  3944					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3945					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3946					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3947					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3948					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3949					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3950					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3951
  3952			006427		SN=SN+1
  3953		000020	000000			ZZ=ZZ+ZZ
  3954						IFE	ZZ,<ZZ=1>
  3955	032403	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3956	032404	200 01 0 00 070313 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3957									;WHERE X VARIES FROM 0 THRU 35
  3958	032405	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3959	032406	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3960						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0094

  3961	032407	254 04 0 00 032410 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3962	032410	324 00 0 00 032411 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3963									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3964									;IN THE SUBTEST) TO LOOP ON ERROR^
  3965	032411	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3966						STOP^
  3967	032412	254 04 0 00 032413 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3968	032413	324 00 0 00 032414 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3969									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3970									;IN THE SUBTEST) TO LOOP ON ERROR^
  3971					;**********
  3972
  3973					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  3974					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  3975					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  3976					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  3977					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  3978					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  3979					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  3980
  3981			006430		SN=SN+1
  3982		000040	000000			ZZ=ZZ+ZZ
  3983						IFE	ZZ,<ZZ=1>
  3984	032414	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  3985	032415	200 01 0 00 070314 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  3986									;WHERE X VARIES FROM 0 THRU 35
  3987	032416	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  3988	032417	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  3989						STOP^
  3990	032420	254 04 0 00 032421 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3991	032421	324 00 0 00 032422 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3992									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3993									;IN THE SUBTEST) TO LOOP ON ERROR^
  3994	032422	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  3995						STOP^
  3996	032423	254 04 0 00 032424 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  3997	032424	324 00 0 00 032425 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  3998									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  3999									;IN THE SUBTEST) TO LOOP ON ERROR^
  4000					;**********
  4001
  4002					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4003					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4004					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4005					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4006					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4007					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4008					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4009
  4010			006431		SN=SN+1
  4011		000100	000000			ZZ=ZZ+ZZ
  4012						IFE	ZZ,<ZZ=1>
  4013	032425	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4014	032426	200 01 0 00 070315 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4015									;WHERE X VARIES FROM 0 THRU 35
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0095

  4016	032427	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4017	032430	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4018						STOP^
  4019	032431	254 04 0 00 032432 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4020	032432	324 00 0 00 032433 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4021									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4022									;IN THE SUBTEST) TO LOOP ON ERROR^
  4023	032433	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4024						STOP^
  4025	032434	254 04 0 00 032435 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4026	032435	324 00 0 00 032436 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4027									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4028									;IN THE SUBTEST) TO LOOP ON ERROR^
  4029					;**********
  4030
  4031					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4032					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4033					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4034					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4035					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4036					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4037					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4038
  4039			006432		SN=SN+1
  4040		000200	000000			ZZ=ZZ+ZZ
  4041						IFE	ZZ,<ZZ=1>
  4042	032436	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4043	032437	200 01 0 00 070316 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4044									;WHERE X VARIES FROM 0 THRU 35
  4045	032440	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4046	032441	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4047						STOP^
  4048	032442	254 04 0 00 032443 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4049	032443	324 00 0 00 032444 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4050									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4051									;IN THE SUBTEST) TO LOOP ON ERROR^
  4052	032444	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4053						STOP^
  4054	032445	254 04 0 00 032446 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4055	032446	324 00 0 00 032447 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4056									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4057									;IN THE SUBTEST) TO LOOP ON ERROR^
  4058					;**********
  4059
  4060					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4061					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4062					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4063					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4064					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4065					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4066					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4067
  4068			006433		SN=SN+1
  4069		000400	000000			ZZ=ZZ+ZZ
  4070						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-15
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0096

  4071	032447	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4072	032450	200 01 0 00 070264 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4073									;WHERE X VARIES FROM 0 THRU 35
  4074	032451	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4075	032452	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4076						STOP^
  4077	032453	254 04 0 00 032454 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4078	032454	324 00 0 00 032455 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4079									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4080									;IN THE SUBTEST) TO LOOP ON ERROR^
  4081	032455	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4082						STOP^
  4083	032456	254 04 0 00 032457 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4084	032457	324 00 0 00 032460 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4085									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4086									;IN THE SUBTEST) TO LOOP ON ERROR^
  4087					;**********
  4088
  4089					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4090					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4091					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4092					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4093					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4094					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4095					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4096
  4097			006434		SN=SN+1
  4098		001000	000000			ZZ=ZZ+ZZ
  4099						IFE	ZZ,<ZZ=1>
  4100	032460	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4101	032461	200 01 0 00 070317 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4102									;WHERE X VARIES FROM 0 THRU 35
  4103	032462	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4104	032463	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4105						STOP^
  4106	032464	254 04 0 00 032465 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4107	032465	324 00 0 00 032466 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4108									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4109									;IN THE SUBTEST) TO LOOP ON ERROR^
  4110	032466	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4111						STOP^
  4112	032467	254 04 0 00 032470 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4113	032470	324 00 0 00 032471 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4114									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4115									;IN THE SUBTEST) TO LOOP ON ERROR^
  4116					;**********
  4117
  4118					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4119					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4120					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4121					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4122					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4123					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4124					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4125
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-16
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0097

  4126			006435		SN=SN+1
  4127		002000	000000			ZZ=ZZ+ZZ
  4128						IFE	ZZ,<ZZ=1>
  4129	032471	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4130	032472	200 01 0 00 070320 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4131									;WHERE X VARIES FROM 0 THRU 35
  4132	032473	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4133	032474	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4134						STOP^
  4135	032475	254 04 0 00 032476 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4136	032476	324 00 0 00 032477 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4137									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4138									;IN THE SUBTEST) TO LOOP ON ERROR^
  4139	032477	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4140						STOP^
  4141	032500	254 04 0 00 032501 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4142	032501	324 00 0 00 032502 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4143									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4144									;IN THE SUBTEST) TO LOOP ON ERROR^
  4145					;**********
  4146
  4147					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4148					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4149					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4150					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4151					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4152					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4153					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4154
  4155			006436		SN=SN+1
  4156		004000	000000			ZZ=ZZ+ZZ
  4157						IFE	ZZ,<ZZ=1>
  4158	032502	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4159	032503	200 01 0 00 070321 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4160									;WHERE X VARIES FROM 0 THRU 35
  4161	032504	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4162	032505	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4163						STOP^
  4164	032506	254 04 0 00 032507 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4165	032507	324 00 0 00 032510 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4166									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4167									;IN THE SUBTEST) TO LOOP ON ERROR^
  4168	032510	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4169						STOP^
  4170	032511	254 04 0 00 032512 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4171	032512	324 00 0 00 032513 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4172									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4173									;IN THE SUBTEST) TO LOOP ON ERROR^
  4174					;**********
  4175
  4176					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4177					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4178					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4179					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4180					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-17
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0098

  4181					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4182					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4183
  4184			006437		SN=SN+1
  4185		010000	000000			ZZ=ZZ+ZZ
  4186						IFE	ZZ,<ZZ=1>
  4187	032513	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4188	032514	200 01 0 00 070322 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4189									;WHERE X VARIES FROM 0 THRU 35
  4190	032515	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4191	032516	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4192						STOP^
  4193	032517	254 04 0 00 032520 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4194	032520	324 00 0 00 032521 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4195									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4196									;IN THE SUBTEST) TO LOOP ON ERROR^
  4197	032521	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4198						STOP^
  4199	032522	254 04 0 00 032523 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4200	032523	324 00 0 00 032524 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4201									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4202									;IN THE SUBTEST) TO LOOP ON ERROR^
  4203					;**********
  4204
  4205					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4206					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4207					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4208					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4209					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4210					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4211					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4212
  4213			006440		SN=SN+1
  4214		020000	000000			ZZ=ZZ+ZZ
  4215						IFE	ZZ,<ZZ=1>
  4216	032524	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4217	032525	200 01 0 00 070323 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4218									;WHERE X VARIES FROM 0 THRU 35
  4219	032526	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4220	032527	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4221						STOP^
  4222	032530	254 04 0 00 032531 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4223	032531	324 00 0 00 032532 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4224									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4225									;IN THE SUBTEST) TO LOOP ON ERROR^
  4226	032532	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4227						STOP^
  4228	032533	254 04 0 00 032534 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4229	032534	324 00 0 00 032535 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4230									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4231									;IN THE SUBTEST) TO LOOP ON ERROR^
  4232					;**********
  4233
  4234					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4235					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-18
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0099

  4236					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4237					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4238					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4239					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4240					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4241
  4242			006441		SN=SN+1
  4243		040000	000000			ZZ=ZZ+ZZ
  4244						IFE	ZZ,<ZZ=1>
  4245	032535	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4246	032536	200 01 0 00 070324 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4247									;WHERE X VARIES FROM 0 THRU 35
  4248	032537	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4249	032540	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4250						STOP^
  4251	032541	254 04 0 00 032542 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4252	032542	324 00 0 00 032543 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4253									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4254									;IN THE SUBTEST) TO LOOP ON ERROR^
  4255	032543	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4256						STOP^
  4257	032544	254 04 0 00 032545 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4258	032545	324 00 0 00 032546 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4259									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4260									;IN THE SUBTEST) TO LOOP ON ERROR^
  4261					;**********
  4262
  4263					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4264					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4265					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4266					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4267					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4268					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4269					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4270
  4271			006442		SN=SN+1
  4272		100000	000000			ZZ=ZZ+ZZ
  4273						IFE	ZZ,<ZZ=1>
  4274	032546	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4275	032547	200 01 0 00 070325 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4276									;WHERE X VARIES FROM 0 THRU 35
  4277	032550	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4278	032551	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4279						STOP^
  4280	032552	254 04 0 00 032553 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4281	032553	324 00 0 00 032554 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4282									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4283									;IN THE SUBTEST) TO LOOP ON ERROR^
  4284	032554	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4285						STOP^
  4286	032555	254 04 0 00 032556 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4287	032556	324 00 0 00 032557 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4288									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4289									;IN THE SUBTEST) TO LOOP ON ERROR^
  4290					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-19
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0100

  4291
  4292					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4293					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4294					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4295					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4296					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4297					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4298					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4299
  4300			006443		SN=SN+1
  4301		200000	000000			ZZ=ZZ+ZZ
  4302						IFE	ZZ,<ZZ=1>
  4303	032557	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4304	032560	200 01 0 00 070326 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4305									;WHERE X VARIES FROM 0 THRU 35
  4306	032561	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4307	032562	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4308						STOP^
  4309	032563	254 04 0 00 032564 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4310	032564	324 00 0 00 032565 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4311									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4312									;IN THE SUBTEST) TO LOOP ON ERROR^
  4313	032565	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4314						STOP^
  4315	032566	254 04 0 00 032567 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4316	032567	324 00 0 00 032570 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4317									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4318									;IN THE SUBTEST) TO LOOP ON ERROR^
  4319					;**********
  4320
  4321					;THIS TEST VERIFIES THAT IF ONE OF THE OPERANDS OF THE AND INSTRUCTION
  4322					;IS ZERO, THE RESULT WILL BE ZERO.  THIS TEST IS REPEATED 36 TIMES WITH
  4323					;ALL ZEROS IN THE AC EXCEPT FOR ONE ONE IN BIT X
  4324					;WHERE X TAKES ON INTEGER VALUES 0 THRU 35.  E CONTAINS ALL ZEROS.
  4325					;THE RESULT SHOULD BE ALL ZEROS IN THE AC.  IF C(AC) IS NON-ZERO,
  4326					;'AND' FAILED.  C(0) IS ALSO CHECKED FOR ALL ZEROS.  IF C(0) IS
  4327					;NON-ZERO, AC0 WAS CLOBBERED BY 'AND'.
  4328
  4329			006444		SN=SN+1
  4330		400000	000000			ZZ=ZZ+ZZ
  4331						IFE	ZZ,<ZZ=1>
  4332	032570	400 00 0 00 000000 		SETZ			;PRESET E TO ALL ZEROS
  4333	032571	200 01 0 00 070256 		MOVE	1,[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN BIT X
  4334									;WHERE X VARIES FROM 0 THRU 35
  4335	032572	404 01 0 00 000000 		AND	1,0		;*AND SHOULD RESULT IN C(AC) = 0
  4336	032573	332 00 0 00 000001 		SKIPE	1		;FAIL IF C(AC) NON-ZERO
  4337						STOP^
  4338	032574	254 04 0 00 032575 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4339	032575	324 00 0 00 032576 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4340									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4341									;IN THE SUBTEST) TO LOOP ON ERROR^
  4342	032576	332 00 0 00 000000 		SKIPE	0		;FAIL IF C(0) IS NON-ZERO
  4343						STOP^
  4344	032577	254 04 0 00 032600 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4345	032600	324 00 0 00 032601 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-20
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0101

  4346									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4347									;IN THE SUBTEST) TO LOOP ON ERROR^
  4348					;**********
  4349
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0102

  4350			006500		SN=6500
  4351			000000			ZZ=0
  4352
  4353					A6500:	REPEAT	^D36,
  4354					<;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4355					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4356					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4357					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4358					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4359					SN=SN+1
  4360						ZZ=ZZ+ZZ
  4361						IFE	ZZ,<ZZ=1>
  4362						MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4363						AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4364									;POSITION WITH ITSELF SHOULD RESULT WITH
  4365									;C(AC) NONZERO
  4366						SKIPN			;PASS TEST IF C(AC) NONZERO
  4367						STOP
  4368					
  4369					;**********
  4370					>
  4371					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4372					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4373					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4374					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4375					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4376			006501		SN=SN+1
  4377			000000			ZZ=ZZ+ZZ
  4378			000001			IFE	ZZ,<ZZ=1>
  4379	032601	200 00 0 00 070265 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4380	032602	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4381									;POSITION WITH ITSELF SHOULD RESULT WITH
  4382									;C(AC) NONZERO
  4383	032603	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4384						STOP^
  4385	032604	254 04 0 00 032605 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4386	032605	324 00 0 00 032606 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4387									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4388									;IN THE SUBTEST) TO LOOP ON ERROR^
  4389
  4390					;**********
  4391
  4392					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4393					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4394					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4395					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4396					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4397			006502		SN=SN+1
  4398			000002			ZZ=ZZ+ZZ
  4399						IFE	ZZ,<ZZ=1>
  4400	032606	200 00 0 00 070266 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4401	032607	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4402									;POSITION WITH ITSELF SHOULD RESULT WITH
  4403									;C(AC) NONZERO
  4404	032610	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0103

  4405						STOP^
  4406	032611	254 04 0 00 032612 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4407	032612	324 00 0 00 032613 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4408									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4409									;IN THE SUBTEST) TO LOOP ON ERROR^
  4410
  4411					;**********
  4412
  4413					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4414					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4415					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4416					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4417					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4418			006503		SN=SN+1
  4419			000004			ZZ=ZZ+ZZ
  4420						IFE	ZZ,<ZZ=1>
  4421	032613	200 00 0 00 070267 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4422	032614	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4423									;POSITION WITH ITSELF SHOULD RESULT WITH
  4424									;C(AC) NONZERO
  4425	032615	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4426						STOP^
  4427	032616	254 04 0 00 032617 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4428	032617	324 00 0 00 032620 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4429									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4430									;IN THE SUBTEST) TO LOOP ON ERROR^
  4431
  4432					;**********
  4433
  4434					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4435					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4436					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4437					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4438					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4439			006504		SN=SN+1
  4440			000010			ZZ=ZZ+ZZ
  4441						IFE	ZZ,<ZZ=1>
  4442	032620	200 00 0 00 070270 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4443	032621	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4444									;POSITION WITH ITSELF SHOULD RESULT WITH
  4445									;C(AC) NONZERO
  4446	032622	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4447						STOP^
  4448	032623	254 04 0 00 032624 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4449	032624	324 00 0 00 032625 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4450									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4451									;IN THE SUBTEST) TO LOOP ON ERROR^
  4452
  4453					;**********
  4454
  4455					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4456					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4457					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4458					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4459					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0104

  4460			006505		SN=SN+1
  4461			000020			ZZ=ZZ+ZZ
  4462						IFE	ZZ,<ZZ=1>
  4463	032625	200 00 0 00 070271 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4464	032626	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4465									;POSITION WITH ITSELF SHOULD RESULT WITH
  4466									;C(AC) NONZERO
  4467	032627	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4468						STOP^
  4469	032630	254 04 0 00 032631 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4470	032631	324 00 0 00 032632 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4471									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4472									;IN THE SUBTEST) TO LOOP ON ERROR^
  4473
  4474					;**********
  4475
  4476					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4477					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4478					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4479					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4480					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4481			006506		SN=SN+1
  4482			000040			ZZ=ZZ+ZZ
  4483						IFE	ZZ,<ZZ=1>
  4484	032632	200 00 0 00 070272 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4485	032633	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4486									;POSITION WITH ITSELF SHOULD RESULT WITH
  4487									;C(AC) NONZERO
  4488	032634	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4489						STOP^
  4490	032635	254 04 0 00 032636 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4491	032636	324 00 0 00 032637 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4492									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4493									;IN THE SUBTEST) TO LOOP ON ERROR^
  4494
  4495					;**********
  4496
  4497					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4498					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4499					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4500					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4501					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4502			006507		SN=SN+1
  4503			000100			ZZ=ZZ+ZZ
  4504						IFE	ZZ,<ZZ=1>
  4505	032637	200 00 0 00 070273 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4506	032640	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4507									;POSITION WITH ITSELF SHOULD RESULT WITH
  4508									;C(AC) NONZERO
  4509	032641	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4510						STOP^
  4511	032642	254 04 0 00 032643 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4512	032643	324 00 0 00 032644 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4513									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4514									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0105

  4515
  4516					;**********
  4517
  4518					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4519					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4520					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4521					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4522					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4523			006510		SN=SN+1
  4524			000200			ZZ=ZZ+ZZ
  4525						IFE	ZZ,<ZZ=1>
  4526	032644	200 00 0 00 070274 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4527	032645	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4528									;POSITION WITH ITSELF SHOULD RESULT WITH
  4529									;C(AC) NONZERO
  4530	032646	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4531						STOP^
  4532	032647	254 04 0 00 032650 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4533	032650	324 00 0 00 032651 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4534									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4535									;IN THE SUBTEST) TO LOOP ON ERROR^
  4536
  4537					;**********
  4538
  4539					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4540					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4541					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4542					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4543					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4544			006511		SN=SN+1
  4545			000400			ZZ=ZZ+ZZ
  4546						IFE	ZZ,<ZZ=1>
  4547	032651	200 00 0 00 070275 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4548	032652	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4549									;POSITION WITH ITSELF SHOULD RESULT WITH
  4550									;C(AC) NONZERO
  4551	032653	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4552						STOP^
  4553	032654	254 04 0 00 032655 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4554	032655	324 00 0 00 032656 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4555									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4556									;IN THE SUBTEST) TO LOOP ON ERROR^
  4557
  4558					;**********
  4559
  4560					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4561					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4562					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4563					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4564					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4565			006512		SN=SN+1
  4566			001000			ZZ=ZZ+ZZ
  4567						IFE	ZZ,<ZZ=1>
  4568	032656	200 00 0 00 070276 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4569	032657	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0106

  4570									;POSITION WITH ITSELF SHOULD RESULT WITH
  4571									;C(AC) NONZERO
  4572	032660	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4573						STOP^
  4574	032661	254 04 0 00 032662 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4575	032662	324 00 0 00 032663 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4576									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4577									;IN THE SUBTEST) TO LOOP ON ERROR^
  4578
  4579					;**********
  4580
  4581					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4582					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4583					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4584					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4585					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4586			006513		SN=SN+1
  4587			002000			ZZ=ZZ+ZZ
  4588						IFE	ZZ,<ZZ=1>
  4589	032663	200 00 0 00 070277 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4590	032664	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4591									;POSITION WITH ITSELF SHOULD RESULT WITH
  4592									;C(AC) NONZERO
  4593	032665	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4594						STOP^
  4595	032666	254 04 0 00 032667 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4596	032667	324 00 0 00 032670 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4597									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4598									;IN THE SUBTEST) TO LOOP ON ERROR^
  4599
  4600					;**********
  4601
  4602					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4603					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4604					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4605					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4606					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4607			006514		SN=SN+1
  4608			004000			ZZ=ZZ+ZZ
  4609						IFE	ZZ,<ZZ=1>
  4610	032670	200 00 0 00 070300 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4611	032671	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4612									;POSITION WITH ITSELF SHOULD RESULT WITH
  4613									;C(AC) NONZERO
  4614	032672	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4615						STOP^
  4616	032673	254 04 0 00 032674 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4617	032674	324 00 0 00 032675 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4618									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4619									;IN THE SUBTEST) TO LOOP ON ERROR^
  4620
  4621					;**********
  4622
  4623					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4624					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0107

  4625					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4626					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4627					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4628			006515		SN=SN+1
  4629			010000			ZZ=ZZ+ZZ
  4630						IFE	ZZ,<ZZ=1>
  4631	032675	200 00 0 00 070301 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4632	032676	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4633									;POSITION WITH ITSELF SHOULD RESULT WITH
  4634									;C(AC) NONZERO
  4635	032677	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4636						STOP^
  4637	032700	254 04 0 00 032701 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4638	032701	324 00 0 00 032702 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4639									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4640									;IN THE SUBTEST) TO LOOP ON ERROR^
  4641
  4642					;**********
  4643
  4644					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4645					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4646					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4647					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4648					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4649			006516		SN=SN+1
  4650			020000			ZZ=ZZ+ZZ
  4651						IFE	ZZ,<ZZ=1>
  4652	032702	200 00 0 00 070302 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4653	032703	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4654									;POSITION WITH ITSELF SHOULD RESULT WITH
  4655									;C(AC) NONZERO
  4656	032704	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4657						STOP^
  4658	032705	254 04 0 00 032706 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4659	032706	324 00 0 00 032707 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4660									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4661									;IN THE SUBTEST) TO LOOP ON ERROR^
  4662
  4663					;**********
  4664
  4665					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4666					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4667					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4668					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4669					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4670			006517		SN=SN+1
  4671			040000			ZZ=ZZ+ZZ
  4672						IFE	ZZ,<ZZ=1>
  4673	032707	200 00 0 00 070303 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4674	032710	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4675									;POSITION WITH ITSELF SHOULD RESULT WITH
  4676									;C(AC) NONZERO
  4677	032711	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4678						STOP^
  4679	032712	254 04 0 00 032713 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0108

  4680	032713	324 00 0 00 032714 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4681									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4682									;IN THE SUBTEST) TO LOOP ON ERROR^
  4683
  4684					;**********
  4685
  4686					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4687					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4688					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4689					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4690					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4691			006520		SN=SN+1
  4692			100000			ZZ=ZZ+ZZ
  4693						IFE	ZZ,<ZZ=1>
  4694	032714	200 00 0 00 070304 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4695	032715	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4696									;POSITION WITH ITSELF SHOULD RESULT WITH
  4697									;C(AC) NONZERO
  4698	032716	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4699						STOP^
  4700	032717	254 04 0 00 032720 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4701	032720	324 00 0 00 032721 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4702									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4703									;IN THE SUBTEST) TO LOOP ON ERROR^
  4704
  4705					;**********
  4706
  4707					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4708					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4709					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4710					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4711					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4712			006521		SN=SN+1
  4713			200000			ZZ=ZZ+ZZ
  4714						IFE	ZZ,<ZZ=1>
  4715	032721	200 00 0 00 070305 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4716	032722	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4717									;POSITION WITH ITSELF SHOULD RESULT WITH
  4718									;C(AC) NONZERO
  4719	032723	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4720						STOP^
  4721	032724	254 04 0 00 032725 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4722	032725	324 00 0 00 032726 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4723									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4724									;IN THE SUBTEST) TO LOOP ON ERROR^
  4725
  4726					;**********
  4727
  4728					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4729					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4730					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4731					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4732					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4733			006522		SN=SN+1
  4734			400000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0109

  4735						IFE	ZZ,<ZZ=1>
  4736	032726	200 00 0 00 070306 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4737	032727	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4738									;POSITION WITH ITSELF SHOULD RESULT WITH
  4739									;C(AC) NONZERO
  4740	032730	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4741						STOP^
  4742	032731	254 04 0 00 032732 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4743	032732	324 00 0 00 032733 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4744									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4745									;IN THE SUBTEST) TO LOOP ON ERROR^
  4746
  4747					;**********
  4748
  4749					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4750					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4751					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4752					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4753					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4754			006523		SN=SN+1
  4755		000001	000000			ZZ=ZZ+ZZ
  4756						IFE	ZZ,<ZZ=1>
  4757	032733	200 00 0 00 070307 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4758	032734	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4759									;POSITION WITH ITSELF SHOULD RESULT WITH
  4760									;C(AC) NONZERO
  4761	032735	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4762						STOP^
  4763	032736	254 04 0 00 032737 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4764	032737	324 00 0 00 032740 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4765									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4766									;IN THE SUBTEST) TO LOOP ON ERROR^
  4767
  4768					;**********
  4769
  4770					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4771					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4772					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4773					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4774					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4775			006524		SN=SN+1
  4776		000002	000000			ZZ=ZZ+ZZ
  4777						IFE	ZZ,<ZZ=1>
  4778	032740	200 00 0 00 070310 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4779	032741	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4780									;POSITION WITH ITSELF SHOULD RESULT WITH
  4781									;C(AC) NONZERO
  4782	032742	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4783						STOP^
  4784	032743	254 04 0 00 032744 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4785	032744	324 00 0 00 032745 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4786									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4787									;IN THE SUBTEST) TO LOOP ON ERROR^
  4788
  4789					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0110

  4790
  4791					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4792					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4793					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4794					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4795					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4796			006525		SN=SN+1
  4797		000004	000000			ZZ=ZZ+ZZ
  4798						IFE	ZZ,<ZZ=1>
  4799	032745	200 00 0 00 070311 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4800	032746	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4801									;POSITION WITH ITSELF SHOULD RESULT WITH
  4802									;C(AC) NONZERO
  4803	032747	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4804						STOP^
  4805	032750	254 04 0 00 032751 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4806	032751	324 00 0 00 032752 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4807									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4808									;IN THE SUBTEST) TO LOOP ON ERROR^
  4809
  4810					;**********
  4811
  4812					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4813					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4814					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4815					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4816					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4817			006526		SN=SN+1
  4818		000010	000000			ZZ=ZZ+ZZ
  4819						IFE	ZZ,<ZZ=1>
  4820	032752	200 00 0 00 070312 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4821	032753	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4822									;POSITION WITH ITSELF SHOULD RESULT WITH
  4823									;C(AC) NONZERO
  4824	032754	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4825						STOP^
  4826	032755	254 04 0 00 032756 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4827	032756	324 00 0 00 032757 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4828									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4829									;IN THE SUBTEST) TO LOOP ON ERROR^
  4830
  4831					;**********
  4832
  4833					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4834					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4835					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4836					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4837					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4838			006527		SN=SN+1
  4839		000020	000000			ZZ=ZZ+ZZ
  4840						IFE	ZZ,<ZZ=1>
  4841	032757	200 00 0 00 070313 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4842	032760	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4843									;POSITION WITH ITSELF SHOULD RESULT WITH
  4844									;C(AC) NONZERO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0111

  4845	032761	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4846						STOP^
  4847	032762	254 04 0 00 032763 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4848	032763	324 00 0 00 032764 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4849									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4850									;IN THE SUBTEST) TO LOOP ON ERROR^
  4851
  4852					;**********
  4853
  4854					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4855					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4856					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4857					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4858					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4859			006530		SN=SN+1
  4860		000040	000000			ZZ=ZZ+ZZ
  4861						IFE	ZZ,<ZZ=1>
  4862	032764	200 00 0 00 070314 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4863	032765	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4864									;POSITION WITH ITSELF SHOULD RESULT WITH
  4865									;C(AC) NONZERO
  4866	032766	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4867						STOP^
  4868	032767	254 04 0 00 032770 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4869	032770	324 00 0 00 032771 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4870									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4871									;IN THE SUBTEST) TO LOOP ON ERROR^
  4872
  4873					;**********
  4874
  4875					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4876					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4877					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4878					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4879					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4880			006531		SN=SN+1
  4881		000100	000000			ZZ=ZZ+ZZ
  4882						IFE	ZZ,<ZZ=1>
  4883	032771	200 00 0 00 070315 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4884	032772	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4885									;POSITION WITH ITSELF SHOULD RESULT WITH
  4886									;C(AC) NONZERO
  4887	032773	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4888						STOP^
  4889	032774	254 04 0 00 032775 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4890	032775	324 00 0 00 032776 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4891									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4892									;IN THE SUBTEST) TO LOOP ON ERROR^
  4893
  4894					;**********
  4895
  4896					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4897					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4898					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4899					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0112

  4900					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4901			006532		SN=SN+1
  4902		000200	000000			ZZ=ZZ+ZZ
  4903						IFE	ZZ,<ZZ=1>
  4904	032776	200 00 0 00 070316 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4905	032777	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4906									;POSITION WITH ITSELF SHOULD RESULT WITH
  4907									;C(AC) NONZERO
  4908	033000	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4909						STOP^
  4910	033001	254 04 0 00 033002 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4911	033002	324 00 0 00 033003 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4912									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4913									;IN THE SUBTEST) TO LOOP ON ERROR^
  4914
  4915					;**********
  4916
  4917					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4918					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4919					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4920					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4921					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4922			006533		SN=SN+1
  4923		000400	000000			ZZ=ZZ+ZZ
  4924						IFE	ZZ,<ZZ=1>
  4925	033003	200 00 0 00 070264 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4926	033004	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4927									;POSITION WITH ITSELF SHOULD RESULT WITH
  4928									;C(AC) NONZERO
  4929	033005	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4930						STOP^
  4931	033006	254 04 0 00 033007 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4932	033007	324 00 0 00 033010 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4933									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4934									;IN THE SUBTEST) TO LOOP ON ERROR^
  4935
  4936					;**********
  4937
  4938					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4939					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4940					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4941					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4942					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4943			006534		SN=SN+1
  4944		001000	000000			ZZ=ZZ+ZZ
  4945						IFE	ZZ,<ZZ=1>
  4946	033010	200 00 0 00 070317 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4947	033011	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4948									;POSITION WITH ITSELF SHOULD RESULT WITH
  4949									;C(AC) NONZERO
  4950	033012	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4951						STOP^
  4952	033013	254 04 0 00 033014 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4953	033014	324 00 0 00 033015 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4954									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0113

  4955									;IN THE SUBTEST) TO LOOP ON ERROR^
  4956
  4957					;**********
  4958
  4959					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4960					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4961					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4962					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4963					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4964			006535		SN=SN+1
  4965		002000	000000			ZZ=ZZ+ZZ
  4966						IFE	ZZ,<ZZ=1>
  4967	033015	200 00 0 00 070320 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4968	033016	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4969									;POSITION WITH ITSELF SHOULD RESULT WITH
  4970									;C(AC) NONZERO
  4971	033017	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4972						STOP^
  4973	033020	254 04 0 00 033021 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4974	033021	324 00 0 00 033022 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4975									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4976									;IN THE SUBTEST) TO LOOP ON ERROR^
  4977
  4978					;**********
  4979
  4980					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  4981					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  4982					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  4983					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  4984					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  4985			006536		SN=SN+1
  4986		004000	000000			ZZ=ZZ+ZZ
  4987						IFE	ZZ,<ZZ=1>
  4988	033022	200 00 0 00 070321 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  4989	033023	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  4990									;POSITION WITH ITSELF SHOULD RESULT WITH
  4991									;C(AC) NONZERO
  4992	033024	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  4993						STOP^
  4994	033025	254 04 0 00 033026 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  4995	033026	324 00 0 00 033027 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  4996									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  4997									;IN THE SUBTEST) TO LOOP ON ERROR^
  4998
  4999					;**********
  5000
  5001					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  5002					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5003					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5004					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5005					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5006			006537		SN=SN+1
  5007		010000	000000			ZZ=ZZ+ZZ
  5008						IFE	ZZ,<ZZ=1>
  5009	033027	200 00 0 00 070322 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0114

  5010	033030	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5011									;POSITION WITH ITSELF SHOULD RESULT WITH
  5012									;C(AC) NONZERO
  5013	033031	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5014						STOP^
  5015	033032	254 04 0 00 033033 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5016	033033	324 00 0 00 033034 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5017									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5018									;IN THE SUBTEST) TO LOOP ON ERROR^
  5019
  5020					;**********
  5021
  5022					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  5023					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5024					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5025					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5026					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5027			006540		SN=SN+1
  5028		020000	000000			ZZ=ZZ+ZZ
  5029						IFE	ZZ,<ZZ=1>
  5030	033034	200 00 0 00 070323 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  5031	033035	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5032									;POSITION WITH ITSELF SHOULD RESULT WITH
  5033									;C(AC) NONZERO
  5034	033036	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5035						STOP^
  5036	033037	254 04 0 00 033040 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5037	033040	324 00 0 00 033041 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5038									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5039									;IN THE SUBTEST) TO LOOP ON ERROR^
  5040
  5041					;**********
  5042
  5043					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  5044					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5045					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5046					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5047					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5048			006541		SN=SN+1
  5049		040000	000000			ZZ=ZZ+ZZ
  5050						IFE	ZZ,<ZZ=1>
  5051	033041	200 00 0 00 070324 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  5052	033042	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5053									;POSITION WITH ITSELF SHOULD RESULT WITH
  5054									;C(AC) NONZERO
  5055	033043	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5056						STOP^
  5057	033044	254 04 0 00 033045 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5058	033045	324 00 0 00 033046 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5059									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5060									;IN THE SUBTEST) TO LOOP ON ERROR^
  5061
  5062					;**********
  5063
  5064					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0115

  5065					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5066					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5067					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5068					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5069			006542		SN=SN+1
  5070		100000	000000			ZZ=ZZ+ZZ
  5071						IFE	ZZ,<ZZ=1>
  5072	033046	200 00 0 00 070325 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  5073	033047	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5074									;POSITION WITH ITSELF SHOULD RESULT WITH
  5075									;C(AC) NONZERO
  5076	033050	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5077						STOP^
  5078	033051	254 04 0 00 033052 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5079	033052	324 00 0 00 033053 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5080									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5081									;IN THE SUBTEST) TO LOOP ON ERROR^
  5082
  5083					;**********
  5084
  5085					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  5086					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5087					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5088					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5089					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5090			006543		SN=SN+1
  5091		200000	000000			ZZ=ZZ+ZZ
  5092						IFE	ZZ,<ZZ=1>
  5093	033053	200 00 0 00 070326 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  5094	033054	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5095									;POSITION WITH ITSELF SHOULD RESULT WITH
  5096									;C(AC) NONZERO
  5097	033055	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5098						STOP^
  5099	033056	254 04 0 00 033057 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5100	033057	324 00 0 00 033060 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5101									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5102									;IN THE SUBTEST) TO LOOP ON ERROR^
  5103
  5104					;**********
  5105
  5106					;THIS TEST VERIFIES THAT THE RESULT OF A WORD ANDED WITH ITSELF
  5107					;SHOULD BE THAT SAME WORD.  A WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE
  5108					;IN ONLY ONE BIT IS ANDED WITH ITSELF.  THE AC IS THEN CHECKED FOR ITS
  5109					;CONTENTS NONZERO.  IF C(AC)=0, THE 'AND' INSTRUCTION FAILED.  THIS TEST IS REPEATED
  5110					;36 TIMES TO CHECK EACH BIT INDIVIDUALLY.
  5111			006544		SN=SN+1
  5112		400000	000000			ZZ=ZZ+ZZ
  5113						IFE	ZZ,<ZZ=1>
  5114	033060	200 00 0 00 070256 		MOVE	[ZZ]		;LOAD AC WITH ALL ZEROS EXCEPT FOR A ONE IN ONE BIT
  5115	033061	404 00 0 00 000000 		AND			;*AND OF WORD CONTAINING A ONE IN ONE BIT
  5116									;POSITION WITH ITSELF SHOULD RESULT WITH
  5117									;C(AC) NONZERO
  5118	033062	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NONZERO
  5119						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0116

  5120	033063	254 04 0 00 033064 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5121	033064	324 00 0 00 033065 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5122									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5123									;IN THE SUBTEST) TO LOOP ON ERROR^
  5124
  5125					;**********
  5126
  5127					;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE
  5128					;C(AC)=0 AND C(E)=0 AND E OUTSIDE OF THE AC RANGE IS ALL ZEROS IN THE AC.
  5129					;FIRST, THE AC IS CLEARED; THEN, THE C(AC) IS ANDED WITH C(E) WHEN
  5130					;E GREATER THAN 20 AND C(E)=0. THE RESULT SHOULD BE C(AC)=0.
  5131					;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
  5132
  5133	033065	200 00 0 00 070253 	A6600:	MOVE	[0]		;PRESET AC TO ALL ZEROS
  5134	033066	404 00 0 00 070253 		AND	[0]		;*AND OF TWO WORDS OF ALL ZEROS
  5135									;SHOULD RESULT IN C(AC)=0
  5136	033067	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  5137						STOP^
  5138	033070	254 04 0 00 033071 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5139	033071	324 00 0 00 033072 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5140									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5141									;IN THE SUBTEST) TO LOOP ON ERROR^
  5142
  5143					;**********
  5144
  5145					;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(AC)=0
  5146					;AND C(E) IS ALL ONES IS AN AC CONTAINING ALL ZEROS.  FIRST, THE AC IS
  5147					;CLEARED; THEN THE C(AC) IS ANDED WITH AN E CONTAINING ALL ONES, WHERE
  5148					;E IS BEYOND THE AC RANGE.  THE RESULT SHOULD BE C(AC)=0.
  5149					;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
  5150
  5151	033072	200 00 0 00 070253 	A6700:	MOVE	[0]		;PRESET AC TO ALL ZEROS
  5152	033073	404 00 0 00 070254 		AND	[-1]		;*AND OF TWO WORDS WHERE C(AC)=0 SHOULD RESULT IN C(AC)=0
  5153	033074	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  5154						STOP^
  5155	033075	254 04 0 00 033076 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5156	033076	324 00 0 00 033077 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5157									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5158									;IN THE SUBTEST) TO LOOP ON ERROR^
  5159
  5160					;AD FM+EN [ADFP],AD FM+EN A [ADFP],
  5161					;F CYC ACT EN C [F1],IR BOOLE AD FM+F [IR2],
  5162					;IR BOOLE [IR1],IRXX(1,4,5,11,13,16) [IR2]
  5163
  5164					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0117

  5165					;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E)=0
  5166					;AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ZEROS. FIRST, THE
  5167					;AC IS SET TO ALL ONES; THEN, THE AC IS ANDED WITH AN E CONTAINING ALL
  5168					;ZEROS, WHERE E IS BEYOND THE AC RANGE.  THE RESULT SHOULD BE C(AC)=0.
  5169					;IF C(AC) IS NON-ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
  5170
  5171	033077	200 00 0 00 070254 	A7000:	MOVE	[-1]		;PRESET AC TO ALL ONES
  5172	033100	404 00 0 00 070253 		AND	[0]		;*AND OF TWO WORDS WHERE C(E)=0 SHOULD RESULT IN C(AC)=0
  5173	033101	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  5174						STOP^
  5175	033102	254 04 0 00 033103 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5176	033103	324 00 0 00 033104 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5177									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5178									;IN THE SUBTEST) TO LOOP ON ERROR^
  5179
  5180					;**********
  5181
  5182					;THIS TEST VERIFIES THAT THE RESULT OF THE AND INSTRUCTION WHERE C(E) IS
  5183					;ALL ONES AND C(AC) IS ALL ONES IS AN AC CONTAINING ALL ONES.  FIRST, THE
  5184					;AC IS SET TO ALL ONES; THEN, C(AC) IS ANDED WITH AN E CONTAINING ALL
  5185					;ONES.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5186					;IF C(AC) IS ZERO, 'AND' FAILED WITH THE MEMORY OPERAND.
  5187
  5188	033104	200 00 0 00 070254 	A7100:	MOVE	[-1]		;PRELOAD AC WITH ALL ONES
  5189	033105	404 00 0 00 070254 		AND	[-1]		;*AND OF TWO WORDS OF ALL ONES SHOULD
  5190									;RESULT IN C(AC)=ALL ONES
  5191	033106	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON ZERO
  5192						STOP^
  5193	033107	254 04 0 00 033110 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5194	033110	324 00 0 00 033111 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5195									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5196									;IN THE SUBTEST) TO LOOP ON ERROR^
  5197
  5198					;**********
  5199
  5200					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE 
  5201					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHERE CONTENTS IS NON-ZERO.
  5202					;FIRST, THE AC IS CLEARED, THEN, XOR IS EXECUTED WHERE C(E) IS NON-ZERO.
  5203					;THE AC IS THEN CHECKED FOR NON-ZERO CONTENTS.
  5204	033111	200 00 0 00 070253 	A7200:	MOVE	[0]		;CLEAR AC
  5205	033112	430 00 0 00 070332 		XOR	[707070707070]	;*XOR WITH C(AC)=0 AND C(E)=7070707070 SHOULD
  5206									;RESTULT IN C(AC)=707070707070
  5207	033113	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5208						STOP^
  5209	033114	254 04 0 00 033115 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5210	033115	324 00 0 00 033116 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5211									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5212									;IN THE SUBTEST) TO LOOP ON ERROR^
  5213
  5214					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0118

  5215			007300		SN=7300
  5216			000000			ZZ=0
  5217
  5218					A7300:	REPEAT	^D36,
  5219					<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5220					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5221					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5222					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5223					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5224					SN=SN+1
  5225						ZZ=ZZ+ZZ
  5226						IFE	ZZ,<ZZ=1>
  5227						MOVE	[0]		;CLEAR AC
  5228						XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5229									;RESULT IN C(AC) NONZERO
  5230						SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5231						STOP
  5232					
  5233					;**********
  5234					>
  5235					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5236					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5237					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5238					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5239					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5240			007301		SN=SN+1
  5241			000000			ZZ=ZZ+ZZ
  5242			000001			IFE	ZZ,<ZZ=1>
  5243	033116	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5244	033117	430 00 0 00 070265 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5245									;RESULT IN C(AC) NONZERO
  5246	033120	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5247						STOP^
  5248	033121	254 04 0 00 033122 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5249	033122	324 00 0 00 033123 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5250									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5251									;IN THE SUBTEST) TO LOOP ON ERROR^
  5252
  5253					;**********
  5254
  5255					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5256					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5257					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5258					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5259					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5260			007302		SN=SN+1
  5261			000002			ZZ=ZZ+ZZ
  5262						IFE	ZZ,<ZZ=1>
  5263	033123	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5264	033124	430 00 0 00 070266 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5265									;RESULT IN C(AC) NONZERO
  5266	033125	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5267						STOP^
  5268	033126	254 04 0 00 033127 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5269	033127	324 00 0 00 033130 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0119

  5270									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5271									;IN THE SUBTEST) TO LOOP ON ERROR^
  5272
  5273					;**********
  5274
  5275					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5276					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5277					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5278					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5279					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5280			007303		SN=SN+1
  5281			000004			ZZ=ZZ+ZZ
  5282						IFE	ZZ,<ZZ=1>
  5283	033130	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5284	033131	430 00 0 00 070267 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5285									;RESULT IN C(AC) NONZERO
  5286	033132	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5287						STOP^
  5288	033133	254 04 0 00 033134 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5289	033134	324 00 0 00 033135 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5290									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5291									;IN THE SUBTEST) TO LOOP ON ERROR^
  5292
  5293					;**********
  5294
  5295					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5296					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5297					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5298					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5299					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5300			007304		SN=SN+1
  5301			000010			ZZ=ZZ+ZZ
  5302						IFE	ZZ,<ZZ=1>
  5303	033135	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5304	033136	430 00 0 00 070270 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5305									;RESULT IN C(AC) NONZERO
  5306	033137	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5307						STOP^
  5308	033140	254 04 0 00 033141 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5309	033141	324 00 0 00 033142 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5310									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5311									;IN THE SUBTEST) TO LOOP ON ERROR^
  5312
  5313					;**********
  5314
  5315					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5316					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5317					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5318					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5319					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5320			007305		SN=SN+1
  5321			000020			ZZ=ZZ+ZZ
  5322						IFE	ZZ,<ZZ=1>
  5323	033142	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5324	033143	430 00 0 00 070271 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0120

  5325									;RESULT IN C(AC) NONZERO
  5326	033144	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5327						STOP^
  5328	033145	254 04 0 00 033146 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5329	033146	324 00 0 00 033147 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5330									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5331									;IN THE SUBTEST) TO LOOP ON ERROR^
  5332
  5333					;**********
  5334
  5335					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5336					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5337					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5338					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5339					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5340			007306		SN=SN+1
  5341			000040			ZZ=ZZ+ZZ
  5342						IFE	ZZ,<ZZ=1>
  5343	033147	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5344	033150	430 00 0 00 070272 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5345									;RESULT IN C(AC) NONZERO
  5346	033151	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5347						STOP^
  5348	033152	254 04 0 00 033153 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5349	033153	324 00 0 00 033154 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5350									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5351									;IN THE SUBTEST) TO LOOP ON ERROR^
  5352
  5353					;**********
  5354
  5355					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5356					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5357					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5358					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5359					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5360			007307		SN=SN+1
  5361			000100			ZZ=ZZ+ZZ
  5362						IFE	ZZ,<ZZ=1>
  5363	033154	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5364	033155	430 00 0 00 070273 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5365									;RESULT IN C(AC) NONZERO
  5366	033156	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5367						STOP^
  5368	033157	254 04 0 00 033160 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5369	033160	324 00 0 00 033161 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5370									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5371									;IN THE SUBTEST) TO LOOP ON ERROR^
  5372
  5373					;**********
  5374
  5375					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5376					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5377					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5378					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5379					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0121

  5380			007310		SN=SN+1
  5381			000200			ZZ=ZZ+ZZ
  5382						IFE	ZZ,<ZZ=1>
  5383	033161	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5384	033162	430 00 0 00 070274 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5385									;RESULT IN C(AC) NONZERO
  5386	033163	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5387						STOP^
  5388	033164	254 04 0 00 033165 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5389	033165	324 00 0 00 033166 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5390									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5391									;IN THE SUBTEST) TO LOOP ON ERROR^
  5392
  5393					;**********
  5394
  5395					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5396					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5397					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5398					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5399					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5400			007311		SN=SN+1
  5401			000400			ZZ=ZZ+ZZ
  5402						IFE	ZZ,<ZZ=1>
  5403	033166	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5404	033167	430 00 0 00 070275 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5405									;RESULT IN C(AC) NONZERO
  5406	033170	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5407						STOP^
  5408	033171	254 04 0 00 033172 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5409	033172	324 00 0 00 033173 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5410									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5411									;IN THE SUBTEST) TO LOOP ON ERROR^
  5412
  5413					;**********
  5414
  5415					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5416					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5417					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5418					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5419					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5420			007312		SN=SN+1
  5421			001000			ZZ=ZZ+ZZ
  5422						IFE	ZZ,<ZZ=1>
  5423	033173	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5424	033174	430 00 0 00 070276 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5425									;RESULT IN C(AC) NONZERO
  5426	033175	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5427						STOP^
  5428	033176	254 04 0 00 033177 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5429	033177	324 00 0 00 033200 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5430									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5431									;IN THE SUBTEST) TO LOOP ON ERROR^
  5432
  5433					;**********
  5434
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0122

  5435					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5436					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5437					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5438					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5439					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5440			007313		SN=SN+1
  5441			002000			ZZ=ZZ+ZZ
  5442						IFE	ZZ,<ZZ=1>
  5443	033200	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5444	033201	430 00 0 00 070277 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5445									;RESULT IN C(AC) NONZERO
  5446	033202	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5447						STOP^
  5448	033203	254 04 0 00 033204 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5449	033204	324 00 0 00 033205 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5450									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5451									;IN THE SUBTEST) TO LOOP ON ERROR^
  5452
  5453					;**********
  5454
  5455					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5456					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5457					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5458					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5459					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5460			007314		SN=SN+1
  5461			004000			ZZ=ZZ+ZZ
  5462						IFE	ZZ,<ZZ=1>
  5463	033205	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5464	033206	430 00 0 00 070300 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5465									;RESULT IN C(AC) NONZERO
  5466	033207	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5467						STOP^
  5468	033210	254 04 0 00 033211 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5469	033211	324 00 0 00 033212 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5470									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5471									;IN THE SUBTEST) TO LOOP ON ERROR^
  5472
  5473					;**********
  5474
  5475					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5476					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5477					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5478					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5479					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5480			007315		SN=SN+1
  5481			010000			ZZ=ZZ+ZZ
  5482						IFE	ZZ,<ZZ=1>
  5483	033212	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5484	033213	430 00 0 00 070301 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5485									;RESULT IN C(AC) NONZERO
  5486	033214	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5487						STOP^
  5488	033215	254 04 0 00 033216 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5489	033216	324 00 0 00 033217 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0123

  5490									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5491									;IN THE SUBTEST) TO LOOP ON ERROR^
  5492
  5493					;**********
  5494
  5495					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5496					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5497					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5498					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5499					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5500			007316		SN=SN+1
  5501			020000			ZZ=ZZ+ZZ
  5502						IFE	ZZ,<ZZ=1>
  5503	033217	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5504	033220	430 00 0 00 070302 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5505									;RESULT IN C(AC) NONZERO
  5506	033221	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5507						STOP^
  5508	033222	254 04 0 00 033223 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5509	033223	324 00 0 00 033224 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5510									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5511									;IN THE SUBTEST) TO LOOP ON ERROR^
  5512
  5513					;**********
  5514
  5515					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5516					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5517					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5518					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5519					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5520			007317		SN=SN+1
  5521			040000			ZZ=ZZ+ZZ
  5522						IFE	ZZ,<ZZ=1>
  5523	033224	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5524	033225	430 00 0 00 070303 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5525									;RESULT IN C(AC) NONZERO
  5526	033226	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5527						STOP^
  5528	033227	254 04 0 00 033230 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5529	033230	324 00 0 00 033231 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5530									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5531									;IN THE SUBTEST) TO LOOP ON ERROR^
  5532
  5533					;**********
  5534
  5535					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5536					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5537					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5538					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5539					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5540			007320		SN=SN+1
  5541			100000			ZZ=ZZ+ZZ
  5542						IFE	ZZ,<ZZ=1>
  5543	033231	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5544	033232	430 00 0 00 070304 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0124

  5545									;RESULT IN C(AC) NONZERO
  5546	033233	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5547						STOP^
  5548	033234	254 04 0 00 033235 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5549	033235	324 00 0 00 033236 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5550									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5551									;IN THE SUBTEST) TO LOOP ON ERROR^
  5552
  5553					;**********
  5554
  5555					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5556					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5557					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5558					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5559					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5560			007321		SN=SN+1
  5561			200000			ZZ=ZZ+ZZ
  5562						IFE	ZZ,<ZZ=1>
  5563	033236	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5564	033237	430 00 0 00 070305 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5565									;RESULT IN C(AC) NONZERO
  5566	033240	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5567						STOP^
  5568	033241	254 04 0 00 033242 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5569	033242	324 00 0 00 033243 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5570									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5571									;IN THE SUBTEST) TO LOOP ON ERROR^
  5572
  5573					;**********
  5574
  5575					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5576					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5577					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5578					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5579					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5580			007322		SN=SN+1
  5581			400000			ZZ=ZZ+ZZ
  5582						IFE	ZZ,<ZZ=1>
  5583	033243	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5584	033244	430 00 0 00 070306 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5585									;RESULT IN C(AC) NONZERO
  5586	033245	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5587						STOP^
  5588	033246	254 04 0 00 033247 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5589	033247	324 00 0 00 033250 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5590									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5591									;IN THE SUBTEST) TO LOOP ON ERROR^
  5592
  5593					;**********
  5594
  5595					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5596					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5597					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5598					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5599					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0125

  5600			007323		SN=SN+1
  5601		000001	000000			ZZ=ZZ+ZZ
  5602						IFE	ZZ,<ZZ=1>
  5603	033250	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5604	033251	430 00 0 00 070307 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5605									;RESULT IN C(AC) NONZERO
  5606	033252	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5607						STOP^
  5608	033253	254 04 0 00 033254 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5609	033254	324 00 0 00 033255 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5610									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5611									;IN THE SUBTEST) TO LOOP ON ERROR^
  5612
  5613					;**********
  5614
  5615					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5616					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5617					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5618					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5619					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5620			007324		SN=SN+1
  5621		000002	000000			ZZ=ZZ+ZZ
  5622						IFE	ZZ,<ZZ=1>
  5623	033255	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5624	033256	430 00 0 00 070310 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5625									;RESULT IN C(AC) NONZERO
  5626	033257	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5627						STOP^
  5628	033260	254 04 0 00 033261 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5629	033261	324 00 0 00 033262 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5630									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5631									;IN THE SUBTEST) TO LOOP ON ERROR^
  5632
  5633					;**********
  5634
  5635					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5636					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5637					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5638					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5639					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5640			007325		SN=SN+1
  5641		000004	000000			ZZ=ZZ+ZZ
  5642						IFE	ZZ,<ZZ=1>
  5643	033262	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5644	033263	430 00 0 00 070311 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5645									;RESULT IN C(AC) NONZERO
  5646	033264	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5647						STOP^
  5648	033265	254 04 0 00 033266 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5649	033266	324 00 0 00 033267 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5650									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5651									;IN THE SUBTEST) TO LOOP ON ERROR^
  5652
  5653					;**********
  5654
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0126

  5655					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5656					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5657					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5658					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5659					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5660			007326		SN=SN+1
  5661		000010	000000			ZZ=ZZ+ZZ
  5662						IFE	ZZ,<ZZ=1>
  5663	033267	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5664	033270	430 00 0 00 070312 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5665									;RESULT IN C(AC) NONZERO
  5666	033271	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5667						STOP^
  5668	033272	254 04 0 00 033273 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5669	033273	324 00 0 00 033274 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5670									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5671									;IN THE SUBTEST) TO LOOP ON ERROR^
  5672
  5673					;**********
  5674
  5675					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5676					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5677					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5678					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5679					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5680			007327		SN=SN+1
  5681		000020	000000			ZZ=ZZ+ZZ
  5682						IFE	ZZ,<ZZ=1>
  5683	033274	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5684	033275	430 00 0 00 070313 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5685									;RESULT IN C(AC) NONZERO
  5686	033276	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5687						STOP^
  5688	033277	254 04 0 00 033300 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5689	033300	324 00 0 00 033301 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5690									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5691									;IN THE SUBTEST) TO LOOP ON ERROR^
  5692
  5693					;**********
  5694
  5695					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5696					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5697					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5698					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5699					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5700			007330		SN=SN+1
  5701		000040	000000			ZZ=ZZ+ZZ
  5702						IFE	ZZ,<ZZ=1>
  5703	033301	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5704	033302	430 00 0 00 070314 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5705									;RESULT IN C(AC) NONZERO
  5706	033303	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5707						STOP^
  5708	033304	254 04 0 00 033305 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5709	033305	324 00 0 00 033306 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0127

  5710									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5711									;IN THE SUBTEST) TO LOOP ON ERROR^
  5712
  5713					;**********
  5714
  5715					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5716					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5717					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5718					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5719					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5720			007331		SN=SN+1
  5721		000100	000000			ZZ=ZZ+ZZ
  5722						IFE	ZZ,<ZZ=1>
  5723	033306	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5724	033307	430 00 0 00 070315 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5725									;RESULT IN C(AC) NONZERO
  5726	033310	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5727						STOP^
  5728	033311	254 04 0 00 033312 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5729	033312	324 00 0 00 033313 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5730									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5731									;IN THE SUBTEST) TO LOOP ON ERROR^
  5732
  5733					;**********
  5734
  5735					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5736					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5737					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5738					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5739					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5740			007332		SN=SN+1
  5741		000200	000000			ZZ=ZZ+ZZ
  5742						IFE	ZZ,<ZZ=1>
  5743	033313	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5744	033314	430 00 0 00 070316 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5745									;RESULT IN C(AC) NONZERO
  5746	033315	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5747						STOP^
  5748	033316	254 04 0 00 033317 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5749	033317	324 00 0 00 033320 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5750									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5751									;IN THE SUBTEST) TO LOOP ON ERROR^
  5752
  5753					;**********
  5754
  5755					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5756					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5757					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5758					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5759					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5760			007333		SN=SN+1
  5761		000400	000000			ZZ=ZZ+ZZ
  5762						IFE	ZZ,<ZZ=1>
  5763	033320	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5764	033321	430 00 0 00 070264 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0128

  5765									;RESULT IN C(AC) NONZERO
  5766	033322	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5767						STOP^
  5768	033323	254 04 0 00 033324 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5769	033324	324 00 0 00 033325 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5770									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5771									;IN THE SUBTEST) TO LOOP ON ERROR^
  5772
  5773					;**********
  5774
  5775					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5776					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5777					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5778					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5779					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5780			007334		SN=SN+1
  5781		001000	000000			ZZ=ZZ+ZZ
  5782						IFE	ZZ,<ZZ=1>
  5783	033325	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5784	033326	430 00 0 00 070317 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5785									;RESULT IN C(AC) NONZERO
  5786	033327	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5787						STOP^
  5788	033330	254 04 0 00 033331 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5789	033331	324 00 0 00 033332 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5790									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5791									;IN THE SUBTEST) TO LOOP ON ERROR^
  5792
  5793					;**********
  5794
  5795					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5796					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5797					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5798					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5799					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5800			007335		SN=SN+1
  5801		002000	000000			ZZ=ZZ+ZZ
  5802						IFE	ZZ,<ZZ=1>
  5803	033332	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5804	033333	430 00 0 00 070320 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5805									;RESULT IN C(AC) NONZERO
  5806	033334	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5807						STOP^
  5808	033335	254 04 0 00 033336 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5809	033336	324 00 0 00 033337 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5810									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5811									;IN THE SUBTEST) TO LOOP ON ERROR^
  5812
  5813					;**********
  5814
  5815					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5816					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5817					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5818					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5819					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0129

  5820			007336		SN=SN+1
  5821		004000	000000			ZZ=ZZ+ZZ
  5822						IFE	ZZ,<ZZ=1>
  5823	033337	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5824	033340	430 00 0 00 070321 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5825									;RESULT IN C(AC) NONZERO
  5826	033341	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5827						STOP^
  5828	033342	254 04 0 00 033343 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5829	033343	324 00 0 00 033344 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5830									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5831									;IN THE SUBTEST) TO LOOP ON ERROR^
  5832
  5833					;**********
  5834
  5835					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5836					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5837					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5838					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5839					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5840			007337		SN=SN+1
  5841		010000	000000			ZZ=ZZ+ZZ
  5842						IFE	ZZ,<ZZ=1>
  5843	033344	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5844	033345	430 00 0 00 070322 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5845									;RESULT IN C(AC) NONZERO
  5846	033346	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5847						STOP^
  5848	033347	254 04 0 00 033350 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5849	033350	324 00 0 00 033351 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5850									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5851									;IN THE SUBTEST) TO LOOP ON ERROR^
  5852
  5853					;**********
  5854
  5855					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5856					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5857					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5858					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5859					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5860			007340		SN=SN+1
  5861		020000	000000			ZZ=ZZ+ZZ
  5862						IFE	ZZ,<ZZ=1>
  5863	033351	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5864	033352	430 00 0 00 070323 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5865									;RESULT IN C(AC) NONZERO
  5866	033353	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5867						STOP^
  5868	033354	254 04 0 00 033355 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5869	033355	324 00 0 00 033356 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5870									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5871									;IN THE SUBTEST) TO LOOP ON ERROR^
  5872
  5873					;**********
  5874
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0130

  5875					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5876					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5877					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5878					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5879					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5880			007341		SN=SN+1
  5881		040000	000000			ZZ=ZZ+ZZ
  5882						IFE	ZZ,<ZZ=1>
  5883	033356	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5884	033357	430 00 0 00 070324 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5885									;RESULT IN C(AC) NONZERO
  5886	033360	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5887						STOP^
  5888	033361	254 04 0 00 033362 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5889	033362	324 00 0 00 033363 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5890									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5891									;IN THE SUBTEST) TO LOOP ON ERROR^
  5892
  5893					;**********
  5894
  5895					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5896					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5897					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5898					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5899					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5900			007342		SN=SN+1
  5901		100000	000000			ZZ=ZZ+ZZ
  5902						IFE	ZZ,<ZZ=1>
  5903	033363	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5904	033364	430 00 0 00 070325 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5905									;RESULT IN C(AC) NONZERO
  5906	033365	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5907						STOP^
  5908	033366	254 04 0 00 033367 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5909	033367	324 00 0 00 033370 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5910									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5911									;IN THE SUBTEST) TO LOOP ON ERROR^
  5912
  5913					;**********
  5914
  5915					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5916					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5917					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5918					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5919					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5920			007343		SN=SN+1
  5921		200000	000000			ZZ=ZZ+ZZ
  5922						IFE	ZZ,<ZZ=1>
  5923	033370	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5924	033371	430 00 0 00 070326 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5925									;RESULT IN C(AC) NONZERO
  5926	033372	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5927						STOP^
  5928	033373	254 04 0 00 033374 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5929	033374	324 00 0 00 033375 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0131

  5930									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5931									;IN THE SUBTEST) TO LOOP ON ERROR^
  5932
  5933					;**********
  5934
  5935					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5936					;C(AC)=0 AND C(E) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO. THIS
  5937					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS CLEARED AND XOR IS EXECUTED
  5938					;WITH ALL BITS OF E CLEAR EXCEPT FOR ONE FLOATING BIT WHICH IS SET TO A ONE.
  5939					;THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5940			007344		SN=SN+1
  5941		400000	000000			ZZ=ZZ+ZZ
  5942						IFE	ZZ,<ZZ=1>
  5943	033375	200 00 0 00 070253 		MOVE	[0]		;CLEAR AC
  5944	033376	430 00 0 00 070256 		XOR	[ZZ]		;*XOR WITH C(AC)=0 AND ONE BIT OF C(E) SET SHOULD
  5945									;RESULT IN C(AC) NONZERO
  5946	033377	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5947						STOP^
  5948	033400	254 04 0 00 033401 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5949	033401	324 00 0 00 033402 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5950									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5951									;IN THE SUBTEST) TO LOOP ON ERROR^
  5952
  5953					;**********
  5954
  5955			007400		SN=7400
  5956			000000			ZZ=0
  5957
  5958					A7400:	REPEAT	^D36,
  5959					<;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5960					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  5961					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  5962					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  5963					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  5964					SN=SN+1
  5965						ZZ=ZZ+ZZ
  5966						IFE	ZZ,<ZZ=1>
  5967						MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  5968						XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  5969									;RESULT IN C(AC) NON-ZERO
  5970						SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5971						STOP
  5972					
  5973					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  5974					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  5975					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  5976					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  5977					
  5978					;**********
  5979					>
  5980					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  5981					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  5982					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  5983					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  5984					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0132

  5985			007401		SN=SN+1
  5986			000000			ZZ=ZZ+ZZ
  5987			000001			IFE	ZZ,<ZZ=1>
  5988	033402	200 00 0 00 070265 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  5989	033403	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  5990									;RESULT IN C(AC) NON-ZERO
  5991	033404	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  5992						STOP^
  5993	033405	254 04 0 00 033406 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  5994	033406	324 00 0 00 033407 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  5995									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  5996									;IN THE SUBTEST) TO LOOP ON ERROR^
  5997
  5998					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  5999					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6000					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6001					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6002
  6003					;**********
  6004
  6005					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6006					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6007					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6008					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6009					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6010			007402		SN=SN+1
  6011			000002			ZZ=ZZ+ZZ
  6012						IFE	ZZ,<ZZ=1>
  6013	033407	200 00 0 00 070266 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6014	033410	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6015									;RESULT IN C(AC) NON-ZERO
  6016	033411	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6017						STOP^
  6018	033412	254 04 0 00 033413 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6019	033413	324 00 0 00 033414 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6020									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6021									;IN THE SUBTEST) TO LOOP ON ERROR^
  6022
  6023					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6024					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6025					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6026					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6027
  6028					;**********
  6029
  6030					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6031					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6032					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6033					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6034					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6035			007403		SN=SN+1
  6036			000004			ZZ=ZZ+ZZ
  6037						IFE	ZZ,<ZZ=1>
  6038	033414	200 00 0 00 070267 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6039	033415	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-15
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0133

  6040									;RESULT IN C(AC) NON-ZERO
  6041	033416	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6042						STOP^
  6043	033417	254 04 0 00 033420 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6044	033420	324 00 0 00 033421 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6045									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6046									;IN THE SUBTEST) TO LOOP ON ERROR^
  6047
  6048					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6049					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6050					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6051					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6052
  6053					;**********
  6054
  6055					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6056					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6057					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6058					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6059					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6060			007404		SN=SN+1
  6061			000010			ZZ=ZZ+ZZ
  6062						IFE	ZZ,<ZZ=1>
  6063	033421	200 00 0 00 070270 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6064	033422	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6065									;RESULT IN C(AC) NON-ZERO
  6066	033423	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6067						STOP^
  6068	033424	254 04 0 00 033425 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6069	033425	324 00 0 00 033426 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6070									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6071									;IN THE SUBTEST) TO LOOP ON ERROR^
  6072
  6073					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6074					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6075					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6076					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6077
  6078					;**********
  6079
  6080					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6081					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6082					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6083					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6084					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6085			007405		SN=SN+1
  6086			000020			ZZ=ZZ+ZZ
  6087						IFE	ZZ,<ZZ=1>
  6088	033426	200 00 0 00 070271 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6089	033427	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6090									;RESULT IN C(AC) NON-ZERO
  6091	033430	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6092						STOP^
  6093	033431	254 04 0 00 033432 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6094	033432	324 00 0 00 033433 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-16
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0134

  6095									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6096									;IN THE SUBTEST) TO LOOP ON ERROR^
  6097
  6098					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6099					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6100					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6101					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6102
  6103					;**********
  6104
  6105					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6106					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6107					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6108					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6109					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6110			007406		SN=SN+1
  6111			000040			ZZ=ZZ+ZZ
  6112						IFE	ZZ,<ZZ=1>
  6113	033433	200 00 0 00 070272 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6114	033434	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6115									;RESULT IN C(AC) NON-ZERO
  6116	033435	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6117						STOP^
  6118	033436	254 04 0 00 033437 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6119	033437	324 00 0 00 033440 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6120									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6121									;IN THE SUBTEST) TO LOOP ON ERROR^
  6122
  6123					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6124					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6125					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6126					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6127
  6128					;**********
  6129
  6130					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6131					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6132					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6133					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6134					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6135			007407		SN=SN+1
  6136			000100			ZZ=ZZ+ZZ
  6137						IFE	ZZ,<ZZ=1>
  6138	033440	200 00 0 00 070273 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6139	033441	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6140									;RESULT IN C(AC) NON-ZERO
  6141	033442	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6142						STOP^
  6143	033443	254 04 0 00 033444 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6144	033444	324 00 0 00 033445 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6145									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6146									;IN THE SUBTEST) TO LOOP ON ERROR^
  6147
  6148					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6149					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-17
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0135

  6150					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6151					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6152
  6153					;**********
  6154
  6155					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6156					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6157					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6158					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6159					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6160			007410		SN=SN+1
  6161			000200			ZZ=ZZ+ZZ
  6162						IFE	ZZ,<ZZ=1>
  6163	033445	200 00 0 00 070274 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6164	033446	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6165									;RESULT IN C(AC) NON-ZERO
  6166	033447	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6167						STOP^
  6168	033450	254 04 0 00 033451 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6169	033451	324 00 0 00 033452 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6170									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6171									;IN THE SUBTEST) TO LOOP ON ERROR^
  6172
  6173					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6174					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6175					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6176					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6177
  6178					;**********
  6179
  6180					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6181					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6182					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6183					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6184					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6185			007411		SN=SN+1
  6186			000400			ZZ=ZZ+ZZ
  6187						IFE	ZZ,<ZZ=1>
  6188	033452	200 00 0 00 070275 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6189	033453	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6190									;RESULT IN C(AC) NON-ZERO
  6191	033454	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6192						STOP^
  6193	033455	254 04 0 00 033456 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6194	033456	324 00 0 00 033457 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6195									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6196									;IN THE SUBTEST) TO LOOP ON ERROR^
  6197
  6198					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6199					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6200					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6201					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6202
  6203					;**********
  6204
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-18
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0136

  6205					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6206					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6207					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6208					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6209					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6210			007412		SN=SN+1
  6211			001000			ZZ=ZZ+ZZ
  6212						IFE	ZZ,<ZZ=1>
  6213	033457	200 00 0 00 070276 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6214	033460	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6215									;RESULT IN C(AC) NON-ZERO
  6216	033461	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6217						STOP^
  6218	033462	254 04 0 00 033463 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6219	033463	324 00 0 00 033464 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6220									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6221									;IN THE SUBTEST) TO LOOP ON ERROR^
  6222
  6223					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6224					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6225					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6226					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6227
  6228					;**********
  6229
  6230					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6231					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6232					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6233					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6234					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6235			007413		SN=SN+1
  6236			002000			ZZ=ZZ+ZZ
  6237						IFE	ZZ,<ZZ=1>
  6238	033464	200 00 0 00 070277 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6239	033465	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6240									;RESULT IN C(AC) NON-ZERO
  6241	033466	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6242						STOP^
  6243	033467	254 04 0 00 033470 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6244	033470	324 00 0 00 033471 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6245									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6246									;IN THE SUBTEST) TO LOOP ON ERROR^
  6247
  6248					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6249					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6250					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6251					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6252
  6253					;**********
  6254
  6255					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6256					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6257					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6258					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6259					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-19
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0137

  6260			007414		SN=SN+1
  6261			004000			ZZ=ZZ+ZZ
  6262						IFE	ZZ,<ZZ=1>
  6263	033471	200 00 0 00 070300 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6264	033472	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6265									;RESULT IN C(AC) NON-ZERO
  6266	033473	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6267						STOP^
  6268	033474	254 04 0 00 033475 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6269	033475	324 00 0 00 033476 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6270									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6271									;IN THE SUBTEST) TO LOOP ON ERROR^
  6272
  6273					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6274					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6275					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6276					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6277
  6278					;**********
  6279
  6280					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6281					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6282					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6283					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6284					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6285			007415		SN=SN+1
  6286			010000			ZZ=ZZ+ZZ
  6287						IFE	ZZ,<ZZ=1>
  6288	033476	200 00 0 00 070301 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6289	033477	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6290									;RESULT IN C(AC) NON-ZERO
  6291	033500	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6292						STOP^
  6293	033501	254 04 0 00 033502 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6294	033502	324 00 0 00 033503 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6295									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6296									;IN THE SUBTEST) TO LOOP ON ERROR^
  6297
  6298					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6299					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6300					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6301					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6302
  6303					;**********
  6304
  6305					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6306					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6307					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6308					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6309					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6310			007416		SN=SN+1
  6311			020000			ZZ=ZZ+ZZ
  6312						IFE	ZZ,<ZZ=1>
  6313	033503	200 00 0 00 070302 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6314	033504	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-20
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0138

  6315									;RESULT IN C(AC) NON-ZERO
  6316	033505	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6317						STOP^
  6318	033506	254 04 0 00 033507 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6319	033507	324 00 0 00 033510 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6320									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6321									;IN THE SUBTEST) TO LOOP ON ERROR^
  6322
  6323					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6324					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6325					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6326					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6327
  6328					;**********
  6329
  6330					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6331					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6332					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6333					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6334					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6335			007417		SN=SN+1
  6336			040000			ZZ=ZZ+ZZ
  6337						IFE	ZZ,<ZZ=1>
  6338	033510	200 00 0 00 070303 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6339	033511	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6340									;RESULT IN C(AC) NON-ZERO
  6341	033512	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6342						STOP^
  6343	033513	254 04 0 00 033514 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6344	033514	324 00 0 00 033515 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6345									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6346									;IN THE SUBTEST) TO LOOP ON ERROR^
  6347
  6348					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6349					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6350					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6351					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6352
  6353					;**********
  6354
  6355					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6356					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6357					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6358					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6359					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6360			007420		SN=SN+1
  6361			100000			ZZ=ZZ+ZZ
  6362						IFE	ZZ,<ZZ=1>
  6363	033515	200 00 0 00 070304 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6364	033516	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6365									;RESULT IN C(AC) NON-ZERO
  6366	033517	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6367						STOP^
  6368	033520	254 04 0 00 033521 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6369	033521	324 00 0 00 033522 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-21
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0139

  6370									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6371									;IN THE SUBTEST) TO LOOP ON ERROR^
  6372
  6373					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6374					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6375					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6376					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6377
  6378					;**********
  6379
  6380					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6381					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6382					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6383					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6384					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6385			007421		SN=SN+1
  6386			200000			ZZ=ZZ+ZZ
  6387						IFE	ZZ,<ZZ=1>
  6388	033522	200 00 0 00 070305 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6389	033523	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6390									;RESULT IN C(AC) NON-ZERO
  6391	033524	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6392						STOP^
  6393	033525	254 04 0 00 033526 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6394	033526	324 00 0 00 033527 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6395									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6396									;IN THE SUBTEST) TO LOOP ON ERROR^
  6397
  6398					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6399					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6400					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6401					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6402
  6403					;**********
  6404
  6405					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6406					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6407					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6408					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6409					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6410			007422		SN=SN+1
  6411			400000			ZZ=ZZ+ZZ
  6412						IFE	ZZ,<ZZ=1>
  6413	033527	200 00 0 00 070306 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6414	033530	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6415									;RESULT IN C(AC) NON-ZERO
  6416	033531	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6417						STOP^
  6418	033532	254 04 0 00 033533 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6419	033533	324 00 0 00 033534 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6420									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6421									;IN THE SUBTEST) TO LOOP ON ERROR^
  6422
  6423					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6424					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-22
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0140

  6425					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6426					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6427
  6428					;**********
  6429
  6430					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6431					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6432					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6433					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6434					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6435			007423		SN=SN+1
  6436		000001	000000			ZZ=ZZ+ZZ
  6437						IFE	ZZ,<ZZ=1>
  6438	033534	200 00 0 00 070307 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6439	033535	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6440									;RESULT IN C(AC) NON-ZERO
  6441	033536	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6442						STOP^
  6443	033537	254 04 0 00 033540 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6444	033540	324 00 0 00 033541 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6445									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6446									;IN THE SUBTEST) TO LOOP ON ERROR^
  6447
  6448					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6449					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6450					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6451					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6452
  6453					;**********
  6454
  6455					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6456					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6457					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6458					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6459					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6460			007424		SN=SN+1
  6461		000002	000000			ZZ=ZZ+ZZ
  6462						IFE	ZZ,<ZZ=1>
  6463	033541	200 00 0 00 070310 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6464	033542	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6465									;RESULT IN C(AC) NON-ZERO
  6466	033543	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6467						STOP^
  6468	033544	254 04 0 00 033545 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6469	033545	324 00 0 00 033546 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6470									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6471									;IN THE SUBTEST) TO LOOP ON ERROR^
  6472
  6473					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6474					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6475					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6476					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6477
  6478					;**********
  6479
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-23
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0141

  6480					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6481					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6482					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6483					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6484					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6485			007425		SN=SN+1
  6486		000004	000000			ZZ=ZZ+ZZ
  6487						IFE	ZZ,<ZZ=1>
  6488	033546	200 00 0 00 070311 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6489	033547	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6490									;RESULT IN C(AC) NON-ZERO
  6491	033550	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6492						STOP^
  6493	033551	254 04 0 00 033552 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6494	033552	324 00 0 00 033553 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6495									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6496									;IN THE SUBTEST) TO LOOP ON ERROR^
  6497
  6498					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6499					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6500					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6501					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6502
  6503					;**********
  6504
  6505					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6506					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6507					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6508					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6509					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6510			007426		SN=SN+1
  6511		000010	000000			ZZ=ZZ+ZZ
  6512						IFE	ZZ,<ZZ=1>
  6513	033553	200 00 0 00 070312 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6514	033554	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6515									;RESULT IN C(AC) NON-ZERO
  6516	033555	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6517						STOP^
  6518	033556	254 04 0 00 033557 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6519	033557	324 00 0 00 033560 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6520									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6521									;IN THE SUBTEST) TO LOOP ON ERROR^
  6522
  6523					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6524					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6525					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6526					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6527
  6528					;**********
  6529
  6530					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6531					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6532					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6533					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6534					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-24
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0142

  6535			007427		SN=SN+1
  6536		000020	000000			ZZ=ZZ+ZZ
  6537						IFE	ZZ,<ZZ=1>
  6538	033560	200 00 0 00 070313 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6539	033561	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6540									;RESULT IN C(AC) NON-ZERO
  6541	033562	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6542						STOP^
  6543	033563	254 04 0 00 033564 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6544	033564	324 00 0 00 033565 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6545									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6546									;IN THE SUBTEST) TO LOOP ON ERROR^
  6547
  6548					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6549					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6550					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6551					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6552
  6553					;**********
  6554
  6555					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6556					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6557					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6558					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6559					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6560			007430		SN=SN+1
  6561		000040	000000			ZZ=ZZ+ZZ
  6562						IFE	ZZ,<ZZ=1>
  6563	033565	200 00 0 00 070314 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6564	033566	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6565									;RESULT IN C(AC) NON-ZERO
  6566	033567	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6567						STOP^
  6568	033570	254 04 0 00 033571 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6569	033571	324 00 0 00 033572 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6570									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6571									;IN THE SUBTEST) TO LOOP ON ERROR^
  6572
  6573					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6574					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6575					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6576					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6577
  6578					;**********
  6579
  6580					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6581					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6582					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6583					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6584					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6585			007431		SN=SN+1
  6586		000100	000000			ZZ=ZZ+ZZ
  6587						IFE	ZZ,<ZZ=1>
  6588	033572	200 00 0 00 070315 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6589	033573	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-25
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0143

  6590									;RESULT IN C(AC) NON-ZERO
  6591	033574	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6592						STOP^
  6593	033575	254 04 0 00 033576 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6594	033576	324 00 0 00 033577 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6595									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6596									;IN THE SUBTEST) TO LOOP ON ERROR^
  6597
  6598					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6599					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6600					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6601					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6602
  6603					;**********
  6604
  6605					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6606					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6607					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6608					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6609					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6610			007432		SN=SN+1
  6611		000200	000000			ZZ=ZZ+ZZ
  6612						IFE	ZZ,<ZZ=1>
  6613	033577	200 00 0 00 070316 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6614	033600	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6615									;RESULT IN C(AC) NON-ZERO
  6616	033601	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6617						STOP^
  6618	033602	254 04 0 00 033603 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6619	033603	324 00 0 00 033604 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6620									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6621									;IN THE SUBTEST) TO LOOP ON ERROR^
  6622
  6623					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6624					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6625					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6626					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6627
  6628					;**********
  6629
  6630					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6631					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6632					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6633					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6634					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6635			007433		SN=SN+1
  6636		000400	000000			ZZ=ZZ+ZZ
  6637						IFE	ZZ,<ZZ=1>
  6638	033604	200 00 0 00 070264 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6639	033605	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6640									;RESULT IN C(AC) NON-ZERO
  6641	033606	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6642						STOP^
  6643	033607	254 04 0 00 033610 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6644	033610	324 00 0 00 033611 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-26
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0144

  6645									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6646									;IN THE SUBTEST) TO LOOP ON ERROR^
  6647
  6648					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6649					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6650					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6651					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6652
  6653					;**********
  6654
  6655					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6656					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6657					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6658					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6659					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6660			007434		SN=SN+1
  6661		001000	000000			ZZ=ZZ+ZZ
  6662						IFE	ZZ,<ZZ=1>
  6663	033611	200 00 0 00 070317 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6664	033612	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6665									;RESULT IN C(AC) NON-ZERO
  6666	033613	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6667						STOP^
  6668	033614	254 04 0 00 033615 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6669	033615	324 00 0 00 033616 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6670									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6671									;IN THE SUBTEST) TO LOOP ON ERROR^
  6672
  6673					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6674					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6675					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6676					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6677
  6678					;**********
  6679
  6680					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6681					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6682					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6683					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6684					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6685			007435		SN=SN+1
  6686		002000	000000			ZZ=ZZ+ZZ
  6687						IFE	ZZ,<ZZ=1>
  6688	033616	200 00 0 00 070320 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6689	033617	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6690									;RESULT IN C(AC) NON-ZERO
  6691	033620	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6692						STOP^
  6693	033621	254 04 0 00 033622 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6694	033622	324 00 0 00 033623 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6695									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6696									;IN THE SUBTEST) TO LOOP ON ERROR^
  6697
  6698					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6699					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-27
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0145

  6700					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6701					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6702
  6703					;**********
  6704
  6705					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6706					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6707					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6708					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6709					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6710			007436		SN=SN+1
  6711		004000	000000			ZZ=ZZ+ZZ
  6712						IFE	ZZ,<ZZ=1>
  6713	033623	200 00 0 00 070321 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6714	033624	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6715									;RESULT IN C(AC) NON-ZERO
  6716	033625	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6717						STOP^
  6718	033626	254 04 0 00 033627 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6719	033627	324 00 0 00 033630 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6720									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6721									;IN THE SUBTEST) TO LOOP ON ERROR^
  6722
  6723					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6724					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6725					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6726					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6727
  6728					;**********
  6729
  6730					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6731					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6732					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6733					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6734					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6735			007437		SN=SN+1
  6736		010000	000000			ZZ=ZZ+ZZ
  6737						IFE	ZZ,<ZZ=1>
  6738	033630	200 00 0 00 070322 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6739	033631	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6740									;RESULT IN C(AC) NON-ZERO
  6741	033632	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6742						STOP^
  6743	033633	254 04 0 00 033634 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6744	033634	324 00 0 00 033635 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6745									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6746									;IN THE SUBTEST) TO LOOP ON ERROR^
  6747
  6748					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6749					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6750					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6751					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6752
  6753					;**********
  6754
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-28
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0146

  6755					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6756					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6757					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6758					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6759					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6760			007440		SN=SN+1
  6761		020000	000000			ZZ=ZZ+ZZ
  6762						IFE	ZZ,<ZZ=1>
  6763	033635	200 00 0 00 070323 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6764	033636	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6765									;RESULT IN C(AC) NON-ZERO
  6766	033637	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6767						STOP^
  6768	033640	254 04 0 00 033641 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6769	033641	324 00 0 00 033642 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6770									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6771									;IN THE SUBTEST) TO LOOP ON ERROR^
  6772
  6773					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6774					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6775					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6776					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6777
  6778					;**********
  6779
  6780					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6781					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6782					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6783					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6784					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6785			007441		SN=SN+1
  6786		040000	000000			ZZ=ZZ+ZZ
  6787						IFE	ZZ,<ZZ=1>
  6788	033642	200 00 0 00 070324 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6789	033643	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6790									;RESULT IN C(AC) NON-ZERO
  6791	033644	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6792						STOP^
  6793	033645	254 04 0 00 033646 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6794	033646	324 00 0 00 033647 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6795									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6796									;IN THE SUBTEST) TO LOOP ON ERROR^
  6797
  6798					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6799					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6800					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6801					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6802
  6803					;**********
  6804
  6805					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6806					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6807					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6808					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6809					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-29
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0147

  6810			007442		SN=SN+1
  6811		100000	000000			ZZ=ZZ+ZZ
  6812						IFE	ZZ,<ZZ=1>
  6813	033647	200 00 0 00 070325 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6814	033650	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6815									;RESULT IN C(AC) NON-ZERO
  6816	033651	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6817						STOP^
  6818	033652	254 04 0 00 033653 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6819	033653	324 00 0 00 033654 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6820									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6821									;IN THE SUBTEST) TO LOOP ON ERROR^
  6822
  6823					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6824					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6825					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6826					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6827
  6828					;**********
  6829
  6830					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6831					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6832					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6833					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6834					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6835			007443		SN=SN+1
  6836		200000	000000			ZZ=ZZ+ZZ
  6837						IFE	ZZ,<ZZ=1>
  6838	033654	200 00 0 00 070326 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6839	033655	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
  6840									;RESULT IN C(AC) NON-ZERO
  6841	033656	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6842						STOP^
  6843	033657	254 04 0 00 033660 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6844	033660	324 00 0 00 033661 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6845									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6846									;IN THE SUBTEST) TO LOOP ON ERROR^
  6847
  6848					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6849					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6850					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6851					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6852
  6853					;**********
  6854
  6855					;THIS TEST VERIFIES THAT THE RESULT OF THE XOR INSTRUCTION WHERE
  6856					;C(E)=0 AND C(AC) IS NON-ZERO IS AN AC WHOSE CONTENTS IS NON-ZERO.  THIS
  6857					;TEST IS REPEATED 36 TIMES. EACH TIME THE AC IS INITIALIZED SO THAT ONE
  6858					;AND ONLY ONE FLOATING BIT IS SET TO ONE AND XOR IS EXECUTED WITH E
  6859					;CONTAINING ALL ZEROS.  THE AC IS THEN CHECKED FOR A NON-ZERO RESULT.
  6860			007444		SN=SN+1
  6861		400000	000000			ZZ=ZZ+ZZ
  6862						IFE	ZZ,<ZZ=1>
  6863	033661	200 00 0 00 070256 		MOVE	[ZZ]		;PRELOAD AC WITH ONE FLOATING BIT SET
  6864	033662	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(E)=0 AND ONE BIT OF C(AC) SET SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-30
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0148

  6865									;RESULT IN C(AC) NON-ZERO
  6866	033663	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  6867						STOP^
  6868	033664	254 04 0 00 033665 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6869	033665	324 00 0 00 033666 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6870									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6871									;IN THE SUBTEST) TO LOOP ON ERROR^
  6872
  6873					;AD FM- EN [ADFM], AD FM- F/F'S[ADFM],F CYC ACT EN D[R1],
  6874					;IR BOOLE AD FM- F [IR2],IR BOOLE[IR1],IR XX (2,6,7,10,12,15)[IR2],
  6875					;AD EQV[ADCR],AD EQV F/F[ADC2],FCYC ACT EN A[F1],
  6876					;IR BOOLE (6,11)[IR2],IR BOOLE[IR1],IRXX(6,11)[IR2]
  6877
  6878					;**********
  6879
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0149

  6880			007500		SN=7500
  6881			000000			ZZ=0
  6882
  6883					A7500:	REPEAT ^D36,
  6884					<;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6885					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6886					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6887					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6888					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  6889					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6890					;INDICATE AN ILLEGAL CARRY GENERATION.
  6891					SN=SN+1
  6892						ZZ=ZZ+ZZ
  6893						IFE	ZZ,<ZZ=1>
  6894						MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6895						XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6896						SKIPE			;PASS TEST IF C(AC)=0
  6897						STOP
  6898					
  6899					;**********
  6900					>
  6901					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6902					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6903					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6904					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6905					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  6906					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6907					;INDICATE AN ILLEGAL CARRY GENERATION.
  6908			007501		SN=SN+1
  6909			000000			ZZ=ZZ+ZZ
  6910			000001			IFE	ZZ,<ZZ=1>
  6911	033666	200 00 0 00 070265 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6912	033667	430 00 0 00 070265 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6913	033670	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  6914						STOP^
  6915	033671	254 04 0 00 033672 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6916	033672	324 00 0 00 033673 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6917									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6918									;IN THE SUBTEST) TO LOOP ON ERROR^
  6919
  6920					;**********
  6921
  6922					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6923					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6924					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6925					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6926					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  6927					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6928					;INDICATE AN ILLEGAL CARRY GENERATION.
  6929			007502		SN=SN+1
  6930			000002			ZZ=ZZ+ZZ
  6931						IFE	ZZ,<ZZ=1>
  6932	033673	200 00 0 00 070266 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6933	033674	430 00 0 00 070266 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6934	033675	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0150

  6935						STOP^
  6936	033676	254 04 0 00 033677 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6937	033677	324 00 0 00 033700 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6938									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6939									;IN THE SUBTEST) TO LOOP ON ERROR^
  6940
  6941					;**********
  6942
  6943					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6944					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6945					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6946					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6947					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  6948					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6949					;INDICATE AN ILLEGAL CARRY GENERATION.
  6950			007503		SN=SN+1
  6951			000004			ZZ=ZZ+ZZ
  6952						IFE	ZZ,<ZZ=1>
  6953	033700	200 00 0 00 070267 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6954	033701	430 00 0 00 070267 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6955	033702	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  6956						STOP^
  6957	033703	254 04 0 00 033704 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6958	033704	324 00 0 00 033705 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6959									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6960									;IN THE SUBTEST) TO LOOP ON ERROR^
  6961
  6962					;**********
  6963
  6964					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6965					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6966					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6967					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6968					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  6969					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6970					;INDICATE AN ILLEGAL CARRY GENERATION.
  6971			007504		SN=SN+1
  6972			000010			ZZ=ZZ+ZZ
  6973						IFE	ZZ,<ZZ=1>
  6974	033705	200 00 0 00 070270 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6975	033706	430 00 0 00 070270 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6976	033707	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  6977						STOP^
  6978	033710	254 04 0 00 033711 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  6979	033711	324 00 0 00 033712 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  6980									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  6981									;IN THE SUBTEST) TO LOOP ON ERROR^
  6982
  6983					;**********
  6984
  6985					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  6986					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  6987					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  6988					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  6989					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0151

  6990					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  6991					;INDICATE AN ILLEGAL CARRY GENERATION.
  6992			007505		SN=SN+1
  6993			000020			ZZ=ZZ+ZZ
  6994						IFE	ZZ,<ZZ=1>
  6995	033712	200 00 0 00 070271 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  6996	033713	430 00 0 00 070271 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  6997	033714	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  6998						STOP^
  6999	033715	254 04 0 00 033716 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7000	033716	324 00 0 00 033717 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7001									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7002									;IN THE SUBTEST) TO LOOP ON ERROR^
  7003
  7004					;**********
  7005
  7006					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7007					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7008					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7009					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7010					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7011					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7012					;INDICATE AN ILLEGAL CARRY GENERATION.
  7013			007506		SN=SN+1
  7014			000040			ZZ=ZZ+ZZ
  7015						IFE	ZZ,<ZZ=1>
  7016	033717	200 00 0 00 070272 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7017	033720	430 00 0 00 070272 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7018	033721	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7019						STOP^
  7020	033722	254 04 0 00 033723 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7021	033723	324 00 0 00 033724 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7022									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7023									;IN THE SUBTEST) TO LOOP ON ERROR^
  7024
  7025					;**********
  7026
  7027					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7028					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7029					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7030					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7031					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7032					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7033					;INDICATE AN ILLEGAL CARRY GENERATION.
  7034			007507		SN=SN+1
  7035			000100			ZZ=ZZ+ZZ
  7036						IFE	ZZ,<ZZ=1>
  7037	033724	200 00 0 00 070273 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7038	033725	430 00 0 00 070273 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7039	033726	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7040						STOP^
  7041	033727	254 04 0 00 033730 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7042	033730	324 00 0 00 033731 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7043									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7044									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0152

  7045
  7046					;**********
  7047
  7048					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7049					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7050					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7051					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7052					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7053					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7054					;INDICATE AN ILLEGAL CARRY GENERATION.
  7055			007510		SN=SN+1
  7056			000200			ZZ=ZZ+ZZ
  7057						IFE	ZZ,<ZZ=1>
  7058	033731	200 00 0 00 070274 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7059	033732	430 00 0 00 070274 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7060	033733	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7061						STOP^
  7062	033734	254 04 0 00 033735 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7063	033735	324 00 0 00 033736 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7064									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7065									;IN THE SUBTEST) TO LOOP ON ERROR^
  7066
  7067					;**********
  7068
  7069					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7070					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7071					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7072					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7073					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7074					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7075					;INDICATE AN ILLEGAL CARRY GENERATION.
  7076			007511		SN=SN+1
  7077			000400			ZZ=ZZ+ZZ
  7078						IFE	ZZ,<ZZ=1>
  7079	033736	200 00 0 00 070275 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7080	033737	430 00 0 00 070275 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7081	033740	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7082						STOP^
  7083	033741	254 04 0 00 033742 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7084	033742	324 00 0 00 033743 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7085									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7086									;IN THE SUBTEST) TO LOOP ON ERROR^
  7087
  7088					;**********
  7089
  7090					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7091					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7092					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7093					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7094					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7095					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7096					;INDICATE AN ILLEGAL CARRY GENERATION.
  7097			007512		SN=SN+1
  7098			001000			ZZ=ZZ+ZZ
  7099						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0153

  7100	033743	200 00 0 00 070276 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7101	033744	430 00 0 00 070276 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7102	033745	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7103						STOP^
  7104	033746	254 04 0 00 033747 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7105	033747	324 00 0 00 033750 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7106									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7107									;IN THE SUBTEST) TO LOOP ON ERROR^
  7108
  7109					;**********
  7110
  7111					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7112					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7113					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7114					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7115					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7116					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7117					;INDICATE AN ILLEGAL CARRY GENERATION.
  7118			007513		SN=SN+1
  7119			002000			ZZ=ZZ+ZZ
  7120						IFE	ZZ,<ZZ=1>
  7121	033750	200 00 0 00 070277 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7122	033751	430 00 0 00 070277 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7123	033752	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7124						STOP^
  7125	033753	254 04 0 00 033754 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7126	033754	324 00 0 00 033755 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7127									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7128									;IN THE SUBTEST) TO LOOP ON ERROR^
  7129
  7130					;**********
  7131
  7132					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7133					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7134					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7135					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7136					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7137					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7138					;INDICATE AN ILLEGAL CARRY GENERATION.
  7139			007514		SN=SN+1
  7140			004000			ZZ=ZZ+ZZ
  7141						IFE	ZZ,<ZZ=1>
  7142	033755	200 00 0 00 070300 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7143	033756	430 00 0 00 070300 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7144	033757	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7145						STOP^
  7146	033760	254 04 0 00 033761 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7147	033761	324 00 0 00 033762 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7148									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7149									;IN THE SUBTEST) TO LOOP ON ERROR^
  7150
  7151					;**********
  7152
  7153					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7154					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0154

  7155					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7156					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7157					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7158					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7159					;INDICATE AN ILLEGAL CARRY GENERATION.
  7160			007515		SN=SN+1
  7161			010000			ZZ=ZZ+ZZ
  7162						IFE	ZZ,<ZZ=1>
  7163	033762	200 00 0 00 070301 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7164	033763	430 00 0 00 070301 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7165	033764	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7166						STOP^
  7167	033765	254 04 0 00 033766 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7168	033766	324 00 0 00 033767 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7169									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7170									;IN THE SUBTEST) TO LOOP ON ERROR^
  7171
  7172					;**********
  7173
  7174					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7175					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7176					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7177					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7178					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7179					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7180					;INDICATE AN ILLEGAL CARRY GENERATION.
  7181			007516		SN=SN+1
  7182			020000			ZZ=ZZ+ZZ
  7183						IFE	ZZ,<ZZ=1>
  7184	033767	200 00 0 00 070302 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7185	033770	430 00 0 00 070302 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7186	033771	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7187						STOP^
  7188	033772	254 04 0 00 033773 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7189	033773	324 00 0 00 033774 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7190									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7191									;IN THE SUBTEST) TO LOOP ON ERROR^
  7192
  7193					;**********
  7194
  7195					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7196					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7197					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7198					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7199					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7200					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7201					;INDICATE AN ILLEGAL CARRY GENERATION.
  7202			007517		SN=SN+1
  7203			040000			ZZ=ZZ+ZZ
  7204						IFE	ZZ,<ZZ=1>
  7205	033774	200 00 0 00 070303 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7206	033775	430 00 0 00 070303 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7207	033776	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7208						STOP^
  7209	033777	254 04 0 00 034000 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0155

  7210	034000	324 00 0 00 034001 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7211									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7212									;IN THE SUBTEST) TO LOOP ON ERROR^
  7213
  7214					;**********
  7215
  7216					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7217					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7218					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7219					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7220					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7221					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7222					;INDICATE AN ILLEGAL CARRY GENERATION.
  7223			007520		SN=SN+1
  7224			100000			ZZ=ZZ+ZZ
  7225						IFE	ZZ,<ZZ=1>
  7226	034001	200 00 0 00 070304 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7227	034002	430 00 0 00 070304 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7228	034003	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7229						STOP^
  7230	034004	254 04 0 00 034005 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7231	034005	324 00 0 00 034006 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7232									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7233									;IN THE SUBTEST) TO LOOP ON ERROR^
  7234
  7235					;**********
  7236
  7237					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7238					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7239					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7240					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7241					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7242					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7243					;INDICATE AN ILLEGAL CARRY GENERATION.
  7244			007521		SN=SN+1
  7245			200000			ZZ=ZZ+ZZ
  7246						IFE	ZZ,<ZZ=1>
  7247	034006	200 00 0 00 070305 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7248	034007	430 00 0 00 070305 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7249	034010	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7250						STOP^
  7251	034011	254 04 0 00 034012 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7252	034012	324 00 0 00 034013 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7253									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7254									;IN THE SUBTEST) TO LOOP ON ERROR^
  7255
  7256					;**********
  7257
  7258					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7259					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7260					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7261					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7262					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7263					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7264					;INDICATE AN ILLEGAL CARRY GENERATION.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0156

  7265			007522		SN=SN+1
  7266			400000			ZZ=ZZ+ZZ
  7267						IFE	ZZ,<ZZ=1>
  7268	034013	200 00 0 00 070306 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7269	034014	430 00 0 00 070306 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7270	034015	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7271						STOP^
  7272	034016	254 04 0 00 034017 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7273	034017	324 00 0 00 034020 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7274									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7275									;IN THE SUBTEST) TO LOOP ON ERROR^
  7276
  7277					;**********
  7278
  7279					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7280					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7281					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7282					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7283					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7284					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7285					;INDICATE AN ILLEGAL CARRY GENERATION.
  7286			007523		SN=SN+1
  7287		000001	000000			ZZ=ZZ+ZZ
  7288						IFE	ZZ,<ZZ=1>
  7289	034020	200 00 0 00 070307 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7290	034021	430 00 0 00 070307 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7291	034022	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7292						STOP^
  7293	034023	254 04 0 00 034024 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7294	034024	324 00 0 00 034025 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7295									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7296									;IN THE SUBTEST) TO LOOP ON ERROR^
  7297
  7298					;**********
  7299
  7300					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7301					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7302					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7303					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7304					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7305					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7306					;INDICATE AN ILLEGAL CARRY GENERATION.
  7307			007524		SN=SN+1
  7308		000002	000000			ZZ=ZZ+ZZ
  7309						IFE	ZZ,<ZZ=1>
  7310	034025	200 00 0 00 070310 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7311	034026	430 00 0 00 070310 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7312	034027	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7313						STOP^
  7314	034030	254 04 0 00 034031 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7315	034031	324 00 0 00 034032 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7316									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7317									;IN THE SUBTEST) TO LOOP ON ERROR^
  7318
  7319					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0157

  7320
  7321					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7322					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7323					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7324					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7325					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7326					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7327					;INDICATE AN ILLEGAL CARRY GENERATION.
  7328			007525		SN=SN+1
  7329		000004	000000			ZZ=ZZ+ZZ
  7330						IFE	ZZ,<ZZ=1>
  7331	034032	200 00 0 00 070311 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7332	034033	430 00 0 00 070311 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7333	034034	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7334						STOP^
  7335	034035	254 04 0 00 034036 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7336	034036	324 00 0 00 034037 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7337									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7338									;IN THE SUBTEST) TO LOOP ON ERROR^
  7339
  7340					;**********
  7341
  7342					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7343					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7344					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7345					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7346					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7347					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7348					;INDICATE AN ILLEGAL CARRY GENERATION.
  7349			007526		SN=SN+1
  7350		000010	000000			ZZ=ZZ+ZZ
  7351						IFE	ZZ,<ZZ=1>
  7352	034037	200 00 0 00 070312 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7353	034040	430 00 0 00 070312 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7354	034041	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7355						STOP^
  7356	034042	254 04 0 00 034043 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7357	034043	324 00 0 00 034044 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7358									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7359									;IN THE SUBTEST) TO LOOP ON ERROR^
  7360
  7361					;**********
  7362
  7363					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7364					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7365					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7366					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7367					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7368					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7369					;INDICATE AN ILLEGAL CARRY GENERATION.
  7370			007527		SN=SN+1
  7371		000020	000000			ZZ=ZZ+ZZ
  7372						IFE	ZZ,<ZZ=1>
  7373	034044	200 00 0 00 070313 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7374	034045	430 00 0 00 070313 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0158

  7375	034046	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7376						STOP^
  7377	034047	254 04 0 00 034050 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7378	034050	324 00 0 00 034051 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7379									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7380									;IN THE SUBTEST) TO LOOP ON ERROR^
  7381
  7382					;**********
  7383
  7384					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7385					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7386					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7387					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7388					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7389					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7390					;INDICATE AN ILLEGAL CARRY GENERATION.
  7391			007530		SN=SN+1
  7392		000040	000000			ZZ=ZZ+ZZ
  7393						IFE	ZZ,<ZZ=1>
  7394	034051	200 00 0 00 070314 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7395	034052	430 00 0 00 070314 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7396	034053	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7397						STOP^
  7398	034054	254 04 0 00 034055 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7399	034055	324 00 0 00 034056 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7400									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7401									;IN THE SUBTEST) TO LOOP ON ERROR^
  7402
  7403					;**********
  7404
  7405					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7406					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7407					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7408					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7409					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7410					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7411					;INDICATE AN ILLEGAL CARRY GENERATION.
  7412			007531		SN=SN+1
  7413		000100	000000			ZZ=ZZ+ZZ
  7414						IFE	ZZ,<ZZ=1>
  7415	034056	200 00 0 00 070315 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7416	034057	430 00 0 00 070315 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7417	034060	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7418						STOP^
  7419	034061	254 04 0 00 034062 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7420	034062	324 00 0 00 034063 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7421									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7422									;IN THE SUBTEST) TO LOOP ON ERROR^
  7423
  7424					;**********
  7425
  7426					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7427					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7428					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7429					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0159

  7430					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7431					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7432					;INDICATE AN ILLEGAL CARRY GENERATION.
  7433			007532		SN=SN+1
  7434		000200	000000			ZZ=ZZ+ZZ
  7435						IFE	ZZ,<ZZ=1>
  7436	034063	200 00 0 00 070316 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7437	034064	430 00 0 00 070316 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7438	034065	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7439						STOP^
  7440	034066	254 04 0 00 034067 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7441	034067	324 00 0 00 034070 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7442									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7443									;IN THE SUBTEST) TO LOOP ON ERROR^
  7444
  7445					;**********
  7446
  7447					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7448					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7449					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7450					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7451					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7452					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7453					;INDICATE AN ILLEGAL CARRY GENERATION.
  7454			007533		SN=SN+1
  7455		000400	000000			ZZ=ZZ+ZZ
  7456						IFE	ZZ,<ZZ=1>
  7457	034070	200 00 0 00 070264 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7458	034071	430 00 0 00 070264 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7459	034072	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7460						STOP^
  7461	034073	254 04 0 00 034074 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7462	034074	324 00 0 00 034075 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7463									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7464									;IN THE SUBTEST) TO LOOP ON ERROR^
  7465
  7466					;**********
  7467
  7468					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7469					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7470					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7471					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7472					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7473					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7474					;INDICATE AN ILLEGAL CARRY GENERATION.
  7475			007534		SN=SN+1
  7476		001000	000000			ZZ=ZZ+ZZ
  7477						IFE	ZZ,<ZZ=1>
  7478	034075	200 00 0 00 070317 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7479	034076	430 00 0 00 070317 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7480	034077	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7481						STOP^
  7482	034100	254 04 0 00 034101 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7483	034101	324 00 0 00 034102 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7484									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0160

  7485									;IN THE SUBTEST) TO LOOP ON ERROR^
  7486
  7487					;**********
  7488
  7489					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7490					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7491					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7492					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7493					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7494					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7495					;INDICATE AN ILLEGAL CARRY GENERATION.
  7496			007535		SN=SN+1
  7497		002000	000000			ZZ=ZZ+ZZ
  7498						IFE	ZZ,<ZZ=1>
  7499	034102	200 00 0 00 070320 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7500	034103	430 00 0 00 070320 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7501	034104	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7502						STOP^
  7503	034105	254 04 0 00 034106 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7504	034106	324 00 0 00 034107 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7505									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7506									;IN THE SUBTEST) TO LOOP ON ERROR^
  7507
  7508					;**********
  7509
  7510					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7511					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7512					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7513					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7514					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7515					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7516					;INDICATE AN ILLEGAL CARRY GENERATION.
  7517			007536		SN=SN+1
  7518		004000	000000			ZZ=ZZ+ZZ
  7519						IFE	ZZ,<ZZ=1>
  7520	034107	200 00 0 00 070321 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7521	034110	430 00 0 00 070321 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7522	034111	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7523						STOP^
  7524	034112	254 04 0 00 034113 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7525	034113	324 00 0 00 034114 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7526									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7527									;IN THE SUBTEST) TO LOOP ON ERROR^
  7528
  7529					;**********
  7530
  7531					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7532					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7533					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7534					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7535					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7536					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7537					;INDICATE AN ILLEGAL CARRY GENERATION.
  7538			007537		SN=SN+1
  7539		010000	000000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0161

  7540						IFE	ZZ,<ZZ=1>
  7541	034114	200 00 0 00 070322 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7542	034115	430 00 0 00 070322 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7543	034116	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7544						STOP^
  7545	034117	254 04 0 00 034120 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7546	034120	324 00 0 00 034121 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7547									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7548									;IN THE SUBTEST) TO LOOP ON ERROR^
  7549
  7550					;**********
  7551
  7552					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7553					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7554					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7555					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7556					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7557					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7558					;INDICATE AN ILLEGAL CARRY GENERATION.
  7559			007540		SN=SN+1
  7560		020000	000000			ZZ=ZZ+ZZ
  7561						IFE	ZZ,<ZZ=1>
  7562	034121	200 00 0 00 070323 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7563	034122	430 00 0 00 070323 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7564	034123	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7565						STOP^
  7566	034124	254 04 0 00 034125 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7567	034125	324 00 0 00 034126 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7568									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7569									;IN THE SUBTEST) TO LOOP ON ERROR^
  7570
  7571					;**********
  7572
  7573					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7574					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7575					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7576					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7577					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7578					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7579					;INDICATE AN ILLEGAL CARRY GENERATION.
  7580			007541		SN=SN+1
  7581		040000	000000			ZZ=ZZ+ZZ
  7582						IFE	ZZ,<ZZ=1>
  7583	034126	200 00 0 00 070324 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7584	034127	430 00 0 00 070324 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7585	034130	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7586						STOP^
  7587	034131	254 04 0 00 034132 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7588	034132	324 00 0 00 034133 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7589									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7590									;IN THE SUBTEST) TO LOOP ON ERROR^
  7591
  7592					;**********
  7593
  7594					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0162

  7595					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7596					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7597					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7598					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7599					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7600					;INDICATE AN ILLEGAL CARRY GENERATION.
  7601			007542		SN=SN+1
  7602		100000	000000			ZZ=ZZ+ZZ
  7603						IFE	ZZ,<ZZ=1>
  7604	034133	200 00 0 00 070325 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7605	034134	430 00 0 00 070325 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7606	034135	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7607						STOP^
  7608	034136	254 04 0 00 034137 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7609	034137	324 00 0 00 034140 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7610									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7611									;IN THE SUBTEST) TO LOOP ON ERROR^
  7612
  7613					;**********
  7614
  7615					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7616					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7617					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7618					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7619					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7620					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7621					;INDICATE AN ILLEGAL CARRY GENERATION.
  7622			007543		SN=SN+1
  7623		200000	000000			ZZ=ZZ+ZZ
  7624						IFE	ZZ,<ZZ=1>
  7625	034140	200 00 0 00 070326 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7626	034141	430 00 0 00 070326 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7627	034142	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7628						STOP^
  7629	034143	254 04 0 00 034144 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7630	034144	324 00 0 00 034145 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7631									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7632									;IN THE SUBTEST) TO LOOP ON ERROR^
  7633
  7634					;**********
  7635
  7636					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION
  7637					;WHERE C(AC) = C(E) IS AN AC CONTAINING ALL ZEROS.  FIRST,
  7638					;THE AC IS INITIALIZED WITH A WORD CONTAINING ALL ZEROS EXCEPT
  7639					;FOR ONE FLOATING ONE; THEN, XOR IS EXECUTED WITH E CONTAINING THE SAME
  7640					;NUMBER.  THE RESULT SHOULD BE AN AC CONTAINING ALL ZEROS.  THIS TEST
  7641					;IS REPEATED 36 TIMES.  IF ANY BIT IN THE RESULT IS NON-ZERO, IT MAY
  7642					;INDICATE AN ILLEGAL CARRY GENERATION.
  7643			007544		SN=SN+1
  7644		400000	000000			ZZ=ZZ+ZZ
  7645						IFE	ZZ,<ZZ=1>
  7646	034145	200 00 0 00 070256 		MOVE	[ZZ]		;INITIALIZE AC WITH ONE FLOATING BIT SET
  7647	034146	430 00 0 00 070256 		XOR	[ZZ]		;*XOR WITH C(AC)=C(E) SHOULD RESULT IN C(AC)=0
  7648	034147	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7649						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 28-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0163

  7650	034150	254 04 0 00 034151 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7651	034151	324 00 0 00 034152 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7652									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7653									;IN THE SUBTEST) TO LOOP ON ERROR^
  7654
  7655					;**********
  7656
  7657					;THIS TEST VERIFIES THAT THE RESULT OF AN XOR INSTRUCTION WHERE
  7658					;C(AC)=C(E)=0 IS AN AC CONTAINING ALL ZEROS; FIRST THE AC IS CLEARED; THEN
  7659					;XOR IS EXECUTED WITH C(E)=0.  THE RESULT IN THE AC IS CHECKED FOR ALL ZEROS
  7660
  7661	034152	200 00 0 00 070253 	A7600:	MOVE	[0]		;INITIALIZE AC TO ALL ZEROS
  7662	034153	430 00 0 00 070253 		XOR	[0]		;*XOR WITH C(AC)=C(E)=0 SHOULD RESULT INC(AC)=0
  7663	034154	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7664						STOP^
  7665	034155	254 04 0 00 034156 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7666	034156	324 00 0 00 034157 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7667									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7668									;IN THE SUBTEST) TO LOOP ON ERROR^
  7669
  7670					;**********
  7671
  7672					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7673					;C(AC)=0 AND C(E) ALL ONES IS AN AC CONTAINING ALL ZEROS SINCE
  7674					;THE EQUIVALENCE FUNCTION SHOULD SET ONLY LIKE BITS.  FIRST, THE AC
  7675					;SHOULD BE CLEARED; THEN, EQV IS EXECUTED WITH E CONTAINING ALL ONES.
  7676					;THE AC IS THEN CHECKED FOR ALL ZEROS
  7677
  7678	034157	200 00 0 00 070253 	A7700:	MOVE	[0]		;CLEAR THE AC
  7679	034160	444 00 0 00 070254 		EQV	[-1]		;*EQV WITH C(AC)=0 AND C(E) ALL ONES SHOULD
  7680									;RESULT IN C(AC)=0
  7681	034161	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  7682						STOP^
  7683	034162	254 04 0 00 034163 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7684	034163	324 00 0 00 034164 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7685									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7686									;IN THE SUBTEST) TO LOOP ON ERROR^
  7687
  7688					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0164

  7689			010000		SN=10000
  7690			000000			ZZ=0
  7691
  7692					A10000:	REPEAT	^D18,
  7693					<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7694					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7695					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7696					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7697					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7698					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7699					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7700					SN=SN+1
  7701						ZZ=ZZ+ZZ+1
  7702						IFE	<ZZ-1>,<ZZ=-2>
  7703						MOVE	[0]		;PRESET AC TO ALL ZEROS
  7704						EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7705									;RESULT IN C(AC) NON-ZERO
  7706						SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7707						STOP
  7708					
  7709					;**********
  7710					>
  7711					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7712					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7713					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7714					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7715					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7716					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7717					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7718			010001		SN=SN+1
  7719			000001			ZZ=ZZ+ZZ+1
  7720		777777	777776			IFE	<ZZ-1>,<ZZ=-2>
  7721	034164	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7722	034165	444 00 0 00 070333 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7723									;RESULT IN C(AC) NON-ZERO
  7724	034166	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7725						STOP^
  7726	034167	254 04 0 00 034170 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7727	034170	324 00 0 00 034171 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7728									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7729									;IN THE SUBTEST) TO LOOP ON ERROR^
  7730
  7731					;**********
  7732
  7733					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7734					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7735					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7736					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7737					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7738					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7739					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7740			010002		SN=SN+1
  7741		777777	777775			ZZ=ZZ+ZZ+1
  7742						IFE	<ZZ-1>,<ZZ=-2>
  7743	034171	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0165

  7744	034172	444 00 0 00 070334 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7745									;RESULT IN C(AC) NON-ZERO
  7746	034173	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7747						STOP^
  7748	034174	254 04 0 00 034175 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7749	034175	324 00 0 00 034176 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7750									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7751									;IN THE SUBTEST) TO LOOP ON ERROR^
  7752
  7753					;**********
  7754
  7755					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7756					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7757					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7758					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7759					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7760					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7761					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7762			010003		SN=SN+1
  7763		777777	777773			ZZ=ZZ+ZZ+1
  7764						IFE	<ZZ-1>,<ZZ=-2>
  7765	034176	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7766	034177	444 00 0 00 070335 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7767									;RESULT IN C(AC) NON-ZERO
  7768	034200	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7769						STOP^
  7770	034201	254 04 0 00 034202 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7771	034202	324 00 0 00 034203 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7772									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7773									;IN THE SUBTEST) TO LOOP ON ERROR^
  7774
  7775					;**********
  7776
  7777					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7778					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7779					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7780					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7781					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7782					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7783					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7784			010004		SN=SN+1
  7785		777777	777767			ZZ=ZZ+ZZ+1
  7786						IFE	<ZZ-1>,<ZZ=-2>
  7787	034203	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7788	034204	444 00 0 00 070336 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7789									;RESULT IN C(AC) NON-ZERO
  7790	034205	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7791						STOP^
  7792	034206	254 04 0 00 034207 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7793	034207	324 00 0 00 034210 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7794									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7795									;IN THE SUBTEST) TO LOOP ON ERROR^
  7796
  7797					;**********
  7798
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0166

  7799					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7800					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7801					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7802					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7803					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7804					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7805					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7806			010005		SN=SN+1
  7807		777777	777757			ZZ=ZZ+ZZ+1
  7808						IFE	<ZZ-1>,<ZZ=-2>
  7809	034210	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7810	034211	444 00 0 00 070337 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7811									;RESULT IN C(AC) NON-ZERO
  7812	034212	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7813						STOP^
  7814	034213	254 04 0 00 034214 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7815	034214	324 00 0 00 034215 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7816									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7817									;IN THE SUBTEST) TO LOOP ON ERROR^
  7818
  7819					;**********
  7820
  7821					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7822					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7823					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7824					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7825					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7826					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7827					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7828			010006		SN=SN+1
  7829		777777	777737			ZZ=ZZ+ZZ+1
  7830						IFE	<ZZ-1>,<ZZ=-2>
  7831	034215	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7832	034216	444 00 0 00 070340 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7833									;RESULT IN C(AC) NON-ZERO
  7834	034217	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7835						STOP^
  7836	034220	254 04 0 00 034221 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7837	034221	324 00 0 00 034222 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7838									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7839									;IN THE SUBTEST) TO LOOP ON ERROR^
  7840
  7841					;**********
  7842
  7843					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7844					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7845					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7846					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7847					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7848					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7849					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7850			010007		SN=SN+1
  7851		777777	777677			ZZ=ZZ+ZZ+1
  7852						IFE	<ZZ-1>,<ZZ=-2>
  7853	034222	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0167

  7854	034223	444 00 0 00 070341 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7855									;RESULT IN C(AC) NON-ZERO
  7856	034224	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7857						STOP^
  7858	034225	254 04 0 00 034226 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7859	034226	324 00 0 00 034227 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7860									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7861									;IN THE SUBTEST) TO LOOP ON ERROR^
  7862
  7863					;**********
  7864
  7865					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7866					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7867					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7868					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7869					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7870					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7871					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7872			010010		SN=SN+1
  7873		777777	777577			ZZ=ZZ+ZZ+1
  7874						IFE	<ZZ-1>,<ZZ=-2>
  7875	034227	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7876	034230	444 00 0 00 070342 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7877									;RESULT IN C(AC) NON-ZERO
  7878	034231	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7879						STOP^
  7880	034232	254 04 0 00 034233 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7881	034233	324 00 0 00 034234 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7882									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7883									;IN THE SUBTEST) TO LOOP ON ERROR^
  7884
  7885					;**********
  7886
  7887					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7888					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7889					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7890					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7891					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7892					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7893					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7894			010011		SN=SN+1
  7895		777777	777377			ZZ=ZZ+ZZ+1
  7896						IFE	<ZZ-1>,<ZZ=-2>
  7897	034234	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7898	034235	444 00 0 00 070343 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7899									;RESULT IN C(AC) NON-ZERO
  7900	034236	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7901						STOP^
  7902	034237	254 04 0 00 034240 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7903	034240	324 00 0 00 034241 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7904									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7905									;IN THE SUBTEST) TO LOOP ON ERROR^
  7906
  7907					;**********
  7908
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0168

  7909					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7910					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7911					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7912					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7913					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7914					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7915					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7916			010012		SN=SN+1
  7917		777777	776777			ZZ=ZZ+ZZ+1
  7918						IFE	<ZZ-1>,<ZZ=-2>
  7919	034241	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7920	034242	444 00 0 00 070344 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7921									;RESULT IN C(AC) NON-ZERO
  7922	034243	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7923						STOP^
  7924	034244	254 04 0 00 034245 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7925	034245	324 00 0 00 034246 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7926									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7927									;IN THE SUBTEST) TO LOOP ON ERROR^
  7928
  7929					;**********
  7930
  7931					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7932					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7933					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7934					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7935					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7936					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7937					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7938			010013		SN=SN+1
  7939		777777	775777			ZZ=ZZ+ZZ+1
  7940						IFE	<ZZ-1>,<ZZ=-2>
  7941	034246	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7942	034247	444 00 0 00 070345 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7943									;RESULT IN C(AC) NON-ZERO
  7944	034250	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7945						STOP^
  7946	034251	254 04 0 00 034252 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7947	034252	324 00 0 00 034253 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7948									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7949									;IN THE SUBTEST) TO LOOP ON ERROR^
  7950
  7951					;**********
  7952
  7953					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7954					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7955					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7956					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7957					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7958					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7959					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7960			010014		SN=SN+1
  7961		777777	773777			ZZ=ZZ+ZZ+1
  7962						IFE	<ZZ-1>,<ZZ=-2>
  7963	034253	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0169

  7964	034254	444 00 0 00 070346 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7965									;RESULT IN C(AC) NON-ZERO
  7966	034255	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7967						STOP^
  7968	034256	254 04 0 00 034257 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7969	034257	324 00 0 00 034260 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7970									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7971									;IN THE SUBTEST) TO LOOP ON ERROR^
  7972
  7973					;**********
  7974
  7975					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7976					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7977					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  7978					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  7979					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  7980					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  7981					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  7982			010015		SN=SN+1
  7983		777777	767777			ZZ=ZZ+ZZ+1
  7984						IFE	<ZZ-1>,<ZZ=-2>
  7985	034260	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  7986	034261	444 00 0 00 070347 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  7987									;RESULT IN C(AC) NON-ZERO
  7988	034262	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  7989						STOP^
  7990	034263	254 04 0 00 034264 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  7991	034264	324 00 0 00 034265 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  7992									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  7993									;IN THE SUBTEST) TO LOOP ON ERROR^
  7994
  7995					;**********
  7996
  7997					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  7998					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  7999					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8000					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8001					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8002					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8003					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8004			010016		SN=SN+1
  8005		777777	757777			ZZ=ZZ+ZZ+1
  8006						IFE	<ZZ-1>,<ZZ=-2>
  8007	034265	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8008	034266	444 00 0 00 070350 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8009									;RESULT IN C(AC) NON-ZERO
  8010	034267	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8011						STOP^
  8012	034270	254 04 0 00 034271 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8013	034271	324 00 0 00 034272 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8014									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8015									;IN THE SUBTEST) TO LOOP ON ERROR^
  8016
  8017					;**********
  8018
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0170

  8019					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8020					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8021					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8022					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8023					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8024					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8025					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8026			010017		SN=SN+1
  8027		777777	737777			ZZ=ZZ+ZZ+1
  8028						IFE	<ZZ-1>,<ZZ=-2>
  8029	034272	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8030	034273	444 00 0 00 070351 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8031									;RESULT IN C(AC) NON-ZERO
  8032	034274	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8033						STOP^
  8034	034275	254 04 0 00 034276 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8035	034276	324 00 0 00 034277 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8036									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8037									;IN THE SUBTEST) TO LOOP ON ERROR^
  8038
  8039					;**********
  8040
  8041					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8042					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8043					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8044					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8045					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8046					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8047					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8048			010020		SN=SN+1
  8049		777777	677777			ZZ=ZZ+ZZ+1
  8050						IFE	<ZZ-1>,<ZZ=-2>
  8051	034277	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8052	034300	444 00 0 00 070352 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8053									;RESULT IN C(AC) NON-ZERO
  8054	034301	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8055						STOP^
  8056	034302	254 04 0 00 034303 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8057	034303	324 00 0 00 034304 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8058									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8059									;IN THE SUBTEST) TO LOOP ON ERROR^
  8060
  8061					;**********
  8062
  8063					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8064					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8065					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8066					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8067					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8068					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8069					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8070			010021		SN=SN+1
  8071		777777	577777			ZZ=ZZ+ZZ+1
  8072						IFE	<ZZ-1>,<ZZ=-2>
  8073	034304	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0171

  8074	034305	444 00 0 00 070353 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8075									;RESULT IN C(AC) NON-ZERO
  8076	034306	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8077						STOP^
  8078	034307	254 04 0 00 034310 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8079	034310	324 00 0 00 034311 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8080									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8081									;IN THE SUBTEST) TO LOOP ON ERROR^
  8082
  8083					;**********
  8084
  8085					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8086					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8087					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8088					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8089					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8090					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8091					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8092			010022		SN=SN+1
  8093		777777	377777			ZZ=ZZ+ZZ+1
  8094						IFE	<ZZ-1>,<ZZ=-2>
  8095	034311	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8096	034312	444 00 0 00 070354 		EQV	[XWD -1,ZZ]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8097									;RESULT IN C(AC) NON-ZERO
  8098	034313	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8099						STOP^
  8100	034314	254 04 0 00 034315 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8101	034315	324 00 0 00 034316 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8102									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8103									;IN THE SUBTEST) TO LOOP ON ERROR^
  8104
  8105					;**********
  8106
  8107			010100		SN=10100
  8108			000000			ZZ=0
  8109
  8110					A10100:	REPEAT	^D18,
  8111					<;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8112					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8113					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8114					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8115					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8116					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8117					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8118					SN=SN+1
  8119						ZZ=ZZ+ZZ+1
  8120						IFE	<ZZ-1>,<ZZ=-2>
  8121						MOVE	[0]		;PRESET AC TO ALL ZEROS
  8122						EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8123									;RESULT IN C(AC) NON-ZERO
  8124						SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8125						STOP
  8126					
  8127					;**********
  8128					>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0172

  8129					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8130					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8131					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8132					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8133					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8134					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8135					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8136			010101		SN=SN+1
  8137			000001			ZZ=ZZ+ZZ+1
  8138		777777	777776			IFE	<ZZ-1>,<ZZ=-2>
  8139	034316	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8140	034317	444 00 0 00 070355 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8141									;RESULT IN C(AC) NON-ZERO
  8142	034320	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8143						STOP^
  8144	034321	254 04 0 00 034322 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8145	034322	324 00 0 00 034323 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8146									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8147									;IN THE SUBTEST) TO LOOP ON ERROR^
  8148
  8149					;**********
  8150
  8151					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8152					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8153					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8154					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8155					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8156					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8157					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8158			010102		SN=SN+1
  8159		777777	777775			ZZ=ZZ+ZZ+1
  8160						IFE	<ZZ-1>,<ZZ=-2>
  8161	034323	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8162	034324	444 00 0 00 070356 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8163									;RESULT IN C(AC) NON-ZERO
  8164	034325	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8165						STOP^
  8166	034326	254 04 0 00 034327 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8167	034327	324 00 0 00 034330 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8168									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8169									;IN THE SUBTEST) TO LOOP ON ERROR^
  8170
  8171					;**********
  8172
  8173					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8174					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8175					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8176					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8177					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8178					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8179					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8180			010103		SN=SN+1
  8181		777777	777773			ZZ=ZZ+ZZ+1
  8182						IFE	<ZZ-1>,<ZZ=-2>
  8183	034330	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0173

  8184	034331	444 00 0 00 070357 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8185									;RESULT IN C(AC) NON-ZERO
  8186	034332	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8187						STOP^
  8188	034333	254 04 0 00 034334 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8189	034334	324 00 0 00 034335 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8190									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8191									;IN THE SUBTEST) TO LOOP ON ERROR^
  8192
  8193					;**********
  8194
  8195					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8196					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8197					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8198					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8199					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8200					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8201					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8202			010104		SN=SN+1
  8203		777777	777767			ZZ=ZZ+ZZ+1
  8204						IFE	<ZZ-1>,<ZZ=-2>
  8205	034335	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8206	034336	444 00 0 00 070360 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8207									;RESULT IN C(AC) NON-ZERO
  8208	034337	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8209						STOP^
  8210	034340	254 04 0 00 034341 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8211	034341	324 00 0 00 034342 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8212									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8213									;IN THE SUBTEST) TO LOOP ON ERROR^
  8214
  8215					;**********
  8216
  8217					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8218					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8219					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8220					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8221					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8222					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8223					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8224			010105		SN=SN+1
  8225		777777	777757			ZZ=ZZ+ZZ+1
  8226						IFE	<ZZ-1>,<ZZ=-2>
  8227	034342	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8228	034343	444 00 0 00 070361 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8229									;RESULT IN C(AC) NON-ZERO
  8230	034344	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8231						STOP^
  8232	034345	254 04 0 00 034346 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8233	034346	324 00 0 00 034347 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8234									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8235									;IN THE SUBTEST) TO LOOP ON ERROR^
  8236
  8237					;**********
  8238
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0174

  8239					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8240					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8241					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8242					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8243					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8244					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8245					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8246			010106		SN=SN+1
  8247		777777	777737			ZZ=ZZ+ZZ+1
  8248						IFE	<ZZ-1>,<ZZ=-2>
  8249	034347	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8250	034350	444 00 0 00 070362 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8251									;RESULT IN C(AC) NON-ZERO
  8252	034351	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8253						STOP^
  8254	034352	254 04 0 00 034353 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8255	034353	324 00 0 00 034354 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8256									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8257									;IN THE SUBTEST) TO LOOP ON ERROR^
  8258
  8259					;**********
  8260
  8261					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8262					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8263					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8264					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8265					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8266					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8267					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8268			010107		SN=SN+1
  8269		777777	777677			ZZ=ZZ+ZZ+1
  8270						IFE	<ZZ-1>,<ZZ=-2>
  8271	034354	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8272	034355	444 00 0 00 070363 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8273									;RESULT IN C(AC) NON-ZERO
  8274	034356	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8275						STOP^
  8276	034357	254 04 0 00 034360 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8277	034360	324 00 0 00 034361 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8278									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8279									;IN THE SUBTEST) TO LOOP ON ERROR^
  8280
  8281					;**********
  8282
  8283					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8284					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8285					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8286					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8287					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8288					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8289					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8290			010110		SN=SN+1
  8291		777777	777577			ZZ=ZZ+ZZ+1
  8292						IFE	<ZZ-1>,<ZZ=-2>
  8293	034361	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0175

  8294	034362	444 00 0 00 070364 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8295									;RESULT IN C(AC) NON-ZERO
  8296	034363	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8297						STOP^
  8298	034364	254 04 0 00 034365 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8299	034365	324 00 0 00 034366 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8300									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8301									;IN THE SUBTEST) TO LOOP ON ERROR^
  8302
  8303					;**********
  8304
  8305					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8306					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8307					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8308					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8309					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8310					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8311					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8312			010111		SN=SN+1
  8313		777777	777377			ZZ=ZZ+ZZ+1
  8314						IFE	<ZZ-1>,<ZZ=-2>
  8315	034366	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8316	034367	444 00 0 00 070365 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8317									;RESULT IN C(AC) NON-ZERO
  8318	034370	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8319						STOP^
  8320	034371	254 04 0 00 034372 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8321	034372	324 00 0 00 034373 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8322									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8323									;IN THE SUBTEST) TO LOOP ON ERROR^
  8324
  8325					;**********
  8326
  8327					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8328					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8329					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8330					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8331					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8332					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8333					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8334			010112		SN=SN+1
  8335		777777	776777			ZZ=ZZ+ZZ+1
  8336						IFE	<ZZ-1>,<ZZ=-2>
  8337	034373	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8338	034374	444 00 0 00 070366 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8339									;RESULT IN C(AC) NON-ZERO
  8340	034375	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8341						STOP^
  8342	034376	254 04 0 00 034377 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8343	034377	324 00 0 00 034400 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8344									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8345									;IN THE SUBTEST) TO LOOP ON ERROR^
  8346
  8347					;**********
  8348
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0176

  8349					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8350					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8351					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8352					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8353					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8354					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8355					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8356			010113		SN=SN+1
  8357		777777	775777			ZZ=ZZ+ZZ+1
  8358						IFE	<ZZ-1>,<ZZ=-2>
  8359	034400	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8360	034401	444 00 0 00 070367 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8361									;RESULT IN C(AC) NON-ZERO
  8362	034402	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8363						STOP^
  8364	034403	254 04 0 00 034404 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8365	034404	324 00 0 00 034405 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8366									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8367									;IN THE SUBTEST) TO LOOP ON ERROR^
  8368
  8369					;**********
  8370
  8371					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8372					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8373					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8374					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8375					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8376					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8377					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8378			010114		SN=SN+1
  8379		777777	773777			ZZ=ZZ+ZZ+1
  8380						IFE	<ZZ-1>,<ZZ=-2>
  8381	034405	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8382	034406	444 00 0 00 070370 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8383									;RESULT IN C(AC) NON-ZERO
  8384	034407	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8385						STOP^
  8386	034410	254 04 0 00 034411 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8387	034411	324 00 0 00 034412 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8388									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8389									;IN THE SUBTEST) TO LOOP ON ERROR^
  8390
  8391					;**********
  8392
  8393					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8394					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8395					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8396					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8397					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8398					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8399					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8400			010115		SN=SN+1
  8401		777777	767777			ZZ=ZZ+ZZ+1
  8402						IFE	<ZZ-1>,<ZZ=-2>
  8403	034412	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0177

  8404	034413	444 00 0 00 070371 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8405									;RESULT IN C(AC) NON-ZERO
  8406	034414	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8407						STOP^
  8408	034415	254 04 0 00 034416 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8409	034416	324 00 0 00 034417 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8410									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8411									;IN THE SUBTEST) TO LOOP ON ERROR^
  8412
  8413					;**********
  8414
  8415					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8416					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8417					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8418					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8419					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8420					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8421					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8422			010116		SN=SN+1
  8423		777777	757777			ZZ=ZZ+ZZ+1
  8424						IFE	<ZZ-1>,<ZZ=-2>
  8425	034417	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8426	034420	444 00 0 00 070372 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8427									;RESULT IN C(AC) NON-ZERO
  8428	034421	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8429						STOP^
  8430	034422	254 04 0 00 034423 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8431	034423	324 00 0 00 034424 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8432									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8433									;IN THE SUBTEST) TO LOOP ON ERROR^
  8434
  8435					;**********
  8436
  8437					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8438					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8439					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8440					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8441					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8442					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8443					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8444			010117		SN=SN+1
  8445		777777	737777			ZZ=ZZ+ZZ+1
  8446						IFE	<ZZ-1>,<ZZ=-2>
  8447	034424	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8448	034425	444 00 0 00 070373 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8449									;RESULT IN C(AC) NON-ZERO
  8450	034426	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8451						STOP^
  8452	034427	254 04 0 00 034430 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8453	034430	324 00 0 00 034431 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8454									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8455									;IN THE SUBTEST) TO LOOP ON ERROR^
  8456
  8457					;**********
  8458
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0178

  8459					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8460					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8461					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8462					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8463					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8464					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8465					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8466			010120		SN=SN+1
  8467		777777	677777			ZZ=ZZ+ZZ+1
  8468						IFE	<ZZ-1>,<ZZ=-2>
  8469	034431	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8470	034432	444 00 0 00 070374 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8471									;RESULT IN C(AC) NON-ZERO
  8472	034433	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8473						STOP^
  8474	034434	254 04 0 00 034435 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8475	034435	324 00 0 00 034436 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8476									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8477									;IN THE SUBTEST) TO LOOP ON ERROR^
  8478
  8479					;**********
  8480
  8481					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8482					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8483					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8484					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8485					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8486					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8487					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8488			010121		SN=SN+1
  8489		777777	577777			ZZ=ZZ+ZZ+1
  8490						IFE	<ZZ-1>,<ZZ=-2>
  8491	034436	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
  8492	034437	444 00 0 00 070375 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8493									;RESULT IN C(AC) NON-ZERO
  8494	034440	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8495						STOP^
  8496	034441	254 04 0 00 034442 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8497	034442	324 00 0 00 034443 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8498									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8499									;IN THE SUBTEST) TO LOOP ON ERROR^
  8500
  8501					;**********
  8502
  8503					;THIS TEST VERIFIES THAT THE RESULT OF AN EQV INSTRUCTION WHERE
  8504					;C(AC)=0 AND C(E) IS ALL ONES EXCEPT FOR A ZERO IN ONLY ONE BIT IS AN
  8505					;AC WHOSE CONTENTS IS NON-ZERO (A ONE RESULTS IN THE BIT WHERE
  8506					;E CONTAINS A ZERO).  THIS TEST IS REPEATED 36 TIMES SO THAT EACH BIT
  8507					;OF THE RESULT IS A ONE ONCE AND ONLY ONCE.  FIRST, THE AC IS
  8508					;CLEARED; THEN,EQV IS EXECUTED WITH ONE BIT OF E EQUAL TO ZERO.  THE 
  8509					;RESULT IN THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  8510			010122		SN=SN+1
  8511		777777	377777			ZZ=ZZ+ZZ+1
  8512						IFE	<ZZ-1>,<ZZ=-2>
  8513	034443	200 00 0 00 070253 		MOVE	[0]		;PRESET AC TO ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 29-15
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0179

  8514	034444	444 00 0 00 070255 		EQV	[XWD ZZ,-1]	;*EQV WITH C(AC)=0 AND ONE BIT OF C(E)=0 SHOULD
  8515									;RESULT IN C(AC) NON-ZERO
  8516	034445	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) NON-ZERO
  8517						STOP^
  8518	034446	254 04 0 00 034447 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8519	034447	324 00 0 00 034450 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8520									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8521									;IN THE SUBTEST) TO LOOP ON ERROR^
  8522
  8523					;**********
  8524
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 30
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0180

  8525					;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ZEROS
  8526					;EQUIVALENCED WITH AN E CONTAINING ALL ZEROS IS AN AC CONTAINING ALL
  8527					;ONES; AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES IS EQUIVALANCED
  8528					;WITH AN E CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC
  8529					;SHOULD BE ALL ZEROS.  FIRST, THE AC IS INITIALIZED TO ALL ZEROS, THEN,
  8530					;THIS AC IS EQUIVALENCED TWICE WITH AN E CONTAINING ALL ZEROS.  THE AC IS 
  8531					;THEN CHECKED FOR ALL ZEROS
  8532
  8533	034450	200 00 0 00 070253 	A10200:	MOVE	[0]		;CLEAR THE AC
  8534	034451	444 00 0 00 070253 		EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=ALL ONES
  8535	034452	444 00 0 00 070253 		EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=0
  8536	034453	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8537						STOP^
  8538	034454	254 04 0 00 034455 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8539	034455	324 00 0 00 034456 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8540									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8541									;IN THE SUBTEST) TO LOOP ON ERROR^
  8542
  8543					;**********
  8544
  8545					;THIS TEST VERIFIES THAT THE RESULT OF AN AC CONTAINING ALL ONES 
  8546					;EQUIVALENCED WITH AN E CONTAINING ALL ONES IS AN AC CONTAINING ALL ONES;
  8547					;AND FUTHERMORE, IF THIS AC CONTAINING ALL ONES ISEQUIVALENCED WITH AN E
  8548					;CONTAINING ALL ZEROS, THE FINAL RESULT IN THE AC SHOULD BE ALL ZEROS.
  8549					;FIRST, THE AC IS INITIALIZED TO ALL ONES; THEN, THIS AC IS 
  8550					;EQUIVALENCED WITH AN E OF ALL ONES.  NEXT, THIS SAME AC IS EQUIVALENCED
  8551					;WITH AN E OF ALL ZEROS.  THE AC IS THEN CHECKED FOR ALL ZEROS.
  8552
  8553	034456	200 00 0 00 070254 	A10300:	MOVE	[-1]		;SET C(AC) TO ALL ONES
  8554	034457	444 00 0 00 070254 		EQV	[-1]		;*EQV SHOULD RESULT IN C(AC) OF ALL ONES
  8555	034460	444 00 0 00 070253 		EQV	[0]		;*EQV SHOULD RESULT IN C(AC)=0
  8556	034461	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8557						STOP^
  8558	034462	254 04 0 00 034463 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8559	034463	324 00 0 00 034464 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8560									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8561									;IN THE SUBTEST) TO LOOP ON ERROR^
  8562
  8563					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0181

  8564			013000		SN=13000
  8565			000000			ZZ=0
  8566
  8567					A13000:	REPEAT	^D36,
  8568					<;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8569					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8570					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8571					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8572					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8573					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8574					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8575					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8576					SN=SN+1
  8577						ZZ=ZZ+ZZ
  8578						IFE	ZZ,<ZZ=1>
  8579						MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8580						AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8581						EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8582						EQV	[0]		;RESULTS IN C(AC)=0
  8583						SKIPE			;PASS TEST IF C(AC)=0
  8584						STOP
  8585					
  8586					;**********
  8587					>
  8588					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8589					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8590					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8591					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8592					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8593					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8594					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8595					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8596			013001		SN=SN+1
  8597			000000			ZZ=ZZ+ZZ
  8598			000001			IFE	ZZ,<ZZ=1>
  8599	034464	200 00 0 00 070265 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8600	034465	404 00 0 00 070265 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8601	034466	444 00 0 00 070265 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8602	034467	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8603	034470	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8604						STOP^
  8605	034471	254 04 0 00 034472 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8606	034472	324 00 0 00 034473 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8607									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8608									;IN THE SUBTEST) TO LOOP ON ERROR^
  8609
  8610					;**********
  8611
  8612					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8613					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8614					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8615					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8616					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8617					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8618					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-1
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0182

  8619					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8620			013002		SN=SN+1
  8621			000002			ZZ=ZZ+ZZ
  8622						IFE	ZZ,<ZZ=1>
  8623	034473	200 00 0 00 070266 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8624	034474	404 00 0 00 070266 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8625	034475	444 00 0 00 070266 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8626	034476	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8627	034477	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8628						STOP^
  8629	034500	254 04 0 00 034501 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8630	034501	324 00 0 00 034502 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8631									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8632									;IN THE SUBTEST) TO LOOP ON ERROR^
  8633
  8634					;**********
  8635
  8636					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8637					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8638					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8639					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8640					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8641					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8642					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8643					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8644			013003		SN=SN+1
  8645			000004			ZZ=ZZ+ZZ
  8646						IFE	ZZ,<ZZ=1>
  8647	034502	200 00 0 00 070267 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8648	034503	404 00 0 00 070267 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8649	034504	444 00 0 00 070267 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8650	034505	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8651	034506	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8652						STOP^
  8653	034507	254 04 0 00 034510 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8654	034510	324 00 0 00 034511 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8655									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8656									;IN THE SUBTEST) TO LOOP ON ERROR^
  8657
  8658					;**********
  8659
  8660					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8661					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8662					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8663					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8664					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8665					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8666					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8667					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8668			013004		SN=SN+1
  8669			000010			ZZ=ZZ+ZZ
  8670						IFE	ZZ,<ZZ=1>
  8671	034511	200 00 0 00 070270 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8672	034512	404 00 0 00 070270 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8673	034513	444 00 0 00 070270 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-2
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0183

  8674	034514	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8675	034515	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8676						STOP^
  8677	034516	254 04 0 00 034517 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8678	034517	324 00 0 00 034520 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8679									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8680									;IN THE SUBTEST) TO LOOP ON ERROR^
  8681
  8682					;**********
  8683
  8684					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8685					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8686					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8687					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8688					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8689					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8690					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8691					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8692			013005		SN=SN+1
  8693			000020			ZZ=ZZ+ZZ
  8694						IFE	ZZ,<ZZ=1>
  8695	034520	200 00 0 00 070271 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8696	034521	404 00 0 00 070271 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8697	034522	444 00 0 00 070271 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8698	034523	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8699	034524	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8700						STOP^
  8701	034525	254 04 0 00 034526 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8702	034526	324 00 0 00 034527 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8703									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8704									;IN THE SUBTEST) TO LOOP ON ERROR^
  8705
  8706					;**********
  8707
  8708					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8709					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8710					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8711					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8712					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8713					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8714					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8715					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8716			013006		SN=SN+1
  8717			000040			ZZ=ZZ+ZZ
  8718						IFE	ZZ,<ZZ=1>
  8719	034527	200 00 0 00 070272 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8720	034530	404 00 0 00 070272 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8721	034531	444 00 0 00 070272 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8722	034532	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8723	034533	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8724						STOP^
  8725	034534	254 04 0 00 034535 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8726	034535	324 00 0 00 034536 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8727									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8728									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-3
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0184

  8729
  8730					;**********
  8731
  8732					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8733					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8734					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8735					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8736					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8737					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8738					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8739					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8740			013007		SN=SN+1
  8741			000100			ZZ=ZZ+ZZ
  8742						IFE	ZZ,<ZZ=1>
  8743	034536	200 00 0 00 070273 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8744	034537	404 00 0 00 070273 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8745	034540	444 00 0 00 070273 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8746	034541	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8747	034542	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8748						STOP^
  8749	034543	254 04 0 00 034544 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8750	034544	324 00 0 00 034545 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8751									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8752									;IN THE SUBTEST) TO LOOP ON ERROR^
  8753
  8754					;**********
  8755
  8756					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8757					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8758					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8759					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8760					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8761					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8762					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8763					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8764			013010		SN=SN+1
  8765			000200			ZZ=ZZ+ZZ
  8766						IFE	ZZ,<ZZ=1>
  8767	034545	200 00 0 00 070274 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8768	034546	404 00 0 00 070274 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8769	034547	444 00 0 00 070274 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8770	034550	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8771	034551	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8772						STOP^
  8773	034552	254 04 0 00 034553 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8774	034553	324 00 0 00 034554 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8775									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8776									;IN THE SUBTEST) TO LOOP ON ERROR^
  8777
  8778					;**********
  8779
  8780					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8781					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8782					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8783					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-4
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0185

  8784					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8785					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8786					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8787					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8788			013011		SN=SN+1
  8789			000400			ZZ=ZZ+ZZ
  8790						IFE	ZZ,<ZZ=1>
  8791	034554	200 00 0 00 070275 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8792	034555	404 00 0 00 070275 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8793	034556	444 00 0 00 070275 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8794	034557	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8795	034560	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8796						STOP^
  8797	034561	254 04 0 00 034562 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8798	034562	324 00 0 00 034563 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8799									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8800									;IN THE SUBTEST) TO LOOP ON ERROR^
  8801
  8802					;**********
  8803
  8804					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8805					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8806					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8807					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8808					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8809					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8810					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8811					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8812			013012		SN=SN+1
  8813			001000			ZZ=ZZ+ZZ
  8814						IFE	ZZ,<ZZ=1>
  8815	034563	200 00 0 00 070276 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8816	034564	404 00 0 00 070276 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8817	034565	444 00 0 00 070276 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8818	034566	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8819	034567	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8820						STOP^
  8821	034570	254 04 0 00 034571 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8822	034571	324 00 0 00 034572 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8823									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8824									;IN THE SUBTEST) TO LOOP ON ERROR^
  8825
  8826					;**********
  8827
  8828					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8829					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8830					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8831					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8832					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8833					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8834					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8835					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8836			013013		SN=SN+1
  8837			002000			ZZ=ZZ+ZZ
  8838						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-5
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0186

  8839	034572	200 00 0 00 070277 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8840	034573	404 00 0 00 070277 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8841	034574	444 00 0 00 070277 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8842	034575	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8843	034576	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8844						STOP^
  8845	034577	254 04 0 00 034600 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8846	034600	324 00 0 00 034601 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8847									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8848									;IN THE SUBTEST) TO LOOP ON ERROR^
  8849
  8850					;**********
  8851
  8852					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8853					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8854					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8855					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8856					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8857					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8858					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8859					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8860			013014		SN=SN+1
  8861			004000			ZZ=ZZ+ZZ
  8862						IFE	ZZ,<ZZ=1>
  8863	034601	200 00 0 00 070300 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8864	034602	404 00 0 00 070300 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8865	034603	444 00 0 00 070300 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8866	034604	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8867	034605	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8868						STOP^
  8869	034606	254 04 0 00 034607 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8870	034607	324 00 0 00 034610 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8871									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8872									;IN THE SUBTEST) TO LOOP ON ERROR^
  8873
  8874					;**********
  8875
  8876					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8877					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8878					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8879					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8880					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8881					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8882					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8883					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8884			013015		SN=SN+1
  8885			010000			ZZ=ZZ+ZZ
  8886						IFE	ZZ,<ZZ=1>
  8887	034610	200 00 0 00 070301 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8888	034611	404 00 0 00 070301 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8889	034612	444 00 0 00 070301 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8890	034613	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8891	034614	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8892						STOP^
  8893	034615	254 04 0 00 034616 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-6
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0187

  8894	034616	324 00 0 00 034617 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8895									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8896									;IN THE SUBTEST) TO LOOP ON ERROR^
  8897
  8898					;**********
  8899
  8900					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8901					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8902					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8903					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8904					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8905					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8906					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8907					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8908			013016		SN=SN+1
  8909			020000			ZZ=ZZ+ZZ
  8910						IFE	ZZ,<ZZ=1>
  8911	034617	200 00 0 00 070302 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8912	034620	404 00 0 00 070302 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8913	034621	444 00 0 00 070302 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8914	034622	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8915	034623	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8916						STOP^
  8917	034624	254 04 0 00 034625 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8918	034625	324 00 0 00 034626 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8919									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8920									;IN THE SUBTEST) TO LOOP ON ERROR^
  8921
  8922					;**********
  8923
  8924					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8925					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8926					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8927					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8928					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8929					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8930					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8931					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8932			013017		SN=SN+1
  8933			040000			ZZ=ZZ+ZZ
  8934						IFE	ZZ,<ZZ=1>
  8935	034626	200 00 0 00 070303 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8936	034627	404 00 0 00 070303 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8937	034630	444 00 0 00 070303 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8938	034631	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8939	034632	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8940						STOP^
  8941	034633	254 04 0 00 034634 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8942	034634	324 00 0 00 034635 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8943									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8944									;IN THE SUBTEST) TO LOOP ON ERROR^
  8945
  8946					;**********
  8947
  8948					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-7
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0188

  8949					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8950					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8951					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8952					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8953					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8954					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8955					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8956			013020		SN=SN+1
  8957			100000			ZZ=ZZ+ZZ
  8958						IFE	ZZ,<ZZ=1>
  8959	034635	200 00 0 00 070304 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8960	034636	404 00 0 00 070304 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8961	034637	444 00 0 00 070304 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8962	034640	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8963	034641	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8964						STOP^
  8965	034642	254 04 0 00 034643 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8966	034643	324 00 0 00 034644 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8967									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8968									;IN THE SUBTEST) TO LOOP ON ERROR^
  8969
  8970					;**********
  8971
  8972					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8973					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8974					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8975					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  8976					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  8977					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  8978					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  8979					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  8980			013021		SN=SN+1
  8981			200000			ZZ=ZZ+ZZ
  8982						IFE	ZZ,<ZZ=1>
  8983	034644	200 00 0 00 070305 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  8984	034645	404 00 0 00 070305 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  8985	034646	444 00 0 00 070305 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  8986	034647	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  8987	034650	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  8988						STOP^
  8989	034651	254 04 0 00 034652 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  8990	034652	324 00 0 00 034653 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  8991									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  8992									;IN THE SUBTEST) TO LOOP ON ERROR^
  8993
  8994					;**********
  8995
  8996					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  8997					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  8998					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  8999					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9000					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9001					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9002					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9003					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-8
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0189

  9004			013022		SN=SN+1
  9005			400000			ZZ=ZZ+ZZ
  9006						IFE	ZZ,<ZZ=1>
  9007	034653	200 00 0 00 070306 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9008	034654	404 00 0 00 070306 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9009	034655	444 00 0 00 070306 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9010	034656	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9011	034657	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9012						STOP^
  9013	034660	254 04 0 00 034661 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9014	034661	324 00 0 00 034662 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9015									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9016									;IN THE SUBTEST) TO LOOP ON ERROR^
  9017
  9018					;**********
  9019
  9020					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9021					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9022					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9023					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9024					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9025					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9026					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9027					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9028			013023		SN=SN+1
  9029		000001	000000			ZZ=ZZ+ZZ
  9030						IFE	ZZ,<ZZ=1>
  9031	034662	200 00 0 00 070307 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9032	034663	404 00 0 00 070307 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9033	034664	444 00 0 00 070307 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9034	034665	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9035	034666	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9036						STOP^
  9037	034667	254 04 0 00 034670 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9038	034670	324 00 0 00 034671 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9039									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9040									;IN THE SUBTEST) TO LOOP ON ERROR^
  9041
  9042					;**********
  9043
  9044					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9045					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9046					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9047					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9048					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9049					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9050					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9051					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9052			013024		SN=SN+1
  9053		000002	000000			ZZ=ZZ+ZZ
  9054						IFE	ZZ,<ZZ=1>
  9055	034671	200 00 0 00 070310 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9056	034672	404 00 0 00 070310 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9057	034673	444 00 0 00 070310 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9058	034674	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-9
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0190

  9059	034675	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9060						STOP^
  9061	034676	254 04 0 00 034677 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9062	034677	324 00 0 00 034700 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9063									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9064									;IN THE SUBTEST) TO LOOP ON ERROR^
  9065
  9066					;**********
  9067
  9068					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9069					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9070					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9071					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9072					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9073					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9074					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9075					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9076			013025		SN=SN+1
  9077		000004	000000			ZZ=ZZ+ZZ
  9078						IFE	ZZ,<ZZ=1>
  9079	034700	200 00 0 00 070311 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9080	034701	404 00 0 00 070311 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9081	034702	444 00 0 00 070311 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9082	034703	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9083	034704	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9084						STOP^
  9085	034705	254 04 0 00 034706 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9086	034706	324 00 0 00 034707 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9087									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9088									;IN THE SUBTEST) TO LOOP ON ERROR^
  9089
  9090					;**********
  9091
  9092					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9093					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9094					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9095					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9096					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9097					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9098					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9099					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9100			013026		SN=SN+1
  9101		000010	000000			ZZ=ZZ+ZZ
  9102						IFE	ZZ,<ZZ=1>
  9103	034707	200 00 0 00 070312 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9104	034710	404 00 0 00 070312 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9105	034711	444 00 0 00 070312 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9106	034712	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9107	034713	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9108						STOP^
  9109	034714	254 04 0 00 034715 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9110	034715	324 00 0 00 034716 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9111									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9112									;IN THE SUBTEST) TO LOOP ON ERROR^
  9113
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-10
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0191

  9114					;**********
  9115
  9116					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9117					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9118					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9119					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9120					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9121					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9122					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9123					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9124			013027		SN=SN+1
  9125		000020	000000			ZZ=ZZ+ZZ
  9126						IFE	ZZ,<ZZ=1>
  9127	034716	200 00 0 00 070313 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9128	034717	404 00 0 00 070313 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9129	034720	444 00 0 00 070313 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9130	034721	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9131	034722	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9132						STOP^
  9133	034723	254 04 0 00 034724 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9134	034724	324 00 0 00 034725 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9135									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9136									;IN THE SUBTEST) TO LOOP ON ERROR^
  9137
  9138					;**********
  9139
  9140					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9141					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9142					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9143					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9144					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9145					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9146					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9147					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9148			013030		SN=SN+1
  9149		000040	000000			ZZ=ZZ+ZZ
  9150						IFE	ZZ,<ZZ=1>
  9151	034725	200 00 0 00 070314 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9152	034726	404 00 0 00 070314 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9153	034727	444 00 0 00 070314 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9154	034730	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9155	034731	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9156						STOP^
  9157	034732	254 04 0 00 034733 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9158	034733	324 00 0 00 034734 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9159									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9160									;IN THE SUBTEST) TO LOOP ON ERROR^
  9161
  9162					;**********
  9163
  9164					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9165					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9166					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9167					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9168					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-11
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0192

  9169					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9170					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9171					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9172			013031		SN=SN+1
  9173		000100	000000			ZZ=ZZ+ZZ
  9174						IFE	ZZ,<ZZ=1>
  9175	034734	200 00 0 00 070315 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9176	034735	404 00 0 00 070315 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9177	034736	444 00 0 00 070315 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9178	034737	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9179	034740	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9180						STOP^
  9181	034741	254 04 0 00 034742 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9182	034742	324 00 0 00 034743 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9183									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9184									;IN THE SUBTEST) TO LOOP ON ERROR^
  9185
  9186					;**********
  9187
  9188					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9189					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9190					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9191					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9192					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9193					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9194					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9195					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9196			013032		SN=SN+1
  9197		000200	000000			ZZ=ZZ+ZZ
  9198						IFE	ZZ,<ZZ=1>
  9199	034743	200 00 0 00 070316 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9200	034744	404 00 0 00 070316 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9201	034745	444 00 0 00 070316 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9202	034746	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9203	034747	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9204						STOP^
  9205	034750	254 04 0 00 034751 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9206	034751	324 00 0 00 034752 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9207									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9208									;IN THE SUBTEST) TO LOOP ON ERROR^
  9209
  9210					;**********
  9211
  9212					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9213					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9214					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9215					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9216					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9217					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9218					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9219					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9220			013033		SN=SN+1
  9221		000400	000000			ZZ=ZZ+ZZ
  9222						IFE	ZZ,<ZZ=1>
  9223	034752	200 00 0 00 070264 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-12
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0193

  9224	034753	404 00 0 00 070264 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9225	034754	444 00 0 00 070264 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9226	034755	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9227	034756	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9228						STOP^
  9229	034757	254 04 0 00 034760 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9230	034760	324 00 0 00 034761 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9231									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9232									;IN THE SUBTEST) TO LOOP ON ERROR^
  9233
  9234					;**********
  9235
  9236					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9237					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9238					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9239					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9240					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9241					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9242					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9243					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9244			013034		SN=SN+1
  9245		001000	000000			ZZ=ZZ+ZZ
  9246						IFE	ZZ,<ZZ=1>
  9247	034761	200 00 0 00 070317 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9248	034762	404 00 0 00 070317 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9249	034763	444 00 0 00 070317 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9250	034764	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9251	034765	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9252						STOP^
  9253	034766	254 04 0 00 034767 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9254	034767	324 00 0 00 034770 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9255									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9256									;IN THE SUBTEST) TO LOOP ON ERROR^
  9257
  9258					;**********
  9259
  9260					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9261					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9262					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9263					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9264					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9265					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9266					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9267					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9268			013035		SN=SN+1
  9269		002000	000000			ZZ=ZZ+ZZ
  9270						IFE	ZZ,<ZZ=1>
  9271	034770	200 00 0 00 070320 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9272	034771	404 00 0 00 070320 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9273	034772	444 00 0 00 070320 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9274	034773	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9275	034774	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9276						STOP^
  9277	034775	254 04 0 00 034776 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9278	034776	324 00 0 00 034777 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-13
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0194

  9279									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9280									;IN THE SUBTEST) TO LOOP ON ERROR^
  9281
  9282					;**********
  9283
  9284					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9285					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9286					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9287					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9288					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9289					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9290					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9291					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9292			013036		SN=SN+1
  9293		004000	000000			ZZ=ZZ+ZZ
  9294						IFE	ZZ,<ZZ=1>
  9295	034777	200 00 0 00 070321 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9296	035000	404 00 0 00 070321 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9297	035001	444 00 0 00 070321 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9298	035002	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9299	035003	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9300						STOP^
  9301	035004	254 04 0 00 035005 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9302	035005	324 00 0 00 035006 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9303									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9304									;IN THE SUBTEST) TO LOOP ON ERROR^
  9305
  9306					;**********
  9307
  9308					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9309					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9310					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9311					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9312					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9313					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9314					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9315					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9316			013037		SN=SN+1
  9317		010000	000000			ZZ=ZZ+ZZ
  9318						IFE	ZZ,<ZZ=1>
  9319	035006	200 00 0 00 070322 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9320	035007	404 00 0 00 070322 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9321	035010	444 00 0 00 070322 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9322	035011	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9323	035012	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9324						STOP^
  9325	035013	254 04 0 00 035014 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9326	035014	324 00 0 00 035015 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9327									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9328									;IN THE SUBTEST) TO LOOP ON ERROR^
  9329
  9330					;**********
  9331
  9332					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9333					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-14
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0195

  9334					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9335					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9336					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9337					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9338					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9339					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9340			013040		SN=SN+1
  9341		020000	000000			ZZ=ZZ+ZZ
  9342						IFE	ZZ,<ZZ=1>
  9343	035015	200 00 0 00 070323 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9344	035016	404 00 0 00 070323 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9345	035017	444 00 0 00 070323 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9346	035020	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9347	035021	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9348						STOP^
  9349	035022	254 04 0 00 035023 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9350	035023	324 00 0 00 035024 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9351									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9352									;IN THE SUBTEST) TO LOOP ON ERROR^
  9353
  9354					;**********
  9355
  9356					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9357					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9358					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9359					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9360					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9361					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9362					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9363					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9364			013041		SN=SN+1
  9365		040000	000000			ZZ=ZZ+ZZ
  9366						IFE	ZZ,<ZZ=1>
  9367	035024	200 00 0 00 070324 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9368	035025	404 00 0 00 070324 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9369	035026	444 00 0 00 070324 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9370	035027	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9371	035030	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9372						STOP^
  9373	035031	254 04 0 00 035032 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9374	035032	324 00 0 00 035033 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9375									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9376									;IN THE SUBTEST) TO LOOP ON ERROR^
  9377
  9378					;**********
  9379
  9380					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9381					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9382					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9383					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9384					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9385					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9386					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9387					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9388			013042		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-15
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0196

  9389		100000	000000			ZZ=ZZ+ZZ
  9390						IFE	ZZ,<ZZ=1>
  9391	035033	200 00 0 00 070325 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9392	035034	404 00 0 00 070325 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9393	035035	444 00 0 00 070325 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9394	035036	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9395	035037	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9396						STOP^
  9397	035040	254 04 0 00 035041 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9398	035041	324 00 0 00 035042 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9399									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9400									;IN THE SUBTEST) TO LOOP ON ERROR^
  9401
  9402					;**********
  9403
  9404					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9405					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9406					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9407					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9408					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9409					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9410					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9411					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9412			013043		SN=SN+1
  9413		200000	000000			ZZ=ZZ+ZZ
  9414						IFE	ZZ,<ZZ=1>
  9415	035042	200 00 0 00 070326 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9416	035043	404 00 0 00 070326 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9417	035044	444 00 0 00 070326 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9418	035045	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9419	035046	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9420						STOP^
  9421	035047	254 04 0 00 035050 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9422	035050	324 00 0 00 035051 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9423									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9424									;IN THE SUBTEST) TO LOOP ON ERROR^
  9425
  9426					;**********
  9427
  9428					;THIS TEST CHECKS THE 'AND' INSTRUCTION AND THE ADDER ON A ONE-BIT-AT-A-TIME BASIS.
  9429					;THE AC IS LOADED WITH ALL ZEROS EXCEPT FOR ONE BIT EQUAL TO ONE; THE AC IS THEN
  9430					;ANDED WITH C(E) WHERE C(E)=C(AC).  THE NET RESULT SHOULD BE NO CHANGE TO C(AC).
  9431					;NEXT, THE AC IS EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9432					;BE ALL ONES IN THE AC.  THE AC IS THEN EQUIVALENCED WITH A WORD OF ALL ZEROS,
  9433					;WHICH SHOULD RESULT IN C(AC)=0.  THE AC IS CHECKED FOR ALL ZEROS.
  9434					;IF C(AC) IS NON-ZERO, THE TEST FAILS.  THIS TEST IS REPEATED 36 TIMES TO
  9435					;RIPPLE A ONE THROUGH EVERY BIT OF THE AC.
  9436			013044		SN=SN+1
  9437		400000	000000			ZZ=ZZ+ZZ
  9438						IFE	ZZ,<ZZ=1>
  9439	035051	200 00 0 00 070256 		MOVE	[ZZ]		;SETUP AC WITH A ONE IN ONLY ONE BIT
  9440	035052	404 00 0 00 070256 		AND	[ZZ]		;*AND FLOATING ONE WITH ITSELF SHOULD NOT CHANGE C(AC)
  9441	035053	444 00 0 00 070256 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9442	035054	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9443	035055	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 31-16
DFKAA1	MAC	31-JAN-77 09:33		TEST OF BOOLEAN INSTRUCTIONS (SETM, SETZ, AND, XOR, EQV)                           SEQ 0197

  9444						STOP^
  9445	035056	254 04 0 00 035057 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9446	035057	324 00 0 00 035060 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9447									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9448									;IN THE SUBTEST) TO LOOP ON ERROR^
  9449
  9450					;**********
  9451
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0198

  9452					SUBTTL	TEST OF THE ADD INSTRUCTION
  9453
  9454					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED
  9455					;TO ADD A NON-ZERO NUMBER CONTAINED IN E TO AN AC CONTAINING ALL ZEROS,
  9456					;THE RESULT IS A NON-ZERO NUMBER IN THE AC.  FIRST, THE AC IS CLEARED;
  9457					;THEN, ANON-ZERO POSITIVE NUMBER IS ADDED TO THE AC USING THE ADD 
  9458					;INSTRUCTION.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9459
  9460	035060	200 00 0 00 070253 		A10400:	MOVE	[0]		;PRESET AC TO ALL ZEROS
  9461	035061	270 00 0 00 070376 		ADD	[123456765432]	;*ADD OF A NON-ZERO NUMBER TO AN AC OF ALL
  9462									;ZEROS SHOULD RESULT
  9463									;IN AN AC CONTAINING A NON-ZERO NUMBER
  9464	035062	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
  9465						STOP^
  9466	035063	254 04 0 00 035064 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9467	035064	324 00 0 00 035065 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9468									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9469									;IN THE SUBTEST) TO LOOP ON ERROR^
  9470
  9471					;AD ADD [ADC1], AD ADD EN [ADC1],
  9472					;F CYC ACT EN A [F1], AD FM + FETCH EN A [ADFP],
  9473					;F CYC ACT EN C[F1], IR ADSUB [IR1], IRXX [IR1]
  9474
  9475					;**********
  9476
  9477					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
  9478					;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
  9479					;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
  9480					;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
  9481					; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9482
  9483	035065	200 00 0 00 070376 	A10500:	MOVE	[123456765432]	;PRESET AC WITH A NON-ZERO NUMBER
  9484	035066	270 00 0 00 070253 		ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC
  9485									;CONTAINING A NON-ZERO NUMBER
  9486									;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
  9487	035067	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
  9488						STOP^
  9489	035070	254 04 0 00 035071 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9490	035071	324 00 0 00 035072 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9491									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9492									;IN THE SUBTEST) TO LOOP ON ERROR^
  9493
  9494					;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F [E],
  9495					;AR AD ET2 EN [ARMA], IR ADSUB [IR1]
  9496
  9497					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0199

  9498					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
  9499					;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
  9500					;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
  9501					;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
  9502					; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9503
  9504	035072	200 00 0 00 070377 	A10600:	MOVE	[XWD 123456,0]	;PRESET AC WITH A NON-ZERO NUMBER
  9505	035073	270 00 0 00 070253 		ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
  9506									;A NON-ZERO NUMBER SHOULD RESULT IN AN AC
  9507									;CONTAINING A NON-ZERO NUMBER
  9508	035074	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
  9509						STOP^
  9510	035075	254 04 0 00 035076 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9511	035076	324 00 0 00 035077 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9512									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9513									;IN THE SUBTEST) TO LOOP ON ERROR^
  9514
  9515					;AR AD EN [ARMA], AR AD EN A [ARMA], ET2C F/F[E],
  9516					;AR AD ET2 EN [ARMA], IR AD SUB [IR1]
  9517
  9518					;*********
  9519
  9520					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
  9521					;A WORD OF ALL ZEROS TO AN AC CONTAINING A NON-ZERO POSITIVE NUMBER, THE
  9522					;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
  9523					;INITIALIZED WITH A NON-ZERO POSITIVE NUMBER; THEN, A WORD OF ALL ZEROS
  9524					; IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9525
  9526	035077	200 00 0 00 070400 	A10700:	MOVE	[123456]	;PRESET AC WITH A NON-ZERO NUMBER
  9527	035100	270 00 0 00 070253 		ADD	[0]		;*ADD OF A WORD OF ALL ZEROS TO AN AC CONTAINING
  9528									;A NON-ZERO NUMBER
  9529									;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
  9530	035101	336 00 0 00 000000 		SKIPN			;PASS TEST IS C(AC) IS NON-ZERO
  9531						STOP^
  9532	035102	254 04 0 00 035103 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9533	035103	324 00 0 00 035104 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9534									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9535									;IN THE SUBTEST) TO LOOP ON ERROR^
  9536
  9537					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0200

  9538					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
  9539					;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
  9540					;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
  9541					;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
  9542					;IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9543
  9544	035104	200 00 0 00 070253 	A13300:	MOVE	[0]		;PRESET AC WITH ALL ZEROS
  9545	035105	270 00 0 00 070377 		ADD	[123456,,0]	;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
  9546									;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
  9547	035106	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
  9548						STOP^
  9549	035107	254 04 0 00 035110 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9550	035110	324 00 0 00 035111 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9551									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9552									;IN THE SUBTEST) TO LOOP ON ERROR^
  9553
  9554					;**********
  9555
  9556					;THIS TEST VERIFIES THAT WHEN THE ADD INSTRUCTION IS USED TO ADD
  9557					;A WORD CONTAINING A NON-ZERO POSITIVE NUMBER TO AN AC OF ALL ZEROS, THE
  9558					;RESULT IS A NON-ZERO POSITIVE NUMBER IN THE AC.  FIRST, THE AC IS
  9559					;INITIALIZED WITH A WORD OF ALL ZEROS ;THEN, A NON-ZERO POSITIVE NUMBER
  9560					;IS ADDED TO THE AC.  THE AC IS THEN CHECKED FOR ITS CONTENTS NON-ZERO
  9561
  9562	035111	200 00 0 00 070253 	A13400:	MOVE	[0]		;PRESET AC WITH ALL ZEROS
  9563	035112	270 00 0 00 070400 		ADD	[123456]	;*ADD OF A NON-ZERO NUMBER TO AN AC CONTAINING ALL ZEROS
  9564									;SHOULD RESULT IN AN AC CONTAINING A NON-ZERO NUMBER
  9565	035113	336 00 0 00 000000 		SKIPN			;PASS TEST IF C(AC) IS NON-ZERO
  9566						STOP^
  9567	035114	254 04 0 00 035115 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9568	035115	324 00 0 00 035116 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9569									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9570									;IN THE SUBTEST) TO LOOP ON ERROR^
  9571
  9572					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0201

  9573					;ADD ZERO TO A RIPPLED ONE
  9574
  9575			011000		SN=11000
  9576			000000			ZZ=0
  9577
  9578					A11000:	REPEAT	^D36,
  9579					<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9580					;A WORD OF ALL ZEROS IS ADDED TO AN
  9581					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9582					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9583					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9584					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9585					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9586					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9587					;EVERY BIT OF THE AC.
  9588					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9589					SN=SN+1
  9590						ZZ=ZZ+ZZ
  9591						IFE	ZZ,<ZZ=1>
  9592						MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9593						ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9594						EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9595						EQV	[0]		;RESULTS IN C(AC)=0
  9596						SKIPE			;PASS TEST IF C(AC)=0
  9597						STOP
  9598					
  9599					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9600					;IR ADDX [IR1], IR ADSUB [IR1]
  9601					
  9602					;**********
  9603					PAGE
  9604					>
  9605					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9606					;A WORD OF ALL ZEROS IS ADDED TO AN
  9607					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9608					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9609					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9610					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9611					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9612					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9613					;EVERY BIT OF THE AC.
  9614					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9615			011001		SN=SN+1
  9616			000000			ZZ=ZZ+ZZ
  9617			000001			IFE	ZZ,<ZZ=1>
  9618	035116	200 00 0 00 070265 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9619	035117	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9620	035120	444 00 0 00 070265 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9621	035121	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9622	035122	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9623						STOP^
  9624	035123	254 04 0 00 035124 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9625	035124	324 00 0 00 035125 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9626									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9627									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0202

  9628
  9629					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9630					;IR ADDX [IR1], IR ADSUB [IR1]
  9631
  9632					;**********
  9633					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0203

  9634
  9635					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9636					;A WORD OF ALL ZEROS IS ADDED TO AN
  9637					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9638					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9639					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9640					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9641					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9642					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9643					;EVERY BIT OF THE AC.
  9644					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9645			011002		SN=SN+1
  9646			000002			ZZ=ZZ+ZZ
  9647						IFE	ZZ,<ZZ=1>
  9648	035125	200 00 0 00 070266 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9649	035126	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9650	035127	444 00 0 00 070266 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9651	035130	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9652	035131	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9653						STOP^
  9654	035132	254 04 0 00 035133 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9655	035133	324 00 0 00 035134 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9656									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9657									;IN THE SUBTEST) TO LOOP ON ERROR^
  9658
  9659					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9660					;IR ADDX [IR1], IR ADSUB [IR1]
  9661
  9662					;**********
  9663					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0204

  9664
  9665					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9666					;A WORD OF ALL ZEROS IS ADDED TO AN
  9667					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9668					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9669					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9670					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9671					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9672					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9673					;EVERY BIT OF THE AC.
  9674					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9675			011003		SN=SN+1
  9676			000004			ZZ=ZZ+ZZ
  9677						IFE	ZZ,<ZZ=1>
  9678	035134	200 00 0 00 070267 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9679	035135	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9680	035136	444 00 0 00 070267 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9681	035137	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9682	035140	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9683						STOP^
  9684	035141	254 04 0 00 035142 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9685	035142	324 00 0 00 035143 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9686									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9687									;IN THE SUBTEST) TO LOOP ON ERROR^
  9688
  9689					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9690					;IR ADDX [IR1], IR ADSUB [IR1]
  9691
  9692					;**********
  9693					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0205

  9694
  9695					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9696					;A WORD OF ALL ZEROS IS ADDED TO AN
  9697					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9698					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9699					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9700					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9701					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9702					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9703					;EVERY BIT OF THE AC.
  9704					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9705			011004		SN=SN+1
  9706			000010			ZZ=ZZ+ZZ
  9707						IFE	ZZ,<ZZ=1>
  9708	035143	200 00 0 00 070270 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9709	035144	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9710	035145	444 00 0 00 070270 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9711	035146	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9712	035147	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9713						STOP^
  9714	035150	254 04 0 00 035151 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9715	035151	324 00 0 00 035152 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9716									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9717									;IN THE SUBTEST) TO LOOP ON ERROR^
  9718
  9719					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9720					;IR ADDX [IR1], IR ADSUB [IR1]
  9721
  9722					;**********
  9723					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0206

  9724
  9725					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9726					;A WORD OF ALL ZEROS IS ADDED TO AN
  9727					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9728					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9729					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9730					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9731					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9732					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9733					;EVERY BIT OF THE AC.
  9734					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9735			011005		SN=SN+1
  9736			000020			ZZ=ZZ+ZZ
  9737						IFE	ZZ,<ZZ=1>
  9738	035152	200 00 0 00 070271 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9739	035153	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9740	035154	444 00 0 00 070271 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9741	035155	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9742	035156	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9743						STOP^
  9744	035157	254 04 0 00 035160 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9745	035160	324 00 0 00 035161 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9746									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9747									;IN THE SUBTEST) TO LOOP ON ERROR^
  9748
  9749					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9750					;IR ADDX [IR1], IR ADSUB [IR1]
  9751
  9752					;**********
  9753					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0207

  9754
  9755					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9756					;A WORD OF ALL ZEROS IS ADDED TO AN
  9757					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9758					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9759					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9760					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9761					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9762					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9763					;EVERY BIT OF THE AC.
  9764					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9765			011006		SN=SN+1
  9766			000040			ZZ=ZZ+ZZ
  9767						IFE	ZZ,<ZZ=1>
  9768	035161	200 00 0 00 070272 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9769	035162	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9770	035163	444 00 0 00 070272 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9771	035164	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9772	035165	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9773						STOP^
  9774	035166	254 04 0 00 035167 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9775	035167	324 00 0 00 035170 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9776									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9777									;IN THE SUBTEST) TO LOOP ON ERROR^
  9778
  9779					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9780					;IR ADDX [IR1], IR ADSUB [IR1]
  9781
  9782					;**********
  9783					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0208

  9784
  9785					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9786					;A WORD OF ALL ZEROS IS ADDED TO AN
  9787					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9788					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9789					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9790					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9791					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9792					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9793					;EVERY BIT OF THE AC.
  9794					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9795			011007		SN=SN+1
  9796			000100			ZZ=ZZ+ZZ
  9797						IFE	ZZ,<ZZ=1>
  9798	035170	200 00 0 00 070273 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9799	035171	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9800	035172	444 00 0 00 070273 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9801	035173	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9802	035174	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9803						STOP^
  9804	035175	254 04 0 00 035176 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9805	035176	324 00 0 00 035177 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9806									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9807									;IN THE SUBTEST) TO LOOP ON ERROR^
  9808
  9809					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9810					;IR ADDX [IR1], IR ADSUB [IR1]
  9811
  9812					;**********
  9813					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0209

  9814
  9815					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9816					;A WORD OF ALL ZEROS IS ADDED TO AN
  9817					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9818					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9819					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9820					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9821					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9822					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9823					;EVERY BIT OF THE AC.
  9824					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9825			011010		SN=SN+1
  9826			000200			ZZ=ZZ+ZZ
  9827						IFE	ZZ,<ZZ=1>
  9828	035177	200 00 0 00 070274 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9829	035200	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9830	035201	444 00 0 00 070274 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9831	035202	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9832	035203	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9833						STOP^
  9834	035204	254 04 0 00 035205 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9835	035205	324 00 0 00 035206 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9836									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9837									;IN THE SUBTEST) TO LOOP ON ERROR^
  9838
  9839					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9840					;IR ADDX [IR1], IR ADSUB [IR1]
  9841
  9842					;**********
  9843					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0210

  9844
  9845					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9846					;A WORD OF ALL ZEROS IS ADDED TO AN
  9847					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9848					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9849					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9850					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9851					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9852					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9853					;EVERY BIT OF THE AC.
  9854					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9855			011011		SN=SN+1
  9856			000400			ZZ=ZZ+ZZ
  9857						IFE	ZZ,<ZZ=1>
  9858	035206	200 00 0 00 070275 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9859	035207	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9860	035210	444 00 0 00 070275 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9861	035211	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9862	035212	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9863						STOP^
  9864	035213	254 04 0 00 035214 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9865	035214	324 00 0 00 035215 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9866									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9867									;IN THE SUBTEST) TO LOOP ON ERROR^
  9868
  9869					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9870					;IR ADDX [IR1], IR ADSUB [IR1]
  9871
  9872					;**********
  9873					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0211

  9874
  9875					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9876					;A WORD OF ALL ZEROS IS ADDED TO AN
  9877					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9878					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9879					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9880					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9881					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9882					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9883					;EVERY BIT OF THE AC.
  9884					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9885			011012		SN=SN+1
  9886			001000			ZZ=ZZ+ZZ
  9887						IFE	ZZ,<ZZ=1>
  9888	035215	200 00 0 00 070276 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9889	035216	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9890	035217	444 00 0 00 070276 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9891	035220	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9892	035221	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9893						STOP^
  9894	035222	254 04 0 00 035223 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9895	035223	324 00 0 00 035224 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9896									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9897									;IN THE SUBTEST) TO LOOP ON ERROR^
  9898
  9899					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9900					;IR ADDX [IR1], IR ADSUB [IR1]
  9901
  9902					;**********
  9903					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0212

  9904
  9905					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9906					;A WORD OF ALL ZEROS IS ADDED TO AN
  9907					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9908					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9909					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9910					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9911					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9912					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9913					;EVERY BIT OF THE AC.
  9914					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9915			011013		SN=SN+1
  9916			002000			ZZ=ZZ+ZZ
  9917						IFE	ZZ,<ZZ=1>
  9918	035224	200 00 0 00 070277 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9919	035225	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9920	035226	444 00 0 00 070277 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9921	035227	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9922	035230	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9923						STOP^
  9924	035231	254 04 0 00 035232 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9925	035232	324 00 0 00 035233 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9926									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9927									;IN THE SUBTEST) TO LOOP ON ERROR^
  9928
  9929					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9930					;IR ADDX [IR1], IR ADSUB [IR1]
  9931
  9932					;**********
  9933					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0213

  9934
  9935					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9936					;A WORD OF ALL ZEROS IS ADDED TO AN
  9937					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9938					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9939					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9940					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9941					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9942					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9943					;EVERY BIT OF THE AC.
  9944					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9945			011014		SN=SN+1
  9946			004000			ZZ=ZZ+ZZ
  9947						IFE	ZZ,<ZZ=1>
  9948	035233	200 00 0 00 070300 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9949	035234	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9950	035235	444 00 0 00 070300 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9951	035236	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9952	035237	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9953						STOP^
  9954	035240	254 04 0 00 035241 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9955	035241	324 00 0 00 035242 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9956									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9957									;IN THE SUBTEST) TO LOOP ON ERROR^
  9958
  9959					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9960					;IR ADDX [IR1], IR ADSUB [IR1]
  9961
  9962					;**********
  9963					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-13
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0214

  9964
  9965					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9966					;A WORD OF ALL ZEROS IS ADDED TO AN
  9967					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9968					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9969					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
  9970					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
  9971					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
  9972					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
  9973					;EVERY BIT OF THE AC.
  9974					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
  9975			011015		SN=SN+1
  9976			010000			ZZ=ZZ+ZZ
  9977						IFE	ZZ,<ZZ=1>
  9978	035242	200 00 0 00 070301 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
  9979	035243	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
  9980	035244	444 00 0 00 070301 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
  9981	035245	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
  9982	035246	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
  9983						STOP^
  9984	035247	254 04 0 00 035250 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
  9985	035250	324 00 0 00 035251 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
  9986									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
  9987									;IN THE SUBTEST) TO LOOP ON ERROR^
  9988
  9989					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
  9990					;IR ADDX [IR1], IR ADSUB [IR1]
  9991
  9992					;**********
  9993					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-14
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0215

  9994
  9995					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
  9996					;A WORD OF ALL ZEROS IS ADDED TO AN
  9997					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
  9998					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
  9999					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10000					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10001					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10002					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10003					;EVERY BIT OF THE AC.
 10004					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10005			011016		SN=SN+1
 10006			020000			ZZ=ZZ+ZZ
 10007						IFE	ZZ,<ZZ=1>
 10008	035251	200 00 0 00 070302 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10009	035252	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10010	035253	444 00 0 00 070302 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10011	035254	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10012	035255	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10013						STOP^
 10014	035256	254 04 0 00 035257 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10015	035257	324 00 0 00 035260 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10016									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10017									;IN THE SUBTEST) TO LOOP ON ERROR^
 10018
 10019					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10020					;IR ADDX [IR1], IR ADSUB [IR1]
 10021
 10022					;**********
 10023					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-15
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0216

 10024
 10025					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10026					;A WORD OF ALL ZEROS IS ADDED TO AN
 10027					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10028					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10029					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10030					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10031					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10032					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10033					;EVERY BIT OF THE AC.
 10034					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10035			011017		SN=SN+1
 10036			040000			ZZ=ZZ+ZZ
 10037						IFE	ZZ,<ZZ=1>
 10038	035260	200 00 0 00 070303 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10039	035261	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10040	035262	444 00 0 00 070303 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10041	035263	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10042	035264	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10043						STOP^
 10044	035265	254 04 0 00 035266 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10045	035266	324 00 0 00 035267 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10046									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10047									;IN THE SUBTEST) TO LOOP ON ERROR^
 10048
 10049					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10050					;IR ADDX [IR1], IR ADSUB [IR1]
 10051
 10052					;**********
 10053					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-16
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0217

 10054
 10055					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10056					;A WORD OF ALL ZEROS IS ADDED TO AN
 10057					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10058					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10059					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10060					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10061					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10062					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10063					;EVERY BIT OF THE AC.
 10064					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10065			011020		SN=SN+1
 10066			100000			ZZ=ZZ+ZZ
 10067						IFE	ZZ,<ZZ=1>
 10068	035267	200 00 0 00 070304 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10069	035270	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10070	035271	444 00 0 00 070304 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10071	035272	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10072	035273	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10073						STOP^
 10074	035274	254 04 0 00 035275 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10075	035275	324 00 0 00 035276 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10076									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10077									;IN THE SUBTEST) TO LOOP ON ERROR^
 10078
 10079					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10080					;IR ADDX [IR1], IR ADSUB [IR1]
 10081
 10082					;**********
 10083					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-17
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0218

 10084
 10085					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10086					;A WORD OF ALL ZEROS IS ADDED TO AN
 10087					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10088					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10089					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10090					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10091					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10092					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10093					;EVERY BIT OF THE AC.
 10094					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10095			011021		SN=SN+1
 10096			200000			ZZ=ZZ+ZZ
 10097						IFE	ZZ,<ZZ=1>
 10098	035276	200 00 0 00 070305 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10099	035277	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10100	035300	444 00 0 00 070305 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10101	035301	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10102	035302	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10103						STOP^
 10104	035303	254 04 0 00 035304 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10105	035304	324 00 0 00 035305 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10106									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10107									;IN THE SUBTEST) TO LOOP ON ERROR^
 10108
 10109					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10110					;IR ADDX [IR1], IR ADSUB [IR1]
 10111
 10112					;**********
 10113					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-18
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0219

 10114
 10115					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10116					;A WORD OF ALL ZEROS IS ADDED TO AN
 10117					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10118					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10119					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10120					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10121					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10122					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10123					;EVERY BIT OF THE AC.
 10124					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10125			011022		SN=SN+1
 10126			400000			ZZ=ZZ+ZZ
 10127						IFE	ZZ,<ZZ=1>
 10128	035305	200 00 0 00 070306 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10129	035306	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10130	035307	444 00 0 00 070306 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10131	035310	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10132	035311	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10133						STOP^
 10134	035312	254 04 0 00 035313 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10135	035313	324 00 0 00 035314 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10136									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10137									;IN THE SUBTEST) TO LOOP ON ERROR^
 10138
 10139					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10140					;IR ADDX [IR1], IR ADSUB [IR1]
 10141
 10142					;**********
 10143					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-19
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0220

 10144
 10145					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10146					;A WORD OF ALL ZEROS IS ADDED TO AN
 10147					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10148					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10149					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10150					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10151					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10152					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10153					;EVERY BIT OF THE AC.
 10154					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10155			011023		SN=SN+1
 10156		000001	000000			ZZ=ZZ+ZZ
 10157						IFE	ZZ,<ZZ=1>
 10158	035314	200 00 0 00 070307 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10159	035315	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10160	035316	444 00 0 00 070307 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10161	035317	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10162	035320	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10163						STOP^
 10164	035321	254 04 0 00 035322 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10165	035322	324 00 0 00 035323 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10166									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10167									;IN THE SUBTEST) TO LOOP ON ERROR^
 10168
 10169					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10170					;IR ADDX [IR1], IR ADSUB [IR1]
 10171
 10172					;**********
 10173					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-20
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0221

 10174
 10175					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10176					;A WORD OF ALL ZEROS IS ADDED TO AN
 10177					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10178					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10179					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10180					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10181					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10182					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10183					;EVERY BIT OF THE AC.
 10184					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10185			011024		SN=SN+1
 10186		000002	000000			ZZ=ZZ+ZZ
 10187						IFE	ZZ,<ZZ=1>
 10188	035323	200 00 0 00 070310 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10189	035324	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10190	035325	444 00 0 00 070310 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10191	035326	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10192	035327	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10193						STOP^
 10194	035330	254 04 0 00 035331 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10195	035331	324 00 0 00 035332 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10196									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10197									;IN THE SUBTEST) TO LOOP ON ERROR^
 10198
 10199					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10200					;IR ADDX [IR1], IR ADSUB [IR1]
 10201
 10202					;**********
 10203					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-21
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0222

 10204
 10205					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10206					;A WORD OF ALL ZEROS IS ADDED TO AN
 10207					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10208					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10209					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10210					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10211					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10212					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10213					;EVERY BIT OF THE AC.
 10214					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10215			011025		SN=SN+1
 10216		000004	000000			ZZ=ZZ+ZZ
 10217						IFE	ZZ,<ZZ=1>
 10218	035332	200 00 0 00 070311 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10219	035333	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10220	035334	444 00 0 00 070311 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10221	035335	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10222	035336	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10223						STOP^
 10224	035337	254 04 0 00 035340 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10225	035340	324 00 0 00 035341 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10226									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10227									;IN THE SUBTEST) TO LOOP ON ERROR^
 10228
 10229					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10230					;IR ADDX [IR1], IR ADSUB [IR1]
 10231
 10232					;**********
 10233					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-22
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0223

 10234
 10235					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10236					;A WORD OF ALL ZEROS IS ADDED TO AN
 10237					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10238					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10239					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10240					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10241					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10242					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10243					;EVERY BIT OF THE AC.
 10244					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10245			011026		SN=SN+1
 10246		000010	000000			ZZ=ZZ+ZZ
 10247						IFE	ZZ,<ZZ=1>
 10248	035341	200 00 0 00 070312 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10249	035342	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10250	035343	444 00 0 00 070312 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10251	035344	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10252	035345	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10253						STOP^
 10254	035346	254 04 0 00 035347 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10255	035347	324 00 0 00 035350 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10256									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10257									;IN THE SUBTEST) TO LOOP ON ERROR^
 10258
 10259					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10260					;IR ADDX [IR1], IR ADSUB [IR1]
 10261
 10262					;**********
 10263					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-23
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0224

 10264
 10265					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10266					;A WORD OF ALL ZEROS IS ADDED TO AN
 10267					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10268					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10269					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10270					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10271					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10272					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10273					;EVERY BIT OF THE AC.
 10274					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10275			011027		SN=SN+1
 10276		000020	000000			ZZ=ZZ+ZZ
 10277						IFE	ZZ,<ZZ=1>
 10278	035350	200 00 0 00 070313 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10279	035351	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10280	035352	444 00 0 00 070313 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10281	035353	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10282	035354	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10283						STOP^
 10284	035355	254 04 0 00 035356 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10285	035356	324 00 0 00 035357 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10286									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10287									;IN THE SUBTEST) TO LOOP ON ERROR^
 10288
 10289					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10290					;IR ADDX [IR1], IR ADSUB [IR1]
 10291
 10292					;**********
 10293					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-24
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0225

 10294
 10295					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10296					;A WORD OF ALL ZEROS IS ADDED TO AN
 10297					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10298					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10299					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10300					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10301					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10302					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10303					;EVERY BIT OF THE AC.
 10304					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10305			011030		SN=SN+1
 10306		000040	000000			ZZ=ZZ+ZZ
 10307						IFE	ZZ,<ZZ=1>
 10308	035357	200 00 0 00 070314 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10309	035360	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10310	035361	444 00 0 00 070314 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10311	035362	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10312	035363	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10313						STOP^
 10314	035364	254 04 0 00 035365 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10315	035365	324 00 0 00 035366 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10316									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10317									;IN THE SUBTEST) TO LOOP ON ERROR^
 10318
 10319					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10320					;IR ADDX [IR1], IR ADSUB [IR1]
 10321
 10322					;**********
 10323					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-25
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0226

 10324
 10325					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10326					;A WORD OF ALL ZEROS IS ADDED TO AN
 10327					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10328					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10329					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10330					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10331					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10332					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10333					;EVERY BIT OF THE AC.
 10334					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10335			011031		SN=SN+1
 10336		000100	000000			ZZ=ZZ+ZZ
 10337						IFE	ZZ,<ZZ=1>
 10338	035366	200 00 0 00 070315 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10339	035367	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10340	035370	444 00 0 00 070315 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10341	035371	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10342	035372	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10343						STOP^
 10344	035373	254 04 0 00 035374 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10345	035374	324 00 0 00 035375 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10346									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10347									;IN THE SUBTEST) TO LOOP ON ERROR^
 10348
 10349					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10350					;IR ADDX [IR1], IR ADSUB [IR1]
 10351
 10352					;**********
 10353					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-26
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0227

 10354
 10355					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10356					;A WORD OF ALL ZEROS IS ADDED TO AN
 10357					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10358					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10359					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10360					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10361					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10362					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10363					;EVERY BIT OF THE AC.
 10364					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10365			011032		SN=SN+1
 10366		000200	000000			ZZ=ZZ+ZZ
 10367						IFE	ZZ,<ZZ=1>
 10368	035375	200 00 0 00 070316 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10369	035376	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10370	035377	444 00 0 00 070316 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10371	035400	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10372	035401	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10373						STOP^
 10374	035402	254 04 0 00 035403 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10375	035403	324 00 0 00 035404 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10376									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10377									;IN THE SUBTEST) TO LOOP ON ERROR^
 10378
 10379					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10380					;IR ADDX [IR1], IR ADSUB [IR1]
 10381
 10382					;**********
 10383					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-27
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0228

 10384
 10385					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10386					;A WORD OF ALL ZEROS IS ADDED TO AN
 10387					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10388					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10389					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10390					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10391					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10392					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10393					;EVERY BIT OF THE AC.
 10394					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10395			011033		SN=SN+1
 10396		000400	000000			ZZ=ZZ+ZZ
 10397						IFE	ZZ,<ZZ=1>
 10398	035404	200 00 0 00 070264 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10399	035405	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10400	035406	444 00 0 00 070264 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10401	035407	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10402	035410	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10403						STOP^
 10404	035411	254 04 0 00 035412 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10405	035412	324 00 0 00 035413 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10406									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10407									;IN THE SUBTEST) TO LOOP ON ERROR^
 10408
 10409					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10410					;IR ADDX [IR1], IR ADSUB [IR1]
 10411
 10412					;**********
 10413					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-28
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0229

 10414
 10415					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10416					;A WORD OF ALL ZEROS IS ADDED TO AN
 10417					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10418					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10419					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10420					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10421					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10422					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10423					;EVERY BIT OF THE AC.
 10424					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10425			011034		SN=SN+1
 10426		001000	000000			ZZ=ZZ+ZZ
 10427						IFE	ZZ,<ZZ=1>
 10428	035413	200 00 0 00 070317 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10429	035414	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10430	035415	444 00 0 00 070317 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10431	035416	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10432	035417	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10433						STOP^
 10434	035420	254 04 0 00 035421 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10435	035421	324 00 0 00 035422 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10436									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10437									;IN THE SUBTEST) TO LOOP ON ERROR^
 10438
 10439					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10440					;IR ADDX [IR1], IR ADSUB [IR1]
 10441
 10442					;**********
 10443					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-29
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0230

 10444
 10445					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10446					;A WORD OF ALL ZEROS IS ADDED TO AN
 10447					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10448					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10449					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10450					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10451					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10452					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10453					;EVERY BIT OF THE AC.
 10454					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10455			011035		SN=SN+1
 10456		002000	000000			ZZ=ZZ+ZZ
 10457						IFE	ZZ,<ZZ=1>
 10458	035422	200 00 0 00 070320 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10459	035423	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10460	035424	444 00 0 00 070320 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10461	035425	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10462	035426	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10463						STOP^
 10464	035427	254 04 0 00 035430 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10465	035430	324 00 0 00 035431 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10466									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10467									;IN THE SUBTEST) TO LOOP ON ERROR^
 10468
 10469					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10470					;IR ADDX [IR1], IR ADSUB [IR1]
 10471
 10472					;**********
 10473					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-30
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0231

 10474
 10475					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10476					;A WORD OF ALL ZEROS IS ADDED TO AN
 10477					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10478					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10479					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10480					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10481					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10482					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10483					;EVERY BIT OF THE AC.
 10484					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10485			011036		SN=SN+1
 10486		004000	000000			ZZ=ZZ+ZZ
 10487						IFE	ZZ,<ZZ=1>
 10488	035431	200 00 0 00 070321 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10489	035432	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10490	035433	444 00 0 00 070321 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10491	035434	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10492	035435	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10493						STOP^
 10494	035436	254 04 0 00 035437 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10495	035437	324 00 0 00 035440 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10496									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10497									;IN THE SUBTEST) TO LOOP ON ERROR^
 10498
 10499					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10500					;IR ADDX [IR1], IR ADSUB [IR1]
 10501
 10502					;**********
 10503					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-31
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0232

 10504
 10505					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10506					;A WORD OF ALL ZEROS IS ADDED TO AN
 10507					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10508					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10509					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10510					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10511					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10512					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10513					;EVERY BIT OF THE AC.
 10514					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10515			011037		SN=SN+1
 10516		010000	000000			ZZ=ZZ+ZZ
 10517						IFE	ZZ,<ZZ=1>
 10518	035440	200 00 0 00 070322 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10519	035441	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10520	035442	444 00 0 00 070322 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10521	035443	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10522	035444	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10523						STOP^
 10524	035445	254 04 0 00 035446 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10525	035446	324 00 0 00 035447 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10526									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10527									;IN THE SUBTEST) TO LOOP ON ERROR^
 10528
 10529					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10530					;IR ADDX [IR1], IR ADSUB [IR1]
 10531
 10532					;**********
 10533					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-32
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0233

 10534
 10535					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10536					;A WORD OF ALL ZEROS IS ADDED TO AN
 10537					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10538					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10539					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10540					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10541					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10542					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10543					;EVERY BIT OF THE AC.
 10544					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10545			011040		SN=SN+1
 10546		020000	000000			ZZ=ZZ+ZZ
 10547						IFE	ZZ,<ZZ=1>
 10548	035447	200 00 0 00 070323 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10549	035450	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10550	035451	444 00 0 00 070323 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10551	035452	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10552	035453	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10553						STOP^
 10554	035454	254 04 0 00 035455 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10555	035455	324 00 0 00 035456 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10556									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10557									;IN THE SUBTEST) TO LOOP ON ERROR^
 10558
 10559					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10560					;IR ADDX [IR1], IR ADSUB [IR1]
 10561
 10562					;**********
 10563					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-33
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0234

 10564
 10565					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10566					;A WORD OF ALL ZEROS IS ADDED TO AN
 10567					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10568					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10569					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10570					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10571					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10572					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10573					;EVERY BIT OF THE AC.
 10574					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10575			011041		SN=SN+1
 10576		040000	000000			ZZ=ZZ+ZZ
 10577						IFE	ZZ,<ZZ=1>
 10578	035456	200 00 0 00 070324 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10579	035457	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10580	035460	444 00 0 00 070324 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10581	035461	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10582	035462	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10583						STOP^
 10584	035463	254 04 0 00 035464 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10585	035464	324 00 0 00 035465 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10586									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10587									;IN THE SUBTEST) TO LOOP ON ERROR^
 10588
 10589					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10590					;IR ADDX [IR1], IR ADSUB [IR1]
 10591
 10592					;**********
 10593					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-34
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0235

 10594
 10595					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10596					;A WORD OF ALL ZEROS IS ADDED TO AN
 10597					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10598					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10599					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10600					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10601					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10602					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10603					;EVERY BIT OF THE AC.
 10604					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10605			011042		SN=SN+1
 10606		100000	000000			ZZ=ZZ+ZZ
 10607						IFE	ZZ,<ZZ=1>
 10608	035465	200 00 0 00 070325 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10609	035466	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10610	035467	444 00 0 00 070325 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10611	035470	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10612	035471	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10613						STOP^
 10614	035472	254 04 0 00 035473 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10615	035473	324 00 0 00 035474 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10616									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10617									;IN THE SUBTEST) TO LOOP ON ERROR^
 10618
 10619					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10620					;IR ADDX [IR1], IR ADSUB [IR1]
 10621
 10622					;**********
 10623					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-35
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0236

 10624
 10625					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10626					;A WORD OF ALL ZEROS IS ADDED TO AN
 10627					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10628					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10629					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10630					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10631					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10632					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10633					;EVERY BIT OF THE AC.
 10634					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10635			011043		SN=SN+1
 10636		200000	000000			ZZ=ZZ+ZZ
 10637						IFE	ZZ,<ZZ=1>
 10638	035474	200 00 0 00 070326 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10639	035475	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10640	035476	444 00 0 00 070326 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10641	035477	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10642	035500	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10643						STOP^
 10644	035501	254 04 0 00 035502 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10645	035502	324 00 0 00 035503 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10646									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10647									;IN THE SUBTEST) TO LOOP ON ERROR^
 10648
 10649					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10650					;IR ADDX [IR1], IR ADSUB [IR1]
 10651
 10652					;**********
 10653					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-36
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0237

 10654
 10655					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10656					;A WORD OF ALL ZEROS IS ADDED TO AN
 10657					;AC CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10658					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS IN IT ORIGINALLY.
 10659					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10660					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10661					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10662					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10663					;EVERY BIT OF THE AC.
 10664					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10665			011044		SN=SN+1
 10666		400000	000000			ZZ=ZZ+ZZ
 10667						IFE	ZZ,<ZZ=1>
 10668	035503	200 00 0 00 070256 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 10669	035504	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO FLOATING ONE
 10670	035505	444 00 0 00 070256 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10671	035506	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10672	035507	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10673						STOP^
 10674	035510	254 04 0 00 035511 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10675	035511	324 00 0 00 035512 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10676									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10677									;IN THE SUBTEST) TO LOOP ON ERROR^
 10678
 10679					;ADDX; AD AR + EN [ADAP], F CYC ACT EN A[F1],
 10680					;IR ADDX [IR1], IR ADSUB [IR1]
 10681
 10682					;**********
 10683					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 4-37
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0238

 10684
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0239

 10685					;THIS TEST VERIFIES THAT THE ADDITION OF A WORD OF 
 10686					;ALL ZEROS TO AN AC OF ALL ZEROS RESULTS IN
 10687					;C(AC)=0. FIRST THE AC IS CLEARED; THEN, A WORD
 10688					;OF ALL ZEROS IS ADDED TO THE AC. THE RESULT IN
 10689					;THE AC IS THEN CHECKED TO INSURE THAT C(AC)=0
 10690
 10691	035512	200 00 0 00 070253 	A11100:	MOVE	[0]		;PRESET AC TO ZERO
 10692	035513	270 00 0 00 070253 		ADD	[0]		;*ADD OF ZERO TO ZERO SHOULD RESULT IN C(AC)=0
 10693	035514	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10694						STOP^
 10695	035515	254 04 0 00 035516 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10696	035516	324 00 0 00 035517 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10697									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10698									;IN THE SUBTEST) TO LOOP ON ERROR^
 10699
 10700					;FCE[F1], IR AD SUB [IR1]
 10701					;AD FM + EN [ADFP], AD FM + EN A [ADFP],
 10702					;F CYC ACT EN C[F1], IR ADSUB [IR1]
 10703
 10704					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0240

 10705					;ADD ZERO TO A RIPPLED ONE
 10706
 10707			013200		SN=13200
 10708			000000			ZZ=0
 10709
 10710					A13200:	REPEAT	^D36,
 10711					<;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10712					;TO AN AC  OF ALL ZEROS IS ADDED A
 10713					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10714					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10715					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10716					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10717					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10718					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10719					;EVERY BIT OF THE AC.
 10720					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10721					SN=SN+1
 10722						ZZ=ZZ+ZZ
 10723						IFE	ZZ,<ZZ=1>
 10724						MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10725						ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10726						EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10727						EQV	[0]		;RESULTS IN C(AC)=0
 10728						SKIPE			;PASS TEST IF C(AC)=0
 10729						STOP
 10730					
 10731					;**********
 10732					>
 10733					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10734					;TO AN AC  OF ALL ZEROS IS ADDED A
 10735					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10736					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10737					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10738					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10739					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10740					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10741					;EVERY BIT OF THE AC.
 10742					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10743			013201		SN=SN+1
 10744			000000			ZZ=ZZ+ZZ
 10745			000001			IFE	ZZ,<ZZ=1>
 10746	035517	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10747	035520	270 00 0 00 070265 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10748	035521	444 00 0 00 070265 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10749	035522	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10750	035523	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10751						STOP^
 10752	035524	254 04 0 00 035525 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10753	035525	324 00 0 00 035526 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10754									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10755									;IN THE SUBTEST) TO LOOP ON ERROR^
 10756
 10757					;**********
 10758
 10759					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0241

 10760					;TO AN AC  OF ALL ZEROS IS ADDED A
 10761					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10762					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10763					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10764					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10765					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10766					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10767					;EVERY BIT OF THE AC.
 10768					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10769			013202		SN=SN+1
 10770			000002			ZZ=ZZ+ZZ
 10771						IFE	ZZ,<ZZ=1>
 10772	035526	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10773	035527	270 00 0 00 070266 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10774	035530	444 00 0 00 070266 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10775	035531	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10776	035532	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10777						STOP^
 10778	035533	254 04 0 00 035534 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10779	035534	324 00 0 00 035535 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10780									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10781									;IN THE SUBTEST) TO LOOP ON ERROR^
 10782
 10783					;**********
 10784
 10785					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10786					;TO AN AC  OF ALL ZEROS IS ADDED A
 10787					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10788					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10789					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10790					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10791					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10792					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10793					;EVERY BIT OF THE AC.
 10794					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10795			013203		SN=SN+1
 10796			000004			ZZ=ZZ+ZZ
 10797						IFE	ZZ,<ZZ=1>
 10798	035535	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10799	035536	270 00 0 00 070267 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10800	035537	444 00 0 00 070267 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10801	035540	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10802	035541	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10803						STOP^
 10804	035542	254 04 0 00 035543 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10805	035543	324 00 0 00 035544 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10806									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10807									;IN THE SUBTEST) TO LOOP ON ERROR^
 10808
 10809					;**********
 10810
 10811					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10812					;TO AN AC  OF ALL ZEROS IS ADDED A
 10813					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10814					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0242

 10815					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10816					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10817					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10818					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10819					;EVERY BIT OF THE AC.
 10820					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10821			013204		SN=SN+1
 10822			000010			ZZ=ZZ+ZZ
 10823						IFE	ZZ,<ZZ=1>
 10824	035544	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10825	035545	270 00 0 00 070270 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10826	035546	444 00 0 00 070270 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10827	035547	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10828	035550	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10829						STOP^
 10830	035551	254 04 0 00 035552 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10831	035552	324 00 0 00 035553 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10832									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10833									;IN THE SUBTEST) TO LOOP ON ERROR^
 10834
 10835					;**********
 10836
 10837					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10838					;TO AN AC  OF ALL ZEROS IS ADDED A
 10839					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10840					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10841					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10842					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10843					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10844					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10845					;EVERY BIT OF THE AC.
 10846					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10847			013205		SN=SN+1
 10848			000020			ZZ=ZZ+ZZ
 10849						IFE	ZZ,<ZZ=1>
 10850	035553	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10851	035554	270 00 0 00 070271 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10852	035555	444 00 0 00 070271 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10853	035556	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10854	035557	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10855						STOP^
 10856	035560	254 04 0 00 035561 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10857	035561	324 00 0 00 035562 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10858									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10859									;IN THE SUBTEST) TO LOOP ON ERROR^
 10860
 10861					;**********
 10862
 10863					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10864					;TO AN AC  OF ALL ZEROS IS ADDED A
 10865					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10866					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10867					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10868					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10869					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0243

 10870					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10871					;EVERY BIT OF THE AC.
 10872					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10873			013206		SN=SN+1
 10874			000040			ZZ=ZZ+ZZ
 10875						IFE	ZZ,<ZZ=1>
 10876	035562	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10877	035563	270 00 0 00 070272 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10878	035564	444 00 0 00 070272 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10879	035565	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10880	035566	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10881						STOP^
 10882	035567	254 04 0 00 035570 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10883	035570	324 00 0 00 035571 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10884									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10885									;IN THE SUBTEST) TO LOOP ON ERROR^
 10886
 10887					;**********
 10888
 10889					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10890					;TO AN AC  OF ALL ZEROS IS ADDED A
 10891					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10892					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10893					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10894					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10895					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10896					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10897					;EVERY BIT OF THE AC.
 10898					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10899			013207		SN=SN+1
 10900			000100			ZZ=ZZ+ZZ
 10901						IFE	ZZ,<ZZ=1>
 10902	035571	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10903	035572	270 00 0 00 070273 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10904	035573	444 00 0 00 070273 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10905	035574	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10906	035575	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10907						STOP^
 10908	035576	254 04 0 00 035577 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10909	035577	324 00 0 00 035600 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10910									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10911									;IN THE SUBTEST) TO LOOP ON ERROR^
 10912
 10913					;**********
 10914
 10915					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10916					;TO AN AC  OF ALL ZEROS IS ADDED A
 10917					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10918					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10919					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10920					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10921					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10922					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10923					;EVERY BIT OF THE AC.
 10924					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0244

 10925			013210		SN=SN+1
 10926			000200			ZZ=ZZ+ZZ
 10927						IFE	ZZ,<ZZ=1>
 10928	035600	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10929	035601	270 00 0 00 070274 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10930	035602	444 00 0 00 070274 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10931	035603	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10932	035604	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10933						STOP^
 10934	035605	254 04 0 00 035606 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10935	035606	324 00 0 00 035607 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10936									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10937									;IN THE SUBTEST) TO LOOP ON ERROR^
 10938
 10939					;**********
 10940
 10941					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10942					;TO AN AC  OF ALL ZEROS IS ADDED A
 10943					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10944					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10945					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10946					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10947					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10948					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10949					;EVERY BIT OF THE AC.
 10950					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10951			013211		SN=SN+1
 10952			000400			ZZ=ZZ+ZZ
 10953						IFE	ZZ,<ZZ=1>
 10954	035607	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10955	035610	270 00 0 00 070275 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10956	035611	444 00 0 00 070275 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10957	035612	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10958	035613	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10959						STOP^
 10960	035614	254 04 0 00 035615 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10961	035615	324 00 0 00 035616 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10962									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10963									;IN THE SUBTEST) TO LOOP ON ERROR^
 10964
 10965					;**********
 10966
 10967					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10968					;TO AN AC  OF ALL ZEROS IS ADDED A
 10969					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10970					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10971					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10972					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10973					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 10974					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 10975					;EVERY BIT OF THE AC.
 10976					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 10977			013212		SN=SN+1
 10978			001000			ZZ=ZZ+ZZ
 10979						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0245

 10980	035616	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 10981	035617	270 00 0 00 070276 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 10982	035620	444 00 0 00 070276 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 10983	035621	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 10984	035622	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 10985						STOP^
 10986	035623	254 04 0 00 035624 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 10987	035624	324 00 0 00 035625 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 10988									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 10989									;IN THE SUBTEST) TO LOOP ON ERROR^
 10990
 10991					;**********
 10992
 10993					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 10994					;TO AN AC  OF ALL ZEROS IS ADDED A
 10995					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 10996					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 10997					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 10998					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 10999					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11000					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11001					;EVERY BIT OF THE AC.
 11002					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11003			013213		SN=SN+1
 11004			002000			ZZ=ZZ+ZZ
 11005						IFE	ZZ,<ZZ=1>
 11006	035625	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11007	035626	270 00 0 00 070277 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11008	035627	444 00 0 00 070277 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11009	035630	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11010	035631	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11011						STOP^
 11012	035632	254 04 0 00 035633 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11013	035633	324 00 0 00 035634 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11014									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11015									;IN THE SUBTEST) TO LOOP ON ERROR^
 11016
 11017					;**********
 11018
 11019					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11020					;TO AN AC  OF ALL ZEROS IS ADDED A
 11021					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11022					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11023					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11024					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11025					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11026					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11027					;EVERY BIT OF THE AC.
 11028					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11029			013214		SN=SN+1
 11030			004000			ZZ=ZZ+ZZ
 11031						IFE	ZZ,<ZZ=1>
 11032	035634	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11033	035635	270 00 0 00 070300 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11034	035636	444 00 0 00 070300 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0246

 11035	035637	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11036	035640	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11037						STOP^
 11038	035641	254 04 0 00 035642 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11039	035642	324 00 0 00 035643 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11040									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11041									;IN THE SUBTEST) TO LOOP ON ERROR^
 11042
 11043					;**********
 11044
 11045					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11046					;TO AN AC  OF ALL ZEROS IS ADDED A
 11047					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11048					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11049					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11050					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11051					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11052					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11053					;EVERY BIT OF THE AC.
 11054					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11055			013215		SN=SN+1
 11056			010000			ZZ=ZZ+ZZ
 11057						IFE	ZZ,<ZZ=1>
 11058	035643	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11059	035644	270 00 0 00 070301 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11060	035645	444 00 0 00 070301 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11061	035646	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11062	035647	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11063						STOP^
 11064	035650	254 04 0 00 035651 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11065	035651	324 00 0 00 035652 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11066									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11067									;IN THE SUBTEST) TO LOOP ON ERROR^
 11068
 11069					;**********
 11070
 11071					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11072					;TO AN AC  OF ALL ZEROS IS ADDED A
 11073					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11074					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11075					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11076					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11077					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11078					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11079					;EVERY BIT OF THE AC.
 11080					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11081			013216		SN=SN+1
 11082			020000			ZZ=ZZ+ZZ
 11083						IFE	ZZ,<ZZ=1>
 11084	035652	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11085	035653	270 00 0 00 070302 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11086	035654	444 00 0 00 070302 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11087	035655	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11088	035656	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11089						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0247

 11090	035657	254 04 0 00 035660 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11091	035660	324 00 0 00 035661 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11092									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11093									;IN THE SUBTEST) TO LOOP ON ERROR^
 11094
 11095					;**********
 11096
 11097					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11098					;TO AN AC  OF ALL ZEROS IS ADDED A
 11099					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11100					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11101					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11102					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11103					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11104					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11105					;EVERY BIT OF THE AC.
 11106					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11107			013217		SN=SN+1
 11108			040000			ZZ=ZZ+ZZ
 11109						IFE	ZZ,<ZZ=1>
 11110	035661	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11111	035662	270 00 0 00 070303 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11112	035663	444 00 0 00 070303 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11113	035664	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11114	035665	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11115						STOP^
 11116	035666	254 04 0 00 035667 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11117	035667	324 00 0 00 035670 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11118									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11119									;IN THE SUBTEST) TO LOOP ON ERROR^
 11120
 11121					;**********
 11122
 11123					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11124					;TO AN AC  OF ALL ZEROS IS ADDED A
 11125					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11126					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11127					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11128					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11129					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11130					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11131					;EVERY BIT OF THE AC.
 11132					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11133			013220		SN=SN+1
 11134			100000			ZZ=ZZ+ZZ
 11135						IFE	ZZ,<ZZ=1>
 11136	035670	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11137	035671	270 00 0 00 070304 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11138	035672	444 00 0 00 070304 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11139	035673	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11140	035674	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11141						STOP^
 11142	035675	254 04 0 00 035676 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11143	035676	324 00 0 00 035677 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11144									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0248

 11145									;IN THE SUBTEST) TO LOOP ON ERROR^
 11146
 11147					;**********
 11148
 11149					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11150					;TO AN AC  OF ALL ZEROS IS ADDED A
 11151					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11152					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11153					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11154					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11155					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11156					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11157					;EVERY BIT OF THE AC.
 11158					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11159			013221		SN=SN+1
 11160			200000			ZZ=ZZ+ZZ
 11161						IFE	ZZ,<ZZ=1>
 11162	035677	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11163	035700	270 00 0 00 070305 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11164	035701	444 00 0 00 070305 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11165	035702	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11166	035703	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11167						STOP^
 11168	035704	254 04 0 00 035705 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11169	035705	324 00 0 00 035706 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11170									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11171									;IN THE SUBTEST) TO LOOP ON ERROR^
 11172
 11173					;**********
 11174
 11175					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11176					;TO AN AC  OF ALL ZEROS IS ADDED A
 11177					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11178					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11179					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11180					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11181					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11182					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11183					;EVERY BIT OF THE AC.
 11184					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11185			013222		SN=SN+1
 11186			400000			ZZ=ZZ+ZZ
 11187						IFE	ZZ,<ZZ=1>
 11188	035706	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11189	035707	270 00 0 00 070306 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11190	035710	444 00 0 00 070306 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11191	035711	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11192	035712	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11193						STOP^
 11194	035713	254 04 0 00 035714 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11195	035714	324 00 0 00 035715 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11196									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11197									;IN THE SUBTEST) TO LOOP ON ERROR^
 11198
 11199					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0249

 11200
 11201					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11202					;TO AN AC  OF ALL ZEROS IS ADDED A
 11203					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11204					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11205					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11206					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11207					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11208					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11209					;EVERY BIT OF THE AC.
 11210					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11211			013223		SN=SN+1
 11212		000001	000000			ZZ=ZZ+ZZ
 11213						IFE	ZZ,<ZZ=1>
 11214	035715	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11215	035716	270 00 0 00 070307 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11216	035717	444 00 0 00 070307 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11217	035720	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11218	035721	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11219						STOP^
 11220	035722	254 04 0 00 035723 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11221	035723	324 00 0 00 035724 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11222									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11223									;IN THE SUBTEST) TO LOOP ON ERROR^
 11224
 11225					;**********
 11226
 11227					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11228					;TO AN AC  OF ALL ZEROS IS ADDED A
 11229					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11230					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11231					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11232					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11233					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11234					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11235					;EVERY BIT OF THE AC.
 11236					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11237			013224		SN=SN+1
 11238		000002	000000			ZZ=ZZ+ZZ
 11239						IFE	ZZ,<ZZ=1>
 11240	035724	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11241	035725	270 00 0 00 070310 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11242	035726	444 00 0 00 070310 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11243	035727	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11244	035730	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11245						STOP^
 11246	035731	254 04 0 00 035732 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11247	035732	324 00 0 00 035733 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11248									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11249									;IN THE SUBTEST) TO LOOP ON ERROR^
 11250
 11251					;**********
 11252
 11253					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11254					;TO AN AC  OF ALL ZEROS IS ADDED A
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0250

 11255					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11256					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11257					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11258					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11259					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11260					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11261					;EVERY BIT OF THE AC.
 11262					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11263			013225		SN=SN+1
 11264		000004	000000			ZZ=ZZ+ZZ
 11265						IFE	ZZ,<ZZ=1>
 11266	035733	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11267	035734	270 00 0 00 070311 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11268	035735	444 00 0 00 070311 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11269	035736	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11270	035737	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11271						STOP^
 11272	035740	254 04 0 00 035741 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11273	035741	324 00 0 00 035742 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11274									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11275									;IN THE SUBTEST) TO LOOP ON ERROR^
 11276
 11277					;**********
 11278
 11279					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11280					;TO AN AC  OF ALL ZEROS IS ADDED A
 11281					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11282					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11283					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11284					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11285					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11286					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11287					;EVERY BIT OF THE AC.
 11288					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11289			013226		SN=SN+1
 11290		000010	000000			ZZ=ZZ+ZZ
 11291						IFE	ZZ,<ZZ=1>
 11292	035742	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11293	035743	270 00 0 00 070312 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11294	035744	444 00 0 00 070312 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11295	035745	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11296	035746	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11297						STOP^
 11298	035747	254 04 0 00 035750 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11299	035750	324 00 0 00 035751 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11300									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11301									;IN THE SUBTEST) TO LOOP ON ERROR^
 11302
 11303					;**********
 11304
 11305					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11306					;TO AN AC  OF ALL ZEROS IS ADDED A
 11307					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11308					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11309					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0251

 11310					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11311					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11312					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11313					;EVERY BIT OF THE AC.
 11314					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11315			013227		SN=SN+1
 11316		000020	000000			ZZ=ZZ+ZZ
 11317						IFE	ZZ,<ZZ=1>
 11318	035751	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11319	035752	270 00 0 00 070313 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11320	035753	444 00 0 00 070313 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11321	035754	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11322	035755	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11323						STOP^
 11324	035756	254 04 0 00 035757 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11325	035757	324 00 0 00 035760 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11326									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11327									;IN THE SUBTEST) TO LOOP ON ERROR^
 11328
 11329					;**********
 11330
 11331					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11332					;TO AN AC  OF ALL ZEROS IS ADDED A
 11333					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11334					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11335					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11336					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11337					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11338					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11339					;EVERY BIT OF THE AC.
 11340					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11341			013230		SN=SN+1
 11342		000040	000000			ZZ=ZZ+ZZ
 11343						IFE	ZZ,<ZZ=1>
 11344	035760	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11345	035761	270 00 0 00 070314 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11346	035762	444 00 0 00 070314 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11347	035763	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11348	035764	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11349						STOP^
 11350	035765	254 04 0 00 035766 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11351	035766	324 00 0 00 035767 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11352									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11353									;IN THE SUBTEST) TO LOOP ON ERROR^
 11354
 11355					;**********
 11356
 11357					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11358					;TO AN AC  OF ALL ZEROS IS ADDED A
 11359					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11360					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11361					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11362					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11363					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11364					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0252

 11365					;EVERY BIT OF THE AC.
 11366					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11367			013231		SN=SN+1
 11368		000100	000000			ZZ=ZZ+ZZ
 11369						IFE	ZZ,<ZZ=1>
 11370	035767	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11371	035770	270 00 0 00 070315 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11372	035771	444 00 0 00 070315 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11373	035772	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11374	035773	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11375						STOP^
 11376	035774	254 04 0 00 035775 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11377	035775	324 00 0 00 035776 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11378									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11379									;IN THE SUBTEST) TO LOOP ON ERROR^
 11380
 11381					;**********
 11382
 11383					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11384					;TO AN AC  OF ALL ZEROS IS ADDED A
 11385					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11386					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11387					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11388					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11389					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11390					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11391					;EVERY BIT OF THE AC.
 11392					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11393			013232		SN=SN+1
 11394		000200	000000			ZZ=ZZ+ZZ
 11395						IFE	ZZ,<ZZ=1>
 11396	035776	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11397	035777	270 00 0 00 070316 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11398	036000	444 00 0 00 070316 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11399	036001	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11400	036002	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11401						STOP^
 11402	036003	254 04 0 00 036004 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11403	036004	324 00 0 00 036005 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11404									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11405									;IN THE SUBTEST) TO LOOP ON ERROR^
 11406
 11407					;**********
 11408
 11409					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11410					;TO AN AC  OF ALL ZEROS IS ADDED A
 11411					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11412					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11413					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11414					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11415					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11416					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11417					;EVERY BIT OF THE AC.
 11418					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11419			013233		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-13
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0253

 11420		000400	000000			ZZ=ZZ+ZZ
 11421						IFE	ZZ,<ZZ=1>
 11422	036005	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11423	036006	270 00 0 00 070264 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11424	036007	444 00 0 00 070264 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11425	036010	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11426	036011	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11427						STOP^
 11428	036012	254 04 0 00 036013 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11429	036013	324 00 0 00 036014 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11430									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11431									;IN THE SUBTEST) TO LOOP ON ERROR^
 11432
 11433					;**********
 11434
 11435					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11436					;TO AN AC  OF ALL ZEROS IS ADDED A
 11437					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11438					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11439					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11440					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11441					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11442					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11443					;EVERY BIT OF THE AC.
 11444					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11445			013234		SN=SN+1
 11446		001000	000000			ZZ=ZZ+ZZ
 11447						IFE	ZZ,<ZZ=1>
 11448	036014	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11449	036015	270 00 0 00 070317 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11450	036016	444 00 0 00 070317 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11451	036017	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11452	036020	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11453						STOP^
 11454	036021	254 04 0 00 036022 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11455	036022	324 00 0 00 036023 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11456									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11457									;IN THE SUBTEST) TO LOOP ON ERROR^
 11458
 11459					;**********
 11460
 11461					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11462					;TO AN AC  OF ALL ZEROS IS ADDED A
 11463					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11464					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11465					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11466					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11467					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11468					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11469					;EVERY BIT OF THE AC.
 11470					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11471			013235		SN=SN+1
 11472		002000	000000			ZZ=ZZ+ZZ
 11473						IFE	ZZ,<ZZ=1>
 11474	036023	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-14
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0254

 11475	036024	270 00 0 00 070320 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11476	036025	444 00 0 00 070320 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11477	036026	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11478	036027	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11479						STOP^
 11480	036030	254 04 0 00 036031 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11481	036031	324 00 0 00 036032 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11482									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11483									;IN THE SUBTEST) TO LOOP ON ERROR^
 11484
 11485					;**********
 11486
 11487					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11488					;TO AN AC  OF ALL ZEROS IS ADDED A
 11489					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11490					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11491					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11492					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11493					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11494					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11495					;EVERY BIT OF THE AC.
 11496					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11497			013236		SN=SN+1
 11498		004000	000000			ZZ=ZZ+ZZ
 11499						IFE	ZZ,<ZZ=1>
 11500	036032	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11501	036033	270 00 0 00 070321 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11502	036034	444 00 0 00 070321 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11503	036035	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11504	036036	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11505						STOP^
 11506	036037	254 04 0 00 036040 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11507	036040	324 00 0 00 036041 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11508									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11509									;IN THE SUBTEST) TO LOOP ON ERROR^
 11510
 11511					;**********
 11512
 11513					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11514					;TO AN AC  OF ALL ZEROS IS ADDED A
 11515					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11516					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11517					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11518					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11519					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11520					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11521					;EVERY BIT OF THE AC.
 11522					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11523			013237		SN=SN+1
 11524		010000	000000			ZZ=ZZ+ZZ
 11525						IFE	ZZ,<ZZ=1>
 11526	036041	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11527	036042	270 00 0 00 070322 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11528	036043	444 00 0 00 070322 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11529	036044	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-15
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0255

 11530	036045	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11531						STOP^
 11532	036046	254 04 0 00 036047 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11533	036047	324 00 0 00 036050 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11534									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11535									;IN THE SUBTEST) TO LOOP ON ERROR^
 11536
 11537					;**********
 11538
 11539					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11540					;TO AN AC  OF ALL ZEROS IS ADDED A
 11541					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11542					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11543					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11544					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11545					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11546					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11547					;EVERY BIT OF THE AC.
 11548					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11549			013240		SN=SN+1
 11550		020000	000000			ZZ=ZZ+ZZ
 11551						IFE	ZZ,<ZZ=1>
 11552	036050	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11553	036051	270 00 0 00 070323 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11554	036052	444 00 0 00 070323 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11555	036053	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11556	036054	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11557						STOP^
 11558	036055	254 04 0 00 036056 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11559	036056	324 00 0 00 036057 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11560									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11561									;IN THE SUBTEST) TO LOOP ON ERROR^
 11562
 11563					;**********
 11564
 11565					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11566					;TO AN AC  OF ALL ZEROS IS ADDED A
 11567					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11568					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11569					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11570					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11571					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11572					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11573					;EVERY BIT OF THE AC.
 11574					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11575			013241		SN=SN+1
 11576		040000	000000			ZZ=ZZ+ZZ
 11577						IFE	ZZ,<ZZ=1>
 11578	036057	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11579	036060	270 00 0 00 070324 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11580	036061	444 00 0 00 070324 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11581	036062	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11582	036063	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11583						STOP^
 11584	036064	254 04 0 00 036065 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-16
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0256

 11585	036065	324 00 0 00 036066 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11586									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11587									;IN THE SUBTEST) TO LOOP ON ERROR^
 11588
 11589					;**********
 11590
 11591					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11592					;TO AN AC  OF ALL ZEROS IS ADDED A
 11593					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11594					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11595					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11596					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11597					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11598					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11599					;EVERY BIT OF THE AC.
 11600					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11601			013242		SN=SN+1
 11602		100000	000000			ZZ=ZZ+ZZ
 11603						IFE	ZZ,<ZZ=1>
 11604	036066	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11605	036067	270 00 0 00 070325 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11606	036070	444 00 0 00 070325 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11607	036071	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11608	036072	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11609						STOP^
 11610	036073	254 04 0 00 036074 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11611	036074	324 00 0 00 036075 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11612									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11613									;IN THE SUBTEST) TO LOOP ON ERROR^
 11614
 11615					;**********
 11616
 11617					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11618					;TO AN AC  OF ALL ZEROS IS ADDED A
 11619					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11620					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11621					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11622					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11623					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11624					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11625					;EVERY BIT OF THE AC.
 11626					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11627			013243		SN=SN+1
 11628		200000	000000			ZZ=ZZ+ZZ
 11629						IFE	ZZ,<ZZ=1>
 11630	036075	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11631	036076	270 00 0 00 070326 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11632	036077	444 00 0 00 070326 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11633	036100	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11634	036101	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11635						STOP^
 11636	036102	254 04 0 00 036103 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11637	036103	324 00 0 00 036104 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11638									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11639									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-17
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0257

 11640
 11641					;**********
 11642
 11643					;THIS TEST CHECKS THE 'ADD' INSTRUCTION AND THE ADDER ON A 0NE-BIT-AT-A-TIME BASIS.
 11644					;TO AN AC  OF ALL ZEROS IS ADDED A
 11645					;WORD CONTAINING ALL ZEROS EXCEPT FOR A ONE IN ONE AND ONLY ONE BIT,
 11646					;THE RESULT IS THAT THE AC CONTAINS THE SAME NUMBER WHICH WAS ADDED TO IT.
 11647					;THE AC IS THEN EQUIVALENCED WITH C(E) WHERE C(E)=C(AC).  THIS RESULT SHOULD
 11648					;BE ALL ONES.  NEXT, THE AC IS EQUIVALENCED WITH A WORD OF ALL ZEROS.
 11649					;THE FINAL RESULT SHOULD BE C(AC)=0. THIS
 11650					;TEST IS REPEATED 36 TIMES SO THAT A ONE MAY BE RIPPLED THOUGH
 11651					;EVERY BIT OF THE AC.
 11652					;THE AC IS CHECKED TO INSURE THAT IT CONTAINS ALL ZEROS.
 11653			013244		SN=SN+1
 11654		400000	000000			ZZ=ZZ+ZZ
 11655						IFE	ZZ,<ZZ=1>
 11656	036104	200 00 0 00 070253 		MOVE	[0]		;LOAD AC WITH ALL ZEROS
 11657	036105	270 00 0 00 070256 		ADD	[ZZ]		;*ADD OF FLOATING ONE TO ZERO
 11658	036106	444 00 0 00 070256 		EQV	[ZZ]		;RESULTS IN C(AC)=ALL ONES
 11659	036107	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11660	036110	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11661						STOP^
 11662	036111	254 04 0 00 036112 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11663	036112	324 00 0 00 036113 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11664									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11665									;IN THE SUBTEST) TO LOOP ON ERROR^
 11666
 11667					;**********
 11668
 11669					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-18
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0258

 11670					;ADD A RIPPLED ONE TO A RIPPLED ONE
 11671
 11672			011200		SN=11200
 11673			000000			ZZ=0
 11674
 11675					A11200:	REPEAT	^D35,
 11676					<;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11677					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11678					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11679					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11680					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11681					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11682					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11683					;SO THAT A ONE WILL BE FLOATED THROUGH
 11684					;BITS 1 THRU 35 OF BOTH AC AND E
 11685					SN=SN+1
 11686						ZZ=ZZ+ZZ
 11687						IFE	ZZ,<ZZ=1>
 11688						MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11689						ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11690						EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11691						EQV	[0]		;RESULTS IN C(AC)=0
 11692						SKIPE			;PASS TEST IF C(AC)=0
 11693						STOP
 11694					
 11695					;**********
 11696					>
 11697					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11698					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11699					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11700					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11701					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11702					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11703					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11704					;SO THAT A ONE WILL BE FLOATED THROUGH
 11705					;BITS 1 THRU 35 OF BOTH AC AND E
 11706			011201		SN=SN+1
 11707			000000			ZZ=ZZ+ZZ
 11708			000001			IFE	ZZ,<ZZ=1>
 11709	036113	200 00 0 00 070265 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11710	036114	270 00 0 00 070265 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11711	036115	444 00 0 00 070266 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11712	036116	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11713	036117	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11714						STOP^
 11715	036120	254 04 0 00 036121 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11716	036121	324 00 0 00 036122 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11717									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11718									;IN THE SUBTEST) TO LOOP ON ERROR^
 11719
 11720					;**********
 11721
 11722					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11723					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11724					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-19
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0259

 11725					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11726					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11727					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11728					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11729					;SO THAT A ONE WILL BE FLOATED THROUGH
 11730					;BITS 1 THRU 35 OF BOTH AC AND E
 11731			011202		SN=SN+1
 11732			000002			ZZ=ZZ+ZZ
 11733						IFE	ZZ,<ZZ=1>
 11734	036122	200 00 0 00 070266 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11735	036123	270 00 0 00 070266 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11736	036124	444 00 0 00 070267 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11737	036125	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11738	036126	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11739						STOP^
 11740	036127	254 04 0 00 036130 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11741	036130	324 00 0 00 036131 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11742									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11743									;IN THE SUBTEST) TO LOOP ON ERROR^
 11744
 11745					;**********
 11746
 11747					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11748					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11749					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11750					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11751					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11752					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11753					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11754					;SO THAT A ONE WILL BE FLOATED THROUGH
 11755					;BITS 1 THRU 35 OF BOTH AC AND E
 11756			011203		SN=SN+1
 11757			000004			ZZ=ZZ+ZZ
 11758						IFE	ZZ,<ZZ=1>
 11759	036131	200 00 0 00 070267 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11760	036132	270 00 0 00 070267 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11761	036133	444 00 0 00 070270 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11762	036134	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11763	036135	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11764						STOP^
 11765	036136	254 04 0 00 036137 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11766	036137	324 00 0 00 036140 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11767									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11768									;IN THE SUBTEST) TO LOOP ON ERROR^
 11769
 11770					;**********
 11771
 11772					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11773					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11774					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11775					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11776					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11777					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11778					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11779					;SO THAT A ONE WILL BE FLOATED THROUGH
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-20
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0260

 11780					;BITS 1 THRU 35 OF BOTH AC AND E
 11781			011204		SN=SN+1
 11782			000010			ZZ=ZZ+ZZ
 11783						IFE	ZZ,<ZZ=1>
 11784	036140	200 00 0 00 070270 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11785	036141	270 00 0 00 070270 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11786	036142	444 00 0 00 070271 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11787	036143	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11788	036144	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11789						STOP^
 11790	036145	254 04 0 00 036146 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11791	036146	324 00 0 00 036147 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11792									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11793									;IN THE SUBTEST) TO LOOP ON ERROR^
 11794
 11795					;**********
 11796
 11797					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11798					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11799					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11800					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11801					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11802					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11803					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11804					;SO THAT A ONE WILL BE FLOATED THROUGH
 11805					;BITS 1 THRU 35 OF BOTH AC AND E
 11806			011205		SN=SN+1
 11807			000020			ZZ=ZZ+ZZ
 11808						IFE	ZZ,<ZZ=1>
 11809	036147	200 00 0 00 070271 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11810	036150	270 00 0 00 070271 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11811	036151	444 00 0 00 070272 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11812	036152	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11813	036153	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11814						STOP^
 11815	036154	254 04 0 00 036155 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11816	036155	324 00 0 00 036156 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11817									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11818									;IN THE SUBTEST) TO LOOP ON ERROR^
 11819
 11820					;**********
 11821
 11822					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11823					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11824					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11825					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11826					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11827					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11828					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11829					;SO THAT A ONE WILL BE FLOATED THROUGH
 11830					;BITS 1 THRU 35 OF BOTH AC AND E
 11831			011206		SN=SN+1
 11832			000040			ZZ=ZZ+ZZ
 11833						IFE	ZZ,<ZZ=1>
 11834	036156	200 00 0 00 070272 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-21
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0261

 11835	036157	270 00 0 00 070272 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11836	036160	444 00 0 00 070273 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11837	036161	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11838	036162	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11839						STOP^
 11840	036163	254 04 0 00 036164 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11841	036164	324 00 0 00 036165 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11842									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11843									;IN THE SUBTEST) TO LOOP ON ERROR^
 11844
 11845					;**********
 11846
 11847					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11848					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11849					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11850					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11851					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11852					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11853					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11854					;SO THAT A ONE WILL BE FLOATED THROUGH
 11855					;BITS 1 THRU 35 OF BOTH AC AND E
 11856			011207		SN=SN+1
 11857			000100			ZZ=ZZ+ZZ
 11858						IFE	ZZ,<ZZ=1>
 11859	036165	200 00 0 00 070273 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11860	036166	270 00 0 00 070273 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11861	036167	444 00 0 00 070274 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11862	036170	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11863	036171	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11864						STOP^
 11865	036172	254 04 0 00 036173 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11866	036173	324 00 0 00 036174 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11867									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11868									;IN THE SUBTEST) TO LOOP ON ERROR^
 11869
 11870					;**********
 11871
 11872					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11873					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11874					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11875					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11876					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11877					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11878					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11879					;SO THAT A ONE WILL BE FLOATED THROUGH
 11880					;BITS 1 THRU 35 OF BOTH AC AND E
 11881			011210		SN=SN+1
 11882			000200			ZZ=ZZ+ZZ
 11883						IFE	ZZ,<ZZ=1>
 11884	036174	200 00 0 00 070274 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11885	036175	270 00 0 00 070274 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11886	036176	444 00 0 00 070275 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11887	036177	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11888	036200	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11889						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-22
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0262

 11890	036201	254 04 0 00 036202 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11891	036202	324 00 0 00 036203 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11892									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11893									;IN THE SUBTEST) TO LOOP ON ERROR^
 11894
 11895					;**********
 11896
 11897					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11898					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11899					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11900					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11901					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11902					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11903					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11904					;SO THAT A ONE WILL BE FLOATED THROUGH
 11905					;BITS 1 THRU 35 OF BOTH AC AND E
 11906			011211		SN=SN+1
 11907			000400			ZZ=ZZ+ZZ
 11908						IFE	ZZ,<ZZ=1>
 11909	036203	200 00 0 00 070275 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11910	036204	270 00 0 00 070275 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11911	036205	444 00 0 00 070276 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11912	036206	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11913	036207	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11914						STOP^
 11915	036210	254 04 0 00 036211 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11916	036211	324 00 0 00 036212 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11917									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11918									;IN THE SUBTEST) TO LOOP ON ERROR^
 11919
 11920					;**********
 11921
 11922					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11923					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11924					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11925					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11926					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11927					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11928					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11929					;SO THAT A ONE WILL BE FLOATED THROUGH
 11930					;BITS 1 THRU 35 OF BOTH AC AND E
 11931			011212		SN=SN+1
 11932			001000			ZZ=ZZ+ZZ
 11933						IFE	ZZ,<ZZ=1>
 11934	036212	200 00 0 00 070276 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11935	036213	270 00 0 00 070276 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11936	036214	444 00 0 00 070277 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11937	036215	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11938	036216	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11939						STOP^
 11940	036217	254 04 0 00 036220 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11941	036220	324 00 0 00 036221 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11942									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11943									;IN THE SUBTEST) TO LOOP ON ERROR^
 11944
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-23
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0263

 11945					;**********
 11946
 11947					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11948					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11949					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11950					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11951					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11952					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11953					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11954					;SO THAT A ONE WILL BE FLOATED THROUGH
 11955					;BITS 1 THRU 35 OF BOTH AC AND E
 11956			011213		SN=SN+1
 11957			002000			ZZ=ZZ+ZZ
 11958						IFE	ZZ,<ZZ=1>
 11959	036221	200 00 0 00 070277 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11960	036222	270 00 0 00 070277 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11961	036223	444 00 0 00 070300 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11962	036224	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11963	036225	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11964						STOP^
 11965	036226	254 04 0 00 036227 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11966	036227	324 00 0 00 036230 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11967									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11968									;IN THE SUBTEST) TO LOOP ON ERROR^
 11969
 11970					;**********
 11971
 11972					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11973					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11974					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 11975					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 11976					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 11977					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 11978					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 11979					;SO THAT A ONE WILL BE FLOATED THROUGH
 11980					;BITS 1 THRU 35 OF BOTH AC AND E
 11981			011214		SN=SN+1
 11982			004000			ZZ=ZZ+ZZ
 11983						IFE	ZZ,<ZZ=1>
 11984	036230	200 00 0 00 070300 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 11985	036231	270 00 0 00 070300 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 11986	036232	444 00 0 00 070301 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 11987	036233	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 11988	036234	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 11989						STOP^
 11990	036235	254 04 0 00 036236 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 11991	036236	324 00 0 00 036237 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 11992									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 11993									;IN THE SUBTEST) TO LOOP ON ERROR^
 11994
 11995					;**********
 11996
 11997					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 11998					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 11999					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-24
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0264

 12000					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12001					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12002					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12003					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12004					;SO THAT A ONE WILL BE FLOATED THROUGH
 12005					;BITS 1 THRU 35 OF BOTH AC AND E
 12006			011215		SN=SN+1
 12007			010000			ZZ=ZZ+ZZ
 12008						IFE	ZZ,<ZZ=1>
 12009	036237	200 00 0 00 070301 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12010	036240	270 00 0 00 070301 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12011	036241	444 00 0 00 070302 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12012	036242	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12013	036243	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12014						STOP^
 12015	036244	254 04 0 00 036245 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12016	036245	324 00 0 00 036246 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12017									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12018									;IN THE SUBTEST) TO LOOP ON ERROR^
 12019
 12020					;**********
 12021
 12022					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12023					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12024					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12025					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12026					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12027					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12028					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12029					;SO THAT A ONE WILL BE FLOATED THROUGH
 12030					;BITS 1 THRU 35 OF BOTH AC AND E
 12031			011216		SN=SN+1
 12032			020000			ZZ=ZZ+ZZ
 12033						IFE	ZZ,<ZZ=1>
 12034	036246	200 00 0 00 070302 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12035	036247	270 00 0 00 070302 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12036	036250	444 00 0 00 070303 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12037	036251	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12038	036252	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12039						STOP^
 12040	036253	254 04 0 00 036254 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12041	036254	324 00 0 00 036255 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12042									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12043									;IN THE SUBTEST) TO LOOP ON ERROR^
 12044
 12045					;**********
 12046
 12047					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12048					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12049					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12050					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12051					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12052					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12053					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12054					;SO THAT A ONE WILL BE FLOATED THROUGH
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-25
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0265

 12055					;BITS 1 THRU 35 OF BOTH AC AND E
 12056			011217		SN=SN+1
 12057			040000			ZZ=ZZ+ZZ
 12058						IFE	ZZ,<ZZ=1>
 12059	036255	200 00 0 00 070303 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12060	036256	270 00 0 00 070303 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12061	036257	444 00 0 00 070304 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12062	036260	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12063	036261	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12064						STOP^
 12065	036262	254 04 0 00 036263 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12066	036263	324 00 0 00 036264 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12067									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12068									;IN THE SUBTEST) TO LOOP ON ERROR^
 12069
 12070					;**********
 12071
 12072					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12073					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12074					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12075					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12076					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12077					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12078					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12079					;SO THAT A ONE WILL BE FLOATED THROUGH
 12080					;BITS 1 THRU 35 OF BOTH AC AND E
 12081			011220		SN=SN+1
 12082			100000			ZZ=ZZ+ZZ
 12083						IFE	ZZ,<ZZ=1>
 12084	036264	200 00 0 00 070304 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12085	036265	270 00 0 00 070304 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12086	036266	444 00 0 00 070305 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12087	036267	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12088	036270	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12089						STOP^
 12090	036271	254 04 0 00 036272 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12091	036272	324 00 0 00 036273 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12092									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12093									;IN THE SUBTEST) TO LOOP ON ERROR^
 12094
 12095					;**********
 12096
 12097					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12098					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12099					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12100					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12101					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12102					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12103					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12104					;SO THAT A ONE WILL BE FLOATED THROUGH
 12105					;BITS 1 THRU 35 OF BOTH AC AND E
 12106			011221		SN=SN+1
 12107			200000			ZZ=ZZ+ZZ
 12108						IFE	ZZ,<ZZ=1>
 12109	036273	200 00 0 00 070305 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-26
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0266

 12110	036274	270 00 0 00 070305 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12111	036275	444 00 0 00 070306 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12112	036276	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12113	036277	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12114						STOP^
 12115	036300	254 04 0 00 036301 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12116	036301	324 00 0 00 036302 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12117									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12118									;IN THE SUBTEST) TO LOOP ON ERROR^
 12119
 12120					;**********
 12121
 12122					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12123					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12124					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12125					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12126					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12127					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12128					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12129					;SO THAT A ONE WILL BE FLOATED THROUGH
 12130					;BITS 1 THRU 35 OF BOTH AC AND E
 12131			011222		SN=SN+1
 12132			400000			ZZ=ZZ+ZZ
 12133						IFE	ZZ,<ZZ=1>
 12134	036302	200 00 0 00 070306 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12135	036303	270 00 0 00 070306 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12136	036304	444 00 0 00 070307 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12137	036305	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12138	036306	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12139						STOP^
 12140	036307	254 04 0 00 036310 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12141	036310	324 00 0 00 036311 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12142									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12143									;IN THE SUBTEST) TO LOOP ON ERROR^
 12144
 12145					;**********
 12146
 12147					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12148					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12149					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12150					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12151					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12152					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12153					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12154					;SO THAT A ONE WILL BE FLOATED THROUGH
 12155					;BITS 1 THRU 35 OF BOTH AC AND E
 12156			011223		SN=SN+1
 12157		000001	000000			ZZ=ZZ+ZZ
 12158						IFE	ZZ,<ZZ=1>
 12159	036311	200 00 0 00 070307 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12160	036312	270 00 0 00 070307 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12161	036313	444 00 0 00 070310 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12162	036314	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12163	036315	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12164						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-27
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0267

 12165	036316	254 04 0 00 036317 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12166	036317	324 00 0 00 036320 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12167									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12168									;IN THE SUBTEST) TO LOOP ON ERROR^
 12169
 12170					;**********
 12171
 12172					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12173					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12174					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12175					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12176					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12177					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12178					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12179					;SO THAT A ONE WILL BE FLOATED THROUGH
 12180					;BITS 1 THRU 35 OF BOTH AC AND E
 12181			011224		SN=SN+1
 12182		000002	000000			ZZ=ZZ+ZZ
 12183						IFE	ZZ,<ZZ=1>
 12184	036320	200 00 0 00 070310 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12185	036321	270 00 0 00 070310 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12186	036322	444 00 0 00 070311 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12187	036323	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12188	036324	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12189						STOP^
 12190	036325	254 04 0 00 036326 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12191	036326	324 00 0 00 036327 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12192									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12193									;IN THE SUBTEST) TO LOOP ON ERROR^
 12194
 12195					;**********
 12196
 12197					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12198					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12199					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12200					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12201					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12202					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12203					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12204					;SO THAT A ONE WILL BE FLOATED THROUGH
 12205					;BITS 1 THRU 35 OF BOTH AC AND E
 12206			011225		SN=SN+1
 12207		000004	000000			ZZ=ZZ+ZZ
 12208						IFE	ZZ,<ZZ=1>
 12209	036327	200 00 0 00 070311 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12210	036330	270 00 0 00 070311 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12211	036331	444 00 0 00 070312 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12212	036332	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12213	036333	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12214						STOP^
 12215	036334	254 04 0 00 036335 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12216	036335	324 00 0 00 036336 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12217									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12218									;IN THE SUBTEST) TO LOOP ON ERROR^
 12219
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-28
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0268

 12220					;**********
 12221
 12222					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12223					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12224					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12225					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12226					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12227					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12228					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12229					;SO THAT A ONE WILL BE FLOATED THROUGH
 12230					;BITS 1 THRU 35 OF BOTH AC AND E
 12231			011226		SN=SN+1
 12232		000010	000000			ZZ=ZZ+ZZ
 12233						IFE	ZZ,<ZZ=1>
 12234	036336	200 00 0 00 070312 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12235	036337	270 00 0 00 070312 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12236	036340	444 00 0 00 070313 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12237	036341	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12238	036342	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12239						STOP^
 12240	036343	254 04 0 00 036344 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12241	036344	324 00 0 00 036345 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12242									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12243									;IN THE SUBTEST) TO LOOP ON ERROR^
 12244
 12245					;**********
 12246
 12247					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12248					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12249					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12250					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12251					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12252					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12253					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12254					;SO THAT A ONE WILL BE FLOATED THROUGH
 12255					;BITS 1 THRU 35 OF BOTH AC AND E
 12256			011227		SN=SN+1
 12257		000020	000000			ZZ=ZZ+ZZ
 12258						IFE	ZZ,<ZZ=1>
 12259	036345	200 00 0 00 070313 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12260	036346	270 00 0 00 070313 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12261	036347	444 00 0 00 070314 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12262	036350	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12263	036351	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12264						STOP^
 12265	036352	254 04 0 00 036353 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12266	036353	324 00 0 00 036354 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12267									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12268									;IN THE SUBTEST) TO LOOP ON ERROR^
 12269
 12270					;**********
 12271
 12272					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12273					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12274					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-29
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0269

 12275					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12276					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12277					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12278					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12279					;SO THAT A ONE WILL BE FLOATED THROUGH
 12280					;BITS 1 THRU 35 OF BOTH AC AND E
 12281			011230		SN=SN+1
 12282		000040	000000			ZZ=ZZ+ZZ
 12283						IFE	ZZ,<ZZ=1>
 12284	036354	200 00 0 00 070314 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12285	036355	270 00 0 00 070314 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12286	036356	444 00 0 00 070315 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12287	036357	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12288	036360	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12289						STOP^
 12290	036361	254 04 0 00 036362 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12291	036362	324 00 0 00 036363 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12292									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12293									;IN THE SUBTEST) TO LOOP ON ERROR^
 12294
 12295					;**********
 12296
 12297					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12298					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12299					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12300					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12301					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12302					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12303					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12304					;SO THAT A ONE WILL BE FLOATED THROUGH
 12305					;BITS 1 THRU 35 OF BOTH AC AND E
 12306			011231		SN=SN+1
 12307		000100	000000			ZZ=ZZ+ZZ
 12308						IFE	ZZ,<ZZ=1>
 12309	036363	200 00 0 00 070315 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12310	036364	270 00 0 00 070315 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12311	036365	444 00 0 00 070316 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12312	036366	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12313	036367	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12314						STOP^
 12315	036370	254 04 0 00 036371 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12316	036371	324 00 0 00 036372 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12317									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12318									;IN THE SUBTEST) TO LOOP ON ERROR^
 12319
 12320					;**********
 12321
 12322					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12323					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12324					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12325					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12326					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12327					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12328					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12329					;SO THAT A ONE WILL BE FLOATED THROUGH
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-30
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0270

 12330					;BITS 1 THRU 35 OF BOTH AC AND E
 12331			011232		SN=SN+1
 12332		000200	000000			ZZ=ZZ+ZZ
 12333						IFE	ZZ,<ZZ=1>
 12334	036372	200 00 0 00 070316 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12335	036373	270 00 0 00 070316 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12336	036374	444 00 0 00 070264 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12337	036375	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12338	036376	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12339						STOP^
 12340	036377	254 04 0 00 036400 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12341	036400	324 00 0 00 036401 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12342									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12343									;IN THE SUBTEST) TO LOOP ON ERROR^
 12344
 12345					;**********
 12346
 12347					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12348					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12349					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12350					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12351					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12352					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12353					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12354					;SO THAT A ONE WILL BE FLOATED THROUGH
 12355					;BITS 1 THRU 35 OF BOTH AC AND E
 12356			011233		SN=SN+1
 12357		000400	000000			ZZ=ZZ+ZZ
 12358						IFE	ZZ,<ZZ=1>
 12359	036401	200 00 0 00 070264 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12360	036402	270 00 0 00 070264 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12361	036403	444 00 0 00 070317 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12362	036404	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12363	036405	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12364						STOP^
 12365	036406	254 04 0 00 036407 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12366	036407	324 00 0 00 036410 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12367									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12368									;IN THE SUBTEST) TO LOOP ON ERROR^
 12369
 12370					;**********
 12371
 12372					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12373					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12374					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12375					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12376					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12377					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12378					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12379					;SO THAT A ONE WILL BE FLOATED THROUGH
 12380					;BITS 1 THRU 35 OF BOTH AC AND E
 12381			011234		SN=SN+1
 12382		001000	000000			ZZ=ZZ+ZZ
 12383						IFE	ZZ,<ZZ=1>
 12384	036410	200 00 0 00 070317 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-31
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0271

 12385	036411	270 00 0 00 070317 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12386	036412	444 00 0 00 070320 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12387	036413	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12388	036414	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12389						STOP^
 12390	036415	254 04 0 00 036416 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12391	036416	324 00 0 00 036417 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12392									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12393									;IN THE SUBTEST) TO LOOP ON ERROR^
 12394
 12395					;**********
 12396
 12397					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12398					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12399					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12400					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12401					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12402					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12403					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12404					;SO THAT A ONE WILL BE FLOATED THROUGH
 12405					;BITS 1 THRU 35 OF BOTH AC AND E
 12406			011235		SN=SN+1
 12407		002000	000000			ZZ=ZZ+ZZ
 12408						IFE	ZZ,<ZZ=1>
 12409	036417	200 00 0 00 070320 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12410	036420	270 00 0 00 070320 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12411	036421	444 00 0 00 070321 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12412	036422	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12413	036423	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12414						STOP^
 12415	036424	254 04 0 00 036425 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12416	036425	324 00 0 00 036426 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12417									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12418									;IN THE SUBTEST) TO LOOP ON ERROR^
 12419
 12420					;**********
 12421
 12422					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12423					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12424					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12425					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12426					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12427					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12428					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12429					;SO THAT A ONE WILL BE FLOATED THROUGH
 12430					;BITS 1 THRU 35 OF BOTH AC AND E
 12431			011236		SN=SN+1
 12432		004000	000000			ZZ=ZZ+ZZ
 12433						IFE	ZZ,<ZZ=1>
 12434	036426	200 00 0 00 070321 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12435	036427	270 00 0 00 070321 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12436	036430	444 00 0 00 070322 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12437	036431	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12438	036432	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12439						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-32
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0272

 12440	036433	254 04 0 00 036434 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12441	036434	324 00 0 00 036435 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12442									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12443									;IN THE SUBTEST) TO LOOP ON ERROR^
 12444
 12445					;**********
 12446
 12447					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12448					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12449					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12450					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12451					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12452					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12453					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12454					;SO THAT A ONE WILL BE FLOATED THROUGH
 12455					;BITS 1 THRU 35 OF BOTH AC AND E
 12456			011237		SN=SN+1
 12457		010000	000000			ZZ=ZZ+ZZ
 12458						IFE	ZZ,<ZZ=1>
 12459	036435	200 00 0 00 070322 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12460	036436	270 00 0 00 070322 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12461	036437	444 00 0 00 070323 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12462	036440	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12463	036441	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12464						STOP^
 12465	036442	254 04 0 00 036443 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12466	036443	324 00 0 00 036444 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12467									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12468									;IN THE SUBTEST) TO LOOP ON ERROR^
 12469
 12470					;**********
 12471
 12472					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12473					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12474					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12475					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12476					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12477					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12478					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12479					;SO THAT A ONE WILL BE FLOATED THROUGH
 12480					;BITS 1 THRU 35 OF BOTH AC AND E
 12481			011240		SN=SN+1
 12482		020000	000000			ZZ=ZZ+ZZ
 12483						IFE	ZZ,<ZZ=1>
 12484	036444	200 00 0 00 070323 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12485	036445	270 00 0 00 070323 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12486	036446	444 00 0 00 070324 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12487	036447	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12488	036450	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12489						STOP^
 12490	036451	254 04 0 00 036452 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12491	036452	324 00 0 00 036453 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12492									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12493									;IN THE SUBTEST) TO LOOP ON ERROR^
 12494
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-33
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0273

 12495					;**********
 12496
 12497					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12498					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12499					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12500					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12501					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12502					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12503					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12504					;SO THAT A ONE WILL BE FLOATED THROUGH
 12505					;BITS 1 THRU 35 OF BOTH AC AND E
 12506			011241		SN=SN+1
 12507		040000	000000			ZZ=ZZ+ZZ
 12508						IFE	ZZ,<ZZ=1>
 12509	036453	200 00 0 00 070324 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12510	036454	270 00 0 00 070324 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12511	036455	444 00 0 00 070325 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12512	036456	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12513	036457	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12514						STOP^
 12515	036460	254 04 0 00 036461 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12516	036461	324 00 0 00 036462 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12517									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12518									;IN THE SUBTEST) TO LOOP ON ERROR^
 12519
 12520					;**********
 12521
 12522					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12523					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12524					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
 12525					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12526					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12527					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12528					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12529					;SO THAT A ONE WILL BE FLOATED THROUGH
 12530					;BITS 1 THRU 35 OF BOTH AC AND E
 12531			011242		SN=SN+1
 12532		100000	000000			ZZ=ZZ+ZZ
 12533						IFE	ZZ,<ZZ=1>
 12534	036462	200 00 0 00 070325 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12535	036463	270 00 0 00 070325 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12536	036464	444 00 0 00 070326 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12537	036465	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12538	036466	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12539						STOP^
 12540	036467	254 04 0 00 036470 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12541	036470	324 00 0 00 036471 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12542									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12543									;IN THE SUBTEST) TO LOOP ON ERROR^
 12544
 12545					;**********
 12546
 12547					;THIS TEST VERIFIES THAT THE RESULT OF ADDING C(AC)
 12548					;TO C(E) WHERE AC IS DIFFERENT FROM E BUT C(AC)=
 12549					;C(E)=A ONE IN ONE AND ONLY ONE BIT IS AN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 6-34
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0274

 12550					;AC WHOSE CONTENTS IS NON-ZERO. HENCE, IF A
 12551					;CARRY IS NOT GENERATED IN THE ADDITION PROCESS THE
 12552					;RESULT IN THE AC WILL BE ZERO AND THE TEST
 12553					;WILL FAIL. THIS TEST IS REPEATED 35 TIMES
 12554					;SO THAT A ONE WILL BE FLOATED THROUGH
 12555					;BITS 1 THRU 35 OF BOTH AC AND E
 12556			011243		SN=SN+1
 12557		200000	000000			ZZ=ZZ+ZZ
 12558						IFE	ZZ,<ZZ=1>
 12559	036471	200 00 0 00 070326 		MOVE	[ZZ]		;PRESET AC WITH A FLOATING ONE
 12560	036472	270 00 0 00 070326 		ADD	[ZZ]		;*ADD FLOATING ONE TO SAME SHOULD RESULT IN C(AC) NONZERO
 12561	036473	444 00 0 00 070256 		EQV	[ZZ+ZZ]		;RESULTS IN C(AC)=ALL ONES
 12562	036474	444 00 0 00 070253 		EQV	[0]		;RESULTS IN C(AC)=0
 12563	036475	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12564						STOP^
 12565	036476	254 04 0 00 036477 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12566	036477	324 00 0 00 036500 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12567									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12568									;IN THE SUBTEST) TO LOOP ON ERROR^
 12569
 12570					;**********
 12571
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0275

 12572			011300		SN=11300
 12573			000000			ZZ=0
 12574			000000			YY=0
 12575
 12576					A11300:	REPEAT	^D18,
 12577					<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12578					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12579					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12580					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12581					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12582					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12583					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12584					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12585					;FORMER VALUE PLUS THE CURRENT C(AC)
 12586					SN=SN+1
 12587						YY=YY/2
 12588						ZZ=ZZ+YY
 12589						IFE	YY,<YY=400000>
 12590						IFE	ZZ,<ZZ=400000>
 12591						MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12592						ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12593									;POWER SHOULD RESULT IN C(AC)=0.
 12594						SKIPE			;PASS TEST IF C(AC)=0
 12595						STOP
 12596					
 12597					;**********
 12598					>
 12599					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12600					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12601					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12602					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12603					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12604					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12605					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12606					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12607					;FORMER VALUE PLUS THE CURRENT C(AC)
 12608			011301		SN=SN+1
 12609			000000			YY=YY/2
 12610			000000			ZZ=ZZ+YY
 12611			400000			IFE	YY,<YY=400000>
 12612			400000			IFE	ZZ,<ZZ=400000>
 12613	036500	200 00 0 00 070256 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12614	036501	270 00 0 00 070256 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12615									;POWER SHOULD RESULT IN C(AC)=0.
 12616	036502	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12617						STOP^
 12618	036503	254 04 0 00 036504 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12619	036504	324 00 0 00 036505 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12620									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12621									;IN THE SUBTEST) TO LOOP ON ERROR^
 12622
 12623					;**********
 12624
 12625					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12626					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0276

 12627					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12628					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12629					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12630					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12631					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12632					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12633					;FORMER VALUE PLUS THE CURRENT C(AC)
 12634			011302		SN=SN+1
 12635			200000			YY=YY/2
 12636			600000			ZZ=ZZ+YY
 12637						IFE	YY,<YY=400000>
 12638						IFE	ZZ,<ZZ=400000>
 12639	036505	200 00 0 00 070401 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12640	036506	270 00 0 00 070326 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12641									;POWER SHOULD RESULT IN C(AC)=0.
 12642	036507	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12643						STOP^
 12644	036510	254 04 0 00 036511 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12645	036511	324 00 0 00 036512 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12646									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12647									;IN THE SUBTEST) TO LOOP ON ERROR^
 12648
 12649					;**********
 12650
 12651					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12652					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12653					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12654					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12655					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12656					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12657					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12658					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12659					;FORMER VALUE PLUS THE CURRENT C(AC)
 12660			011303		SN=SN+1
 12661			100000			YY=YY/2
 12662			700000			ZZ=ZZ+YY
 12663						IFE	YY,<YY=400000>
 12664						IFE	ZZ,<ZZ=400000>
 12665	036512	200 00 0 00 070402 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12666	036513	270 00 0 00 070325 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12667									;POWER SHOULD RESULT IN C(AC)=0.
 12668	036514	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12669						STOP^
 12670	036515	254 04 0 00 036516 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12671	036516	324 00 0 00 036517 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12672									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12673									;IN THE SUBTEST) TO LOOP ON ERROR^
 12674
 12675					;**********
 12676
 12677					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12678					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12679					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12680					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12681					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0277

 12682					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12683					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12684					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12685					;FORMER VALUE PLUS THE CURRENT C(AC)
 12686			011304		SN=SN+1
 12687			040000			YY=YY/2
 12688			740000			ZZ=ZZ+YY
 12689						IFE	YY,<YY=400000>
 12690						IFE	ZZ,<ZZ=400000>
 12691	036517	200 00 0 00 070403 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12692	036520	270 00 0 00 070324 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12693									;POWER SHOULD RESULT IN C(AC)=0.
 12694	036521	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12695						STOP^
 12696	036522	254 04 0 00 036523 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12697	036523	324 00 0 00 036524 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12698									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12699									;IN THE SUBTEST) TO LOOP ON ERROR^
 12700
 12701					;**********
 12702
 12703					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12704					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12705					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12706					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12707					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12708					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12709					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12710					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12711					;FORMER VALUE PLUS THE CURRENT C(AC)
 12712			011305		SN=SN+1
 12713			020000			YY=YY/2
 12714			760000			ZZ=ZZ+YY
 12715						IFE	YY,<YY=400000>
 12716						IFE	ZZ,<ZZ=400000>
 12717	036524	200 00 0 00 070404 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12718	036525	270 00 0 00 070323 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12719									;POWER SHOULD RESULT IN C(AC)=0.
 12720	036526	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12721						STOP^
 12722	036527	254 04 0 00 036530 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12723	036530	324 00 0 00 036531 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12724									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12725									;IN THE SUBTEST) TO LOOP ON ERROR^
 12726
 12727					;**********
 12728
 12729					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12730					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12731					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12732					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12733					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12734					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12735					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12736					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0278

 12737					;FORMER VALUE PLUS THE CURRENT C(AC)
 12738			011306		SN=SN+1
 12739			010000			YY=YY/2
 12740			770000			ZZ=ZZ+YY
 12741						IFE	YY,<YY=400000>
 12742						IFE	ZZ,<ZZ=400000>
 12743	036531	200 00 0 00 070405 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12744	036532	270 00 0 00 070322 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12745									;POWER SHOULD RESULT IN C(AC)=0.
 12746	036533	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12747						STOP^
 12748	036534	254 04 0 00 036535 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12749	036535	324 00 0 00 036536 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12750									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12751									;IN THE SUBTEST) TO LOOP ON ERROR^
 12752
 12753					;**********
 12754
 12755					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12756					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12757					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12758					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12759					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12760					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12761					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12762					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12763					;FORMER VALUE PLUS THE CURRENT C(AC)
 12764			011307		SN=SN+1
 12765			004000			YY=YY/2
 12766			774000			ZZ=ZZ+YY
 12767						IFE	YY,<YY=400000>
 12768						IFE	ZZ,<ZZ=400000>
 12769	036536	200 00 0 00 070406 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12770	036537	270 00 0 00 070321 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12771									;POWER SHOULD RESULT IN C(AC)=0.
 12772	036540	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12773						STOP^
 12774	036541	254 04 0 00 036542 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12775	036542	324 00 0 00 036543 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12776									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12777									;IN THE SUBTEST) TO LOOP ON ERROR^
 12778
 12779					;**********
 12780
 12781					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12782					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12783					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12784					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12785					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12786					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12787					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12788					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12789					;FORMER VALUE PLUS THE CURRENT C(AC)
 12790			011310		SN=SN+1
 12791			002000			YY=YY/2
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0279

 12792			776000			ZZ=ZZ+YY
 12793						IFE	YY,<YY=400000>
 12794						IFE	ZZ,<ZZ=400000>
 12795	036543	200 00 0 00 070407 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12796	036544	270 00 0 00 070320 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12797									;POWER SHOULD RESULT IN C(AC)=0.
 12798	036545	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12799						STOP^
 12800	036546	254 04 0 00 036547 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12801	036547	324 00 0 00 036550 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12802									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12803									;IN THE SUBTEST) TO LOOP ON ERROR^
 12804
 12805					;**********
 12806
 12807					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12808					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12809					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12810					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12811					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12812					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12813					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12814					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12815					;FORMER VALUE PLUS THE CURRENT C(AC)
 12816			011311		SN=SN+1
 12817			001000			YY=YY/2
 12818			777000			ZZ=ZZ+YY
 12819						IFE	YY,<YY=400000>
 12820						IFE	ZZ,<ZZ=400000>
 12821	036550	200 00 0 00 070257 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12822	036551	270 00 0 00 070317 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12823									;POWER SHOULD RESULT IN C(AC)=0.
 12824	036552	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12825						STOP^
 12826	036553	254 04 0 00 036554 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12827	036554	324 00 0 00 036555 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12828									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12829									;IN THE SUBTEST) TO LOOP ON ERROR^
 12830
 12831					;**********
 12832
 12833					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12834					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12835					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12836					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12837					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12838					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12839					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12840					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12841					;FORMER VALUE PLUS THE CURRENT C(AC)
 12842			011312		SN=SN+1
 12843			000400			YY=YY/2
 12844			777400			ZZ=ZZ+YY
 12845						IFE	YY,<YY=400000>
 12846						IFE	ZZ,<ZZ=400000>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0280

 12847	036555	200 00 0 00 070410 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12848	036556	270 00 0 00 070264 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12849									;POWER SHOULD RESULT IN C(AC)=0.
 12850	036557	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12851						STOP^
 12852	036560	254 04 0 00 036561 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12853	036561	324 00 0 00 036562 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12854									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12855									;IN THE SUBTEST) TO LOOP ON ERROR^
 12856
 12857					;**********
 12858
 12859					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12860					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12861					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12862					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12863					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12864					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12865					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12866					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12867					;FORMER VALUE PLUS THE CURRENT C(AC)
 12868			011313		SN=SN+1
 12869			000200			YY=YY/2
 12870			777600			ZZ=ZZ+YY
 12871						IFE	YY,<YY=400000>
 12872						IFE	ZZ,<ZZ=400000>
 12873	036562	200 00 0 00 070411 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12874	036563	270 00 0 00 070316 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12875									;POWER SHOULD RESULT IN C(AC)=0.
 12876	036564	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12877						STOP^
 12878	036565	254 04 0 00 036566 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12879	036566	324 00 0 00 036567 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12880									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12881									;IN THE SUBTEST) TO LOOP ON ERROR^
 12882
 12883					;**********
 12884
 12885					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12886					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12887					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12888					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12889					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12890					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12891					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12892					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12893					;FORMER VALUE PLUS THE CURRENT C(AC)
 12894			011314		SN=SN+1
 12895			000100			YY=YY/2
 12896			777700			ZZ=ZZ+YY
 12897						IFE	YY,<YY=400000>
 12898						IFE	ZZ,<ZZ=400000>
 12899	036567	200 00 0 00 070412 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12900	036570	270 00 0 00 070315 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12901									;POWER SHOULD RESULT IN C(AC)=0.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0281

 12902	036571	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12903						STOP^
 12904	036572	254 04 0 00 036573 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12905	036573	324 00 0 00 036574 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12906									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12907									;IN THE SUBTEST) TO LOOP ON ERROR^
 12908
 12909					;**********
 12910
 12911					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12912					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12913					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12914					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12915					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12916					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12917					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12918					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12919					;FORMER VALUE PLUS THE CURRENT C(AC)
 12920			011315		SN=SN+1
 12921			000040			YY=YY/2
 12922			777740			ZZ=ZZ+YY
 12923						IFE	YY,<YY=400000>
 12924						IFE	ZZ,<ZZ=400000>
 12925	036574	200 00 0 00 070413 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12926	036575	270 00 0 00 070314 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12927									;POWER SHOULD RESULT IN C(AC)=0.
 12928	036576	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12929						STOP^
 12930	036577	254 04 0 00 036600 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12931	036600	324 00 0 00 036601 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12932									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12933									;IN THE SUBTEST) TO LOOP ON ERROR^
 12934
 12935					;**********
 12936
 12937					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12938					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12939					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12940					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12941					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12942					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12943					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12944					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12945					;FORMER VALUE PLUS THE CURRENT C(AC)
 12946			011316		SN=SN+1
 12947			000020			YY=YY/2
 12948			777760			ZZ=ZZ+YY
 12949						IFE	YY,<YY=400000>
 12950						IFE	ZZ,<ZZ=400000>
 12951	036601	200 00 0 00 070414 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12952	036602	270 00 0 00 070313 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12953									;POWER SHOULD RESULT IN C(AC)=0.
 12954	036603	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12955						STOP^
 12956	036604	254 04 0 00 036605 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0282

 12957	036605	324 00 0 00 036606 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12958									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12959									;IN THE SUBTEST) TO LOOP ON ERROR^
 12960
 12961					;**********
 12962
 12963					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12964					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12965					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12966					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12967					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12968					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12969					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12970					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12971					;FORMER VALUE PLUS THE CURRENT C(AC)
 12972			011317		SN=SN+1
 12973			000010			YY=YY/2
 12974			777770			ZZ=ZZ+YY
 12975						IFE	YY,<YY=400000>
 12976						IFE	ZZ,<ZZ=400000>
 12977	036606	200 00 0 00 070415 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 12978	036607	270 00 0 00 070312 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 12979									;POWER SHOULD RESULT IN C(AC)=0.
 12980	036610	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 12981						STOP^
 12982	036611	254 04 0 00 036612 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 12983	036612	324 00 0 00 036613 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 12984									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 12985									;IN THE SUBTEST) TO LOOP ON ERROR^
 12986
 12987					;**********
 12988
 12989					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 12990					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 12991					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 12992					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 12993					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 12994					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 12995					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 12996					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 12997					;FORMER VALUE PLUS THE CURRENT C(AC)
 12998			011320		SN=SN+1
 12999			000004			YY=YY/2
 13000			777774			ZZ=ZZ+YY
 13001						IFE	YY,<YY=400000>
 13002						IFE	ZZ,<ZZ=400000>
 13003	036613	200 00 0 00 070416 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13004	036614	270 00 0 00 070311 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13005									;POWER SHOULD RESULT IN C(AC)=0.
 13006	036615	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13007						STOP^
 13008	036616	254 04 0 00 036617 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13009	036617	324 00 0 00 036620 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13010									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13011									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0283

 13012
 13013					;**********
 13014
 13015					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13016					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13017					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13018					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 13019					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13020					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13021					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13022					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 13023					;FORMER VALUE PLUS THE CURRENT C(AC)
 13024			011321		SN=SN+1
 13025			000002			YY=YY/2
 13026			777776			ZZ=ZZ+YY
 13027						IFE	YY,<YY=400000>
 13028						IFE	ZZ,<ZZ=400000>
 13029	036620	200 00 0 00 070417 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13030	036621	270 00 0 00 070310 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13031									;POWER SHOULD RESULT IN C(AC)=0.
 13032	036622	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13033						STOP^
 13034	036623	254 04 0 00 036624 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13035	036624	324 00 0 00 036625 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13036									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13037									;IN THE SUBTEST) TO LOOP ON ERROR^
 13038
 13039					;**********
 13040
 13041					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13042					;36TH POWER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13043					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13044					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHOUT THE
 13045					;ADDER. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13046					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13047					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13048					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MADE EQUAL TO ITS
 13049					;FORMER VALUE PLUS THE CURRENT C(AC)
 13050			011322		SN=SN+1
 13051			000001			YY=YY/2
 13052			777777			ZZ=ZZ+YY
 13053						IFE	YY,<YY=400000>
 13054						IFE	ZZ,<ZZ=400000>
 13055	036625	200 00 0 00 070331 		MOVE	[XWD ZZ,0]	;PRESET AC TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13056	036626	270 00 0 00 070307 		ADD	[XWD YY,0]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13057									;POWER SHOULD RESULT IN C(AC)=0.
 13058	036627	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13059						STOP^
 13060	036630	254 04 0 00 036631 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13061	036631	324 00 0 00 036632 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13062									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13063									;IN THE SUBTEST) TO LOOP ON ERROR^
 13064
 13065					;**********
 13066
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0284

 13067					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0285

 13068			011400		SN=11400
 13069			000000			ZZ=0
 13070			000000			YY=0
 13071
 13072					A11400:	REPEAT	^D18,
 13073					<;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13074					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13075					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13076					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13077					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13078					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13079					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13080					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13081					;FORMER VALUE PLUS THE CURRENT C(AC)
 13082					SN=SN+1
 13083						YY=YY/2
 13084						ZZ=ZZ+YY
 13085						IFE	YY,<YY=400000>
 13086						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13087						MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13088									;POWER SHOULD RESULT IN C(AC)=0.
 13089						ADD	[YY]		;PASS TEST IF C(AC)=0
 13090						SKIPE
 13091						STOP
 13092					
 13093					;**********
 13094					>
 13095					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13096					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13097					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13098					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13099					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13100					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13101					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13102					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13103					;FORMER VALUE PLUS THE CURRENT C(AC)
 13104			011401		SN=SN+1
 13105			000000			YY=YY/2
 13106			000000			ZZ=ZZ+YY
 13107			400000			IFE	YY,<YY=400000>
 13108			400000			IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13109	036632	200 00 0 00 070420 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13110									;POWER SHOULD RESULT IN C(AC)=0.
 13111	036633	270 00 0 00 070306 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13112	036634	332 00 0 00 000000 		SKIPE
 13113						STOP^
 13114	036635	254 04 0 00 036636 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13115	036636	324 00 0 00 036637 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13116									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13117									;IN THE SUBTEST) TO LOOP ON ERROR^
 13118
 13119					;**********
 13120
 13121					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13122					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0286

 13123					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13124					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13125					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13126					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13127					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13128					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13129					;FORMER VALUE PLUS THE CURRENT C(AC)
 13130			011402		SN=SN+1
 13131			200000			YY=YY/2
 13132			600000			ZZ=ZZ+YY
 13133						IFE	YY,<YY=400000>
 13134						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13135	036637	200 00 0 00 070421 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13136									;POWER SHOULD RESULT IN C(AC)=0.
 13137	036640	270 00 0 00 070305 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13138	036641	332 00 0 00 000000 		SKIPE
 13139						STOP^
 13140	036642	254 04 0 00 036643 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13141	036643	324 00 0 00 036644 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13142									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13143									;IN THE SUBTEST) TO LOOP ON ERROR^
 13144
 13145					;**********
 13146
 13147					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13148					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13149					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13150					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13151					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13152					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13153					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13154					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13155					;FORMER VALUE PLUS THE CURRENT C(AC)
 13156			011403		SN=SN+1
 13157			100000			YY=YY/2
 13158			700000			ZZ=ZZ+YY
 13159						IFE	YY,<YY=400000>
 13160						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13161	036644	200 00 0 00 070422 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13162									;POWER SHOULD RESULT IN C(AC)=0.
 13163	036645	270 00 0 00 070304 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13164	036646	332 00 0 00 000000 		SKIPE
 13165						STOP^
 13166	036647	254 04 0 00 036650 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13167	036650	324 00 0 00 036651 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13168									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13169									;IN THE SUBTEST) TO LOOP ON ERROR^
 13170
 13171					;**********
 13172
 13173					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13174					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13175					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13176					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13177					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0287

 13178					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13179					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13180					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13181					;FORMER VALUE PLUS THE CURRENT C(AC)
 13182			011404		SN=SN+1
 13183			040000			YY=YY/2
 13184			740000			ZZ=ZZ+YY
 13185						IFE	YY,<YY=400000>
 13186						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13187	036651	200 00 0 00 070423 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13188									;POWER SHOULD RESULT IN C(AC)=0.
 13189	036652	270 00 0 00 070303 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13190	036653	332 00 0 00 000000 		SKIPE
 13191						STOP^
 13192	036654	254 04 0 00 036655 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13193	036655	324 00 0 00 036656 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13194									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13195									;IN THE SUBTEST) TO LOOP ON ERROR^
 13196
 13197					;**********
 13198
 13199					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13200					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13201					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13202					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13203					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13204					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13205					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13206					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13207					;FORMER VALUE PLUS THE CURRENT C(AC)
 13208			011405		SN=SN+1
 13209			020000			YY=YY/2
 13210			760000			ZZ=ZZ+YY
 13211						IFE	YY,<YY=400000>
 13212						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13213	036656	200 00 0 00 070424 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13214									;POWER SHOULD RESULT IN C(AC)=0.
 13215	036657	270 00 0 00 070302 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13216	036660	332 00 0 00 000000 		SKIPE
 13217						STOP^
 13218	036661	254 04 0 00 036662 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13219	036662	324 00 0 00 036663 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13220									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13221									;IN THE SUBTEST) TO LOOP ON ERROR^
 13222
 13223					;**********
 13224
 13225					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13226					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13227					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13228					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13229					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13230					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13231					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13232					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-13
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0288

 13233					;FORMER VALUE PLUS THE CURRENT C(AC)
 13234			011406		SN=SN+1
 13235			010000			YY=YY/2
 13236			770000			ZZ=ZZ+YY
 13237						IFE	YY,<YY=400000>
 13238						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13239	036663	200 00 0 00 070425 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13240									;POWER SHOULD RESULT IN C(AC)=0.
 13241	036664	270 00 0 00 070301 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13242	036665	332 00 0 00 000000 		SKIPE
 13243						STOP^
 13244	036666	254 04 0 00 036667 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13245	036667	324 00 0 00 036670 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13246									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13247									;IN THE SUBTEST) TO LOOP ON ERROR^
 13248
 13249					;**********
 13250
 13251					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13252					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13253					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13254					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13255					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13256					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13257					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13258					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13259					;FORMER VALUE PLUS THE CURRENT C(AC)
 13260			011407		SN=SN+1
 13261			004000			YY=YY/2
 13262			774000			ZZ=ZZ+YY
 13263						IFE	YY,<YY=400000>
 13264						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13265	036670	200 00 0 00 070426 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13266									;POWER SHOULD RESULT IN C(AC)=0.
 13267	036671	270 00 0 00 070300 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13268	036672	332 00 0 00 000000 		SKIPE
 13269						STOP^
 13270	036673	254 04 0 00 036674 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13271	036674	324 00 0 00 036675 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13272									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13273									;IN THE SUBTEST) TO LOOP ON ERROR^
 13274
 13275					;**********
 13276
 13277					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13278					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13279					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13280					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13281					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13282					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13283					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13284					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13285					;FORMER VALUE PLUS THE CURRENT C(AC)
 13286			011410		SN=SN+1
 13287			002000			YY=YY/2
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-14
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0289

 13288			776000			ZZ=ZZ+YY
 13289						IFE	YY,<YY=400000>
 13290						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13291	036675	200 00 0 00 070427 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13292									;POWER SHOULD RESULT IN C(AC)=0.
 13293	036676	270 00 0 00 070277 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13294	036677	332 00 0 00 000000 		SKIPE
 13295						STOP^
 13296	036700	254 04 0 00 036701 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13297	036701	324 00 0 00 036702 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13298									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13299									;IN THE SUBTEST) TO LOOP ON ERROR^
 13300
 13301					;**********
 13302
 13303					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13304					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13305					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13306					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13307					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13308					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13309					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13310					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13311					;FORMER VALUE PLUS THE CURRENT C(AC)
 13312			011411		SN=SN+1
 13313			001000			YY=YY/2
 13314			777000			ZZ=ZZ+YY
 13315						IFE	YY,<YY=400000>
 13316						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13317	036702	200 00 0 00 070430 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13318									;POWER SHOULD RESULT IN C(AC)=0.
 13319	036703	270 00 0 00 070276 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13320	036704	332 00 0 00 000000 		SKIPE
 13321						STOP^
 13322	036705	254 04 0 00 036706 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13323	036706	324 00 0 00 036707 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13324									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13325									;IN THE SUBTEST) TO LOOP ON ERROR^
 13326
 13327					;**********
 13328
 13329					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13330					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13331					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13332					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13333					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13334					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13335					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13336					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13337					;FORMER VALUE PLUS THE CURRENT C(AC)
 13338			011412		SN=SN+1
 13339			000400			YY=YY/2
 13340			777400			ZZ=ZZ+YY
 13341						IFE	YY,<YY=400000>
 13342						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-15
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0290

 13343	036707	200 00 0 00 070431 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13344									;POWER SHOULD RESULT IN C(AC)=0.
 13345	036710	270 00 0 00 070275 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13346	036711	332 00 0 00 000000 		SKIPE
 13347						STOP^
 13348	036712	254 04 0 00 036713 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13349	036713	324 00 0 00 036714 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13350									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13351									;IN THE SUBTEST) TO LOOP ON ERROR^
 13352
 13353					;**********
 13354
 13355					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13356					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13357					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13358					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13359					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13360					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13361					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13362					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13363					;FORMER VALUE PLUS THE CURRENT C(AC)
 13364			011413		SN=SN+1
 13365			000200			YY=YY/2
 13366			777600			ZZ=ZZ+YY
 13367						IFE	YY,<YY=400000>
 13368						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13369	036714	200 00 0 00 070432 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13370									;POWER SHOULD RESULT IN C(AC)=0.
 13371	036715	270 00 0 00 070274 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13372	036716	332 00 0 00 000000 		SKIPE
 13373						STOP^
 13374	036717	254 04 0 00 036720 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13375	036720	324 00 0 00 036721 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13376									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13377									;IN THE SUBTEST) TO LOOP ON ERROR^
 13378
 13379					;**********
 13380
 13381					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13382					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13383					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13384					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13385					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13386					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13387					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13388					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13389					;FORMER VALUE PLUS THE CURRENT C(AC)
 13390			011414		SN=SN+1
 13391			000100			YY=YY/2
 13392			777700			ZZ=ZZ+YY
 13393						IFE	YY,<YY=400000>
 13394						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13395	036721	200 00 0 00 070433 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13396									;POWER SHOULD RESULT IN C(AC)=0.
 13397	036722	270 00 0 00 070273 		ADD	[YY]		;PASS TEST IF C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-16
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0291

 13398	036723	332 00 0 00 000000 		SKIPE
 13399						STOP^
 13400	036724	254 04 0 00 036725 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13401	036725	324 00 0 00 036726 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13402									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13403									;IN THE SUBTEST) TO LOOP ON ERROR^
 13404
 13405					;**********
 13406
 13407					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13408					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13409					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13410					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13411					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13412					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13413					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13414					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13415					;FORMER VALUE PLUS THE CURRENT C(AC)
 13416			011415		SN=SN+1
 13417			000040			YY=YY/2
 13418			777740			ZZ=ZZ+YY
 13419						IFE	YY,<YY=400000>
 13420						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13421	036726	200 00 0 00 070434 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13422									;POWER SHOULD RESULT IN C(AC)=0.
 13423	036727	270 00 0 00 070272 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13424	036730	332 00 0 00 000000 		SKIPE
 13425						STOP^
 13426	036731	254 04 0 00 036732 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13427	036732	324 00 0 00 036733 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13428									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13429									;IN THE SUBTEST) TO LOOP ON ERROR^
 13430
 13431					;**********
 13432
 13433					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13434					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13435					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13436					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13437					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13438					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13439					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13440					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13441					;FORMER VALUE PLUS THE CURRENT C(AC)
 13442			011416		SN=SN+1
 13443			000020			YY=YY/2
 13444			777760			ZZ=ZZ+YY
 13445						IFE	YY,<YY=400000>
 13446						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13447	036733	200 00 0 00 070435 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13448									;POWER SHOULD RESULT IN C(AC)=0.
 13449	036734	270 00 0 00 070271 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13450	036735	332 00 0 00 000000 		SKIPE
 13451						STOP^
 13452	036736	254 04 0 00 036737 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-17
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0292

 13453	036737	324 00 0 00 036740 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13454									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13455									;IN THE SUBTEST) TO LOOP ON ERROR^
 13456
 13457					;**********
 13458
 13459					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13460					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13461					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13462					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13463					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13464					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13465					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13466					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13467					;FORMER VALUE PLUS THE CURRENT C(AC)
 13468			011417		SN=SN+1
 13469			000010			YY=YY/2
 13470			777770			ZZ=ZZ+YY
 13471						IFE	YY,<YY=400000>
 13472						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13473	036740	200 00 0 00 070436 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13474									;POWER SHOULD RESULT IN C(AC)=0.
 13475	036741	270 00 0 00 070270 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13476	036742	332 00 0 00 000000 		SKIPE
 13477						STOP^
 13478	036743	254 04 0 00 036744 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13479	036744	324 00 0 00 036745 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13480									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13481									;IN THE SUBTEST) TO LOOP ON ERROR^
 13482
 13483					;**********
 13484
 13485					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13486					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13487					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13488					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13489					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13490					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13491					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13492					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13493					;FORMER VALUE PLUS THE CURRENT C(AC)
 13494			011420		SN=SN+1
 13495			000004			YY=YY/2
 13496			777774			ZZ=ZZ+YY
 13497						IFE	YY,<YY=400000>
 13498						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13499	036745	200 00 0 00 070437 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13500									;POWER SHOULD RESULT IN C(AC)=0.
 13501	036746	270 00 0 00 070267 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13502	036747	332 00 0 00 000000 		SKIPE
 13503						STOP^
 13504	036750	254 04 0 00 036751 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13505	036751	324 00 0 00 036752 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13506									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13507									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 7-18
DFKAA2	MAC	25-AUG-75 13:56		TEST OF THE ADD INSTRUCTION                                                        SEQ 0293

 13508
 13509					;**********
 13510
 13511					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13512					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13513					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13514					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13515					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13516					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13517					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13518					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13519					;FORMER VALUE PLUS THE CURRENT C(AC)
 13520			011421		SN=SN+1
 13521			000002			YY=YY/2
 13522			777776			ZZ=ZZ+YY
 13523						IFE	YY,<YY=400000>
 13524						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13525	036752	200 00 0 00 070333 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13526									;POWER SHOULD RESULT IN C(AC)=0.
 13527	036753	270 00 0 00 070266 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13528	036754	332 00 0 00 000000 		SKIPE
 13529						STOP^
 13530	036755	254 04 0 00 036756 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13531	036756	324 00 0 00 036757 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13532									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13533									;IN THE SUBTEST) TO LOOP ON ERROR^
 13534
 13535					;**********
 13536
 13537					;THIS TEST VERIFIES THAT THE ADDITION OF TWO NUMBERS WHOSE SUM IS 2 RAISED TO THE
 13538					;36TH POSER WILL RESULT IN THE C(AC)=0 SINCE THIS NUMBER IS ONE LARGER
 13539					;THAN THE 36 BIT HARDWARE OF THE PROCESSOR IS DESIGNED TO HANDLE. THIS TEST
 13540					;ALSO VERIFIES CARRY GENERATION AND PROPAGATION THROUGHT THE
 13541					;ADDEC. THIS TEST IS REPEATED 36 TIMES. TESTING BEGINS WITH LOADING THE
 13542					;AC WITH 400000000000 AND ADDING THE SAME NUMBER TO IT; THEN,
 13543					;CHECKING FOR C(AC)=0. IN THE SUBSEQUENT 35 TESTS, THE NUMBER
 13544					;LOADED INTO THE AC IS HALVED EACH TIME AND C(E) IS MODE EQUAL TO ITS
 13545					;FORMER VALUE PLUS THE CURRENT C(AC)
 13546			011422		SN=SN+1
 13547			000001			YY=YY/2
 13548			777777			ZZ=ZZ+YY
 13549						IFE	YY,<YY=400000>
 13550						IFE	ZZ,<ZZ=400000>	;PRESET AB TO A RIPPLED ONE STARTING WITH BIT POSITION 0
 13551	036757	200 00 0 00 070254 		MOVE	[XWD -1,ZZ]	;*ADD OF TWO NUMBERS TOTALING 2 RAISED TO THE 36TH
 13552									;POWER SHOULD RESULT IN C(AC)=0.
 13553	036760	270 00 0 00 070265 		ADD	[YY]		;PASS TEST IF C(AC)=0
 13554	036761	332 00 0 00 000000 		SKIPE
 13555						STOP^
 13556	036762	254 04 0 00 036763 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13557	036763	324 00 0 00 036764 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13558									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13559									;IN THE SUBTEST) TO LOOP ON ERROR^
 13560
 13561					;**********
 13562
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 8
DFKAA2	MAC	25-AUG-75 13:56		SPECIAL KI10 FOUR BIT ADDER TEST                                                   SEQ 0294

 13563					SUBTTL	SPECIAL KI10 FOUR BIT ADDER TEST
 13564
 13565					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13566					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13567					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 33 TO BIT 32.
 13568
 13569	036764	200 00 0 00 070335 	A13500:	MOVE	[-1,,-5]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 33
 13570	036765	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 33 TO BIT 32
 13571	036766	444 00 0 00 070437 		EQV	[-1,,-4]	;RESULT IN AC=ALL ONES
 13572	036767	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13573	036770	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13574						STOP^
 13575	036771	254 04 0 00 036772 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13576	036772	324 00 0 00 036773 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13577									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13578									;IN THE SUBTEST) TO LOOP ON ERROR^
 13579
 13580					;**********
 13581
 13582					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13583					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13584					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 29 TO BIT 28.
 13585
 13586	036773	200 00 0 00 070341 	A13600:	MOVE	[-1,,-101]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 29
 13587	036774	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 29 TO BIT 28
 13588	036775	444 00 0 00 070433 		EQV	[-1,,-100]	;RESULT IN AC=ALL ONES
 13589	036776	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13590	036777	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13591						STOP^
 13592	037000	254 04 0 00 037001 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13593	037001	324 00 0 00 037002 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13594									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13595									;IN THE SUBTEST) TO LOOP ON ERROR^
 13596
 13597					;**********
 13598
 13599					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13600					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13601					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 25 TO BIT 24.
 13602
 13603	037002	200 00 0 00 070345 	A13700:	MOVE	[-1,,-2001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 25
 13604	037003	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 25 TO BIT 24
 13605	037004	444 00 0 00 070427 		EQV	[-1,,-2000]	;RESULT IN AC=ALL ONES
 13606	037005	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13607	037006	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13608						STOP^
 13609	037007	254 04 0 00 037010 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13610	037010	324 00 0 00 037011 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13611									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13612									;IN THE SUBTEST) TO LOOP ON ERROR^
 13613
 13614					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 9
DFKAA2	MAC	25-AUG-75 13:56		SPECIAL KI10 FOUR BIT ADDER TEST                                                   SEQ 0295

 13615					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13616					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13617					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 21 TO BIT 20.
 13618
 13619	037011	200 00 0 00 070351 	A14000:	MOVE	[-1,,-40001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 21
 13620	037012	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 21 TO BIT 20
 13621	037013	444 00 0 00 070423 		EQV	[-1,,-40000]	;RESULT IN AC=ALL ONES
 13622	037014	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13623	037015	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13624						STOP^
 13625	037016	254 04 0 00 037017 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13626	037017	324 00 0 00 037020 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13627									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13628									;IN THE SUBTEST) TO LOOP ON ERROR^
 13629
 13630					;**********
 13631
 13632					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13633					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13634					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 18 TO BIT 17.
 13635
 13636	037020	200 00 0 00 070354 	A14100:	MOVE	[-1,,-400001]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 18
 13637	037021	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 18 TO BIT 17
 13638	037022	444 00 0 00 070420 		EQV	[-1,,400000]	;RESULT IN AC=ALL ONES
 13639	037023	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13640	037024	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13641						STOP^
 13642	037025	254 04 0 00 037026 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13643	037026	324 00 0 00 037027 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13644									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13645									;IN THE SUBTEST) TO LOOP ON ERROR^
 13646
 13647					;**********
 13648
 13649					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13650					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13651					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 14 TO BIT 13.
 13652
 13653	037027	200 00 0 00 070360 	A14200:	MOVE	[-11,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 14
 13654	037030	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 14 TO BIT 13
 13655	037031	444 00 0 00 070415 		EQV	[-10,,0]	;RESULT IN AC=ALL ONES
 13656	037032	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13657	037033	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13658						STOP^
 13659	037034	254 04 0 00 037035 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13660	037035	324 00 0 00 037036 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13661									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13662									;IN THE SUBTEST) TO LOOP ON ERROR^
 13663
 13664					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 10
DFKAA2	MAC	25-AUG-75 13:56		SPECIAL KI10 FOUR BIT ADDER TEST                                                   SEQ 0296

 13665					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13666					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13667					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 10 TO BIT 9.
 13668
 13669	037036	200 00 0 00 070364 	A14300:	MOVE	[-201,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 10
 13670	037037	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 10 TO BIT 9
 13671	037040	444 00 0 00 070411 		EQV	[-200,,0]	;RESULT IN AC=ALL ONES
 13672	037041	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13673	037042	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13674						STOP^
 13675	037043	254 04 0 00 037044 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13676	037044	324 00 0 00 037045 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13677									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13678									;IN THE SUBTEST) TO LOOP ON ERROR^
 13679
 13680					;**********
 13681
 13682					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13683					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13684					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 6 TO BIT 5.
 13685
 13686	037045	200 00 0 00 070370 	A14400:	MOVE	[-4001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 6
 13687	037046	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 6 TO BIT 5
 13688	037047	444 00 0 00 070406 		EQV	[-4000,,0]	;RESULT IN AC=ALL ONES
 13689	037050	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13690	037051	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13691						STOP^
 13692	037052	254 04 0 00 037053 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13693	037053	324 00 0 00 037054 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13694									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13695									;IN THE SUBTEST) TO LOOP ON ERROR^
 13696
 13697					;**********
 13698
 13699					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13700					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13701					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 2 TO BIT 1.
 13702
 13703	037054	200 00 0 00 070374 	A14500:	MOVE	[-100001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 2
 13704	037055	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 2 TO BIT 1
 13705	037056	444 00 0 00 070402 		EQV	[-100000,,0]	;RESULT IN AC=ALL ONES
 13706	037057	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13707	037060	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13708						STOP^
 13709	037061	254 04 0 00 037062 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13710	037062	324 00 0 00 037063 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13711									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13712									;IN THE SUBTEST) TO LOOP ON ERROR^
 13713
 13714					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 11
DFKAA2	MAC	25-AUG-75 13:56		SPECIAL KI10 FOUR BIT ADDER TEST                                                   SEQ 0297

 13715					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13716					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13717					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT 1 TO BIT 0.
 13718
 13719	037063	200 00 0 00 070375 	A14600:	MOVE	[-200001,,-1]	;PRESET AC WITH ALL ONES EXCEPT FOR BIT 1
 13720	037064	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT 1 TO BIT 0
 13721	037065	444 00 0 00 070401 		EQV	[600000,,0]	;RESULT IN AC=ALL ONES
 13722	037066	444 00 0 00 070253 		EQV	[0]		;RESULT IN AC=0
 13723	037067	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13724						STOP^
 13725	037070	254 04 0 00 037071 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13726	037071	324 00 0 00 037072 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13727									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13728									;IN THE SUBTEST) TO LOOP ON ERROR^
 13729
 13730					;**********
 13731
 13732					;THIS TEST CHECKS THE CARRY FUNCTION FROM THE MOST SIGNIFICANT BIT OF A FOUR
 13733					;BIT ADDER TO THE LEAST SIGNIFICANT BIT OF THE NEXT SIGNIFICANT FOUR BIT ADDER.
 13734					;SPECIFICALLY, IT IS VERIFIED THAT AN ILLEGAL CARRY DOES NOT OCCUR FROM BIT -1TO BIT 35.
 13735
 13736	037072	200 00 0 00 070254 	A14700:	MOVE	[-1,,-1]	;PRESET AC WITH ALL ONES
 13737	037073	270 00 0 00 070265 		ADD	[1]		;*ADD SHOULD NOT CAUSE CARRY FROM BIT -1 TO BIT 35
 13738	037074	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13739						STOP^
 13740	037075	254 04 0 00 037076 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13741	037076	324 00 0 00 037077 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13742									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13743									;IN THE SUBTEST) TO LOOP ON ERROR^
 13744
 13745					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0298

 13746					SUBTTL	TEST OF SUB AND COMPARE INSTRUCTIONS
 13747
 13748					;THIS TEST VERIFIES THAT IF A NON ZERO POSITIVE NUMBER IN E IS
 13749					;SUBTRACTED FROM THE AC WHEN C(AC)=0, THE RESULT IN THE AC
 13750					;IS NEGATIVE
 13751
 13752	037077	200 00 0 00 070253 	A11500:	MOVE	[0]		;PRESET AC TO ZERO
 13753	037100	274 00 0 00 070330 		SUB	[XWD 0,-1]	;*SUB OF POSITIVE NONZERO NUMBER FROM AC OF ALL ZEROS
 13754									;SHOULD RESULT IN C(AC) NEGATIVE
 13755	037101	331 00 0 00 000000 		SKIPL			;PASS TEST IF C(AC) IS NEGATIVE
 13756						STOP^
 13757	037102	254 04 0 00 037103 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13758	037103	324 00 0 00 037104 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13759									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13760									;IN THE SUBTEST) TO LOOP ON ERROR^
 13761
 13762					;AD AR- EN D [ADAM], F CYC ACT ENB [F1],
 13763					;IR SUBX[IR1], IR ADSUB[IR1]
 13764
 13765					;**********
 13766
 13767					;THIS TEST VERIFIES THAT IF A WORD OF ALL ZEROS IS
 13768					;SUBTRACTED FROM AN AC OF ALL ZEROS, THE RESULT
 13769					;IS AN AC OF ZEROS.
 13770
 13771	037104	200 00 0 00 070253 	A11600:	MOVE	[0]		;PRESET AC TO ZERO
 13772	037105	274 00 0 00 070253 		SUB	[0]		;*SUB OF 0 FROM 0 SHOULD RESULT IN C(AC)=0
 13773	037106	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13774						STOP^
 13775	037107	254 04 0 00 037110 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13776	037110	324 00 0 00 037111 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13777									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13778									;IN THE SUBTEST) TO LOOP ON ERROR^
 13779					;AD CRY 36[ADCR], F CYC ACT EN D[F1], IF SUBX [IR1]
 13780
 13781					;**********
 13782					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0299

 13783			011700		SN=11700
 13784			000000			ZZ=0
 13785
 13786					A11700:	REPEAT	^D36,
 13787					<;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13788					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13789					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13790					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13791					SN=SN+1
 13792						ZZ=ZZ+ZZ
 13793						IFE	ZZ,<ZZ=1>
 13794						MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13795						SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13796						SKIPE			;PASS TEST IF C(AC)=0
 13797						STOP
 13798					
 13799					;**********
 13800					>
 13801					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13802					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13803					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13804					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13805			011701		SN=SN+1
 13806			000000			ZZ=ZZ+ZZ
 13807			000001			IFE	ZZ,<ZZ=1>
 13808	037111	200 00 0 00 070265 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13809	037112	274 00 0 00 070265 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13810	037113	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13811						STOP^
 13812	037114	254 04 0 00 037115 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13813	037115	324 00 0 00 037116 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13814									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13815									;IN THE SUBTEST) TO LOOP ON ERROR^
 13816
 13817					;**********
 13818
 13819					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13820					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13821					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13822					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13823			011702		SN=SN+1
 13824			000002			ZZ=ZZ+ZZ
 13825						IFE	ZZ,<ZZ=1>
 13826	037116	200 00 0 00 070266 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13827	037117	274 00 0 00 070266 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13828	037120	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13829						STOP^
 13830	037121	254 04 0 00 037122 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13831	037122	324 00 0 00 037123 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13832									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13833									;IN THE SUBTEST) TO LOOP ON ERROR^
 13834
 13835					;**********
 13836
 13837					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0300

 13838					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13839					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13840					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13841			011703		SN=SN+1
 13842			000004			ZZ=ZZ+ZZ
 13843						IFE	ZZ,<ZZ=1>
 13844	037123	200 00 0 00 070267 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13845	037124	274 00 0 00 070267 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13846	037125	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13847						STOP^
 13848	037126	254 04 0 00 037127 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13849	037127	324 00 0 00 037130 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13850									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13851									;IN THE SUBTEST) TO LOOP ON ERROR^
 13852
 13853					;**********
 13854
 13855					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13856					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13857					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13858					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13859			011704		SN=SN+1
 13860			000010			ZZ=ZZ+ZZ
 13861						IFE	ZZ,<ZZ=1>
 13862	037130	200 00 0 00 070270 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13863	037131	274 00 0 00 070270 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13864	037132	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13865						STOP^
 13866	037133	254 04 0 00 037134 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13867	037134	324 00 0 00 037135 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13868									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13869									;IN THE SUBTEST) TO LOOP ON ERROR^
 13870
 13871					;**********
 13872
 13873					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13874					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13875					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13876					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13877			011705		SN=SN+1
 13878			000020			ZZ=ZZ+ZZ
 13879						IFE	ZZ,<ZZ=1>
 13880	037135	200 00 0 00 070271 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13881	037136	274 00 0 00 070271 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13882	037137	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13883						STOP^
 13884	037140	254 04 0 00 037141 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13885	037141	324 00 0 00 037142 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13886									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13887									;IN THE SUBTEST) TO LOOP ON ERROR^
 13888
 13889					;**********
 13890
 13891					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13892					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0301

 13893					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13894					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13895			011706		SN=SN+1
 13896			000040			ZZ=ZZ+ZZ
 13897						IFE	ZZ,<ZZ=1>
 13898	037142	200 00 0 00 070272 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13899	037143	274 00 0 00 070272 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13900	037144	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13901						STOP^
 13902	037145	254 04 0 00 037146 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13903	037146	324 00 0 00 037147 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13904									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13905									;IN THE SUBTEST) TO LOOP ON ERROR^
 13906
 13907					;**********
 13908
 13909					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13910					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13911					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13912					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13913			011707		SN=SN+1
 13914			000100			ZZ=ZZ+ZZ
 13915						IFE	ZZ,<ZZ=1>
 13916	037147	200 00 0 00 070273 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13917	037150	274 00 0 00 070273 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13918	037151	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13919						STOP^
 13920	037152	254 04 0 00 037153 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13921	037153	324 00 0 00 037154 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13922									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13923									;IN THE SUBTEST) TO LOOP ON ERROR^
 13924
 13925					;**********
 13926
 13927					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13928					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13929					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13930					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13931			011710		SN=SN+1
 13932			000200			ZZ=ZZ+ZZ
 13933						IFE	ZZ,<ZZ=1>
 13934	037154	200 00 0 00 070274 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13935	037155	274 00 0 00 070274 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13936	037156	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13937						STOP^
 13938	037157	254 04 0 00 037160 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13939	037160	324 00 0 00 037161 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13940									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13941									;IN THE SUBTEST) TO LOOP ON ERROR^
 13942
 13943					;**********
 13944
 13945					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13946					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13947					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0302

 13948					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13949			011711		SN=SN+1
 13950			000400			ZZ=ZZ+ZZ
 13951						IFE	ZZ,<ZZ=1>
 13952	037161	200 00 0 00 070275 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13953	037162	274 00 0 00 070275 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13954	037163	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13955						STOP^
 13956	037164	254 04 0 00 037165 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13957	037165	324 00 0 00 037166 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13958									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13959									;IN THE SUBTEST) TO LOOP ON ERROR^
 13960
 13961					;**********
 13962
 13963					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13964					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13965					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13966					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13967			011712		SN=SN+1
 13968			001000			ZZ=ZZ+ZZ
 13969						IFE	ZZ,<ZZ=1>
 13970	037166	200 00 0 00 070276 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13971	037167	274 00 0 00 070276 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13972	037170	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13973						STOP^
 13974	037171	254 04 0 00 037172 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13975	037172	324 00 0 00 037173 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13976									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13977									;IN THE SUBTEST) TO LOOP ON ERROR^
 13978
 13979					;**********
 13980
 13981					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 13982					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 13983					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 13984					;TIMES IN ORDER TO TEST ALL 36 BITS.
 13985			011713		SN=SN+1
 13986			002000			ZZ=ZZ+ZZ
 13987						IFE	ZZ,<ZZ=1>
 13988	037173	200 00 0 00 070277 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 13989	037174	274 00 0 00 070277 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 13990	037175	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 13991						STOP^
 13992	037176	254 04 0 00 037177 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 13993	037177	324 00 0 00 037200 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 13994									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 13995									;IN THE SUBTEST) TO LOOP ON ERROR^
 13996
 13997					;**********
 13998
 13999					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14000					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14001					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14002					;TIMES IN ORDER TO TEST ALL 36 BITS.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0303

 14003			011714		SN=SN+1
 14004			004000			ZZ=ZZ+ZZ
 14005						IFE	ZZ,<ZZ=1>
 14006	037200	200 00 0 00 070300 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14007	037201	274 00 0 00 070300 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14008	037202	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14009						STOP^
 14010	037203	254 04 0 00 037204 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14011	037204	324 00 0 00 037205 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14012									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14013									;IN THE SUBTEST) TO LOOP ON ERROR^
 14014
 14015					;**********
 14016
 14017					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14018					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14019					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14020					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14021			011715		SN=SN+1
 14022			010000			ZZ=ZZ+ZZ
 14023						IFE	ZZ,<ZZ=1>
 14024	037205	200 00 0 00 070301 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14025	037206	274 00 0 00 070301 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14026	037207	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14027						STOP^
 14028	037210	254 04 0 00 037211 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14029	037211	324 00 0 00 037212 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14030									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14031									;IN THE SUBTEST) TO LOOP ON ERROR^
 14032
 14033					;**********
 14034
 14035					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14036					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14037					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14038					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14039			011716		SN=SN+1
 14040			020000			ZZ=ZZ+ZZ
 14041						IFE	ZZ,<ZZ=1>
 14042	037212	200 00 0 00 070302 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14043	037213	274 00 0 00 070302 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14044	037214	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14045						STOP^
 14046	037215	254 04 0 00 037216 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14047	037216	324 00 0 00 037217 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14048									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14049									;IN THE SUBTEST) TO LOOP ON ERROR^
 14050
 14051					;**********
 14052
 14053					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14054					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14055					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14056					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14057			011717		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0304

 14058			040000			ZZ=ZZ+ZZ
 14059						IFE	ZZ,<ZZ=1>
 14060	037217	200 00 0 00 070303 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14061	037220	274 00 0 00 070303 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14062	037221	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14063						STOP^
 14064	037222	254 04 0 00 037223 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14065	037223	324 00 0 00 037224 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14066									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14067									;IN THE SUBTEST) TO LOOP ON ERROR^
 14068
 14069					;**********
 14070
 14071					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14072					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14073					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14074					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14075			011720		SN=SN+1
 14076			100000			ZZ=ZZ+ZZ
 14077						IFE	ZZ,<ZZ=1>
 14078	037224	200 00 0 00 070304 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14079	037225	274 00 0 00 070304 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14080	037226	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14081						STOP^
 14082	037227	254 04 0 00 037230 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14083	037230	324 00 0 00 037231 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14084									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14085									;IN THE SUBTEST) TO LOOP ON ERROR^
 14086
 14087					;**********
 14088
 14089					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14090					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14091					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14092					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14093			011721		SN=SN+1
 14094			200000			ZZ=ZZ+ZZ
 14095						IFE	ZZ,<ZZ=1>
 14096	037231	200 00 0 00 070305 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14097	037232	274 00 0 00 070305 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14098	037233	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14099						STOP^
 14100	037234	254 04 0 00 037235 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14101	037235	324 00 0 00 037236 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14102									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14103									;IN THE SUBTEST) TO LOOP ON ERROR^
 14104
 14105					;**********
 14106
 14107					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14108					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14109					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14110					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14111			011722		SN=SN+1
 14112			400000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0305

 14113						IFE	ZZ,<ZZ=1>
 14114	037236	200 00 0 00 070306 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14115	037237	274 00 0 00 070306 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14116	037240	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14117						STOP^
 14118	037241	254 04 0 00 037242 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14119	037242	324 00 0 00 037243 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14120									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14121									;IN THE SUBTEST) TO LOOP ON ERROR^
 14122
 14123					;**********
 14124
 14125					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14126					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14127					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14128					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14129			011723		SN=SN+1
 14130		000001	000000			ZZ=ZZ+ZZ
 14131						IFE	ZZ,<ZZ=1>
 14132	037243	200 00 0 00 070307 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14133	037244	274 00 0 00 070307 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14134	037245	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14135						STOP^
 14136	037246	254 04 0 00 037247 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14137	037247	324 00 0 00 037250 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14138									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14139									;IN THE SUBTEST) TO LOOP ON ERROR^
 14140
 14141					;**********
 14142
 14143					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14144					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14145					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14146					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14147			011724		SN=SN+1
 14148		000002	000000			ZZ=ZZ+ZZ
 14149						IFE	ZZ,<ZZ=1>
 14150	037250	200 00 0 00 070310 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14151	037251	274 00 0 00 070310 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14152	037252	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14153						STOP^
 14154	037253	254 04 0 00 037254 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14155	037254	324 00 0 00 037255 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14156									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14157									;IN THE SUBTEST) TO LOOP ON ERROR^
 14158
 14159					;**********
 14160
 14161					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14162					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14163					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14164					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14165			011725		SN=SN+1
 14166		000004	000000			ZZ=ZZ+ZZ
 14167						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0306

 14168	037255	200 00 0 00 070311 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14169	037256	274 00 0 00 070311 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14170	037257	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14171						STOP^
 14172	037260	254 04 0 00 037261 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14173	037261	324 00 0 00 037262 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14174									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14175									;IN THE SUBTEST) TO LOOP ON ERROR^
 14176
 14177					;**********
 14178
 14179					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14180					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14181					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14182					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14183			011726		SN=SN+1
 14184		000010	000000			ZZ=ZZ+ZZ
 14185						IFE	ZZ,<ZZ=1>
 14186	037262	200 00 0 00 070312 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14187	037263	274 00 0 00 070312 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14188	037264	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14189						STOP^
 14190	037265	254 04 0 00 037266 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14191	037266	324 00 0 00 037267 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14192									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14193									;IN THE SUBTEST) TO LOOP ON ERROR^
 14194
 14195					;**********
 14196
 14197					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14198					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14199					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14200					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14201			011727		SN=SN+1
 14202		000020	000000			ZZ=ZZ+ZZ
 14203						IFE	ZZ,<ZZ=1>
 14204	037267	200 00 0 00 070313 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14205	037270	274 00 0 00 070313 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14206	037271	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14207						STOP^
 14208	037272	254 04 0 00 037273 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14209	037273	324 00 0 00 037274 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14210									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14211									;IN THE SUBTEST) TO LOOP ON ERROR^
 14212
 14213					;**********
 14214
 14215					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14216					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14217					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14218					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14219			011730		SN=SN+1
 14220		000040	000000			ZZ=ZZ+ZZ
 14221						IFE	ZZ,<ZZ=1>
 14222	037274	200 00 0 00 070314 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0307

 14223	037275	274 00 0 00 070314 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14224	037276	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14225						STOP^
 14226	037277	254 04 0 00 037300 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14227	037300	324 00 0 00 037301 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14228									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14229									;IN THE SUBTEST) TO LOOP ON ERROR^
 14230
 14231					;**********
 14232
 14233					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14234					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14235					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14236					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14237			011731		SN=SN+1
 14238		000100	000000			ZZ=ZZ+ZZ
 14239						IFE	ZZ,<ZZ=1>
 14240	037301	200 00 0 00 070315 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14241	037302	274 00 0 00 070315 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14242	037303	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14243						STOP^
 14244	037304	254 04 0 00 037305 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14245	037305	324 00 0 00 037306 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14246									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14247									;IN THE SUBTEST) TO LOOP ON ERROR^
 14248
 14249					;**********
 14250
 14251					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14252					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14253					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14254					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14255			011732		SN=SN+1
 14256		000200	000000			ZZ=ZZ+ZZ
 14257						IFE	ZZ,<ZZ=1>
 14258	037306	200 00 0 00 070316 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14259	037307	274 00 0 00 070316 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14260	037310	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14261						STOP^
 14262	037311	254 04 0 00 037312 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14263	037312	324 00 0 00 037313 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14264									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14265									;IN THE SUBTEST) TO LOOP ON ERROR^
 14266
 14267					;**********
 14268
 14269					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14270					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14271					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14272					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14273			011733		SN=SN+1
 14274		000400	000000			ZZ=ZZ+ZZ
 14275						IFE	ZZ,<ZZ=1>
 14276	037313	200 00 0 00 070264 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14277	037314	274 00 0 00 070264 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0308

 14278	037315	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14279						STOP^
 14280	037316	254 04 0 00 037317 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14281	037317	324 00 0 00 037320 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14282									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14283									;IN THE SUBTEST) TO LOOP ON ERROR^
 14284
 14285					;**********
 14286
 14287					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14288					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14289					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14290					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14291			011734		SN=SN+1
 14292		001000	000000			ZZ=ZZ+ZZ
 14293						IFE	ZZ,<ZZ=1>
 14294	037320	200 00 0 00 070317 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14295	037321	274 00 0 00 070317 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14296	037322	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14297						STOP^
 14298	037323	254 04 0 00 037324 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14299	037324	324 00 0 00 037325 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14300									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14301									;IN THE SUBTEST) TO LOOP ON ERROR^
 14302
 14303					;**********
 14304
 14305					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14306					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14307					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14308					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14309			011735		SN=SN+1
 14310		002000	000000			ZZ=ZZ+ZZ
 14311						IFE	ZZ,<ZZ=1>
 14312	037325	200 00 0 00 070320 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14313	037326	274 00 0 00 070320 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14314	037327	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14315						STOP^
 14316	037330	254 04 0 00 037331 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14317	037331	324 00 0 00 037332 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14318									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14319									;IN THE SUBTEST) TO LOOP ON ERROR^
 14320
 14321					;**********
 14322
 14323					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14324					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14325					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14326					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14327			011736		SN=SN+1
 14328		004000	000000			ZZ=ZZ+ZZ
 14329						IFE	ZZ,<ZZ=1>
 14330	037332	200 00 0 00 070321 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14331	037333	274 00 0 00 070321 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14332	037334	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0309

 14333						STOP^
 14334	037335	254 04 0 00 037336 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14335	037336	324 00 0 00 037337 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14336									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14337									;IN THE SUBTEST) TO LOOP ON ERROR^
 14338
 14339					;**********
 14340
 14341					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14342					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14343					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14344					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14345			011737		SN=SN+1
 14346		010000	000000			ZZ=ZZ+ZZ
 14347						IFE	ZZ,<ZZ=1>
 14348	037337	200 00 0 00 070322 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14349	037340	274 00 0 00 070322 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14350	037341	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14351						STOP^
 14352	037342	254 04 0 00 037343 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14353	037343	324 00 0 00 037344 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14354									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14355									;IN THE SUBTEST) TO LOOP ON ERROR^
 14356
 14357					;**********
 14358
 14359					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14360					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14361					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14362					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14363			011740		SN=SN+1
 14364		020000	000000			ZZ=ZZ+ZZ
 14365						IFE	ZZ,<ZZ=1>
 14366	037344	200 00 0 00 070323 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14367	037345	274 00 0 00 070323 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14368	037346	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14369						STOP^
 14370	037347	254 04 0 00 037350 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14371	037350	324 00 0 00 037351 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14372									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14373									;IN THE SUBTEST) TO LOOP ON ERROR^
 14374
 14375					;**********
 14376
 14377					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14378					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14379					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14380					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14381			011741		SN=SN+1
 14382		040000	000000			ZZ=ZZ+ZZ
 14383						IFE	ZZ,<ZZ=1>
 14384	037351	200 00 0 00 070324 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14385	037352	274 00 0 00 070324 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14386	037353	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14387						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0310

 14388	037354	254 04 0 00 037355 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14389	037355	324 00 0 00 037356 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14390									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14391									;IN THE SUBTEST) TO LOOP ON ERROR^
 14392
 14393					;**********
 14394
 14395					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14396					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14397					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14398					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14399			011742		SN=SN+1
 14400		100000	000000			ZZ=ZZ+ZZ
 14401						IFE	ZZ,<ZZ=1>
 14402	037356	200 00 0 00 070325 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14403	037357	274 00 0 00 070325 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14404	037360	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14405						STOP^
 14406	037361	254 04 0 00 037362 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14407	037362	324 00 0 00 037363 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14408									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14409									;IN THE SUBTEST) TO LOOP ON ERROR^
 14410
 14411					;**********
 14412
 14413					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14414					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14415					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14416					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14417			011743		SN=SN+1
 14418		200000	000000			ZZ=ZZ+ZZ
 14419						IFE	ZZ,<ZZ=1>
 14420	037363	200 00 0 00 070326 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14421	037364	274 00 0 00 070326 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14422	037365	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14423						STOP^
 14424	037366	254 04 0 00 037367 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14425	037367	324 00 0 00 037370 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14426									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14427									;IN THE SUBTEST) TO LOOP ON ERROR^
 14428
 14429					;**********
 14430
 14431					;THIS TEST VERIFIES THAT IF A RIPPLED ONE
 14432					;IS SUBTRACTED FROM ITSELF, THE RESULT IS
 14433					;AN AC OF ALL ZEROS. THIS TEST IS REPEATED 36
 14434					;TIMES IN ORDER TO TEST ALL 36 BITS.
 14435			011744		SN=SN+1
 14436		400000	000000			ZZ=ZZ+ZZ
 14437						IFE	ZZ,<ZZ=1>
 14438	037370	200 00 0 00 070256 		MOVE	[ZZ]		;LOAD AC WITH A FLOATING ONE
 14439	037371	274 00 0 00 070256 		SUB	[ZZ]		;*SUB OF FLOATING ONE FROM ITSELF SHOULD RESULT IN C(AC)=0
 14440	037372	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14441						STOP^
 14442	037373	254 04 0 00 037374 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-13
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0311

 14443	037374	324 00 0 00 037375 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14444									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14445									;IN THE SUBTEST) TO LOOP ON ERROR^
 14446
 14447					;**********
 14448
 14449					PAGE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 12-14
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0312

 14450					;THIS TEST VERIFIES THAT IF A WORD OF ALL
 14451					;ONES IS SUBTRACTED FROM ITSELF, THE RESULT
 14452					;IN THE AC IS ZERO.
 14453
 14454	037375	200 00 0 00 070254 	A12000:	MOVE	[-1]		;PRESET AC TO ALL ONES
 14455	037376	274 00 0 00 070254 		SUB	[-1]		;*SUB OF -1 FROM ITSELF SHOULD RESULT IN C(AC)=0
 14456	037377	332 00 0 00 000000 		SKIPE			;PASS TEST IF C(AC)=0
 14457						STOP^
 14458	037400	254 04 0 00 037401 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14459	037401	324 00 0 00 037402 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14460									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14461									;IN THE SUBTEST) TO LOOP ON ERROR^
 14462
 14463					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 13
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0313

 14464					;THIS TEST VERIFIES THAT CAMA ALWAYS SKIPS THE
 14465					;NEXT INSTRUCTION INDEPENDENT OF THE DATA WITH AC
 14466					;AND E. THIS TEST FAILS IF CAMA DOES NOT SKIP ALWAYS.
 14467
 14468	037402	200 00 0 00 070253 	A12100:	MOVE	[0]		;PRESET AC, E TO ZERO
 14469	037403	314 00 0 00 000000 		CAMA			;*CAMA SHOULD ALWAYS SKIP THE NEXT INSTRUCTION,
 14470									;OTHERWISE THIS TEST FAILS
 14471						STOP^
 14472	037404	254 04 0 00 037405 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14473	037405	324 00 0 00 037406 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14474									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14475									;IN THE SUBTEST) TO LOOP ON ERROR^
 14476
 14477					;ET0 [E], ET0 EN[E], IR CAXX[IR3], AD CRY 3C[ADCR],
 14478					;FCYC ACT EN D [ADCR], AD CRY 36 F/F'S [ADCR],
 14479					;PC CLOCK EN [PCC], ET0 C F/F[E], IR CAXX[IR3],
 14480					;ADZ COND P[ADZ] AND ADZ COND Z[ADZ]
 14481
 14482					;**********
 14483
 14484					;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
 14485					;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY
 14486					;IF C(AC)=C(E). IN THIS TEST AC=E=0 AND
 14487					;C(AC)=C(E)=0. HENCE, CAME MUST
 14488					;SKIP THE NEXT INSTRUCTION
 14489					;IN THIS TEST
 14490
 14491	037406	200 00 0 00 070253 	A12200:	MOVE	[0]		;PRESET AC, E TO ZERO
 14492	037407	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP SINCE E=AC
 14493						STOP^
 14494	037410	254 04 0 00 037411 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14495	037411	324 00 0 00 037412 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14496									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14497									;IN THE SUBTEST) TO LOOP ON ERROR^
 14498
 14499					;AD FM + EN [ADFP], F CXC ACT ENC[F1], IRCAXX[IR3]
 14500
 14501					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 14
DFKAA2	MAC	25-AUG-75 13:56		TEST OF SUB AND COMPARE INSTRUCTIONS                                               SEQ 0314

 14502					;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE
 14503					;IT SKIPS THE NEXT INSTRUCTION OF AND ONLY IF
 14504					;C(AC)=C(E). IN THIS TEST C(AC)=C(E)=0;
 14505					;BUT, E IS NOT WITHIN THE AC RANGE.
 14506					;HENCE, CAME MUST SKIP
 14507					;THE NEXT INSTRUCTION IN THIS TEST.
 14508
 14509	037412	200 00 0 00 070253 	A12300:	MOVE	[0]		;*CAME SHOULD SKIP WHEN C(AC)=C(E)=0
 14510	037413	312 00 0 00 070253 		CAME	[0]
 14511						STOP^
 14512	037414	254 04 0 00 037415 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14513	037415	324 00 0 00 037416 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14514									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14515									;IN THE SUBTEST) TO LOOP ON ERROR^
 14516
 14517					;CAMX: FCE[F1], IR CAMX[IR1]
 14518
 14519					;**********
 14520
 14521					;THIS TEST VERIFIES THAT CAME IS DATA SENSITIVE.
 14522					;IT SKIPS THE NEXT INSTRUCTION IF AND ONLY IF
 14523					;C(AC)=C(E). IN THIS TEST C(AC)=0 AND
 14524					;C(E)=-1. HENCE, CAME SHOULD NOT
 14525					;SKIP THE NEXT INSTRUCTION IN THIS TEST.
 14526
 14527	037416	200 00 0 00 070253 	A12400:	MOVE	[0]		;PRESET AC TO ZERO
 14528	037417	312 00 0 00 070254 		CAME	[-1]		;*CAME SHOULD NOT SKIP BECAUSE C(AC)=0 ANDC(E)=-
 14529	037420	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAME PASSES TEST
 14530						STOP^
 14531	037421	254 04 0 00 037422 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14532	037422	324 00 0 00 037423 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14533									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14534									;IN THE SUBTEST) TO LOOP ON ERROR^
 14535
 14536					;AD AR- EN [ADAM], IR CAXX [IR3], F CYC ACT EN B [F1],
 14537					;AD AR- F/F'S [ADAM], AD ADD [ADC1], AD FM + FETCH EN A [ADFP],
 14538					;F CYC ACT EN A [F1], AD ADD EN C [ADC1], AD ADD F/F'S [ADC1]
 14539
 14540					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 15
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0315

 14541					SUBTTL	TEST OF COMPARE (CAMX) INSTRUCTIONS
 14542
 14543					;**********
 14544
 14545					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14546					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14547					;IN THIS TEST, C(AC)=-1 AND C(E)=0; HENCE, CAML SHOULD SKIP.  OTHERWISE,THE 
 14548					;PROGRAM HALTS.
 14549
 14550	037423	200 00 0 00 070254 	B100:	MOVE	[-1]		;PRELOAD AC WITH -1
 14551	037424	311 00 0 00 070253 		CAML	[0]		;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
 14552						STOP^
 14553	037425	254 04 0 00 037426 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14554	037426	324 00 0 00 037427 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14555									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14556									;IN THE SUBTEST) TO LOOP ON ERROR^
 14557
 14558					;*****     FAILURE ANALYSIS     *****
 14559					;C(AC0)		C(AC1)		FAILING SIGNAL
 14560
 14561					;				FC: AB PC EN
 14562					;				ET0: COND Q: PC CLK EN
 14563
 14564					;**********
 14565
 14566					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14567					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14568					;IN THIS CASE, C(AC)=0 AND C(E)=-1; HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
 14569					;THE PROGRAM HALTS.
 14570
 14571	037427	200 00 0 00 070253 	B200:	MOVE	[0]		;PRELOAD AC WITH 0
 14572	037430	311 00 0 00 070254 		CAML	[-1]		;*CAML SHOULD NOT SKIP BECAUSE
 14573									;C(AC) IS GREATER THAN C(E)
 14574	037431	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
 14575						STOP^
 14576	037432	254 04 0 00 037433 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14577	037433	324 00 0 00 037434 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14578									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14579									;IN THE SUBTEST) TO LOOP ON ERROR^
 14580
 14581					;*****     FAILURE ANALYSIS     *****
 14582					;C(AC0)		C(AC1)		FAILING SIGNAL
 14583
 14584					;				SW: FCE
 14585					;				FC: PC CHANGE
 14586
 14587					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 16
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0316

 14588					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14589					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14590					;IN THIS CASE, C(AC)=400000,,0 (THE MOST
 14591					;NEGATIVE NUMBER) AND C(E)=377777,,-1
 14592					;(THE MOST POSITIVE NUMBER); HENCE,
 14593					;CAML SHOULD SKIP.  OTHERWISE, THE
 14594					;PROGRAM HALTS
 14595
 14596	037434	200 00 0 00 070256 	B300:	MOVE	[XWD 400000,0]	;PRELOAD AC WITH 400000,,0
 14597	037435	311 00 0 00 070255 		CAML	[XWD 377777,-1]	;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
 14598						STOP^
 14599	037436	254 04 0 00 037437 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14600	037437	324 00 0 00 037440 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14601									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14602									;IN THE SUBTEST) TO LOOP ON ERROR^
 14603
 14604					;*****     FAILURE ANALYSIS     *****
 14605					;C(AC0)		C(AC1)		FAILING SIGNAL
 14606
 14607					;				FC: AD ADD
 14608
 14609					;**********
 14610
 14611					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14612					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14613					;IN THIS CASE, C(AC)=377777,,-1 (THE MOST POSITIVE NUMBER) AND C(E)=400000,,0 (THE MOST NEG
 14614					ATIVE NUMBER)
 14615					;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE, THE PROGRAM HALTS.
 14616
 14617	037440	200 00 0 00 070255 	B400:	MOVE	[XWD 377777,-1]	;PRELOAD AC WITH 377777,,-1
 14618	037441	311 00 0 00 070256 		CAML	[XWD 400000,0]	;*CAML SHOULD NOT SKIP BECAUSE
 14619									;C(AC) IS GREATER THAN C(E)
 14620	037442	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
 14621						STOP^
 14622	037443	254 04 0 00 037444 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14623	037444	324 00 0 00 037445 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14624									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14625									;IN THE SUBTEST) TO LOOP ON ERROR^
 14626
 14627					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 17
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0317

 14628					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14629					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14630					;IN THIS CASE, C(AC)=400000,,0 (THE MOST NEGTIVE NUMBER) AND C(E)=-1;
 14631					;HENCE, CAML SHOULD SKIP.  OTHERWISE, THE PROGRAM HALTS
 14632
 14633	037445	200 00 0 00 070256 	B500:	MOVE	[XWD 400000,0]	;PRELOAD AC WITH 400000,,0
 14634	037446	311 00 0 00 070254 		CAML	[-1]		;*CAML SHOULD SKIP BECAUSE C(AC) IS LESS THAN C(E)
 14635						STOP^
 14636	037447	254 04 0 00 037450 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14637	037450	324 00 0 00 037451 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14638									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14639									;IN THE SUBTEST) TO LOOP ON ERROR^
 14640
 14641					;*****     FAILURE ANALYSIS     *****
 14642					;C(AC0)		C(AC1)		FAILING SIGNAL
 14643
 14644					;				FC: AD FM + EN
 14645
 14646					;**********
 14647
 14648					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14649					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14650					;IN THIS CASE, C(AC)=0 AND C(E)=-1 ;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
 14651					;THE PROGRAM HALTS.
 14652
 14653	037451	400 00 0 00 000000 	B600:	SETZ			;PRELOAD AC WITH 0		
 14654	037452	311 00 0 00 070254 		CAML	[-1]		;*CAML SHOULD NOT SKIP BECAUSE
 14655									;C(AC) IS GREATER THAN C(E)
 14656	037453	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES.
 14657						STOP^
 14658	037454	254 04 0 00 037455 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14659	037455	324 00 0 00 037456 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14660									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14661									;IN THE SUBTEST) TO LOOP ON ERROR^
 14662
 14663					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 18
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0318

 14664					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT INSTRUCTION WHEN AND
 14665					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14666					;IN THIS CASE, C(AC)=0 AND C(E)=0 ;HENCE, CAML SHOULD NOT SKIP.  OTHERWISE,
 14667					;THE PROGRAM HALTS.
 14668
 14669	037456	400 00 0 00 000000 	B700:	SETZ			;PRELOAD AS WITH 0		
 14670	037457	311 00 0 00 070253 		CAML	[0]		;*CAML SHOULD NOT SKIP BECAUSE C(AC)=C(E)
 14671	037460	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
 14672						STOP^
 14673	037461	254 04 0 00 037462 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14674	037462	324 00 0 00 037463 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14675									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14676									;IN THE SUBTEST) TO LOOP ON ERROR^
 14677
 14678					;*****     FAILURE ANALYSIS     *****
 14679					;C(AC0)		C(AC1)		FAILING SIGNAL
 14680
 14681					;				FC: AD CRY 36
 14682
 14683					;**********
 14684
 14685					;THIS TEST VERIFIES THAT CAML SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14686					;ONLY WHEN C(AC) IS LESS THAN C(E).
 14687					;IN THIS CASE, C(AC)=0 AND C(E)=400000,,O (THE MOST NEGATIVE NUMBER);
 14688					;HENCE CAML SHOULD NOT SKIP.  OTHERWISE, THE PROGRAM HALTS.
 14689
 14690	037463	400 00 0 00 000000 	B1000:	SETZ			;PRELOAD AC WITH 0
 14691	037464	311 00 0 00 070256 		CAML	[XWD 400000,0]	;*CAML SHOULD NOT SKIP BECAUSE
 14692									;C(AC) IS GREATER THAN C(E)
 14693	037465	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAML PASSES
 14694						STOP^
 14695	037466	254 04 0 00 037467 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14696	037467	324 00 0 00 037470 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14697									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14698									;IN THE SUBTEST) TO LOOP ON ERROR^
 14699
 14700					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 19
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0319

 14701					;THIS TEST VERIFIES THAT CAM IS DATA INDEPENDENT.  IT NEVER SKIPS
 14702					;THE NEXT SEQUENTIAL INSTRUCTION
 14703					;IN THIS CASE, C(AC)=-1 AND C(E)=0
 14704					;IF IT DOES SKIP THE NEXT INSTRUCTION, THE PROGRAM HALTS
 14705
 14706	037470	200 00 0 00 070254 	B1100:	MOVE	[-1]		;PRELOAD AC WITH -1	
 14707	037471	310 00 0 00 070253 		CAM	[0]		;*CAM SHOULD NEVER SKIP
 14708	037472	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAM PASSES
 14709						STOP^
 14710	037473	254 04 0 00 037474 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14711	037474	324 00 0 00 037475 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14712									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14713									;IN THE SUBTEST) TO LOOP ON ERROR^
 14714
 14715					;**********
 14716
 14717					;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14718					;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E).
 14719					;IN THIS CASE, C(AC)=-1 AND C(E)=0;  HENCE, CAMGE SHOULD NOT SKIP.
 14720					;OTHERWISE, THE PROGRAM HALTS.
 14721
 14722	037475	200 00 0 00 070254 	B1200:	MOVE	[-1]		;PRELOAD AC WITH-1	
 14723	037476	315 00 0 00 070253 		CAMGE	[0]		;*CAMGE SHOULD NOT SKIP BECAUSE C(AC) IS LESS THAN C(E)
 14724	037477	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAMGE PASSES.
 14725						STOP^
 14726	037500	254 04 0 00 037501 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14727	037501	324 00 0 00 037502 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14728									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14729									;IN THE SUBTEST) TO LOOP ON ERROR^
 14730
 14731					;*****     FAILURE ANALYSIS     *****
 14732					;C(AC0)		C(AC1)		FAILING SIGNAL
 14733
 14734					;				FC: PC CHANGE
 14735					;				FC: AB PC EN
 14736
 14737					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 20
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0320

 14738					;THIS TEST VERIFIES THAT CAMGE SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14739					;ONLY WHEN C(AC) IS GREATER THAN OR EQUAL TO C(E)
 14740					;IN THIS CASE, C(AC)=0 AND C(E)=-1;  HENCE CAMGE SHOULD SKIP.
 14741					;OTHEWISE, THE PROGRAM HALTS.
 14742
 14743	037502	400 00 0 00 000000 	B1300:	SETZ			;PRELOAD AC WITH 0		
 14744	037503	315 00 0 00 070254 		CAMGE	[-1]		;*CAMGE SHOULD SKIP BECAUSE C(AC) IS GREATER THAN C(E)
 14745						STOP^
 14746	037504	254 04 0 00 037505 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14747	037505	324 00 0 00 037506 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14748									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14749									;IN THE SUBTEST) TO LOOP ON ERROR^
 14750
 14751					;*****     FAILURE ANALYSIS     *****
 14752					;C(AC0)		C(AC1)		FAILING SIGNAL
 14753
 14754					;				SW: FCE
 14755					;				ET0: COND Q: PC CLK EN
 14756
 14757					;**********
 14758
 14759					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14760					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
 14761					;IN THIS CASE C(AC)=0 AND C(E)=-1;  HENCE CAMN SHOULD SKIP.
 14762					;OTHERWISE, THE PROGRAM HALTS
 14763
 14764	037506	400 00 0 00 000000 	B1400:	SETZ			;PRELOAD AC WITH 0		
 14765	037507	316 00 0 00 070254 		CAMN	[-1]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)
 14766						STOP^
 14767	037510	254 04 0 00 037511 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14768	037511	324 00 0 00 037512 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14769									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14770									;IN THE SUBTEST) TO LOOP ON ERROR^
 14771
 14772					;*****     FAILURE ANALYSIS     *****
 14773					;C(AC0)		C(AC1)		FAILING SIGNAL
 14774
 14775					;				FC:AD FM + EN
 14776					;				FC: AD AR - EN
 14777					;				FC: AD CRY 36
 14778					;				FC: AD ADD
 14779					;				FC: AB PC EN
 14780					;				ET0: PC CLK EN
 14781
 14782					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 21
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0321

 14783					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 14784					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E)
 14785					;IN THIS CASE, C(AC)=0 AND C(E)=0;  HENCE CAMN SHOULD NOT SKIP.
 14786					;OTHERWISE, THE PROGRAM HALTS
 14787
 14788	037512	400 00 0 00 000000 	B1500:	SETZ			;PRELOAD AC WITH 0		
 14789	037513	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD NOT SKIP BECAUSE C(AC)=C(E).
 14790	037514	334 00 0 00 000000 		SKIPA			;SKIP HALT INSTRUCTION IF CAMN PASSES
 14791						STOP^
 14792	037515	254 04 0 00 037516 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14793	037516	324 00 0 00 037517 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14794									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14795									;IN THE SUBTEST) TO LOOP ON ERROR^
 14796
 14797					;*****     FAILURE ANALYSIS     *****
 14798					;C(AC0)		C(AC1)		FAILING SIGNAL
 14799
 14800					;				SW: FCE
 14801					;				FC: PC CHANGE
 14802
 14803					;**********
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0322

 14804			001600		SN=1600
 14805			000000			ZZ=0
 14806
 14807					B1600:	REPEAT	^D18,<
 14808					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14809					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14810					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14811					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14812					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14813					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14814					
 14815					SN=SN+1
 14816						ZZ=ZZ+ZZ
 14817						IFE	ZZ,<ZZ=1>
 14818						MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14819						CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14820						CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14821						STOP
 14822					
 14823					;*****     FAILURE ANALYSIS     *****
 14824					;C(AC0)		C(AC1)		FAILING SIGNAL
 14825					
 14826					;				ET0: COND P
 14827					
 14828					;**********
 14829					>
 14830
 14831					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14832					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14833					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14834					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14835					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14836					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14837
 14838			001601		SN=SN+1
 14839			000000			ZZ=ZZ+ZZ
 14840			000001			IFE	ZZ,<ZZ=1>
 14841	037517	200 00 0 00 070265 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14842	037520	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14843	037521	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14844						STOP^
 14845	037522	254 04 0 00 037523 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14846	037523	324 00 0 00 037524 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14847									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14848									;IN THE SUBTEST) TO LOOP ON ERROR^
 14849
 14850					;*****     FAILURE ANALYSIS     *****
 14851					;C(AC0)		C(AC1)		FAILING SIGNAL
 14852
 14853					;				ET0: COND P
 14854
 14855					;**********
 14856
 14857
 14858					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0323

 14859					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14860					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14861					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14862					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14863					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14864
 14865			001602		SN=SN+1
 14866			000002			ZZ=ZZ+ZZ
 14867						IFE	ZZ,<ZZ=1>
 14868	037524	200 00 0 00 070266 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14869	037525	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14870	037526	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14871						STOP^
 14872	037527	254 04 0 00 037530 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14873	037530	324 00 0 00 037531 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14874									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14875									;IN THE SUBTEST) TO LOOP ON ERROR^
 14876
 14877					;*****     FAILURE ANALYSIS     *****
 14878					;C(AC0)		C(AC1)		FAILING SIGNAL
 14879
 14880					;				ET0: COND P
 14881
 14882					;**********
 14883
 14884
 14885					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14886					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14887					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14888					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14889					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14890					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14891
 14892			001603		SN=SN+1
 14893			000004			ZZ=ZZ+ZZ
 14894						IFE	ZZ,<ZZ=1>
 14895	037531	200 00 0 00 070267 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14896	037532	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14897	037533	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14898						STOP^
 14899	037534	254 04 0 00 037535 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14900	037535	324 00 0 00 037536 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14901									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14902									;IN THE SUBTEST) TO LOOP ON ERROR^
 14903
 14904					;*****     FAILURE ANALYSIS     *****
 14905					;C(AC0)		C(AC1)		FAILING SIGNAL
 14906
 14907					;				ET0: COND P
 14908
 14909					;**********
 14910
 14911
 14912					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14913					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0324

 14914					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14915					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14916					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14917					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14918
 14919			001604		SN=SN+1
 14920			000010			ZZ=ZZ+ZZ
 14921						IFE	ZZ,<ZZ=1>
 14922	037536	200 00 0 00 070270 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14923	037537	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14924	037540	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14925						STOP^
 14926	037541	254 04 0 00 037542 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14927	037542	324 00 0 00 037543 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14928									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14929									;IN THE SUBTEST) TO LOOP ON ERROR^
 14930
 14931					;*****     FAILURE ANALYSIS     *****
 14932					;C(AC0)		C(AC1)		FAILING SIGNAL
 14933
 14934					;				ET0: COND P
 14935
 14936					;**********
 14937
 14938
 14939					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14940					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14941					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14942					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14943					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14944					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14945
 14946			001605		SN=SN+1
 14947			000020			ZZ=ZZ+ZZ
 14948						IFE	ZZ,<ZZ=1>
 14949	037543	200 00 0 00 070271 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14950	037544	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14951	037545	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14952						STOP^
 14953	037546	254 04 0 00 037547 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14954	037547	324 00 0 00 037550 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14955									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14956									;IN THE SUBTEST) TO LOOP ON ERROR^
 14957
 14958					;*****     FAILURE ANALYSIS     *****
 14959					;C(AC0)		C(AC1)		FAILING SIGNAL
 14960
 14961					;				ET0: COND P
 14962
 14963					;**********
 14964
 14965
 14966					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14967					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14968					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0325

 14969					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14970					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14971					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14972
 14973			001606		SN=SN+1
 14974			000040			ZZ=ZZ+ZZ
 14975						IFE	ZZ,<ZZ=1>
 14976	037550	200 00 0 00 070272 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 14977	037551	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 14978	037552	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 14979						STOP^
 14980	037553	254 04 0 00 037554 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 14981	037554	324 00 0 00 037555 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 14982									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 14983									;IN THE SUBTEST) TO LOOP ON ERROR^
 14984
 14985					;*****     FAILURE ANALYSIS     *****
 14986					;C(AC0)		C(AC1)		FAILING SIGNAL
 14987
 14988					;				ET0: COND P
 14989
 14990					;**********
 14991
 14992
 14993					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 14994					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 14995					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 14996					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 14997					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 14998					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 14999
 15000			001607		SN=SN+1
 15001			000100			ZZ=ZZ+ZZ
 15002						IFE	ZZ,<ZZ=1>
 15003	037555	200 00 0 00 070273 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15004	037556	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15005	037557	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15006						STOP^
 15007	037560	254 04 0 00 037561 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15008	037561	324 00 0 00 037562 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15009									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15010									;IN THE SUBTEST) TO LOOP ON ERROR^
 15011
 15012					;*****     FAILURE ANALYSIS     *****
 15013					;C(AC0)		C(AC1)		FAILING SIGNAL
 15014
 15015					;				ET0: COND P
 15016
 15017					;**********
 15018
 15019
 15020					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15021					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15022					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15023					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0326

 15024					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15025					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15026
 15027			001610		SN=SN+1
 15028			000200			ZZ=ZZ+ZZ
 15029						IFE	ZZ,<ZZ=1>
 15030	037562	200 00 0 00 070274 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15031	037563	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15032	037564	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15033						STOP^
 15034	037565	254 04 0 00 037566 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15035	037566	324 00 0 00 037567 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15036									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15037									;IN THE SUBTEST) TO LOOP ON ERROR^
 15038
 15039					;*****     FAILURE ANALYSIS     *****
 15040					;C(AC0)		C(AC1)		FAILING SIGNAL
 15041
 15042					;				ET0: COND P
 15043
 15044					;**********
 15045
 15046
 15047					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15048					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15049					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15050					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15051					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15052					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15053
 15054			001611		SN=SN+1
 15055			000400			ZZ=ZZ+ZZ
 15056						IFE	ZZ,<ZZ=1>
 15057	037567	200 00 0 00 070275 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15058	037570	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15059	037571	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15060						STOP^
 15061	037572	254 04 0 00 037573 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15062	037573	324 00 0 00 037574 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15063									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15064									;IN THE SUBTEST) TO LOOP ON ERROR^
 15065
 15066					;*****     FAILURE ANALYSIS     *****
 15067					;C(AC0)		C(AC1)		FAILING SIGNAL
 15068
 15069					;				ET0: COND P
 15070
 15071					;**********
 15072
 15073
 15074					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15075					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15076					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15077					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15078					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0327

 15079					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15080
 15081			001612		SN=SN+1
 15082			001000			ZZ=ZZ+ZZ
 15083						IFE	ZZ,<ZZ=1>
 15084	037574	200 00 0 00 070276 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15085	037575	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15086	037576	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15087						STOP^
 15088	037577	254 04 0 00 037600 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15089	037600	324 00 0 00 037601 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15090									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15091									;IN THE SUBTEST) TO LOOP ON ERROR^
 15092
 15093					;*****     FAILURE ANALYSIS     *****
 15094					;C(AC0)		C(AC1)		FAILING SIGNAL
 15095
 15096					;				ET0: COND P
 15097
 15098					;**********
 15099
 15100
 15101					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15102					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15103					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15104					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15105					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15106					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15107
 15108			001613		SN=SN+1
 15109			002000			ZZ=ZZ+ZZ
 15110						IFE	ZZ,<ZZ=1>
 15111	037601	200 00 0 00 070277 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15112	037602	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15113	037603	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15114						STOP^
 15115	037604	254 04 0 00 037605 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15116	037605	324 00 0 00 037606 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15117									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15118									;IN THE SUBTEST) TO LOOP ON ERROR^
 15119
 15120					;*****     FAILURE ANALYSIS     *****
 15121					;C(AC0)		C(AC1)		FAILING SIGNAL
 15122
 15123					;				ET0: COND P
 15124
 15125					;**********
 15126
 15127
 15128					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15129					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15130					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15131					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15132					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15133					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0328

 15134
 15135			001614		SN=SN+1
 15136			004000			ZZ=ZZ+ZZ
 15137						IFE	ZZ,<ZZ=1>
 15138	037606	200 00 0 00 070300 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15139	037607	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15140	037610	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15141						STOP^
 15142	037611	254 04 0 00 037612 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15143	037612	324 00 0 00 037613 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15144									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15145									;IN THE SUBTEST) TO LOOP ON ERROR^
 15146
 15147					;*****     FAILURE ANALYSIS     *****
 15148					;C(AC0)		C(AC1)		FAILING SIGNAL
 15149
 15150					;				ET0: COND P
 15151
 15152					;**********
 15153
 15154
 15155					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15156					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15157					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15158					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15159					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15160					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15161
 15162			001615		SN=SN+1
 15163			010000			ZZ=ZZ+ZZ
 15164						IFE	ZZ,<ZZ=1>
 15165	037613	200 00 0 00 070301 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15166	037614	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15167	037615	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15168						STOP^
 15169	037616	254 04 0 00 037617 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15170	037617	324 00 0 00 037620 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15171									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15172									;IN THE SUBTEST) TO LOOP ON ERROR^
 15173
 15174					;*****     FAILURE ANALYSIS     *****
 15175					;C(AC0)		C(AC1)		FAILING SIGNAL
 15176
 15177					;				ET0: COND P
 15178
 15179					;**********
 15180
 15181
 15182					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15183					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15184					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15185					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15186					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15187					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15188
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0329

 15189			001616		SN=SN+1
 15190			020000			ZZ=ZZ+ZZ
 15191						IFE	ZZ,<ZZ=1>
 15192	037620	200 00 0 00 070302 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15193	037621	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15194	037622	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15195						STOP^
 15196	037623	254 04 0 00 037624 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15197	037624	324 00 0 00 037625 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15198									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15199									;IN THE SUBTEST) TO LOOP ON ERROR^
 15200
 15201					;*****     FAILURE ANALYSIS     *****
 15202					;C(AC0)		C(AC1)		FAILING SIGNAL
 15203
 15204					;				ET0: COND P
 15205
 15206					;**********
 15207
 15208
 15209					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15210					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15211					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15212					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15213					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15214					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15215
 15216			001617		SN=SN+1
 15217			040000			ZZ=ZZ+ZZ
 15218						IFE	ZZ,<ZZ=1>
 15219	037625	200 00 0 00 070303 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15220	037626	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15221	037627	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15222						STOP^
 15223	037630	254 04 0 00 037631 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15224	037631	324 00 0 00 037632 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15225									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15226									;IN THE SUBTEST) TO LOOP ON ERROR^
 15227
 15228					;*****     FAILURE ANALYSIS     *****
 15229					;C(AC0)		C(AC1)		FAILING SIGNAL
 15230
 15231					;				ET0: COND P
 15232
 15233					;**********
 15234
 15235
 15236					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15237					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15238					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15239					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15240					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15241					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15242
 15243			001620		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0330

 15244			100000			ZZ=ZZ+ZZ
 15245						IFE	ZZ,<ZZ=1>
 15246	037632	200 00 0 00 070304 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15247	037633	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15248	037634	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15249						STOP^
 15250	037635	254 04 0 00 037636 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15251	037636	324 00 0 00 037637 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15252									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15253									;IN THE SUBTEST) TO LOOP ON ERROR^
 15254
 15255					;*****     FAILURE ANALYSIS     *****
 15256					;C(AC0)		C(AC1)		FAILING SIGNAL
 15257
 15258					;				ET0: COND P
 15259
 15260					;**********
 15261
 15262
 15263					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15264					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15265					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15266					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15267					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15268					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15269
 15270			001621		SN=SN+1
 15271			200000			ZZ=ZZ+ZZ
 15272						IFE	ZZ,<ZZ=1>
 15273	037637	200 00 0 00 070305 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15274	037640	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15275	037641	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15276						STOP^
 15277	037642	254 04 0 00 037643 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15278	037643	324 00 0 00 037644 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15279									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15280									;IN THE SUBTEST) TO LOOP ON ERROR^
 15281
 15282					;*****     FAILURE ANALYSIS     *****
 15283					;C(AC0)		C(AC1)		FAILING SIGNAL
 15284
 15285					;				ET0: COND P
 15286
 15287					;**********
 15288
 15289
 15290					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15291					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15292					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15293					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15294					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15295					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15296
 15297			001622		SN=SN+1
 15298			400000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 22-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0331

 15299						IFE	ZZ,<ZZ=1>
 15300	037644	200 00 0 00 070306 		MOVE	[XWD ZZ]	;PRELOAD AC,E WITH A FLOATING 1
 15301	037645	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15302	037646	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15303						STOP^
 15304	037647	254 04 0 00 037650 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15305	037650	324 00 0 00 037651 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15306									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15307									;IN THE SUBTEST) TO LOOP ON ERROR^
 15308
 15309					;*****     FAILURE ANALYSIS     *****
 15310					;C(AC0)		C(AC1)		FAILING SIGNAL
 15311
 15312					;				ET0: COND P
 15313
 15314					;**********
 15315
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0332

 15316			000000			ZZ=0
 15317
 15318						REPEAT	^D18,<
 15319					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15320					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15321					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15322					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15323					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15324					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15325					
 15326					SN=SN+1
 15327						ZZ=ZZ+ZZ
 15328						IFE	ZZ,<ZZ=1>
 15329						MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15330						CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15331						CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15332						STOP
 15333					
 15334					;**********
 15335					>
 15336
 15337					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15338					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15339					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15340					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15341					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15342					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15343
 15344			001623		SN=SN+1
 15345			000000			ZZ=ZZ+ZZ
 15346			000001			IFE	ZZ,<ZZ=1>
 15347	037651	200 00 0 00 070307 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15348	037652	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15349	037653	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15350						STOP^
 15351	037654	254 04 0 00 037655 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15352	037655	324 00 0 00 037656 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15353									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15354									;IN THE SUBTEST) TO LOOP ON ERROR^
 15355
 15356					;**********
 15357
 15358
 15359					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15360					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15361					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15362					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15363					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15364					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15365
 15366			001624		SN=SN+1
 15367			000002			ZZ=ZZ+ZZ
 15368						IFE	ZZ,<ZZ=1>
 15369	037656	200 00 0 00 070310 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15370	037657	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0333

 15371	037660	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15372						STOP^
 15373	037661	254 04 0 00 037662 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15374	037662	324 00 0 00 037663 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15375									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15376									;IN THE SUBTEST) TO LOOP ON ERROR^
 15377
 15378					;**********
 15379
 15380
 15381					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15382					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15383					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15384					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15385					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15386					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15387
 15388			001625		SN=SN+1
 15389			000004			ZZ=ZZ+ZZ
 15390						IFE	ZZ,<ZZ=1>
 15391	037663	200 00 0 00 070311 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15392	037664	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15393	037665	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15394						STOP^
 15395	037666	254 04 0 00 037667 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15396	037667	324 00 0 00 037670 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15397									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15398									;IN THE SUBTEST) TO LOOP ON ERROR^
 15399
 15400					;**********
 15401
 15402
 15403					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15404					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15405					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15406					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15407					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15408					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15409
 15410			001626		SN=SN+1
 15411			000010			ZZ=ZZ+ZZ
 15412						IFE	ZZ,<ZZ=1>
 15413	037670	200 00 0 00 070312 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15414	037671	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15415	037672	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15416						STOP^
 15417	037673	254 04 0 00 037674 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15418	037674	324 00 0 00 037675 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15419									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15420									;IN THE SUBTEST) TO LOOP ON ERROR^
 15421
 15422					;**********
 15423
 15424
 15425					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0334

 15426					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15427					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15428					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15429					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15430					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15431
 15432			001627		SN=SN+1
 15433			000020			ZZ=ZZ+ZZ
 15434						IFE	ZZ,<ZZ=1>
 15435	037675	200 00 0 00 070313 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15436	037676	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15437	037677	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15438						STOP^
 15439	037700	254 04 0 00 037701 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15440	037701	324 00 0 00 037702 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15441									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15442									;IN THE SUBTEST) TO LOOP ON ERROR^
 15443
 15444					;**********
 15445
 15446
 15447					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15448					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15449					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15450					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15451					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15452					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15453
 15454			001630		SN=SN+1
 15455			000040			ZZ=ZZ+ZZ
 15456						IFE	ZZ,<ZZ=1>
 15457	037702	200 00 0 00 070314 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15458	037703	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15459	037704	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15460						STOP^
 15461	037705	254 04 0 00 037706 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15462	037706	324 00 0 00 037707 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15463									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15464									;IN THE SUBTEST) TO LOOP ON ERROR^
 15465
 15466					;**********
 15467
 15468
 15469					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15470					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15471					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15472					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15473					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15474					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15475
 15476			001631		SN=SN+1
 15477			000100			ZZ=ZZ+ZZ
 15478						IFE	ZZ,<ZZ=1>
 15479	037707	200 00 0 00 070315 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15480	037710	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0335

 15481	037711	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15482						STOP^
 15483	037712	254 04 0 00 037713 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15484	037713	324 00 0 00 037714 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15485									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15486									;IN THE SUBTEST) TO LOOP ON ERROR^
 15487
 15488					;**********
 15489
 15490
 15491					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15492					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15493					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15494					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15495					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15496					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15497
 15498			001632		SN=SN+1
 15499			000200			ZZ=ZZ+ZZ
 15500						IFE	ZZ,<ZZ=1>
 15501	037714	200 00 0 00 070316 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15502	037715	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15503	037716	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15504						STOP^
 15505	037717	254 04 0 00 037720 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15506	037720	324 00 0 00 037721 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15507									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15508									;IN THE SUBTEST) TO LOOP ON ERROR^
 15509
 15510					;**********
 15511
 15512
 15513					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15514					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15515					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15516					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15517					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15518					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15519
 15520			001633		SN=SN+1
 15521			000400			ZZ=ZZ+ZZ
 15522						IFE	ZZ,<ZZ=1>
 15523	037721	200 00 0 00 070264 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15524	037722	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15525	037723	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15526						STOP^
 15527	037724	254 04 0 00 037725 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15528	037725	324 00 0 00 037726 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15529									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15530									;IN THE SUBTEST) TO LOOP ON ERROR^
 15531
 15532					;**********
 15533
 15534
 15535					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0336

 15536					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15537					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15538					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15539					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15540					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15541
 15542			001634		SN=SN+1
 15543			001000			ZZ=ZZ+ZZ
 15544						IFE	ZZ,<ZZ=1>
 15545	037726	200 00 0 00 070317 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15546	037727	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15547	037730	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15548						STOP^
 15549	037731	254 04 0 00 037732 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15550	037732	324 00 0 00 037733 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15551									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15552									;IN THE SUBTEST) TO LOOP ON ERROR^
 15553
 15554					;**********
 15555
 15556
 15557					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15558					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15559					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15560					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15561					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15562					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15563
 15564			001635		SN=SN+1
 15565			002000			ZZ=ZZ+ZZ
 15566						IFE	ZZ,<ZZ=1>
 15567	037733	200 00 0 00 070320 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15568	037734	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15569	037735	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15570						STOP^
 15571	037736	254 04 0 00 037737 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15572	037737	324 00 0 00 037740 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15573									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15574									;IN THE SUBTEST) TO LOOP ON ERROR^
 15575
 15576					;**********
 15577
 15578
 15579					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15580					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15581					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15582					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15583					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15584					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15585
 15586			001636		SN=SN+1
 15587			004000			ZZ=ZZ+ZZ
 15588						IFE	ZZ,<ZZ=1>
 15589	037740	200 00 0 00 070321 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15590	037741	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0337

 15591	037742	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15592						STOP^
 15593	037743	254 04 0 00 037744 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15594	037744	324 00 0 00 037745 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15595									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15596									;IN THE SUBTEST) TO LOOP ON ERROR^
 15597
 15598					;**********
 15599
 15600
 15601					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15602					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15603					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15604					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15605					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15606					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15607
 15608			001637		SN=SN+1
 15609			010000			ZZ=ZZ+ZZ
 15610						IFE	ZZ,<ZZ=1>
 15611	037745	200 00 0 00 070322 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15612	037746	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15613	037747	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15614						STOP^
 15615	037750	254 04 0 00 037751 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15616	037751	324 00 0 00 037752 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15617									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15618									;IN THE SUBTEST) TO LOOP ON ERROR^
 15619
 15620					;**********
 15621
 15622
 15623					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15624					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15625					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15626					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15627					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15628					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15629
 15630			001640		SN=SN+1
 15631			020000			ZZ=ZZ+ZZ
 15632						IFE	ZZ,<ZZ=1>
 15633	037752	200 00 0 00 070323 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15634	037753	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15635	037754	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15636						STOP^
 15637	037755	254 04 0 00 037756 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15638	037756	324 00 0 00 037757 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15639									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15640									;IN THE SUBTEST) TO LOOP ON ERROR^
 15641
 15642					;**********
 15643
 15644
 15645					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0338

 15646					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15647					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15648					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15649					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15650					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15651
 15652			001641		SN=SN+1
 15653			040000			ZZ=ZZ+ZZ
 15654						IFE	ZZ,<ZZ=1>
 15655	037757	200 00 0 00 070324 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15656	037760	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15657	037761	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15658						STOP^
 15659	037762	254 04 0 00 037763 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15660	037763	324 00 0 00 037764 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15661									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15662									;IN THE SUBTEST) TO LOOP ON ERROR^
 15663
 15664					;**********
 15665
 15666
 15667					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15668					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15669					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15670					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15671					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15672					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15673
 15674			001642		SN=SN+1
 15675			100000			ZZ=ZZ+ZZ
 15676						IFE	ZZ,<ZZ=1>
 15677	037764	200 00 0 00 070325 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15678	037765	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15679	037766	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15680						STOP^
 15681	037767	254 04 0 00 037770 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15682	037770	324 00 0 00 037771 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15683									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15684									;IN THE SUBTEST) TO LOOP ON ERROR^
 15685
 15686					;**********
 15687
 15688
 15689					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15690					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15691					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15692					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15693					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15694					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15695
 15696			001643		SN=SN+1
 15697			200000			ZZ=ZZ+ZZ
 15698						IFE	ZZ,<ZZ=1>
 15699	037771	200 00 0 00 070326 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15700	037772	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 23-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0339

 15701	037773	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15702						STOP^
 15703	037774	254 04 0 00 037775 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15704	037775	324 00 0 00 037776 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15705									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15706									;IN THE SUBTEST) TO LOOP ON ERROR^
 15707
 15708					;**********
 15709
 15710
 15711					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY
 15712					;WHEN C(AC) IS NOT EQUAL TO C(E).  IT ALSO VERIFIES THAT CAME
 15713					;SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND ONLY WHEN
 15714					;C(AC)=C(E).  IN BOTH CASES AC=E;  HENCE, C(AC)=C(E)
 15715					;IF EITHER CAMN OR CAME FAILS, THE PROGRAM HALTS
 15716					;THIS TEST IS REPEATED 36 TIMES IN ORDER TO FLOAT A 1 THRU ALL 36 BITS
 15717
 15718			001644		SN=SN+1
 15719			400000			ZZ=ZZ+ZZ
 15720						IFE	ZZ,<ZZ=1>
 15721	037776	200 00 0 00 070256 		MOVE	[XWD ZZ,0]	;PRELOAD AC,E WITH A FLOATING 1
 15722	037777	316 00 0 00 000000 		CAMN			;*CAMN SHOLD NOT SKIP BECAUSE C(AC)=C(E)		
 15723	040000	312 00 0 00 000000 		CAME			;*CAME SHOULD SKIP BECAUSE C(AC)=C(E)		
 15724						STOP^
 15725	040001	254 04 0 00 040002 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15726	040002	324 00 0 00 040003 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15727									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15728									;IN THE SUBTEST) TO LOOP ON ERROR^
 15729
 15730					;**********
 15731
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0340

 15732			001700		SN=1700
 15733			000000			ZZ=0
 15734
 15735					B1700:	REPEAT	^D36,<
 15736					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15737					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15738					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15739					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15740					SN=SN+1
 15741						ZZ=ZZ+ZZ
 15742						IFE	ZZ,<ZZ=1>
 15743						SETZ			;PRELOAD AC WITH 0
 15744						CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15745						STOP		
 15746					
 15747					;**********
 15748					>
 15749
 15750					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15751					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15752					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15753					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15754			001701		SN=SN+1
 15755			000000			ZZ=ZZ+ZZ
 15756			000001			IFE	ZZ,<ZZ=1>
 15757	040003	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15758	040004	316 00 0 00 070265 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15759						STOP		^
 15760	040005	254 04 0 00 040006 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15761	040006	324 00 0 00 040007 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15762									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15763									;IN THE SUBTEST) TO LOOP ON ERROR^
 15764
 15765					;**********
 15766
 15767
 15768					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15769					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15770					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15771					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15772			001702		SN=SN+1
 15773			000002			ZZ=ZZ+ZZ
 15774						IFE	ZZ,<ZZ=1>
 15775	040007	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15776	040010	316 00 0 00 070266 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15777						STOP		^
 15778	040011	254 04 0 00 040012 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15779	040012	324 00 0 00 040013 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15780									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15781									;IN THE SUBTEST) TO LOOP ON ERROR^
 15782
 15783					;**********
 15784
 15785
 15786					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0341

 15787					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15788					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15789					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15790			001703		SN=SN+1
 15791			000004			ZZ=ZZ+ZZ
 15792						IFE	ZZ,<ZZ=1>
 15793	040013	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15794	040014	316 00 0 00 070267 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15795						STOP		^
 15796	040015	254 04 0 00 040016 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15797	040016	324 00 0 00 040017 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15798									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15799									;IN THE SUBTEST) TO LOOP ON ERROR^
 15800
 15801					;**********
 15802
 15803
 15804					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15805					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15806					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15807					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15808			001704		SN=SN+1
 15809			000010			ZZ=ZZ+ZZ
 15810						IFE	ZZ,<ZZ=1>
 15811	040017	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15812	040020	316 00 0 00 070270 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15813						STOP		^
 15814	040021	254 04 0 00 040022 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15815	040022	324 00 0 00 040023 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15816									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15817									;IN THE SUBTEST) TO LOOP ON ERROR^
 15818
 15819					;**********
 15820
 15821
 15822					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15823					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15824					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15825					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15826			001705		SN=SN+1
 15827			000020			ZZ=ZZ+ZZ
 15828						IFE	ZZ,<ZZ=1>
 15829	040023	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15830	040024	316 00 0 00 070271 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15831						STOP		^
 15832	040025	254 04 0 00 040026 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15833	040026	324 00 0 00 040027 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15834									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15835									;IN THE SUBTEST) TO LOOP ON ERROR^
 15836
 15837					;**********
 15838
 15839
 15840					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15841					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0342

 15842					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15843					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15844			001706		SN=SN+1
 15845			000040			ZZ=ZZ+ZZ
 15846						IFE	ZZ,<ZZ=1>
 15847	040027	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15848	040030	316 00 0 00 070272 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15849						STOP		^
 15850	040031	254 04 0 00 040032 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15851	040032	324 00 0 00 040033 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15852									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15853									;IN THE SUBTEST) TO LOOP ON ERROR^
 15854
 15855					;**********
 15856
 15857
 15858					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15859					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15860					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15861					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15862			001707		SN=SN+1
 15863			000100			ZZ=ZZ+ZZ
 15864						IFE	ZZ,<ZZ=1>
 15865	040033	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15866	040034	316 00 0 00 070273 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15867						STOP		^
 15868	040035	254 04 0 00 040036 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15869	040036	324 00 0 00 040037 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15870									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15871									;IN THE SUBTEST) TO LOOP ON ERROR^
 15872
 15873					;**********
 15874
 15875
 15876					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15877					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15878					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15879					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15880			001710		SN=SN+1
 15881			000200			ZZ=ZZ+ZZ
 15882						IFE	ZZ,<ZZ=1>
 15883	040037	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15884	040040	316 00 0 00 070274 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15885						STOP		^
 15886	040041	254 04 0 00 040042 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15887	040042	324 00 0 00 040043 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15888									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15889									;IN THE SUBTEST) TO LOOP ON ERROR^
 15890
 15891					;**********
 15892
 15893
 15894					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15895					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15896					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0343

 15897					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15898			001711		SN=SN+1
 15899			000400			ZZ=ZZ+ZZ
 15900						IFE	ZZ,<ZZ=1>
 15901	040043	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15902	040044	316 00 0 00 070275 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15903						STOP		^
 15904	040045	254 04 0 00 040046 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15905	040046	324 00 0 00 040047 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15906									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15907									;IN THE SUBTEST) TO LOOP ON ERROR^
 15908
 15909					;**********
 15910
 15911
 15912					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15913					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15914					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15915					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15916			001712		SN=SN+1
 15917			001000			ZZ=ZZ+ZZ
 15918						IFE	ZZ,<ZZ=1>
 15919	040047	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15920	040050	316 00 0 00 070276 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15921						STOP		^
 15922	040051	254 04 0 00 040052 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15923	040052	324 00 0 00 040053 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15924									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15925									;IN THE SUBTEST) TO LOOP ON ERROR^
 15926
 15927					;**********
 15928
 15929
 15930					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15931					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15932					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15933					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15934			001713		SN=SN+1
 15935			002000			ZZ=ZZ+ZZ
 15936						IFE	ZZ,<ZZ=1>
 15937	040053	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15938	040054	316 00 0 00 070277 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15939						STOP		^
 15940	040055	254 04 0 00 040056 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15941	040056	324 00 0 00 040057 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15942									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15943									;IN THE SUBTEST) TO LOOP ON ERROR^
 15944
 15945					;**********
 15946
 15947
 15948					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15949					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15950					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15951					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0344

 15952			001714		SN=SN+1
 15953			004000			ZZ=ZZ+ZZ
 15954						IFE	ZZ,<ZZ=1>
 15955	040057	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15956	040060	316 00 0 00 070300 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15957						STOP		^
 15958	040061	254 04 0 00 040062 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15959	040062	324 00 0 00 040063 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15960									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15961									;IN THE SUBTEST) TO LOOP ON ERROR^
 15962
 15963					;**********
 15964
 15965
 15966					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15967					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15968					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15969					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15970			001715		SN=SN+1
 15971			010000			ZZ=ZZ+ZZ
 15972						IFE	ZZ,<ZZ=1>
 15973	040063	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15974	040064	316 00 0 00 070301 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15975						STOP		^
 15976	040065	254 04 0 00 040066 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15977	040066	324 00 0 00 040067 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15978									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15979									;IN THE SUBTEST) TO LOOP ON ERROR^
 15980
 15981					;**********
 15982
 15983
 15984					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 15985					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 15986					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 15987					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 15988			001716		SN=SN+1
 15989			020000			ZZ=ZZ+ZZ
 15990						IFE	ZZ,<ZZ=1>
 15991	040067	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 15992	040070	316 00 0 00 070302 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 15993						STOP		^
 15994	040071	254 04 0 00 040072 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 15995	040072	324 00 0 00 040073 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 15996									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 15997									;IN THE SUBTEST) TO LOOP ON ERROR^
 15998
 15999					;**********
 16000
 16001
 16002					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16003					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16004					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16005					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16006			001717		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0345

 16007			040000			ZZ=ZZ+ZZ
 16008						IFE	ZZ,<ZZ=1>
 16009	040073	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16010	040074	316 00 0 00 070303 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16011						STOP		^
 16012	040075	254 04 0 00 040076 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16013	040076	324 00 0 00 040077 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16014									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16015									;IN THE SUBTEST) TO LOOP ON ERROR^
 16016
 16017					;**********
 16018
 16019
 16020					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16021					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16022					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16023					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16024			001720		SN=SN+1
 16025			100000			ZZ=ZZ+ZZ
 16026						IFE	ZZ,<ZZ=1>
 16027	040077	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16028	040100	316 00 0 00 070304 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16029						STOP		^
 16030	040101	254 04 0 00 040102 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16031	040102	324 00 0 00 040103 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16032									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16033									;IN THE SUBTEST) TO LOOP ON ERROR^
 16034
 16035					;**********
 16036
 16037
 16038					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16039					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16040					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16041					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16042			001721		SN=SN+1
 16043			200000			ZZ=ZZ+ZZ
 16044						IFE	ZZ,<ZZ=1>
 16045	040103	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16046	040104	316 00 0 00 070305 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16047						STOP		^
 16048	040105	254 04 0 00 040106 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16049	040106	324 00 0 00 040107 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16050									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16051									;IN THE SUBTEST) TO LOOP ON ERROR^
 16052
 16053					;**********
 16054
 16055
 16056					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16057					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16058					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16059					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16060			001722		SN=SN+1
 16061			400000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0346

 16062						IFE	ZZ,<ZZ=1>
 16063	040107	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16064	040110	316 00 0 00 070306 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16065						STOP		^
 16066	040111	254 04 0 00 040112 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16067	040112	324 00 0 00 040113 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16068									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16069									;IN THE SUBTEST) TO LOOP ON ERROR^
 16070
 16071					;**********
 16072
 16073
 16074					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16075					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16076					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16077					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16078			001723		SN=SN+1
 16079		000001	000000			ZZ=ZZ+ZZ
 16080						IFE	ZZ,<ZZ=1>
 16081	040113	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16082	040114	316 00 0 00 070307 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16083						STOP		^
 16084	040115	254 04 0 00 040116 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16085	040116	324 00 0 00 040117 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16086									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16087									;IN THE SUBTEST) TO LOOP ON ERROR^
 16088
 16089					;**********
 16090
 16091
 16092					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16093					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16094					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16095					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16096			001724		SN=SN+1
 16097		000002	000000			ZZ=ZZ+ZZ
 16098						IFE	ZZ,<ZZ=1>
 16099	040117	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16100	040120	316 00 0 00 070310 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16101						STOP		^
 16102	040121	254 04 0 00 040122 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16103	040122	324 00 0 00 040123 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16104									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16105									;IN THE SUBTEST) TO LOOP ON ERROR^
 16106
 16107					;**********
 16108
 16109
 16110					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16111					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16112					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16113					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16114			001725		SN=SN+1
 16115		000004	000000			ZZ=ZZ+ZZ
 16116						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0347

 16117	040123	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16118	040124	316 00 0 00 070311 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16119						STOP		^
 16120	040125	254 04 0 00 040126 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16121	040126	324 00 0 00 040127 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16122									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16123									;IN THE SUBTEST) TO LOOP ON ERROR^
 16124
 16125					;**********
 16126
 16127
 16128					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16129					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16130					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16131					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16132			001726		SN=SN+1
 16133		000010	000000			ZZ=ZZ+ZZ
 16134						IFE	ZZ,<ZZ=1>
 16135	040127	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16136	040130	316 00 0 00 070312 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16137						STOP		^
 16138	040131	254 04 0 00 040132 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16139	040132	324 00 0 00 040133 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16140									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16141									;IN THE SUBTEST) TO LOOP ON ERROR^
 16142
 16143					;**********
 16144
 16145
 16146					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16147					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16148					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16149					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16150			001727		SN=SN+1
 16151		000020	000000			ZZ=ZZ+ZZ
 16152						IFE	ZZ,<ZZ=1>
 16153	040133	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16154	040134	316 00 0 00 070313 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16155						STOP		^
 16156	040135	254 04 0 00 040136 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16157	040136	324 00 0 00 040137 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16158									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16159									;IN THE SUBTEST) TO LOOP ON ERROR^
 16160
 16161					;**********
 16162
 16163
 16164					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16165					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16166					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16167					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16168			001730		SN=SN+1
 16169		000040	000000			ZZ=ZZ+ZZ
 16170						IFE	ZZ,<ZZ=1>
 16171	040137	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0348

 16172	040140	316 00 0 00 070314 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16173						STOP		^
 16174	040141	254 04 0 00 040142 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16175	040142	324 00 0 00 040143 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16176									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16177									;IN THE SUBTEST) TO LOOP ON ERROR^
 16178
 16179					;**********
 16180
 16181
 16182					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16183					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16184					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16185					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16186			001731		SN=SN+1
 16187		000100	000000			ZZ=ZZ+ZZ
 16188						IFE	ZZ,<ZZ=1>
 16189	040143	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16190	040144	316 00 0 00 070315 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16191						STOP		^
 16192	040145	254 04 0 00 040146 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16193	040146	324 00 0 00 040147 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16194									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16195									;IN THE SUBTEST) TO LOOP ON ERROR^
 16196
 16197					;**********
 16198
 16199
 16200					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16201					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16202					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16203					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16204			001732		SN=SN+1
 16205		000200	000000			ZZ=ZZ+ZZ
 16206						IFE	ZZ,<ZZ=1>
 16207	040147	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16208	040150	316 00 0 00 070316 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16209						STOP		^
 16210	040151	254 04 0 00 040152 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16211	040152	324 00 0 00 040153 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16212									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16213									;IN THE SUBTEST) TO LOOP ON ERROR^
 16214
 16215					;**********
 16216
 16217
 16218					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16219					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16220					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16221					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16222			001733		SN=SN+1
 16223		000400	000000			ZZ=ZZ+ZZ
 16224						IFE	ZZ,<ZZ=1>
 16225	040153	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16226	040154	316 00 0 00 070264 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0349

 16227						STOP		^
 16228	040155	254 04 0 00 040156 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16229	040156	324 00 0 00 040157 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16230									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16231									;IN THE SUBTEST) TO LOOP ON ERROR^
 16232
 16233					;**********
 16234
 16235
 16236					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16237					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16238					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16239					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16240			001734		SN=SN+1
 16241		001000	000000			ZZ=ZZ+ZZ
 16242						IFE	ZZ,<ZZ=1>
 16243	040157	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16244	040160	316 00 0 00 070317 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16245						STOP		^
 16246	040161	254 04 0 00 040162 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16247	040162	324 00 0 00 040163 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16248									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16249									;IN THE SUBTEST) TO LOOP ON ERROR^
 16250
 16251					;**********
 16252
 16253
 16254					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16255					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16256					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16257					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16258			001735		SN=SN+1
 16259		002000	000000			ZZ=ZZ+ZZ
 16260						IFE	ZZ,<ZZ=1>
 16261	040163	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16262	040164	316 00 0 00 070320 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16263						STOP		^
 16264	040165	254 04 0 00 040166 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16265	040166	324 00 0 00 040167 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16266									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16267									;IN THE SUBTEST) TO LOOP ON ERROR^
 16268
 16269					;**********
 16270
 16271
 16272					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16273					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16274					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16275					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16276			001736		SN=SN+1
 16277		004000	000000			ZZ=ZZ+ZZ
 16278						IFE	ZZ,<ZZ=1>
 16279	040167	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16280	040170	316 00 0 00 070321 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16281						STOP		^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0350

 16282	040171	254 04 0 00 040172 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16283	040172	324 00 0 00 040173 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16284									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16285									;IN THE SUBTEST) TO LOOP ON ERROR^
 16286
 16287					;**********
 16288
 16289
 16290					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16291					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16292					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16293					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16294			001737		SN=SN+1
 16295		010000	000000			ZZ=ZZ+ZZ
 16296						IFE	ZZ,<ZZ=1>
 16297	040173	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16298	040174	316 00 0 00 070322 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16299						STOP		^
 16300	040175	254 04 0 00 040176 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16301	040176	324 00 0 00 040177 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16302									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16303									;IN THE SUBTEST) TO LOOP ON ERROR^
 16304
 16305					;**********
 16306
 16307
 16308					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16309					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16310					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16311					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16312			001740		SN=SN+1
 16313		020000	000000			ZZ=ZZ+ZZ
 16314						IFE	ZZ,<ZZ=1>
 16315	040177	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16316	040200	316 00 0 00 070323 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16317						STOP		^
 16318	040201	254 04 0 00 040202 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16319	040202	324 00 0 00 040203 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16320									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16321									;IN THE SUBTEST) TO LOOP ON ERROR^
 16322
 16323					;**********
 16324
 16325
 16326					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16327					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16328					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16329					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16330			001741		SN=SN+1
 16331		040000	000000			ZZ=ZZ+ZZ
 16332						IFE	ZZ,<ZZ=1>
 16333	040203	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16334	040204	316 00 0 00 070324 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16335						STOP		^
 16336	040205	254 04 0 00 040206 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0351

 16337	040206	324 00 0 00 040207 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16338									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16339									;IN THE SUBTEST) TO LOOP ON ERROR^
 16340
 16341					;**********
 16342
 16343
 16344					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16345					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16346					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16347					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16348			001742		SN=SN+1
 16349		100000	000000			ZZ=ZZ+ZZ
 16350						IFE	ZZ,<ZZ=1>
 16351	040207	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16352	040210	316 00 0 00 070325 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16353						STOP		^
 16354	040211	254 04 0 00 040212 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16355	040212	324 00 0 00 040213 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16356									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16357									;IN THE SUBTEST) TO LOOP ON ERROR^
 16358
 16359					;**********
 16360
 16361
 16362					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16363					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16364					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16365					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16366			001743		SN=SN+1
 16367		200000	000000			ZZ=ZZ+ZZ
 16368						IFE	ZZ,<ZZ=1>
 16369	040213	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16370	040214	316 00 0 00 070326 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16371						STOP		^
 16372	040215	254 04 0 00 040216 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16373	040216	324 00 0 00 040217 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16374									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16375									;IN THE SUBTEST) TO LOOP ON ERROR^
 16376
 16377					;**********
 16378
 16379
 16380					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT INSTRUCTION WHEN AND
 16381					;ONLY WHEN C(AC)=0 AND C(E)=FLOATING 1.  HENCE,
 16382					;CAMN SHOULD SKIP;  OTHERWISE, THE PROGRAM HALTS
 16383					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF E
 16384			001744		SN=SN+1
 16385		400000	000000			ZZ=ZZ+ZZ
 16386						IFE	ZZ,<ZZ=1>
 16387	040217	400 00 0 00 000000 		SETZ			;PRELOAD AC WITH 0
 16388	040220	316 00 0 00 070256 		CAMN	[ZZ]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16389						STOP		^
 16390	040221	254 04 0 00 040222 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16391	040222	324 00 0 00 040223 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 24-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0352

 16392									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16393									;IN THE SUBTEST) TO LOOP ON ERROR^
 16394
 16395					;**********
 16396
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0353

 16397			002000		SN=2000
 16398			000000			ZZ=0
 16399
 16400					B2000:	REPEAT	^D36,<
 16401					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16402					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16403					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16404					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16405					SN=SN+1
 16406						ZZ=ZZ+ZZ
 16407						IFE	ZZ,<ZZ=1>
 16408						MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16409						CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16410						STOP
 16411					
 16412					;**********
 16413					>
 16414
 16415					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16416					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16417					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16418					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16419			002001		SN=SN+1
 16420			000000			ZZ=ZZ+ZZ
 16421			000001			IFE	ZZ,<ZZ=1>
 16422	040223	200 00 0 00 070265 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16423	040224	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16424						STOP^
 16425	040225	254 04 0 00 040226 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16426	040226	324 00 0 00 040227 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16427									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16428									;IN THE SUBTEST) TO LOOP ON ERROR^
 16429
 16430					;**********
 16431
 16432
 16433					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16434					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16435					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16436					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16437			002002		SN=SN+1
 16438			000002			ZZ=ZZ+ZZ
 16439						IFE	ZZ,<ZZ=1>
 16440	040227	200 00 0 00 070266 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16441	040230	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16442						STOP^
 16443	040231	254 04 0 00 040232 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16444	040232	324 00 0 00 040233 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16445									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16446									;IN THE SUBTEST) TO LOOP ON ERROR^
 16447
 16448					;**********
 16449
 16450
 16451					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0354

 16452					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16453					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16454					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16455			002003		SN=SN+1
 16456			000004			ZZ=ZZ+ZZ
 16457						IFE	ZZ,<ZZ=1>
 16458	040233	200 00 0 00 070267 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16459	040234	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16460						STOP^
 16461	040235	254 04 0 00 040236 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16462	040236	324 00 0 00 040237 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16463									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16464									;IN THE SUBTEST) TO LOOP ON ERROR^
 16465
 16466					;**********
 16467
 16468
 16469					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16470					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16471					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16472					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16473			002004		SN=SN+1
 16474			000010			ZZ=ZZ+ZZ
 16475						IFE	ZZ,<ZZ=1>
 16476	040237	200 00 0 00 070270 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16477	040240	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16478						STOP^
 16479	040241	254 04 0 00 040242 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16480	040242	324 00 0 00 040243 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16481									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16482									;IN THE SUBTEST) TO LOOP ON ERROR^
 16483
 16484					;**********
 16485
 16486
 16487					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16488					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16489					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16490					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16491			002005		SN=SN+1
 16492			000020			ZZ=ZZ+ZZ
 16493						IFE	ZZ,<ZZ=1>
 16494	040243	200 00 0 00 070271 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16495	040244	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16496						STOP^
 16497	040245	254 04 0 00 040246 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16498	040246	324 00 0 00 040247 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16499									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16500									;IN THE SUBTEST) TO LOOP ON ERROR^
 16501
 16502					;**********
 16503
 16504
 16505					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16506					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0355

 16507					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16508					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16509			002006		SN=SN+1
 16510			000040			ZZ=ZZ+ZZ
 16511						IFE	ZZ,<ZZ=1>
 16512	040247	200 00 0 00 070272 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16513	040250	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16514						STOP^
 16515	040251	254 04 0 00 040252 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16516	040252	324 00 0 00 040253 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16517									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16518									;IN THE SUBTEST) TO LOOP ON ERROR^
 16519
 16520					;**********
 16521
 16522
 16523					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16524					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16525					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16526					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16527			002007		SN=SN+1
 16528			000100			ZZ=ZZ+ZZ
 16529						IFE	ZZ,<ZZ=1>
 16530	040253	200 00 0 00 070273 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16531	040254	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16532						STOP^
 16533	040255	254 04 0 00 040256 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16534	040256	324 00 0 00 040257 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16535									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16536									;IN THE SUBTEST) TO LOOP ON ERROR^
 16537
 16538					;**********
 16539
 16540
 16541					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16542					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16543					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16544					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16545			002010		SN=SN+1
 16546			000200			ZZ=ZZ+ZZ
 16547						IFE	ZZ,<ZZ=1>
 16548	040257	200 00 0 00 070274 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16549	040260	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16550						STOP^
 16551	040261	254 04 0 00 040262 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16552	040262	324 00 0 00 040263 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16553									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16554									;IN THE SUBTEST) TO LOOP ON ERROR^
 16555
 16556					;**********
 16557
 16558
 16559					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16560					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16561					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0356

 16562					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16563			002011		SN=SN+1
 16564			000400			ZZ=ZZ+ZZ
 16565						IFE	ZZ,<ZZ=1>
 16566	040263	200 00 0 00 070275 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16567	040264	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16568						STOP^
 16569	040265	254 04 0 00 040266 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16570	040266	324 00 0 00 040267 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16571									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16572									;IN THE SUBTEST) TO LOOP ON ERROR^
 16573
 16574					;**********
 16575
 16576
 16577					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16578					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16579					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16580					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16581			002012		SN=SN+1
 16582			001000			ZZ=ZZ+ZZ
 16583						IFE	ZZ,<ZZ=1>
 16584	040267	200 00 0 00 070276 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16585	040270	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16586						STOP^
 16587	040271	254 04 0 00 040272 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16588	040272	324 00 0 00 040273 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16589									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16590									;IN THE SUBTEST) TO LOOP ON ERROR^
 16591
 16592					;**********
 16593
 16594
 16595					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16596					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16597					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16598					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16599			002013		SN=SN+1
 16600			002000			ZZ=ZZ+ZZ
 16601						IFE	ZZ,<ZZ=1>
 16602	040273	200 00 0 00 070277 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16603	040274	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16604						STOP^
 16605	040275	254 04 0 00 040276 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16606	040276	324 00 0 00 040277 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16607									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16608									;IN THE SUBTEST) TO LOOP ON ERROR^
 16609
 16610					;**********
 16611
 16612
 16613					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16614					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16615					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16616					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0357

 16617			002014		SN=SN+1
 16618			004000			ZZ=ZZ+ZZ
 16619						IFE	ZZ,<ZZ=1>
 16620	040277	200 00 0 00 070300 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16621	040300	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16622						STOP^
 16623	040301	254 04 0 00 040302 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16624	040302	324 00 0 00 040303 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16625									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16626									;IN THE SUBTEST) TO LOOP ON ERROR^
 16627
 16628					;**********
 16629
 16630
 16631					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16632					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16633					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16634					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16635			002015		SN=SN+1
 16636			010000			ZZ=ZZ+ZZ
 16637						IFE	ZZ,<ZZ=1>
 16638	040303	200 00 0 00 070301 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16639	040304	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16640						STOP^
 16641	040305	254 04 0 00 040306 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16642	040306	324 00 0 00 040307 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16643									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16644									;IN THE SUBTEST) TO LOOP ON ERROR^
 16645
 16646					;**********
 16647
 16648
 16649					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16650					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16651					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16652					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16653			002016		SN=SN+1
 16654			020000			ZZ=ZZ+ZZ
 16655						IFE	ZZ,<ZZ=1>
 16656	040307	200 00 0 00 070302 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16657	040310	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16658						STOP^
 16659	040311	254 04 0 00 040312 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16660	040312	324 00 0 00 040313 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16661									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16662									;IN THE SUBTEST) TO LOOP ON ERROR^
 16663
 16664					;**********
 16665
 16666
 16667					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16668					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16669					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16670					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16671			002017		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0358

 16672			040000			ZZ=ZZ+ZZ
 16673						IFE	ZZ,<ZZ=1>
 16674	040313	200 00 0 00 070303 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16675	040314	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16676						STOP^
 16677	040315	254 04 0 00 040316 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16678	040316	324 00 0 00 040317 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16679									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16680									;IN THE SUBTEST) TO LOOP ON ERROR^
 16681
 16682					;**********
 16683
 16684
 16685					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16686					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16687					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16688					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16689			002020		SN=SN+1
 16690			100000			ZZ=ZZ+ZZ
 16691						IFE	ZZ,<ZZ=1>
 16692	040317	200 00 0 00 070304 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16693	040320	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16694						STOP^
 16695	040321	254 04 0 00 040322 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16696	040322	324 00 0 00 040323 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16697									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16698									;IN THE SUBTEST) TO LOOP ON ERROR^
 16699
 16700					;**********
 16701
 16702
 16703					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16704					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16705					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16706					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16707			002021		SN=SN+1
 16708			200000			ZZ=ZZ+ZZ
 16709						IFE	ZZ,<ZZ=1>
 16710	040323	200 00 0 00 070305 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16711	040324	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16712						STOP^
 16713	040325	254 04 0 00 040326 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16714	040326	324 00 0 00 040327 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16715									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16716									;IN THE SUBTEST) TO LOOP ON ERROR^
 16717
 16718					;**********
 16719
 16720
 16721					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16722					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16723					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16724					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16725			002022		SN=SN+1
 16726			400000			ZZ=ZZ+ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0359

 16727						IFE	ZZ,<ZZ=1>
 16728	040327	200 00 0 00 070306 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16729	040330	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16730						STOP^
 16731	040331	254 04 0 00 040332 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16732	040332	324 00 0 00 040333 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16733									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16734									;IN THE SUBTEST) TO LOOP ON ERROR^
 16735
 16736					;**********
 16737
 16738
 16739					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16740					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16741					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16742					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16743			002023		SN=SN+1
 16744		000001	000000			ZZ=ZZ+ZZ
 16745						IFE	ZZ,<ZZ=1>
 16746	040333	200 00 0 00 070307 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16747	040334	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16748						STOP^
 16749	040335	254 04 0 00 040336 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16750	040336	324 00 0 00 040337 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16751									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16752									;IN THE SUBTEST) TO LOOP ON ERROR^
 16753
 16754					;**********
 16755
 16756
 16757					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16758					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16759					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16760					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16761			002024		SN=SN+1
 16762		000002	000000			ZZ=ZZ+ZZ
 16763						IFE	ZZ,<ZZ=1>
 16764	040337	200 00 0 00 070310 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16765	040340	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16766						STOP^
 16767	040341	254 04 0 00 040342 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16768	040342	324 00 0 00 040343 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16769									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16770									;IN THE SUBTEST) TO LOOP ON ERROR^
 16771
 16772					;**********
 16773
 16774
 16775					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16776					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16777					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16778					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16779			002025		SN=SN+1
 16780		000004	000000			ZZ=ZZ+ZZ
 16781						IFE	ZZ,<ZZ=1>
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-7
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0360

 16782	040343	200 00 0 00 070311 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16783	040344	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16784						STOP^
 16785	040345	254 04 0 00 040346 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16786	040346	324 00 0 00 040347 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16787									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16788									;IN THE SUBTEST) TO LOOP ON ERROR^
 16789
 16790					;**********
 16791
 16792
 16793					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16794					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16795					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16796					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16797			002026		SN=SN+1
 16798		000010	000000			ZZ=ZZ+ZZ
 16799						IFE	ZZ,<ZZ=1>
 16800	040347	200 00 0 00 070312 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16801	040350	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16802						STOP^
 16803	040351	254 04 0 00 040352 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16804	040352	324 00 0 00 040353 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16805									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16806									;IN THE SUBTEST) TO LOOP ON ERROR^
 16807
 16808					;**********
 16809
 16810
 16811					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16812					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16813					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16814					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16815			002027		SN=SN+1
 16816		000020	000000			ZZ=ZZ+ZZ
 16817						IFE	ZZ,<ZZ=1>
 16818	040353	200 00 0 00 070313 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16819	040354	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16820						STOP^
 16821	040355	254 04 0 00 040356 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16822	040356	324 00 0 00 040357 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16823									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16824									;IN THE SUBTEST) TO LOOP ON ERROR^
 16825
 16826					;**********
 16827
 16828
 16829					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16830					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16831					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16832					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16833			002030		SN=SN+1
 16834		000040	000000			ZZ=ZZ+ZZ
 16835						IFE	ZZ,<ZZ=1>
 16836	040357	200 00 0 00 070314 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-8
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0361

 16837	040360	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16838						STOP^
 16839	040361	254 04 0 00 040362 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16840	040362	324 00 0 00 040363 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16841									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16842									;IN THE SUBTEST) TO LOOP ON ERROR^
 16843
 16844					;**********
 16845
 16846
 16847					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16848					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16849					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16850					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16851			002031		SN=SN+1
 16852		000100	000000			ZZ=ZZ+ZZ
 16853						IFE	ZZ,<ZZ=1>
 16854	040363	200 00 0 00 070315 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16855	040364	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16856						STOP^
 16857	040365	254 04 0 00 040366 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16858	040366	324 00 0 00 040367 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16859									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16860									;IN THE SUBTEST) TO LOOP ON ERROR^
 16861
 16862					;**********
 16863
 16864
 16865					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16866					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16867					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16868					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16869			002032		SN=SN+1
 16870		000200	000000			ZZ=ZZ+ZZ
 16871						IFE	ZZ,<ZZ=1>
 16872	040367	200 00 0 00 070316 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16873	040370	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16874						STOP^
 16875	040371	254 04 0 00 040372 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16876	040372	324 00 0 00 040373 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16877									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16878									;IN THE SUBTEST) TO LOOP ON ERROR^
 16879
 16880					;**********
 16881
 16882
 16883					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16884					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16885					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16886					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16887			002033		SN=SN+1
 16888		000400	000000			ZZ=ZZ+ZZ
 16889						IFE	ZZ,<ZZ=1>
 16890	040373	200 00 0 00 070264 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16891	040374	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-9
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0362

 16892						STOP^
 16893	040375	254 04 0 00 040376 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16894	040376	324 00 0 00 040377 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16895									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16896									;IN THE SUBTEST) TO LOOP ON ERROR^
 16897
 16898					;**********
 16899
 16900
 16901					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16902					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16903					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16904					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16905			002034		SN=SN+1
 16906		001000	000000			ZZ=ZZ+ZZ
 16907						IFE	ZZ,<ZZ=1>
 16908	040377	200 00 0 00 070317 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16909	040400	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16910						STOP^
 16911	040401	254 04 0 00 040402 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16912	040402	324 00 0 00 040403 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16913									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16914									;IN THE SUBTEST) TO LOOP ON ERROR^
 16915
 16916					;**********
 16917
 16918
 16919					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16920					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16921					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16922					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16923			002035		SN=SN+1
 16924		002000	000000			ZZ=ZZ+ZZ
 16925						IFE	ZZ,<ZZ=1>
 16926	040403	200 00 0 00 070320 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16927	040404	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16928						STOP^
 16929	040405	254 04 0 00 040406 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16930	040406	324 00 0 00 040407 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16931									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16932									;IN THE SUBTEST) TO LOOP ON ERROR^
 16933
 16934					;**********
 16935
 16936
 16937					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16938					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16939					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16940					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16941			002036		SN=SN+1
 16942		004000	000000			ZZ=ZZ+ZZ
 16943						IFE	ZZ,<ZZ=1>
 16944	040407	200 00 0 00 070321 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16945	040410	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16946						STOP^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-10
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0363

 16947	040411	254 04 0 00 040412 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16948	040412	324 00 0 00 040413 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16949									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16950									;IN THE SUBTEST) TO LOOP ON ERROR^
 16951
 16952					;**********
 16953
 16954
 16955					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16956					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16957					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16958					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16959			002037		SN=SN+1
 16960		010000	000000			ZZ=ZZ+ZZ
 16961						IFE	ZZ,<ZZ=1>
 16962	040413	200 00 0 00 070322 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16963	040414	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16964						STOP^
 16965	040415	254 04 0 00 040416 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16966	040416	324 00 0 00 040417 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16967									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16968									;IN THE SUBTEST) TO LOOP ON ERROR^
 16969
 16970					;**********
 16971
 16972
 16973					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16974					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16975					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16976					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16977			002040		SN=SN+1
 16978		020000	000000			ZZ=ZZ+ZZ
 16979						IFE	ZZ,<ZZ=1>
 16980	040417	200 00 0 00 070323 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16981	040420	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 16982						STOP^
 16983	040421	254 04 0 00 040422 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 16984	040422	324 00 0 00 040423 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 16985									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 16986									;IN THE SUBTEST) TO LOOP ON ERROR^
 16987
 16988					;**********
 16989
 16990
 16991					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 16992					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 16993					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 16994					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 16995			002041		SN=SN+1
 16996		040000	000000			ZZ=ZZ+ZZ
 16997						IFE	ZZ,<ZZ=1>
 16998	040423	200 00 0 00 070324 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 16999	040424	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 17000						STOP^
 17001	040425	254 04 0 00 040426 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-11
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0364

 17002	040426	324 00 0 00 040427 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17003									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17004									;IN THE SUBTEST) TO LOOP ON ERROR^
 17005
 17006					;**********
 17007
 17008
 17009					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 17010					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 17011					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 17012					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 17013			002042		SN=SN+1
 17014		100000	000000			ZZ=ZZ+ZZ
 17015						IFE	ZZ,<ZZ=1>
 17016	040427	200 00 0 00 070325 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 17017	040430	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 17018						STOP^
 17019	040431	254 04 0 00 040432 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17020	040432	324 00 0 00 040433 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17021									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17022									;IN THE SUBTEST) TO LOOP ON ERROR^
 17023
 17024					;**********
 17025
 17026
 17027					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 17028					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 17029					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 17030					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 17031			002043		SN=SN+1
 17032		200000	000000			ZZ=ZZ+ZZ
 17033						IFE	ZZ,<ZZ=1>
 17034	040433	200 00 0 00 070326 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 17035	040434	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 17036						STOP^
 17037	040435	254 04 0 00 040436 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17038	040436	324 00 0 00 040437 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17039									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17040									;IN THE SUBTEST) TO LOOP ON ERROR^
 17041
 17042					;**********
 17043
 17044
 17045					;THIS TEST VERIFIES THAT CAMN SKIPS THE NEXT SEQUENTIAL INSTRUCTION WHEN AND
 17046					;ONLY WHEN C(AC) IS NOT EQUAL TO C(E).  HENCE,
 17047					;CAMN SHOULD SKIP;  OTHERWISE THE PROGRAM HALTS.
 17048					;THIS TEST IS REPEATED 36 TIMES TO FLOAT A 1 THRU ALL 36 BITS OF THE AC
 17049			002044		SN=SN+1
 17050		400000	000000			ZZ=ZZ+ZZ
 17051						IFE	ZZ,<ZZ=1>
 17052	040437	200 00 0 00 070256 		MOVE	[ZZ]		;PRELOAD AC WITH A FLOATING 1	
 17053	040440	316 00 0 00 070253 		CAMN	[0]		;*CAMN SHOULD SKIP BECAUSE C(AC) IS NOT EQUAL TO C(E)	
 17054						STOP^
 17055	040441	254 04 0 00 040442 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17056	040442	324 00 0 00 040443 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 25-12
DFKAA2	MAC	25-AUG-75 13:56		TEST OF COMPARE (CAMX) INSTRUCTIONS                                                SEQ 0365

 17057									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17058									;IN THE SUBTEST) TO LOOP ON ERROR^
 17059
 17060					;**********
 17061
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0366

 17062					SUBTTL	TEST OF MOVS INSTRUCTION
 17063
 17064					;**********
 17065
 17066			002100		SN=2100
 17067			000000			ZZ=0
 17068
 17069					B2100:	REPEAT	^D18,<
 17070					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17071					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17072					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17073					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17074					
 17075					SN=SN+1
 17076						ZZ=ZZ+ZZ
 17077						IFE	ZZ,<ZZ=1>
 17078						MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17079									;AND MOVE RESULT INTO AC
 17080						CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17081						STOP		
 17082					
 17083					;**********
 17084					>
 17085
 17086					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17087					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17088					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17089					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17090
 17091			002101		SN=SN+1
 17092			000000			ZZ=ZZ+ZZ
 17093			000001			IFE	ZZ,<ZZ=1>
 17094	040443	204 00 0 00 070251 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17095									;AND MOVE RESULT INTO AC
 17096	040444	312 00 0 00 070251 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17097						STOP		^
 17098	040445	254 04 0 00 040446 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17099	040446	324 00 0 00 040447 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17100									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17101									;IN THE SUBTEST) TO LOOP ON ERROR^
 17102
 17103					;**********
 17104
 17105
 17106					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17107					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17108					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17109					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17110
 17111			002102		SN=SN+1
 17112			000002			ZZ=ZZ+ZZ
 17113						IFE	ZZ,<ZZ=1>
 17114	040447	204 00 0 00 070440 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17115									;AND MOVE RESULT INTO AC
 17116	040450	312 00 0 00 070440 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0367

 17117						STOP		^
 17118	040451	254 04 0 00 040452 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17119	040452	324 00 0 00 040453 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17120									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17121									;IN THE SUBTEST) TO LOOP ON ERROR^
 17122
 17123					;**********
 17124
 17125
 17126					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17127					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17128					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17129					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17130
 17131			002103		SN=SN+1
 17132			000004			ZZ=ZZ+ZZ
 17133						IFE	ZZ,<ZZ=1>
 17134	040453	204 00 0 00 070441 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17135									;AND MOVE RESULT INTO AC
 17136	040454	312 00 0 00 070441 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17137						STOP		^
 17138	040455	254 04 0 00 040456 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17139	040456	324 00 0 00 040457 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17140									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17141									;IN THE SUBTEST) TO LOOP ON ERROR^
 17142
 17143					;**********
 17144
 17145
 17146					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17147					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17148					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17149					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17150
 17151			002104		SN=SN+1
 17152			000010			ZZ=ZZ+ZZ
 17153						IFE	ZZ,<ZZ=1>
 17154	040457	204 00 0 00 070442 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17155									;AND MOVE RESULT INTO AC
 17156	040460	312 00 0 00 070442 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17157						STOP		^
 17158	040461	254 04 0 00 040462 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17159	040462	324 00 0 00 040463 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17160									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17161									;IN THE SUBTEST) TO LOOP ON ERROR^
 17162
 17163					;**********
 17164
 17165
 17166					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17167					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17168					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17169					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17170
 17171			002105		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0368

 17172			000020			ZZ=ZZ+ZZ
 17173						IFE	ZZ,<ZZ=1>
 17174	040463	204 00 0 00 070443 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17175									;AND MOVE RESULT INTO AC
 17176	040464	312 00 0 00 070443 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17177						STOP		^
 17178	040465	254 04 0 00 040466 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17179	040466	324 00 0 00 040467 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17180									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17181									;IN THE SUBTEST) TO LOOP ON ERROR^
 17182
 17183					;**********
 17184
 17185
 17186					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17187					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17188					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17189					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17190
 17191			002106		SN=SN+1
 17192			000040			ZZ=ZZ+ZZ
 17193						IFE	ZZ,<ZZ=1>
 17194	040467	204 00 0 00 070444 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17195									;AND MOVE RESULT INTO AC
 17196	040470	312 00 0 00 070444 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17197						STOP		^
 17198	040471	254 04 0 00 040472 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17199	040472	324 00 0 00 040473 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17200									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17201									;IN THE SUBTEST) TO LOOP ON ERROR^
 17202
 17203					;**********
 17204
 17205
 17206					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17207					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17208					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17209					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17210
 17211			002107		SN=SN+1
 17212			000100			ZZ=ZZ+ZZ
 17213						IFE	ZZ,<ZZ=1>
 17214	040473	204 00 0 00 070445 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17215									;AND MOVE RESULT INTO AC
 17216	040474	312 00 0 00 070445 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17217						STOP		^
 17218	040475	254 04 0 00 040476 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17219	040476	324 00 0 00 040477 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17220									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17221									;IN THE SUBTEST) TO LOOP ON ERROR^
 17222
 17223					;**********
 17224
 17225
 17226					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-3
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0369

 17227					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17228					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17229					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17230
 17231			002110		SN=SN+1
 17232			000200			ZZ=ZZ+ZZ
 17233						IFE	ZZ,<ZZ=1>
 17234	040477	204 00 0 00 070446 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17235									;AND MOVE RESULT INTO AC
 17236	040500	312 00 0 00 070446 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17237						STOP		^
 17238	040501	254 04 0 00 040502 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17239	040502	324 00 0 00 040503 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17240									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17241									;IN THE SUBTEST) TO LOOP ON ERROR^
 17242
 17243					;**********
 17244
 17245
 17246					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17247					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17248					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17249					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17250
 17251			002111		SN=SN+1
 17252			000400			ZZ=ZZ+ZZ
 17253						IFE	ZZ,<ZZ=1>
 17254	040503	204 00 0 00 070447 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17255									;AND MOVE RESULT INTO AC
 17256	040504	312 00 0 00 070447 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17257						STOP		^
 17258	040505	254 04 0 00 040506 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17259	040506	324 00 0 00 040507 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17260									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17261									;IN THE SUBTEST) TO LOOP ON ERROR^
 17262
 17263					;**********
 17264
 17265
 17266					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17267					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17268					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17269					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17270
 17271			002112		SN=SN+1
 17272			001000			ZZ=ZZ+ZZ
 17273						IFE	ZZ,<ZZ=1>
 17274	040507	204 00 0 00 070450 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17275									;AND MOVE RESULT INTO AC
 17276	040510	312 00 0 00 070450 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17277						STOP		^
 17278	040511	254 04 0 00 040512 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17279	040512	324 00 0 00 040513 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17280									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17281									;IN THE SUBTEST) TO LOOP ON ERROR^
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-4
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0370

 17282
 17283					;**********
 17284
 17285
 17286					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17287					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17288					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17289					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17290
 17291			002113		SN=SN+1
 17292			002000			ZZ=ZZ+ZZ
 17293						IFE	ZZ,<ZZ=1>
 17294	040513	204 00 0 00 070451 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17295									;AND MOVE RESULT INTO AC
 17296	040514	312 00 0 00 070451 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17297						STOP		^
 17298	040515	254 04 0 00 040516 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17299	040516	324 00 0 00 040517 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17300									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17301									;IN THE SUBTEST) TO LOOP ON ERROR^
 17302
 17303					;**********
 17304
 17305
 17306					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17307					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17308					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17309					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17310
 17311			002114		SN=SN+1
 17312			004000			ZZ=ZZ+ZZ
 17313						IFE	ZZ,<ZZ=1>
 17314	040517	204 00 0 00 070452 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17315									;AND MOVE RESULT INTO AC
 17316	040520	312 00 0 00 070452 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17317						STOP		^
 17318	040521	254 04 0 00 040522 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17319	040522	324 00 0 00 040523 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17320									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17321									;IN THE SUBTEST) TO LOOP ON ERROR^
 17322
 17323					;**********
 17324
 17325
 17326					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17327					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17328					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17329					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17330
 17331			002115		SN=SN+1
 17332			010000			ZZ=ZZ+ZZ
 17333						IFE	ZZ,<ZZ=1>
 17334	040523	204 00 0 00 070453 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17335									;AND MOVE RESULT INTO AC
 17336	040524	312 00 0 00 070453 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-5
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0371

 17337						STOP		^
 17338	040525	254 04 0 00 040526 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17339	040526	324 00 0 00 040527 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17340									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17341									;IN THE SUBTEST) TO LOOP ON ERROR^
 17342
 17343					;**********
 17344
 17345
 17346					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17347					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17348					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17349					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17350
 17351			002116		SN=SN+1
 17352			020000			ZZ=ZZ+ZZ
 17353						IFE	ZZ,<ZZ=1>
 17354	040527	204 00 0 00 070454 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17355									;AND MOVE RESULT INTO AC
 17356	040530	312 00 0 00 070454 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17357						STOP		^
 17358	040531	254 04 0 00 040532 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17359	040532	324 00 0 00 040533 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17360									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17361									;IN THE SUBTEST) TO LOOP ON ERROR^
 17362
 17363					;**********
 17364
 17365
 17366					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17367					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17368					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17369					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17370
 17371			002117		SN=SN+1
 17372			040000			ZZ=ZZ+ZZ
 17373						IFE	ZZ,<ZZ=1>
 17374	040533	204 00 0 00 070455 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17375									;AND MOVE RESULT INTO AC
 17376	040534	312 00 0 00 070455 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17377						STOP		^
 17378	040535	254 04 0 00 040536 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17379	040536	324 00 0 00 040537 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17380									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17381									;IN THE SUBTEST) TO LOOP ON ERROR^
 17382
 17383					;**********
 17384
 17385
 17386					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17387					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17388					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17389					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17390
 17391			002120		SN=SN+1
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 26-6
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0372

 17392			100000			ZZ=ZZ+ZZ
 17393						IFE	ZZ,<ZZ=1>
 17394	040537	204 00 0 00 070456 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17395									;AND MOVE RESULT INTO AC
 17396	040540	312 00 0 00 070456 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17397						STOP		^
 17398	040541	254 04 0 00 040542 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17399	040542	324 00 0 00 040543 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17400									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17401									;IN THE SUBTEST) TO LOOP ON ERROR^
 17402
 17403					;**********
 17404
 17405
 17406					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17407					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17408					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17409					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17410
 17411			002121		SN=SN+1
 17412			200000			ZZ=ZZ+ZZ
 17413						IFE	ZZ,<ZZ=1>
 17414	040543	204 00 0 00 070457 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17415									;AND MOVE RESULT INTO AC
 17416	040544	312 00 0 00 070457 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17417						STOP		^
 17418	040545	254 04 0 00 040546 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17419	040546	324 00 0 00 040547 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17420									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17421									;IN THE SUBTEST) TO LOOP ON ERROR^
 17422
 17423					;**********
 17424
 17425
 17426					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17427					;MOVES IT INTO AC.  IN THIS CASE, A 1 IS RIPPLED THRU BOTH HALVES
 17428					;OF E [C(E)=ZZ,,ZZ WHERE ZZ IS A FLOATING 1].  THEN, C(AC) IS CHECKED.
 17429					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 1 THRU ALL 18 BITS OF EACH HALF
 17430
 17431			002122		SN=SN+1
 17432			400000			ZZ=ZZ+ZZ
 17433						IFE	ZZ,<ZZ=1>
 17434	040547	204 00 0 00 070460 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17435									;AND MOVE RESULT INTO AC
 17436	040550	312 00 0 00 070460 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF C(AC) CONTAINS ZZ,,ZZ
 17437						STOP		^
 17438	040551	254 04 0 00 040552 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17439	040552	324 00 0 00 040553 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17440									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17441									;IN THE SUBTEST) TO LOOP ON ERROR^
 17442
 17443					;**********
 17444
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0373

 17445			002200		SN=2200
 17446			000000			ZZ=0
 17447
 17448					B2200:	REPEAT	^D18,<
 17449					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17450					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17451					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17452					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17453					
 17454					SN=SN+1
 17455						ZZ=ZZ+ZZ+1
 17456						IFE	<ZZ-1>,<ZZ=-2>
 17457						MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17458									;AND MOVE RESULT INTO AC
 17459						CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17460						STOP		
 17461					
 17462					;**********
 17463					>
 17464
 17465					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17466					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17467					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17468					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17469
 17470			002201		SN=SN+1
 17471			000001			ZZ=ZZ+ZZ+1
 17472		777777	777776			IFE	<ZZ-1>,<ZZ=-2>
 17473	040553	204 00 0 00 070461 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17474									;AND MOVE RESULT INTO AC
 17475	040554	312 00 0 00 070461 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17476						STOP		^
 17477	040555	254 04 0 00 040556 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17478	040556	324 00 0 00 040557 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17479									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17480									;IN THE SUBTEST) TO LOOP ON ERROR^
 17481
 17482					;**********
 17483
 17484
 17485					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17486					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17487					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17488					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17489
 17490			002202		SN=SN+1
 17491		777777	777775			ZZ=ZZ+ZZ+1
 17492						IFE	<ZZ-1>,<ZZ=-2>
 17493	040557	204 00 0 00 070462 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17494									;AND MOVE RESULT INTO AC
 17495	040560	312 00 0 00 070462 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17496						STOP		^
 17497	040561	254 04 0 00 040562 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17498	040562	324 00 0 00 040563 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17499									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-1
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0374

 17500									;IN THE SUBTEST) TO LOOP ON ERROR^
 17501
 17502					;**********
 17503
 17504
 17505					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17506					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17507					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17508					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17509
 17510			002203		SN=SN+1
 17511		777777	777773			ZZ=ZZ+ZZ+1
 17512						IFE	<ZZ-1>,<ZZ=-2>
 17513	040563	204 00 0 00 070463 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17514									;AND MOVE RESULT INTO AC
 17515	040564	312 00 0 00 070463 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17516						STOP		^
 17517	040565	254 04 0 00 040566 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17518	040566	324 00 0 00 040567 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17519									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17520									;IN THE SUBTEST) TO LOOP ON ERROR^
 17521
 17522					;**********
 17523
 17524
 17525					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17526					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17527					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17528					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17529
 17530			002204		SN=SN+1
 17531		777777	777767			ZZ=ZZ+ZZ+1
 17532						IFE	<ZZ-1>,<ZZ=-2>
 17533	040567	204 00 0 00 070464 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17534									;AND MOVE RESULT INTO AC
 17535	040570	312 00 0 00 070464 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17536						STOP		^
 17537	040571	254 04 0 00 040572 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17538	040572	324 00 0 00 040573 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17539									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17540									;IN THE SUBTEST) TO LOOP ON ERROR^
 17541
 17542					;**********
 17543
 17544
 17545					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17546					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17547					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17548					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17549
 17550			002205		SN=SN+1
 17551		777777	777757			ZZ=ZZ+ZZ+1
 17552						IFE	<ZZ-1>,<ZZ=-2>
 17553	040573	204 00 0 00 070465 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17554									;AND MOVE RESULT INTO AC
DFKAA PDP-10 KL10 BASIC INSTRUCTION DIAGNOSTIC (1) VER 0,2	MACRO %52(537) 09:34 31-JAN-77 PAGE 27-2
DFKAA2	MAC	25-AUG-75 13:56		TEST OF MOVS INSTRUCTION                                                           SEQ 0375

 17555	040574	312 00 0 00 070465 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17556						STOP		^
 17557	040575	254 04 0 00 040576 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17558	040576	324 00 0 00 040577 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17559									;JUMPA X (X IS THE ADDRESS OF THE FIRST INSTRUCTION
 17560									;IN THE SUBTEST) TO LOOP ON ERROR^
 17561
 17562					;**********
 17563
 17564
 17565					;THIS TEST VERIFIES THAT MOVS SWAPS LEFT AND RIGHT HALVES OF E AND
 17566					;MOVES IT INTO AC.  IN THIS CASE, A 0 IS RIPPLED THRU BOTH HALVES
 17567					;OF E [C(E)=ZZ,,ZZ, WHERE ZZ IS A FLOATING 0].  THEN, C(AC) IS CHECKED.
 17568					;THIS TEST IS REPEATED 18 TIMES TO FLOAT A 0 THRU ALL 18 BITS OF EACH HALF
 17569
 17570			002206		SN=SN+1
 17571		777777	777737			ZZ=ZZ+ZZ+1
 17572						IFE	<ZZ-1>,<ZZ=-2>
 17573	040577	204 00 0 00 070466 		MOVS	[XWD ZZ,ZZ]	;*MOVS SHOULD SWAP HALVES OF C(E)
 17574									;AND MOVE RESULT INTO AC
 17575	040600	312 00 0 00 070466 		CAME	[XWD ZZ,ZZ]	;PASS TEST IF AC CONTAINS ZZ,,ZZ
 17576						STOP		^
 17577	040601	254 04 0 00 040602 		HALT	.+1		;TEST FAILED IF PROGRAM HALTS HERE
 17578	040602	324 00 0 00 040603 		JUMPA	.+1		;IF TEST FAILS, CHANGE THIS INSTRUCTION (JUMPA .+1) TO
 17579									;JUMPA X (X IS THE ADD