% - - - more crufty debugging version  - - -

	rbase_ rbase[TSP];
	LTEMP0_ Link;


TOP LEVEL;

	rbase_ rbase[InstCount];
InstBreakCheck:
	T_ InstCount_ (InstCount) + 1;
	branch[.+2, carry'], pd_ T - (InstBreak);
		branch[.nextok];

	branch[.+2, alu#0];
:if[BreakPoints];
		nop, breakpoint;
:else;
		RESCHEDULE;
:endif;

	nop;
.nextok:
	call[CHECKREGS];

	rbase_ rbase[RANDNUM], call[.Random];

	LTEMP0_ T, call[.Random];
	LTEMP1_ T, call[.Random];
	Q_ T, call[.Random];
	LTEMP2_ T, call[.Random];
	LTEMP3_ T, call[.Random];
	LTEMP4_ T, call[.Random];
	NARGS_ T, call[.Random];
	DEFHI_ T, call[.Random];
	DEFLO_ T, call[.Random];
	Cnt_ T;

 - - - - - end crufty debugging version

% 
SUBROUTINE;

CHECKREGS:
	rbase_ rbase[LTEMP1];
	LTEMP1_ Link;

TOP LEVEL;

	branch[.+2, R even], TSP, memBase_ StackBR;
		UCodeCheck[TSPODD];

	T_ (PVAR) - (FX.PVAR);
	fetch_ T;
	T_ Md;
	T_ T and (StackMask);
	pd_ T xor (FxtnBlock);
	branch[.+2, alu=0];
		uCodeCheck[BadFrame];

	T_ ESP;
	T_ T - (TSP);
	T _ T rsh 1;
	T_ T - (LEFTOffset);
	pd_ (LEFT) - T;
	branch[.+2, alu=0];
		UCodeCheck[LEFTWRONG];
	pd_ (PSTATE) and not (PS.PCXBAD);
	branch[.+2, alu=0];
		UCodeCheck[PSTATEWRONG];

	T_ (PVAR) - (FXBACK[IVAR]);
	fetch_ T;
	pd_ (IVAR) - (Md);
	branch[.+2, alu=0];
		UCodeCheck[IVARMISMATCH];

SUBROUTINE;
	Link_ LTEMP1;
	return;

SCANSTACK:
	rbase_ rbase[LTEMP1];
	LTEMP1_ Link;

TOP LEVEL;

	pd_ (PVAR) - (10000c);
	branch[.+2, carry];
		branch[.endcheck];
	LTEMP2_ A0, memBase_ StackBR;
	LTEMP3_ A0, branch[.scanstk0];

.scanstack:
	T_ LTEMP2;			* new frame
	pd_ T - (LTEMP3);	* old frame
	branch[.+2, carry]; * new must be greater than old
		ucodecheck[BadFrame];

	LTEMP3_ T;
	
.scanstk0:
	branch[.+2, R even], LTEMP2_ (fetch_ LTEMP2) + 1;
		ucodecheck[BadFrame];
	T_ Md;
	LTEMP2_ (fetch_ LTEMP2) - 1;
	T_ (T) and (StackMask);
	pd_ T - (FreeStackBlock);
	branch[.scanfree, alu=0], pd_ T - (BFBlock);
	branch[.scanbf, alu=0], pd_ T - (FxtnBlock);
	branch[.scanfx, alu=0], pd_ T - (GuardBlock);
	branch[.scanend, alu=0];
	branch[.scanbf];

.scanfree:
		LTEMP2_ (LTEMP2) + (Md), branch[.scanstack];

.scanfx:	* LTEMP2 points to a FX. Could check it here
	T_ (PVAR) - (FX.PVAR);
	pd_ (LTEMP2) - T;
	branch[.+2, alu#0];
		LTEMP2_ ESP, branch[.scanstack];	* was current frame

	T_ (LTEMP2) + (FX.NEXT);
	fetch_ T;
	LTEMP2_ Md, branch[.scanstack];

.scanbf:
	LTEMP2_ (fetch_ LTEMP2) + 1;
	LTEMP4_ Md;											* flags
	LTEMP2_ (fetch_ LTEMP2) + 1;
	T_ (LTEMP4) and (StackMask);
	pd_ T - (BFBlock);
	branch[.scanbfend, alu=0], T_ Md, pd_ T;
	branch[.+2, alu=0];
.bfbad: 	uCodeCheck[StackBad];
	branch[.scanbf];

.scanbfend:
	pd_ (LTEMP4) and (BFResidual);
	branch[.scanresid, alu#0], pd_ T - (LTEMP3);
	branch[.scanstack, alu=0];

.scanbadstack:
	uCodeCheck[StackBad];

.scanresid:
	T_ (LTEMP3) + (2c);
	pd_ T - (LTEMP2);
	branch[.+2, alu#0];
		branch[.scanstack];

.badresid:
	ucodecheck[StackBad];

.scanend:
	memBase_ InterfaceBR;
	fetch_ 7s;
	pd_ (LTEMP2) - (Md);
	branch[.endcheck, alu=0], memBase_ StackBR;
	T_ (LTEMP2) + 1;
	fetch_ T, branch[.scanfree];


SUBROUTINE;
.endcheck:
	Link_ LTEMP1;
	return;


KnowRBase[RANDNUM];

.Random:	T_ LSH[RANDNUM, 11];		* T_ 2^9 * R
	T_ T+(RANDNUM);			* (2^9 + 2^0)* R
	T_ LSH[T, 2];			* (2^11 + 2^2)* R
	T_ T+(RANDNUM);			* (2^11 + 2^2 + 2^0)* R
	T_ T + (33000c);
	T_ RANDNUM_ T+(31c), Return;	* +13849


:endif;* end of checking code
(1792)\f8 1011f0 4f8 15f0 4f8 2061f0 12f8 7f0 20f8 7f0 28f8 7f0 64f8 7f0 51f8 7f0 29f8