ER[DGMB];	*SECOND HALF OF MEMORY DIAGNOSTIC

*NOW TEST OUT THE REF'S USING BOTH FORCED USER AND NOT FORCED SETTINGS
*OF XCT0, XCT1, XCT2, AND XCT3 AND WITH THE MAP LOADED WITH THE COMPLEMENT
*OF THE ADDRESS PASSED TO TMVAT AND WITH BOTH LEGAL AND ILLEGAL SETTINGS
*OF THE ACCESS PERMISSION BITS.
TREFS:	CALL[AINI], CLEARF[-1S]; *INITIALIZE ADDRESS TO MLOW
*CALL SUBROUTINE TO LOOP OVER 80 VALUES OF DATA AT THE CURRENT ADDRESS.
TREF0:	CALL[REFCON];
	CALL[AGEN], P←LADR; *LOOP THRU AC ADDRESSES
	P-Q;
	GOTO[TREF0,ALU>=0];

TREF1:	CALL[REFCON];
	CALL[AGEN1], Q←LADR;
	GOTO[TREF1,ALU>=0];
	GOTO[TSTOP];

REFCON:	CALL[DINIS1];		*INITIALIZE DATA TO 1
	CALL[SREF], CLEARF[-1S]; *TEST ALL THE REFS AT THIS ADDRESS AND DATA
	CALL[BDADV];		*CYCLE THE DATA
	GOTO[.-2,Q EVEN];	*LOOP TO TRY 40 VALUES OF DATA
	CALL[DINIS0];		*INITIALIZE DATA TO -2
	CALL[SREF];
	CALL[BDADV];
	GOTO[.-2,ALU<0];
	RETURN;

SREF:	P←MHIGH, Q←LADR;
	Q←P AND NOT Q, MAPVA←Q, CALL[Q33];
	MAP←Q, SETF[CUM], PQ RCY [33]; *MON. MAP ENTRY← COMPLEMENT OF PG. NO.
	Q←P, P←LADR, BAMASK[11];
	RTEMP←P OR Q, Q←RP&WP&XP; *RTEMP← WHAT MAR SHOULD BE AFTER REF
	MAP←Q, LTEMP←P, CLEARF[-1S]; *700000 (NO ACCESS AND PG 0) TO USER MAP
	P←LADR;
	MAPVA←P;
	GOTO[TREFAC,G=1], Q←(MAP) U (RP&WP&XP);

*FIRST CHECK EACH OF THE REFS IN MONITOR MODE WITH THE APPROPRIATE MAP ACCESS
*BIT SET TO 1 (PREVENTING ACCESS TO THE PAGE).	NONE OF THESE REFS SHOULD
*ACTIVATE THE MEMORY INTERFACE.
	MDR←NULL, P←RTEMP;
	WRITE←P;		*PUT A KNOWN VALUE IN MEMORY SO THAT WE CAN
				*CHECK LATER TO FIND OUT IF THE WRITE IMPROPERLY
				*TOOK PLACE
	Q←MAP;
	Q←(NOT Q) U (RP&WP&XP);
	Q←(NOT Q) U (WP);
	MAP←Q, P←LADR;
	MAPVA←P;
IWREF:	WREF, MDR←SDATA, CALL[CBRK,G=1], INHINT; *MAPVA← INCONSISTENTLY
				*YIELDED G=0 EARLIER BUT NOW G=1
	P←MDRL←SDATAL, CALL[CBRK,G=0];	*WREF ILLEGAL SO G SHOULD BE 1
	RTEMP1←P, CALL[CBRK,H=1], SETSF[CUM&H]; *NOT XCTI#0 SO H SHOULD BE 0
	CALL[CBRK,H=1];	 *CUM SHOULD BE 0 SINCE UM=0 AND XCTI=0
	P←MAR, Q←RTEMP, CALL[PQCOMP]; *MEMORY ADDRESS INCORRECT

	P←LADR, SETF[XCTN];
	MAPVA←P;
IWDXK:	WREFDXK, CALL[CBRK,G=1];
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP];
	MDRL←SDATAL, P←LADR, CALL[CBRK,G=0];

*CHECK RMWREF ILLEGAL DUE TO WP=0
	MAPVA←P;
IRMWREFA: RMWREFDXK, INHINT, MDR←MHIGH, CALL[CBRK,G=1];
	CALL[IRFCHK];
	P←LADR;
	MAPVA←P;
	RMWREF, INHINT, MDR←MHIGH, CALL[CBRK,G=1];
	CALL[IRFCHK];

	Q←MAP, CLEARF[-1S];
	Q←(NOT Q) U (RP&WP&XP);
	Q←(NOT Q) U (RP);
	P←LADR, MAP←Q;
	MAPVA←P;
IIREF:	IREF, MDR←MHIGH, CALL[CBRK,G=1]; *MAPVA← SCREWED UP
	CALL[IRFCHK];		*MHIGH IS USED TO TEST WHETHER READ WRONGLY
				*TAKES PLACE

IRREF:	RREF, MDR←MHIGH, CALL[CBRK,G=1];
	CALL[IRFCHK];

*CHECK RMWREF ILLEGAL DUE TO RP=0
IRMWREF: MDR←MHIGH, RMWREF, INHINT, CALL[CBRK,G=1];
	CALL[IRFCHK];
	SETF[XCTN], P←LADR;
	MAPVA←P;
	RMWREFDXK, MDR←MHIGH, CALL[CBRK,G=1];
	CALL[IRFCHK];

	Q←MAP;
	Q←(NOT Q) U (RP&WP&XP);
	Q←(NOT Q) U (XP);
	MAP←Q;
IXREF:	XREF, MDR←MHIGH, CALL[CBRK,G=1];
	CALL[IRFCHK];


*NOW TEST LEGAL MONITOR MODE REFERENCES
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (WP);
	Q←NOT Q;		*PERMIT ONLY WRITES
	MAP←Q, SETF[CUM&NXCT3], P←LADR; *NOW PERMITTING ONLY MONITOR WRITES
	MAPVA←P;
*TEST WREF WITH UM=G=H=WP=0, CUM=XCT0=XCT1=XCT2=RP=XP=1
WREFM:	WREF, MDR←SDATA, INHINT, CALL[CBRK,G=1];
	CALL[CBRK,G=1], MDRL←SDATAL; *WREF SHOULD SUCCEED SINCE G=0 BEFORE
				*AND WP=0 IN MAP
	CALL[CBRK,H=1], SETSF[CUM&H]; *XCT3=0 SO H SHOULD BE 0
	CALL[CBRK,H=1];	 *CUM SHOULD BE 0 SINCE UM=0 AND XCT3=0
	P←MAR, Q←RTEMP, CALL[PQCOMP];	*MAR SHOULD BE [Q]

*NOW TEST READS BACK WITH EACH OF THE FOUR REFS THAT READ
	CLEARF[-1S], MDR←NULL, CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP);
	Q←NOT Q;		*ONLY READ ACCESS PERMITTED
	MAP←Q, SETF[CUM&NXCT0], P←LADR, CALL[RETN];
	MAPVA←P;
IREFM:	IREF, CALL[CBRK,G=1];	*[P]#AC REF
	CALL[MRCHK];

	SETF[CUM&NXCT1];
	MAPVA←P;
RREFM:	RREF, CALL[CBRK,G=1];	*[P]#AC REF
	CALL[MRCHK];

	SETF[CUM&XCTN];
	MAPVA←P;
RDXKM:	RREFDXK, CALL[CBRK,G=1];
	CALL[MRCHK];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP&WP);
	Q←NOT Q;
	MAP←Q, P←LADR, SETF[CUM&NXCT1];
	MAPVA←P;
RMWREFM: RMWREF, CALL[CBRK,G=1], INHINT;
	CALL[MRCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	SETF[CUM&XCTN], P←LADR;
	MAPVA←P;
RMWDXKM: RMWREFDXK, INHINT, CALL[CBRK,G=1];
	CALL[MRCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (XP);
	Q←NOT Q;
	MAP←Q, P←LADR;
	SETF[CUM&XCTN];
	MAPVA←P;
XREFM:	XREF, CALL[CBRK,G=1];
	CALL[MRCHK];


*NOW CHECK LEGAL WRITE AND READS WITH XCTI=1 AND CFM=1 (SHOULD GET SAME RESULT
*AS MONITOR MODE REFERENCES ABOVE)
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (WP);
	Q←NOT Q;
	MAP←Q, SETF[CFM&CUM&XCT3], P←LADR;
	MAPVA←P;
WREFCFM: WREF, MDR←SDATA, INHINT, CALL[CBRK,G=1];
	CALL[CBRK,G=1], MDRL←SDATAL;
	CALL[CBRK,H=0], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP];

	CLEARF[-1S], MDR←NULL, CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP);
	Q←NOT Q;
	MAP←Q, SETF[CFM&CUM&XCT0], P←LADR;
	MAPVA←P;
IREFCFM: IREF, CALL[CBRK,G=1];
	CALL[CFMCHK];

	SETF[CFM&CUM&XCT1];
	MAPVA←P;
RREFCFM: RREF, CALL[CBRK,G=1];
	CALL[CFMCHK];

	SETF[CFM&CUM&XCTN];
	MAPVA←P;
RDXKCFM: RREFDXK, CALL[CBRK,G=1];
	CALL[MRCHK];

	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP&WP);
	Q←NOT Q;
	MAP←Q, P←LADR, SETF[CFM&CUM&XCT1];
	MAPVA←P;
RMWREFCFM: RMWREF, INHINT, CALL[CBRK,G=1];
	CALL[CFMCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	SETF[CFM&CUM&XCTN], P←LADR, CALL[RETN];
	MAPVA←P;
RMWDXKCFM: RMWREFDXK, INHINT, CALL[CBRK,G=1];
	CALL[MRCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (XP);
	Q←NOT Q;
	MAP←Q, P←LADR, SETF[CFM&CUM&XCTN];
	MAPVA←P;
XREFCFM: XREF, CALL[CBRK,G=1];
	CALL[MRCHK];


*NOW CHECK A LEGAL WRITE AND LEGAL READS IN EACH OF THREE FORCED USER MODES
	CLEARF[-1S], P←LADR, CALL[RETN];
	Q←(MAP) U (RP&WP&XP); *TURN-OFF ALL ACCESS TO MONITOR MAP ENTRY
	SETF[CUM&H], MAP←Q, CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (WP);
	Q←NOT Q;
	MAP←Q, CLEARF[-1S], P←LADR; *PERMIT WRITE ACCESS TO USER MAP ENTRY
	SETF[XCT3];
	MAPVA←P;
	WREF, MDR←SDATA, CALL[CBRK,G=1], INHINT; *NOT AC
WREFFU:	CALL[CBRK,G=1], MDRL←SDATAL;
	CALL[CBRK,H=0], SETSF[CUM&H]; *SHOULD BE TO USER MODE
	CALL[CBRK,H=0];
	P←MAR, Q←LTEMP, CALL[PQCOMP]; *MAR SHOULD BE [Q]

*NOW TEST THE READS BACK
	CLEARF[-1S], MDR←NULL;
	SETF[CUM&H], CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP);
	Q←NOT Q, SETF[XCT0];
	MAP←Q, CLEARF[CUM], P←LADR;
	MAPVA←P;
IREFFU:	IREF, CALL[CBRK,G=1];
	CALL[FURCHK];

	SETF[CUM&H], CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP&WP);
	Q←NOT Q;
	MAP←Q, P←LADR, SETF[XCT1];
	MAPVA←P;
RMWREFFU: RMWREF, CALL[CBRK,G=1], INHINT;
	CALL[FURCHK];
	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	CLEARF[-1S], P←LADR;
	SETF[XCT1];
	MAPVA←P;
RREFFU:	RREF, CALL[CBRK,G=1];
	CALL[FURCHK];

*THERE IS NO XREF FU SINCE ALL XCT'S GO TO MONITOR MODE
*NOW TEST NORMAL USER REF'S
	P←MAP;
	Q←RP&WP&XP;
	MAP←Q, SETF[CUM], Q←P AND NOT Q;
	Q←(Q) U (NWP);
	MAP←Q, CLEARF[-1S], P←LADR;	*PERMIT ONLY WRITES
	SETF[UM];
	MAPVA←P;
WREFU:	WREF, CALL[CBRK,G=1], MDR←SDATA, INHINT;
	CALL[CBRK,G=1], MDRL←SDATAL;
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=0];
	P←MAR, Q←RTEMP, CLEARF[-1S], CALL[PQCOMP];

*NOW TEST NORMAL USER READ REFS
	SETF[CUM&H], MDR←NULL, CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP);
	Q←NOT Q, SETF[UM];
	MAP←Q, CLEARF[CUM], P←LADR;
	MAPVA←P;
IREFU:	IREF, CALL[CBRK,G=1];	*NOT TO AC
	CALL[URCHK];

	SETF[UM];
	MAPVA←P;
RREFU:	RREF, CALL[CBRK,G=1];
	CALL[URCHK];

	SETF[CUM&H], CALL[RETN];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (RP&WP);
	Q←NOT Q;
	MAP←Q, CLEARF[-1S], P←LADR;
	SETF[UM];
	MAPVA←P;
RMWREFU: RMWREF, INHINT, CALL[CBRK,G=1];
	CALL[URCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	SETF[UM];
	P←MAR, Q←RTEMP, CALL[PQCOMP];	*WRESTART SMASHED MAR
	MAPVA←SADR, ACFS;
RMWDXKU: RMWREFDXK, INHINT, CALL[CBRK,G=1];
	CALL[URCHK];

	Q←NOT Q, P←SDATAL, CALL[NDGEN];
	SETF[UM];
	P←MAR, Q←RTEMP, SETF[CUM&H], CALL[PQCOMP];
	Q←(MAP) U (RP&WP&XP);
	Q←(NOT Q) U (XP);
	Q←NOT Q;
	MAP←Q, CLEARF[-1S], P←LADR;
	SETF[UM];
	MAPVA←P;
XREFU:	XREF, CALL[CBRK,G=1];
	CALL[URCHK];

	RETURN;		 ******FINISH THIS LATER

*CHECK AFTERMATH OF AC REFERENCE IN MONITOR MODE
AMRCHK:	CALL[CBRK,H=1], SETSF[CUM&H];
AMCHK1:	P←MAR, Q←RTEMP, CALL[PQCOMP];
	CALL[CBRK,H=1], P←RP&WP&XP;
	Q←MDR, CALL[PQCOMP];
	CLEARF[-1S], P←LADR, RETURN;

*CHECK AFTERMATH OF AC REF IN MON MODE WITH BOTH XCTI AND CFM SET
ACFMCHK: CALL[CBRK,H=0], SETSF[CUM&H];
	GOTO[AMCHK1];

*CHECK AFTERMATH OF AC REF IN MON MODE FORCED TO USER MODE BY AN XCTI
AFURCHK: CALL[CBRK,H=0], SETSF[CUM&H];
	P←MAR, Q←LTEMP, CALL[PQCOMP];
	CALL[CBRK,H=0], P←XCTN;
	Q←MDR, CALL[PQCOMP];
	CLEARF[-1S], P←LADR, RETURN;

*CHECK AFTERMATH OF USER MODE AC REFS
AURCHK:	CALL[CBRK,H=1], SETSF[CUM&H]; *NOT A FORCED USER REF
	P←MAR, Q←LTEMP, CALL[PQCOMP];	*MEMORY ADDRESS NOT FROM USER MAP
	CALL[CBRK,H=0], P←MHIGH;	*CUM SHOULD BE 1 SINCE UM WAS 1
	Q←MDR, CALL[PQCOMP];	*MDR SHOULDN'T HAVE CHANGED SINCE AC REF
	CLEARF[-1S], P←LADR;
	SETF[UM];
	MAPVA←P, RETURN;


*TEST OUT THE REF'S ON AC REFERENCES.  G=DON'T CARE AFTER TO REF TO AC
*SINCE COMPLETE ACCESS ALLOWED TO AC'S SO THAT MAP PROTECTION DOESN'T
*APPLY.	HOWEVER, G=ACCESS TO PAGE SAME AS NON-AC REF WOULD BE MORE
*GENERAL.  H=FORCED USER MODE.  CUM MUST BE SET PER UM/XCTI.
*MAR MUST BE LOADED FROM 12 BITS OF MAP ENTRY SAME AS NON-AC REF.
*MEMORY INTERFACE MUST NOT BE STARTED WHICH MEANS THAT MDR MUST NOT
*BE CLOBBERED ON READS AND MEMORY NOT CLOBBERED BY WRITES
TREFAC:	MDR←NULL, P←RTEMP;	*INITIALIZE THE MEMORY TO A VALUE
				*SO THAT WE CAN READ IT BACK LATER AND
				*CHECK FOR ITS GETTING CLOBBERED
	WRITE←P;
	Q←MAP;
	Q←(NOT Q) U (RP&WP&XP);
	Q←NOT Q;
	MAP←Q, SETF[CUM], CALL[RETN];	*ALLOW COMPLETE ACCESS TO MONITOR PAGE 0
				*SINCE THIS IS WORST CASE FOR LETTING THE
				*MEMORY INTERFACE START INCORRECTLY
	Q←MAP;
	Q←(NOT Q) U (RP&WP&XP);
	Q←NOT Q, MDRL←-1S;
	MAP←Q, SETF[CUM&NXCT3], P←LADR, CALL[RETN]; *COMPLETE ACCESS TO USER PAGE 0 ALSO
	MAPVA←P;
ACWM:	WREF, MDR←A1, CALL[CBRK,G=0]; *SHOULD NEVER BE G=0 HERE
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP]; *MAR # [Q]

	CLEARF[-1S], CALL[QLCY6];	*GIVE MEMORY PLENTY OF TIME TO WRITE
				*IF IT WANTS TO
	P←LADR, SETF[CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACWDXKM: WREFDXK, CALL[CBRK,G=0];
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP];

	CLEARF[-1S];
	P←LADR, SETF[CUM&NXCT0], CALL[RETN];
	MAPVA←P;
ACIM:	IREF, CALL[CBRK,G=0], MDR←RP&WP&XP; *AC REF'S LEAVE G=1
	CALL[AMRCHK];

	SETF[CUM&NXCT1], CALL[RETN];
	MAPVA←P;
ACRM:	RREF, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[AMRCHK];

	SETF[CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACRDXKM: RREFDXK, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[AMRCHK];

	SETF[CUM&NXCT1], CALL[RETN];
	MAPVA←P;
ACRMWM:	RMWREF, CALL[CBRK,G=0], MDR←RP&WP&XP, INHINT;
	CALL[AMRCHK];

	SETF[CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACRMWDXKM: RMWREFDXK, CALL[CBRK,G=0], MDR←RP&WP&XP, INHINT;
	CALL[AMRCHK];

	SETF[CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACXM:	XREF, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[AMRCHK];


*NOW CHECK A WRITE AND READS WITH BOTH CFM AND XCTI SET
	P←LADR, SETF[CFM&CUM&XCT3], CALL[RETN];
	MAPVA←P;
ACWCFM:	WREF, MDR←A1, CALL[CBRK,G=0];
	CALL[CBRK,H=0], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP];

	CLEARF[-1S];
	P←LADR, SETF[CFM&CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACWDXKCFM: WREFDXK, CALL[CBRK,G=0];
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=1];
	P←MAR, Q←RTEMP, CALL[PQCOMP];

	CLEARF[-1S];
	P←LADR, SETF[CFM&CUM&XCT0], CALL[RETN];
	MAPVA←P;
ACICFM:	IREF, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[ACFMCHK];

	SETF[CFM&CUM&XCT1], CALL[RETN];
	MAPVA←P;
ACRCFM:	RREF, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[ACFMCHK];

	SETF[CFM&CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACRDXKCFM: RREFDXK, MDR←RP&WP&XP, CALL[CBRK,G=0];
	CALL[AMRCHK];

	SETF[CFM&CUM&XCT1], CALL[RETN];
	MAPVA←P;
ACRMWCFM: RMWREF, CALL[CBRK,G=0], INHINT, MDR←RP&WP&XP;
	CALL[ACFMCHK];
	SETF[CFM&CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACRMWDXKCFM: RMWREFDXK, CALL[CBRK,G=0], MDR←RP&WP&XP, INHINT;
	CALL[AMRCHK];
	SETF[CFM&CUM&XCTN], CALL[RETN];
	MAPVA←P;
ACXCFM:	XREF, CALL[CBRK,G=0], MDR←RP&WP&XP;
	CALL[AMRCHK];


*NOW CHECK A WRITE AND READS WHICH FORCE USER MODE
	SETF[XCT3], CALL[RETN];
	MAPVA←P;
ACWFU:	WREF, MDR←A1, CALL[CBRK,G=0];
	CALL[CBRK,H=0], SETSF[CUM&H];
	CALL[CBRK,H=0];	 *XCT3 DIDN'T SET CUM=1
	P←MAR, Q←LTEMP, CALL[PQCOMP];

	CLEARF[-1S], CALL[QLCY6];
	P←LADR, SETF[XCT0], CALL[RETN];
	MAPVA←P;
ACIFU:	IREF, CALL[CBRK,G=0], MDR←XCTN;
	CALL[AFURCHK];

	SETF[XCT1], CALL[RETN];
	MAPVA←P;
ACRFU:	RREF, MDR←XCTN, CALL[CBRK,G=0];
	CALL[AFURCHK];

	SETF[XCT1], CALL[RETN];
	MAPVA←P;
ACRMWFU: RMWREF, MDR←XCTN, CALL[CBRK,G=0], INHINT;
	CALL[AFURCHK];


*NOW CHECK A WRITE AND READS IN USER MODE
	SETF[UM];
	MAPVA←P;
ACWU:	WREF, MDR←A1, CALL[CBRK,G=0];
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=0];
	CLEARF[-1S], P←MAR, Q←LTEMP, CALL[PQCOMP];

	SETF[UM], P←LADR;
	MAPVA←P;
ACWDXKU: WREFDXK, MDR←A1, CALL[CBRK,G=0], INHINT;
	CALL[CBRK,H=1], SETSF[CUM&H];
	CALL[CBRK,H=0];
	CLEARF[-1S], P←MAR, Q←LTEMP, CALL[PQCOMP];

	SETF[UM], P←LADR;
	MAPVA←P;
ACIU:	IREF, CALL[CBRK,G=0], MDR←MHIGH;
	CALL[AURCHK];

ACRU:	RREF, CALL[CBRK,G=0], MDR←MHIGH;
	CALL[AURCHK];

ACRDXKU: RREFDXK, MDR←MHIGH, CALL[CBRK,G=0];
	CALL[AURCHK];

ACRMWU:	RMWREF, CALL[CBRK,G=0], MDR←MHIGH, INHINT;
	CALL[AURCHK];

ACRMWDXKU: RMWREFDXK, CALL[CBRK,G=0], MDR←MHIGH;
	CALL[AURCHK];

ACXU:	XREF, CALL[CBRK,G=0], MDR←MHIGH;
	CALL[AURCHK];

*NOW MAKE SURE MEMORY AC IS STILL 0 AFTER ALL THIS MACHINATION WHEN THE
*MEMORY INTERFACE WAS PRESUMED INACTIVE
	P←RTEMP;
	READ←P, CALL[RETN];
	Q←MDR, CALL[QZT];	*MEMORY CLOBBERED BY AC REFERENCE
	RETURN;

TSTOP:	GOTO[MCYCLE];		******TEMPORARY END OF DIAG.
	IM[ILC,ADD[IP[ILC],-1]]; *BACK UP PC IN CASE MORE DIAG ARE BEING
				*ASSEMBLED