ER[DG1];

TARGET[ILC];

%DG1, NORMALLY ASSEMBLED WITH DG0, TESTS THE MEMORIES ON BASIC PATTERNS,
THE F-REGISTER, AND FUNCTIONS DEPENDENT ON MEMORIES OR F-REGISTER.
IT MUST BE ASSEMBLED BEFORE DG2A FOR MAXC1 OR DG2B FOR MAXC2.
%
  
*TEST ADDRESSING FROM X AND DATA STORAGE OF BOTH LB AND RB
LRXT:	Q_A1, CALL[Q5], P_NULL;
	Y_Q, Q_P+1;		*Y HOLDS 37 DURING THE REMAINDER OF THE
				*RB AND LB TESTS
*FIRST TEST THE REGISTERS ON THE 36 PATTERNS WHICH CONTAIN A SINGLE 1
*WITH 35 ZEROES.  THE PATTERN IS LCY'ED 1 IN PASSING FROM REGISTER TO REGISTER
	X_Y, CALL[LRBT1];	*RETURN FROM LRBT1 WITH ORIGINAL Q RCY 1
	GOTO[.-1,Q EVEN];
*NOW TEST 36 PATTERNS OF A SINGLE 0 WITH 35 1'S
	Q_NOT Q;
	X_Y, CALL[LRBT1];	*RETURN FROM LRBT1 WITH ORIGINAL Q RCY 1
	GOTO[.-1,Q ODD];
*NOW TEST LB SPECIAL KLUDGES LINDX AND LACS
	Q_A1, X_NULL;
	LX_A1, AC_NULL;
	Q_LINDX, CALL[QZT];	*LINDX DIDN'T READ 0 ON [X]=0
	Q_LACS, CALL[QZT];	*LACS DIDN'T READ 0
	LINDX_A0;
	Q_LX, CALL[NQZT];	*LINDX_A0 SUCCEEDED ON [X]=0
	LACS_A0, INCAC;
	Q_LX, CALL[NQZT], INCX; *LACS_A0 SUCCEEDED ON [AC]=0
LBTL:	LAC_A1;
	Q_LACS, CALL[NQZT];	*LACS FAILED ON [AC]#0
	Q_LINDX, CALL[NQZT];	*LINDX FAILED ON [X]#0
	LINDX_A0;
	Q_LX, CALL[QZT];	*LINDX_ FAILED ON [X]#0
	LACS_A1, INCAC;
	Q_LX, CALL[NQZT], INCX; *LACS_ FAILED ON [AC]#0
	P_AC;
	P;
	GOTO[LBTL,ALU#0];
	LX_A1;
	Q_LINDX, CALL[QZT];	***IT WOULD BE BETTER IF THIS TEST WERE ON
				***FIVE BITS.
	LINDX_A0;
	Q_LX, CALL[NQZT];	*LINDX FAILED ON [X]=20
*[X]>17 IS REALLY A DON'T CARE FOR LINDX
	GOTO[SMTEST];

LRBT1:	RX_Q, Q LCY 1, DECX;
	GOTO[.-1,X>=0];
	X_Y;
	LX_Q, Q LCY 1, DECX;
	GOTO[.-1,X>=0];
*AT THIS POINT THE ORIGINAL VALUE IN Q HAS BEEN LCY'ED AFTER EACH OF 64
*LOADS SO IT CAN BE RESTORED TO THE ORIGINAL VALUE BY LCYING 8 MORE TIMES.
	Q LCY 1, CALL[QLCY7], X_Y;
LRBTA:	P_B, B_Q, Q_RX, DECX, CALL[PQCOMP]; *RB[X-1] FAILED ON [P]
	Q_P;
	Q LCY 1, GOTO[.-2,X>=0];
	X_Y;
LRBTB:	P_B, B_Q, Q_LX, DECX, CALL[PQCOMP]; *LB[X-1] FAILED ON [P]
	Q_P;
	Q LCY 1, GOTO[.-2,X>=0], P_AC_Y;
*NOW CHECK OUT ADDRESSING LB AND RB FROM AC
LRBT2:	P;
	GOTO[.-1,ALU>0], LAC_RAC_Q, DECAC, P_AC, Q LCY 1;
	CALL[QLCY23], Q LCY 1;
LRBT4:	P_B, B_Q, Q_LAC, CALL[PQCOMP];
	Q_RAC, CALL[PQCOMP];
	Q_P, P_AC, DECAC;
	P, Q LCY 1;
	GOTO[LRBT4,ALU>0];

*ORIGINAL Q HAS NOW BEEN CYCLED 80 TIMES
SET[TT,4];
LRBT5:	REPEAT[33,ILC[(LA[TT]RA[TT] LB_RB_Q, Q LCY 1, SET[TT,ADD[TT,1]])]];
	CALL[QLCY10], Q LCY 1;
SET[TT,4];
LRBT6:	REPEAT[33,ILC[(P_B, B_Q, Q_LB, CALL[PQCOMP], LA[TT], SET[TT,ADD[TT,1]])]
		ILC[(Q_RB, RA[TT], CALL[CPQCOMP])]];
	RETURN;		 *ORIGINAL Q CYCLED 107 TIMES = RCY 1

CPQCOMP: CALL[PQCOMP];		 *GET PROBLEM ADDRESS FROM STACK
	Q_P;
	Q LCY 1, RETURN;

*TEST OF SM
INCPCOMP:	P_B, B_P+1, GOTO[PQCOMP];

*SUBROUTINE "SMTC" INITIALIZES ALL THE SM AND DM REGISTERS TO VALUES BEGINNING
*WITH [R7] AND [Q] AND THEN CYCLED BY 1 FOR EACH SUCCESSIVE WORD.	AFTER
*INITIALIZING ALL 1024 REGISTERS IT READS THEM BACK AND CHECKS FOR ERRORS.
*DM[I] IS ALWAYS SET TO NOT[SM[I]].
SMTC:	SY_Q, Q_NOT Q;
	D_Q, Q_NOT Q, INCY;
	Q LCY 1, GOTO[.-2,Y>=0];
	SY_Q, Q_NOT Q;
	D_Q, Q_NOT Q, INCY;
	Q LCY 1, GOTO[.-2,Y<0];
SMTC0:	Q_R7, P_SY, CALL[PQCOMP]; *SY_B OR B_SY FAILED
SMTC1:	Q_NOT Q, P_D, CALL[PQCOMP], INCY; *D_B OR B_D FAILED
	Q_NOT Q, DGOTO[.-1,Y>=0];
SMTC2:	Q LCY 1, P_SY, CALL[PQCOMP]; *SY_B OR B_SY FAILED
SMTC3:	Q_NOT Q, P_D, CALL[PQCOMP], INCY; *D_B OR B_D FAILED
	Q_NOT Q, DGOTO[.-1,Y<0];
SMTC4:	Q LCY 1, P_SY, CALL[PQCOMP,Y<0]; *SY_B OR B_SY FAILED
	Q_R7, RETURN;

*TEST OF SM AND DM ADDRESSED FROM Y
SMTEST:	Y_P_NULL, DGOTO[SMT0];
	R7_Q_P+1, CALL[SMTC];
	GOTO[SMT1,ALU<=0], R7_Q, Y_NULL;
	CALL[SMTC];
SMT0:	GOTO[.-2], Q RCY 1, AQ;
SMT1:	P_B, B_A1;
	R7_Q_2P, CALL[SMTC];
	AQ, Q LCY 1;
	DGOTO[.-1,ALU<0];
	CALL[SMTC], R7_Q, Y_NULL;

*TEST Y U SA FOR SA FROM 0 TO 17 FOR Y FROM 0 BY 20 TO 760
*WRITE ADDRESS INTO EACH SM LOCATION
SMT2:	Y_P_Q_NULL;
	SY_Q, INCY;
	P_Q_B, B_P+1, GOTO[.-1,Y>=0];
	SY_Q, INCY;
	P_Q_B, B_P+1, GOTO[.-1,Y<0];
*TEST BELOW FAILS WITH EXPECTED VALUE IN P, ACTUAL VALUE READ FROM SM IN Q.
*INTENDED TO CATCH ADDRESSING FAILURES FOR SM, FAILURES MIGHT ALSO
*BE THE LOW FOUR BITS OF RETURN ADDRESS.
SMT3:	P_B, B_A1;
	Y_NULL;
SMTX:	SET[TEMP,0];
REPEAT[20,ILC[(Q_$,SET[TEMP,ADD[TEMP,1]],SA[TEMP], CALL[INCPCOMP])]];
	Q_A1, CALL[Q10];
	P-Q;
	GOTO[SMTX,ALU<0], Y_P+1;

*TEST READ ADDRESSING FROM SA FOR SA = 20 TO 377
SMT4:	Q_A1, CALL[Q4];
	P_B, B_Q;
SET[TEMP,17];
REPEAT[360,(ILC[(Q_$, SA[TEMP], CALL[INCPCOMP], SET[TEMP,ADD[TEMP,1]])] )];

*TEST F1 = READS AND F2 = READS
TREADS:	STEMP_Q_NULL;
	P_(Q) U (AQ) U (STEMP), CALL[PZT];	*F2=READS FAILED ON BITS IN Q
	Q_NULL;
	P_(Q) U (STEMP), INHINT, CALL[PZT];	*F1=READS FAILED ON BITS IN Q
	Q_A1;
	STEMP_Q, Q_A0;
	P_(Q) U (AQ) U (STEMP), CALL[NPZT];	*F2=READS FAILED ON BITS IN Q
	P_(Q) U (STEMP), INHINT, CALL[NPZT];	*F1=READS FAILED ON BITS IN Q

*TEST F1=LOADS AND F2=LOADS
TLOADS:	Q_A1;
	STEMP_Q;
	STEMP_X_NULL;
	P_STEMP, Q_A0, CALL[PQCOMP];	*F2=LOADS FAILED ON 1'S IN P
	STEMP_NULL, Q_A1;
	STEMP_X_Q;
	P_STEMP, CALL[PQCOMP];	*F2=LOADS FAILED ON 0'S IN P
	STEMP_Q;
	STEMP_X_NULL, INHINT;
	P_STEMP, Q_A0, CALL[PQCOMP];	*F1=LOADS FAILED ON 1'S IN P
	STEMP_NULL, Q_A1;
	STEMP_X_Q, INHINT;
	P_STEMP, CALL[PQCOMP];	*F1=LOADS FAILED ON 0'S IN P

*TEST Q-REGISTER RCYQQ, RCYNOTLUQ, RCY0Q (=NO ACTION) ON
* Q RSH 1 AND Q LSH 1.  F2=RCYQQ HAS ALREADY BEEN TESTED ON Q RSH 1 AND
*Q LSH 1 SO ONLY F1 = RCYQQ NEED BE TESTED

*! MAXC1 ONLY
M[RCYNOTLUQ,Z[47]]; *LANG HAS NO WAY TO INVOKE THIS F1 WITHOUT CLOBBERING P ALSO
*!
*~ MAXC2 ONLY
M[RCYNOTLUQ,Z[7]]; *LANG2 HAS NO WAY TO INVOKE THIS F1 WITHOUT CLOBBERING P ALSO
*~

TQCYC:	Q_A1;
	Q RCY 1, INHINT, CALL[NQZT]; *F1=RCYQQ FAILED ON Q RSH 1, Q=-1
	Q_A1;
TQC0:	Q RSH 1, RCYNOTLUQ, CALL[NQZT]; *F1=RCYNOTLUQ FAILED ON -1
	Q_A1;
	Q RSH 1, RCY0Q;
	P_B, B_Q;
TQC1:	Q_2P+1, CALL[NQZT];	*F2=RCY0Q SCRAMBLED Q RSH 1
	Q_A1;
	Q RSH 1, RCY0Q, INHINT;
	P_B, B_Q;
TQC2:	Q_2P+1, CALL[NQZT];	*F1=RCY0Q SCRAMBLED Q RSH 1
	P_Q_B, B_A1;
TQC3:	Q LCY 1, INHINT, CALL[NQZT]; *F1=RCYQQ FAILED ON Q LSH 1, Q=-1
	Q_A1;
TQC4:	Q LSH 1, RCYNOTLUQ, CALL[NQZT];
				*F1=RCYNOTLUQ FAILED ON Q LSH 1, Q=-1
	Q_A0;
TQC5:	Q RCY 1, INHINT, CALL[QZT]; *F1=RCYQQ FAILED ON Q=0, Q RSH 1
	Q_A0;
TQC6:	Q RSH 1, RCYNOTLUQ, CALL[QZT]; *F1=RCYNOTLUQ FAILED ON Q=0,Q RSH 1
	Q_A0;
TQC7:	Q LCY 1, INHINT, CALL[QZT]; *F1=RCYQQ FAILED ON Q=0, Q LSH 1
	Q_A0;
TQC8:	Q LSH 1, RCYNOTLUQ, CALL[QZT];
				*F1=RCYNOTLUQ FAILED ON Q=0, Q LSH 1
	P_Q_NULL;
TQC9:	Q RSH 1, ASHOVF, CALL[PQCOMP]; *ASHOVF FAILED ON Q RSH 1
				*0 IN P, 0 IN Q
	P_B, B_P+1;
	Q RSH 1, ASHOVF;
TQC10:	Q LCY 1, CALL[PQCOMP];	*ASHOVF FAILED ON Q RSH 1, 1 IN P, 0 IN Q
	Q_NULL;
	P_B, B_NOT P;
TQC11:	Q RSH 1, ASHOVF, CALL[QZT]; *ASHOVF FAILED ON Q=0, P=-2
	P_B, B_A1;
	Q_NULL;
	Q RSH 1, ASHOVF;
	P_NULL;
TQC12:	Q LCY 1, P_B, B_P+1, CALL[PQCOMP];	*ASHOVF FAILED ON Q=0, P=-1

*TEST Q_RB RSH 1 FOR THE CASES PS=ALU RSH 1, F1 OR F2=RCYQQ, OR F1=
*RCYNOTLUQ, OR NOT THESE
TQRB:	Q_R7_A1, CALL[QRB1];
	Q_R7_A0, CALL[QRB1];
	GOTO[FTEST];

QRB1:	P_B, B_Q, Q_A0;
	Q_(R7) RCY 1, CALL[PQCOMP]; *RB RSH 1, F2=RCYQQ FAILED
	Q_(R7) RCY 1, INHINT, CALL[PQCOMP]; *RB RSH 1, F1=RCYQQ FAILED
	Q_(R7) RSH 1, RCYNOTLUQ, CALL[PQCOMP]; *RB RSH 1, F1=RCYNOTLUQ FAILED
	Q_P;
	Q RSH 1;
QRB2:	P_B, B_Q, Q_(R7) RSH 1, CALL[PQCOMP];	*RB RSH 1 FAILED
	L7_P;
	P_(A0) ARSHC 1, Q_(R7) RSH 1;	*RB ARSHC 1 FAILED ON 0 THROUGH ALU
QRB3:	P_B, B_Q, Q_L7, CALL[PQCOMP];
	P_(A1) ARSHC 1, Q_(R7) RSH 1;
	AQ;
QRB4:	CALL[CBRK,ALU>=0], P_NULL; *RB ARSHC 1 FAILED ON -1 THROUGH ALU
	P_B, L7_B_P+1;
	P_(P) ARSHC 1, Q_(R7) RSH 1;
	AQ, Q_L7;
QRB5:	CALL[CBRK,ALU>=0], P_B, B_Q; *RB ARSHC 1 FAILED ON 1 THROUGH ALU
	P_(NOT P) ARSHC 1, Q_(R7) RSH 1;
	AQ;
	RETURN[ALU>=0];
QRB6:	BREAK;			*RB ARSHC 1 FAILED ON -2 THROUGH ALU

*TEST FLAG REGISTER
FTEST:	Q_A1;
	-1S_Q;
	SETF[-1S], CALL[NFZT];	*SETF OR NOT F (OR F) FAILED (WRONG BITS IN Q)
	CLEARF[-1S], CALL[FZT];	*CLEARF OR NOT F (OR F) FAILED (WRONG BITS IN Q)
	SETFC[-1S,NEVER], CALL[FZT,NEVER];	*SETFC TOOK ON BC=NEVER (WRONG BITS IN Q)
	SETFC[-1S,A], CALL[NFZT];	*SETFC FAILED TO TAKE ON BC=ALWAYS (WRONG BITS IN Q)
	CLEARFC[-1S,NEVER], CALL[NFZT,NEVER];	*CLEARFC FAILED ON BC=NEVER (WRONG BITS IN Q)
	CLEARFC[-1S,A], CALL[FZT];	*CLEARFC FAILED ON BC=ALWAYS (WRONG BITS IN Q)
	SETFB[-1S,A], CALL[NFZT];	*SETFB FAILED ON BC=ALWAYS (WRONG BITS IN Q)
	SETFB[-1S,NEVER], CALL[FZT,NEVER];	*SETFB FAILED ON BC=NEVER (WRONG BITS IN Q)

*TEST SETF ON EVERY COMBINATION OF A SINGLE 1 WITH 35 0'S WITH F ORIGINALLY
*0 AND WITH F ORIGINALLY THE COMPLEMENT OF THE WORD CONTAINING THE SINGLE 1.
*PERFORM THE ANALOGOUS TESTS ON CLEARF.  PERFORM THE COMPLEMENT TESTS.
FT1:	P_NULL;
	R7_Q_P+1;
	STEMP_Q, Q_NOT Q;
	STEMP1_Q, CALL[FTX];	*Q=STEMP1=NOT[STEMP]
	Q LCY 1, DGOTO[TSETSF];
	GOTO[.-3,Q EVEN], R7_Q;

FTX:	CLEARF[-1S];
	SETF[STEMP], CALL[FQNEQ];	*SETF FAILED ON [Q]
	CLEARF[STEMP1], CALL[FQNEQ];	*CLEARF FAILED ON NOT[Q]
	CLEARF[STEMP], CALL[FZT];	*CLEARF FAILED ON [Q]
	SETF[STEMP1], Q_R7, CALL[FQNEQ];	*SETF FAILED ON NOT[Q]
	Q_R7, RETURN;

*NOW TEST SETSF.
TSETSF:	P_NULL;
	Q_P+1;
	G_Q, Q LSH 1;
	H_Q, Q LSH 1;
	J_Q, Q LSH 1;
	K_Q, Q LSH 1;
	STEMP1_Q, GOTO[.+3];
SFT1:	Q LCY 1;
	GOTO[GBCT,Q ODD], STEMP1_Q;
	CALL[SETSFT];
	GOTO[SFT1], Q_STEMP1;

SETSFT:	P_G, CALL[SFT2];
	P_H, CALL[SFT2];
	P_J, CALL[SFT2];
	P_K, GOTO[SFT2];

*"SFT2" CALLED WITH G, H, J, OR K COMBINATION IN P AND BIT TO
*BE TESTED IN Q
SFT2:	STEMP2_P_B, B_Q, Q_P;	*STEMP2_P_BIT, Q_FLAG
	STEMP3_Q, Q_P OR Q;	*STEMP3_G, H, J, OR K
	STEMP4_Q;		*STEMP4_BOTH BIT AND G, H, J, OR K
	CLEARF[-1S];		*CLEAR ALL FLAGS
	SETF[STEMP2], Q_$, CALL[FQEQ];	*SETF FAILED ON NOT[Q]
	SETSF[STEMP4], Q_$, CALL[FQEQ];	*SETSF FAILED TO SET FLAG = 1
	CLEARF[STEMP3];
	Q_STEMP2, CALL[FQEQ];	*CLEARF FAILED ON BIT IN STEMP3

*NOW TEST FOR ALL 37 CASES WHEN SETSF DOES NOT SET THE SELECTED FLAGS TO 1
SFT3:	Q_STEMP2, GOTO[SFT5];
SFT3X:	P_STEMP2;
	P#Q, STEMP5_Q;
	GOTO[SFT4,ALU=0], P_B, B_NOT P;
	Q_(Q) U (STEMP3);
	STEMP4_Q;
	SETSF[STEMP4], CALL[FPEQ];	*SETSF SET SOME FLAG TO 1 IT SHOULDN'T HAVE.
	Q_STEMP5;
SFT5:	Q LCY 1, DGOTO[SFT3X];
	CALL[QLCY4,Q ODD];
SFT4:	Q_STEMP1, RETURN;

*NOW TEST G, H, J, AND K BRANCH CONDITIONS
GBCT:	CLEARF[-1S];
	SETF[G];
	GOTO[.+2,G=1];
	BREAK;			*G=1 BC FAILED ON TRUE
	CALL[CBRK,G=0], SETF[-1S]; *G=0 BC FAILED ON FALSE
	CLEARF[G];
	GOTO[.+2,G=0];
	BREAK;			*G=0 BC FAILED ON TRUE
	CALL[CBRK,G=1];		*G=1 BC FAILED ON FALSE

HBCT:	CLEARF[-1S];
	SETF[H];
	GOTO[.+2,H=1];
	BREAK;			*H=1 FAILED ON TRUE
	CALL[CBRK,H=0], SETF[-1S]; *H=0 FAILED ON FALSE
	CLEARF[H];
	GOTO[.+2,H=0];
	BREAK;			*H=0 FAILED ON TRUE
	CALL[CBRK,H=1];		*H=1 FAILED ON FALSE

JBCT:	CLEARF[-1S];
	SETF[J];
	GOTO[.+2,J=1];
	BREAK;			*J=1 FAILED ON TRUE
	CALL[CBRK,J=0], SETF[-1S]; *J=0 FAILED ON FALSE
	CLEARF[J];
	GOTO[.+2,J=0];
	BREAK;			*J=0 FAILED ON TRUE
	CALL[CBRK,J=1];		*J=1 FAILED ON FALSE

KBCT:	CLEARF[-1S];
	SETF[K];
	GOTO[.+2,K=1];
	BREAK;			*K=1 FAILED ON TRUE
	CALL[CBRK,K=0], SETF[-1S]; *K=0 FAILED ON FALSE
	CLEARF[K];
	GOTO[.+2,K=0];
	BREAK;			*K=0 FAILED ON TRUE
	CALL[CBRK,K=1];		*K=1 FAILED ON FALSE

*TEST Q35ALUG (Q35_ALU0[PREVIOUS INSTRUCTION] # G) IF Q LSH 1
TQ35AG:	P_Q_NULL, CALL[TQ35X];
	Q_A1, CALL[Q43];
	P_B, B_Q, Q_A0, CALL[TQ35X];
	GOTO[MPTEST];

TQ35X:	CLEARF[G], P;
	Q LSH 1, Q35ALUG;
	CALL[CBRK,Q ODD], NOT P; *Q35ALUG FAILED ON G=0, ALU0=0, Q35=0
	Q LSH 1, Q35ALUG, CALL[CBRK,Q ODD]; *Q35ALUG FAILED ON G=0, ALU0=0,Q35=0
	CALL[CBRK,Q EVEN], NOT P; *Q35ALUG FAILED ON G=0, ALU0=1, Q35=0
	Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=0,ALU0=1,Q35=0
	CALL[CBRK,Q EVEN], SETF[G], P; *Q35ALUG FAILED ON G=0, ALU0=1, Q35=1
	Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=0,ALU0=1,Q35=1
	CALL[CBRK,Q EVEN], NOT P; *Q35ALUG FAILED ON G=1, ALU0=0,Q35=1
	Q LSH 1, Q35ALUG, CALL[CBRK,Q EVEN]; *Q35ALUG FAILED ON G=1,ALU0=0,Q35=1
	CALL[CBRK,Q ODD]; *Q35ALUG FAILED ON G=1,ALU0=1,Q35=1
	RETURN[Q EVEN];
	BREAK;			*Q35ALUG FAILED ON G=1, ALU0=1

*SUBROUTINES TO FILL 1024 MAP ENTRIES WITH Q, Q LCY 1, Q LCY 2, ETC.
*AND THEN READ BACK AND CHECK THE RESULTS.  ORIGINAL Q IS
*RETURNED IN Q. [Y]=0, CUM=0, [P]=777777 AT CALL.
MPTCX:	Q_P AND Q, P_B, B_Q;
	MAP_Q, Q_P, INCY;
	Q LCY 1, GOTO[.-2,Y>=0], P_777777S;
	Q_P AND Q, P_B, B_Q;
	MAP_Q, Q_P, INCY, DGOTO[.-1];
	Q LCY 1, P_777777S, RETURN[Y>=0];

MPTCY:	R11_L7_P AND Q, Q LCY 1;
	P_MAP, INCY, R10_Q, Q_L7, CALL[PQCOMP];	*[MAP] AT Y-1 WRONG
	Q_R10, P_777777S, GOTO[.-2,Y>=0];
	R11_L7_P AND Q, Q LCY 1, P_MAP, INCY;
	R10_Q, Q_L7, CALL[PQCOMP];	*[MAP] AT Y-1 WRONG
	Q_R10, P_777777S, GOTO[.-2,Y<0];
	RETURN;

*HERE WITH [Y]=0, 777777 IN P, AND NUMBER BASE IN R7
MPTC:	CLEARF[CUM], CALL[MPTCX];	*MON. MAP WRITES
	SETF[CUM], CALL[MPTCX];	*USER MAP WRITES
	CLEARF[CUM], Q_R7, CALL[MPTCY]; *MON. MAP READS
	SETF[CUM], GOTO[MPTCY];	*USER MAP READS

MPTEST:	Y_P_NULL, CLEARF[-1S];
	Q_P+1, CALL[QLCY10];
	CUM_Q, Q_A1, CALL[Q22];
*TEST 18 PATTERNS OF A SINGLE 1 WITH 17 ZEROES AND 18 PATTERNS OF ALL ZEROES
	777777S_Q, DGOTO[MPT0];
	R7_Q_P+1, CALL[MPTC], P_777777S;
MPT2:	GOTO[MPT1,ALU<=0], R7_Q, Y_NULL;
	CALL[MPTC], P_777777S;
MPT0:	Q LCY 1, AQ, GOTO[MPT2];

*TEST 18 PATTERNS OF A SINGLE 0 WITH 17 1'S AND 18 PATTERNS OF 777777
MPT1:	P_B, B_A1, DGOTO[MPT3];
	R7_Q_2P, CALL[MPTC], P_777777S;

MPT4:	GOTO[M4TEST,ALU>=0], R7_Q, Y_NULL;
	CALL[MPTC], P_777777S;
MPT3:	Q LCY 1, AQ, GOTO[MPT4];

*M4CHK CALLED WITH Y, CUM, AND Q LOADED WITH SOME VALUES.  IT PERFORMS
*MAP4_ AND CHECKS IT.  LH[Q] MUST BE 0
M4CHK:	P_Y;
	MAP4_Q, R7_Q;
	REPEAT[4,ILC[(DECY)]];
	Q_Y, CALL[PQCOMP];	*MAP4_ FAILED TO INCREMENT Y BY 4
				*CORRECT VALUE IN P, WRONG VALUE IN Q
	P_MAP, INCY, Q_R7, CALL[PQCOMP]; *MAP4_ FAILED ON 0TH WORD
	P_MAP, INCY, Q_R7, CALL[PQCOMP]; *MAP4_ FAILED ON 1ST WORD
	P_MAP, INCY, Q_R7, CALL[PQCOMP]; *MAP4_ FAILED ON 2ND WORD
	P_MAP, INCY, Q_R7, GOTO[PQCOMP]; *MAP4_ FAILED ON 3RD WORD

*RETURN WITH Y INCREMENTED BY 4, Q UNCHANGED
M4TX:	Q_Y_NULL, CALL[M4CHK];
	Q_NULL, CALL[M4CHK];
	GOTO[.-1, Y>=0];
	Q_NULL, CALL[M4CHK];
	GOTO[.-1,Y<0], Q_777777S;
	Y_NULL, CALL[M4CHK];
	Q_777777S, CALL[M4CHK];
	GOTO[.-1,Y>=0];
	Q_777777S, CALL[M4CHK];
	GOTO[.-1,Y<0];
	RETURN;

M4TEST:	CLEARF[CUM], CALL[M4TX];
	SETF[CUM], CALL[M4TX];

*XSPLIT_ PUTS B[0,8] INTO Y, B[9,12] INTO AC, B[14,17] INTO X, AND NOT
*B[13] INTO G AND H
TXSPLIT:	Q_A1, Y_NULL, CALL[Q11];
	CALL[QLCY33], P_B, B_Q;
	XSPLIT_Q;
	Q_Y, CALL[PQCOMP];	*XSPLIT_ FAILED TO LOAD Y FROM 777
	Q_NOT P, CALL[QLCY33];
	XSPLIT_Q;
	Q_Y, CALL[QZT];		 *XSPLIT_ FAILED TO LOAD Y FROM 0
	Q_A1, CALL[Q4], X_NULL;
	CALL[QLCY22], P_B, B_Q;
	XSPLIT_Q;
	Q_X, CALL[PQCOMP];	*XSPLIT_ FAILED TO LOAD X FROM 17
	Q_NOT P, CALL[QLCY22];
	XSPLIT_Q;
	Q_X, CALL[QZT];		 *XSPLIT_ FAILED TO LOAD X FROM 0
	Q_A1, CALL[Q4], AC_NULL;
	CALL[QLCY27], P_B, B_Q;
	XSPLIT_Q;
	Q_AC, CALL[PQCOMP];	*XSPLIT_ FAILED TO LOAD AC FROM 17
	Q_NOT P, CALL[QLCY27];
	XSPLIT_Q;
	Q_AC, CALL[QZT];	*XSPLIT_ FAILED TO LOAD AC FROM 0
	P_NULL, SETF[-1S];
	B_Q_P+1, CALL[QLCY26], P_B;
	XSPLIT_Q, Q_2P+1, CALL[FQNEQ];	*P SHOULD HAVE 3 (777777 777774)
	CLEARF[-1S], P_NULL;
	B_Q_P+1, P_B, CALL[QLCY26];
	XSPLIT_Q_NOT Q;
	Q_2P+1, CALL[FQEQ];	*P SHOULD HAVE NOT 3 (3) (XSPLIT_ FAILED TO
				*SET G=H=1 ON B[13]=0

*ISPLIT SHOULD LOAD X FROM B[14,17] AND G_NOT B[13].
** ASSUME THAT ROUGHLY SAME LOGIC AS FOR XSPLIT IS USED SO WORRY
**ABOUT CLOBBERING OTHER REGISTERS
TISPLIT: XSPLIT_NULL;
	CLEARF[-1S];
	ISPLIT_A1;
	P_AC, CALL[PZT];	*ISPLIT_ CLOBBERED AC
	P_Y, CALL[PZT];		*ISPLIT_ CLOBBERED Y
	P_X, Q_A1, CALL[Q4];	*Q_17
	CALL[PQCOMP];		*ISPLIT_ FAILED TO LOAD X FROM 17
	CALL[FZT];		*ISPLIT_ CLOBBERED F (SHOULD HAVE 0 IN Q)
	ISPLIT_NULL;
	Q_X, CALL[QZT];		*ISPLIT_ FAILED TO LOAD X FROM 0
	CALL[F1T];		*ISPLIT_ FAILED TO LOAD G FROM 1

*FSPLIT_ LOADS Y FROM B[0,8]
TFSPLIT: XSPLIT_NULL, SETF[-1S];	*CLEAR ALL
	FSPLIT_Q_A1, CALL[Q11];
	P_Y, CALL[PQCOMP];	*FSPLIT_ FAILED TO LOAD Y FROM 777
	CALL[NFZT];		*FSPLIT_ CLOBBERED F
	Q_X, CALL[QZT];		*FSPLIT_ CLOBBERED AC
	FSPLIT_NULL;
	Q_Y, CALL[QZT];		*FSPLIT_ DIDN'T LOAD Y FROM 0

*BSPLIT_ LOADS Y FROM B[0,5] AND X FROM B[6,11]
TBSPLIT: XSPLIT_NULL;
	CLEARF[-1S], Q_A1, CALL[Q6];
	CALL[QLCY36], R7_Q;
	BSPLIT_Q, Q_R7;
	P_Y, CALL[PQCOMP];	*BSPLIT_ FAILED TO LOAD Y FROM 77.
	Q_X, CALL[QZT];		*BSPLIT_ FAILED TO LOAD X FROM 0
	Q_R7, CALL[QLCY30];
	BSPLIT_Q;
	Q_Y, CALL[QZT];		*BSPLIT_ FAILED TO LOAD Y FROM 0
	P_X, CALL[PQCOMP], Q_R7; *BSPLIT_ FAILED TO LOAD X FROM 77

*TEST STACK_ FOR ITS AFFECT ON G.	PREVIOUSLY TESTED ONLY DATA PUSHING
*AND POPPING.	G_G OR (B[0]=0) IS SUPPOSED TO OCCUR.
TSTACKG: CLEARF[-1S], Q_A1, CALL[Q43];
	STACK_NULL;
	CALL[CBRK,G=0];	 *G WRONG AFTER STACK_NULL (SHOULD CHANGE 0 TO 1)
	STACK_A1;
	CALL[CBRK,G=0];	 *G WRONG AFTER STACK_A1 (SHOULD REMAIN 1)
	CLEARF[-1S];
	STACK_A1;
	CALL[CBRK,G=1];	 *G WRONG AFTER STACK_A1 (SHOULD REMAIN 0)
	STACK_Q;
	CALL[CBRK,G=0]; *G WRONG AFTER STACK_377777 777777 (G SHOULD GO 0 TO 1)
	STACK_NOT Q;
	CALL[CBRK,G=0]; *G WRONG AFTER STACK_400000 000000 (SHOULD REMAIN 1)
*THIS COMPLETES TEST OF ALL SOURCES AND DESTINATIONS APART FROM THOSE
*RELATED TO THE DISK UNITS OR INTERRUPT SYSTEM, TO THE INSTRUCTION
*MEMORY, AND TO THE MEMORY INTERFACES.
	GOTO[TOVPC01];

%"OPC01T" ACCEPTS ARGUMENTS FOR P+Q AND P-Q-1 IN P AND Q, PROPER VALUE
FOR F AFTER P+Q IN STEMP1, PROPER VALUE FOR F AFTER P-Q-1 IN STEMP2.
SETOVPC01 IS CHECKED FOR P+Q AND P-Q-1 WITH F ORIGINALLY 0 AND ORIGINALLY
-1.	CJ&SJC IS ALSO CHECKED FOR BOTH INITIAL VALUES OF J FOR THE ARGU-
MENTS IN P AND IN Q.	SETHOVF IS ALSO CHECKED.
%
OPC01T:	CLEARF[-1S], L7_Q;
	P+Q, SETOVPC01;
OPCT0:	Q_STEMP1, R7_P, CALL[FQEQ];	*SETOVPC01 FAILED ON P+Q, F=0
	CALL[TCJ];
	Q_R7;
	P_B, B_Q, Q_L7, SETF[-1S];
OPCT1:	P+Q, SETOVPC01, CALL[NFZT];	*SETOVPC01 ZEROED OVF, PC0, OR PC1
	Q_R7, CLEARF[-1S];
	P_B, B_Q, Q_L7;
OPCT2:	P-Q-1, SETOVPC01, Q_STEMP2, CALL[FQEQ];	*SETOVPC01 FAILED ON P-Q-1, F=0
	CALL[TCNJ];
	Q_R7;
	P_B, B_Q, Q_L7, SETF[-1S];
OPCT3:	P-Q-1, SETOVPC01, CALL[NFZT];	*SETOVPC01 ZEROED OVF, PC0, OR PC1
	RETURN, P_Q_NULL;

TCJ:	Q_R7;
	P_B, B_Q, Q_L7, CLEARF[400000 000000S];
	R10_P+Q+J, GOTO[TCJ1,J=1];
	P+Q, SETHOVF;
	P_B, B_P+Q, Q_R10, CALL[PQCOMP], SETOVPC01;	*P+Q+J # P+Q FOR J=0; P+Q IS IN P,
				*P+Q+J IN Q, ORIGINAL P IN R7, ORIGINAL Q IN L7
TCNJ2:	SETSF[PC0&G], GOTO[.+3,J=0];
	GOTO[THO,G=1];
	BREAK;			*J AFTER CJ&SJC # PC0 (PC0 WAS 0)
	CALL[CBRK,G=1];	 *J AFTER CJ&SJC # PC0 (PC0 WAS 1)
THO:	Q_R7;
	P_B, B_Q, Q_L7, SETSF[OVF&G];
	GOTO[.+3,G=0];
	RETURN[H=1];
	BREAK;			*H=0 AFTER SETHOVF WHEN OVF=1
	RETURN[H=0];
	BREAK;			*H=1 AFTER SETHOVF WHEN OVF=0
TCJ1:	P+Q+1, SETHOVF;
	P_B, B_P+Q+1, Q_R10, CALL[PQCOMP], SETOVPC01;
				*P+Q+J # P+Q+1 FOR J=1, (SEE EARLIER COMMENT)
TCNJ:	Q_R7;
	P_B, B_Q, Q_L7, CLEARF[400000 000000S];
	R10_P-Q-NJ, GOTO[TCNJ1,J=0];
	P-Q, SETHOVF;
	P_B, B_P-Q, Q_R10, SETOVPC01, CALL[PQCOMP];	*P-Q-NJ # P-Q FOR J=1
	GOTO[TCNJ2];

TCNJ1:	P-Q-1, SETHOVF;
	P_B, B_P-Q-1, Q_R10, SETOVPC01, CALL[PQCOMP];	*P-Q-NJ # P-Q-1 FOR J=0
	GOTO[TCNJ2];

*TEST OF OVF, PC0, AND PC1 BEGINS HERE AND USES THE SUBROUTINES ABOVE
TOVPC01:	P_NULL;
	Q_P_B, B_P+1, CALL[QLCY42];
	Q_P OR Q;
	PC0&G_Q, Q_P, CALL[QLCY43];
	Q_P OR Q;
	OVF&G_Q;
	Q_A1, CALL[Q43];
	Q_NOT Q;
	400000 000000S_Q;
	STEMP1_P_Q_NULL;
TOP01:	STEMP2_NULL, CALL[OPC01T];	*00,00 = 000,000
	Q_P+1, CALL[QLCY41];
	P_B, B_R11_Q, Q LCY 1;	*R11_100000 000000
	R12_Q;			*R12_200000 000000
	R15_P OR Q, Q LCY 1;	*R15_300000 000000
	B_R13_Q, P_B;		*R13_400000 000000
	Q_R12;
	R14_P OR Q;		*R14_600000 000000
*THE NUMBERS IN THE COMMENTS BELOW REFER TO THE 2 LEADING BITS OF P AND
*OF Q AND TO THE RESULTING OVF, PC0, AND PC1 RESULTS FOR P+Q AND P-Q,
*RESPECTIVELY
TOP02:	P_NULL, Q_R12, CALL[OPC01T]; *00,01 = 000,000
TOP03:	P_NULL, Q_R13, CALL[OPC01T]; *00,10 = 000,000
TOP04:	Q_R14, P_NULL, CALL[OPC01T]; *00,11=000,000
	Q_R12;
	Q_R15, P_B, B_Q;
TOP05:	STEMP2_Q, Q_A0, CALL[OPC01T]; *01,00=000,011
	Q_R14;
TOP06:	P_B, B_Q, Q_A0, CALL[OPC01T]; *11,00=000,011
	Q_R13;
	P_B, B_Q, Q_R14;
TOP07:	STEMP2_Q, Q_A0, CALL[OPC01T]; *10,00=000,110
	Q_R13;
TOP10:	P_B, B_Q, Q_R12, CALL[OPC01T]; *10,01=000,110
	Q_R13;
	P_B, B_Q, Q_R11;
	R16_Q_P OR Q;		*R16_500000 000000
	STEMP2_Q, Q_R12;
TOP11:	P_B, B_Q, Q_R13, CALL[OPC01T]; *01,10=000,101

	STEMP2_NULL, Q_R13;
	P_B, B_Q, Q_R14;
TOP12:	STEMP1_Q, CALL[OPC01T]; *10,11=110,000
	Q_R13;
TOP13:	P_B, B_Q, CALL[OPC01T];	*10,10=011,000
	Q_R16;
	STEMP1_Q, Q_R12;
TOP14:	P_B, B_Q, CALL[OPC01T]; *01,01=101,000
	Q_R15;
	STEMP1_Q, Q_R14;
TOP15:	P_B, B_Q, CALL[OPC01T]; *11,11=011,000
	Q_R12;
TOP16:	P_B, B_Q, Q_R14, CALL[OPC01T]; *01,11=011,000
	Q_R14;
TOP17:	STEMP2_Q, P_B, Q_R12, CALL[OPC01T]; *11,01=011,110
	P_Q_STEMP2;
	STEMP1_Q, Q_R15;
TOP20:	STEMP2_Q, Q_R13, CALL[OPC01T]; *11,10=110,011


***DG2A.MC (MAXC1) OR DG2B.MC (MAXC2) MUST BE ASSEMBLED AFTER THIS***