ER[MAIN];

*I = 212+2 FOR MAXC2

%THIS FILE CONTAINS THE EMULATOR'S MAIN LOOP, PREPARATION ROUTINES,
AND COMPLETION ROUTINES.  IT CONTAINS REFERENCES TO VARIABLES AND TAGS
DEFINED IN "MAP" AND "PISYS" WHICH ARE ASSEMBLED AHEAD OF THIS FILE.

THE INSTRUCTION-FETCH LOOP CONTAINS A BRANCH CONDITIONED ON THE "LOGF" FLAG
TO A SPECIAL PROGRAM.  THIS PROGRAM CAN BE FILLED OUT BY  "LOGI", "BRKI",
OR "TRACEI" (NORMAL = "LOGI").  TIMING COMMENTS APPLY WHEN "LOGF" = 0.

THE ENTRY POINT TO THE MAIN LOOP IS CALLED "REMAPPC".  OPCODES MAY
REENTER THE MAIN LOOP IN ANY OF THE FOLLOWING WAYS:

	P_MAPVA_PC, Q_1R, ACFS, GOTO[REMAP1]; *= "ENDM"
	RETURN;		*IF THE STACK HAS BEEN POPPED ENOUGH TIMES
	GOTO[REMAPPC];

COMPLETION ROUTINES WHICH CAN SHOULD FINISH WITH "ENDM" (OR AN EQUIVALENT
FOR JUMPS AND SKIPS) SINCE THAT SAVES ONE CYCLE.

"PC" IS ADVANCED IN THE MAIN LOOP (UNLIKE THE PDP-10) SO "LOADMAP" MUST
DECREMENT "PC" BEFORE TRAPPING EXCEPT ON PURE WRITES. "PI" DECREMENTS "PC".

IT IS NECESSARY, BEFORE ENTERING THE INDIRECT ADDRESS LOOP, LOADING THE
MAP, OR TRIPLE-DISPATCHING, TO CLEAR ALL FOUR XCTN FLAGS, J AND PICYCLE.
THE MAIN LOOP MUST ALSO CHECK FOR INTERRUPT CONDITIONS.  ALL OF
THESE ARE REPRESENTED BY 1 BITS IN F SELECTED BY "INTCONDH."

TIMING:	4 CYCLES + 1R
	+4 CYCLES + 1R / INDIRECT
	+1 CYCLE IF THE INSTRUCTION DOES NOT FINISH WITH "ENDM"

DEEPEST STACK DEPTH = 4 DURING INDIRECT LOOP
		= 7 DURING INDIRECT LOOP MAP LOADING
		= 3 AT MAIN LOOP EXIT

NOTE:	R = 2 FOR AC INSTRUCTION FETCHES OR 0 FOR INDIRECT READS.  OTHERWISE,
	IT IS THE NO. OF INSTRUCTIONS WHICH ELAPSE AFTER THE ONE INITIATING
	THE READ BUT NOT INCLUDING THE ONE WHICH READS MDR.

"TFLAGS" CONTAINS 1'S FOR XCT0, XCT1, XCT2, XCT3, J, AND PICYCLE.
IN THE SPECIAL VERSION OF THE MAIN LOOP USED BY TRAP AND PICYCLES,
"TFLAGSPI" IS USED INSTEAD.  IT DOES NOT CLEAR J (J=UM) NOR PICYCLE (=1),
AND DOES CLEAR UM (TO XCT THE INSTRUCTION IN MONITOR MODE).

THE MAIN LOOP ZEROES "PC" LEFT HALF BEFORE CHECKING PI CONDITIONS OR
CALLING "LOADMAP".  THIS MEANS THAT DURING EXECUTION OF AN INSTRUCTION,
"PC" CAN ALWAYS BE MERGED WITH THE FLAGS WITHOUT CLEARING ITS LEFT HALF
FIRST, AND INSTRUCTIONS WHICH CHANGE "PC" DON'T HAVE TO CLEAR THE LEFT HALF
BEFORE REENTERING THE MAIN LOOP.  NOTE THAT THE TRAP CODE FOR "LOADMAP"
NECESSARILY CLEARS THE LEFT HALF OF "PC".  FINALLY, NOTE THAT "PC" IS
INVALID WHEN ENTRY IS MADE AT "REMAP1" SO THE NEW VALUE COMPUTED FROM P
MUST BE SAVED BEFORE GOING TO "LOADMAP" OR "PI".  AT EXIT FROM THE MAIN
LOOP, "INSTR" CONTAINS THE INSTRUCTION, P THE EFFECTIVE ADDRESS E, Q THE AC,
AC POINTS TO THE AC, G=1 IFF E POINTS TO AN AC K=0 IF NO INDIRECTION
ELSE K=XCT3 (FOR BYTE INDIRECTION), J=0 (FOR UM COMPUTATION BY INTERRUPT
INSTRUCTIONS), PC HAS BEEN INCREMENTED, AND ICTR HAS BEEN INCREMENTED
ONCE PLUS ONCE PER INDIRECT ADDRESS.  "OLDPC" ALSO CONTAINS THE PC.
"REFADR" ALSO CONTAINS E WITH GARBAGE IN THE L.H.

I = 24
%

MC[XCTN,XCTN];
MC[TFLAGS,J,PICYCLE,XCTN];
MC[XCT3&K,XCT3,K];
RVN[INSTR];
*INTCONDH IS DEFINED IN PISYS

TARGET[ILC];

*SUBROUTINES TO HANDLE THE MONITOR'S FORCED REFERENCES TO USER AC'S
RMWAMDR: P_MAPVA_(MDR) U (ACBASE), A1;
	RMWREFDXK, INHINT, RETURN;

RAMDR:	P_MAPVA_(MDR) U (ACBASE), A1;
RREFX:	RREFDXK, RETURN;


M[ENDM,(P_MAPVA_PC, Q_1R, ACFS, GOTO[REMAP1,#1])];

%SET UP TRIPLE DISPATCH.  CALL INDLP ONLY IF INDIRECT BIT IN INSTRUCTION
=1 (BOTH G AND H =0) AND D[0]=1 (B[0]=0 SETS G=1).  NOTE THAT H REMEMBERS
THE SETTING OF THE INDIRECT BIT WHEN D[0]=0 FORCES A MAIN LOOP EXIT.%

REMAPE:	NPC_STACK_D, Q_LINDX, INSTR_P, GOTO[LOGI,K=1];
	MAPVA_REFADR_P_P+Q, SAMASK[22], Q_LAC, CALL[INDLP,G=0];

INDLP1:	RTEMP_P, Q_LINDX, GOTO[PI,H=1]; *RTEMP HOLDS LAST MEM REF FOR JRST@
*ALSO ENTER HERE FOR BYTE INDIRECT SEQUENCES (K_XCT3 FOR BYTE STUFF)
BINDE:	MAPVA_REFADR_P_P+Q, BAMASK[22], Q_LAC, RETURN[G=1], SETSF[XCT3&K];
*REENTER AT "INDLP" FOR JRST INDIRECT SEQUENCES
INDLP:	IREF, MDR_X, Q_LX, REFADR_P, GOTO[INDLP2,G=0];
	ISPLIT_P_Q, SETSF[INTCONDH], GOTO[INDLP1,H=0];
	P_MAPVA_(MDR) U (ACBASE), A1, CALL[RREFX];
*INDIRECTING THROUGH AC DOESN'T INCREMENT ICTR
INDLP2:	Q_(P) U (ILE), P_ICTR, GOTO[.+2,G=1];
	ICTR_P+1, P_ISPLIT_MDR, SETSF[INTCONDH], GOTO[INDLP1];
	LEFADR_Q, Q_RMQ, CALL[LOADMAP];
	GOTO[INDLP];

XMAPL:	REFADR_P_Q, BAMASK[22], Q_XLE;
	LEFADR_P OR Q, Q_XMQ, CALL[LOADMAP];
*ENTRY HERE WITH PC IN P AFTER MAPVA_PC, 1 IN Q
REMAP1:	XREF, Q_P+Q, P_777777R, SETSF[INTCONDH], DGOTO[XRAC,G=1];
	OLDPC_P_Q_P AND Q, CLEARF[TFLAGS], GOTO[PI1,H=1];
XR2:	PC_Q, Q_P-1, P_ICTR, GOTO[XMAPL,G=1];
XREMAP:	XSPLIT_P_MDR, ICTR_P+1, SETSF[LOGF&K], CALL[REMAPE];

REMAPPC:	ENDM;

XJAC:	OLDPC_P_Q_P AND Q;
XRAC:	PC_Q, Q_LX, P_ICTR, DGOTO[REMAPPC];
	SETSF[LOGF&K], P_XSPLIT_Q, ICTR_P+1, CALL[REMAPE];

XJMP:	XREF, Q_1R, SETSF[INTCONDH], DGOTO[XJAC,G=1];
	Q_P+Q, P_777777R, CLEARF[TFLAGS], DGOTO[PI1,H=1];
	OLDPC_P_Q_P AND Q, GOTO[XR2,H=0];

%NPC HOLDS 1ST INSTRUCTION DISPATCH.  INSTRUCTIONS BELOW ARE OPTIONAL
CONTINUATIONS FROM "REMAPE".
I = 3
%
LOGI:	RMW_(LOGT) U (Y), INHINT, CALL[LOGOP];

%THE "LOGF" FLAG CAUSES THE OPCODE TO BE COUNTED IN THE TABLE POINTED
TO BY "LOGT" WHICH MUST BEGIN AT A 1000-WORD BOUNDARY.  "BLT" LOGGING
ISN'T HANDLED CORRECTLY BY THIS, NOR IS INDIRECTION.
%
LOGOP:	P, CALL[PMDR];
BRKRET:	MDR_P+1, WRESTART, P_INSTR, Q_LINDX, GOTO[BINDE];

%THE "LOGF" FLAG CAUSES THE BREAK AND SINGLE-STEP FEATURE TO BE INVOKED.
SINGLE-STEP IF "LOGT" = 0, ELSE COMPARE "LOGT" TO "PC" AND BREAK IF THEY
ARE EQUAL.  CONTINUING FROM THE BREAK WORKS FINE.

BRKI:	Q_LOGT, CALL[BRKTST];

BRKTST:	AQ, P_PC;
	P_P-1, FRZBALUBC, DGOTO[BRKRET,ALU=0];
	P#Q, SETSF[K], CALL[SPUNT,ALU=0];
	CALL[SPUNT,ALU=0];
%

%ROUTINES TO SETUP THE ARGUMENTS FOR A TASK IN A STANDARD FORM.
MOST PDP-10 INSTRUCTIONS COME IN GROUPS, EACH ELEMENT OF WHICH
PERFORMS THE SAME CONCEPTUAL TASK BUT GETS ITS ARGUMENTS IN A
DIFFERENT WAY OR STORES AWAY ITS RESULTS IN A DIFFERENT WAY.
THE MAIN LOOP LEAVES E IN P AND AC IN Q.  THIS IS THE STANDARD FORM
FOR IMMEDIATE INSTRUCTIONS.  NON-IMMEDIATE INSTRUCTIONS USUALLY
LEAVE [E] IN P AND AC IN Q, ALSO.
RARG AND RMWARG ARE CALLED AFTER MAPVA_P_E.  THEY LEAVE MEMORY DATA [E]
IN P AND THE AC IN Q.  WHEN THE FETCH IS NOT FROM AN AC, THE MEMORY
DATA IS ALSO LEFT IN WDATA.
I = 13
%
RMAPL:	LEFADR_P, Q_RMQ, CALL[LOADMAP];
RARG:	RREF, Q_REFADR_P, GOTO[.+3,G=0], P_LX;
	Q_LAC, RETURN[H=0], STEMP_Q;
	MAPVA_Q_(X) U (ACBASE), A1, CALL[RREFX];  *FOR THE AC TEST MUST DO A1
	GOTO[RMAPL,G=1], P_(RLE) U (Q);
TPMDR:	STEMP_Q;	*FOR MULTIPLY AND ANY OTHER INSTRUCTIONS
			*WHICH DO A READ FOLLOWED BY A WRITE
			*RATHER THAN A READ-MODIFY-WRITE REFERENCE
RARG1:	WDATA_P_MDR, Q_LAC, RETURN;

RW0:	P_(RMWLE) U (Q), GOTO[RARG1,G=0];
	LEFADR_P, Q_RMWMQ, CALL[LOADMAP];
RMWARG:	RMWREF, Q_REFADR_P, P_LX, GOTO[RW0,G=0], INHINT;
	Q_LAC, RETURN[H=0];
	MAPVA_Q_(X) U (ACBASE), A1;
	RMWREFDXK, INHINT, GOTO[RW0];

%THOSE SUBROUTINES WHICH CAN OVERLAP WORK WITH MEMORY FETCH TIME
GENERALLY LEAVE THE MEMORY ARGUMENT IN MDR.  RTOMDR RETURNS AC IN P,
1 000001 IN Q.  USED BY PUSH, DATAO PI
I = 8
%
RM0:	P_LAC, Q_(2 000002R) RSH 1, RETURN[G=0], STEMP_Q;
	P_STEMP, DGOTO[RTOMDR];
	Q_RMQ, LEFADR_P, CALL[LOADMAP];
*USED BY POP AND POPJ
POPX:	RTEMP_P, P_Q, SETF[J], CALL[JUMPA];
RTOMDR:	RREF, Q_(REFADR_P) U (RLE), P_LX, GOTO[RM0,G=0];
	MDR_P, Q_(2 000002R) RSH 1, RETURN[H=0], P_LAC;
	MAPVA_Q_(X) U (ACBASE), A1;
	RREFDXK, Q_(Q) U (RLE), GOTO[RM0];

%IQARG, RQARG, AND RMWQARG REVERSE AC AND E (OR [E]) AS LEFT BY
MAIN LOOP, RARG, AND RMWARG, RESPECTIVELY.
I = 13
%
*USED BY SUBI, HRLI, HRLZI, HRLOI, HRLEI, HLROI
IQARG:	Q_P, P_LAC, RETURN;

*USED BY SUB, HRL,HRLZ, HLRZ, HLRO, HLR, HRLE, HRLO, KGO
RQL:	LEFADR_P, Q_RMQ, CALL[LOADMAP];
RQARG:	RREF, REFADR_P, GOTO[.+3,G=0], Q_LX;
	P_LAC, RETURN[H=0];
	MAPVA_P_(X) U (ACBASE), A1, CALL[RREFX];
	GOTO[RQL,G=1], P_(RLE) U (P);
	WDATA_Q_MDR, P_LAC, RETURN;

*USED BY SUBM, SUBB, HLROS, HLRZS, HRLES, HRLOS, HRLZS, MOVSS
RWQ0:	P_(RMWLE) U (P), GOTO[.-1,G=0];
	LEFADR_P, Q_RMWMQ, CALL[LOADMAP];
RMWQARG: RMWREF, REFADR_P, Q_LX, GOTO[RWQ0,G=0], INHINT;
	P_LAC, RETURN[H=0];
	MAPVA_P_(X) U (ACBASE), A1;
	RMWREFDXK, INHINT, GOTO[RWQ0];

%SRARG AND ESWAP ARE THE SAME AS RARG AND THE MAIN LOOP EXCEPT THAT
THEY RCY THE MEMORY ARGUMENT 22 BEFORE RETURNING.  THESE ARE USED BY THE
TEST-AND-SET AND MOVS INSTRUCTIONS.
I = 8
%
ESWAP:	Q_P, SETSF[H];
SRAC:	PQ RCY [22], Q_LAC, RETURN[H=0];
	MAPVA_P_(X) U (ACBASE), A1, CALL[RREFX];
	GOTO[SRARG0,G=0], Q_RLE;
	LEFADR_P OR Q, Q_RMQ, CALL[LOADMAP];
SRARG:	RREF, GOTO[SRAC,G=1], P_Q_LX, REFADR_P;
	GOTO[.-2,G=1], P_REFADR, Q_RLE;
SRARG0:	P_Q_MDR, CLEARF[H], GOTO[SRAC];

%ROUTINES TO SETUP THE ARGUMENTS FOR THE VARIOUS HALF-WORD INSTRUCTIONS.
THESE ALL LEAVE THE INDICATED ARGUMENT IN P AND 777777 IN Q, WITH
REFADR HOLDING E.
***ELIMINATE AT THE COST OF 1 CYCLE BY USING "RARG" FOLLOWED BY "EHARG"
I = 15
%
*USED BY HLL, HLLZ, HLLO, HLLE, HRR, HRRZ, HRRO
RHL:	LEFADR_P, Q_RMQ, CALL[LOADMAP];
RHARG:	RREF, REFADR_P, GOTO[.+3,G=0];
	P_LX, Q_777777R, RETURN[H=0];
	MAPVA_P_(X) U (ACBASE), A1, CALL[RREFX];
	GOTO[RHL,G=1], P_(P) U (RLE);
	WDATA_P_MDR, Q_777777R, RETURN;

*USED BY HLLM , HRLM, HRLS, HLLZS
RWH0:	GOTO[.-1,G=0], P_(P) U (RMWLE);
	LEFADR_P, Q_RMWMQ, CALL[LOADMAP];
RMWHARG: RMWREF, INHINT, REFADR_P, GOTO[RWH0,G=0];
	P_LX, Q_777777R, RETURN[H=0];
	MAPVA_P_(X) U (ACBASE), A1;
	RMWREFDXK, INHINT, GOTO[RWH0];

EHARG:	Q_777777R, RETURN;

*USED BY HLLI, HLLZM, HLLOM, HLLEM, HLRI, HRROM
ACHARG: REFADR_P, P_LAC, Q_777777S, RETURN;

*FREQUENT USAGE
Q22H:	REFADR_P, QQ RCY [22], INHINT, Q_777777S, RETURN;

%FINISHING ROUTINES

ACCEPT DATA IN Q, WRITE ADDRESS IN P.
MOVEM GOES TO WREFQ DIRECTLY FROM THE MAIN LOOP SO IT IS IMPORTANT FOR THE
INSTRUCTION AT WQTOP TO DO NO MORE THAN THE EXIT INSTRUCTION OF THE
MAIN LOOP.
I = 42
%
*"WQTOP" ALSO EXECUTED WITH A DGOTO PENDING AT IOD+10
WQTOP:	MAPVA_P_P, SAMASK[22];
WREFQ:	WREF, REFADR_P, MDR_Q, GOTO[QTOLX,G=1];
WQTOP0:	P_(P) U (WLE), GOTO[REMAPPC,G=0];
	Q_WMQ, CALL[LOADMAP], LEFADR_P;
	WREF, Q_MDR_WDATA, GOTO[WQTOP0,G=0];
QTOLX:	GOTO[QTOMAC,H=0], P_(X) U (ACBASE);
	MAPVA_P_(P) U (WLE);
	WREFDXK, MDR_Q, GOTO[WQTOP0];

%"WREFP" WRITES DATA IN P TO ADDRESS IN REFADR.
MAPVA_WRITE ADDRESS MUST ALREADY HAVE BEEN DONE.  USED BY MOVSM.
%
HLREM:	REFADR_P, P_LAC, B_Q;
HLREM1:	PQ RCY [22], SAMASK[22], Q_777777R, GOTO[WPONQM,B<0];
WREFP:	WREF, MDR_Q_P, GOTO[QTOLX,G=1], P_REFADR;
	GOTO[WQTOP0];

*FINISHING ROUTINE TO WRITE DATA ALREADY IN MDR TO ADDRESS IN P
*MAPVA_P ALREADY DONE.  ENTERED FROM HLLEM, POP, LMOVEM
WTOP1:	WREF, REFADR_P, GOTO[QTOLX,G=1], Q_MDR;
	GOTO[WQTOP0];

MAGQTOP: GOTO[WREFQ,ALU>=0]; *USED BY MOVMM
NEGQTOP: REFADR_P, P_1S, WREF, DGOTO[QTOLX,G=1], INHINT;  *USED BY MOVNM
*REMEMBER THAT SETOVPC01 WON'T WORK ON P+1
	MDR_Q_P-Q-1, SETOVPC01, P_REFADR;
	GOTO[WQTOP0];

*SAVE 1 UINST PER ROUTINE BELOW AT COST OF 1 CYCLE TIME
WPAQM:	WREF, P_REFADR, MDR_Q_P AND Q, GOTO[QTOLX,G=1];
	GOTO[WQTOP0];
WPANQM:	WREF, MDR_Q_P AND NOT Q, P_REFADR, GOTO[QTOLX,G=1];
	GOTO[WQTOP0];
WPOQM:	WREF, MDR_Q_P OR Q, P_REFADR, GOTO[QTOLX,G=1];
	GOTO[WQTOP0];
WPONQM:	WREF, MDR_Q_P OR NOT Q, P_REFADR, GOTO[QTOLX,G=1];
	GOTO[WQTOP0];
NQB:	WREF, MDR_LAC_Q_NOT Q, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];
NQM:	WREF, MDR_Q_NOT Q, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];
SETZM:	WREF, MDR_Q_A0, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];
SETZB:	WREF, MDR_Q_LAC_A0, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];
SETOM:	WREF, MDR_Q_A1, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];
SETOB:	WREF, MDR_LAC_Q_A1, GOTO[QTOLX,G=1];
	REFADR_P, GOTO[WQTOP0];

HLLEM:	MDR_P AND NOT Q, DGOTO[WTOP1];
	Q_P OR Q, GOTO[WREFQ,ALU<0], P_REFADR;

HRREM:	REFADR_P, QQ RCY [22];
	B_Q_P, GOTO[HLREM1];

%FINISHING ROUTINES WHICH LEAVE RESULT IN AC
I = 25
%
MAGPTOAC: LAC_P, DGOTO[REMAPPC];
MINP:	P_NOT P, Q_1S, GOTO[.+1,ALU<0]; *USED BY MOVN, MOVNI
P+QA:	LAC_P+Q, SETOVPC01, ENDM; *USED BY DFN, ADD, ADDI

PIRDX:	Q_200000S, GOTO[POQA,K=1]; *USED BY PIREAD JMC
PTOAC:	LAC_P, ENDM;
*QTOAC: LAC_Q, ENDM;  *IN "ARITH"
*SETZ:  LAC_A0, ENDM; *IN "ARITH"
SETO:	LAC_A1, ENDM;
NPAQA:	LAC_NOT P AND Q, ENDM;
PXQA:	LAC_P#Q, ENDM;
NPANQA:	LAC_NOT P AND NOT Q, ENDM;
PEQA:	LAC_P=Q, ENDM;
NQA:	LAC_NOT Q, ENDM;
NPA:	LAC_NOT P, ENDM;
NPOQA:	LAC_NOT P OR Q, ENDM;
NPONQA:	LAC_NOT P OR NOT Q, ENDM;
PAQA:	LAC_P AND Q, ENDM;
PANQA:	LAC_P AND NOT Q, ENDM;
*POQA:	LAC_P OR Q, ENDM; *IN "BS"
PONQA:	LAC_P OR NOT Q, ENDM;
HLLA:	Q_P AND NOT Q, P_LAC, SAMASK[22], GOTO[POQA];

HLLEA:	LAC_P AND NOT Q, DGOTO[QTOAC];
	Q_P OR Q, GOTO[REMAPPC,ALU>=0];

HRRA:	MDR_P AND Q, P_LAC;
	P_(MDR) U (P AND NOT Q), GOTO[PTOAC];

HRREA:	Q_400000S, POP;
	P AND Q, Q_777777R, DGOTO[PONQA];
	LAC_P AND Q, RETURN[ALU=0];

HLREA:	P, PQ RCY [22], SAMASK[22], Q_777777R, DGOTO[PONQA], POP;
	LAC_P AND Q, RETURN[ALU>=0];

%FINISHING ROUTINES FOR RMW INSTRUCTIONS.  G MUST NOT HAVE CHANGED
DURING MODIFY.  HENCE G=0 ON NORMAL AND ACBASE REFERENCES AND
G=1 ONLY FOR AC REFERENCES.
I = 62
%
PTOMAC:	LX_P, ENDM;
QTOMCHK: GOTO[REMAPPC,G=0];
QTOMAC:	LX_Q, ENDM;
QTOM:	MDR_Q, WRESTART, GOTO[QTOMCHK];
PTOM:	MDR_Q_P, WRESTART, GOTO[QTOMCHK];
PTOB:	LAC_Q_MDR_P, WRESTART, GOTO[QTOMCHK];
PTOS:	LACS_Q_MDR_P, WRESTART, GOTO[QTOMCHK];
PAQS:	LACS_MDR_Q_P AND Q, WRESTART, GOTO[QTOMCHK];
POQS:	LACS_MDR_Q_P OR Q, WRESTART, GOTO[QTOMCHK];
PONQS:	LACS_MDR_Q_P OR NOT Q, WRESTART, GOTO[QTOMCHK];
PANQS:	LACS_MDR_Q_P AND NOT Q, WRESTART, GOTO[QTOMCHK];
PAQM:	MDR_Q_P AND Q, WRESTART, GOTO[QTOMCHK];
PAQB:	LAC_MDR_Q_P AND Q, WRESTART, GOTO[QTOMCHK];
PANQM:	MDR_Q_P AND NOT Q, WRESTART, GOTO[QTOMCHK];
PANQB:	LAC_MDR_Q_P AND NOT Q, WRESTART, GOTO[QTOMCHK];
NPAQM:	MDR_Q_NOT P AND Q, WRESTART, GOTO[QTOMCHK];
NPAQB:	LAC_MDR_Q_NOT P AND Q, WRESTART, GOTO[QTOMCHK];
PXQM:	MDR_Q_P#Q, WRESTART, GOTO[QTOMCHK];
PXQB:	LAC_MDR_Q_P#Q, WRESTART, GOTO[QTOMCHK];

POQM:	MDR_Q_P OR Q, WRESTART, GOTO[QTOMCHK];
POQB:	LAC_MDR_Q_P OR Q, WRESTART, GOTO[QTOMCHK];
NPANQM: MDR_Q_NOT P AND NOT Q, WRESTART, GOTO[QTOMCHK];
NPANQB: LAC_Q_MDR_NOT P AND NOT Q, WRESTART, GOTO[QTOMCHK];
PEQM:	MDR_Q_P=Q, WRESTART, GOTO[QTOMCHK];
PEQB:	LAC_MDR_Q_P=Q, WRESTART, GOTO[QTOMCHK];
PONQM:	MDR_Q_P OR NOT Q, WRESTART, GOTO[QTOMCHK];
PONQB:	LAC_Q_MDR_P OR NOT Q, WRESTART, GOTO[QTOMCHK];
NPM:	MDR_Q_NOT P, WRESTART, GOTO[QTOMCHK];
NPB:	LAC_Q_MDR_NOT P, WRESTART, GOTO[QTOMCHK];
NPOQM:	MDR_Q_NOT P OR Q, WRESTART, GOTO[QTOMCHK];
NPOQB:	LAC_MDR_Q_NOT P OR Q, WRESTART, GOTO[QTOMCHK];
NPONQM:	MDR_Q_NOT P OR NOT Q, WRESTART, GOTO[QTOMCHK];
NPONQB:	LAC_MDR_Q_NOT P OR NOT Q, WRESTART, GOTO[QTOMCHK];

*! MAXC1 ONLY
HLLM:	WRESTART, MDR_P AND Q, P_LAC, DGOTO[QTOMAC];
	Q_(MDR) U (P AND NOT Q), INHINT, GOTO[WABS,G=0]; **SHORT PATH PROBLEM

HRLM:	MDR_P AND Q, Q_LAC, DGOTO[.-1]; **SHORT PATH PROBLEM
	REFADR_P, QQ RCY [22], WRESTART, Q_777777S, DGOTO[QTOMAC];

*EXTRA WRESTART SHOULDN'T HURT
HLRM:	MDR_P AND NOT Q, P_Q_LAC, WRESTART;
	PQ RCY [22], SAMASK[22], Q_MDR, INHINT, GOTO[POQM];

HRRM:	WRESTART, MDR_P AND NOT Q, P_LAC, DGOTO[QTOMAC,G=1]; **SHORT PATH PROBLEM
	Q_(MDR) U (P AND Q), INHINT, GOTO[WABS,G=0];
*!
*~ MAXC2 ONLY (READING MDR AFTER WRESTART ILLEGAL ON MAXC2)
POQMAC:	LX_P OR Q, ENDM;

HLLM:	WRESTART, RTEMP_P AND Q, P_LAC;
	P_P AND NOT Q, Q_RTEMP, INHINT, GOTO[POQMAC,G=1];
POQMM:	MDR_P OR Q, GOTO[REMAPPC];
HRLM:	RTEMP_P AND Q, Q_LAC, DGOTO[.-2];
	REFADR_P, QQ RCY [22], WRESTART, Q_777777S;

HLRM:	RTEMP_P AND NOT Q, P_Q_LAC, WRESTART, DGOTO[POQMM];
	PQ RCY [22], SAMASK[22], Q_RTEMP, INHINT, GOTO[POQMAC,G=1];

HRRM:	WRESTART, RTEMP_P AND NOT Q, P_LAC, DGOTO[POQMM];
	P_P AND Q, Q_RTEMP, INHINT, GOTO[POQMAC,G=1];
*~

HRLS:	P_Q_P AND Q, POP, WRESTART;
	PQ RCY [22], INHINT, DGOTO[REMAPPC];
	MDR_LACS_Q_P OR Q, GOTO[QTOMAC,G=1];

HLRS:	P_Q_P AND NOT Q, WRESTART, POP, GOTO[.-2];

HLLES:	WRESTART, LACS_MDR_P AND NOT Q, GOTO[HLLESAC,G=1];
	INHINT, RETURN[ALU>=0];
	LACS_MDR_P OR Q, RETURN;

HLLESAC: LX_P AND NOT Q, RETURN[ALU>=0];
	LACS_Q_P OR Q, GOTO[QTOMAC];

HLRES:	P, PQ RCY [22], Q_777777R, WRESTART, GOTO[HLRESAC,G=1];
	LACS_MDR_P AND Q, INHINT, RETURN[ALU>=0];
	LACS_MDR_P OR NOT Q, RETURN;

HLRESAC: LACS_P_P AND Q, GOTO[PTOMAC,ALU>=0];
	LACS_Q_P OR NOT Q, GOTO[QTOMAC];

*~ MAXC2 ONLY (EXTRA WRESTART IS NO GOOD ON MAXC2)
MAGPTOS: LACS_MDR_P, WRESTART, GOTO[MAGPTOSAC,G=1];
	P_NOT P, Q_1S, INHINT, GOTO[REMAPPC,ALU>=0];
	LACS_MDR_Q_P+Q, SETOVPC01, GOTO[REMAPPC];

MAGPTOSAC: NOT(LX_P)Q RCY [0], Q_1R, GOTO[REMAPPC,ALU>=0];
	LACS_Q_P+Q, SETOVPC01, GOTO[QTOMAC];

NEGPS:	P_NOT P, Q_1R, WRESTART, DGOTO[QTOMAC];
	LACS_MDR_Q_P+Q, SETOVPC01, GOTO[REMAPPC,G=0];
*~
*! MAXC1 ONLY
MAGPTOS: LACS_MDR_P, WRESTART, GOTO[MAGPTOSAC,G=1];
	P_NOT P, Q_1S, INHINT, GOTO[REMAPPC,ALU>=0];
P+QS:	LACS_MDR_Q_P+Q, SETOVPC01, WRESTART, GOTO[QTOMCHK];
MAGPTOSAC: LX_P, GOTO[REMAPPC,ALU>=0];
NEGPS:	P_NOT P, Q_1S, GOTO[P+QS];
*!

NOOPR:	P_P, FRZBALUBC;