ER[DGRL]; *RANDOM NO. TEST OF RM AND LM

%TO ASSEMBLE:  @MI@ DGRL
TO RUN:		MIDAS DGRL
		START;G
%

TARGET[ILC];

*ORIGINAL VALUES FOR RANDOM NO. GENERATOR
SV[X0,7654321];
SV[X1,76543210];
SV[X2,765432100];
SV[X3,7654321000];
SV[X4,76543210000];
SV[X5,765432100000];
SV[X6,654321000007];
SV[X7,543210000076];

SM[SY10,10];
SM[SLC,20]; SVN[RAN]; SVN[RRAN]; SVN[YRAN]; SVN[COUNT];

IM[ILC,20];

MCYCLE:	BRKP[1], COUNT_Q, GOTO[LOOP];
START:	ARM_NULL, INHINT, DGOTO[LOOP];
	IRET, INHINT, COUNT_NULL, CALL[INIRAN];

PQCOMP:	P#Q;
	RETURN[ALU=0];
	BRKP[1], RETURN;

*INITIALIZE RANDOM NO. GENERATOR
INIRAN:	Y_7S;
	Q_SY;
	RAN_Q, RETURN;

*RETURN RANDOM NO. IN Q (USES Y WHICH MUST NOT BE CLOBBERED), CLOBBERS P
RGEN:	P_RAN, GOTO[.+2,Y>=0];
	Y_7S;
	Q_SY;
	Q_P+Q;
	SY_Q;
	RAN_Q, DECY, RETURN;

*SAVE RANDOM NO. GENERATOR STATE IN SM FOR RESTORATION LATER
RMARK:	YRAN_Y;
	Y_7S;
	Q_RAN;
	RRAN_Q;
	Q_SY;
	SY10_Q, DECY;
	GOTO[.-2,Y>=0];
	RETURN, Y_YRAN;

*RESTORE RANDOM NO. GENERATOR STATE
RREST:	Q_RRAN;
	RAN_Q;
	Y_7S;
	Q_SY10;
	SY_Q, DECY;
	GOTO[.-2,Y>=0];
	Y_YRAN, RETURN;

*FIRST LOOP--ADDRESSING FROM X, LM WRITTEN/READ FIRST
LOOP:	X_37S, CALL[RMARK]; *SAVE INITIAL RANDOM NO. GEN. STATE
	CALL[RGEN];	*GET NEXT RANDOM NO. IN Q
	LX_Q, CALL[RGEN];
	RX_Q, DECX;
	GOTO[.-3,X>=0];
	CALL[RREST], X_37S;
LOOP1:	CALL[RGEN];
	P_LX, CALL[PQCOMP];
	CALL[RGEN];
	P_RX, DECX, CALL[PQCOMP];
	GOTO[LOOP1,X>=0];

*SECOND LOOP--ADDRESSING FROM X, RM WRITTEN/READ FIRST
	X_37S, CALL[RMARK];
	CALL[RGEN];
	RX_Q, CALL[RGEN];
	LX_Q, DECX;
	GOTO[.-3,X>=0];
	CALL[RREST], X_37S;
LOOP2:	CALL[RGEN];
	P_RX, CALL[PQCOMP];
	CALL[RGEN];
	P_LX, DECX, CALL[PQCOMP];
	GOTO[LOOP2,X>=0];

*THIRD LOOP--ADDRESSING FROM AC, LM WRITTEN/READ FIRST (FIRST 16 ONLY)
	X_17S, CALL[RMARK];
	AC_X;
	CALL[RGEN];
	LAC_Q, DECX, CALL[RGEN];
	RAC_Q, DECAC, GOTO[.-2,X>=0];
	X_17S, CALL[RREST];
	AC_X;
LOOP3:	CALL[RGEN];
	P_LAC, CALL[PQCOMP];
	DECX, CALL[RGEN];
	P_RAC, DECAC, CALL[PQCOMP];
	GOTO[LOOP3,X>=0];

*FOURTH LOOP--ADDRESSING FROM AC, RM WRITTEN/READ FIRST (FIRST 16 ONLY)
	X_17S, CALL[RMARK];
	AC_X;
	CALL[RGEN];
	RAC_Q, DECX, CALL[RGEN];
	LAC_Q, DECAC, GOTO[.-2,X>=0];
	X_17S, CALL[RREST];
	AC_X;
LOOP4:	CALL[RGEN];
	P_RAC, CALL[PQCOMP];
	DECX, CALL[RGEN];
	P_LAC, DECAC, CALL[PQCOMP];
	GOTO[LOOP4,X>=0];

	P_COUNT;
	Q_P+1, GOTO[MCYCLE];


*LOOPS TO BEAT ON FAILURES WHICH OCCUR ABOVE UNDER APPROXIMATELY EQUAL
*INSTRUCTION SEQUENCES
BEATRX1: INCX, DGOTO[.];	*START HERE AFTER READ FAILURE AT LOOP1+3
	P_RX, DECX, CALL[PQCOMP];

BEATLX1: INCX, DGOTO[.];	*START HERE AFTER READ FAILURE AT LOOP2+3
	P_LX, DECX, CALL[PQCOMP];

BEATRA1: INCAC, DGOTO[.];	*START HERE AFTER READ FAILURE AT LOOP3+3
	P_RAC, DECAC, CALL[PQCOMP];

BEATLA1: INCAC, DGOTO[.];	*START HERE AFTER READ FAILURE AT LOOP4+3
	P_LAC, DECAC, CALL[PQCOMP];

BEATRX2: P_RX, CALL[PQCOMP];	*START HERE AFTER READ FAILURE AT LOOP2+1
	GOTO[.-1];

BEATLX2: P_LX, CALL[PQCOMP];	*START HERE AFTER READ FAILURE AT LOOP1+1
	GOTO[.-1];

BEATRA2: P_RAC, CALL[PQCOMP];	*START HERE AFTER READ FAILURE AT LOOP4+1
	GOTO[.-1];

BEATLA2: P_LAC, CALL[PQCOMP];	*START HERE AFTER READ FAILURE AT LOOP3+1
	GOTO[.-1];