ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееFLT1    FLBd	

FLD1    DAT%FLT2    FLBXFLD2    DAT !"STG2    FLBЂ#$%&'()*+,-./012STG2    FLB
Ђ3456789:;<=>?@ABSTG2    FLByCDEFGHIJKLMNOPQRST2T    DATST ** IF PTR * GE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 20.
VAL B = 1 + 0.
READ NEXT B.
TO 21 IF PTR 1 GE 1.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 21.
VAL B = 1 + 0.
READ NEXT B.
TO 22 IF PTR 1 GE 2.
TO 23.
LOC 22.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 2
VAL B = 1 + 0.
READ NEXT B.
TO 02 IF FLG 1 = 1.                         TO ** IF FLG * = *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 02.
VAL B = 1 + 0.
READ NEXT B.
TO 03 IF FLG 1 = 2.
TO 04.
LOC 03.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 04.
VAL B = 1 + ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее                        TO ** IF PTR * = *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 14.
VAL B = 1 + 0.
READ NEXT B.
TO 15 IF PTR 1 = 2.
TO 16.
LOC 15.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 16.
VAL B = 1 + 0.
READ NEXT B.
TO 17 IF PTR 1 NE 2.              ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееFLUB8080S2M UVWXSTG2SUP ASM"YZ[\]STG2MATHASM$^_`abIMPL    DOC
cdFLUB$   SUB
eVDB     ALX,fghijkHELP    DOClmnABSTRACT051opT B.
TO 08 IF VAL 1 = 1.                         TO ** IF VAL * = *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 08.
VAL B = 1 + 0.
READ NEXT B.
TO 09 IF VAL 1 = 2.
TO 10.
LOC 09.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 10.
VAL B = 1 + 0.
READ NEXT B.
TO 11 IF0.
READ NEXT B.
TO 05 IF FLG 1 NE 2.                        TO ** IF FLG * NE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 05.
VAL B = 1 + 0.
READ NEXT B.
TO 06 IF FLG 1 NE 1.
TO 07.
LOC 06.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 07.
VAL B = 1 + 0.
READ NEXееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее          TO ** IF PTR * NE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 17.
VAL B = 1 + 0.
READ NEXT B.
TO 18 IF PTR 1 NE 1.
TO 19.
LOC 18.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 19.
VAL B = 1 + 0.
READ NEXT B.
TO 20 IF PTR 3 GE 1.                        TOBEGIN STAGE2.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
TO 01.                                      TO **
VAL W = 4 + 0.
WRITE NEXT W.
LOC 01.-CATALOG051qrsCRCKLISTCRCtееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее VAL 1 NE 2.                        TO ** IF VAL * NE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 11.
VAL B = 1 + 0.
READ NEXT B.
TO 12 IF VAL 1 NE 1.
TO 13.
LOC 12.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 13.
VAL B = 1 + 0.
READ NEXT B.
TO 14 IF PTR 1 = 1. ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее3.
VAL B = 1 + 0.
READ NEXT B.
FLG A = 1.                                  FLG * = *
TO 24 IF FLG A = 1.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 24.
VAL B = 1 + 0.
READ NEXT B.
VAL A = PTR 3.                              VAL * = PTR *
TO 25 IF VAL A = 
VAL W = 4 + 0.
WRITE NEXT W.
LOC 40.
VAL B = 1 + 0.
READ NEXT B.
TO 41 IF PTR G = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 41.
VAL B = 1 + 0.
READ NEXT B.
VAL H = G + 1.                              VAL * = * + *.
VAL I = 0 - 1.
TO 42 IF VAL H = EACH.
VAL G = F + 1.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 2.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 3.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 4.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 5.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 6.
CHA C = 0.
PTR C = VAL 0.                              PTR * = VAL *
TO 29 IF VAL C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 29.
VAL B = 1 + 0.
READ NEXT B.
TO 30 IF FLG C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 30.
VAL B = 1 + 0.
READ NEXT B.
VAL D = VAL 0.
VAL F = 3 - 1.                              VAL * = * - *
TO 36 IF VAL F = 2.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 36.
VAL B = 1 + 0.
READ NEXT B.
TO 37 IF FLG F = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 37.
VAL B = 1 + 0.
READ NEXT B.
TO 38EXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL C = CHAR.                READ THE CARD NUMBER.
VAL D = CHAR.                READ THE PERIOD.
VAL E = CHAR.                READ A SPACE.
VAL E = CHAR.                READ THE SECOND SPACE.
VAL F = CHAR.         3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 25.
VAL B = 1 + 0.
READ NEXT B.
PTR A = VAL 3.                              PTR * = VAL *
TO 26 IF PTR A = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 26.
VAL B = 1 + 0.
READ NEXT B.
FLG C = 0.
PTR C = VAL 0.
VAL MBER.
VAL D = CHAR.                READ THE PERIOD.
CHAR = VAL C.                REWRITE THE FIRST FOUR COLUMNS.
CHAR = VAL D.
CHAR = VAL E.
CHAR = VAL E.
VAL H = PTR 0.               PRINT OUT PTR 0 - PTR 3.
VAL G = F + H.
CHAR = VAL G.
CHAR = VAR = VAL G.
CHAR = VAL E.
VAL G = F + 7.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 8.
CHAR = VAL G.
CHAR = VAL E.
VAL G = F + 9.
CHAR = VAL G.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL C = CHAR.                READ THE CARD NU= PTR 0.
PTR D = VAL 0.
FLG D = 3.                                  FLG * = *
TO 31 IF PTR D = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 31.
VAL B = 1 + 0.
READ NEXT B.
TO 32 IF VAL D = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 32.
VAL B = 1 + 0.
READ NE IF PTR F = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 38.
VAL B = 1 + 0.
READ NEXT B.
FLG G = 0.
PTR G = VAL 0.
VAL G = 1 - 3.
VAL H = G + 4.
TO 39 IF VAL H = 2.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 39.
VAL B = 1 + 0.
READ NEXT B.
TO 40 IF FLG G = 0.       READ A ZERO.
CHAR = VAL C.                REWRITE THE FIRST FOUR COLUMNS.
CHAR = VAL D.
CHAR = VAL E.
CHAR = VAL E.
VAL G = F + 0.               PRINT THE NUMERIC VAL FIELDS.
CHAR = VAL G.
CHAR = VAL E.                PRINT A SPACE FOLLOWING C = PTR 2.                              VAL * = PTR *
TO 27 IF PTR C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 27.
VAL B = 1 + 0.
READ NEXT B.
TO 28 IF FLG C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 28.
VAL B = 1 + 0.
READ NEXT B.
VAL C = PTR 0.
FLGL E.
VAL H = PTR 1.
VAL G = F + H.
CHAR = VAL G.
CHAR = VAL E.
VAL H = PTR 2.
VAL G = F + H.
CHAR = VAL G.
CHAR = VAL E.
VAL H = PTR 3.
VAL G = F + H.
CHAR = VAL G.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
FLG F = 0.
PTR F TE NEXT W.
LOC 33.
VAL B = 1 + 0.
READ NEXT B.
TO 34 IF FLG E = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 34.
VAL B = 1 + 0.
READ NEXT B.
TO 35 IF PTR E = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 35.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
FLG E = 0.
PTR E = VAL 0.
VAL E = 1 + 3.                              VAL * = * + *
TO 33 IF VAL E = 4.
VAL W = 4 + 0.
WRII.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 42.
VAL B = 1 + 0.
READ NEXT B.
VAL J = I + I.
TO 43 IF VAL J = G.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 43.
VAL B = 1 + 0.
READ NEXT B.
VAL K = H - 1.                              VAL * = * - *
TO 44 IF VAL K =PTR Z = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 73.
VAL B = 1 + 0.
READ NEXT B.
TO 74 IF FLG Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 74.
VAL B = 1 + 0.
READ NEXT B.
TO 75 IF VAL Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 75.
VAL B = 1 + 0.
READ NE NEXT W.
LOC 60.
VAL B = 1 + 0.
READ NEXT B.
TO 61 IF PTR U = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 61.
VAL B = 1 + 0.
READ NEXT B.
FLG V = 0.
VAL V = PTR 0.
PTR V = VAL I.                              PTR * = VAL *
TO 62 IF PTR V = Q.
VAL W =VAL B = 1 + 0.
READ NEXT B.
FLG N = 0.
VAL N = PTR 0.
PTR N = 3 - 2.                              PTR * = * - *
TO 49 IF PTR N = 1.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 49.
VAL B = 1 + 0.
READ NEXT B.
TO 50 IF FLG N = 0.
VAL W = 4 + 0.
WRITE NEXT 0.
PTR Y = P * 3.
TO 69 IF PTR Y = D.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 69.
VAL B = 1 + 0.
READ NEXT B.
TO 70 IF FLG Y = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 70.
VAL B = 1 + 0.
READ NEXT B.
TO 71 IF VAL Y = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LO 56.
VAL B = 1 + 0.
READ NEXT B.
PTR T = R - 2.                              PTR * = * - *
TO 57 IF PTR T = P.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 57.
VAL B = 1 + 0.
READ NEXT B.
PTR T = 2 - R.
TO 58 IF PTR T = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LO G.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 44.
VAL B = 1 + 0.
READ NEXT B.
VAL L = 1 - G.
TO 45 IF VAL L = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 45.
VAL B = 1 + 0.
READ NEXT B.
FLG M = 0.
VAL M = PTR 0.
PTR M = 1 + 2.                              PT 0.
FLG X = 0.
PTR D = VAL 9.
PTR X = 3 * 3.                              PTR ' = ' * '
TO 65 IF PTR X = D.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 65.
VAL B = 1 + 0.
READ NEXT B.
TO 66 IF FLG X = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 66.
VAL B = 1 +  4 + 0.
WRITE NEXT W.
LOC 62.
VAL B = 1 + 0.
READ NEXT B.
TO 63 IF FLG V = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 63.
VAL B = 1 + 0.
READ NEXT B.
TO 64 IF VAL V = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 64.
VAL B = 1 + 0.
READ NEXT B.
VAL X = PTRW.
LOC 50.
VAL B = 1 + 0.
READ NEXT B.
TO 51 IF VAL N = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 51.
VAL B = 1 + 0.
READ NEXT B.
PTR O = VAL 5.
PTR P = VAL 4.
PTR P = 0 - P.
FLG O = 0.
VAL O = PTR 0.
PTR O = 2 - O.
PTR P = P + 1.
TO 52 IF PTR OC 71.
VAL B = 1 + 0.
READ NEXT B.
PTR Y = 3 * P.
TO 72 IF PTR Y = D.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 72.
VAL B = 1 + 0.
READ NEXT B.
PTR D = VAL 9.
FLG Z = 0.
VAL Z = PTR 0.
PTR Z = D / 3.                              PTR * = * / *
TO 73 IF C 58.
VAL B = 1 + 0.
READ NEXT B.
FLG U = 0.
PTR U = VAL 0.
VAL U = PTR Q.                              VAL * = PTR *
TO 59 IF VAL U = H.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 59.
VAL B = 1 + 0.
READ NEXT B.
TO 60 IF FLG U = 0.
VAL W = 4 + 0.
WRITR * = * + *
TO 46 IF PTR M = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 46.
VAL B = 1 + 0.
READ NEXT B.
TO 47 IF FLG M = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 47.
VAL B = 1 + 0.
READ NEXT B.
TO 48 IF VAL M = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 48.
0.
READ NEXT B.
TO 67 IF VAL X = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 67.
VAL B = 1 + 0.
READ NEXT B.
PTR X = P * S.
TO 68 IF PTR X = D.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 68.
VAL B = 1 + 0.
READ NEXT B.
PTR D = 0 - D.
FLG Y = 0.
VAL Y = PTR .
PTR Q = 0 - 1.
PTR R = P + 2.                              PTR * = * + *
TO 55 IF PTR R = Q.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 55.
VAL B = 1 + 0.
READ NEXT B.
PTR S = R + Q.
PTR S = S + Q.
TO 56 IF PTR S = P.
VAL W = 4 + 0.
WRITE NEXT W.
LOC = P.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 52.
VAL B = 1 + 0.
READ NEXT B.
TO 53 IF FLG O = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 53.
VAL B = 1 + 0.
READ NEXT B.
TO 54 IF VAL O = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 54.
VAL B = 1 + 0.
READ NEXT BEXT B.
PTR D = 0 - D.
PTR Z = D / S.
TO 76 IF PTR Z = 3.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 76.
VAL B = 1 + 0.
READ NEXT B.
FLG Z = 0.
VAL Z = PTR 0.
PTR Z = D / 3.
TO 77 IF PTR Z = S.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 77.
VAL B = 1 + 0.
READO ** IF PTR * GE * TRANSFERS ON LESS.
    FLG * = * FAILS.
    VAL * = PTR * FAILS.
    PTR * = VAL * FAILS.
    VAL * = PTR * CHANGED PTR FIELD.
    VAL * = PTR * CHANGED FLG FIELD.
    PTR * = VAL * CHANGED VAL FIELD.
    PTR * = VAL * CHANGED FLG B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
TO 99 BY I.
VAL W = 4 + 0.
WRITE NEXT W.
STOP.
LOC 99.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
RETURN BY I.
STOP.
END PROGRAM.
VAL B = 1 T W.
LOC 82.
VAL B = 1 + 0.
READ NEXT B.
TO 83 IF VAL Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 83.
VAL B = 1 + 0.
READ NEXT B.
PTR E = 0 - E.
FLG Z = 0.
VAL Z = PTR 0.
PTR Z = D / E.
TO 84 IF PTR Z = Q.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 84.
FLG * NE * FAILS ON UNEQUAL.
    TO ** IF FLG * NE * TRANSFERS ON EQUAL.
    TO ** IF VAL * = * FAILS ON EQUAL.
    TO ** IF VAL * = * TRANSFERS ON UNEQUAL.
    TO ** IF VAL * NE * FAILS ON UNEQUAL.
    TO ** IF VAL * NE * TRANSFERS ON EQUAL.
    TO .
VAL B = 1 + 0.
READ NEXT B.
TO 93 IF PTR 2 GE Q.                        TO ** IF PTR * GE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 93.
VAL B = 1 + 0.
READ NEXT B.
TO 94 IF PTR S GE 3.
TO 95.
LOC 94.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 95.
VAL B = 1 NEXT B.
TO 78 IF FLG Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 78.
VAL B = 1 + 0.
READ NEXT B.
TO 79 IF VAL Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 79.
VAL B = 1 + 0.
READ NEXT B.
PTR D = VAL 9.
PTR Z = D / S.
TO 80 IF PTR Z = S.
VAL W = 4 +ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее
VAL B = 1 + 0.
READ NEXT B.
TO 85 IF FLG Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 85.
VAL B = 1 + 0.
READ NEXT B.
TO 86 IF VAL Z = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 86.
VAL B = 1 + 0.
READ NEXT B.
VAL F = 0 - 6.
TO 87 IF VAL F = 6.        ** IF PTR * = * FAILS ON EQUAL.
    TO ** IF PTR * = * TRANSFERS ON UNEQUAL.
    TO ** IF PTR * NE * FAILS ON UNEQUAL.
    TO ** IF PTR * NE * TRANSFERS ON EQUAL.
    TO ** IF PTR * GE * FAILS ON GREATER.
    TO ** IF PTR * GE * FAILS ON EQUAL.
    T + 0.
READ NEXT B.
TO 96 IF PTR R GE S.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 96.
VAL B = 1 + 0.
READ NEXT B.
TO 97 IF PTR S GE R.
TO 98.
LOC 97.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 98.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL 0.
WRITE NEXT W.
LOC 80.
VAL B = 1 + 0.
READ NEXT B.
PTR E = VAL 5.
FLG Z = 0.
VAL Z = PTR 0.
PTR Z = D / E.
TO 81 IF PTR Z = 1.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 81.
VAL B = 1 + 0.
READ NEXT B.
TO 82 IF FLG Z = 0.
VAL W = 4 + 0.
WRITE NEX1.  IF FLUB IS CORRECT, OUTPUT CONSISTS ONLY OF NUMBERED LINES.
2.  FIRST TWO LINES RELY ON READ NEXT *, WRITE NEXT * AND VAL * = 1 + 0
    TO ** FAILED.
    TO ** IF FLG * = * FAILS ON EQUAL.
    TO ** IF FLG * = * TRANSFERS ON UNEQUAL.
    TO ** IF .
TO 90 IF PTR R = 1.                         TO ** IF PTR * = *
TO 91.
LOC 90.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 91.
VAL B = 1 + 0.
READ NEXT B.
TO 92 IF PTR S NE 1.                        TO ** IF PTR * NE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 92                 TO ** IF VAL * = *
TO 88.
LOC 87.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 88.
VAL B = 1 + 0.
READ NEXT B.
TO 89 IF VAL F NE 8.                        TO ** IF VAL * NE *
VAL W = 4 + 0.
WRITE NEXT W.
LOC 89.
VAL B = 1 + 0.
READ NEXT B FIELD.
    FLG * = * CHANGEDTMTR FIELD.
    FLG * = * CHANGED VAL FIELD.
3.  BASIC CONDITIONALS AND ASSIGNMENTS (VAL TO PTR, PTR TO VAL AND FLG
4.  TO FLG) HAVE BEEN CHECKED WITH POSITIVE OPERANDS.
    VAL * = * + * FAILS FOR ALL +.
    VAL * = * + ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееOP2 + INTEGRAL RESULT.
    PTR * = * / * CHANGED FLG FIELD  OP1 - OP2 + INTEGRAL RESULT.
    PTR * = * / * CHANGED VAL FIELD  OP1 - OP2 +.
    PTR * = * / * FAILS OP1 + OP2 - INTEGRAL RESULT.
    PTR * = * / * FAILS  BOTH + NON-INTEGRAL QUOTIENT.
    LD  RESULT -.
    VAL * = * + * FAILS  OP1 - OP2 + RESULT -.
    VAL * = * + * FAILS  OP1 - OP2 -.
    VAL * = * - * FAILS  OP1 - OP2 +.
    VAL * = * - * FAILS  OP1+ OP2-.
    PTR * = * + * FAILS  ALL +.
    PTR * = * + * CHANGED FLG FIELD.
    PTRE * TRANSFERS ON OP1 - OP2 - OP2 GT OP1.
8.  FURTHER CONDITIONAL AND REGISTER ARITHMETIC CHECKING IS COMPLETE.
9.  IF LINE 10 IS MISSING AND 9 DUPLICATED, TO ** BY * FAILED.
10. IF LINE 11 IS MISSING, RETURN BY * FAILED.
11. CHECK OF TO AND RETURN COMP  PTR * = * * * CHANGED VAL FIELD  BOTH +.
    PTR * = * * * FAILS BOTH -.
    PTR * = * * * FAILS  OP1 - OP2 +.
    PTR * = * * * CHANGED FLG FIELD  OP1 - OP2 +.
    PTR * = * * * CHANGED VAL FIELD  OP1 - OP2 +.
    PTR * = * * * FAILS  OP1 + OP2 -.
* CHANGED FLG FIELD  ALL +.
    VAL * = * + * CHANGED PTR FIELD  ALL+.
5.  THE NEXT TWO CARD NUMBERS TEST VAL * = CHAR AND CHAR = VAL *.
6.  0 X X X X X X X X X ARE THE CONTENTS OF VAL 0 - VAL 9.
7.  X X X X ARE THE CONTENTS OF PTR 0 - PTR 3.
    VAL UOTIENT.
    PTR * = * / * CHANGED VAL FIELD  OP1 + OP2 - NON-INTEGRAL QUOTIENT.
    TO ** IF VAL * = * TRANSFERS ON OP1 = -OP2.
    TO ** IF VAL * NE * FAILS ON UNEQUAL, OPPOSITE SIGN.
    TO ** IF PTR * = * TRANSFERS ON OP1 = -OP2.
    TO ** IF PTR PTR * = * / * CHANGED FLG FIELD BOTH + NON-INTEGRAL QUOTIENT.
    PTR * = * / * CHANGED VAL FIELD  BOTH +  NON-INTEGRAL QUOTIENT.
    PTR * = * / * FAILS  OP1 + OP2 - NON-INTEGRAL QUOTIENT.
    PTR * = * / * CHANGED FLG FIELD  OP1 + OP2 - NON-INTEGRAL Q * = * + * CHANGED VAL FIELD.
    PTR * = * - * FAILS ALL +.
    PTR * = * - * CHANGED FLG FIELD ALL +.
    PTR * = * - * CHANGED VAL FIELD  ALL +.
    PTR * = * - * FAILS  RES. - OR PTR * = * + * FAILS OP 1 -.
    PTR * = * - * CHANGED FLG FIELD  RESLETED.
 AND 9 DUPLICATED, TO ** BY * FAILED.
10. IF LINE 11 IS MISSING, RETURN BY * FAILED.
11. CHECK OF TO AND RETURN COMPIS MISSING AND 9 DUPLICATED, TO ** BY * FAILED.
10. IF LINE 11 IS MISSING, RETURN BY * FAILED.
11. CHECK OF TO AND RETURN COMP
    PTR * = * / * FAILS  BOTH + INTEGRAL RESULT.
    PTR * = * / * CHANGED FLG FIELD  BOTH + INTEGRAL RESULT.
    PTR * = * / * CHANGED VAL FIELD  BOTH + INTEGRAL RESULT.
    PTR * = * / * FAILS  BOTH - INTEGRAL RESULT.
    PTR * = * / * FAILS  OP1 - * = * - * FAILS  ALL +.
    VAL * = * - * CHANGED FLG FIELD  ALL+.
    VAL * = * - * CHANGED PTR FIELD  ALL+.
    VAL * = * - * FAILS RES. - OR VAL * = * + * FAILS OP1 -.
    VAL * = * - * CHANGED FLG FIELD  RESULT -.
    VAL * = * - * CHANGED PTR FIE* NE * FAILS ON UNEQUAL, OPPOSITE SIGN.
    TO ** IF PTR * GE * FAILS ON OP1 + OP2 -  ABS OP1 GT ABS OP2.
    TO ** IF PTR * GE * TRANSFERS ON OP1 - OP2 + ABS OP1 GT ABS OP2.
    TO ** IF PTR * GE * FAILS ON OP1 - OP2 - OP1 GT OP2.
    TO ** IF PTR * GVAL * = PTR * CHANGED FLG ON -.
    VAL * = PTR * CHANGED PTR ON -.
    PTR * = VAL * FAILS ON -.
    PTR * = VAL * CHANGED FLG ON -.
    PTR * = VAL * CHANGED VAL ON -.
    PTR * = * * * FAILS BOTH +.
    PTR * = * * * CHANGED FLG FIELD  BOTH +.
  ULT -.
    PTR * = * - * CHANGED VAL FIELD  RESULT -.
    PTR * = * + * FAILS  OP1 - OP2 + RESULT -.
    PTR * = * + * FAILS  OP1 - OP2 -.
    PTR * = * - * FAILS  OP1 - OP2 +.
    PTR * = * - * FAILS  OP1 + OP2 -.
    VAL * = PTR * FAILS ON -.
    BEGIN STAGE2.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT WE 0.
TO 21 IF FLG X NE 0.
TO 22.
LOC 21.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 22.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = 0 + Y.
PTR X = X / 2.                         PTR X = X / *
TO 23 IF PTR X NE 3.
TO 23 IF VAL X NE 0.
 09 IF FLG X NE 0.
TO 09 IF PTR X NE 0.
TO 10.
LOC 09.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 10.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR Y = VAL 6.
PTR X = VAL 4.
PTR X = X + 2.                         PTR X = X + *
TO 11 IF PTR NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
FLG X = 3.                   TEST TO ENSURE THAT A MESSAGE DOES NOT
VAL X = 4 + 0.               CORRUPT THE REGISTER WHICH SPECIFIES THE
PTR X = 2 + 0.               CHANNEL, AND THAT IT RETURNS THE PROPER FLG
MEIF VAL X NE 0.
TO 17 IF FLG X NE 0.
TO 18.
LOC 17.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 18.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 2.
PTR X = X * 3.                         PTR X = X * *
TO 19 IF PTR X NE Y.
TO 19 IF VA NE 5.
TO 05 IF PTR X NE 0.
TO 05 IF FLG X NE 0.
TO 06.
LOC 05.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 06.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
PTR X = VAL 0.
VAL X = PTR 3.
VAL X = X - 2.                         VAL X = X - *
TO 07 IF VAL X NE 1.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 3 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL W = 4 + 0.
MESSAGE CONV TO W.           PRINT THE CONVERSION ERROR MESSAGE.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRIY.
TO 13 IF VAL X NE 0.
TO 13 IF FLG X NE 0.
TO 14.
LOC 13.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 14.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 5.
PTR X = X - 3.                         PTR X = X - *
TO 15 IF PTR X NE 2.
TX NE Y.
TO 11 IF VAL X NE 0.
TO 11 IF FLG X NE 0.
TO 12.
LOC 11.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 12.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 3.
PTR X = 3 + X.                         PTR X = * + X
TO 13 IF PTR X NE SSAGE IOCH TO X.           PRINT THE I/O ERROR MESSAGE
VAL B = 1 + 0.
READ NEXT B.
TO 65 IF VAL X = 4.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 65.
TO 70 BY D.
VAL B = 1 + 0.
READ NEXT B.
FLG C = 2.
FLG D = C.                             FLG * = *
TO 0L X NE 0.
TO 19 IF FLG X NE 0.
TO 20.
LOC 19.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 20.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 3.
PTR X = 2 * X.                         PTR X = * * X
TO 21 IF PTR X NE Y.
TO 21 IF VAL X N.
TO 07 IF PTR X NE 0.
TO 07 IF FLG X NE 0.
TO 08.
LOC 07.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 08.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
PTR X = VAL 0.
VAL X = PTR 3.
VAL X = 7 - X.                         VAL X = * - X
TO 09 IF VAL X NE 4.
TOTE NEXT W.
VAL W = 4 + 0.
MESSAGE EXPR TO W.           PRINT THE EXPRESSION ERROR MESSAGE.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL W = 4 + 0.
MESSAGE FULL TO W.           PRINT THE SPACE OVERFLOW MESSAGE.
VAL B = 1 + 0.
READ O 15 IF VAL X NE 0.
TO 15 IF FLG X NE 0.
TO 16.
LOC 15.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 16.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 2.
PTR X = 3 - X.                         PTR X = * - X
TO 17 IF PTR X NE 1.
TO 17 VAL X NE 7.
TO 03 IF PTR X NE 0.
TO 03 IF FLG X NE 0.
TO 04.
LOC 03.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 04.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 3.
PTR X = VAL 0.
VAL X = 2 + X.                         VAL X = * + X
TO 05 IF VAL X1 IF FLG C NE 2.
TO 01 IF FLG D NE 2.
TO 01 IF FLG D NE C.
TO 02.
LOC 01.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 02.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 3.
PTR X = VAL 0.
VAL X = X + 4.                         VAL X = X + *
TO 03 IF 
TO 23 IF FLG X NE 0.
TO 24.
LOC 23.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 24.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 2.
PTR X = Y / X.                         PTR X = * / X
TO 25 IF PTR X NE 3.
TO 25 IF VAL X NE 0.
TO 2 3.
PTR C = 0 + 8.
LOC 42.
GET E = C.
TO 43 IF FLG E NE 0.                        CHECK STO-GET FLG
STO C = D.
GET E = C.
TO 43 IF FLG E NE 3.
PTR C = C + 7.
TO 42 IF PTR C LT 9.
GET E = C.
TO 43 IF FLG E NE 0.
STO C = D.
GET E = C.
TO 43 IF B = 1 + 0.
READ NEXT B.
TO 60 IF VAL X = 4.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 60.
TO 70 BY D.                  CHECK FOR SIDE EFFECTS OF WRITE.
FLG X = 3.
VAL X = 1 + 0.
PTR X = 2 + 0.
READ NEXT X.
TO 61 IF VAL X = 1.
VAL W = 4 + 0.
WRITE NEXT  NE 0.
TO 30.
LOC 29.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 30.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
PTR X = VAL 1.
VAL X = PTR 0.
PTR X = X + X.                         PTR X = X + X
TO 31 IF FLG X NE 0.
TO 31 IF VAL X NE 0.
TO 31 IF PTR X NE 2
VAL B = 1 + 0.
READ NEXT B.
VAL W = 3 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 3 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
TO 39 IF PTR 8 GE 9.
TO 40.
LOC 39.
VA1.
TO 38.
LOC 37.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 38.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
PTR X = 0 + 0.
VAL X = CHAR.
TO 58 IF FLG X NE 0.
TO 58 IF PTR X NE 0.
TO 59.
LOC 58.
5 IF FLG X NE 0.
TO 26.
LOC 25.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 26.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 2.
PTR X = VAL 0.
VAL X = X + X.                         VAL X = X + X
TO 27 IF FLG X NE 0.
TO 27 IF PTR X NE 0.
TO 27 IF  0.
WRITE NEXT Z.
VAL B = 1 + 0.
READ NEXT B.
VAL Z = 2 + 0.
WRITE NEXT Z.
VAL B = 1 + 0.
READ NEXT B.
VAL Z = 2 + 0.
REWIND Z.
VAL Z = 2 + 0.
READ NEXT Z.
VAL Z = CHAR.
VAL Z = CHAR.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT BW.
LOC 61.
TO 70 BY D.
FLG X = 3.
VAL X = 2 + 0.
PTR X = 2 + 0.
REWIND X.
VAL B = 1 + 0.
READ NEXT B.
TO 62 IF VAL X = 2.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 62.
TO 70 BY D.
VAL B = 1 + 0.
READ NEXT B.
VAL X = CHAR.
VAL X = CHAR.
VAL Z = 2 +.
TO 32.
LOC 31.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 32.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 4.
PTR X = X - X.                         PTR X = X - X
TO 33 IF FLG X NE 0.
TO 33 IF VAL X NE 0.
TO 33 IF PTR X NE 0.
TOL W = 4 + 0.
WRITE NEXT W.
STOP.
LOC 40.
VAL B = 1 + 0.
READ NEXT B.
PTR C = 0 + 8.
FLG D = 0.
VAL D = PTR 0.
PTR D = VAL 0.
LOC 41.
STO C = D.                                  STO ZEROS
PTR C = C + 7.
TO 41 IF PTR C LT 9.
STO C = D.
FLG D =VAL W = 4 + 0.
WRITE NEXT W.
LOC 59.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL A = 0 - 1.
CHAR = VAL A.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 3.
VAL X = 4 + 0.
PTR X = 2 + 0.
WRITE NEXT X.
VAL VAL X NE 4.
TO 28.
LOC 27.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 28.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 2.
PTR X = VAL 0.
VAL X = X - X.                         VAL X = X - X
TO 29 IF FLG X NE 0.
TO 29 IF PTR X NE 0.
TO 29 IF VAL X.
TO 63 IF VAL X = Z.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 63.
VAL Z = 2 + 0.
READ NEXT Z.
VAL W = 4 + 0.
WRITE NEXT W.
FLG Z = 0.
VAL Z = 2 + 0.
READ NEXT Z.
VAL B = 1 + 0.
READ NEXT B.
TO 64 IF FLG Z = 1.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 64.X NE Y.
TO 36.
LOC 35.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 36.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR X = VAL 3.
PTR X = X / X.                         PTR X = X / X
TO 37 IF FLG X NE 0.
TO 37 IF VAL X NE 0.
TO 37 IF PTR X NE  34.
LOC 33.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 34.
VAL B = 1 + 0.
READ NEXT B.
FLG X = 0.
VAL X = PTR 0.
PTR Y = VAL 4.
PTR X = VAL 2.
PTR X = X * X.                         PTR X = X * X
TO 35 IF FLG X NE 0.
TO 35 IF VAL X NE 0.
TO 35 IF PTR FLG E NE 3.
TO 44.
LOC 43.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 44.
VAL B = 1 + 0.
READ NEXT B.
VAL D = 0 - 1.
VAL F = 0 - 1.
PTR C = 0 + 8.
LOC 45.
GET E = C.
TO 46 IF VAL E NE 0.                        CHECK STO-GET VAL
STO C = D.
GET E = C.
 MESSAGE DESTROYS THE FLAG OF THE CHANNEL REGISTER.
     FLG * = * FAILS FOR BOTH DESCRIPTORS ALPHABETIC.
     VAL X = X + * FAILS
     VAL X = * + X FAILS
     VAL X = X - * FAILS
     VAL X = * - X FAILS
     PTR X = X + * FAILS
    PTR X = * + X S TO BE READ.
TO 73 IF FLG X = 0.          CORRECT VALUE.
VAL B = 1 + 0.               ENDFILE MESSAGE.
READ NEXT B.
VAL X = X - 1.
TO 72 IF FLG X = 1.
VAL B = 1 + 0.               ILLEGAL OP MESSAGE.
READ NEXT B.
VAL X = X - 1.
TO 72 IF FLG X = 2R E NE F.
TO 50.
LOC 49.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 50.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 51.
VAL X = CHAR.
PTR D = D + 1.
TO 51 IF VAL X NE F.
VAL RATIONS ARE TESTED HERE.
1.  THIS LINE SHOULD APPEAR ONLY ON CHANNEL 3 (MACHINE READABLE OUTPUT)
5.  CONV ERROR MESSAGE SHOULD FOLLOW
6.  EXPR ERROR MESSAGE SHOULD FOLLOW
7.  FULL ERROR MESSAGE SHOULD FOLLOW
8.  IOCH ERROR MESSAGE SHOULD FOLLOW
      W = 4 + 0.
WRITE NEXT W.
STOP.
LOC 53.
CHAR = VAL C.
TO 53 IF FLG C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READ NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
STOP.
LOC 70.                      ROUTINE FOR CHECKING I/O OPERATIONS.
VAL B = 1 TO 46 IF VAL E NE F.
PTR C = C + 7.
TO 45 IF PTR C LT 9.
GET E = C.
TO 46 IF VAL E NE 0.
STO C = D.
GET E = C.
TO 46 IF VAL E NE F.
TO 47.
LOC 46.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 47.
VAL B = 1 + 0.
READ NEXT B.
PTR D = 0 - 1.
PTR F = 0 - 1TE NEXT W.
LOC 73.                      DISCARD FURTHER MESSAGES.
TO 74 IF VAL X = 0.
VAL B = 1 + 0.
READ NEXT B.
VAL X = X - 1.
TO 73.
LOC 74.
RETURN BY D.
END PROGRAM.
ER MESSAGES.
TO 74 IF VAL X = 0.
VAL B = 1 + 0.
READ NEXT B.
VAL X = X.
VAL B = 1 + 0.               FLAG UNCHANGED MESSAGE.
READ NEXT B.
VAL X = X - 1.
TO 72 IF FLG X = 3.
VAL B = 1 + 0.               RUBBISH IN FLAG.
READ NEXT B.
VAL X = X - 1.
LOC 72.                      ERROR MESSAGE OUTPUT.
VAL W = 4 + 0.
WRIB = 1 + 0.
READ NEXT B.
VAL A = CHAR.
VAL B = CHAR.
VAL C = CHAR.
VAL D = CHAR.
VAL E = CHAR.
VAL H = CHAR.
PTR X = VAL 5.
PTR X = X + X.
PTR Y = X * X.
PTR A = D / Y.
PTR B = D / X.
PTR C = B * X.
PTR C = D - C.
PTR E = A * X.
PTR B = B - MESSAGE ALTERS VAL FIELD OF CHANNEL REGISTER.
     MESSAGE ALTERS PTR FIELD OF CHANNEL REGISTER.
     MESSAGE SET ENDFILE ON CHANNEL 4.
     MESSAGE SET ILLEGAL OPERATION ON CHANNEL 4.
     MESSAGE DOES NOT ALTER THE FLAG OF THE CHANNEL REGISTER.
    + 0.               READ POINTER ALTERED MESSAGE.
READ NEXT B.
TO 71 IF PTR X = 2.
VAL W = 4 + 0.               POINTER HAS BEEN ALTERED.
WRITE NEXT W.
LOC 71.                      CHECK FLAG VALUE RETURNED.
VAL X = 4 + 0.               NUMBER OF CARD.
PTR C = 0 + 8.
LOC 48.
GET E = C.
TO 49 IF PTR E NE 0.                        CHECK STO-GET PTR
STO C = D.
GET E = C.
TO 49 IF PTR E NE F.
PTR C = C + 7.
TO 48 IF PTR C LT 9.
GET E = C.
TO 49 IF PTR E NE 0.
STO C = D.
GET E = C.
TO 49 IF PT1.  THIS PROGRAM PERFORMS FURTHER TESTS ON THE FLUB MACROS.  IT SHOULD
2.  BE RUN ONLY AFTER FLT1 HAS BEEN COMPLETED SUCCESSFULLY.  OUTPUT
3.  FROM THIS PROGRAM CONSISTS OF A SERIES OF NUMBERED LINES AND ERROR
4.  MESSAGES.  BOTH REGISTER AND MEMORY OPE NEXT B.
VAL W = 4 + 0.
WRITE NEXT W.
FLG C = 2.
CHAR = VAL C.
VAL B = 1 + 0.
READ NEXT B.
TO 52 IF FLG C = 0.
VAL W = 4 + 0.
WRITE NEXT W.
LOC 52.
VAL B = 1 + 0.
READ NEXT B.
FLG A = 0.
VAL A = 0 - 1.
CHAR = VAL A.
TO 53 IF FLG A = 1.
VALE.
VAL E = PTR A.
VAL E = E + H.
VAL F = PTR B.
VAL F = F + H.
VAL G = PTR C.
VAL G = G + H.
CHAR = VAL A.
CHAR = VAL B.
CHAR = VAL C.
CHAR = VAL D.
CHAR = VAL E.
CHAR = VAL F.
CHAR = VAL G.
VAL W = 4 + 0.
WRITE NEXT W.
VAL B = 1 + 0.
READFAILS
     PTR X = X - * FAILS
     PTR X = * - X FAILS
    PTR X = X * * FAILS
    PTR X = * * X FAILS
     PTR X = X / * FAILS
     PTR X = * / X FAILS
    VAL X = X + X FAILS
    VAL X = X - X FAILS
    PTR X = X + X FAILS
    PTR X = X - X  F          SET UP A VOID SYMBOL TREE.
STO F = 0.
VAL G = 0 + 0.               RESET THE DIGIT COUNT FOR NUMBER CONVERSION
PTR H = 5 * 7.               10*DESCRIPTOR LENGTH.
FLG J = 1.                   FLAG TO TERMINATE CREATED SYMBOL.
PTR J = 0 + 0.

18. THE NEXT LINE TESTS THE SETTING OF FLG=1 ON FILLING THE LINE BUFFER.
     FLG IS NOT SET TO 0 WHEN A SPACE IS INSERTED INTO THE LINE BUFFER
     FLG IS NOT SET TO 1 WHEN -1 IS INSERTED INTO THE LINE BUFFER
19. A FULL LINE OF DOTS PROVES THE FLG IS OT ALTER FLAG OF SPECIFYING REGISTER.
     WRITE NEXT DESTROYS FLAG OF SPECIFYING REGISTER.
     READ NEXT ALTERS VAL FIELD OF SPECIFYING REGISTER.
     READ NEXT ALTERS PTR FIELD OF SPECIFYING REGISTER.
     READ NEXT SETS ENDFILE ON CHANNEL 1.
     0.               SET UP A VOID TEMPLATE TREE.
STO A = I.                   SAVE THE MACRO CHANNEL SPEC.
FLG B = 2.                   PHASE FLAG.
VAL B = CHAR.                SOURCE PARAMETER FLAG.
VAL C = CHAR.                MCT EOL.
PTR C = 9 + 0.  PPEAR ON CHANNEL 3
3.  THIS LINE SHOULD ONLY APPEAR ON CHANNEL 3 (IT IS THE LAST)
14. I/O TESTS COMPLETE.  MEMORY TESTS FOLLOW.
    MEMORY SIZE IS ZERO OR NEGATIVE, FURTHER TESTS ABORTED
     ERROR IN STO-GET IN FLG FIELD.
     ERROR IN STO-GET IN VALAILS
    PTR X = X * X FAILS
    PTR X = X / X FAILS
9.  REGISTER TESTS COMPLETE.  I/O TESTS FOLLOW.
    VAL * = CHAR  ALTERS FLG OR PTR.
10. IF THIS REPEATS, -1 DIDNT CLEAR LINE BUFFER. A BLANK SHOULD FOLLOW.
11. THIS LINE SHOULD BE SEPARATED FROM 1ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееSET PROPERLY BY CHAR = VAL *.
T SET TO 1 WHEN -1 IS INSERTED INTO THE LINE BUFFER
19. A FULL LINE OF DOTS PROVES THE FLG IS O THE LINE BUFFER
     FLG IS NOT SET TO 1 WHEN -1 IS INSERTED INTO THE LINE BUFFER
19. A FULL LINE OF DOTS PROVES THE FLG IS READ NEXT SETS ILLEGAL OPERATION ON CHANNEL 1.
     READ NEXT DOES NOT ALTER FLAG OF SPECIFYING REGISTER.
     READ NEXT DESTROYS FLAG OF SPECIFYING REGISTER.
     REWIND ALTERS VAL FIELD OF SPECIFYING REGISTER.
     REWIND ALTERS PTR FIELD OF SPECIFYI             INITIAL TEXT POINTER.
VAL D = CHAR.                MCT PARAMETER FLAG.
VAL E = CHAR.                ZERO CHARACTER.
PTR E = VAL E.               PREPARE FOR NORMALIZATIONS.
VAL F = CHAR.                SPACE CHARACTER.
PTR F = A + 7.      FIELD.
     ERROR IN STO-GET IN PTR FIELD.
15. MEMORY TESTS COMPLETE.  FURTHER TESTS OF CHARACTER I/O FOLLOW.
16. IF LINE 17 IS WRONG, -1 WAS NOT FOUND AT THE END OF THE LINE BUFFER.
17. 000 CHARACTERS WERE EXTRACTED FROM THIS LINE BEFORE FINDING -1.
0 BY A BLANK LINE.
     WRITE NEXT ALTERS VAL FIELD OF SPECIFYING REGISTER.
     WRITE NEXT ALTERS PTR FIELD OF SPECIFYING REGISTER.
     WRITE NEXT SETS ENDFILE ON CHANNEL 4.
     WRITE NEXT SETS ILLEGAL OPERATION ON CHANNEL 4.
     WRITE NEXT DOES NBEGIN STAGE2.
FLG I = 0.                   SET UP MACRO CHANNEL.
VAL I = 1 + 0.
PTR I = 0 + 0.
READ NEXT I.                 GRAB THE FLAG LINE.
TO 98 IF FLG I NE 0.         QUIT UNLESS ALL IS OK.
VAL A = CHAR.                SOURCE EOL.
PTR A = 8 + D BACK.
13. THIS LINE WAS ALSO READ BACK FROM CHANNEL 2.  IT WAS THE LAST.
     THE LINE BUFFER WAS UNCHANGED BY A READ FROM CHANNEL 2.
     REWIND DOES NOT REPOSITION CHANNEL 2 PROPERLY.
     NO ENDFILE FOUND ON CHANNEL 2.
2.  THIS LINE SHOULD ONLY ANG REGISTER.
     REWIND SET ENDFILE ON CHANNEL 2.
     REWIND SET ILLEGAL OPERATION ON CHANNEL 2.
     REWIND DOES NOT ALTER FLAG OF SPECIFYING REGISTER.
     REWIND DESTROYS FLAG OF SPECIFYING REGISTER.
12. THIS LINE WAS WRITTEN TO CHANNEL 2 AND REAFLG L = 1.                   END-OF-LINE INDICATOR.
VAL L = 0 - 1.               CARRIAGE RETURN IS -1.
PTR L = 0 + 0.               LOCATION COUNTER.
VAL M = CHAR.                LEFT PARENTHESIS.
PTR M = 0 + 0.               RESET THE SKIP COUNT.
FLO REPETITION IN PROGRESS.
PTR C = 9 - 7.               NEW TEXT POINTER.
TO 97 IF PTR 8 GE C.         IS THE SPACE FULL ALREADY, YES.
TO 05 BY D.                  GO PROCESS THE MCT
LOC 05.                      SUBSTITUTE PARAMETERS IN ONE LINE.
PTR 9    WAS THIS A CARRIAGE RETURN, NO.
LOC 04.                      SCANNER.
PTR U = 9 - 7.               SET ALL PARAMETERS UNDEFINED.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 1 BY D.                  START WORKING IN EARNEST.
LOC 01.                      ROUTINE TO READ FROM THE INPUT.
GET I = A.                   RECALL THE CHANNEL SPEC.
READ NEXT I.                 GRAB A LINE.
TO 98 IF FLG I NE 0.         GET OUT UNLESS  9 = J.                   PREVIOUS PARAMTER POINTER.
PTR J = 9 + H.               SET THE CURRENT PARAMETER POINTER.
PTR 9 = 9 - 7.
STO 9 = C.                   PREVIOUS TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = D.                   SAVE THE OLD RETURN ADD  NO, IS THIS A PARAMETER FLAG, NO.
PTR B = I + 0.               YES, SET THE PARAMETER POINTER AND
STO 9 = B.                   STORE IT WITH THE PHASE FLAG.
TO 02.
LOC 03.                      READ THE REMAINDER OF THE LINE.
PTR 9 = I + 0.          G N = 0.                   SET EXPRESSION SIGN POSITIVE.
VAL N = CHAR.                ADDITION OPERATOR.
FLG O = 0.
VAL O = CHAR.                SUBTRACTION OPERATOR.
VAL P = CHAR.                MULTIPLICATION OPERATOR.
VAL Q = CHAR.                DE POINTER.
GET X = Y.                   GRAB THE FIRST INPUT CHARACTER.
FLG Y = 0.                   SET THE STRING UNDEFINED.
PTR Z = A + 0.               SET THE TREE POINTER TO THE TEMPLATE ROOT.
TO 58 BY B.                  CALL THE SCANNER.
TO 503.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR U = U - 7.
STO U = 3.
PTR V = U - 7.
STO V = 3.
PTR U = V - 7.
PTR 9 = U + 0.               FREE SPACE POINTER.
TO 97 IF PTR 8 GE 9.
GET W = A.                   SET UP THE TEMPLATE TREALL IS OK.
PTR I = C + 0.
VAL Y = 0 + 0.
PTR Y = C + 0.
TO 02 IF PTR M = 0.          SHOULD THIS LINE BE SKIPPED, NO.
PTR M = M - 1.               YES, DROP THE SKIP COUNT
TO 01.                       TRY AGAIN.
LOC 02.                      READING RESS.
PTR 9 = 9 - 7.
STO 9 = K.                   SAVE THE CURRENT TEXT POINTER.
PTR K = U + 0.               SET UP THE NEW TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = R.                   SAVE THE OLD REPETITION POINTER.
PTR R = 0 + 0.               SET N     POINT TO THE FIRST FREE SPACE.
VAL I = CHAR.                GRAB ANOTHER CHARACTER.
PTR I = 9 - 7.               SET A POINTER TO THE NEXT CHARACTER.
STO 9 = I.
TO 97 IF PTR 8 GE I.         HAVE WE RUN OUT OF SPACE, YES.
TO 03 IF VAL I NE L.     IVISION OPERATOR.
VAL R = CHAR.                RIGHT PARENTHESIS.
PTR R = 0 + 0.               SET NO REPETITION IN PROGRESS.
PTR 4 = 7 + 7.               LENGTH OF TWO DESCRIPTORS.
PTR 8 = F + 7.               POINT TO THE FIRST AVAILABLE SPACE.
TO 0 IF FLG B = 2.          IS THIS THE DEFINITION PHASE, YES.
TO 56 IF FLG Y = 0.          WAS THERE A DEFINITION, NO.
STO 9 = 1.                   INITIALLY NO CREATED SYMBOLS FOR THIS MACRO
PTR 9 = 9 - H.               SPACE FOR THE CREATED SYMBOLS.
STO                  PUT AWAY THE CHARACTER.
TO 04 IF VAL I = L.          WAS THIS A CARRIAGE RETURN, YES.
TO 03 IF VAL I = A.          HAVE WE COMPLETED THE READ, YES.
VAL Y = Y + 1.               BUMP THE INPUT STRING LENGTH.
TO 02 IF VAL I NE B.       LOOP.
PTR 9 = I + 0.               ADVANCE THE SPACE POINTER.
VAL I = CHAR.                READ THE NEXT CHARACTER.
PTR I = 9 - 7.               POINT TO THE NEXT CHARACTER SPACE.
TO 97 IF PTR 8 GE I.         HAVE WE OVERRUN THE AREA, YES.
STO 9 = I.  = C + 0.               DISCARD ANY JUNK.
PTR Y = 0 + 0.               RESET THE LOOP COUNTER.
LOC 06.
TO 07 IF PTR M = 0.          SHOULD WE SKIP LINES, NO.
PTR Z = K + 7.               RETAIN THE CODE BODY POSITION.
GET K = K.                   SKIPSCANNER.
TO 07 IF FLG Y NE 1.         WAS THE SYMBOL DEFINED, NO.
FLG I = 0.                   PREPARE TO COPY OVER THE SYMBOL VALUE.
GET X = Y.                   NO, GRAB THE FIRST CHARACTER.
LOC 11.                      COPY A PARAMETER TO THE PSEUDO    RETURN ADDRESS.
PTR 9 = 9 - 7.
GET K = 9.                   CODE BODY POINTER.
PTR 9 = 9 - 7.
GET R = 9.                   ITERATION POINTER.
RETURN BY D.
LOC 09.                      DO PARAMETER CONVERSION.
PTR V = J + I.               NO, FINCHANGE IF NOT LOOP END.
PTR Y = Y - 1.               ELSE DECREMANT THE COUNT
TO 06 IF PTR Y GE 0.         AND GO ON IF SKIPPING AN ENTIRE LOOP.
TO 06 IF PTR R = 0.          OR IF THERE IS NO CURRENT LOOP.
PTR U = R - 7.               ELSE TERMINATE THAL I = 8.          REQUEST FOR INTERNAL REPRESENTATION.
MESSAGE CONV TO 4.           THE CONVERSION DIGIT IS UNAVAILABLE.
TO 94 BY B.                  CALL ERROR TRACEBACK.
TO 07.                       CONTINUE WITH THE LINE.
LOC 10.                   HE SPACE EXHAUSTED, YES.
TO 07 IF FLG I = 0.          WAS THAT THE LAST CHARACTER, NO.
PTR Y = C - 9.               SET THE PSEUDO-INPUT LENGTH.
PTR Y = Y / 7.
PTR Y = Y - 1.
VAL Y = PTR Y.
PTR Y = C + 0.
TO 04 IF VAL I NE 1.         WAS THAT THE EN A LINE.
GET I = K.                   GRAB THE TERMINATOR.
TO 08 IF VAL I = 1.          CHECK FOR THE END OF THE MACRO.
PTR M = M - 1.               DECREMENT THE SKIP COUNT.
GET Z = Z.                   GRAB THE FIRST SKIPPED ELEMENT.
TO 06 IF FLG Z X = Y.                   GET THE FIRST CHARACTER.
TO 11 IF VAL I = 0.          COPY CONVERSION.
TO 10 IF VAL I = 1.          SYMBOL REFERENCE.
TO 12 IF VAL I = 2.          LOCATION SYMBOL DEFINITION.
TO 15 IF VAL I = 4.          REQUEST FOR EXPRESSION D THE PARAMETER POINTER.
TO 21 IF VAL I = 6.          SET A PARAMETER.
GET Y = V.                   AND LOAD IT.
TO 45 IF VAL I = 7.          INITIATE REPETITION OVER AN ARGUMENT LIST.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
GET E LOOP.
GET Y = U.
TO 49 IF FLG Y NE 1.         IS IT COUNT CONTROLLED, NO.
PTR C = R + 0.               YES, RESET THE LINE SPACE POINTER.
GET R = R.                   RESTORE ITERATION POINTER.
TO 05.                       IF NOT, CONTINUE.
LOC 07.   DEAL WITH A LOCATION SYMBOL.
PTR V = 9 + 7.               STACK POINTER FOR SCANNER.
GET W = F.                   SET UP THE SYMBOL TREE.
PTR Z = F + 0.               SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.                  CALL ON THE D OF THE CODE BODY, NO.
LOC 08.
PTR 9 = J - H.               RESTORE FROM THE CURRENT RECURSION.
GET J = 9.                   PARAMETER POINTER.
PTR 9 = 9 - 7.
GET C = 9.                   TEXT SPACE POINTER.
PTR 9 = 9 - 7.
GET D = 9.               NE 3.         IGNORE NON FUNCTION CALLS.
PTR Y = Y + 1.               BUMP THE COUNT OF LOOPS ENTERED.
TO 06 IF VAL Z = 7.          LEAVE THE INCREM VALUE IF LOOP ENTERED.
PTR Y = Y - 1.               ELSE DROP IT BACK.
TO 06 IF VAL Z NE 8.         NO CONVERSION.
PTR X = Y + 0.
TO 20 IF VAL I = 3.          REQUEST THE BREAK CHARACTER.
PTR N = VAL Y.
TO 18 IF VAL I = 5.          REQUEST FOR PARAMETER LENGTH.
TO 23 IF VAL Y NE 1.         IF NOT ONE CHARACTER, SIGNAL ERROR.
PTR N = VAL X.
TO 18 IF VIT A COMPILER SWITCH, YES.
PTR I = 9 - 7.               NO, SET THE POINTER TO THE NEXT SPACE.
STO 9 = I.                   PUT THE CHARACTER IN THE PSEUDO-INPUT.
PTR 9 = I + 0.               ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.         IS T                      CHARACTER PROCESSING LOOP.
PTR K = K + 7.               ADVANCE THE POINTER AND
GET I = K.                   FETCH THE NEXT CHARACTER
TO 09 IF FLG I = 2.          IS THIS A PARAMETER CALL, YES.
TO 22 IF FLG I = 3.          NO, IS -INPUT.
TO 07 IF VAL Y = 0.          IS THE PARAMETER VOID, YES.
GET I = X.                   FETCH THE NEXT CHARACTER.
PTR X = 9 - 7.               SET THE POINTER
STO 9 = X.                   AND PUT IT IN THE PSEUDO-INPUT.
PTR 9 = X + 0.           .                       AND INSERT IT IN THE LINE
LOC 17.                      CREATE A NEW SYMBOL.
PTR Y = V + H.               CHECK THAT THERE IS ROOM FOR IT.
TO 23 IF PTR Y = J.          IF NOT, TREAT AS A CONVERSION ERROR.
PTR L = L + 1.           RECOVER A POSSIBLE DIGIT.
PTR W = W + 7.               MOVE THE DIGIT POINTER BACK.
VAL X = X + E.               MAKE THE DIGITS INTO CHARACTERS
PTR X = 8 + 7.               SET UP A POINTER TO THE NEXT SPACE.
STO 8 = X.                   PUT AWAY THE           MOVE A DEFINITION TO THE OUTPUT.
FLG B = 2.                   ALLOW SYMBOL DEFINITION.
GET W = F.                   SET UP THE SYMBOL TREE.
PTR Z = F + 0.               SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.                  CAR 8 GE O.
STO 9 = O.
PTR 9 = O + 0.
PTR N = 0 - N.               MAKE THE NUMBER POSITIVE AND
TO 18.                       STORE DOWN.
LOC 16.                      CONVERSION OF PARAMETER ZERO (LOC. CNTR.)
GET Y = V.                   GRAB THE NEXT C X.               MOVE THE RESULT TO THE VALUE FIELD.
PTR X = V + 0.               THE QUOTIENT IS TO BE OPERATED ON NEXT.
PTR W = W - 7.               ADVANCE THE TEMPORARY STORAGE POINTER.
STO W = X.                   AND SALT AWAY THE RESULT.
VAL Y     POINT TO THE NEXT FREE SPACE.
VAL Y = Y - 1.               DECREMENT THE CHARACTER COUNT.
TO 07 IF VAL Y = 0.          ARE WE DONE, YES.
GET X = I.                   NO, GET THE NEXT CHARACTER.
PTR I = 9 - 7.               SET ITS POINTER.
STO 9 =TR 8 GE 9.
STO U = Y.                   PUT AWAY THE POINTER TO THE DEFINITION.
GET X = Y.                   PICK UP THE FIRST CHAR OF THE DEFINITION.
FLG I = 0.                   CLEAN OUT THE INPUT BUFFER.
TO 11.                       COPY OUT THE VA CHARACTER.
PTR 8 = X + 0.               BUMP THE SPACE POINTER.
TO 14 IF PTR 9 GE W.         DID WE REALLY HAVE ANOTHER DIGIT, YES.
STO 8 = 0.                   PUT IN THE TERMINATOR.
PTR 8 = 8 + 7.               ADVANCE THE SPACE POINTER.
TO 97 IF PLL ON THE SCANNER.
FLG B = 0.                   EXIT THE DEFINITION PHASE.
GET X = Y.
TO 11 IF FLG Y = 1.          IS THIS A NEW SYMBOL, NO.
PTR Y = 8 + 0.               YES, SET UP THE DEFINITION POINTER.
FLG Y = 1.                   MARK IT AS HAVINREATED SYMBOL.
TO 17 IF FLG Y = 1.          IS THIS A SYMBOL, NO.
PTR V = V - 7.               YES, ADVANCE THE CREATED SYMBOL POINTER.
TO 16 IF VAL Y NE I.         IS THIS THE RIGHT SYMBOL, NO.
PTR N = Y + 0.               YES, SET UP ITS VALUE
TO 18= Y + 1.               BUMP THE DIGIT COUNT.
TO 97 IF PTR 8 GE W.         HAVE WE RUN OUT OF ROOM, YES.
TO 13 IF PTR X NE 0.         NO, MUST WE GO ON, YES.
LOC 14.                      MOVE THE DIGITS TO THEIR DESTINATION.
GET X = W.                   I.                   PUT AWAY THE COPY.
PTR 9 = I + 0.               POINT TO THE NEXT FREE SPACE.
TO 97 IF PTR 8 GE 9.         HAVE WE EXHAUSTED THE SPACE, YES.
VAL Y = Y - 1.               NO, DROP THE COUNT OF CHARACTERS.
TO 11.
LOC 12.           LUE.
LOC 15.                      PROCESS AN EXPRESSION PARAMETER.
TO 74 BY P.                  EVALUATE THE EXPRESSION.
TO 18 IF PTR N GE 0.         AND TEST FOR NON-NEGATIVE.
PTR O = 9 - 7.               IF NEGATIVE, INSERT A MINUS SIGN.
TO 97 IF PT                      CONVERT ONE DIGIT AT A TIME.
PTR V = X / 5.               GET THE QUOTIENT BY INTEGER DIVISION.
PTR Z = V * 5.               THE REMAINDER MUST BE FOUND BY MULTIPLYING
PTR X = X - Z.               AND THEN SUBTRACTING.
VAL X = PTRG BEEN DEFINED.
PTR L = L + 1.               BUMP THE LOCATION COUNTER
PTR X = L + 0.               AND INSERT IT AS THE DEFINITION.
PTR W = 9 + 7.               USE STORE AT THE TOP AS TEMPORARY.
VAL Y = 0 + 0.               COUNT THE DIGITS.
LOC 13.     BUMP THE LOCATION COUNTER.
PTR I = L + 0.               SAVE THE NEW VALUE IN THE NEXT SPACE.
STO V = I.
PTR V = V - 7.               FLAG THE NEXT ENTRY AS NO SYMBOL.
GET Y = V.
FLG Y = 1.
STO V = Y.
PTR N = L + 0.               SET UP THE NUMG X = 1.          IF NO CHANNEL NUMBER, TAKE THE DEFAULT.
PTR K = K + 7.               ELSE ADVANCE THE CODE BODY POINTER.
VAL W = X - E.               CONVERT THE DIGIT TO AN INTEGER.
GET X = K.                   CHECK FOR REWIND REQUEST.
TO 24 IF FLG                   SET THE PARAMETER STORE.
PTR C = 9 - 7.               NEXT EMPTY SPACE FOR NEW LINE.
TO 05.
LOC 22.                      DECODE COMPILER SWITCHES.
PTR V = J + 0.               SET A PARAMETER POINTER.
TO 16 IF PTR I = 0.          IS 7.
STO 8 = X.                   AND SALT AWAY THE RESULT.
TO 18 IF PTR N NE 0.         NO, MUST WE GO ON, YES.
LOC 19.                      MOVE THE DIGITS TO THEIR DESTINATION.
GET X = 8.                   RECOVER A POSSIBLE DIGIT.
PTR 8 = 8 - 7.          IF NOT A REQUEST FOR TERMINATION, COMPLAIN
STOP.                        ELSE TERMINATE NORMALLY.
LOC 23.                      ERROR IN CONVERSION DIGIT.
MESSAGE CONV TO 4.           PUT OUT THE MESSAGE.
TO 94 BY B.                  PRODUCE A TRA7 IF PTR 8 GE X.
STO 9 = X.                   AND PUT AWAY THE BREAK CHARACTER.
PTR 9 = X + 0.
TO 07.
LOC 21.                      SET A PARAMETER.
STO 9 = L.                   TERMINATE THE CURRENT LINE.
PTR K = K + 7.               BYPASS THE NEXT BER TO BE CONVERTED.
LOC 18.                      CONVERT PTR X TO CHARACTERS, STORE DOWN.
PTR Y = N / 5.               GET THE QUOTIENT BY INTEGER DIVISION.
PTR Z = Y * 5.               THE REMAINDER MUST BE FOUND BY MULTIPLYING
PTR X = N - Z.              OUTPUT A LINE WITHOUT RESCANNING.
TO 32 IF VAL I = 2.          CHANGE I/O UNITS AND COPY.
TO 33 IF VAL I = 3.          REDEFINE A SYMBOL.
TO 42 IF VAL I = 4.          SKIP ARG 1 LINES UNCONDITIONALLY.
TO 36 IF VAL I = 5.          COMPARE ARG 1 AN THIS A CALL ON PARAMETER ZERO, YES.
TO 08 IF VAL I = 9.          ESCAPE FROM THE CURRENT MACRO.
PTR V = V + 7.               ADVANCE THE PARAMETER POINTER.
PTR K = K + 7.               BYPASS THE CHARACTER FOLLOWING THE SWITCH.
TO 32 IF VAL I = 1.                MOVE THE DIGIT POINTER BACK.
VAL G = G - 1.
VAL X = X + E.               MAKE THE DIGITS INTO CHARACTERS.
PTR X = 9 - 7.               SET UP A POINTER TO THE NEXT SPACE.
STO 9 = X.                   PUT AWAY THE CHARACTER.
PTR 9 = X + 0. CEBACK
TO 07.                       AND THEN CONTINUE.
LOC 32.                      CHECK FOR ALTERNATE OUTPUT UNIT.
GET X = K.                   THIS MIGHT BE A CHANNEL NUMBER.
VAL W = 3 + 0.               THE DEFAULT OUTPUT CHANNEL IS 3.
TO 24 IF FLCHARACTER.
PTR Y = C - 9.               SET UP THE SPECIFICATION OF THE
PTR Y = Y / 7.               CURRENT STRING.
FLG Y = 0.
VAL Y = PTR Y.               LENGTH IN CHARACTERS.
PTR Y = C + 0.               POINTER TO THE FIRST CHARACTER.
STO V = Y.       AND THEN SUBTRACTING.
FLG X = 0.
VAL X = PTR X.               MOVE THE RESULT TO THE VALUE FIELD.
PTR N = Y + 0.               THE QUOTIENT IS TO BE OPERATED ON NEXT.
VAL G = G + 1.               ADVANCE THE TEMPORARY STORAGE COUNT.
PTR 8 = 8 +D ARG 2 AS STRINGS.
TO 39 IF VAL I = 6.          COMPARE ARG 1 AND ARG 2 AS EXPRESSIONS.
TO 43 IF VAL I = 7.          INITIATE A REPETITION UNDER COUNT CONTROL.
TO 47 IF VAL I = 8.          ADVANCE TO THE NEXT MEMBER OF THE LIST.
TO 23 IF VAL I NE 0.        GET THE NEXT CHARACTER
VAL Y = Y - 1.               AND DROP THE NUMBER REMAINING.
TO 20 IF VAL Y NE L.         WAS THAT THE BREAK, NO.
TO 07 IF FLG X = 1.          END-OF-LINE IS THE NULL BREAK.
PTR X = 9 - 7.               SET THE POINTER
TO 9              DROP THE SPACE POINTER.
TO 19 IF VAL G NE 0.         DID WE REALLY HAVE ANOTHER DIGIT, YES.
TO 07.                       NO, GO BACK TO THE LINE PROCESSOR.
LOC 20.                      ADVANCE TO A BREAK CHARACTER.
GET X = X.              X = 1.          IF NONE, CONTINUE.
REWIND W.                    ELSE REWIND THE OUTPUT CHANNEL.
PTR K = K + 7.               AND ADVANCE THE CODE BODY POINTER.
LOC 24.
TO 31 IF VAL I = 2.          INITIATE BLOCK COPYING.
STO 9 = L.                    SET UP THE SYMBOL TREE.
PTR Z = F + 0.               SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.                  CALL ON THE SCANNER.
FLG B = 0.                   RESET PHASE FLAG.
FLG W = Y.                   SAVE THE DEFINITION FLAG.
PTR       IF NO REWIND REQUEST, CONTINUE.
REWIND I.                    ELSE PERFORM THE REWIND
TO 98 IF FLG I NE 0.         AND QUIT UNLESS IT WAS ALL OK.
LOC 29.                      BLOCK COPY FROM INPUT TO OUTPUT.
GET X = V.                   PICK UP TH DIGIT.
TO 28 IF PTR 0 GE Z.
VAL X = I + 0.               IF SO, SAVE FOR FUTURE REFERENCE.
PTR Z = Z * 7.               COMPUTE THE PARAMETER LOCATION
PTR Y = J + Z.               AND GRAB ITS SPECIFICATION.
GET Y = Y.
TO 27 IF FLG Y = 3.          TE LINE
TO 29 IF FLG W = 0.          AND KEEP LOOKING FOR THE TERMINATOR IF OK.
TO 98.                       ELSE I/O ERROR MESSAGE AND QUIT
LOC 33.                      REDEFINE A SYMBOL.
GET Y = V.                   NAME OF THE SYMBOL TO BE REDEFINED.AT THE END OF THE LINE.
CHAR = VAL I.
PTR K = K + 7.               ELSE ADVANCE ALONG THE CODE BODY.
GET I = K.
TO 25.
LOC 31.                      CHECK FOR ALTERNATE INPUT UNIT.
GET I = A.                   RECALL THE CHANNEL SPEC.
TO 29 IF PTR C TERMINATE THE CURRENT LINE.
PTR X = C + 0.               POINT TO THE START OF THE LINE.
TO 57 IF PTR C NE 9.         PUNCH IT IF IT EXISTS.
PTR K = K + 7.
GET I = K.                   GET THE NEXT COLUMN.
TO 25 IF FLG I NE 1.         CONTINUE IF THIS
TO 05 IF FLG I = 1.          QUIT ON ENDFILE
TO 98 IF FLG I NE 0.         GET OUT UNLESS ALL IS OK.
LOC 30.                      CHECK FOR THE TERMINATOR.
TO 05 IF VAL X = 0.          RETURN IF THE MATCH IS COMPLETE.
VAL X = X - 1.               ELSE E PARAMETER SPECIFICATION.
TO 05 IF VAL X = 0.          NO COPYING IF PARAMETER IS VOID.
TO 05 IF FLG X = 3.          OR UNDEFINED.
PTR Y = X + 0.               ELSE SET UP THE ADDRESS OF THE FIRST CHAR.
READ NEXT I.                 GET THE NEXT LINE.
REAT AN UNDEFINED PARAMETER AS VOID.
GET Z = Y.                   PICK UP THE FIRST CHARACTER.
LOC 26.
TO 27 IF VAL Y = 0.          IS THE PARAMETER VOID, YES.
CHAR = VAL Z.                NO, OUTPUT A CHARACTER.
GET Z = Z.                   PICK UP T
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
TO 05 IF VAL Y = 0.          IGNORE THE NULL SYMBOL.
GET X = Y.                   PICK UP THE FIRST CHARACTER.
FLG B = 2.                   ALLOW SYMBOL ENTRY.
GET W = F.                  = 9.          IF NO ALTERNATE INPUT UNIT, CONTINUE.
GET X = C.                   ELSE GRAB THE UNIT NUMBER
VAL I = X - E.               AND CONVERT IT TO AN INTEGER.
STO A = I.                   CHANGE THE CURRENT UNIT IN STORE.
TO 29 IF PTR X = 9.     LINE IS VALID.
PTR K = K - 7.               ELSE BACKSPACE THE CODE BODY
TO 23.                       AND ISSUE AN ERROR MESSAGE.
LOC 25.
PTR Z = VAL I.
PTR Z = Z - E.               SUBTRACT THE CHARACTER ZERO.
TO 28 IF PTR Z GE 5.         CHECK FORDECREMENT THE CHARACTER COUNT
GET Y = Y.                   PICK UP THE NEXT TERMINATOR CHARACTER.
VAL Z = CHAR.                AND INPUT CHARACTER.
TO 30 IF VAL Y = Z.          IF WE ARE STILL MATCHING, GO ON.
WRITE NEXT W.                ELSE WRITE THE SAME DIGIT, YES.
TO 25.
LOC 27.                      FILL A FIELD WITH SPACES.
CHAR = VAL F.
PTR K = K + 7.
GET I = K.
TO 27 IF VAL I = X.
TO 25.
LOC 28.                      COPY A NON-PARAMETER TO THE OUTPUT.
TO 57 IF FLG I = 1.          QUIT HE NEXT CHARACTER OF THE PARAMETER
VAL Y = Y - 1.               AND DROP THE NUMBER REMAINING.
PTR K = K + 7.               ADVANCE THE POINTER.
GET I = K.                   GRAB THE NEXT CHARACTER OF THE CODE BODY
TO 26 IF VAL I = X.          IS IT THW = U + 0.               POINT TO THE DEFINITION POINTER.
PTR Z = Y + 0.               SET THE SYMBOL POINTER
PTR V = V + 7.               GET THE NEW DEFINITION OF THE SYMBOL.
GET Y = V.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
P.          NO, WAS THE CONDITION LT, YES.
TO 41.
LOC 40.                      PARAMETER 1 LT PARAMETER 2.
TO 05 IF VAL I = N.           WAS THE CONDITION GT, YES.
LOC 41.                      THE STRINGS ARE NOT EQUAL.
TO 05 IF VAL I = E.          IS SE PICK UP THE THIRD ARGUMENT
TO 41 IF VAL Y NE Z.         COULD THEY BE EQUAL, NO.
TO 38 IF VAL Y = 0.          TWO NULL STRINGS ARE EQUAL.
PTR X = Z + 0.               POINT X TO THE SECOND STRING.
LOC 37.                      COMPARE THE STRINGS CHAPTR W = Z + 0.               POINT TO THE NEXT SPACE.
GET Z = W.                   GRAB THE OLD CONTENTS OF THE SPACE.
VAL Z = X + 0.               MOVE THE CHARACTER INTO THE SPACE,
STO W = Z.                   RETAINING THE OLD POINTER VALUE.
VAL Y =  EVALUATE THE FIRST PARAMETER.
PTR I = N + 0.               SAVE THE VALUE OF THE FIRST EXPRESSION.
PTR V = J + 4.
GET Y = V.                   SET UP THE SECOND PARAMETER.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
TO 74 BY P.    HECK FOR TERMINATION OF THE DEFINITION.
STO W = 0.                   STORE THE TERMINATOR IF THERE IS NO MORE.
TO 05.
LOC 36.                      COMPARE TWO STRINGS.
GET I = K.                   PICK UP THE CONDITION CODE.
TO 23 IF FLG I NE 0.      TR X = Y + 0.               POINT TO THE FIRST CHARACTER OF THE
FLG Z = 1.                   NEW DEFINITION.  CLEAR OUT THE TEMPORARY
VAL Z = Y + 0.               SET THE NEW SYMBOL LENGTH.
TO 35 IF FLG W NE 1.         WAS THERE A DEFINITION, NO.
STO W, NO.
LOC 38.                      THE STRINGS ARE EQUAL.
TO 05 IF VAL I NE E.         IS THE CONDITON CODE EQ, NO.
TO 42.
LOC 39.                      COMPARE TWO EXPRESSIONS.
GET I = K.                   PICK UP THE CONDITION CODE.
TO 23 IF FLG I NRACTER BY CHARACTER.
GET X = X.                   GRAB THE NEXT CHARACTER OF EACH STRING.
GET Y = Y.
TO 41 IF VAL X NE Y.         ARE THEY EQUAL, NO.
VAL Z = Z - 1.               YES, DROP THE NUMBER REMAINING.
TO 37 IF VAL Z NE 0.         ARE WE DONE Y - 1.               DECREMENT THE CHARACTER COUNT.
TO 35 IF PTR Z = 0.          IS THERE MORE SPACE AVAILABLE, NO.
TO 34 IF VAL Y NE 0.         YES, IS THERE MORE DEFINITION, YES.
TO 05.
LOC 35.                      CREATE NEW SPACE FOR THE DEFINITIO              EVALUATE IT.
PTR V = J + 4.
PTR V = V + 7.
PTR N = N - I.               COMPUTE THE DIFFERENCE.
TO 38 IF PTR N = 0.          WERE THE PARAMETERS EQUAL, YES.
TO 40 IF PTR N GE 0.         NO, WAS THE SECOND LARGER, YES.
TO 05 IF VAL I = O   COMPLAIN IF ILLEGAL CONDITION CODE
PTR K = K + 7.               BYPASS THE NEXT CHARACTER.
GET Y = V.
PTR V = V + 7.
GET Z = V.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
TO 23 IF FLG Z = 3.
PTR V = V + 7.               OTHERWI = Z.                   YES, STORE THE NEW SYMBOL LENGTH.
TO 05 IF VAL Y = 0.          IS THE DEFINITION VOID, NO.
LOC 34.                      INSERT THE NEW DEFINITION IN THE OLD SPACE.
GET X = X.                   GET THE NEXT DEFINITION CHARACTER.
E 0.         COMPLAIN IF ILLEGAL CONDITION CODE
PTR K = K + 7.               BYPASS THE NEXT CHARACTER.
GET Y = V.                   FIRST ARGUMENT SPECIFICATION.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
TO 74 BY P.                     ADVANCE THE CHARACTER POINTER.
GET Z = X.                   GRAB THE NEXT DEFINITION CHARACTER.
PTR X = Z + 0.               ADVANCE THE DEFINITION POINTER.
VAL Y = Y - 1.               DECREMENT THE CHARACTER COUNT.
TO 35 IF VAL Y NE L.         CN.
PTR Z = 8 + 0.               POINT TO THE NEXT AVAILABLE SPACE.
STO W = Z.                   PUT AWAY THE CHARACTER.
PTR 8 = 8 + 7.               ADVANCE THE POINTER
TO 97 IF PTR 8 GE 9.         AND TEST FOR SPACE OVERFILL.
PTR W = Z + 0.          THE CONDITION CODE EQ, YES.
LOC 42.                      SET UP THE SKIP COUNTER.
GET Y = V.
TO 23 IF FLG Y = 3.          ERROR IF PARAMETER IS UNDEFINED.
TO 05 IF VAL Y = 0.          IS IT VOID, YES.
TO 74 BY P.                  CONVERT A POSSIBLE EXPTR Z = Z - 7.               FIRST TIME ROOT POINTER.
TO 48.
LOC 47.                      RE-ENTER FOR NEXT REPETITION.
TO 05 IF PTR R = 0.          IF THERE IS NO REPETITION, GET OUT.
GET Z = R.                   ELSE POINT THE SCANNER TO THE ROOT.
LZ = 1.                   END-OF-LINE.
VAL Z = 0 + 0.               INITIALIZE BREAK COUNT.
PTR Z = 0 + 0.
PTR X = 9 - 7.
LOC 46.                      ADD BREAK CHARACTERS TO THE TREE.
VAL Z = Z + 1.               BUMP THE BREAK COUNT.
STO 9 = Z.     N ITERATION COUNT.
VAL Y = 0 + 0.
PTR Y = N + 1.
STO C = R.                   SAVE THE CURRENT ITERATION POINTER.
PTR Z = R + 0.               PREPARE TO RESTORE IT.
PTR R = C + 0.               SET A NEW ONE.
PTR C = C - 4.
STO C = K.              9 - 7.
STO 9 = R.                   PREVIOUS ROOT POINTER.
PTR 9 = 9 - 7.
STO 9 = C.                   PREVIOUS TEXT POINTER.
PTR 9 = 9 - 7.
STO 9 = V.                   POINTER TO PARAMETER STORE.
PTR 9 = 9 - 7.
STO 9 = Y.                   ORIGINA      SPECIFY THE CURRENT STRING.
PTR W = W / 7.               COMPUTE ITS LENGTH IN CHARACTERS.
FLG W = 0.                   FLAG FOR CONTEXT-CONTROLLED ITERATION.
VAL W = PTR W.               LENGTH IN CHARACTERS.
PTR W = C + 0.               POINTERPRESSION.
PTR M = N + 0.               SET THE COUNT.
TO 05.
LOC 43.                      ITERATE UNDER COUNT CONTROL.
PTR Y = C - 9.               SET UP THE SPECIFICATION OF THE
PTR Y = Y / 7.               CURRENT STRING.
VAL Y = PTR Y.                POINT TO THE ALTERNATIVE.
STO 9 = I.                   CURRENT BREAK CHARACTER.
PTR X = 9 + 0.               SAVE THE CURRENT POSITION FOR AN ALTERNATE.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
TO 46 IF FLG I NE 1.
STO 9 = B.                   ANOTHE              END-OF-LINE.
PTR 9 = 9 - 7.
STO 9 = U.                   RIGHT PAREN.
PTR 9 = 9 - 7.
STO 9 = B.                   PARAMETER FLAG.
PTR 9 = 9 - 7.
PTR K = K + 7.
GET I = K.                   GRAB THE NEXT BREAK.
PTR I = X - 9.               SAVE THE CURRENT CODE BODY POINTER.
LOC 44.                      RE-ENTRY FOR ANOTHER ITERATION.
PTR C = R + 0.               RESET THE TEXT POINTER.
PTR R = Z + 0.               RESET THE ITERATION POINTER.
PTR Y = Y - 1.               DECREMENT L PARAMETER SPEC.
PTR R = 9 - 7.               NEW REPETITION POINTER.
STO R = Z.                   NEW ROOT POINTER.
PTR 9 = R - 7.
STO 9 = W.                   PARAMETER REMAINDER.
PTR 9 = 9 - 4.
STO 9 = K.                   CURRENT TEXT POINTER.
 TO THE FIRST CHARACTER.
PTR 9 = 9 - 7.
FLG B = 2.                   CONSTRUCT THE TREE FOR ARGUMENT SCANNING.
PTR B = 0 + 0.               SET UP THE PARAMETER.
FLG U = 0.                   SET UP THE RIGHT PAREN.
VAL U = R + 0.
PTR U = 7 + 0.
FLG     LENGTH IN CHARACTERS.
TO 07 IF VAL Y = 0.          IF NULL, IGNORE IT.
PTR Y = C + 0.               POINTER TO THE FIRST CHARACTER.
TO 74 BY P.                  EVALUATE THE LINE AS AN EXPRESSION.
FLG Y = 1.                   SET UP THE RESULT AS AR PARAMETER FLAG.
FLG B = 0.                   RESET THE PHASE FLAG.
PTR Z = 9 + 0.               SET UP A POINTER TO THE ROOT LOCATION.
PTR 9 = 9 - 7.
VAL U = M + 0.               SET UP A LEFT PAREN.
STO 9 = U.                   TREE ROOT.
PTR 9 =       RESTORE THE CODE BODY POINTER.
PTR C = C - 7.               NEW SPACE FOR THE NEXT TEXT LINE.
TO 05.
LOC 45.                      ITERATE UNDER CONTEXT CONTROL.
STO 9 = L.                   TERMINATE THE PARAMETER STRING.
PTR W = C - 9.         THE ITERATION COUNT.
TO 05 IF PTR 0 GE Y.         GET OUT IF NO MORE ARE NEEDED.
PTR R = C + 0.               ELSE RESET THE ITERATION POINTER.
PTR C = C - 7.
STO C = Y.                   SAVE THE CURRENT COUNT.
PTR C = C - 7.
GET K = C.             OC 48.                      FIRST TIME ENTRY POINT.
PTR U = R - 7.               REMAINDER OF THE LIST.
GET Y = U.
TO 44 IF FLG Y = 1.          IS THIS ITERATION UNDER COUNT CONTROL, YES.
TO 49 IF FLG Y = 3.          TERMINATE ON AN UNDEFINED PARAMETER54.                      READ AND STORE A NEW MCT LINE.
GET I = A.                   RECALL THE CHANNEL SPECIFIER.
READ NEXT I.                 GRAB THE NEXT LINE.
TO 98 IF FLG I NE 0.         GET OUT UNLESS ALL IS OK.
VAL I = CHAR.                READH AN ESCAPE CHARACTER.
VAL I = CHAR.                PICK UP THE NEXT CHARACTER.
STO 8 = I.                   ASSUME THAT IT IS A SPECIAL TO BE SAVED.
TO 52 IF VAL I = C.          IF IT REALLY IS AN MCT PARAMETER OR END-
TO 52 IF VAL I = D.          OF-E PARAMETER
GET W = Y.                   TO BE FIDDLED.
PTR Y = R - 4.               GET THE NEW VALUE OF THE SPECIFICATION.
TO 97 IF PTR 8 GE Y.
GET Y = Y.
STO W = Y.                   AND PUT IT IN THE PARAMETER SPACE.
TO 05.                        RUN OUT OF ROOM, YES.
VAL I = CHAR.                READ THE NEXT CHARACTER.
STO 8 = I.                   STORE IT.
TO 51 IF VAL I = D.          IS THIS AN ESCAPE CHARACTER, YES.
TO 53 IF VAL I = L.          RECOGNIZE A CARRIAGE CONTROL.
TO 52 IF VAL   RESTORE THE ORIGINAL VALUE OF THE
PTR R = R + 7.               PARAMETER SPECIFICATION.
GET W = R.
STO W = Y.
PTR R = R + 7.
GET C = R.                   RESTORE THE TEXT POINTER.
PTR R = R + 7.
GET R = R.
TO 05.
LOC 50.                      DEF.
TO 49 IF VAL Y = 0.          TERMINATE THE ITERATION ON A NULL REMAINDER
STO U = 0.                   ELSE SET UP ANOTHER SCAN.
PTR U = U - 4.
GET K = U.                   RESET THE CODE BODY POINTER.
PTR V = U + 0.               SET UP THE STACK PO Z - E.               CONVERT FROM A CHARACTER TO AN INTEGER.
PTR Z = VAL I.               PUT AWAY THE SPEC.
STO 8 = Z.
TO 52 IF PTR 0 GE Z.         IF IT IS REALLY A FUNCTION, GO ON.
TO 52 IF PTR Z GE 5.
FLG Z = 2.                   OTHERWISE MAKE ILINE FLAG, THEN GO ON TO THE NEXT CHAR.
VAL I = I - E.               ELSE CONVERT A POSSIBLE DIGIT CHARACTER.
FLG Z = 3.                   ASSUME THAT IT IS A FUNCTION CALL.
VAL Z = CHAR.                GET THE PARAMETER CONVERSION OR FUNCTION.
VAL Z =CONTINUE WITH THE CODE BODY.
LOC 99.                      CHECK AND SERVICE SINGLE-CHARACTER SPLITS.
TO 60 IF VAL Z NE 1.         IF BREAK CHARACTERS USED, GO TO THE SCANNER
FLG X = 0.                   ELSE PICK OFF A SINGLE CHARACTER.
VAL X = Y - 1. I NE C.         NO, WAS IT AN MCT END-OF-LINE, NO.
LOC 53.
PTR Y = 8 + 0.               POINT TO THE CURRENT LINE TERMINATOR.
STO U = Y.                   SET UP THE PREVIOUS TERMINATOR.
PTR U = 8 + 0.               UPDATE THE TERMINATOR ADDRESS.
LOC INE A MACRO.
FLG Y = 1.                   MARK IT AS DEFINED.
VAL Y = L + 0.               LINE TERMINATOR.
PTR 8 = 8 - 7.               PREPARE FOR A SPURIOUS ADVANCE.
TO 54.                       GO GET THE MCT.
LOC 51.                      DEAL WITINTER.
PTR 9 = U - 7.
PTR C = 9 + 0.               RESET THE TEXT ORIGIN.
GET X = Y.                   GRAB THE FIRST CHARACTER AND
TO 99 BY B.                  GO CHECK FOR SINGLE-CHARACTER BREAKOUT.
PTR Y = R + 4.               GET THE ADDRESS OF THT A PARAMETER CONVERSION.
PTR Z = Z * 7.               SET UP THE RELATIVE ADDR OF THE PARAMETER.
STO 8 = Z.
LOC 52.                      PROCESS AN MCT LINE.
PTR 8 = 8 + 7.               ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.         HAVE WERING.
STO U = X.
RETURN BY B.                 RETURN AS THOUGH FROM THE SCANNER.
LOC 49.                      TERMINATE THE ITERATION.
TO 44 IF FLG Y = 1.          IS THIS ITERATION UNDER COUNT CONTROL, YES.
PTR R = R + 7.
GET Y = R.                               DROP THE LENGTH OF THE PARAMETER.
VAL Y = 1 + 0.               SET THE NEW PARAMETER LENGTH TO 1.
PTR U = U + 7.               SAVE THE NEW PARAMETER SPECIFICATION.
STO U = Y.
PTR U = U + 7.               ALSO SAVE THE REMAINDER OF THE ST THE FIRST CHARACTER OF A LINE.
PTR I = 0 + 0.               CLEAN OUT THE INPUT REGISTER.
PTR 8 = 8 + 7.               ADVANCE THE SPACE POINTER.
STO 8 = I.                   PUT IT AWAY.
TO 51 IF VAL I = D.          WAS IT A PARAMETER FLAG, YES.
TO            SET FOR PARAMETER EXTENSION.
PTR Z = Z + 7.
STO V = Z.
PTR U = U + 7.               ADVANCE THE PARAM STORE POINTER.
FLG W = 0.
VAL W = 0 + 0.               SET THE PARAMETER LENGTH TO ZERO.
PTR W = Y + 0.               POINT IT TO THE CURBANDON THE STACK ENTRY.
PTR Q = V + 7.
LOC 60.                      TRY AN ALTERNATIVE.
GET W = Z.                   GRAB THE MACRO CHARACTER.
TO 69 IF FLG W = 1.          IS THIS THE END OF THE MACRO, YES.
TO 62 IF FLG W = 2.          NO, IS IT A PAR         COMMON SYSTEM RETURN POINT.
RETURN BY D.                 REGISTER D IS THE RETURN ADDRESS.
LOC 56.                      PUNCH AN UNRECOGNIZED LINE.
VAL W = 3 + 0.               CHANNEL 3 USED WHEN A LINE IS NOT MATCHED.
PTR X = C + 0.                 SET UP A PARAMETER IF POSSIBLE.
TO 61 IF FLG X = 2.          IS THIS A PARAMETER DEFINITION, YES.
TO 58 IF FLG B = 2.          NO, COULD WE NEED A PARAMETER, NO.
PTR Q = V - 7.               CREATE AN ENTRY FOR THE PARAMETER.
PTR V = Q - 7.
TO = 2.          NO, ARE WE DEFINING, YES.
LOC 59.                      TRY EXTENDING THE PREVIOUS PARAMETER.
TO 70 IF PTR V GE 9.         IS THERE ONE TO EXTEND, NO.
GET Z = V.                   RECALL THE MACRO POINTER.
GET Y = Q.                   YES52 IF VAL I NE C.         WAS IT AN END-OF-LINE, NO.
PTR Y = 8 + 0.               FILL IN THE PREVIOUS TERMINATOR.
STO U = Y.
STO 8 = 1.
PTR 8 = 8 + 7.               ADVANCE THE SPACE POINTER.
TO 97 IF PTR 8 GE 9.         HAVE WE OVERRUN THE AREA, YESERNATIVES FOLLOWING A PARAM
TO 61 IF FLG B = 2.          DO NOT STACK ALTERNATIVES DURING DEFINITION
PTR Q = V - 7.
PTR V = Q - 7.
TO 97 IF PTR 8 GE V.
STO Q = Y.                   SAVE THE INPUT POINTER
PTR W = W + Z.               GET THE ADDRESS OAMETER, YES.
TO 58 IF VAL Y = 0.          NO, IS THIS THE END OF THE INPUT LINE, YES.
TO 58 IF VAL X NE W.         NO, DOES THE CHARACTER MATCH, NO.
TO 61 IF PTR W = 0.          IS THERE AN ALTERNATIVE, NO.
TO 61 IF FLG X = 3.          DO NOT STACK ALT      ADDRESS THE FIRST CHARACTER.
LOC 57.                      LOOP TO PUT OUT THE CHARACTERS.
GET X = X.                   GET THE NEXT ONE.
CHAR = VAL X.                MOVE IT INTO THE LINE BUFFER.
TO 57 IF FLG X NE 1.         HAVE WE REACHED THE E 97 IF PTR 8 GE V.
STO Q = Y.
FLG Z = 2.                   SET UP THE PARAMETER POINTER.
STO V = Z.
FLG X = 3.                   DONT STACK FURTHER ALTERNATIVES.
TO 58.
LOC 63.                      FIRST TIME ENTRY FOR PARAMETERS.
FLG Z = 3.        , RECALL THE INPUT POINTER
GET X = Y.                   AND THE CURRENT CHARACTER
TO 63 IF FLG Z = 2.          IS THIS THE FIRST TIME FOR A PARAMETER, YES
TO 64 IF FLG Z = 3.          NO, IS IT A PARAMETER EXTENSION, YES.
PTR V = Q + 7.               A.
VAL I = CHAR.                GET THE NEXT CHARACTER.
TO 55 IF VAL I NE C.         DID THAT CLOSE THE DEFINITION PHASE, NO.
FLG B = 0.                   YES, RESET THE PHASE FLAG.
TRAP.                               END OF MACROS
LOC 55.             F THE ALTERNATIVE.
STO V = W.
LOC 61.
VAL Y = Y - 1.
PTR Y = X + 0.
GET X = X.                   ADVANCE THE INPUT POINTER
PTR Z = Z + 7.               ADVANCE THE MACRO POINTER.
TO 60.                       CONTINUE MATCHING.
LOC 62.               CHARACTER
TO 57.                       AND CONTINUE.
LOC 58.                      TRY FOR AN ALTERNATIVE MATCH.
PTR Z = W + Z.               GET THE POINTER TO THE ALTERNATIVE.
TO 60 IF PTR W NE 0.         WAS THERE ONE AFTER ALL, YES.
TO 71 IF FLG BND, NO.
WRITE NEXT W.                YES, PUT IT OUT ON THE DESIGNATED CHANNEL.
TO 98 IF FLG W NE 0.         TREAT ANY ERROR AS FATAL.
TO 55 IF VAL X = L.          ELSE IF THE LINE IS COMPLETE, RETURN.
CHAR = VAL X.                ELSE REPRINT THE LASTRENT INPUT CHARACTER.
STO U = W.
TO 60.
LOC 64.                      EXTEND THE CURRENT PARAMETER.
TO 68 IF VAL Y = 0.          CAN IT BE EXTENDED, NO.
TO 68 IF VAL X = R.          FAIL ON AN UNMATCHED CLOSING PAREN.
GET W = U.                   INCR   IS THIS A PLUS, YES.
TO 78 IF VAL X = O.          MINUS.
TO 78 IF VAL X = P.          TIMES.
TO 78 IF VAL X = Q.          DIVIDE.
TO 78 IF VAL X = R.          RIGHT PAREN.
VAL Y = Y + 1.               NOT AN OPERATOR. BUMP SECTION LENGTH.
GET X =  8 GE 9.         HAVE WE OVERRUN THE AREA, YES.
GET X = Y.                   GRAB THE NEXT CHARACTER.
TO 72 IF VAL Y NE 0.         WAS THAT THE LAST, NO.
LOC 73.                      TERMINATE A TREE BRANCH.
FLG X = 1.                   SET THE MACRO TR LENGTH.
TO 65 IF VAL X = M.          IS IT ANOTHER OPEN PAREN, YES.
TO 66 IF VAL X NE R.         NO, IS IT A CLOSE PAREN, NO.
VAL Z = Z - 1.               YES, DROP THE PAREN COUNT.
TO 66 IF VAL Z NE 0.         CONTINUE IF THE COUNT IS NONZERO.
LOC                ELSE GRAB THE NEXT.
PTR Y = S + 0.               POINT TO A POSSIBLE SECTION START.
VAL Y = 0 + 0.               THE STRING IS INITIALLY EMPTY.
TO 77 IF VAL X NE M.         IS THE CHARACTER A LEFT PAREN, NO.
STO 9 = T.                   TINE TO ADD MACRO DEFINITIONS.
PTR W = 8 - Z.               CREATE THE ALTERNATE POINTER.
STO Z = W.                   CHANGE THE CURRENT ALTERNATE.
TO 73 IF VAL Y = 0.          TERMINATE THE BRANCH IF THIS IS THE END.
LOC 72.                      READEASE THE PARAMETER LENGTH.
VAL W = W + 1.
VAL Y = Y - 1.
PTR Y = X + 0.
TO 67 IF VAL X NE M.         IS THIS AN OPEN PAREN, NO.
VAL Z = 0 + 0.               YES, ZERO THE PAREN COUNT.
LOC 65.                      OBTAIN A BALANCED STRING.
VAL Z = Z  9.
RETURN BY B.
LOC 74.                      EXPRESSION PROCESSOR.
PTR O = 9 + 0.               SAVE THE CURRENT TOP OF FREE SPACE.
VAL S = Y + 0.               SET UP THE STRING SPECIFIER.
PTR S = Y + 0.
PTR T = 0 + 0.               INITIAL VALUE OERMINATOR.
PTR X = 0 + 0.               SET FOR NO ALTERNATIVE.
STO 8 = X.
PTR U = 8 + 7.               SET UP A DEFINITION POINTER.
FLG Y = 0.
PTR Y = U + 0.
STO U = Y.
PTR 8 = U + 7.               POINT TO THE FIRST EMPTY SPACE.
TO 97 IF PTR 8 GE67.                      CONTINUE THE SCAN.
GET X = X.                   GET THE NEXT INPUT CHARACTER.
STO Q = Y.                   INCREMENT THE INPUT POINTER.
STO U = W.
TO 60.
LOC 68.                      ABANDON THE CURRENT PARAMETER.
STO U = 3. YES, PUSH THE STACK.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL S = S - 1.               DROP THE STRING LENGTH REMAINING.
PTR S = X + 0.               BUMP THE POINTER.
TO 75.
LOC 77.                      SPECIFIY A SECTION.
TO 78 IF VAL X = N.        THE REMAINDER OF THE TEMPLATE LINE.
VAL Y = Y - 1.
PTR Y = X + 0.
PTR X = 0 + 0.               RESET THE POINTER OF THE CURRENT CHARACTER.
STO 8 = X.                   PUT IT AWAY.
PTR 8 = 8 + 7.               ADVANCE THE SPACE POINTER.
TO 97 IF PTR+ 1.               BUMP THE PARENTHESIS COUNT.
LOC 66.
TO 68 IF VAL Y = 0.          FAIL IF THIS IS THE END.
GET X = X.                   GRAB THE NEXT INPUT CHARACTER.
VAL Y = Y - 1.
PTR Y = X + 0.
VAL W = W + 1.               ELSE BUMP THE PARAMETEF THE EXPRESSION IS ZERO.
TO 75 IF VAL Y NE 0.         IS THE EXPRESSION VOID, NO.
PTR N = 0 + 0.               YES, ITS VALUE IS ZERO.
RETURN BY P.
LOC 75.
VAL T = M + 0.               STACK A LEFT PAREN.
LOC 76.
TO 93 IF VAL S = 0.
GET X = S.    .
LOC 69.
TO 58 IF VAL Y NE 0.         IS THIS A FINAL MATCH, NO.
PTR U = Z + 7.               YES, POINT TO THE DEFINITION SPEC.
GET Y = U.
LOC 70.
RETURN BY B.                 COMMON RETURN POINT FOR PTR B RETURNS.
LOC 71.                      ROU                  SET THE PARAMETER UNDEFINED.
PTR U = U - 7.               DROP THE PARAMETER STORE POINTER BACK.
PTR V = Q + 7.               ABANDON THE STACK ENTRY.
PTR Q = V + 7.
TO 59.                       SEE IF THERE ARE OTHERS TO FALL BACK ONX.                   GRAB THE NEXT CHARACTER.
TO 77 IF VAL S NE Y.         IS THE STRING EXHAUSTED, NO.
VAL X = R + 0.               YES, SET UP A RIGHT PAREN.
VAL S = S + 1.               PRETEND THAT IT WAS IN THE INPUT STRING.
LOC 78.
VAL J = X + 0
TO 91 IF PTR 9 = O.          YES, IS THE STACK EMPTY, YES.
PTR 9 = 9 + 7.               NO, POP IT UP.
GET T = 9.
TO 92 IF VAL S = 0.          IS THERE MORE IN THE EXPRESSION, NO.
GET X = S.                   YES, GRAB THE NEXT CHARACTER.
VAL S = S J = R.          IS THE SECTION OPERATOR A RIGHT PAREN, YES.
TO 90 IF VAL T = M.          NO, IS THE STACK OPERATOR A LEFT PAREN, YES
TO 89 IF VAL J = P.          NO, IS THE SECTION OPERATOR A TIMES, YES.
TO 89 IF VAL J = Q.          NO, IS IT A DIVIDE,  9 + 7.               STACK POINTER FOR SCANNER.
GET W = F.                   SET UP THE SYMBOL TREE.
FLG Y = 0.                   SET THE RESULTING SYMBOL UNDEFINED.
PTR Z = F + 0.               SET THE TREE POINTER TO THE SYMBOL ROOT.
TO 58 BY B.    IF VAL T = Q.          OR DIVIDE.
LOC 90.                      STACK A SECTION.
STO 9 = T.                   PUSH THE STACK.
PTR 9 = 9 - 7.
TO 97 IF PTR 8 GE 9.
VAL T = J + 0.               SET THE OPERATOR
PTR T = N + 0.               AND OPERAND ON     INCORPORATE A DIGIT INTO THE SECTION VALUE.
PTR N = N * 5.               MULTIPLY ACCUMULATOR BY 10.
PTR N = N + U.               ADD CURRENT DIGIT.
LOC 82.
VAL Y = Y - 1.               DROP THE REMAINING LENGTH.
TO 80 IF VAL Y NE 0.         ARE .               SET UP THE SECTION OPERATOR.
PTR N = 0 + 0.               ZERO THE ACCUMULATOR.
VAL S = S - Y.               UPDATE THE STRING POINTER.
VAL S = S - 1.
PTR S = X + 0.
TO 83 IF VAL Y = 0.          A NULL STRING HAS THE VALUE ZERO.
GET X       PLUS.
TO 88.
LOC 85.
PTR T = T - N.
TO 88.
LOC 86.
PTR T = T * N.
TO 88.
LOC 87.
PTR T = T / N.
LOC 88.
VAL T = J + 0.               RESET THE STACK OPERATOR.
TO 76 IF VAL J NE R.         WAS THE SECTION OPERATOR A RIGHT PAREN, NO.
PTR YES.
LOC 84.                      PERFORM A PENDING OPERATION.
TO 87 IF VAL T = Q.          IS THE OPERATOR A DIVIDE, YES.
TO 86 IF VAL T = P.          NO, IS IT A TIMES, YES.
TO 85 IF VAL T = O.          NO, IS IT A MINUS, YES.
PTR T = T + N.                      LOOK UP THE SYMBOL VALUE.
TO 83 IF FLG Y NE 1.         AN UNDEFINED SYMBOL HAS THE VALUE ZERO.
TO 83 IF VAL Y = 0.          A NULL STRING HAS THE VALUE ZERO.
GET X = Y.                   GRAB FIRST CHARACTER OF NON-NULL STRING.
FLG N = 1.TO THE STACK.
TO 76.
LOC 91.                      STACK IS EMPTY.
TO 93 IF VAL S NE 0.         IS THE EXPRESSION EMPTY, NO.
RETURN BY P.                 YES, CORRECT RETURN.
LOC 92.
TO 84 IF VAL T NE M.         IS THE STACK OPERATOR A LEFT PAREN, NO.WE DONE, NO.
TO 83 IF FLG N = 0.          IS THE ACCUMULATOR NEGATIVE, NO.
FLG N = 0.                   YES, RESET THE SIGN BIT.
PTR N = 0 - N.               NEGATE THE CONTENTS.
LOC 83.                      EVALUATE THE CURRENT SECTION.
TO 92 IF VAL  = Y.                   GRAB FIRST CHARACTER OF NON-NULL STRING.
PTR U = VAL X.               CHECK FOR A DIGIT.
PTR U = U - E.
TO 79 IF PTR U GE 5.
TO 81 IF PTR U GE 0.
LOC 79.                      IF FIRST CHARACTER IS NOT A DIGIT, LOOK UP.
PTR V =N = T + 0.               YES, KEEP EVALUATING.
PTR 9 = 9 + 7.               POP THE STACK.
GET T = 9.
TO 92.
LOC 89.                      CHECK PRECEDENCE OF STACK OPERATORS.
TO 86 IF VAL T = P.          EVALUATE IF THE STACK OPERATOR IS TIMES
TO 87       CHECK THE NEXT CHARACTER FOR DIGIT.
GET X = X.                   NO, GRAB THE NEXT CHARACTER.
PTR U = VAL X.               CHECK FOR A DIGIT.
PTR U = U - E.
TO 81 IF PTR U = 0.
TO 93 IF PTR U GE 5.
TO 93 IF PTR 0 GE U.
LOC 81.                                    ASSUME IT IS A MINUS SIGN
TO 82 IF VAL X = O.          AND IF IT IS GO ON TO THE NEXT DIGIT.
FLG N = 0.                   ELSE RESET THE SIGN TO PLUS.
PTR X = Y + 0.               PREPARE FOR A SPURIOUS FETCH.
LOC 80.                - 1.
PTR S = X + 0.
VAL J = X + 0.
TO 92 IF VAL J = R.          IS THE SECTION OPERATOR A RIGHT PAREN, YES.
TO 83 IF VAL J = N.          NO, IS IT A PLUS, YES.
TO 83 IF VAL J = O.          NO, MINUS, YES.
TO 83 IF VAL J = P.          NO, TIMES, YES.
GENERATED SYMBOL 6$
'06 IS GENERATED SYMBOL 7$
'07 IS GENERATED SYMBOL 8$
'08 IS GENERATED SYMBOL 9$
'09 IS GENERATED SYMBOL 10$
'00 IS GENERATED SYMBOL 1$
'01 IS GENERATED SYMBOL 2$
'02 IS GENERATED SYMBOL 3$
'03 IS GENERATED SYMBOL 4$
'04 IS GENееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееEING BUILT.
PTR Y = J + 0.               CURRENT PARAMETER POINTER.
TO 96 IF PTR 9 GE C.         IS THERE A LINE BEING CONSTRUCTED, NO.
STO 9 = L.                   YES, TERMINATE IT.
LOC 95.                      PRINTING LOOP.
GET X = X.             ETER IN FORMATTED OUTPUT 111111111$
$
TYPE 2 '.
TEST CHARACTER IS '10$
TRANSFORMATION 1 YIELDS '11$
TRANSFORMATION 2 YIELDS '12$
TRANSFORMATION 3 YIELDS '13$
TRANSFORMATION 4 YIELDS '14$
TRANSFORMATION 5 YIELDS '15$
PARAMETER 2 WAS SET TO '10'26 '           ISSUE AN ERROR MESSAGE.
TO 94 BY B.                  CALL ERROR TRACEBACK.
STOP.
LOC 98.                      AN I/O ERROR HAS OCCURRED
MESSAGE IOCH TO 4.           ISSUE THE CHANNEL ERROR MESSAGE
TO 94 BY B.                  AND PROVIDE A 
TO 83 IF VAL J = Q.          NO, DIVIDE, YES.
LOC 93.                      ERROR IN ARITHMETIC EXPRESSION.
MESSAGE EXPR TO 4.           ISSUE AN ERROR MESSAGE.
PTR N = 0 + 0.               ZERO OUT A POSSIBLE SKIP COUNT.
PTR 9 = O + 0.               Rееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее      GRAB THE NEXT CHARACTER.
CHAR = VAL X.                MOVE IT TO THE LINE BUFFER.
TO 95 IF FLG X = 0.          ARE WE DONE WITH THIS LINE, NO.
WRITE NEXT 4.                YES, WRITE IT OUT.
TO 98 IF FLG 4 NE 0.         TREAT AN ERROR AS FATAL.
20$
'10'37,$
ITERATION ON '10. NEXT MEMBER '30$
'F8$
TRANSFORMATION 8 YIELDS '18$
$
TEST PARAMETER 0.
'00 IS GENERATED SYMBOL 1$
'01 IS GENERATED SYMBOL 2$
'02 IS GENERATED SYMBOL 3$
'03 IS GENERATED SYMBOL 4$
'04 IS GENERATED SYMBOL 5$
'05 IS TRACEBACK.
STOP.
END PROGRAM.
/O ERROR HAS OCCURRED
MESSAGE IOCH TO 4.           ISSUE THE CHANNEL ERROR MESSAGE
TO 94 BY B.                  AND PROVIDE A ESET THE FREE SPACE POINTER.
TO 94 BY B.                  CALL ERROR TRACEBACK.
RETURN BY P.                 CONTINUE WITH THE LINE.
LOC 94.                      PROVIDE TRACEBACK FROM ERROR.
PTR X = C + 0.               FIRST CHARACTER OF THE STRING B.'$'0 (+-*/)
END PROGRAM.
4'F7$
THIS LINE REPEATS 4 TIMES UNDER COUNT CONTROL'F1$
'F8$
END OF STAGE2 TEST.  THIS LINE CONTAINS TYPE 0 ELEMENTS ONLY$
'F0$
$
TRY USING AN UNDEFINED PARAMETER.
THE UNDEFINED PARAMETER IS '10'F1$
'F1$
UNDEFINED PARAM      YES, MOVE BACK UP THE CHAIN.
PTR X = Y - 7.
GET Y = Y.                   PREVIOUS PARAMETER POINTER.
GET X = X.                   CURRENT TEXT POINTER.
TO 95.
LOC 97.                      THE WORKING AREA HAS BEEN OVERFILLED.
MESSAGE FULL TO 4.TO 96 IF VAL X = L.          IF THE LINE ENDED, FINE.
CHAR = VAL X.                OTHERWISE RE-ISSUE THE LAST CHARACTER
TO 95.                       AND KEEP OUTPUTTING.
LOC 96.
TO 70 IF PTR Y = 0.          ARE THERE MORE, NO.
PTR Y = Y - H.         ERATED SYMBOL 5$
'05 IS GENERATED SYMBOL 6$
'06 IS GENERATED SYMBOL 7$
'07 IS GENERATED SYMBOL 8$
'08 IS GENERATED SYMBOL 9$
'09 IS GENERATED SYMBOL 10$
$
NULL MACRO.
$
NINE PARAMETERS ' ' ' ' ' ' ' ' '.
NINE PARAMETERS ARE '10 '20 '30 '40 '50 '62#
#
=REWIND $#
.. LDA K$10+3#
.. CALL REWIND#
.. STA K$10+2#
#
=MESSAGE $ TO $#
.. LDA K$20+3#
.. LXI H,M$10#
.. CALL MWRITE#
.. STA K$20+2#
#
=TRAP#
.. CALL TRAP#
#
=STOP#
.. RET #
#
=END PROGRAM#
..MEMLOW EQU $$#
.. END #
$F0#
#
 K$20+3#
.. DCR A#
.. STA K$10+3#
#
=VAL $ = $ $ $#
.. LDA K$20+3#
.. LXI H,K$40+3#
V$30$56 .. $51#
.. STA K$10+3#
#
=PTR $ = $ + 0#
.. LHLD K$20#
.. SHLD K$10#
#
=PTR $ = $ + 1#
.. LHLD K$20#
.. INX H#
.. SHLD K$10#
#
=PTR $ = $ + 2#
.ING.
TYPE 2 L1,L2,(L31,L32,L33),L4,L5.
TYPE 2 (PL1,PL2,PL3,(PL41,PL42,PL43),PL5,PL6,PL7).
TRY USING AN UNDEFINED PARAMETER.
END PROGRAM.
L2,(L31,L32,L33),L4,L5.
TYPE 2 (PL1,PL2,PL3,(PL41,PL42,PL43),PL5,PL6,PL7).
TRY USING AN UNDEFINED PARAMETER.
$56 .. $51 LL$10#
#
=TO $ IF $ $ $ $#
.. LDA K$30$21#
.. LXI H,K$50$21#
.. CMP M#
C$40$66 .. $61 LL$10#
#
=LOC $#
..LL$10:  #
#
=TO $#
.. JMP LL$10#
#
=TO $ BY $#
.. LXI H,$$+9#
.. SHLD K$20#
.. JMP LL$10#
#
=RETURN BY $#
.. LHLD K$10#
LO TO 5#
.. CALL INITL#
#
=$ $ = $#
.. LDA K$30$11#
.. STA K$20$11#
#
=VAL $ = PTR $#
.. LDA K$20#
.. STA K$10+3#
#
=PTR $ = VAL $#
.. LDA K$20+3#
.. MOV L,A#
.. CMA #
.. ORI 7FH#
.. RLC #
.. INR A#
.. MOV H,A#
.. SHLD K$10#
#
=GET $ =0 '70 '80 '90.'F1$
$
CODE BODY LINE WITH NO TERMINATOR.
THIS CODE BODY LINE HAS NO TERMINATOR.  IT SHOULD HAVE 80 CHARACTERS.
$$
C  THIS DATA EXERCISES MOST OF THE FEATURES OF STAGE2.  THE FIRST TWO
C  LINES WILL NOT BE MATCHED, AND SHOULD BE PRINTED $ - 7#
.. LHLD K$20#
.. DCX H#
.. SHLD K$10#
#
=PTR $ = $ * 7#
.. LHLD K$20#
.. SHLD K$10#
#
=PTR $ = $ / 7#
.. LHLD K$20#
.. SHLD K$10#
#
=PTR $ = $ * 5#
.. LHLD K$20#
.. CALL DMUL10#		SIGNED MULTIPLY BY 10
.. SHLD K$10#
#
=PTR $ = $ / . LHLD K$20#
.. INX H#
.. INX H#
.. SHLD K$10#
#
=PTR $ = $ - 1#
.. LHLD K$20#
.. DCX H#
.. SHLD K$10#
#
=PTR $ = $ - 2#
.. LHLD K$20#
.. DCX H#
.. DCX H#
.. SHLD K$10#
#
=PTR $ = $ + 7#
.. LHLD K$20#
.. INX H#
.. SHLD K$10#
#
=PTR $ =#$#$0 (+-*/)  FLUB TO 8080 TRANSLATION MACROS
.REV $,$#
%FREV: DB 32H	; 06/13/79  R. CURTISS#
..REV: DB $10#
$20$37,#
.. DB '$30'#
.. DW $30REV#
$F8#
#
$.$#			ACCEPT AN INPUT LINE
* $10.#			  OUTPUT COMMENT LINE
=$10#			  PASS LINE ON FOR PROCES
.. PCHL #
#
=READ NEXT $#
.. LDA K$10+3#
.. CALL READ#
.. STA K$10+2#
#
=WRITE NEXT $#
.. LDA K$10+3#
.. CALL WRITE#
.. STA K$10+2#
#
=VAL $ = CHAR#
.. CALL RDCH#
.. STA K$10+3#
#
=CHAR = VAL $#
.. LDA K$10+3#
.. CALL WRCH#
.. STA K$10+ $#
.. LHLD K$20#
.. LXI D,K$10#
.. CALL GMOVE#
#
=STO $ = $#
.. LXI D,K$20#
.. LHLD K$10#
.. CALL SMOVE#
#
=VAL $ = $ + 0#
.. LDA K$20+3#
.. STA K$10+3#
#
=VAL $ = $ + 1#
.. LDA K$20+3#
.. INR A#
.. STA K$10+3#
#
=VAL $ = $ - 1#
.. LDA OUT UNCHANGED.
TEST PARAMETER 0.
NULL MACRO.
NINE PARAMETERS 1 2 3 4 5 6 7 8 9.
TYPE 2 A.
CODE BODY LINE WITH NO TERMINATOR.
TYPE 2 0.
TYPE 2 13.
TYPE 2 A.
TYPE 2 A+13.
TYPE 2 15/2.
TYPE 2 5*(A+13).
TEST PARAMETER 0.
TYPE 2 THIS IS A LONG STR5#
.. LHLD K$20#
.. CALL DDIV10#		SIGNED DIVIDE BY 10
.. SHLD K$10#
#
=PTR $ = $ $ $#
.. LHLD K$40#
.. XCHG #
.. LHLD K$20#
P$30$56 .. $51#
.. SHLD K$10#
#
=TO $ IF PTR $ $ $#
.. LHLD K$40#
.. XCHG #
.. LHLD K$20#
K$30$66 .. CALL $61#
C$30KNE EQU CMPEQ#
.LET KLT EQU CMPLT#
.LET KGE EQU CMPLT#
.LET VAL EQU +3#
.LET FLG EQU +2#
..;  #
.REV 5,I,D,S,M,F#		GENERATE REVISION LIST IN SIGN ON MESSAGE
..PROGR: LXI H,REV#
.. MOV C,M#
.. INX H#
.. LXI D,MHELLO+2#
.. CALL DSPR#
=MESSAGE HELSING
#
=BEGIN STAGE2#
.LET P+ EQU DAD D#
.LET P- EQU CALL DSUB#
.LET P* EQU CALL DMULT#
.LET P/ EQU CALL DDIV#
.LET V+ EQU ADD M#
.LET V- EQU SUB M#
.LET C= EQU JZ#
.LET CNE EQU JNZ#
.LET CLT EQU JC#
.LET CGE EQU JNC#
.LET K= EQU CMPEQ#
.LET .REG $ $ $#		SETUP REGISTER INITIAL VALUES
..K$30: DW $10#
.. DB $20,$30#
#
.REG#
ABCDEFGHIJKLMNOPQRSTUVWXYZ$17#
..K$10: DS 4#
$F8#
#
.MSG $=$#
..M$10: DB $25,'$20',0FFH#
#
%#
 $F13#
#
%$#
$10$F13#
#
..$ $ $#
$10	$20	$30$F13#
#
* $#   
%;
%WRCH:	LHLD	OPTR	; GET LINE BUFFER POINTER
%	ORA	A	; TEST (A)
%	JM	WRCH1	; JUMP IF NEGATIVE
%;
%	MOV	B,A	; SAVE CHARACTER POINTER
%	LXI	D,LINE+132	; END OF LINE POINTER
%	CALL	UCMPLT	; UNSIGNED COMPARE LESS THAN
%	JNC	WRCH1	; JUMP IF OPTR AT ENRD TO OR FROM MEMORY
%;
%;	REG(DE) = MEM(4*HL)
%;
%GMOVE:	DAD	H
%	DAD	H	; MULTIPLY BY 4
%	XCHG
%	JMP	MOVE
%;
%;	MEM(4*HL) = REG(DE)
%;
%SMOVE:	DAD	H
%	DAD	H	; MULTIPLY BY 4
%
%MOVE:	LDAX	D
%	MOV	M,A
%	INX	H
%	INX	D
%
%	LDAX	D
%	MOV	M,A
*** EXPRESSION ERROR ***
.MSG CONV=*** CONVERSION ERROR ***
.MSG FULL=*** MEMORY FULL ERROR ***
.MSG HELLO=---------------------  STAGE2  --  8080 VERSION#
%;
%;
INE LENGTH (LENGTH) = (HL) - LINE  ; (HL) = LINE
%;
%LEN:	PUSH	PSW	; SAVE (A)
%	LXI	D,LINE	; START OF LINE BUFFER
%	CALL	DSUB
%	MOV	A,L	; LINE LENGTH .LT. 255
%	STA	LENGTH
%	XCHG		; (HL) = LINE
%	POP	PSW	; RESTORE (A)
%	RET	
%;
%; --------------	OPTR
%	SHLD	WPTR
%	XRA	A
%	STA	LENGTH
%;
%	LXI	D,MEMLOW
%	CALL	MEMSET
%	PUSH	H	; SAVE HIGH BOUND
%
%	XCHG
%	LXI	D,15
%	DAD	D
%	MOV	A,L
%	ANI	0F0H
%	MOV	L,A	; ADJUSTED FOR 4 BYTE BOUNDRY
%	CALL	UDIV4	; DIVIDE BY 4
%	SHLD	K8	; LOW MEMORY BOU                      SOURCE COMMENT LINE
;			$10$F13#
#
.LET $ EQU $#
$F3#
##			END OF FLUB TO 8080 MACROS
%MAIN	EQU	100H
%IREV	EQU	MAIN+3
%DREV	EQU	MAIN+7
%
%	ORG	1000H
%
%	JMP	PROGR
%	NOP
%IOOP:	JMP	MAIN+4
%	NOP
%TRAP:	JMP	MAIN+8
%	NOP
%	RET	
%;
%; ------------------------------------------- READ
%;  INPUT NEXT LINE FROM CHANNEL (A)
%;
%READ:	MOV	B,A	; CHANNEL NUMBER
%	MVI	A,0FFH	; OPERATION CODE
%	LXI	H,LINE	; START OF LINE BUFFER
%	SHLD	IPTR
%	CALL	IOOP
%	LXI	H,LENGTH
%	MOV
%	INX	H
%	INX	D
%
%	LDAX	D
%	MOV	M,A
%	INX	H
%	INX	D
%
%	LDAX	D
%	MOV	M,A
%	RET
%;
%; ------------------------------------------ REWIND
%;  REWIND ON CHANNEL (A)
%;
%REWIND:	MOV	B,A	; CHANNEL NUMBER
%	MVI	A,0	; OPERATION CODE
%	CALL	IOOP
%SREV: DB 31H ;	05/31/79  R. CURTISS
%;
%; PUT REVISION INFO INTO SIGNON MESSAGE
%;
%;	HL - REVISION LIST POINTER
%;	DE - DESTINATION STRING POINTER
%;	C  - COUNT OF REVISION ITEMS
%;
%DSPR:	MOV	A,M
%	INX	H
%	STAX	D	; PUT REV ID CHARACTER
%	INX	-------------------------------- RDCH
%;  GET CHARACTER FROM LINE
%;
%RDCH:	LHLD	IPTR	; GET LINE BUFFER POINTER
%	MOV	A,M
%	INX	H
%	SHLD	IPTR
%	RET
%;
%; ------------------------------------------------- WRCH
%;  STORE CHARACTER INTO LINE BUFFER
ND
%
%	POP	H	; RECALL HIGH BOUND
%	LXI	D,-15
%	DAD	D
%	MOV	A,L
%	ANI	0F0H
%	MOV	L,A	; ADJUSTED FOR 4 BYTE BOUNDRY
%	CALL	UDIV4	; DIVIDE BY 4
%	SHLD	K9	; HIGH MEMORY BOUND
%	RET
%;
%; ------------------------------------ MOVE
%;  MOVE A FLUB WO
%MEMSET:	JMP	MAIN+12
%	NOP
%
.REG 0 0 0
.REG 1 1 1
.REG 2 2 2
.REG 3 3 3
.REG 4 0 4
.REG 10 0 5
.REG 0 0 6
.REG 1 0 7
.REG 0 0 8
.REG 0 0 9
%
%	DB	0,0,0,0,0,0,0,0
%
.REG#
%
%	DB	0,0,0,0,0,0,0,0
%
.MSG IOCH=*** I/O ERROR ***
.MSG EXPR=	E,M	; GET LINE LENGTH
%	MVI	D,0
%	INX	H	; POINT TO START OF LINE
%	SHLD	OPTR	; RESET LINE BUFFER POINTER
%	DAD	D	; POINT ONE PAST END OF LINE
%	MVI	M,0FFH	; TERMINATE LINE
%	RET	
%;
%; ------------------------------------------- LEN
%;  COMPUTE L
%	JNZ	DSPR
%
%	RET
%
%
%DSPR1:	ANI	0FH
%	ADI	'0'
%	CPI	'9'+1
%	JC	$+5
%	ADI	7
%	STAX	D
%	INX	D
%	RET
%;
%; ----------------------------------- INITL
%; STAGE2 INITIALIZATION
%;
%INITL:	LXI	H,LINE	; LINE BUFFER ORIGIN
%	SHLD	IPTR
%	SHLDD
%
%	PUSH	B	; SAVE COUNT
%	MOV	C,M
%	INX	H
%	MOV	B,M	; BC POINTS TO REV NUMBER
%	INX	H
%
%	LDAX	B	; GET REVISION BYTE
%	RRC
%	RRC
%	RRC
%	RRC
%	CALL	DSPR1
%	LDAX	B
%	CALL	DSPR1
%	INX	D	; SKIP FOR SPACING
%
%	POP	B	; RECALL COUNT
%	DCR	CD OF BUFFER
%;
%	MOV	M,B	; PUT CHARACTER INTO BUFFER
%	INX	H	; INCREMENT POINTER
%	SHLD	OPTR	; SAVE LINE BUFFER POINTER
%	XRA	A	; (A) = 0 = STATUS
%	RET	
%;
%WRCH1:	MVI	M,0FFH	; MARK END OF LINE
%	CALL	LEN
%	SHLD	OPTR	; RESET LINE BUFFER POINTER
 4  --  UNSIGNED
%;
%UDIV4:	MOV	A,H
%	DAD	H
%	DAD	H
%	DAD	H
%	DAD	H
%	DAD	H
%	DAD	H
%	MOV	L,H
%	RRC
%	RRC
%	ANI	3FH
%	MOV	H,A
%	RET
%;
%; ------------------------------------------ NORMAL
%;	NORMAL MULTIPLY AND DIVIDE
%;
%;	HL = HL * DE GH BYTE WITH BORROW
%	MOV	H,A
%	RET	
%;
%; ---------------------------------------- CMPEQ
%; DOUBLE COMPARE (HL) - (DE)
%;
%;	IF HL = DE THEN Z=1
%;
%CMPEQ:	MOV	A,H
%	CMP	D
%	RNZ
%
%	MOV	A,L
%	CMP	E
%	RET
%;
%;
%;	IF HL < DE THEN CY=1  --
%;
%; ----------------------------------------- STORAGE
%;  STORAGE FOR I/O
%;
%IPTR:	DW	LINE	; INPUT POINTER
%OPTR:	DW	LINE	; OUTPUT POINTER
%WPTR:	DW	LINE	; WCH POINTER
%;
%;    THE NEXT THREE ITEMS MUST APPEAR IN ORDER
%;
%MAXLEN:	DB	132	; MACOMP
%;
%;
%;	HL = HL / 10  --  UNSIGNED
%;	DE = HL MOD 10
%;
%UDIV10:	LXI	D,0
%	LXI	B,05000H+12  ; B=10  C=LOOP COUNT
%	JMP	UDV10B
%
%UDV10A:	XCHG
%	DAD	H	; SHIFT DE LEFT 1 BIT
%	XCHG
%	DAD	H	; SHIFT HL LEFT 1 BIT
%
%UDV10B:	MOV	A,H
%	SUB	ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее
%	MVI	A,1	; (A) = 1 = STATUS
%	RET	
%;
%; ----------------------------------------- WRITE
%;  OUTPUT LINE ON CHANNEL (A)
%;
%WRITE:	MOV	B,A	; CHANNEL NUMBER
%	MVI	A,1	; OPERATION CODE
%	LXI	H,LINE	; START OF LINE BUFFER
%	SHLD	OPTR	; INITIALIZE F------------------- SPECIAL
%;  SPECIAL MULTIPLY AND DIVIDE
%;
%;	HL = HL * 10  --  SIGNED
%;
%DMUL10:	MVI	B,0	; MINUS SIGN COUNTER
%	CALL	ICOMP	; COMPLEMENT IF NECESSARY
%	MOV	D,H
%	MOV	E,L
%	DAD	H
%	DAD	H
%	DAD	D
%	DAD	H
%	DCR	B
%	RNZ		; RE  SIGNED
%;
%CMPLT:	MOV	A,H
%	XRA	D
%	MOV	A,H
%	RLC		; SET CY = SIGN OF HL
%	RM		; RETURN IF SIGNS DIFFERENT
%;
%;	IF HL < DE THEN CY=1  --  UNSIGNED
%;
%UCMPLT:	MOV	A,H
%	CMP	D
%	RNZ
%
%	MOV	A,L
%	CMP	E
%	RET
%;
%; ----------------------X LENGTH OF LINE
%LENGTH:	DB	0	; LINE LENGTH
%LINE:	DS	133	; LINE BUFFER
%;
%	DB	0,0,0,0,0,0,0,0,0,0 ; UNUSED SPACE
%;
%;
B
%	JC	UDV10C	; JUMP IF CAN'T SUBTRACT 10
%
%	MOV	H,A
%	INR	E	; SET LSB OF DE TO 1
%
%UDV10C:	DCR	C	; LOOP COUNT
%	JNZ	UDV10A
%
%	XCHG
%	MOV	A,D
%	RRC
%	RRC
%	RRC
%	RRC
%	ANI	0FH
%	MOV	E,A	; REMAINDER
%	MVI	D,0
%	RET
%;
%;
%;	HL = HL /%MREV: DB 32H ;	06/08/79  R. CURTISS	FIX DMUL10  MOV D,H
%;
%;MREV: DB 31H ;	05/31/79  R. CURTISS	SIGNED OPERATIONS
%;
%;  DOUBLE SUBTRACT  (HL) = (HL) - (DE)
%;
%DSUB:	MOV	A,L
%	SUB	E	; SUBTRACT LOW BYTE
%	MOV	L,A
%	MOV	A,H
%	SBB	D	; SUBTRACT HIOR NEXT LINE
%	CALL	IOOP
%	RET	
%;
%; ------------------------------------------ MWRITE
%;  OUTPUT ERROR MESSAGE ON CHANNEL (A)
%;
%MWRITE:	MOV	B,A	; CHANNEL NUMBER
%	MVI	A,1	; OPERATION CODE
%	INX	H	; (HL) = START OF MESSAGE
%	CALL	IOOP
%	RET	
TURN IF POSITIVE
%
%	JMP	COMP	; COMPLEMENT RESULT
%;
%;
%;	HL = HL / 10  -- SIGNED
%;
%DDIV10:	MVI	B,0	; MINUS SIGN COUNTER
%	CALL	ICOMP
%	PUSH	B
%	CALL	UDIV10
%	POP	B
%	DCR	B
%	RNZ		; RETURN IF POSITIVE
%
%	XCHG
%	CALL	COMP
%	XCHG
%	JMP	ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее --  SIGNED
%;
%DMULT:	MVI	B,0	; MINUS SIGN COUNTER
%	XCHG
%	CALL	ICOMP
%	XCHG
%	CALL	ICOMP
%	PUSH	B	; SAVE MINUS SIGN COUNTER
%	CALL	UMULT
%	POP	PSW	; RECALL MINUS SIGN COUNTER
%	ANI	1
%	RZ		; RETURN IF RESULT POSITIVE
%
%	JMP	COMP
%;
%;
%

	IFLT1.HEX
	 FLT2
	 STG2
	R

	^C

	SAVE __ FLT1.COM
		FLT2.COM
		STG2.COM

	FLT1   CH3,CH4=FLD1.DAT		; TEST RUN 1
	FLT2   CH3,CH4=FLD2.DAT		; TEST RUN 2
	STG2   CH3,CH4=ST2T.DAT		; TEST RUN 3

	Compare CH3 & CH4 output files against publi
%;
%COMP:	MOV	A,H
%	CMA		; COMPLEMENT HIGH BYTE
%	MOV	H,A
%	MOV	A,L
%	CMA		; COMPLEMENT LOW BYTE
%	MOV	L,A
%	INX	H	; TWO'S COMPLEMENT
%	RET	
%;
%;
ESULT LEFT
%	XCHG	
%	DAD	H	; SHIFT MULTIPLIER LEFT
%	XCHG	
%	JMP	MLOOP
%;
%;
%;	HL = HL / DE  --  SIGNED
%;	DE = HL MOD DE
%;
%DDIV:	MVI	B,0	; MINUS SIGN COUNTER
%	CALL	ICOMP
%	XCHG
%	CALL	ICOMP
%	PUSH	B
%	CALL	DIV80
%	XCHG
%	POP	PSW
%	ANtuff.

	This stuff is NOT relevent to using STAGE2.  It is supplied for those
	who have to see how things work inside or want to modify STAGE2 (lots
	of luck) or want to create a STAGE2 for some other processor or
	operating system.

	Working disk iLT
%	MOV	B,A
%	PUSH	B	; SAVE TEMP RESULT ON STACK
%	JNC	SKIP	; NO BORROW FROM SUBRRACT
%;
%	DAD	B	; ADD DIVIDEND BACK IN
%	XTHL		; REPLACE TEMP RESULT ON STACK
%;
%SKIP:	LXI	H,BNUM	; RESTORE HL
%	CMC		; COMPLEMENT CARRY
%	JMP	LOOP
%;
%;
%TEMP:;  DOUBLE MULTIPLY  (HL) = (HL) * (DE)  --  UNSIGNED
%;
%UMULT:	MOV	B,H	; MOVE MULTIPLICAND TO BC
%	MOV	C,L
%	LXI	H,0	; INITIALIZE RESULT
%	MVI	A,16	; INITIALIZE LOOP COUNT
%	ORA	A	; CLEAR CARRY
%	PUSH	PSW	; SAVE COUNT AND ZERO CARRY
%;
%MLOOP:	MOееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееI	1
%	RZ		; RETURN IF RESULT POSITIVE
%
%	XCHG
%	CALL	COMP
%	XCHG
%	JMP	COMP
%;
%;
%;  DOUBLE DIVIDE    (HL) = (HL) / (DE)
%;
%UDIV:	XCHG	
%	CALL	DIV80
%	XCHG	
%	RET	
%;
%;
%DIV80:	SHLD	TEMP	; SAVE DIVIDEND IN TEMPORARY
%	LXI	H,BNUM	; STOn drive A
	Source file disk in drive B

	SUBMIT B:IOOP$		; INPUT/OUTPUT PACKAGE ASSEMBLY - IOOP.HEX

	SUBMIT B:FLUB$ FLT1	; FLUB TEST 1 ASSEMBLY - FLT1.HEX
		       FLT2	; FLUB TEST 2
		       STG2	; STAGE2

	DDT

	F100,3FFF,0

	IIOOP.HEX
	R
	DS	2	; FOR M   DIVIDE
%BNUM:	DS	1	; FOR DIVIDE
%;
%; ------------------------------------------- ICOMP, COMP
%;  TWO'S COMPLEMENT ROUTINE FOR (HL)
%;
%ICOMP:	MOV	A,H	; CHECK SIGN BIT
%	ORA	A
%	RP		; RETURN IF POSITIVE
%
%	INR	B	; COUNT NEGATIVE
V	A,D	; GET MULTIPLIER BIT
%	RLC	
%	JNC	OVER	; JUMP IF BIT ZERO
%
%	DAD	B
%
%OVER:	POP	PSW	; RECALL LOOP COUNT AND CLEAR CARRY
%	DCR	A	; DECREMENT LOOP COUNT
%	RZ		; RETURN IF COUNT ZERO
%
%	PUSH	PSW	; SAVE COUNT AND ZERO CARRY
%	DAD	H	; SHIFT RSTAGE2 GENERATION PROCESS:

	This is only used to create new versions of STAGE2 if changes are
	desired.  It is highly recommended that the STAGE2 implementation
	portions of Waite's book be carefully studied and understood before
	fooling with this sSTORE TEMP RESULT
%	RZ		; RETURN IF COUNT ZERO
%
%	MVI	A,0	; ADD IN CARRY
%	ACI	0
%	DAD	H	; SHIFT TEMP RESULT LEFT
%	MOV	B,H	; COPY HL TO AC
%	ADD	L
%	LHLD	TEMP	; GET DIVIDEND
%	SUB	L	; SUBTRACT FROM
%	MOV	C,A
%	MOV	A,B
%	SBB	H	; TEMPORARY RESURE
%	MVI	M,17	; BIT COUNT
%	LXI	B,0	; INITIALIZE RESULT
%	PUSH	B	; SAVE RESULT ON STACK
%;
%LOOP:	MOV	A,E	; GET LOW DIVISOR BYTE
%	RAL	
%	MOV	E,A	; SHIFT DIVISOR LEFT ONE BIT
%	MOV	A,D
%	RAL	
%	MOV	D,A
%	DCR	M	; DECREMENT BIT COUNT
%	POP	H	; REshed test results.

	Do only one at a time (not all 3 as shown above).

	Order is FLT1, FLT2 then STG2.  Tests must be successful before
	continuing to the next test.  After all test are successful the
	current version of STAGE2, "STAGE2.COM", may beE
	ANA	B
	CALL	PUTMODE
	FIN
	ELSE
	CALL	GETMODE
	ORA	B
	CALL	PUTMODE
	FIN
	FIN
	FIN
	POP	H
	POP	D
	POP	B
	RET
PROCEDURE VOUT
	SELECT
	( DEL )  NOP
	( CR )
	XRA	A
	CALL	PUTX
	FIN
	( LF )
	CALL	GETY
	INR	A
	CPI	25
	WHEN ( CARRY )  Cial)
;
NSTATE:	DW	ST1
CIMAGE:	DB	00000000B
MSR:	DB	0
INVERT:	DB	0
;
; Local data storage (uninitialized)
;
	DSEG
BUFF:	DS	81	; scroll buffer
	CSEG
;
; ----------------------------------------
;
BS	EQU	08H
CR	EQU	0DH
LF	EQU	0AH
BEL	EQU	07Hееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее	MSR
	FIN
	( 'R' )
	SETNEXT ( NSTATE = ST5 )
	XRA	A
	STA	MSR
	FIN
	( OTHERWISE )
	SETNEXT ( NSTATE = ST1 )
	CALL	VOP
	FIN
	FIN
	FIN
	( ST3 )
	SETNEXT ( NSTATE = ST4 )
	SUI	32
	CALL	PUTY
	FIN
	( ST4 )
	SETNEXT ( NSTATE = ST1 )
	SUI	32
	ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееее deleted and the
	new version, "STG2.COM", may be renamed.

MEMORY MAP:

	0100	Initialization and I/O package
		Disk I/O package

	1000	Support routines
		Math routines
		FLT1 or FLT2 or STG2 program
		FLUB memory - extends up to BDOS

		BDOS
U	00000001B

VDBAP	EQU	0
VDBBE	EQU	1
VDBIS	EQU	2
VDBID	EQU	3
VDBDC	EQU	4
VDBDD	EQU	5
PROCEDURE VOINIT
	SETNEXT ( NSTATE = ST1 )
	MVI	A,00000000B
	STA	CIMAGE
	XRA	A
	STA	INVERT
	MVI	A,4
	CALL	PUTMODE
	RET
PROCEDURE VO
	PUSH	B
	PUSH	D
	PU
ESC	EQU	1BH
DEL	EQU	7FH

VDBCTL	EQU	9CH
VDBDAT	EQU	VDBCTL+1
CONTROL	EQU	VDBCTL+2

VDBMRF	EQU	10000000B
VDBYCF	EQU	11000000B
VDBXCR	EQU	11100000B
VDBYCR	EQU	11100001B
VDBMRR	EQU	11100010B
VDBRES	EQU	11100011B
VDBGMK	EQU	01100000B

BELBIT	EQ; $1 = FLT1, FLT2 or STG2
;
ERA $1.ASM
STAGE2 $1.ASM,CON:=B:FLUB8080.S2M,B:STG2SUP.ASM,B:STG2MATH.ASM,B:$1.FLB
ASM $1.AAZ
FLUB$   $$$ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееCALL	PUTX
	FIN
	( ST5 )
	SETNEXT ( NSTATE = ST1 )
	SUI	'0'
	ANI	7
	MOV	B,A
	MVI	A,1
	INR	B
	LOOP
	DCR	B
	BREAK IF ( ZERO )
	RLC
	FIN
	MOV	B,A
	LDA	MSR
	ORA	A
	WHEN ( ZERO )  ; reset selected mode bit
	MOV	A,B
	CMA
	MOV	B,A
	CALL	GETMODREV EQU 11H ;	12/28/80  R. Curtiss	BUFF, INIR, OTIR

;REV EQU 10H ;	12/28/80  R. Curtiss	from NB-VDB

;VREV EQU 21H ;	06/10/80  R. Curtiss	HOME --> CHOME

BEGIN
;
; Entry points
;
	ENTRY	VO
;
; TDL-XITAN VDB driver for Heath H19 emulation (part
		BIOS
ackage

	1000	Support routines
		Math routines
		FLT1 or FLT2 or STG2 program
		FLUB memory - extends up to BDOS

		BDOS
SH	H
	MOV	A,C
	ANI	7FH
	EXECUTE ( NSTATE )
	( ST1 )
	CPI	ESC
	WHEN ( ZERO )
	SETNEXT ( NSTATE = ST2 )
	FIN
	ELSE  CALL VOUT
	FIN
	( ST2 )
	SELECT
	( 'Y' )
	SETNEXT ( NSTATE = ST3 )
	FIN
	( 'S' )
	SETNEXT ( NSTATE = ST5 )
	MVI	A,0FFH
	STAееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееALL PUTY  ; y = y + 1
	ELSE  CALL SCROLL
	FIN
	( BS )
	CALL	GETX
	ORA	A
	IF ( NOT ZERO )
	DCR	A
	CALL	PUTX	; x = x - 1
	FIN
	FIN
	( BEL )
	LDA	CIMAGE
	ORI	BELBIT
	OUT	CONTROL	; fire bell one shot
	XRI	BELBIT
	OUT	CONTROL
	FIN
	( OTHERWISEееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееT
PROCEDURE CHOME
	XRA	A
	CALL	PUTX	; X = 0
	CALL	PUTY	; Y = 0
	RET
PROCEDURE SCROLL
	CALL	GETMODE	; GET MODE
	LXI	H,BUFF
	PUSH	PSW
	ORI	10H	; 1<VDBDC  KILL CURSOR
	OUT	VDBCTL	; INHIBIT
	PUSH	H
	MVI	D,VDBYCF+1
	MVI	C,VDBDAT	; data port
	XRA	W
	MVI	A,'^'+80H
	CALL	DISPLAY
	POP	PSW
	ORI	0C0H	; reverse and non control
	CALL	DISPLAY
	FIN
	ELSE
	ORI	80H
	CALL	DISPLAY
	FIN
	RET
PROCEDURE DISPLAY
	MOV	B,A
	LDA	INVERT
	ORA	A
	MOV	A,B
	IF ( NOT ZERO )  ; blink or invert
	XRI	80H
	FIRET
PROCEDURE CLIN
	MVI	A,VDBXCR
	OUT	VDBCTL
	REPEAT
	MVI	A,' '
	OUT	VDBDAT
	IN	VDBCTL
	ORA	A
	UNTIL ( ZERO )
	RET
	END
END-OF-FILE
LL	GETX
	INR	A
	CPI	80
	IF ( CARRY )  ; cursor at right of screen
	CALL	PUTX	; X = X + 1
	FIN
	RET
PROCEDURE LEFT
	CALL	GETX
	ORA	A
	IF ( NOT ZERO )
	DCR	A
	CALL	PUTX
	FIN
	RET
PROCEDURE REVERSE
	MVI	A,0FFH
	STA	INVERT
	RET
PROCEDURE NOR )
	CPI	' '
	WHEN ( CARRY )  CALL WHAT  ; control character display
	ELSE  CALL DISPLAY  ; normal character display
	FIN
	FIN
	RET
PROCEDURE VOP
	SELECT
	( 'E' )  CALL ERASE
	( 'J' )  CALL E2EOS
	( 'K' )  CALL E2EOL
	( 'l' )  CALL ELINE
	( 'H'P	H
	CALL	CLIN	; CLEAR LAST LINE
	MVI	A,0D8H	; 24!VDBYCF
	OUT	VDBCTL
	POP	PSW
	OUT	VDBCTL	; ENABLE DISPLAY
	RET
PROCEDURE PUTY
	ANI	1FH
	ORI	VDBYCF
	OUT	VDBCTL
	RET
PROCEDURE PUTX
	ANI	7FH
	OUT	VDBCTL
	RET
PROCEDURE GETY
	MVI	A,VDBYCR
	OUA
	OUT	VDBCTL
	MOV	A,D
	REPEAT
	OUT	VDBCTL	; SET Y POS
	MVI	B,80
	.Z80
	INIR
	.8080
	POP	H
	PUSH	H
	MOV	A,D
	DCR	A
	OUT	VDBCTL
	MVI	B,80
	.Z80
	OTIR
	.8080
	POP	H
	PUSH	H
	INR	D
	MOV	A,D
	CPI	0D9H	; 25!VDBYCF
	UNTIL ( NO CARRY )
	PON
	OUT	VDBDAT
	MVI	A,VDBXCR
	OUT	VDBCTL
	IN	VDBCTL
	ORA	A
	IF ( ZERO )   ; line full - wrap around
	MVI	A,VDBYCR
	OUT	VDBCTL
	IN	VDBCTL
	ORA	A
	IF ( ZERO )   ; screen full - scroll required
	CALL	SCROLL
	FIN
	FIN
	RET
PROCEDURE ERASE
	XRA	ееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееMAL
	MVI	A,0
	STA	INVERT
	RET
PROCEDURE E2EOL
	CALL	GETX
	PUSH	PSW
	CALL	GETY
	PUSH	PSW
	CALL	CLIN
	POP	PSW
	CALL	PUTY
	POP	PSW
	CALL	PUTX
	RET
PROCEDURE ELINE
	CALL	GETY
	PUSH	PSW
	XRA	A
	CALL	PUTX
	CALL	CLIN
	POP	PSW
	CALL	PUTY
	RE )  CALL CHOME
	( 'A' )  CALL UP
	( 'B' )  CALL DOWN
	( 'C' )  CALL RIGHT
	( 'D' )  CALL LEFT
	( 'p' )  CALL REVERSE
	( 'q' )  CALL NORMAL
	( OTHERWISE )  CALL WHAT
	FIN
	RET
PROCEDURE WHAT
	CPI	32
	WHEN ( CARRY )  ; control character
	PUSH	PST	VDBCTL
	IN	VDBCTL
	RET
PROCEDURE GETX
	MVI	A,VDBXCR
	OUT	VDBCTL
	IN	VDBCTL
	RET
PROCEDURE PUTMODE
	ANI	3FH
	ORI	VDBMRF
	OUT	VDBCTL
	RET
PROCEDURE GETMODE
	MVI	A,VDBMRR
	OUT	VDBCTL
	IN	VDBCTL	; READ MODE
	ORI	VDBMRF	; SET TO WRITE MODE
	PSW
	CALL	PUTX
	RET
PROCEDURE UP
	CALL	GETY
	ORA	A
	IF ( NOT ZERO )  ; not top of screen
	DCR	A
	CALL	PUTY	; Y = Y - 1
	FIN
	RET
PROCEDURE DOWN
	CALL	GETY
	INR	A
	CPI	25
	IF ( CARRY )
	CALL PUTY	; y = y + 1
	FIN
	RET
PROCEDURE RIGHT
	CAA
	CALL	PUTX
	CALL	PUTY
	REPEAT
	CALL	CLIN	; CLEAR THE LINE
	CALL	GETY
	ORA	A
	UNTIL ( ZERO )
	RET
PROCEDURE E2EOS
	CALL	GETX
	PUSH	PSW
	CALL	GETY
	PUSH	PSW
	REPEAT
	CALL	CLIN
	CALL	GETY
	ORA	A
	UNTIL ( ZERO )
	POP	PSW
	CALL	PUTY
	POP			Getting Started for the STAGE2 Novice
								3/20/81

Step 1.	Print the following files:
		HELP.DOC
		USE.DOC
		INTRO.DOC
		DEMO.S2M

Step 2.	Read through INTRO.DOC but do not get bogged down in trying to under-
	stand it.  The idea on this fie, " OPEN MYFILE,INPUT,4096", rather than
having to code the necessary assembler instructions.  Richard
Curtiss uses it to expand ANY language he uses on his micro,
to add structured programming:  IF/THEN, WHILE, REPEAT, etc.
The macros generate the prееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееry to understand what is going on.  Then start over and do each
	example while referring to the listings DEMO.S2M and INTRO.DOC in an
	effort to understand the operations being performed.  Don't get dis-
	couraged as it may not make sense at first.  Perdoc-
umentation, but "insight", which is normally the service an
"abstract" serves.  Because of such good documentation, (and
this disk is full), this abstract will be brief.
	STAGE2 is "cryptic", but quite interesting.  Many of
you will enjor "experitring
		C6 MAGIC		; parameter redefinition
		C7 ONE,TWO;THREE	; scanner operation
		C8 A
		C8 B			; internal code for character
		F1			; output request
		F7 2+3			; count controlled iteration
		F7 PDQ
		FE			; error trace back
		F0			; terminates rst pass is to become a little familiar
	with what is there.

Step 3.	Run STAGE2 using DEMO.S2M for input.
		A>STAGE2 DEMO.S2M		; make sure printer is on
			or
		A>STAGE2 CON:,CON:=DEMO.S2M	; if you do not have a printer

		STAGE2 error messages goееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееееseverance is in order.

		HELP
		C0 ABC			; simple copy
		C1 ABC			; symbol undefined in memory
		F3 ABC=XYZ		; defines symbol in memory
		C1 ABC			; symbol now defined -
					;   note difference from previous C1 
		F3 ABC=IJK		; new value for ABC menting with it", and many will make
regular use of it.
	What is a "macro processor"?  A program, which "trans-
forms" or "expands" character strings, into something else.
Traditional uses were in assembler programming, allowing you
to say, for exampl- WARM BOOT
ter
		F1			; output request
		F7 2+3			; count controlled iteration
		F7 PDQ
		FE			; error trace back
		F0			; terminates  to channel 4 which is defaulted to
		the list device if nothing is specified on the command line.

Step 4.	Type the following examples and carefully observe the results.  Go
	through all of the examples once to become familiar with them but do
	not tAbstract for National CP/M Users Group Vol. 51,
	"STAGE2 Macro Processor"


	Richard Curtiss implemented STAGE2, wrote many of the
sample programs, and did an excellent job of commenting on his
own work.  INTRO.DOC and VOLUME51.DOC, provide not only sion evaluation
		C4 PDQ-6		; will use value of PDQ from memory
		C4 XXX+3		; XXX is undefined so value is 0
		C4 ABC+3		; causes error message to channel 4
					;   because ABC has non-numeric value
					;   in memory
		C5 ABCDEFGHIJK		; length of sin memory
		C1 ABC
		S			; next symbol from generator
		S
		S
		C2 ABC			; similar to C1 except if symbol is not
					;   defined it will be given the next
					;   value from the symbol generator
		C2 PDQ
		S
		C2 PDQ
		C4 2+3*(4-7/3)		; expresoper GOTOs, etc, no matter what the
language
	STAGE2 was written in "FLUB", a machine-independent
simple language.  The FLUB source for STAGE2 is on the disk.
IMPL.DOC goes into the details.  You could transport STAGE2 to
some other processor, quite rle.  Thus people that are concerned that
	a copy went wrong somewhere, can check the CRC of the
	file, and compare it to the one stored in CRCKLIST.CRC.

	Thanks to Keith Petersen for this excellent program.
	CRCKLIST.CRC	Contains the CRCs for all files on this
					disk. (except itself)
51.8	2K	DEMO.S2M	Interactive STAGE2 demo macros.
51.9	17K	DISKIO2.SRC	(*) disk I/O for STAGE2 processor
51.10	6K	DISKIO2-.DOC	(*) DOC on above
51.11	5K	FLD1.DAT	(*) Samplve the column.  Then reset to state 1.
	The NSTATE DW is the address of the next state (rou-
tine) you will be in, and "EXECUTE ( NSTATE )" expands to
"branch to what is stored in NSTATE.

	Abstract by Ward Christensen
GE2 in FLUB code
51.27	5K	STG2MATH.ASM	(*) STAGE2 support routines
51.28	5K	STG2SUP.ASM	(*)		"
51.29	8K	TERM.ALX	Sample 8080 terminal program w/ALX macros.
51.30	3K	TERMSUP.ASM	Subroutines for TERM.ALX
51.31	2K	USE.DOC		How to execute STAGE2.
51.32	6oftware Tools for Non-Numeric Applications"

    by: Wm. M. Waite

  from: Prentice Hall, Inc.

NUMBER	SIZE	NAME		COMMENTS

		CATALOG.051	CONTENTS OF CP/M VOL. 51
51.1	2K	ABSTRACT.051	Overview of volume
51.2	16K	ALX.S2M		Assembly Language Extensieadily.
	The only thing missing is some documentation on the
"state machine" macros of ALX.  VDB.ALX, a video driver for a
memory-mapped display, uses them.  You are normally in ST1
(state 1) waiting for characters.  If you get an ESC, you go
to ST2, 	HELP.DOC	First-timer's "to do" list.
51.18	2K	IMPL.DOC	(*) Notes on implementing STAGE2
51.19	2K	INTERACT.S2M	Another macro demo.
51.20	22K	INTRO.DOC	Sufficient info to "read" STAGE2 macros,
					and with diligence, write them.
51.22	1K	IOOP$.SUB	(*)e data for FLUB test
51.12	4K	FLD2.DAT	(*) 		"
51.13	13K	FLT1.FLB	(*) Sample program for FLUB test
51.14	11K	FLT2.FLB	(*)		"
51.15	1K	FLUB$.SUB	(*) Submit file for FLT1, FLT2, STG2.
51.16	4K	FLUB8080.S2M	(*) Macros to turn FLUB into 8080 asm
51.17	3KVOLUME 51	The CP/M Users Group

DESCRIPTION: STAGE2 MACRO PROCESSOR

By:	Dick Curtiss			
	843 NW 54th
	Seattle, WA 98107

<<Congratulations to Dick for a superb User's group contribution: A major
  work, well documented, good examples, a good refeK	VDB.ALX		TDL video driver in ALX, a "state machine".
51.33	5K	VOLUME51.DOC	Dick Curtiss' own excellent documentation.

(*)	Files are necessary only to change STAGE2.

NOTE:	Included on this volume for the first time, is a file
	of CRC's for each fion macros
51.3	3K	ALX-.DOC	Doc on above
51.4	3K	ALXTEST.ALX	Sample macros to test above, including
		ALXTEST.ALX		errors to be detected.
51.5	4K	CIO.ALX		Console I/O routines in ALX
51.6	2K	CRCK.COM	Keith Petersen's program to CRC check files
51.7	1Kbecause you are awaiting a control sequence.  Then, if
you receive a "Y", it is cursor addressing, so you set the
next state to ST3 via "SETNEXT ( NSTATE = ST3 )" to get the
row, then when its received, "SETNEXT ( NSTATE = ST4 )", i.e.
state 4 to recei submit file for macro pass + asm of above
51.21	16K	IOOP.SRC	(*) I/O processor 8080 source
51.23	1K	MEMORY.INP	Another macro demo.
51.24	2K	ST2T.DAT	(*)
51.25	12K	STAGE2.COM	The executable macro processor itself.
51.26	48K	STG2.FLB	(*) Source for STAment), etc.  STAGE2 is a general-purpose text-replacement
processor, not limited to programming language applications.
Those interested in transporting it to other machines, or in
studying its background and implementation wi