1c1
< %BEGIN;                               !HAL-70
---
> %BEGIN;                               !HAL-7502
8d7
< %OWNINTEGER SINGLE=16_5000
10d8
< %OWNINTEGER OPFMASK=16_F800;          !=OPMASK+FMASK
12d9
< %OWNINTEGER BMASK=16_0100;            !BYTE
38a36
> 
44,45d41
< %OWNINTEGER BINCOUNT=0;               !OUTPUT RECORD ITEM COUNT
< %OWNINTEGER CHECK=0;                  !OUTPUT RECORD CHECKSUM
50c46,48
< %OWNINTEGER TEMPS=12;                 !TEMPORARY REGISTER SET (2,3)
---
> %OWNINTEGER TEMPS=12;                 !TEMPORARY REGISTER SET
> %OWNINTEGER CONTROL=16_40;            !OBJECT CODE CONTROL FIELD
> %OWNINTEGER CHECK=0;  !BINARY CHECKSUM
53c51
< %INTEGER CREG,CTYPE,CVAL;             !CONDITION CODE
---
> %INTEGER CREG;                        !CONDITION CODE
60,62c58,60
< %INTEGER FLAG;                        !JUMPS / AHM
< %OWNINTEGER QQ='?'
< %OWNINTEGERARRAY BREC(1:52);          !BINARY OUTPUT RECORD
---
> %INTEGER FLAG;                        !JUMPS
> 
> 
68a67
> 
77a77
> 
89a90
> 
94a96
> 
98a101
> 
108a112
> 
113a118
> 
117a123
> 
154,165c160
< %ROUTINE PUT(%INTEGER V)
< !STORE 4-BIT ITEM IN BINARY RECORD
< %OWNINTEGER HOLD=0
<     V = V&15
<     HOLD = HOLD<<4+V
<     BINCOUNT = BINCOUNT+1
<     %IF BINCOUNT&3 = 0 %START
<        BREC(BINCOUNT>>2) = HOLD
<        CHECK = CHECK!!HOLD
<        HOLD = 0
<     %FINISH
< %END
---
> 
167,178c162
<     %ROUTINE PUT1(%INTEGER V)
<         PUT(V>>4);  PUT(V)
<     %END
<     PUT1(V>>8);  PUT1(V)
< %END
< %ROUTINE OUTPUT RECORD
< %OWNINTEGER SEQ=0
< %INTEGER I
<     %ROUTINE OUTPUT WORD(%INTEGER W)
<         PRINT CH(W>>8&255);  PRINT CH(W&255)
<     %END
<     PUT(0) %WHILE BINCOUNT # 208
---
>     CHECK = CHECK!!V
180,190c164,168
<     %CYCLE I = 1,1,10
<        PRINT CH(0);                   !RUNOUT
<     %REPEAT
<     PRINT CH(16_F0);                  !HEADER CODE
<     SEQ = SEQ-1
<     OUTPUT WORD(SEQ);                 !SEQUENCE NUMBER
<     OUTPUT WORD(\(CHECK!!SEQ));       !CHECKSUM
<     %CYCLE I = 1,1,52
<        OUTPUT WORD(BREC(I))
<     %REPEAT
<     BINCOUNT = 0;  CHECK = 0
---
>     PRINT CH(V>>12&15+CONTROL)
>     PRINT CH(V>>8&15+16_40)
>     PRINT CH(V>>4&15+16_40)
>     PRINT CH(V&15+16_40)
>     CONTROL = 16_50
192a171
> 
194,196d172
< %INTEGER I,J
<     TYPE = 0 %IF TYPE = SINGLE
<     I = 2;  I = 4 %IF TYPE&OPMASK # 0
198,212c174,178
<        OUTPUT RECORD %IF BINCOUNT+I+I >= 208
<        %IF I = 4 %START
<           %IF TYPE&16_4000 = 0 %START
<              PUT(11);  J = TYPE!!OPMASK
<              TYPE = RELMASK
<           %ELSE %START
<              PUT(10);  J = TYPE;  TYPE = 0
<           %FINISH
<           PUT WORD(J)
<           PRINT LINE %IF CHARS # 0
<           PRINT LOC
<           PRINT WORD(J);  PRINT(' ')
<        %ELSE %START
<           %IF TYPE&RELMASK # 0 %THEN PUT(9) %ELSE PUT(8)
<           %IF CHARS # 0 %THEN PRINT(' ') %ELSE PRINT LOC
---
>     %IF CHARS = 0 %START
>     %IF PRINTPOS#0 %THEN PRINT LOC %ELSE %START
>     PRINT(' '); PRINT(' '); PRINT(' ')
>     PRINT(' '); PRINT(' '); PRINT(' ')
>     %FINISH
214c180,181
<        PUT WORD(VAL);  PRINT WORD(VAL)
---
>     PRINT(' ') %IF CHARS = 10
>     PRINT WORD(VAL); PUT WORD(VAL)
216c183
<        PRINT LINE %IF TYPE&RELMASK#0 %OR CHARS=15
---
>     PRINT LINE %IF CHARS >= 15
218c185,193
<     LOC = LOC+I
---
>     LOC = LOC+1
> %END
> 
> %ROUTINE PLANT(%INTEGER V)
> %INTEGER THOLD,VHOLD
>     THOLD = TYPE;  VHOLD = VAL
>     TYPE = 0;  VAL = V
>     PLANT VAL
>     TYPE = THOLD;  VAL = THOLD
219a195
> 
223a200
> 
225,226c202,203
< %INTEGER D
<     D = DEST
---
> %INTEGER P,Q
>     Q = 0
228c205
<        TYPE = INTEGER(NP)&16_FFF+DEFLIM; !DEST SLOT
---
>     TYPE = INTEGER(NP);  P = TYPE&16_3FF+DEFLIM; !DEST SLOT
233,234c210,215
<        FLAG = 0;  FLAG = 2 %IF (D-VAL)>>1+PASS <= 16
<        VAL = VAL-FLAG
---
>     FLAG = 0;
>     %IF TYPE&16_800 = 0 %START
>     FLAG = 1 %IF DEST-VAL+PASS <= 128
>     %ELSE %IF TYPE&16_400 # 0 %START
>     FLAG = 2 %IF DEST-VAL+PASS+PASS = 1
>     %FINISH
236c217
<           D = D-FLAG;  INTEGER(TYPE) = D
---
>     DEST = DEST-FLAG;  INTEGER(P) = DEST
238,240c219,221
<              LOC = LOC-2;  DEST = DEST-2
<              %WHILE TYPE # ALMAX %CYCLE
<                 TYPE = TYPE+1;  INTEGER(TYPE) = INTEGER(TYPE)-2
---
>     LOC = LOC-FLAG
>     %WHILE P # ALMAX %CYCLE
>     P = P+1;  INTEGER(P) = INTEGER(P)-FLAG
244c225
<           FAULT('P') %IF INTEGER(TYPE) # D
---
>     FAULT('P') %IF INTEGER(P) # DEST
246,250c227,231
<        %RETURN %UNLESS INTEGER(NP)&16_1000 # 0
<        %IF INTEGER(NP)&16_2000 # 0 %START; !OR
<           D = VAL+4 %IF D = DEST
<        %ELSE %START
<           D = DEST
---
>     %RETURN %IF INTEGER(NP)&16_1000 = 0
>     %IF INTEGER(NP)&16_2000 # 0 %AND Q = 0 %START; !OR
>     DEST = VAL+1
>     DEST = VAL+2-FLAG %UNLESS TYPE&16_C00 = 16_C00
>     Q = 1
253a235
> 
255,266c237,247
< !   INTERDATA OP-CODES (+FORMATS)
< %OWNINTEGER LOAD=16_080F, LB=16_9303
< %OWNINTEGER ADD=16_0A0F, SUB=16_0B0F, AND=16_0407
< %OWNINTEGER OR=16_0607, XOR=16_0707
< %OWNINTEGER SLLS=16_7508, SRLS=16_7408, SLHL=16_0D04, SRHL=16_0C04
< %OWNINTEGER COMP=16_0907, CLB=16_9402
< %OWNINTEGER STORE=16_0002, STB=16_9202, AHM=16_2102
< %OWNINTEGER BT=16_0203, BF=16_0303
< !    FORMAT CODES
< %OWNINTEGER REGISTER=1, MEM=2, LIT=4, SHORT=8
< %OWNINTEGER ZQUERY=0
< %INTEGER OP,K,Q,LITVAL,NQ,TYPE1,VAL1,FREE
---
> !   7502 OP-CODES
> %OWNINTEGER ADD=16_F400, SUB=16_F500, AND=16_F100
> %OWNINTEGER OR=16_F000, XOR=16_F700, COMP=16_F200
> %OWNINTEGER COPY=16_F300
> %OWNINTEGER LOADI=16_6000, SKIDI=16_7000, ADDI=16_8000
> %OWNINTEGER ANDI=16_9000
> %OWNINTEGER BOC=16_5800, BOCR=16_5000, JUM=16_4000
> %OWNINTEGER SKIP=16_4002, LOADC=16_20F2, ROT=16_3000
> %OWNINTEGER LOAD=16_2000, STORE=16_2008
> 
> %INTEGER Q,NQ,OP,K,LITVAL,TYPE1,VAL1,FREE
268,297c249,258
< %ROUTINE FORM INST(%INTEGER CODE)
< !    LS 4 BITS OF CODE DEFINE VALID FORMATS
< !    INTERDATA OP-CODES FOR DIFFERENT FORMATS
< !    ARE SYSTEMATICALLY RELATED
< !    SHORT=REGISTER+SINC, LIT=REGISTER+LINC, MEM=REGISTER+MINC
< %OWNINTEGER SINC=16_1C00, LINC=16_C000, MINC=16_4000
< %INTEGER OP
<     OP = CODE&16_FFF0
<     %IF TYPE = REG %START
<        %IF CODE&REGISTER # 0 %START
<           TYPE = SINGLE;  VAL = OP+VAL
<           %RETURN
<        %FINISH
<        TYPE = XMASK+VAL;  VAL = 0;    !COERCE TO INDEXED IMMEDIATE
<     %FINISH
<     %IF TYPE=0 %AND !VAL!<=15 %AND CODE&SHORT#0 %START; !SHORT
<        VAL = -VAL %AND OP = OP!!16_100 %IF VAL < 0
<        TYPE = SINGLE;  VAL = OP+SINC+VAL
<     %ELSE %START
<        FAULT('R') %IF TYPE&31 = XMASK; !R0 AS INDEX
<        %IF TYPE&MEMMASK = 0 %START;   !IMMEDIATE
<           FAULT('I') %IF CODE&LIT = 0
<           OP = OP+LINC
<        %ELSE %START;                  !MEMORY
<           FAULT('I') %IF CODE&MEM = 0
<           OP = OP+MINC
<        %FINISH
<        OP = OP!!OPMASK %IF TYPE&RELMASK # 0
<        TYPE = TYPE&15+OP
<     %FINISH
---
> 
> %ROUTINE COMBINE
> %INTEGER I,J,K
>     I = 11; K = 2048
>     I=I-1 %AND K=K>>1 %WHILE K&TYPE1 = 0 %AND I # 0
>     J = K
>     I =I-1 %AND J=J>>1 %WHILE J&VAL1 = 0 %AND I # 0
>     VAL = VAL<<I & (K<<1-1)
>     TYPE = TYPE1-K
>     VAL = VAL1-J+VAL
298a260
> 
300,308c262,268
< %INTEGER I,OP
<     OP = BF;  COND=\COND %AND OP=BT %IF COND < 0
<     %IF TYPE&(\UMASK) = LOCTYPE %START
<        I = LOC>>1-VAL>>1
<        FAULT('J') %AND I=0 %IF FLAG # 0 %AND !I! > 15
<        %IF !I! <= 15 %START
<           %IF TYPE&UMASK = 0 %OR FLAG # 0 %START
<              OP = OP<<1+2;            !0408, 0608
<              TYPE = 0;  VAL = I
---
> %INTEGER I,V
>     I = VAL-LOC
>     %IF COND&6 = 0 %START
>     %IF COND = 8 %START
>     %RETURN %IF I=1
>     PLANT(SKIP)
>     %FINISH
310c270,274
<              FAULT('S') %IF LIST >= 0 %AND LIST&8 # 0
---
>     FAULT('J') %AND I=0 %IF FLAG # 0 %AND !I! > 127
>     %IF !I! <= 127 %START
>     %IF TYPE&UMASK = 0 %OR FLAG # 0 %START
>     PLANT(BOC+(COND!!1)<<8+I&255)
>     %RETURN
311a276
>     FAULT('S') %IF LIST >= 0 %AND LIST&8 # 0
312a278
>     PLANT(BOC+COND<<8+2)
314,316c280
<     FORM INST(COND<<4+OP)
<     PLANT VAL
<     COND = 0
---
>     PLANT(JUM+(VAL-LOC)&4095)
317a282
> 
319a285,286
>     CASE = CASE+16_0800 %IF COND&6 = 0
>     CASE = CASE+16_0400 %IF COND&1 # 0
325,326c292,293
<     COND = \COND
<     PLANT JUMP
---
>     COND = COND!!1
>     PLANT JUMP;  COND = 0
328a296
> 
330d297
<     FORM INST(CODE)
332,351c299
<     PLANT VAL
< %END
< %ROUTINE LOAD REG(%INTEGER R)
< %INTEGER OP
<     %IF ATYPE = TYPE %AND AVAL = VAL %START
<        TYPE = REG;  VAL = ACC
<        %RETURN %IF R = ACC
<     %FINISH
<     ATYPE = TYPE %AND AVAL = VAL %IF R = ACC
<     ATYPE = -1 %IF (ATYPE=REG %AND AVAL=R) %OR ATYPE&15=R#0
<     %IF TYPE&BMASK = 0 %START
<        OP = LOAD
<        OP = ADD %AND TYPE = 0 %IF TYPE!!XMASK = R # 0
<        CREG = R;  CTYPE = 0;  CVAL = 0
<     %ELSE %START
<        OP = LB
<        CREG = -1 %IF CREG = R
<     %FINISH
<     PLANT INST(R<<4+OP)
<     TYPE = REG;  VAL = R
---
>     PLANT(CODE)
352a301
> 
356c305
<     I = TYPE&15;  I = VAL %IF I = 0
---
>     I = TYPE&15;  I = VAL %IF TYPE = REG
364c313,314
< %ROUTINE LOAD TEMP
---
> 
> %INTEGERFN TREG
366,371c316,321
<     RELEASE
<     %IF DREG >= ZQUERY %AND DUSE = 0 %START
<        I = DREG;  DUSE = 1
<     %ELSE %START
<        J = 1+ZQUERY
<        %CYCLE I = ZQUERY,1,15
---
>     %IF DREG >= 0 %AND DUSE = 0 %START
>     DUSE = 1
>     %RESULT = DREG
>     %FINISH
>     J = 1
>     %CYCLE I = 0,1,15
376a327,347
>     %RESULT = I
> %END
> 
> %ROUTINE LOAD CONST(%INTEGER R)
> %INTEGER I,J
>     I = LOADI+R<<8
>     %IF VAL&(\255) = 0 %AND TYPE&UMASK = 0 %START
>     PLANT INST(I+VAL)
>     %ELSE %IF \VAL&(\255) = 0 %AND TYPE&UMASK = 0 %START
>     PLANT INST(I+(\VAL))
>     PLANT INST(COMP+R<<4+R)
>     CREG = R
>     %ELSE %START
> !       PLANT INST(LOADC+R<<8)
> !       PLANT INST(SKIP)
> !       PLANT VAL
>     J = VAL>>8&255
>     J = J+1 %IF VAL&128 # 0
>     PLANT INST(I+J)
>     PLANT INST(ROT+R<<8+7<<4+R)
>     PLANT INST(ADDI+R<<8+VAL&255) %IF VAL&255 # 0
378d348
<     LOAD REG(I)
379a350,410
> 
> %ROUTINE LOAD REG(%INTEGER R)
> %INTEGER OP
>     %IF ATYPE = TYPE %AND AVAL = VAL %START
>     TYPE = REG;  VAL = ACC
>     %RETURN %IF R = ACC
>     %FINISH
>     ATYPE = TYPE %AND AVAL = VAL %IF R = ACC
>     ATYPE = -1 %IF (ATYPE=REG %AND AVAL=R)
>     ATYPE = -1 %IF ATYPE&XMASK # 0 %AND ATYPE&15 = R
>     %IF TYPE = REG %START
>     PLANT INST(COPY+R<<4+VAL)
>     CREG = R
>     %ELSE %IF TYPE&XMASK = 0 %START
>     LOAD CONST(R)
>        PLANT INST(LOAD+R<<8+R<<4) %IF TYPE&MEMMASK # 0
>     %ELSE %START
>        %IF VAL&(\3) # 0 %OR TYPE&MEMMASK = 0 %START
>           %IF TYPE&15 # R %START
>              %IF !VAL! <= 127 %START
>                 PLANT INST(COPY+R<<4+TYPE&15)
>                 PLANT INST(ADDI+R<<8+VAL&255) %IF VAL # 0
>              %ELSE %START
>                 LOAD CONST(R)
>                 PLANT INST(ADD+R<<4+TYPE&15)
>              %FINISH
>              CREG = R
>           %ELSE %START
>              %IF !VAL! <= 127 %START
>                 %IF VAL # 0 %START
>                    PLANT INST(ADDI+R<<8+VAL&255)
>                    CREG = R
>                 %FINISH
>                 %ELSE %START
>                 OP = TREG
>                 LOAD CONST(OP)
>                 TYPE = REG;  VAL = OP
>                 RELEASE
>                 PLANT INST(ADD+R<<4+OP)
>                 CREG = R
>                 %FINISH
>                 %FINISH
>                 TYPE = TYPE&MEMMASK+XMASK+R;  VAL = 0
>                 %FINISH
>     %IF TYPE&MEMMASK # 0 %START
>     PLANT INST(LOAD+R<<8+(TYPE&15)<<4+VAL)
>     CREG = -1
> !   %FINISH  -- commenting out this line allows the program to compile
>     %ELSE %START
>     LOAD CONST(R)
>     PLANT INST(LOAD+R<<8+R<<4)
>     %FINISH
>     %FINISH
>     TYPE = REG;  VAL = R
> %END
> 
> %ROUTINE LOAD TEMP
>     RELEASE
>     LOAD REG(TREG)
> %END
> 
385,390c416
< %ROUTINE PROGREF
<     %IF TYPE&RELUXMASK = XMASK %AND VAL = 0 %START
<        VAL = TYPE&15;  TYPE = REG
<     %FINISH
<     TYPE = TYPE!MEMMASK %IF TYPE # REG
< %END
---
> 
394a421
> 
403a431
> 
412a441
> 
424c453,456
<        LOAD TEMP %IF TYPE&BMASK # 0 %OR (OP&MEM=0 %AND TYPE&MEMMASK#0)
---
>     %IF OP = AND %AND TYPE = 0 %AND VAL&(\255) = 0 %START
>     PLANT INST(ANDI+VAL1<<8+VAL)
>     %ELSE %START
>     LOAD TEMP %IF TYPE # REG
426c458,459
<        PLANT INST(VAL1<<4+OP)
---
>     PLANT INST(OP+VAL1<<4+VAL)
>     %FINISH
428,429c461,463
<        CREG = VAL;  CTYPE = 0;  CVAL = 0
<        ATYPE = -1 %IF ACC = VAL %OR ATYPE&15 = VAL # 0
---
>     CREG = VAL
>     ATYPE = -1 %IF ACC = VAL
>     ATYPE = -1 %IF ATYPE&XMASK # 0 %AND ATYPE&15 = VAL
431a466
> 
434a470
> 
446,447c482
<     %IF TYPE1 = REG %START
<        ->BOP %IF VAL1 = 0
---
>     %IF TYPE1 = REG %AND %NOT TYPE=VAL=0 %START
451a487,501
> ASS(-6):
>     LITVAL = VAL1<<VAL;  K = (-1)<<VAL
>     VAL = 16-VAL
>     ->AS7
> ASS(-7):
>     LITVAL = VAL1>>VAL;  K = (16_FFFF)>>VAL
> AS7:K=0 %AND ->BOP %IF MODE <= 0
>     FAULT('I') %IF TYPE # 0 %OR VAL&(\15) # 0
>     %IF %NOT TEMP %START
>     SWOP;  LOAD TEMP;  SWOP
>     %FINISH
>     OP = ROT+VAL1<<8+VAL1
>     PLANT INST(OP+16_0070) %IF VAL > 8
>     PLANT INST(OP+(VAL-1)<<4) %IF VAL # 0
>     TYPE = 0;  VAL = K;  K = -3
461,468c511
< ASS(-6):
<     OP = SLLS;  LITVAL = VAL1<<VAL
<     OP = SLHL %IF TYPE # 0
<     ->NOP
< ASS(-7):
<     OP = SRLS;  LITVAL = VAL1>>VAL
<     OP = SRHL %IF TYPE # 0
<     ->NOP
---
> 
473a517
> 
477,486c521,524
<        VAL1 = TYPE1 %AND VAL = TYPE %IF TYPE1 # TYPE
<        LITVAL = \3
<        LITVAL = 1 %IF VAL1 < VAL
<        LITVAL = 2 %IF VAL1 > VAL
<        K = K&LITVAL;  K = \0 %IF K # 0
<     %ELSE %UNLESS CREG=16 %AND TYPE1=CTYPE %AND VAL1=CVAL %AND TYPE=VAL=0 %START
<        %IF TYPE1 # REG %START
<           SWOP
<           %IF TYPE1 # REG %START
<              LOAD TEMP;  SWOP
---
>     LITVAL = 2_01011000
>     LITVAL = 2_01100100 %IF VAL < 0
>     LITVAL = 2_10101000 %IF VAL1 > VAL
>     K = LITVAL>>K&1;
488,501c526,529
<              K = K!!3 %UNLESS K = 3 %OR K = \3
<           %FINISH
<        %FINISH
<        %UNLESS CREG = VAL1 %AND CTYPE = TYPE %AND CVAL = VAL %START
<           CREG = VAL1;  CTYPE = TYPE;  CVAL = VAL
<           %UNLESS TYPE = VAL = 0 %START
<              OP = COMP
<              %IF TYPE = ATYPE %AND VAL = AVAL %START
<                 TYPE = REG;  VAL = ACC
<              %FINISH
<              %IF TYPE&BMASK # 0 %START
<                 OP = CLB
<                 FAULT('I') %UNLESS K = 3 %OR K = \3
<              %FINISH
---
>     %UNLESS K&6=4 %AND -256<VAL<0 %AND TYPE&XMASK#0 %START
>     LOAD TEMP %IF TYPE # REG
>     PLANT INST(COPY+VAL<<4+VAL) %IF CREG # VAL
>     CREG = VAL
503,506c531,532
<              OP = LOAD
<              TYPE = REG;  VAL = VAL1
<           %FINISH
<           PLANT INST(VAL1<<4+OP)
---
>     PLANT INST(SKIDI+(TYPE&15)<<8-VAL)
>     K = K+4;                    !8,9
510a537
> 
512c539
<     COND = \VAL
---
>     COND = VAL!!1
514c541,542
< ASS(-13):                             !AND,WHILE
---
> 
> ASS(-13):                             !AND
518c546
<        %RETURN %IF COND # 0;          !CONDITION FALSE
---
>     %RETURN %IF COND = 0
521a550
> 
524c553
<        COND = \COND
---
>     COND = COND!!1
527c556
<        %RETURN %IF COND = 0;          !CONDITION TRUE
---
>     %RETURN %IF COND # 0
529a559
> 
532a563
> 
534c565
<     COND = \0
---
>     COND = 1
536a568
> 
539a572
> 
542a576
> 
545a580
> 
549,553c584
<        %IF MODE > 0 %START
<           ZQUERY = 1
<           LOAD TEMP
<           ZQUERY = 0
<        %ELSE FAULT('A')
---
>     %IF MODE > 0 %THEN LOAD TEMP %ELSE FAULT('A')
558d588
<     ZQUERY = 0
561a592
> 
563,574c594
<     %IF TYPE1&OPMASK = 16_7000 %START
<        %IF TYPE1&16_10 = 0 %START;    !REG-TYPE INST
<           FAULT('I') %IF TYPE # REG
<        %ELSE %START
<           VAL = \VAL %AND VAL1 = VAL1!!16_0100 %IF VAL < 0
<           FAULT('I') %IF TYPE # 0 %OR VAL > 15
<        %FINISH
<        TYPE = TYPE1+16_8000;  VAL = VAL1&16_FF0F+VAL<<4
<     %ELSE %IF TYPE1&OPMASK = 16_F000 %START
<        PROGREF %IF VAL1&16_FC0F = 16_0003; !BAL,BTC,BFC
<        FORM INST(VAL1)
<     %ELSE FAULT('I')
---
>     COMBINE
576,578c596,599
< ASS(-23):                             !MACHINE INST
<     SET JUMP(16_1000) %IF COND # 0
<     PLANT VAL
---
> 
> ASS(-23):                             !PLANT INST
>     MODE = 1
>     PLANT INST(VAL)
580a602
> 
584a607
> 
590d612
<        %IF FLAG = 0 %START
593c615
<              ATYPE = TYPE %AND AVAL = VAL %IF K = 0 %OR 1<<K&TEMPS = 0
---
>     ATYPE = TYPE %AND AVAL = VAL %IF TYPE&XMASK = 0 %OR 1<<K&TEMPS = 0
595,598c617,620
<           OP = STORE;  OP = STB %IF TYPE&BMASK # 0
<        %ELSE %START
<           CREG = 16;  CTYPE = TYPE;  CVAL = VAL
<           OP = AHM
---
>     %IF TYPE&XMASK = 0 %OR VAL&(\3) # 0 %START
>     TYPE = TYPE&(\MEMMASK)
>     LOAD TEMP
>     TYPE = MEMMASK+XMASK+VAL;  VAL = 0
600c622
<        PLANT INST(VAL1<<4+OP)
---
>     PLANT INST(STORE+VAL1<<8+(TYPE&15)<<4+VAL)
602a625
> 
605,615c628,629
<     %IF FLAG < 0 %START;              !REPEAT
<        FLAG = 0
<        %IF PASS = 0 %START
<           K = NP;  LITVAL = LOC
<           %WHILE INTEGER(K)&16_1000 # 0 %CYCLE
<              K = K+2;  LITVAL = LITVAL-2
<           %REPEAT
<           FLAG = 1 %IF LITVAL-VAL < 32
<        %FINISH
<     %FINISH
<     PROGREF
---
>     TYPE = TYPE!MEMMASK %IF TYPE # REG
>     %IF TYPE&(\UMASK) = LOCTYPE %START
617,661d630
<     %RETURN
< %END;  !ASSEMBLE
< %ROUTINE LOOKUP(%INTEGER CONTROL)
< !ALL DICT OPERATIONS LOCALISED HERE
< !CONTROL = 0 (LOOKUP ONLY), 1 (FORWARD OK),
< !          2 (REDEF), 3 (DEF),
< !          4 (MACPARM), 7 (LABEL)
< %INTEGER DP
<     DP = DEFMIN;  DP = MP+5 %IF CONTROL = 4
< !    %WHILE INTEGER(DP) # 0 %CYCLE
< !       ->YES %IF INTEGER(DP) = TAG1 %AND INTEGER(DP+1) = TAG2
< !       DP = DP+4
< !    %REPEAT
< %OWNINTEGER P
<     DP = DP-4
< REP:DP = DP+4
<     %LAC* DP; %OPR 640;!SNA; %JMP NO
<     %SAD TAG1; %OPR 512; %JMP REP
<     %LAC DP; %TAD #1; %DAC P
<     %LAC* P; %SAD TAG2; %JMP YES
<     ->REP
< NO:
<     %RETURN %IF CONTROL&1 = 0;        !NO CREATION
< NEW:DEFMIN = DEFMIN-4;  DP = DEFMIN
<     %MONITOR 21 %IF DP-QLIM <= 0
<     INTEGER(DP) = TAG1;  INTEGER(DP+1) = TAG2
< SET:INTEGER(DP+2) = TYPE;  INTEGER(DP+3) = VAL
<     %RETURN
< YES:%IF CONTROL&2 = 0 %START;         !NOT DEF CLASS
<        TYPE = INTEGER(DP+2);  VAL = INTEGER(DP+3)
<        %RETURN
<     %FINISH
<     %IF CONTROL = 3 %START
<        ->NEW %IF DP-INTEGER(BP) >= 0; !GLOBAL
<        FAULT('D')
<     %FINISH
<     ->SET %IF CONTROL # 7
<     %IF INTEGER(DP+2)&OPFMASK = FMASK %START
<        VAL = INTEGER(DP+3)
<        %IF PASS = 0 %START
<           INTEGER(VAL) = LOC
<        %ELSE %START
<           FAULT('P') %AND LOC=INTEGER(VAL) %IF INTEGER(VAL) # LOC
<        %FINISH
<        VAL = LOC
663,680c632,636
<        ->NEW %IF DP-INTEGER(BP) >= 0
<        FAULT('D')
<     %FINISH
<     ->SET
< %END
< %ROUTINE TAGREF
< %OWNINTEGER B=2184, W=24717
<     %IF TERM = '(' %START
<        TYPE = 0;  VAL = 0
<        %RETURN %IF TAG1 = W
<        TYPE = BMASK
<        %RETURN %IF TAG1 = B
<     %FINISH
<     TYPE = LOCTYPE+FMASK+UMASK;  VAL = LABMIN-1
<     LOOKUP(1)
<     %IF TYPE&OPFMASK = FMASK %START
<        %IF VAL = LABMIN-1 %START
<           LABMIN = VAL;  %MONITOR 22 %IF LABMIN = ALMAX
---
>     TYPE = XMASK+VAL %AND VAL=0 %IF TYPE = REG
>     FAULT('I') %IF TYPE&XMASK = 0 %OR VAL&(\15) # 0
>     %IF COND&8 # 0 %START
>     PLANT(SKIP) %IF COND = 8
>     COND = 1
682,686c638
<        %IF PASS > 0 %START
<           VAL = INTEGER(VAL)
<           FAULT('U') %IF VAL = 0
<        %FINISH
<        TYPE = TYPE-FMASK
---
>     PLANT(BOCR+COND<<8+(TYPE&15)<<4+VAL)
687a640,641
>     COND = 0
>     %RETURN
688a643
> 
694a650
> 
699a656
> 
705a663
> 
743,745c701
<     TAG1 = J
<     %CYCLE
<        J = 0
---
>     TAG1 = J;  J = 0
749,754d704
<        %EXIT %UNLESS TERM = QQ
<        TYPE = 1;  LOOKUP(0)
<        FAULT('U') %IF TYPE # 0
<        TAG1 = VAL
<        TERM = 0;  CODE SYM
<     %REPEAT
757a708
> 
763a715,766
> 
> %ROUTINE LOOKUP(%INTEGER CONTROL)
> !ALL DICT OPERATIONS LOCALISED HERE
> !CONTROL = 0 (LOOKUP ONLY), 1 (FORWARD OK),
> !          2 (REDEF), 3 (DEF),
> !          4 (MACPARM), 7 (LABEL)
> %INTEGER DP
>     DP = DEFMIN;  DP = MP+5 %IF CONTROL = 4
> !    %WHILE INTEGER(DP) # 0 %CYCLE
> !       ->YES %IF INTEGER(DP) = TAG1 %AND INTEGER(DP+1) = TAG2
> !       DP = DP+4
> !    %REPEAT
> %OWNINTEGER P
>     DP = DP-4
> REP:DP = DP+4
>     %LAC* DP; %OPR 640;!SNA; %JMP NO
>     %SAD TAG1; %OPR 512; %JMP REP
>     %LAC DP; %TAD #1; %DAC P
>     %LAC* P; %SAD TAG2; %JMP YES
>     ->REP
> NO:
>     %RETURN %IF CONTROL&1 = 0;        !NO CREATION
> NEW:DEFMIN = DEFMIN-4;  DP = DEFMIN
>     %MONITOR 21 %IF DP-QLIM <= 0
>     INTEGER(DP) = TAG1;  INTEGER(DP+1) = TAG2
> SET:INTEGER(DP+2) = TYPE;  INTEGER(DP+3) = VAL
>     %RETURN
> YES:->NEW %IF CONTROL = 3 %AND DP-INTEGER(BP) >= 0
>     %IF CONTROL&2 = 0 %START;         !NOT DEF CLASS
>     TYPE = INTEGER(DP+2);  VAL = INTEGER(DP+3)
>     %RETURN %UNLESS TYPE&OPMASK = MACRO %AND CONTROL = 0
>     %IF TYPE&31#25 %THEN INTEGER(DP+2)=TYPE+1 %C
>     %ELSE INTEGER(DP+2) = TYPE+7
>     %RETURN
>     %FINISH
>     FAULT('D') %IF CONTROL = 3
>     ->SET %IF CONTROL # 7
>     %IF INTEGER(DP+2)&(OPMASK+FMASK) = FMASK %START
>     VAL = INTEGER(DP+3)
>     %IF PASS = 0 %START
>     INTEGER(VAL) = LOC
>     %ELSE %START
>     FAULT('P') %AND LOC=INTEGER(VAL) %IF INTEGER(VAL) # LOC
>     %FINISH
>     VAL = LOC
>     %ELSE %START
>     ->NEW %IF DP-INTEGER(BP) >= 0
>     FAULT('D')
>     %FINISH
>     ->SET
> %END
> 
767a771
> 
768a773
> %OWNINTEGER W=24717
769a775
> 
775c781,796
< E3:    TAGREF %IF PEND >= 0
---
> E3: %IF TAG1 = W %START;          !W
>     TYPE = 0;  VAL = 0
>     %ELSE %START
>     %IF PEND >= 0 %START
>     TYPE = LOCTYPE+FMASK+UMASK;  VAL = LABMIN-1
>     LOOKUP(1)
>     %IF TYPE&(OPMASK+FMASK) = FMASK %START
>     %IF VAL = LABMIN-1 %START
>     LABMIN = VAL;  %MONITOR 22 %IF LABMIN = ALMAX
>     %FINISH
>     VAL = INTEGER(VAL)
>     FAULT('U') %IF VAL = 0
>     TYPE = TYPE-FMASK
>     %FINISH
>     %FINISH
>     %FINISH
778c799
<           TYPE = 0 %IF SAVE&1 = 0;  VAL = VAL+VAL+SAVE
---
>     TYPE = 0 %IF SAVE&1 = 0;  VAL = VAL+SAVE;   !?
780d800
<        FAULT('I') %AND TYPE=0 %IF TYPE&OPMASK # 0
781a802
>     FAULT('I') %AND TYPE=0 %IF TYPE&OPMASK # 0
839a861
> 
848,856c870,878
<     I = 1
<     NEST(-1) %AND ->E8 %IF S('+')
<     NEST(-2) %AND ->E8 %IF S('-')
<     NEST(-3) %AND ->E9 %IF S('&')
<     NEST(-4) %AND ->E9 %IF S('!')
<     NEST(-5) %AND ->E9 %IF S('\')
<     NEST(-6) %AND ->E9 %IF SS('<')
<     NEST(-7) %AND ->E9 %IF SS('>')
<     NEST(-8) %AND ->E9 %IF S('_')
---
> 
>     NEST(-1) %AND ->E1 %IF S('+')
>     NEST(-2) %AND ->E1 %IF S('-')
>     NEST(-3) %AND ->E1 %IF S('&')
>     NEST(-4) %AND ->E1 %IF S('!')
>     NEST(-5) %AND ->E1 %IF S('\')
>     NEST(-6) %AND ->E1 %IF SS('<')
>     NEST(-7) %AND ->E1 %IF SS('>')
>     NEST(-8) %AND ->E1 %IF S('_')
860,863d881
< E8: I = 0
< E9: ->E1 %UNLESS MODE = 2 %AND NP+1 = NBASE
<     %IF FLAG = I %THEN FLAG = QLIM %ELSE FLAG = -1
<     ->E1
865c883,884
< %ROUTINE CONDIT(%INTEGER QVAL)
---
> 
> %ROUTINE GET COND
873c892
<           K = 3
---
>     K = 5
875c894
<           K = \3
---
>     K = 4
877c896
<           K = \1;  K = 2 %IF S('=')
---
>     K = 3;  K = 7 %IF S('=')
879c898
<           K = \2;  K = 1 %IF S('=')
---
>     K = 6;  K = 2 %IF S('=')
882c901
<           ->ANDOR
---
>     %RETURN
884a904
>     QUEUE(-2);  !SUBTRACT
886,887c906
< ANDOR:
<        %EXIT %IF %NOT TAG
---
>     %RETURN %IF %NOT TAG
896,898d914
<     QUEUE(QVAL) %IF QVAL # 0
<     ASSEMBLE
<     ATYPE=-1 %AND CREG=-1 %IF J < 0
899a916
> 
902,908d918
< !OPMASK VALUES
< !    0100,0110,1100,1101,1110: DOUBLE WORD INSTRUCTIONS
< !    1011,1001,0011,0010,0001: AS ABOVE BUT RELOCATABLE
< !    0101: SINGLE WORD INSTRUCTION
< !    0111: 2 OPERANDS TO COME
< !    1111: 1 OPERAND TO COME
< !    1010: MACRO
910d919
<     %RETURN %IF TYPE&16_7000 # 16_7000
917a927
> 
950,954c960
<           GETPOS = INTEGER(MP+2)
<           STARTPOS = INTEGER(MP+3)
<           MP = INTEGER(MP+4)
<           %IF MP < 0 %START
<              MP = MP-8_700000
---
>     %IF INTEGER(MP+1)&16_8000 # 0 %START
959a966,968
>     GETPOS = INTEGER(MP+2)
>     STARTPOS = INTEGER(MP+3)
>     MP = INTEGER(MP+4)
966d974
<        QQ = 0
977a986,989
>     %IF SYM = '?' %START
>     PUT CHAR(INTEGER(MP+1)>>5&31+'A')
>     SYM = INTEGER(MP+1)&31+'A'
>     %FINISH
982d993
<        QQ = '?'
986a998
> 
1006a1019
> 
1017a1031
> 
1018a1033
> 
1021a1037
> 
1024a1041
> 
1034c1051
<     DEFLIM = BP-(SBOUND>>2)
---
>     DEFLIM = STORELIM-(SBOUND>>2)
1038a1056
>     PUT WORD(0) %AND CONTROL=16_20 %IF PASS > 0
1075c1093,1097
<     ->LEND %IF SYM = NL
---
>     %IF SYM = NL %START
>     ->LEND %IF LINES < 54
>     DO NEWLINE %WHILE LINES # 0
>     ->READ
>     %FINISH
1112c1134
<                 PLANT VAL;  VAL = VAL&255
---
>     PLANT VAL
1115c1137
<              PLANT VAL
---
>     PLANT VAL;  VAL = VAL&255
1127a1150
> 
1134a1158
> 
1146,1160d1169
<     %IF FLAG # 0 %START
<        %IF DREG<0 %AND FLAG-QSTART=QSTART-QBASE-1 %C
<           %AND INTEGER(QBASE)&BMASK=0 %START
<        I = QBASE;  J = QSTART
<        I = I+1 %AND J=J+1 %WHILE INTEGER(I) = INTEGER(J)
<        %IF J = FLAG %START
<           %IF INTEGER(QLIM-1) = -2 %START; !MINUS
<              QSTART = J-2
<              INTEGER(QSTART) = 0;  INTEGER(QSTART+1) = 0
<           %ELSE
<              QSTART = J;  QLIM = QLIM-1
<           %FINISH
<        %ELSE FLAG = 0
<        %ELSE FLAG = 0
<     %FINISH
1161a1171
> 
1165c1175
<        CONDIT(0)
---
>     GET COND;  ASSEMBLE
1170a1181
> 
1175a1187
> 
1180a1193
> 
1182,1183c1195,1196
<     QUEUE(0);                         !(DEFPOS)
<     QUEUE(0);                         !SPARE
---
>     QUEUE(VAL);                       !DEFPOS
>     QUEUE(TYPE&1023);                 !JOKER
1187d1199
<     J = VAL;  QQ = 0
1189c1201
<        %EXIT %IF CHAR(J) = NL;        !END OF MAC DEF
---
>     %EXIT %IF CHAR(INTEGER(QBASE)) = NL; !END OF MAC DEF
1191c1203
<        GETPOS = J;  GET SYM
---
>     GETPOS = INTEGER(QBASE);  GET SYM
1196c1208
<        J = GETPOS-1;                  !SAVE DEFPOS
---
>     INTEGER(QBASE) = GETPOS-1;        !UPDATE DEFPOS
1203d1214
<     QQ = '?'
1206c1217
<        CONDIT(-18)
---
>     GET COND; QUEUE(-18); ASSEMBLE
1208c1219
<        INTEGER(QBASE+4) = MP+8_700000
---
>     INTEGER(QBASE+1) = INTEGER(QBASE+1)+16_8000
1211,1213c1222,1223
<     STARTPOS = QLIM<<1
<     MP = QBASE
<     INTEGER(MP) = J+1;                !START OF BODY
---
>     MP = QBASE; STARTPOS = QLIM<<1
>     INTEGER(MP) = INTEGER(MP)+1
1215c1225,1227
<     ->LEND
---
>     PRINT LINE %IF PRINTPOS # 0 %AND LIST&2 # 0
>     ->READ
> 
1217a1230
> 
1219c1232
<     CONDIT(-15)
---
>     GET COND;  QUEUE(-15);  ASSEMBLE
1220a1234
> 
1227c1241
<        CONDIT(-17)
---
>     GET COND;  QUEUE(-17);  ASSEMBLE
1229a1244
> 
1238c1253
<           I = VAL+4
---
>     I = VAL+1
1242a1258
> 
1245c1261
<     CONDIT(-13)
---
>     GET COND;  QUEUE(-13); ASSEMBLE
1247a1264
> 
1250d1266
<     ATYPE = -1;  CREG = -1
1251a1268
> 
1258a1276
> 
1261a1280
> 
1265a1285
> 
1267a1288
> 
1273a1295
> 
1277c1299
< A1: CONDIT(0)
---
> A1: GET COND; ASSEMBLE
1280a1303
> 
1291a1315
> 
1296a1321
> 
1304c1329
<           TAGREF
---
>     TYPE = UMASK;  LOOKUP(0)
1317a1343
> 
1320a1347
> 
1324a1352
> 
1337a1366
> 
1341,1347c1370,1372
<     %IF TYPE&16_FF80 = 0 %START
<        %IF I = 13556 %START;          !LOC
<           OUTPUT RECORD %IF BINCOUNT >= 203
<           PUT(3) %IF (LOCTYPE!!TYPE)&RELMASK # 0
<           PUT(5);  PUT WORD(VAL)
<        %FINISH
<        LOCTYPE = TYPE&63+MEMMASK;  LOC = VAL
---
>     %IF TYPE&16_FF9F = 0 %START
>     LOCTYPE = TYPE&RELMASK+MEMMASK;  LOC = VAL
>     PUT WORD(VAL-1) %AND CONTROL=16_30 %IF PASS > 0
1349a1375
> 
1353a1380
> 
1380a1408
> 
1385a1414
> 
1389a1419
> 
1406,1408c1436,1439
<     OUTPUT RECORD %IF BINCOUNT = 208
<     PUT(1)
<     OUTPUT RECORD
---
> 
>     PUT WORD(CHECK!!16_0100);  CONTROL = 16_30
>     PUT WORD(16_0100)
>     SELECT OUTPUT(BIN);  PRINT CH(16_60);  SELECT OUTPUT(LIS)
1410a1442,1444
>     LINES = 60 %IF OUTDEV = 1
>     DO NEWLINE %WHILE LINES # 0
>