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***