ER[DG0];

%TO ASSEMBLE:	@MI@ DGBASIC/L DGBASIC/B DG0 DG1 DG2B
		(USE DG2A INSTEAD OF DG2B ON MAXC1.)
TO RUN:		MIDAS RDG01
		START;G

DG0, THE MOST BASIC OF ALL SELF-TESTING MICROPROCESSOR DIAGNOSTICS,
TESTS ALMOST EVERYTHING EXCEPT THE MEMORIES, THE CYCLER AND ALU INPUTS TO THE
P-REGISTER, AND THOSE FUNCTIONS WHICH DEPEND UPON THE MEMORIES IN SOME
WAY.  ERRORS RESULT IN A HALT (BREAKPOINT).  MANY HALTS OCCUR AT THE
"CBRK" INSTRUCTION IN "DBEG0".  THESE ARE THE RESULT OF A CALL TO ONE
OF THE TEST ROUTINES, "PQCOMP", "AZT", "PEQZ", "QZT", "NQZT", "PZT",
OR "NPZT".  THE ADDRESS OF THE CALLER IS AT "STK 0" ON THE MIDAS DISPLAY.
%

INSERT[DBEG.MC];

TARGET[ILC];

BEGIN:	GOTO[TCALL], STEMP_ARM_NULL;
	BREAK;			*UNCONDITIONAL GOTO FAILED
TCALL1:	RETURN;
	BREAK;			*RETURN FAILED TO TAKE AT ALL
TCALL2:	P_STACK, Q_A0;
	B_P+1, NPC_B;
	Q_A1;			*GOING TO A RANDOM PLACE AFTER THIS INSTR.
				*MEANS THAT THE STACK FAILED TO HOLD THE
				*RETURN ADDRESS FOR THE CALL OR THAT P+1
				*FAILED OR THAT NPC_ FAILED.
	BREAK;			*NPC_ DIDN'T DO ANYTHING
TCALL:	CALL[.+2];
	BREAK;			*UNCONDITIONAL CALL FAILED TO JUMP
	CALL[TCALL2];
	BREAK;			*CALL OR P+1 FAILED
	DGOTO[.+2];
	GOTO[.+2];
	BREAK;			*UNCONDITIONAL DGOTO FAILED TO EXECUTE FOLLOWING
				*INSTRUCTION
	DGOTO[.+3];
	P_P1;
	BREAK;			*UNCONDITIONAL DGOTO FAILED
BR0:	P_Q_NULL;
	P#Q;
	CALL[CBRK,ALU#0], P#Q;	*GOTO TOOK WHEN BC ALU#0 WAS FALSE OR
				*P#Q FAILED OR P_Q_B FAILED ON 0
	CALL[CBRK,ALU#0], P#Q;	*P_P1 OR Q_Q FAILED ON 0
	GOTO[.+2,ALU=0];
	BREAK;			*P_Q_B, P#Q, ALU#0 OR ALU=0 BC FAILED
	P_Q_B, B_A1;
	P#Q;
	CALL[CBRK,ALU#0], P#Q;	*GOTO TOOK WHEN BC ALU#0 WAS FALSE OR P#Q
				*FAILED OR P_Q_B FAILED ON -1
	CALL[CBRK,ALU#0], P#Q;	*P_P1 OR Q_Q FAILED
	GOTO[.+2,ALU=0];
	BREAK;			*P_Q_B, P#Q, ALU#0 OR ALU=0 BC FAILED ON -1
	P_B, Q_B_A0, CALL[PQCOMP]; *Q_ALU, P_B, OR B_ALU FAILED ON 0
	P_B, Q_B_A1, CALL[PQCOMP]; *Q_ALU, P_B, OR B_ALU FAILED ON -1
*SO FAR ALL TESTS OF ALU=0 HAVE BEEN TRUE AND ALL TESTS OF ALU#0 FALSE.
*WE NOW ASSUME THAT ALU=0 WILL BE TRUE WHEN IT IS SUPPOSED TO BE TRUE
*BUT THERE REMAINS DANGER THAT IT WILL BE TRUE WHEN IT IS SUPPOSED TO BE
*FALSE.	REDUCE THIS DANGER BY CHECKING WITH THE P+1 AND 2P ALU FUNCTIONS
*WHICH HAVE NOT BEEN TESTED YET.
	P_NULL;
	B_P+1, P_B;

ALU0T:	P_B, B_2P, CALL[CBRK,ALU=0]; *P+1 FAILED ON P=0 OR ALU=0 FAILED ON 1
REPEAT[42,ILC[(P_B, B_2P, CALL[CBRK,ALU=0])]]; *2P, P+1, OR ALU=0 FAILED
				*IF [P] #0 THEN ALU=0 FAILED

*X>=0 AND X<0 BC TESTS HERE, NOT COMPLETELY TESTED UNTIL LATER
XBCT:	X_NULL;
	GOTO[.+2,X>=0];
	BREAK;			*X>=0 FAILED ON 0 OR X[28] FAILED
	CALL[CBRK,X<0];		*X<0 FAILED ON 0 OR X[28] FAILED
	X_A1;
	GOTO[.+2,X<0];
	BREAK;			*X<0 FAILED ON 377 OR X[28] FAILED
	CALL[CBRK,X>=0];	*X>=0 FAILED ON 377 OR X[28] FAILED

*Y>=0 AND Y<0 BC TESTS HERE
YBCT:	Y_NULL;
	GOTO[.+2,Y>=0];
	BREAK;			*Y>=0 FAILED ON 0 OR Y[27] FAILED
	CALL[CBRK,Y<0];		*Y<0 FAILED ON 0 OR Y[27] FAILED
	Y_A1;
	GOTO[.+2,Y<0];
	BREAK;			*Y<0 FAILED ON 777 OR Y[27] FAILED
	CALL[CBRK,Y>=0];	*Y>=0 FAILED ON 777 OR Y[27] FAILED
	Y_X;
	GOTO[.+2,Y>=0];
	BREAK;			*Y>=0 FAILED ON 377 OR Y STORAGE FAILED
	CALL[CBRK,Y<0], INCY;	*Y<0 FAILED ON 377
	GOTO[.+2,Y<0];
	BREAK;			*Y<0 FAILED ON 400 OR INCY FAILED OR
				*X STORAGE FAILED OR Y STORAGE FAILED ON 377
	CALL[CBRK,Y>=0];	*Y>=0 FAILED ON 400

*TEST INCX AGAINST INCY
IXIYT:	X_NULL;
	Y_NULL;
IXIYL:	P_X;
	Q_Y, CALL[PQCOMP];	*X_B, Y_B, INCX, OR INCY FAILED
	INCY, DGOTO[.+3];
	INCX, GOTO[IXIYL,Y>=0];
	BREAK;			*GOTO[Y>=0] OR DGOTO[ALWAYS] FAILED
	P_X, CALL[PZT];	 *INCY FAILED COUNTING 0 TO 400

*TEST INCY AGAINST P+1
	Y_P_NULL, GOTO[IYP2];
IYP1:	P#Q;
	GOTO[.+2,ALU=0], P_B, B_P+1, INCY;
	BREAK;			*CARRY1=F2 OR ALUF=37 (P) OR P_P1 FAILED
IYP2:	GOTO[IYP1,Y>=0], Q_Y;
IYP3:	P#Q;
	GOTO[.+2,ALU=0], INCY, P_B, B_P+1;
	BREAK;			*CARRY1=F2 OR ALUF = 37 OR P_P1 FAILED
	GOTO[IYP3,Y<0], Q_Y;
	AQ, CALL[AZT];		*INCY FAILED GOING 777 TO 0

*TEST THAT 2P+1 REPEATED 44 TIMES WITH P=0 INITIALLY PRODUCES -1
T2P:	Q_A1, P_NULL, DGOTO[.+1];
	REPEAT[21,ILC[(P_B, B_2P+1, DGOTO[.+1])]];
	P_B, B_2P+1;
	CALL[PQCOMP];		*2P+1 FAILED (PROBABLY CARRY FAILURE)

*TEST 2P AGAINST Q LSH 1
QLSHV2PT:	P_Q_NULL;
	P_B, B_P+1;
	Q_2P;
	P_B, B_P+1, CALL[PQCOMP];	*P_2P FAILED
	P_Q_NULL;
	P_Q_B, B_P+1;
	P#Q;
QL2P1:	GOTO[.+2,ALU=0], AQ;
	BREAK;			*P_2P OR Q LSH 1 FAILED ON SINGLE 1
	Q LSH 1, P_B, B_2P, GOTO[.+2,ALU#0];
	BREAK;			*ALU#0 FAILED
	P#Q, GOTO[QL2P1, ALU#0];
	P_Q_B, B_A1;
QL2P2:	P#Q, CALL[AZT];	 *P_2P OR Q LSH 1 FAILED ON LEADING 1'S
	P_B, Q LSH 1, B_2P;
	GOTO[QL2P2,ALU#0];

*STACK IS 12 BITS WIDE, 12 BITS LOADED FROM BUS, LEADING BIT =0 ON CALL
*STACK_ FIRST PUSHES B[1,13] AND ALSO SETS G=1 IF B[0]=1 BUT LEAVES
*G UNCHANGED IF B[0]=0.  THEN IT PUSHES B[14,27].  NOTE THAT THE FIRST
*PUSH IS OF ONLY 11 BITS WHILE THE 2ND IS OF 12 BITS.
***REMEMBER TO CHECK STACK_ FOR ITS AFFECT ON G LATER.
TSTACK:	REPEAT[6,ILC[(P_STEMP1_STACK_NULL)]];
TST0:	REPEAT[14,ILC[(STEMP_Q_STACK)]
		ILC[(P#Q, POP)]
		ILC[CALL[CBRK,ALU#0]]];	*STACK_ FAILED
TST1:	Q_A1, CALL[Q14];		*Q_7777
	P_B, B_Q, Q_A1;
	REPEAT[6,ILC[(STEMP1_STACK_Q)]];
	Q_P;
TST2:	REPEAT[6,ILC[STEMP_P_STACK]
		ILC[(P#Q, POP)]
		ILC[CALL[CBRK,ALU#0]]
		ILC[STEMP_P_STACK]
		ILC[(P_B, B_2P+1, POP)]
		ILC[P#Q]
		ILC[CALL[CBRK,ALU#0]]];
TST3:	STEMP1_STACK_P_B, B_A1;
	REPEAT[5,ILC[(STACK_NULL)]];
	REPEAT[12,ILC[(STEMP_P_STACK)]
		ILC[(POP, P)]
		ILC[GOTO[.+2,ALU=0]]
		ILC[BRKP[1]]];
	STEMP_P_STACK;
	P#Q, POP;
	GOTO[.+2,ALU=0], STEMP_P_STACK;
	BRKP[1];			*STACK NOT PUSHING OR POPPING PROPERLY
	P_B, B_2P+1, POP;
	P#Q;
	GOTO[TNPC,ALU=0];
	BREAK;			*STACK NOT PUSHING OR POPPING PROPERLY

*SUBROUTINE USED BY TNPC BELOW
NPCT:	P_NPC_B, B_2P;
NPCT0:	Q_NPC, GOTO[.+1];
	P#Q, GOTO[AZT];

*TEST NPC REGISTER
TNPC:	P_NULL;
	B_P+1, NPC_P_B, CALL[NPCT0];	*F2=NPC_ FAILED OR NPC STORAGE FAILED
	REPEAT[12,ILC[(CALL[NPCT])]]; *TO HOLD VALUE IN P

*TEST ALL BITS OF BA
BAT:	P_NULL;
	B_P+1, P_B, DGOTO[1];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 1
	P_B, B_2P, DGOTO[2];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 2
	P_B, B_2P, DGOTO[4];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 4
	P_B, B_2P, DGOTO[10];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 10
	P_B, B_2P, DGOTO[20];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 20
	P_B, B_2P, DGOTO[40];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 40
	P_B, B_2P, DGOTO[100];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 100
	P_B, B_2P, DGOTO[200];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 200
	P_B, B_2P, DGOTO[400];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 400
	P_B, B_2P, DGOTO[1000];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 1000
	P_B, B_2P, DGOTO[2000];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];		*BA FAILED ON 2000
*~
	P_B, B_2P, DGOTO[4000];
	Q_NPC, GOTO[.+1];
	CALL[PQCOMP];
*~
	GOTO[QODDT];

*NOW TEST Q ODD AND Q EVEN BC'S
QODDT:	P_Q_NULL;
	GOTO[.+2,Q EVEN];
	BREAK;			*Q EVEN FAILED ON Q=0
	CALL[CBRK,Q ODD], Q_P+1; *Q ODD FAILED ON Q=0
	Q_Q;			*BECAUSE Q IS SLOW SINK WHEN BC=QODD OR QEVEN
	GOTO[.+2,Q ODD];
	BREAK;			*Q ODD FAILED ON Q=1
	CALL[CBRK,Q EVEN], Q_A1; *Q EVEN FAILED ON Q=1
	GOTO[.+2,Q ODD];
	BREAK;			*Q ODD FAILED ON Q =-1
	CALL[CBRK,Q EVEN], Q LSH 1; *Q EVEN FAILED ON Q=-1
	GOTO[.+2,Q EVEN];
	BREAK;			*Q EVEN FAILED ON Q =-2
	CALL[CBRK,Q ODD];	*Q ODD FAILED ON Q=-2

*TEST Q LCY 1 (Q LSH 1, F2=RCYQQ) ON PATTERNS OF SINGLE 1'S IN EACH BIT
*POSITION
QLCYT:	P_NULL;
	P_Q_B, B_P+1;
	Q LCY 1, GOTO[.+2,ALU>=0], P_B, B_2P;
	BREAK;			*ALU>=0 FAILED
	CALL[PQCOMP];		*Q LCY 1 FAILED TO PRODUCE VALUE =2P
				*(F2=RCYQQ)
	P_B, B_2P, Q LCY 1;
	GOTO[.-2,ALU>=0];
	CALL[PQCOMP];		*Q LCY 1 FAILED TO PRODUCE 2P.	RESULT
				*SHOULD BE 400000 000000
	P_NULL;
	P_B, B_P+1, CALL[PQCOMP], Q LCY 1; *Q LCY 1 FAILED GOING
				*400000 000000 TO 1 (F2 = RCYQQ)

*TEST Q RCY 1 AGAINST Q LCY 1
QRCYT:	P_NULL;
	Q_P+1;
	Q LCY 1;
	Q RCY 1, DGOTO[.-1,Q EVEN], P_B, B_Q;
	Q LCY 1, CALL[PQCOMP];	*Q RCY 1 (POSSIBLY Q LCY 1) FAILED ON SINGLE 1
	P_B, B_A1;
	Q_2P;
	Q LCY 1;
	Q RCY 1, P_B, B_Q, DGOTO[.-1,Q ODD];
	Q LCY 1, CALL[PQCOMP];	*Q RCY 1 (POSSIBLY Q LCY 1) FAILED ON SINGLE 0

*TEST Q RSH 1 AGAINST Q LSH 1
QRSHT:	P_NULL;
	Q_P+1, CALL[QLCY43];
QRSHL:	P_B, B_Q, Q RSH 1;
	Q LSH 1, CALL[PQCOMP];	*Q RSH 1 FAILED TO YIELD P RCY 1
	CALL[QLCY43];
	GOTO[QRSHL, Q EVEN];
	Q RSH 1, CALL[QZT];	*Q RSH 1 FAILED GOING 1 TO 0

*NOW FINISH THE X<0 AND X>=0 BC TESTS
XBCT1:	P_NULL;
	Q_P+1, CALL[QLCY7];
	X_Q;
	GOTO[.+2,X<0];
	BREAK;			*X<0 BC FAILED ON 200
	CALL[CBRK,X>=0];	*X>=0 BC FAILED ON 200

*ALU CHECKOUT
ANDT:	P_Q_NULL;
	Q_P AND Q, CALL[AZT];	*AND FAILED ON 0,0
	Q_A1;
	Q_P AND Q, CALL[AZT];	*AND FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P AND Q, CALL[AZT];	*AND FAILED ON P=-1, Q=0
	P_Q_B, B_A1;
	P_B, B_P AND Q;
	Q_P+1, CALL[AZT];	*AND FAILED ON -1,-1

*NOT P CHECK
NOTPC:	P_NULL;
	P_B, B_NOT P;
	Q_P+1, CALL[AZT];	*NOT P FAILED ON 0
	P_B, B_A1, CALL[NPZT];	*NOT P FAILED ON -1

*NOT Q CHECK
NOTQC:	Q_NULL;
	P_B, B_NOT Q;
	Q_P+1, CALL[AZT];	*NOT Q FAILED ON 0
	Q_A1, CALL[NQZT];	*NOT Q FAILED ON -1

*NOT P OR NOT Q CHECK
NPONQC:	P_Q_NULL;
	P_B, B_NOT P OR NOT Q;
	Q_P+1, CALL[AZT];	*NOT P OR NOT Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_NOT P OR NOT Q, CALL[AZT]; *NOT P OR NOT Q FAILED ON -1,-1
	P_NULL, Q_A1;
	B_NOT P OR NOT Q, P_B;
	Q_P+1, CALL[AZT];	*NOT P OR NOT Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	B_NOT P OR NOT Q, P_B;
	Q_P+1, CALL[AZT];	*NOT P OR NOT Q FAILED ON P=-1, Q=0

*NOT P OR Q CHECK
NPOQC:	P_Q_NULL;
	Q_NOT P OR Q, CALL[NQZT]; *NOT P OR Q FAILED ON 0,0
	Q_A1, P_NULL;
	Q_NOT P OR Q, CALL[NQZT]; *NOT P OR Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_NOT P OR Q, CALL[AZT]; *NOT P OR Q FAILED ON P=-1, Q=0
	P_Q_B, B_A1;
	Q_NOT P OR Q, CALL[NQZT]; *NOT P OR Q FAILED ON -1,-1

*NOT P AND NOT Q CHECK
NPANQC:	P_Q_NULL;
	Q_NOT P AND NOT Q, CALL[NQZT]; *NOT P AND NOT Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_NOT P AND NOT Q, CALL[AZT]; *NOT P AND NOT Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_NOT P AND NOT Q, CALL[AZT]; *NOT P AND NOT Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_NOT P AND NOT Q, CALL[AZT]; *NOT P AND NOT Q FAILED ON P=-1,Q=0

*P=Q CHECK
P=QC:	P_Q_NULL;
	Q_P=Q, CALL[NQZT];	*P=Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P=Q, CALL[NQZT];	*P=Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P=Q, CALL[AZT];	*P=Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P=Q, CALL[AZT];	*P=Q FAILED ON P=-1, Q=0

*P OR NOT Q CHECK
PONQC:	P_Q_NULL;
	Q_P OR NOT Q, CALL[NQZT]; *P OR NOT Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P OR NOT Q, CALL[NQZT]; *P OR NOT Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P OR NOT Q, CALL[AZT];  *P OR NOT Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P OR NOT Q, CALL[NQZT]; *P OR NOT Q FAILED ON P=-1, Q=0

*NOT P AND Q CHECK
NPAQC:	P_Q_NULL;
	Q_NOT P AND Q, CALL[AZT]; *NOT P AND Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_NOT P AND Q, CALL[AZT]; *NOT P AND Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_NOT P AND Q, CALL[NQZT]; *NOT P AND Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_NOT P AND Q, CALL[AZT];	*NOT P AND Q FAILED ON P=-1, Q=0

*AQ TEST
AQT:	Q_NULL, CALL[QZT];	*AQ=0 FAILED
	Q_A1;
	P_B, B_AQ, CALL[NPZT];	*AQ=-1 FAILED

*P OR Q TEST
POQT:	P_Q_NULL;
	Q_P OR Q, CALL[AZT];	*P OR Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P OR Q, CALL[NQZT];	*P OR Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P OR Q, CALL[NQZT];	*P OR Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P OR Q, CALL[NQZT];	*P OR Q FAILED ON P=-1, Q=0

*A0 TEST
A0T:	Q_A0, CALL[AZT];	*A0 FAILED

*P AND NOT Q TEST
PANQT:	P_Q_NULL;
	Q_P AND NOT Q, CALL[AZT]; *P AND NOT Q FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P AND NOT Q, CALL[AZT]; *P AND NOT Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P AND NOT Q, CALL[AZT]; *P AND NOT Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P AND NOT Q, CALL[NQZT]; *P AND NOT Q FAILED ON P=-1, Q=0

*P TEST
PT:	P_NULL, CALL[PZT];	*P (ALUF[17]) FAILED ON 0
	P_B, B_A1;
	Q_P, CALL[NQZT];	*P FAILED ON -1

*P AND Q -1 TEST
PAQ-1T:	P_Q_NULL;
	Q_P AND Q -1, CALL[NQZT]; *P AND Q - 1 FAILED ON 0,0
	P_Q_B, B_A1;
	B_P AND Q-1, P_B;
	P_B, B_P+1;
	Q_B, B_P+1, CALL[AZT];	*P AND Q - 1 FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P AND Q-1, CALL[NQZT]; *P AND Q -1 FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P AND Q-1, CALL[NQZT]; *P AND Q -1 FAILED ON P=-1, Q=0

*P AND NOT Q -1 TEST
PANQ-1T:	P_Q_NULL;
	Q_P AND NOT Q-1, CALL[NQZT]; *P AND NOT Q-1 FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P AND NOT Q -1, CALL[NQZT]; *P AND NOT Q -1 FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P AND NOT Q -1, CALL[NQZT]; *P AND NOT Q -1 FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	B_P AND NOT Q-1, P_B;
	B_P+1, P_B, CALL[NPZT]; *P AND NOT Q - 1 FAILED ON P=-1, Q=0

*P-Q-1 = P + NOT Q TEST
P-Q-1T:	P_Q_NULL;
	Q_P-Q-1, CALL[NQZT];	*P-Q-1 FAILED ON 0,0
	P_Q_B, B_A1;
	Q_P-Q-1, CALL[NQZT];	*P-Q-1 FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P-Q-1, CALL[AZT];	*P-Q-1 FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	P_B, B_P-Q-1;
	P_B, B_P+1;
	Q_P+1, CALL[AZT];	*P-Q-1 FAILED ON P=-1, Q=0

**P-Q TEST OMITTED SINCE CARRY1 ALREADY TESTED
*P+Q TEST
P+QT:	P_Q_NULL;
	Q_P+Q, CALL[AZT];	*P+Q FAILED ON 0,0
	P_Q_B, B_A1;
	P_B, B_P+Q;
	P_B, B_P+1;
	Q_P+1, CALL[AZT];	*P+Q FAILED ON -1,-1
	P_NULL, Q_A1;
	Q_P+Q, CALL[NQZT];	*P + Q FAILED ON P=0, Q=-1
	P_B, B_A1;
	Q_NULL;
	Q_P+Q, CALL[NQZT];	*P+Q FAILED ON P=-1, Q=0

*P-1 TEST
P-1T:	P_NULL;
	Q_P-1, CALL[NQZT];	*P-1 FAILED GOING 0 TO -1
	P_B, B_A1;
	P_B, B_P-1;
	Q_P+1, CALL[NQZT];	*P-1 FAILED GOING -1 TO -2
	P_NULL;
	P_B, B_P+1;
	Q_P-1, CALL[AZT];	*P-1 FAILED GOING +1 TO 0

**P+Q+1 TEST OMITTED
*2P, 2P+1, P+1 ALREADY TESTED
*P AND Q +P, P AND NOT Q + P TESTS OMITTED (NOT USED ANYWHERE)

*TEST OF BUS BRANCH CONDITIONS
TBBC:	Q_A1;
	Q RSH 1;
	B_Q, P_B;
	GOTO[.+2,B>=0], B_Q;
	BREAK;			*B>=0 BC FAILED ON TRUE OR B_Q FAILED
	CALL[CBRK,B<0];	 *B<0 BC FAILED ON FALSE OR B_Q FAILED
	B_Q_P+1;
	GOTO[.+2,B<0], B_Q;
	BREAK;			*B<0 BC FAILED ON TRUE OR B_ALU FAILED
	CALL[CBRK,B>=0];	*B>=0 FAILED ON FALSE OR B_Q FAILED

*TEST ALU BRANCH CONDITIONS
*ALU=0 BC HAS ALREADY BEEN TESTED
*ALU#0 BC HAS BEEN TESTED FOR FAILURE WHEN FALSE
ALUBC:	Q_A1;
	Q RSH 1;
	B_AQ, P_B;
	GOTO[.+2,ALU>=0], AQ;
	BREAK;			*ALU>=0 BC FAILED ON TRUE
	CALL[CBRK,ALU<0];	*ALU<0 BC FAILED ON FALSE
	Q_P+1;
	GOTO[.+2,ALU<0], AQ;
	BREAK;			*ALU<0 BC FAILED ON TRUE
	CALL[CBRK,ALU>=0];	*ALU>=0 BC FAILED ON FALSE
	P_NULL;
	Q_P+1;

ALUGLP:	GOTO[.+2,ALU>0], AQ;
	BREAK;			*ALU>0 BC FAILED ON TRUE VALUE IN Q
	CALL[CBRK,ALU<=0], AQ;	*ALU<=0 BC FAILED ON FALSE VALUE IN Q
	GOTO[.+2,ALU#0];
	BREAK;			*ALU#0 BC FAILED ON TRUE VALUE IN Q
	Q LSH 1;
	AQ;
	GOTO[ALUGLP,ALU>=0], AQ;
	GOTO[.+2,ALU<=0], AQ;
	BREAK;			*ALU<=0 BC FAILED ON 400000 000000
	GOTO[.+2,ALU#0];
	BREAK;			*ALU#0 BC FAILED ON TRUE VALUE IN Q
	CALL[CBRK,ALU>0], A0;	*ALU>0 BC FAILED ON 400000 000000
	GOTO[.+2,ALU<=0], A0;
	BREAK;			*ALU<=0 BC FAILED ON 0
	CALL[CBRK,ALU>0];	*ALU>0 BC FAILED ON 0

ALU8T:	P_A0;
	GOTO[.+2,ALU8=0], A0;
	BREAK;			*ALU8=0 FAILED ON 0
	CALL[CBRK,ALU8=1],A1;	*ALU8=1 FAILED ON 0
	GOTO[.+2,ALU8=1], A1;
	BREAK;			*ALU8=1 FAILED ON -1
	CALL[CBRK,ALU8=0];	*ALU8=0 FAILED ON -1
	Q_P+1, CALL[QLCY33];
	AQ;
	GOTO[.+2,ALU8=1], AQ;
	BREAK;			*ALU8=1 FAILED ON 1000 000000
	CALL[CBRK,ALU8=0], Q_NOT Q; *ALU8=0 FAILED ON 1000 000000
	GOTO[.+2,ALU8=0], AQ;
	BREAK;			*ALU8=0 FAILED ON 776777 777777
	CALL[CBRK,ALU8=1];	*ALU8=1 FAILED ON 776777 777777

*NOW TEST FRZBALUBC
FBAT:	B_A1;
	B_A0, FRZBALUBC, P_B;
	GOTO[.+2,ALU<0], FRZBALUBC, B_P+1, P_B;
	BREAK;			*ALU<0 WASN'T FROZEN BY FRZBALUBC
	GOTO[.+2,ALU<=0], FRZBALUBC, B_A0;
	BREAK;			*ALU<=0 WASN'T FROZEN BY FRZBALUBC
	GOTO[.+2,B<0], FRZBALUBC, B_A0;
	BREAK;			*B<0 WASN'T FROZEN BY FRZBALUBC
	GOTO[.+2,ALU8=1], FRZBALUBC, B_A0;
	BREAK;			*ALU8=1 WASN'T FROZEN BY FRZBALUBC
	GOTO[.+2,ALU#0], FRZBALUBC, B_A0;
	BREAK;			*ALU#0 WASN'T FROZEN BY FRZBALUBC
	CALL[CBRK,ALU>=0], FRZBALUBC, B_P+1; *ALU<0 WASN'T FROZEN
	CALL[CBRK,ALU>0], FRZBALUBC, B_A0; *ALU<=0 WASN'T FROZEN
	CALL[CBRK,B>=0], FRZBALUBC, B_A0; *B<0 WASN'T FROZEN
	CALL[CBRK,ALU8=0], FRZBALUBC, B_A0; *ALU8=1 WASN'T FROZEN
	CALL[CBRK,ALU=0], B_A0; *ALU#0 WASN'T FROZEN
	B_A1, FRZBALUBC;
	GOTO[.+2,ALU>=0], FRZBALUBC, B_P;
	BREAK;			*ALU>=0 WASN'T FROZEN
	GOTO[.+2,B>=0], FRZBALUBC, B_A1;
	BREAK;			*B>=0 WASN'T FROZEN
	GOTO[.+2,ALU=0], FRZBALUBC, B_A1;
	BREAK;			*ALU=0 WASN'T FROZEN
	GOTO[.+2,ALU8=0], FRZBALUBC, B_A1;
	BREAK;			*ALU8=0 WASN'T FROZEN
	CALL[CBRK,ALU<0], FRZBALUBC, B_P; *ALU>=0 WASN'T FROZEN
	CALL[CBRK,ALU>0], FRZBALUBC, B_A1; *ALU<=0 WASN'T FROZEN
	CALL[CBRK,ALU#0], FRZBALUBC, B_A1; *ALU=0 WASN'T FROZEN
	CALL[CBRK,ALU8=1], FRZBALUBC, B_A1; *ALU8=0 WASN'T FROZEN
	CALL[CBRK,B<0], B_P;	*B>=0 WASN'T FROZEN
	B_A0, FRZBALUBC;
	GOTO[.+2,ALU>0];
	BREAK;			*ALU>0 WASN'T FROZEN

*NOW TEST LOADING Y FROM BUS.	(Y_NULL WAS TESTED EARLIER)
YBUST:	Y_P_NULL;
	Q_Y, CALL[PQCOMP];	*Y_0 FAILED
	P_Y_B, B_P+1;
	Q_Y, CALL[PQCOMP];	*Y_1 FAILED
	REPEAT[10,ILC[(P_Y_B, B_2P)] ILC[(Q_Y, CALL[PQCOMP])]];
	Q_A1;
	Q LSH 1, CALL[YBT1];	*Y_776 FAILED
	Q LSH 1;
	Q LCY 1, CALL[YBT1];	*Y_775 FAILED
	Q LSH 1, CALL[QLCY2];
	CALL[YBT1];		*Y_773 FAILED
	Q LSH 1, CALL[QLCY2];
	Q LCY 1, CALL[YBT1];	*Y_767 FAILED
	Q LSH 1, CALL[QLCY3];
	Q LCY 1, CALL[YBT1];	*Y_757 FAILED
	Q LSH 1, CALL[QLCY4];
	Q LCY 1, CALL[YBT1];	*Y_737 FAILED
	Q LSH 1, CALL[QLCY5];
	Q LCY 1, CALL[YBT1];	*Y_677 FAILED
	Q LSH 1, CALL[QLCY6];
	Q LCY 1, CALL[YBT1];	*Y_577 FAILED
	Q LSH 1, CALL[QLCY7];
	Q LCY 1, CALL[YBT1];	*Y_377 FAILED
	GOTO[XBUST];

YBT1:	B_Q, Y_P_B, Q_A1, CALL[Q11];
	Q_P AND Q, P_Y, CALL[PQCOMP];	* Y FAILED AT [STK 1]
	Q_A1, RETURN;

XBT1:	B_Q, X_P_B, Q_A1, CALL[Q10];
	Q_P AND Q, P_X, CALL[PQCOMP];	*X FAILED AT [STK 1]
	Q_A1, RETURN;

*NOW TEST OUT LOADING X FROM BUS.	(X_NULL TESTED EARLIER)
XBUST:	X_P_NULL;
	Q_X, CALL[PQCOMP];	*X_0 FAILED
	P_X_B, B_P+1;
	Q_X, CALL[PQCOMP];	*X_1 FAILED
	REPEAT[7,ILC[(P_X_B, B_2P)] ILC[(Q_X, CALL[PQCOMP])]];
	Q_A1;
	Q LSH 1, CALL[XBT1];	*X_376 FAILED
	Q LSH 1;
	Q LCY 1, CALL[XBT1];	*X_375 FAILED
	Q LSH 1, CALL[QLCY2];
	CALL[XBT1];	*X_373 FAILED
	Q LSH 1, CALL[QLCY2];
	Q LCY 1, CALL[XBT1];	*X_367 FAILED
	Q LSH 1, CALL[QLCY3];
	Q LCY 1, CALL[XBT1];	*X_357 FAILED
	Q LSH 1, CALL[QLCY4];
	Q LCY 1, CALL[XBT1];	*X_337 FAILED
	Q LSH 1, CALL[QLCY5];
	Q LCY 1, CALL[XBT1];	*X_277 FAILED
	Q LSH 1, CALL[QLCY6];
	Q LCY 1, CALL[XBT1];	*X_177 FAILED

*NOW TEST OUT DECY
DECYT:	P_Y_NULL, CALL[Q11], Q_A1;
	DECY, P_B, B_Q;
	Q_Y, CALL[PQCOMP], DECY;
	GOTO[.-1,Y<0], P_B, B_P-1;
	Q_Y, CALL[PQCOMP], DECY;
	GOTO[.-1,Y>=0], P_B, B_P-1;
	INCY;
	Q_Y, CALL[QZT];	 *DECY FAILED GOING 0 TO 777

*TEST OF DECX
DECXT:	P_X_NULL, Q_A1, CALL[Q10];
	DECX, P_B, B_Q;
	Q_X, DECX, CALL[PQCOMP];	*DECX FAILED
	GOTO[.-1,X<0], P_B, B_P-1;
	Q_X, DECX, CALL[PQCOMP];
	GOTO[.-1,X>=0], P_B, B_P-1;
	INCX;
	Q_X, CALL[QZT];	 *DECX FAILED GOING 0 TO 377

*TEST OF AC REGISTER
ACTEST:	P_AC_NULL;
	Q_AC, CALL[PQCOMP];	*AC_NULL OR B_AC FAILED ON 0
	B_P+1, P_B, DGOTO[.+1];
	B_2P+1, P_B;
	AC_2P+1, P_B;
	Q_AC, CALL[PQCOMP];	*AC_B OR B_AC FAILED ON 17

*DECAC TEST
DECACT:	DECAC, P_B, B_P-1;
	Q_AC, CALL[PQCOMP];	*DECAC FAILED ON [P]+1
	P_B, B_P-1, DECAC;
	GOTO[.-2,ALU>=0];

*INCAC TEST
INCACT:	P_AC, INCAC;		*STARTS WITH [AC]=17
	DECAC, P;
	DGOTO[INCACT,ALU>0];
	Q_AC, CALL[PQCOMP], DECAC; *INCAC FAILED ON [P]

*TEST OF F1 = READALU
TRALU:	Q_NULL;
	P_(Q) U (A1);
	Q_A1, CALL[PQCOMP];	*F1=READALU FAILED
	P_(Q) U (A0);
	Q_A1, CALL[PQCOMP];	*F1=READALU FAILED

*XTOP BUS SOURCE PUTS X[30,35] ONTO B[0,5]
XTOPT:	Q_A1, CALL[Q6];	*Q_77
	X_Q, CALL[QLCY36];
	P_XTOP, CALL[PQCOMP];	*XTOP FAILED ON 77 IN X.  WRONG VALUE IN P
	INCX;
	Q_XTOP, CALL[QZT];	*XTOP FAILED ON 100 IN X.  WRONG VALUE IN Q

*YSHIFT_ LOADS Y[27] FROM B[18] AND Y[28,35] FROM B[28,35]
YSHIFTT: P_NULL;
	Q_P+1, CALL[QLCY21];
	YSHIFT_Q, CALL[Q33];
	P_Y, CALL[PQCOMP];	*P SHOULD HAVE 400 IN IT.  YSHIFT_ FAILED
	P_NULL;
	Q_P+1, CALL[QLCY21];
	YSHIFT_Q_NOT Q, CALL[Q10];
	P_Y, CALL[PQCOMP];	*P SHOULD HAVE 377 IN IT.  YSHIFT_ FAILED

*TEST X AND Y BC'S WHEN LOADED FROM SLOWEST SOURCES WITH PREVIOUS SIGN
*REVERSED
XBCT2:	P_Q_A1, X_NULL;
	X_P+Q;
	CALL[CBRK,X>=0], P_Q_A0; *X BC FAILED ON SLOW SOURCE
	X_P+Q;
	CALL[CBRK,X<0];	*X BC FAILED ON SLOW SOURCE

YBCT2:	Y_NULL, P_Q_A1;
	YSHIFT_P+Q;
	CALL[CBRK,Y>=0], P_Q_A0; *Y BC FAILED ON SLOW SOURCE
	Y_P+Q;
	CALL[CBRK,Y<0];	*Y BC FAILED ON SLOW SOURCE

	GOTO[MCYCLE];		*END OF DG0.  THIS INSTRUCTION OVERWRITTEN
				*IF MORE DIAGNOSTICS ARE LOADED
IM[ILC,ADD[IP[ILC],-1]];