*DECK     SQZ 
          IDENT  SQZ
 SBB      TITLE  SQZ - REDUNDANT OPERATION ELIMINATION
*CALL     SSTCALL 
 B=SQZ    RPVDEF
  
*IF       DEF,SQZ,1 
          TRACER (INITX,EDD,SQZ.X)
          TABLES (CUT,CVT,MOD,RND,TET,TXT)
          EXT#   (N.GT,L.HB)
  
**        SQZ - SQUEEZE INSTRUCTION SEQUENCE TO - 
*                ELIMINATE REDUNDANT AND UNUSED INSTRUCTIONS
*                INSTRUCTION SIMPLIFICATION ( ALGEBRAIC IDENTITIES )
*                COMPILE TIME EVALUATION OF CONSTANT EXPRESSIONS
*                GLOBAL TEMPORARY SQUEEZING ( IT."S ) 
* 
*         ENTRY  *TXT* TABLE HOLDS AN ARBITRARY COLLECTION OF BLOCKS
*         TERMINATED BY AN *EOQ*.  R-NUMBERS MAY NOT "ROLL OVER". 
* 
*         EXIT   BLOCK SQUEEZED, REDUNDANT AND USELESS INSTRUCTIONS 
*         REMOVED. PRECEDENCE BITS ( PS,PRS,RJRS ) SET AND USES COUNTS
*         INSTALLED, LINK WORDS CLEARED AND *USI* BIT SET FOR REDUCED 
*         *IAZ/ISZ* INSTRUCTIONS TO PREVENT OVERSQUEEZING IN OPT=2 .
* 
*         S.I. JASIK - JAN 1973 
          SPACE  2
 STLDS    ENTRY. 0,#         ST/LD SQZ FLAG, "0 IF ST/LD SQZ DONE 
 SUVA     ENTRY. 0,#         SQUEEZED USE *BV* ADDRESS ( *AUV* CALL ) 
 LCM#G    ENTRY. 0           = 1S( D.L2++59-D.STP ) IF LCM=G ON CC
  
          QUAL   SQUEEZE
          SPACE  2
 CLEAR    MACRO              CLEAR LINK CHAINS
          MX6    0
          SA6    MRC
          DUP    N.CHAIN-1,1
          SA6    A6+B1
          ENDM
 LINK     SPACE  2
**        I. - LINK INFORMATION WORD FORMAT DURING SQUEEZING
  
          DESCRIBE I.,60
 JP       DEFINE 1           =1 IF INSTRUCTION IS A JP ON *MRC* 
          DEFINE 5
 RS       DEFINE 18          *RS* DEFINITION ADDRESS
 STC      DEFINE 18          STORE CHAIN ( POINTER TO PRECEEDING STORES 
 IC       DEFINE 18          MEMORY REF / MISC INSTRUCTION CHAINS 
  
 CA       DEQU   STC         SAVED CA OF LDC INSTRUCTION
          SPACE  2
 SQZ      TITLE  TABLE FORMATS, FLAGS 
**        RN. - R-NUMBER DEFINITION/EQUIVALENCE TABLE FORMAT
  
          DESCRIBE RN.,60 
 Z        DEFINE 1           RI DEFINES A ZERO
 C        DEFINE 1           CONSTANT ( S, FMA, CLR, LDC, ETC. )
 SA       DEFINE 1           RI IS RESULT OF SA  RI,RJ
 IAC      DEFINE 1           IA/IS HAS A CONSTANT OPERAND 
 INC      DEFINE 1           IA/IS IS AN INCREMENT ( I = I+CON )
 XMT      DEFINE 1           RI IS THE RESULT OF AN XMT 
 XMTC     DEFINE 1           RI IS THE RESULT OF AN XMTC
 PZ       DEFINE 1           PACKED ZERO
 NR       DEFINE 1           NORMALIZE NOT REQUIRED 
 FMA      DEFINE 1           "0 IF FMA CHANGED TO A SET 
          DEFINE 4
 USES     DEFINE 10          USES COUNT 
 TP       DEFINE 18          *TXT* ADDR OF INSTRUCTION DEFINING THE RI
 RN       DEFINE 18          R-NUMBER / EQUIVALENT
  
 CZ       DEQU   C,2         CONSTANT AND ZERO BITS 
 CIA      DEQU   IAC,3       C, SA , IAC BITS 
 IACI     DEQU   INC,2       IAC & INC
 FLAGS    SPACE  3
*         FLAGS 
  
 BIAS     BSSZ   1           *RNI* BIAS , =0 DURING PHASE 1 OF OPT=2
  
          USE    /CCGSCR/ 
 RNBT     BSS    2           R-NUMBER BIAS TABLE
  
 MRC      BSS    1           MEMORY REFERENCE CHAIN POINTER 
 MIC      BSS    1           MISCELLANEOUS INSTRUCTION CHAIN
 CRJC     BSS    1           CONDITIONAL  RJ CHAIN
 SXTC     BSS    1           SXT CHAIN
 FAC      BSS    1           FUNCTION ARG CHAIN 
 RJ3C     BSS    1           RJ3 CHAIN
 LDCC     BSS    1           LDC CHAIN
 N.CHAIN  EQU    *-MRC
 IXF      BSS    1           "0 IF *LDC* & PS OR *S* & SO ^= 0
 LDCN     BSS    1           LDC COUNT
 RSS      BSS    1           RS SEPARATION FLAG 
 STC      BSS    1           ADDRESS OF FINAL STORE ( ^L2 ) 
 JPXA     BSS    1           R1 ADDRESS OF LAST *JPX* 
 RJ3T     BSS    1           TEMP 
 FACS     BSS    1           TEMP 
 CAS      BSS    1           CA'S OF STORES 
 M.STK    EQU    40 
 STK      BSS    M.STK       ADDRESS STACK FOR RJ3 SQZ
          EXT    N.STMAX
 STBASE   EQU    N.STMAX
          USE    0
          SPACE  2
*         REGISTER ASSIGNMENTS
  
 TXT      MICRO  1,,/A0/     REGISTER HOLDING FWA OF BLOCK
 OC       MICRO  1,,/B3/     B REGISTER HOLDING OPCODE
 RN       MICRO  1,,/B7/     B REGISTER HOLDING BASE OF *RND* 
*         (B1) = 1
*         (B2) = 2
*         (X0) = MASK FOR RI FIELD
*         THROUGHOUT THE MASTER SQUEEZE LOOP
*         (A4,X4) = DESCRIPTOR OF CURRENT RLIST INSTRUCTION 
*         (A5) = ADDRESS OF INSTRUCTION BEING INSPECTED 
*         (B6) = RI OF CURRENT INSTRUCTION
 SQZB     TITLE  SIE / SQZB - OPT=2 ENTRY POINTS TO SQUEEZE 
**        SIE - SQUEEZE INCREMENT EXPRESSION
* 
*         EXIT   INSTRUCTIONS IN *TXT* RENUMBERED SO THAT THEY WILL 
*                BE IN CANONICAL ORDER WHEN THEY ARE ADDED TO THE 
*                LOOP HOLDING BLOCK.
  
 SIE      ROUTINE 
          SA5    SIE
          SA2    =XL.MOD
          SA3    =XL.HB 
          MX6    0           TSS = 0
          IX4    X2+X3
          SX7    X4-8        BIAS = L.HB + L.MOD-8
          EQ     SQZB1
 SQZB     SPACE  3
**        SQZB - OPT=2 ENTRY TO SQUEEZE 
* 
*                (X6) = TSS , =1 IF *TST* SQUEEZING IS TO BE DONE.
  
 SQZB     ROUTINE 
          SA5    SQZB 
          SX7    0           BIAS = 0 
          SA7    STLDS       STLDS = 0
  
 SQZB1    SA1    L.TXT
          SA2    SQZBA+X6 
          SA7    BIAS 
          BX6    X5 
          LX7    X2 
          SA6    SBB         [SBB] = EXIT ADDRESS 
          SA7    SBB.JT      [SBB.JT] = *EOQ* PROCESSOR ADDRESS 
          ALLOC  RND,X1-6    ALLOC( RND , L.TXT-6 ) 
          SA5    O.TXT
          MX0    -R1.RIL
          S"RN"  X2 
          SB2    B1+B1
          S"TXT" X5 
          EQ     SBB5A
  
 SQZBA    BSS    0
          LOC    0
          EQ     .EOQ        NO *TST* SQZ 
-         VFD    12/1S10+(EOQ,18/0
          EQ     STS
-         VFD    12/1S10+(EOQ,18/0
          LOC    *O 
 STS      TITLE  STS - SQUEEZE TEMP STORES TO ELIMINATE REDUNDANT ONES
**        STS - SQUEEZE TEMP STORES ( *TST*"S ) TO ELIMINATE REDUNDANT
*         ONE"S AND SET THE *CA* FIELD OF THE NON-REDUNDANT ONES. 
* 
*         ENTRY  FROM *SBB.JT* WHEN *EOQ* IS ENCOUNTERED. 
*         EXIT   TO *EOQ* PROCESSOR WHEN FINISHED 
  
 STS      SA1    =XN.GT      N = N.GT      */ NUMBER OF ASSIGNED IT. S
          SA5    STC
          SB2    OC.TST 
          SB4    B0          USC = 0       */ UNASSIGNED *TST* CHAIN
          SB5    X5          I = STC
          SB6    "TXT"+3     TB = O.TXT + 3 
          SA0    B0          ASC = 0       */ ASSIGNED *TST* CHAIN
          MX7    1
          EQ     STS2 
  
*         SCAN *STC* AND FORM CHAINS OF ASSIGNED AND UNASSIGNED *TST*"S 
  
 STS1     SX6    A0 
          SA6    A5          [LI] = ASC    */ LINK LAST TO THIS 
          SA0    A5+         ASC = LI      */ CHAIN POINTS TO THIS
  
 STS2     SA5    B5          LI = I 
          ZR     B5,STS3     IF I = 0      */ END OF CHAIN
          LX5    -I.STCP
          SA3    A5-3        R1 = LI - 3
          SA4    A3+B1       R2 = R1 + 1
          SB5    X5          I = STC[LI]
          UX6    B3,X3
          NE     B3,B2,STS2  IF OC[R1] " OC.TST 
  
          LX4    -IH.CAP
          SX2    X4          C = CA[R2] 
          IX6    X2-X1
          BX5    -X0*X3 
          SA7    B6+X5       LIP = TB + RI[R1];  [LIP] = 1S59  */ NOT AS
          MI     X6,STS1     IF C < N      */ TEMP NUMBER ASSIGNED
  
          SX6    B4 
          SA6    A5          [LI] = USC 
          SB4    A5          USC = LI 
          EQ     STS2 
  
 STS3     SA2    =XO.TET
          SB3    A0          I = ASC
          SB5    X2                        (B5) = [O.TET] 
          ZR     B3,STS7     IF I = 0      */ NO ASSIGNED TET"S 
  
*         SET THE *CA*"S OF THE ASSIGNED *TST*"S IN THE LINK WORD OF
*         THE INSTRUCTION DEFINING THE *RI* IN THE *TST*. 
  
 STS4     SA3    B3-3        R1 = I - 3 
          SA4    A3+B1       R2 = R1 + 1
          BX6    -X0*X3      R = RI[R1] 
          SA2    B6+X6       LIP = TB + R;  K = [LIP] 
          LX4    -IH.CAP
          SX7    X4          C = CA[R2] 
          MI     X2,STS5     IF K < 0      */ NOT EQUIVALENCED
  
*         EQUIVALENCE THE CELLS IF THEY ARE BOTH INVARIANT TEMPS
  
          SA3    B5+X7
          SX5    B1 
          LX5    T.CALP 
          BX4    X3*X5
          NZ     X4,STS5     IF CA FIELD STILL IN USE 
          SA5    B5+X2
          BX4    X3*X5
          LX4    59-T.INVP
          PL     X4,STS5     IF ^( INV[TET(C)] & INV[TET(K)] )
  
          BX7    X0*X3
          SX5    B1 
          BX7    X7+X2       CA[TET(C)] = K 
          LX5    T.EQVP 
          BX7    X5+X7       EQV[TET(C)] = 1
          SA7    A3 
          SA2    "RN"+X6     RNI = RND(R) 
          LX5    RN.USESP-T.EQVP
          IX6    X2-X5       USES[RNI] = USES[RNI] - 1
          SA6    A2 
          MX6    0
          SA6    A4+B1       DI = R2 + 1;  [DI] = 0  */ KILL ST 
          EQ     STS6 
  
 STS5     SA7    A2+         [LIP] = C     */ SET ASSIGNMENT
  
 STS6     SA5    B3          LI = [I] 
          SB3    X5          I = [LI] 
          NZ     B3,STS4     IF I " 0 
  
*         ASSIGN TEMP NUMBERS TO THE UNASSIGNED *TST*"S 
  
 STS7     SX2    B1          I = USC
          LX2    RN.USESP 
          ZR     B4,STS0     IF I = 0      */ NO UNASSIGNED TEMPS 
  
 STS8     SA3    B4-3        R1 = I - 3 
          SA4    A3+B1       R2 = R1 + 1
          BX6    -X0*X3 
          SA5    B6+X6       LIP = TB + RI[R1];  K = [LIP]
          LX4    -IH.CAP     C = CA[R2] 
          MI     X5,STS9     IF K < 0      */ NO TEMP NUMBER ASSIGNED 
  
*         *TST* IS REDUNDANT, ELIMINATE IT
  
          SA3    "RN"+X6     R = RND(RI[R1])
          MX7    0
          IX6    X3-X2       USES[R] = USES[R] - 1
          SA7    A4+B1       DI = R2 + 1;  [DI] = 0 
          SA6    A3 
          EQ     STS10
  
*         *TST* NOT REDUNDANT, ASSIGN IT A TEMP NUMBER
  
 STS9     BX7    X1 
          BX5    X0*X4
          SA7    A5          [LIP] = N     ASSIGN TEMP NUMBER 
          IX6    X5+X1       CA[R2] = N 
          LX6    IH.CAP 
          BX5    X1          K = N
          SA6    A4 
          SX1    X1+B1       N = N + 1
  
 STS10    SA3    B5+X4
          BX6    X3+X5       CA[TET(C)] = K  */ SET FINAL *CA* IN *TET* 
          SX3    1
          LX3    T.CALP 
          BX6    X6+X3       CAL[TET(C)]=1  */ LOCK CA FIELD
          SA6    A3 
          BX7    X5-X4
          SB3    X7 
          ZR     B3,STS11    IF C = K 
  
          SA5    B5+X5
          MX7    1
          LX7    1+T.INVP 
          BX6    X7*X6
          BX5    -X7*X5 
          BX6    X6+X5       INV[TET(K)] = INV[TET(C)]
          SA6    A5 
  
 STS11    SA4    B4          LI = I 
          SB4    X4          I = [LI]      */ NEXT ON CHAIN 
          NZ     B4,STS8     IF I " 0 
  
 STS0     BX7    X1          N.GT = N      */ NEXT AVAIL TEMP NO
          SA2    SQZBA
          SB2    B1+B1
          SA7    N.GT 
          BX6    X2          [SBB.JT] = [SQZBA]  */ RESTORE *EOQ* PROC
          S"TXT" B6-3 
          SA6    SBB.JT 
          EQ     .EOQ 
 SQZ      TITLE  INITIALIZATION 
**        SBB - SQUEEZE EXTENDED BASIC BLOCK. ENTRY TO SQZ FROM CG$PAS. 
* 
*         ENTRY  (CC$BRN) = BASE,LIMIT R-NUMBERS IN SEQUENCE
*                (CC$BIR) = BASE,LIMIT INTERMEDIATE R-NUMBERS 
 SBB      ROUTINE 
 .ROL     IFEQ   HC.ROL,0 
          SA1    =XCC$BRN+1 
          AX1    2
 .ROL     ELSE
  
          SA1    =XCC$BRN 
          SA3    =XCC$BIR 
          SA2    A1+B1
          SA4    A3+B1
          IX2    X2-X1       DEL(R) = CC$BRN(2) - CC$BRN(1) 
          SX0    B1+B1
          IX4    X4-X3       DEL(IR) = CC$BIR(2) - CC$BIR(1)
          IX7    X2+X4
          IX6    X0-X1
          IX1    X7+X0
          IX7    X0-X3
          SA6    RNBT        RNBT(0) = 2 - CC$BRN(1)
          IX7    X2+X7
          SA7    A6+B1       RNBT(1) = 2 + DEL(R) - CC$BIR(1) 
 .ROL     ENDIF 
  
          ALLOC  RND,X1      ALLOC( RND , DEL(IR)+DEL(R)+2 )
  
*         NOTE - ABSOLUTE ADDRESSES ARE USED THROUGHOUT THE REST OF 
*         *SBB*, HENCE NO TABLE ALLOCATION REQUESTS MAY BE MADE.
  
          SA1    O.TXT
          S"RN"  X2          (B7) = O.RND 
          S"TXT" X1          (A0) = O.TXT 
          SB2    B1+B1             (B2) = 2 
 SBB      SPACE  3           SBB
 .ROL     IFNE   HC.ROL,0 
**        REPLACE ALL OCCURRENCES OF R-NUMBERS BY INDICES TO *RND*. 
*         MAP R,R+1,...,IR,IR+1,... INTO  2,3,4,... 
*         NOTE - LOOP IS STRUCTURED TO BE *INSTACK* FOR TYPE I PROCESSIN
  
          MX0    -R1.RIL           (X0) = R-NUMBER EXTRACTOR MASK 
          SB5    R1.RIL-1 
          SB6    RNBT 
          MX1    1
          SA4    "TXT"+B2    DI = O.TXT + 2 
          EQ     SBB2 
  
*         TYPE II/III 
  
 SBB1     BX3    -X0*X5      RI = RI[R1]
          AX7    B5,X3
          SA2    X7+B6       BIAS = RNBT( SHIFT(RI,-15) ) 
          SA3    A5+B1       R2 = R1 + 1
          IX6    X2+X5       RI = RI + BIAS 
          SA6    A5 
          LX3    -IH.RFP
          BX6    -X0*X3 
          AX7    B5,X6
          SB4    X6 
          LE     B4,B1,SBB2  IF RF @ 1
          SA2    X7+B6
          IX6    X2+X3       RF = RF + BIAS 
          LX6    IH.RFP 
          SA6    A3 
  
 SBB2     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          LX4    58-D.TYP 
          IX6    X4+X4
          BX7    X4-X6
          MI     X7,SBB1     IF TYPE[DI] = II ! III 
          MI     X4,SBB5     IF TYPE[DI] = IV 
  
*         TYPE I INSTRUCTION
  
          UX7    "OC",X5
          SX6    "OC"+6000B  RWD = OC[R1] + 6000B  */ PACKED OC + TERM
          LX5    -R1.RJP     RNUMS = RJ/RK/RI 
  
 SBB3     BX3    -X0*X5 
          SB4    X3 
          AX4    B5,X3
          SA2    X4+B6       BIAS = RNBT( SHIFT(RN,-15) ) 
          LX6    R1.RIL      RWD = SHIFT(RWD,16)
          LE     B4,B1,SBB4  IF RN @ 1
          IX3    X2+X3       RN = RN + BIAS 
 SBB4     LX5    R1.RIL      RNUMS = SHIFT(RNUMS,16)
          BX6    X6+X3
          PL     X6,SBB3     IF RWD > 0 
          BX7    -X1*X6      [R1] = TYI(OC,RJ,RK,RI)
          SA7    A5 
          EQ     SBB2 
  
 SBB5     UX7    "OC",X5
          NZ     "OC",SBB2   IF OC[R1] " EOQ
 .ROL     ELSE
  
*         REPLACE ALL OCCURANCES OF R-NUMBERS BY INDICES TO *RND* 
*         MAP 0,1,4,8,....    INTO  0,1,2,3,... 
  
          MX0    -R1.RIL
          MX1    1
          SA4    "TXT"+B2    DI = O.TXT + 2 
          EQ     SBB2 
  
*         TYPE II/III 
  
 SBB1     BX3    -X0*X5 
          ZR     X3,SBB1A    IF R = 0 
          AX3    2
          BX5    X0*X5
          SX3    X3+B1       R = R/4 + 1
          IX6    X3+X5
          SA6    A5 
 SBB1A    SA2    A5+B1       R2 = R1 + 1
          LX2    -IH.RFP
          BX3    -X0*X2 
          AX3    2
          ZR     X3,SBB2     IF R < 4 
          BX2    X0*X2
          SX3    X3+B1       R = R/4 + 1
          IX6    X3+X2
          LX6    IH.RFP 
          SA6    A2 
  
 SBB2     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          LX4    58-D.TYP 
          IX6    X4+X4
          BX7    X4-X6
          MI     X7,SBB1     IF TYPE[DI] = II ! III 
          MI     X4,SBB5     IF TYPE[DI] = IV 
  
*         TYPE I INSTRUCTION
  
          UX7    "OC",X5
          SX6    "OC"+6000B  RWD = OC[R1] + 6000B  */ PACKED OC + TERM
          LX5    -R1.RJP     RNUMS = RJ/RK/RI 
  
 SBB3     BX3    -X0*X5 
          LX6    R1.RIL 
          AX4    B1,X3
          ZR     X4,SBB4     IF R < 2 
          AX3    2
          SX3    X3+B1       R = R/4 + 1
 SBB4     LX5    R1.RIL      RNUMS = SHIFT(RNUMS,16)
          BX6    X6+X3
          PL     X6,SBB3     IF RWD > 0 
          BX7    -X1*X6      [R1] = TYI(OC,RJ,RK,RI)
          SA7    A5 
          EQ     SBB2 
  
 SBB5     UX7    "OC",X5
          NZ     "OC",SBB2   IF OC[R1] " EOQ
  
          MX0    -R1.RIL           (X0) = R-NUMBER EXTRACTOR MASK 
 .ROL     ENDIF 
 SBB      EJECT 
**        SCAN *TXT* AND SETUP *RND*. CHAIN THE *RND* ENTRIES TO THE
*         INSTRUCTION THAT DEFINES THE *RI* ( RND INDEX ).
*         SET PRECEDENCE BITS ( PS,PRS,RJRS ) FOR INSTRUCTIONS
*         PRECEDING A STORE / REGISTER STORE. 
  
 SBB5A    SB4    B2+B2
          SA2    F.RDT+OC.RS       (X2) = DESCR FOR *RJ RS* 
          SX7    B0          LINK = 0 
          SX1    B1 
          LX1    D.^DP
          SB5    OC.RS
          BX2    -X1*X2 
          LX1    D.PSP-D.^DP
          SB6    B0          RSL = 0
          SA5    "TXT"
          EQ     SBB8 
  
 SBB6     SX6    B6 
          SA6    A4+B1       [DI+1] = RSL 
          LX5    59-R1.INP
          SB6    A4+B1       RSL = DI + 1 
          PL     X5,SBB8     IF IN[R1] = 0  */ NORMAL REGISTER STORE
          BX6    X2          ^D[DI] = 0 
          SA6    A4 
  
 SBB7     SX5    A5 
          LX5    RN.TPP 
          BX6    X5+X3       RND(RI) = RNDT(0,0,R1,RI[R1])
          SA6    "RN"+X3
  
 SBB8     SA5    A5+B4       R1 = R1 + 4   */ ADVANCE TO NEXT INSTRUCTIO
          SA4    A5+B2       DI = R1 + 2
          BX3    -X0*X5 
          LX4    59-D.^DP 
          UX6    "OC",X5
          PL     X4,SBB7     IF D[DI]      */ DEFINES AN *RI* ( RESULT )
          LX4    D.^DP-D.STP
          ZR     "OC",SBB9   IF OC[R1] = OC.EOQ 
          EQ     "OC",B5,SBB6      IF OC[R1] = OC.RS
          PL     X4,SBB8     IF ^ST[DI] 
                                                                                CCGA039 28
 #DAL     IFNE   .DAL,0                                                         CCGA039 29
          LX4    D.STP-D.L2P
          PL     X4,SBB8A    IF ^L2[DI]                                         CCGA039 31
          LX4    D.L2P-D.XMTP                                                   CCGA039 32
          PL     X4,SBB8     IF ^XMT[DI] */ LEVEL 2                             CCGA039 33
                                                                                CCGA039 34
 SBB8A    BSS    0                                                              CCGA039 35
 #DAL     ENDIF                                                                 CCGA039 36
                                                                                CCGA039 37
          SA3    "RN"+X3
          SA7    A4+B1       [R1+3] = LINK
          LX3    -RN.TPP
          SX7    A7 
          LX7    18          LINK = R1 + 3
          SA4    X3+B2       DJ = TP[RI] + 2
          BX6    X1+X4
          SA6    A4          PS[DJ] = 1 
          EQ     SBB8 
  
 SBB9     LX7    -I.STCP     STC = LINK    */ ADDRESS OF A FINAL STORE
          SA7    STC
  
*         NOW SET THE REGISTER STORE PRECEDENCE BITS
  
          ZR     B6,SBB11    IF RSL = 0    */ NO REGISTER STORES
          LX1    D.PRSP-D.PSP 
          MX7    0
  
 SBB10    SA2    B6-3        R1 = [RSL-3] 
          SA4    A2-B2       DI = R1 - 2   */ DESCR OF PREDECESSOR
          LX2    -R1.INP+1
          SB5    X2 
          SA2    B6 
          LX5    B5,X1       BIT = SHIFT( PRS , 2*IN[R1] )
          SA7    B6          [R1+3] = 0 
          BX6    X5+X4       DI = DI ! BIT
          SB6    X2          RSL = [RSL]
          SA6    A4 
          NZ     B6,SBB10    IF RSL " 0 
  
*         COMPLETE INITIALIZATION OF *RND*, SET REGISTERS FOR MAIN LOOP 
  
 SBB11    SX5    "TXT"
          LX5    RN.TPP 
          MX6    2
          LX6    2+RN.CZP 
          SX4    B1 
          BX6    X5+X6
          IX7    X5+X4
          LX4    RN.USESP+3 
          BX6    X4+X6
          SA6    "RN"        RND(0) = RNDT(Z,C,8,O.TXT,0) ( B0 )
          SA7    "RN"+B1     RND(1) = RNDT(0,0,O.TXT,1)   ( A0 )
          CLEAR              CLEAR CHAIN POINTERS 
          SA6    RSS         RSS = 0
          SA6    JPXA        JPXA = 0 
          SA6    IXF         IXF = 0
          SA4    "TXT"+B2    DI = O.TXT + 2 
          MX6    1
          SA6    LDCN        LDCN = 1S59   */ INDICATE NO LDC"S 
          TRACE  INITX,RLIST
 MSL      TITLE  MASTER SQUEEZE LOOP
**        MSL - MASTER SQUEEZE LOOP 
*         EVALUATE INSTRUCTIONS WITH CONSTANT OPERANDS OR REDUCE TO 
*         SIMPLER INSTRUCTION BY AN ALGEBRAIC IDENTITY, IF ONE OF THE 
*         OPERANDS IS CONSTANT. ALSO ATTEMPT TO ELIMINATE ANY 
*         REDUNDANT INSTRUCTIONS. 
  
  
 MSL1     SA5    A4+B2       R1 = DI + 2   */ ADVANCE TO NEXT INSTRUCTIO
          SA4    A5+B2       DI = R1 + 2
          MX1    D.TYL
          LX4    58-D.TYP 
          BX6    X1*X4
          LX4    D.TYP+2
          UX7    "OC",X5
          NZ     X6,MSL3     IF TYPE[DI] " I
  
*         TYPE I - REPLACE OPERAND R-NUMBERS WITH EQUIVALENTS FROM RND. 
  
          LX7    -R1.RKP
          BX6    -X0*X7 
          SA2    "RN"+X6     (X2) = RK = RND(RK)
          LX7    R1.RKP-R1.RJP
          SA1    "RN"+X7     (X1) = RJ = RND(RJ)
          LX4    59-D.CMP 
          BX5    -X0*X5 
          PL     X4,MSL2     IF ^CM[DI] 
          SB4    X1 
          SB5    X2 
          GE     B4,B5,MSL2  IF RJ \ RK    */ CANONICAL ORDER 
          SA1    A2+
          SA2    "RN"+X7     SWAP( RJ , RK )
  
 MSL2     BX3    -X0*X1 
          LX4    1+D.CMP
          PX5    "OC",X5
          BX6    -X0*X2 
          LX3    R1.RJP 
          BX5    X3+X5
          LX6    R1.RKP 
          IX7    X5+X6
          BX5    X5+X6
          BX6    X1*X2
          SA7    A5          [R1] = TYI(OC RJ,RK,RI)
          LX6    59-RN.CP 
          PL     X6,MSL3     IF ^(C[RJ] & C[RK])
  
*         TYPE I AND CONSTANT OPERANDS, JUMP TO SPECIAL PROCESSOR TO
*         EVALUATE THE VALUE OF THIS INSTRUCTION. 
  
          SA3    SBB.JT+"OC"
          BX6    -X0*X5 
          SB6    X6          (B6) = RI
          SB5    X3+
          JP     B5 
 MSL      SPACE  2,10 
**        JUMP TO INSTRUCTION PROCESSORS WITH - 
*         (A5) = R1 = ADDRESS OF R1 WORD  , (X5) = [R1] 
*         (A4) = DI, ADDRESS OF DESCRIPTOR , (X4) = [DI]
*         (B6) = RI = RI[R1]
*         FOR TYPE I INSTRUCTIONS, (X1/X2) = RND(RJ)/RND(RK)
  
 MSL3     BX6    -X0*X5 
          SB6    X6          (B6) = RI
          JP     SBB.JT+"OC" JUMP( SBB.JT(OC[R1]) ) 
 EOQ      SPACE  3,14 
*         EOQ - END OF SEQUENCE 
*         MAKE FURTHER PASS"S OVER THE INSTRUCTIONS TO ELIMINATE
*         THE USELESS DEFINITIONS AND COMPRESS OUT THE DEAD INSTRUCTIONS. 
  
          PROCESS EOQ 
          RJ     EDD         BACKWARDS SCAN TO TRANSFER USES
*                            AND ELIMINATE USELESS DEFINITIONS
          RJ     UCT         UPDATE CVT/CUT 
          TRACE  EDD,RLIST
  
          RJ     EDI         COMPRESS SEQUENCE
  
          SA2    BIAS 
          SA0    B5+
          CALL   RNI#        RENUMBER THE INSTRUCTIONS
          SX6    0
          SA6    L.RND       L.RND = 0
          TRACE  SQZ.X,RLIST
  
          RJ     IXI         INSERT EXTRA INSTRUCTIONS
          EQ     SBB
 MSL      SPACE  3,14 
**        EPROC - DEFINE ADDRESSES FOR NAMES OF EVALUATE
*                   CONSTANT PROCESSORS 
* 
*         EPROC  (A,B,C,...,Z)
  
          PURGMAC EPROC 
 EPROC    MACRO  P
          IRP    P
          NOREF  )P 
 )P       BSS    0
          IRP 
 EPROC    ENDM
  
 SXT      TITLE  MASTER SQUEEZE LOOP - TYPE I INSTRUCTIONS
**        SPECIAL PROCESSING OF TYPE I INSTRUCTIONS 
  
          PROCESS SXT        CONSTANT SHIFT PREDECESSOR 
          EPROC  SXT
          SA3    A4+4        DIS = DI + 4 
          LX3    59-D.KSP 
          PL     X3,AUC.RJ   IF ^KS[DIS]   */ NEXT IS NOT A CON SHIFT 
          LX1    59-RN.CP 
          PL     X1,SXT0     IF ^C[RJ]
  
*         CONSTANT OPERAND, EVALUATE SXT, SHIFT COMBINATION 
  
          LX1    1+RN.CP-RN.TPP 
          SA3    X1          R1J = TP[RJ] 
          RJ     DCV         VAL = DCV(R1J) 
          SA2    A4+B2       R1S = DI + 2 
          SA3    A2+B1       R2S = R1S + 1
          UX2    B3,X2
          LX3    -IH.CAP
          SB3    B3-OC.KLS
          LX1    RN.TPP+59-RN.CP
          SB4    X3 
+         LX6    B4,X7
          ZR     B3,*+1      VAL[RI] = SHIFT( VAL[RJ] , CA[R2S] ) 
          AX6    B4,X7
          MX7    0
          SA7    A4          [DI] = 0      */ KILL THE *SXT*
          SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2   */ ADVANCE TO NEXT INSTRUCTION 
          BX3    -X0*X5 
          SB6    X3 
          EQ     CCV
  
 SXT0     SA2    SXTC 
          ZR     X2,SXT4     IF SXTC = 0   */ FIRST *SXT* 
          LX1    1+RN.CP-RN.TPP 
          SB5    X1          DEFA = TP[RJ]
          BX5    X0*X5       KEY = TYI(OC,RJ,0,0) 
          SA3    A4+B2
          UX7    B4,X3
          SA3    A3+B1
          LX3    -IH.CAP
          BX6    -X0*X3 
          PX4    B4,X6       OC.CA = TY1(OC[R1+4],0,0,CA[R1+5]) 
          EQ     SXT2 
  
*         SEARCH THE SXT CHAIN FOR A PREVIOUS OCCURRENCE WITH THE 
*         SAME SHIFT FOLLOWING
  
 SXT1     SA2    X2          SXTC = [SXTC]
          SB4    X2 
          LE     B4,B5,SXT3  IF SXTC @ DEFA 
 SXT2     SA3    X2-3        R1C = [SXTC-3] 
          BX6    X0*X3
          IX7    X5-X6
          NZ     X7,SXT1     IF KEY " TYI(OC,RJ,0,0)(SXTC)
          SA3    A3+5 
          LX3    -IH.CAP
          BX7    -X0*X3 
          SA3    A3-B1
          UX6    B4,X3
          PX6    B4,X7
          IX7    X6-X4
          NZ     X7,SXT1     IF OC.CA " OC.CA(SXTC+4) 
  
*         MARK THE *SXT* AND THE FOLLOWING CON SHIFT AS REDUNDANT 
*         NOTE - CON SHIFTS MAY NOT PRECEDE A STORE / REGISTER STORE. 
  
          SA7    A4          [DI] = 0 
          BX2    -X0*X3      RIP = RI[R1C]   */ RI OF FIRST SHIFT 
          SA5    A4+B2       R1 = DI + 2   */ ADVANCE TO NEXT INST
          SA7    A5+B2       [R1+2] = 0    */ MARK SHIFT DEAD 
          BX4    -X0*X5 
          SA3    "RN"+X2
          BX7    X3 
          SA7    "RN"+X4     RND(RI) = RND(RIP) 
          SA4    A5+B2       DI = R1 + 2
          EQ     MSL1 
  
*         ADD THE *SXT* TO THE CHAIN
  
 SXT3     SA2    SXTC 
          BX7    X2 
          SA7    A4+B1       [DI+1] = SXTC
 SXT4     SX6    A4+B1
          SA6    A2          SXTC = DI + 1
*         EQ     AUC.RJ 
 AUC.RJ   SPACE  3
**        AUC.RJ - ADVANCE USES COUNT FOR R-NUMBER IN *RJ* FIELD
  
          PROCESS DAR 
 AUC.RJ   LX5    -R1.RJP
          SX2    B1 
          BX3    -X0*X5 
          SA1    "RN"+X3
          LX2    RN.USESP 
          IX6    X2+X1       USES[RJ] = USES[RJ] + 1
          SA6    A1+
          EQ     MSL1 
 KLS      SPACE  2,14 
          PROCESS (KLS,KRS)  NON REDUNDANT CON SHIFT
          SA2    A5+B1       R2 = R1 + 1
          LX2    -IH.CAP
          SB4    X2          CS = CA[R2]
          SB5    "OC"-OC.KLS
          ZR     B4,KLS1     IF CS = 0
          NZ     B5,KLS2     IF OC " KLS
          SB5    B4-60
          NZ     B5,KLS2     IF OC " 60 
  
 KLS1     MX6    0
          SA6    A4-4        DI[SXT] = 0   */ KILL SXT INSTR. 
          SA2    A6-B2       R1S = DI[SXT] - 2
          LX2    -R1.RJP
          BX6    -X0*X2      RJS = RJ[R1S]
          SA1    "RN"+X6     (X1) = RND(RJS)
          SX7    B1 
          LX7    RN.USESP 
          IX7    X1-X7
          SA7    A1          DECREMENT USES COUNT ON SHIFT PRED.
          BX1    X7 
          LX6    R1.RJP 
          EQ     XMT0        GO TO GENERATE  (XMT RI,RJS )
  
 KLS2     LX2    IH.CAP-IH.RFP
          SX3    B1 
          SA1    "RN"+X2     RF = RND(RF) 
          LX3    RN.USESP 
          IX6    X3+X1       USES[RF] = USES[RF] + 1
          SA6    A1 
          EQ     MSL1 
 XMT      SPACE  3,14 
 XMT0     S"OC"  OC.XMT 
          RJ     URI         GENERATE AN *XMT*
  
          EPROC  XMT
 XMT      PROCESS XMT 
          RJ     CTI         CHECK TRANSMIT INSTRUCTION 
          BX6    X4 
          LX6    59-D.PRSP
          PL     X6,SRCH     IF ^PRS[DI]
          EQ     AUC.RJ 
 XMTC     SPACE  2
*         XMTC - UNARY COMPLEMENT 
  
          EPROC  XMTC 
 XMTC     PROCESS XMTC
          BX6    X1 
          LX6    59-RN.XMTCP
          PL     X6,XMTC1 
  
*         REDUCE -(-X) TO X 
  
          LX1    -RN.TPP
          SA2    X1          R1P = R1[TP[RJ]] 
          LX2    -R1.RJP
          BX6    -X0*X2 
          SA1    "RN"+X6
          LX6    R1.RJP 
          EQ     XMT0 
  
 XMTC1    BX6    X1 
          LX6    59-RN.CP 
          PL     X6,XMTC2    IF ^C[RI]
  
          LX1    -RN.TPP
          SA3    X1 
          RJ     DCV
          BX6    -X7         VAL = -DCV(TP[RI]) 
          LX1    RN.TPP 
          SB4    OC.FMA 
          EQ     B5,B4,XMTC2 IF OC = OC.FMA  */ NO REDUCTION
          SB4    OC.LDC 
          NE     B5,B4,CCV   IF OC " OC.LDC 
          BX7    X4 
          LX7    59-D.PSP 
          PL     X7,CCV      IF ^PS[DI] 
  
 XMTC2    SA2    "RN"+B6
          SX6    B1 
          LX6    RN.XMTCP 
          BX7    X6+X2       XMTC[RI] = 1 
          LX6    RN.CP-RN.XMTCP 
          BX1    X6*X1
          BX7    X7+X1       C[RI] = C[RJ]
          SA7    A2 
          EQ     SRCH 
 AND      EJECT 
          PROCESS AND 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,ZERO     IF Z[RJ] ! Z[RK] 
          IX7    X1-X2
          ZR     X7,C.XMT    IF RJ = RK 
          LX6    RN.ZP-RN.XMTCP 
          PL     X6,SRCH     IF ^XMTC[RJ] & ^XMTC[RK] 
          S"OC"  OC.STR 
          SB5    R1.RJP 
          EQ     CAO
 DFM      SPACE  3,14 
*         MULTIPLY INSTRUCTION PROCESSING 
  
          PROCESS IM
          BX6    X4 
          LX6    59-D.USIP
          PL     X6,DFM      IF ^USI[DI]
          SX6    1
          SA6    IXF         IXF = 1       */ SET FOR *IXI* SCAN
  
 DFM      PROCESS (DFM,FM,RFM)
          BX6    X1+X2
          LX6    59-RN.CP 
          PL     X6,SRCH     IF ^( C[RJ] ! C[RK] )
          BX7    X1 
          LX7    59-RN.CP 
          MI     X7,DFM1     IF C[RJ] 
          BX1    X2 
          LX7    1+RN.CP
          BX2    X7 
  
 DFM1     LX1    -RN.TPP
          SA3    X1 
          RJ     DCV         VAL = VAL[RJ/RK] 
          ZR     X7,ZERO     IF VAL = 0 
          SB4    "OC"-OC.IM 
          NZ     B4,FM1      IF OC " IM 
          SX3    B1 
          IX3    X7+X3
          MI     X3,SRCH     IF VAL < -1
          AX3    2
          SB4    X7 
          NZ     X3,SRCH     IF VAL > 2 
          SA1    "RN"+X2
          BX6    -X0*X2 
          LX6    R1.RJP 
          S"OC"  OC.IA
          EQ     B4,B2,DFM3  IF VAL = 2 
          EQ     B4,B1,XMT0  IF VAL = 1 
  
*         VAL = -1
  
 DFM2     S"OC"  OC.XMTC
          RJ     URI         URI(  XMTC  RI,RJ )
          EQ     XMTC 
  
  
*         CONVERT 2*X TO X+X
  
 DFM4     SB4    "OC"-OC.FM 
          S"OC"  OC.FA
          ZR     B4,DFM3     OC = IF( OC = OC.FM ) THEN OC.FA 
          S"OC"  OC.RFA                            ELSE OC.RFA
  
 DFM3     BX7    X6 
          LX7    R1.RKP-R1.RJP
          IX6    X6+X7
          RJ     URI
          EQ     SRCH 
  
*         CHECK FLOATING MULTIPLY FOR POSSIBLE REDUCTION
  
 FM1      SB4    "OC"-OC.DFM
          NZ     B4,FM2      IF OC " OC.DFM 
          LX7    13 
          AX7    13 
          ZR     X7,ZERO     IF DFM OF 2.**N  ( =0 )
          EQ     SRCH 
  
 FM2      BX6    X7 
          AX6    48 
          ZR     X6,ZERO     IF EXP[VAL] = 0
  
          SX6    2./1S45
          LX6    45 
          IX3    X7-X6
          BX6    -X0*X2 
          LX6    R1.RJP            */ SETUP X6 INCASE JUMP TO DFM4
          ZR     X3,DFM4     IF VAL = 2.0 
  
  
 FM3      SX6    1./1S45
          LX6    45 
          IX3    X7-X6
          IX7    X7+X6
          SA1    "RN"+X2
          BX6   -X0*X2
          LX6    R1.RJP 
          ZR     X3,XMT0     IF VAL = 1.0 
          NZ     X7,SRCH     IF VAL " -1.0
          EQ     DFM2 
  
          PROCESS (FD,RFD)
          LX1    59-RN.ZP 
          MI     X1,ZERO     IF Z[RJ] 
          LX1    RN.ZP-RN.PZP 
          MI     X1,ZERO     IF PZ[RJ]
          BX7    X2 
          LX7    59-RN.CP 
          PL     X7,SRCH     IF ^C[RK]
          LX7    1+RN.CP-RN.TPP 
          SA3    X7 
          RJ     DCV
          SA2    A1          (X2) = ^CONSTANT OPERAND 
          EQ     FM3         GO CHECK FOR X/1. , X/-1.
  
          PROCESS OR
          IX7    X1-X2
          ZR     X7,C.XMT    IF RJ = RK 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,C.XMT    IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          PL     X6,SRCH     IF ^(XMTC[RJ] ! XMTC[RK])
          S"OC"  OC.IMP 
          SB5    R1.RJP 
          EQ     CAO
  
          PROCESS XOR 
          BX6    X1-X2
          ZR     X6,ZERO     IF RND(RJ) = RND(RK) 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,C.XMT    IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          PL     X6,SRCH     IF ^(XMTC[RJ] ! XMTC[RK])
          S"OC"  OC.EQV 
          SB5    R1.RJP 
          EQ     CAO
 IADD     SPACE  2
          PROCESS IA
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,C.XMT    IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          MI     X6,FA1      IF XMTC[RJ] ! XMTC[RK] 
  
          BX7    X4 
          LX7    59-D.USIP
          MI     X7,IA1      IF USI[DI]    */ USI OR REDUCED IAZ/ISZ
          LX1    -RN.TPP
          SA3    X1          R1J = TP[RJ] 
          SB5    OC.IS
          UX7    B4,X3
          LX1    RN.TPP 
          NE     B4,B5,IA1   IF OC[R1J] " OC.IS 
  
          BX7    X5-X3
          LX7    -R1.RKP
          BX7    -X0*X7 
          LX3    -R1.RJP     RJX = RJ[R1J]
          NZ     X7,IA1      IF RK[R1] " RK[R1J]  */ NOT (J-K)+K
  
          BX7    X1 
          LX7    59-RN.INCP 
          PL     X7,I.XMT    IF ^INC[R1J] 
          SX7    A3 
          SB5    X3 
          SA3    JPXA 
          IX7    X7-X3
          SX3    B5 
          PL     X7,I.XMT    IF R1J > JPXA */ IN THE SAME BLOCK 
  
 IA1      LX6    RN.XMTCP-RN.CP 
          PL     X6,SRCH     IF ^( C(RJ] ! C[RK] )
          EQ     CIA
 IAZ      SPACE  3,14 
*         IAZ - ADD ZERO TO OPERAND PRIOR TO USE IN A CONDITIONAL JUMP
  
          PROCESS IAZ 
          MX7    2
          BX6    X1+X2       RJK = RJ ! RK
          BX3    X6 
          LX3    59-RN.ZP 
          PL     X3,SRCH     IF _Z[RJK]  */ IAZ INVENTED AT CIA4
          LX6    58-RN.IACIP
          BX7    X7*X6
          NZ     X7,IAZ1     IF IAC[RJK] ! INC[RJK] 
          LX6    1+RN.IACIP-RN.XMTCP
          PL     X6,SRCH     IF ^XMTC[RJK]
          EQ     FA1
  
 IAZ1     BX6    X2          RW = RKW 
          LX6    59-RN.ZP 
          PL     X6,IAZ2     IF ^Z[RKW] 
          BX6    X1          RW = RJW 
          LX6    59-RN.ZP 
 IAZ2     LX6    1+RN.ZP-RN.TPP 
          SA3    X6+B2       DP = TP[RW] + 2
          SX7    B1 
          LX7    D.USIP 
          BX6    X7+X3       USI[DP] = 1   */ INHIBIT FURTHER REDUCTION 
          SA6    A3 
          EQ     C.XMT                     */ GO CHANGE IAZ TO AN *XMT* 
 DFA      SPACE  2,14 
          PROCESS DFA 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,ZERO     IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          MI     X6,FA1      IF XMTC[RJ] ! XMTC[RK] 
          EQ     SRCH 
  
          PROCESS (FA,RFA)
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,F.XMT    IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          BX7    X1-X2
          MI     X6,FA1      IF XMTC[RJ] ! XMTC[RK] 
          NZ     X7,SRCH     IF RJ " RK    */ NOT X+X 
          SA3    "RN"+B6
          SX6    B1 
          LX6    RN.NRP 
          BX7    X6+X3       NR[RND(RI)] = 1  */ INDICATE NORMALIZE NOT 
          SA7    A3 
          EQ     SRCH 
  
 FA1      S"OC"  "OC"+1      OC = OC + 1   */ CHANGE ADD TO A SUBTRACT
          SB5    R1.RKP 
 CAO      SPACE  3,18 
**        CAO - CHANGE COMMUTATIVE-ADDITIVE OPERATION TO APPROPRIATE
*         SUBTRACTIVE OPERATION.
* 
*         ENTRY  (B3) = NEW OPCODE
*                (B5) = RJ/RK SHIFT COUNT 
*                (X1/X2) = RND ENTRIES FOR RJ,RK
*                (X5) = R1 WORD 
*                (B6) = RI
  
 CAO      BX6    X1 
          LX5    -R1.RKP
          LX6    59-RN.XMTCP
          MI     X6,CAO1     IF XMTC[RJ]
          BX1    X2 
          LX5    R1.RKP-R1.RJP
  
 CAO1     BX5    -X0*X5 
          LX1    -RN.TPP
          SA2    X1          R1P = TP[RJ/K] 
          LX2    -R1.RJP
          BX1    -X0*X2      NEW R NUM
          LX7    B5,X1
          SB5    B5-3*R1.RIL
          AX5    B5,X5
          BX6    X5+X7
  
 CAO2     SX3    B1 
          LX3    D.USIP 
          BX7    X3*X4
          LX7    -D.USIP
          SB4    X7          U = USI[DI]
          RJ     URI         UPDATE INSTRUCTION 
          SX7    B4 
          LX7    D.USIP 
          BX7    X7+X4       USI[DI] = USI[DI] ! U
          SA7    A4 
          BX4    X7 
          LX6    -R1.RJP
          BX7    -X0*X6 
          SA1    "RN"+X7     (X1) = RND(RJ) 
          LX6    R1.RJP-R1.RKP
          BX7    -X0*X6 
          SA2    "RN"+X7     (X2) = RND(RK) 
          LX4    59-D.CMP 
          PL     X4,CAO3     IF ^CM[DI] 
          SA4    A5-B2       DI = R1 - 2
          EQ     MSL1        */ ADJUST RJ,RK BEFORE PROCESSING
  
 CAO3     LX4    1+D.CMP
          JP     SBB.JT+"OC" JUMP( OC )    */ PROCESS NEW INSTRUCTION 
 I.XMT    SPACE  3
**        I.XMT - CHANGE IA/IS COMBINATION TO AN *XMT/XMTC* 
* 
*         ENTRY  (X3) = RJX , *RJ* OF *XMT/XMTC*
  
 I.XMTC   S"OC"  OC.XMTC     OC = OC.XMTC 
          EQ     I.XMT1 
  
 I.XMT    S"OC"  OC.XMT      OC = OC.XMT
 I.XMT1   BX6    -X0*X3 
          SA1    "RN"+X6     (X1) = RND(RJX)
          LX6    R1.RJP 
          RJ     URI         URI(  OC  RI,RJX ) 
          JP     SBB.JT+"OC" JUMP(SBB.JT(OC)) 
 STR      TITLE  MASTER SQUEEZE LOOP - TYPE I SUBTRACTIVE INSTRUCTIONS
          PROCESS STR        NAND  ( ^RJ & RK ) 
          BX6    X1-X2
          LX2    59-RN.ZP 
          MI     X2,ZERO     IF Z[RK] 
          ZR     X6,ZERO     IF RJ = RK 
          LX1    59-RN.ZP 
          MI     X1,C.XMT    IF Z[RJ] 
          S"OC"  OC.AND 
          EQ     EQV1 
 IMP      SPACE  3
          PROCESS IMP        NOR  ( ^RJ ! RK )
          BX6    X1-X2
          ZR     X6,FMA60    IF RJ = RK 
          LX1    59-RN.ZP 
          MI     X1,FMA60    IF Z[RJ] 
          LX2    59-RN.ZP 
          MI     X2,C.XMTC   IF Z[RK] 
          S"OC"  OC.OR
          EQ     EQV1 
 EQV      SPACE  3
          PROCESS EQV        NXOR  ( ^RJ XOR RK ) 
          IX7    X1-X2
          ZR     X7,FMA60    IF RJ = RK 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,C.XMTC   IF Z[RJ] ! Z[RK] 
          LX1    59-RN.ZP 
          LX2    59-RN.ZP 
          S"OC"  OC.XOR 
  
*         CHANGE TO OPERATION NOT INVOLVING THE COMPLEMENT
  
 EQV1     LX1    RN.ZP-RN.XMTCP 
          PL     X1,SRCH     IF ^XMTC[RJ] 
          LX1    1+RN.XMTCP-RN.TPP
          SA3    X1          R1P = TP[RJ] 
          LX5    -R1.RKP
          BX5    -X0*X5      RK 
          LX3    -R1.RJP
          BX6    -X0*X3      RJ = RJ[R1P] 
          EQ     SUB1 
 SUBTRACT SPACE  3,8
          PROCESS DFS 
          BX6    X1+X2
          LX6    59-RN.ZP 
          IX7    X1-X2
          MI     X6,ZERO     IF Z[RJ] ! Z[RK] 
          NZ     X7,SUB      IF RJ " RK 
          EQ     ZERO 
  
  
          PROCESS (FS,RFS)
          IX6    X1-X2
          ZR     X6,ZERO     IF RJ = RK 
          LX2    59-RN.ZP 
          MI     X2,F.XMT    IF Z[RK] 
          LX1    59-RN.ZP 
          MI     X1,F.XMTC   IF Z[RJ] 
          LX2    1+RN.ZP
          EQ     SUB
  
          PROCESS IS
          BX6    X1-X2
          SB4    X6 
          ZR     B4,ZERO     IF RN[RJ] = RN[RK] 
          LX2    59-RN.ZP 
          MI     X2,C.XMT    IF Z[RK] 
          LX1    59-RN.ZP 
          MI     X1,C.XMTC   IF Z[RJ] 
          LX1    1+RN.ZP
          LX2    1+RN.ZP
  
*         CHECK FOR AND REDUCE COMBINATIONS OF THE FORM (J+K)-K , ETC.
  
          BX7    X4 
          LX7    59-D.USIP
          MI     X7,IS4      IF USI[DI]    */ USI OR REDUCED IAZ/ISZ
          LX1    -RN.TPP
          SA3    X1          R1J = TP[RJ]  */ CHECK J OPERAND 
          SB5    OC.IA
          UX7    B4,X3
          LX1    RN.TPP 
          NE     B4,B5,IS1   IF OC[R1J] " OC.IA 
  
          LX3    -R1.RJP
          BX7    X2-X3
          LX3    R1.RJP-R1.RKP     RJX = RK[R1J]
          BX7    -X0*X7 
          ZR     X7,IS1A     IF RJ[R1J] = RK  */ REDUCE (J+K)-J TO K
          BX7    X2-X3
          BX7    -X0*X7 
          NZ     X7,IS4      IF RK[R1J] " RK */ NOT (K+J)-K 
          LX3    R1.RKP-R1.RJP     RJX = RJ[R1J]
  
 IS1A     BX6    X1          RJW = RND(RJ)
          EQ     IS3A 
  
 IS1      NE     B4,B3,IS2   IF OC[R1J] " OC.IS 
          LX3    -R1.RJP
          BX7    X2-X3
          BX7    -X0*X7 
          NZ     X7,IS4      IF RJ[R1J] " RK  */ NOT (J-K)-J
          LX3    R1.RJP-R1.RKP     RJX = RK[R1P]
          EQ     I.XMTC 
  
 IS2      LX2    -RN.TPP
          SA3    X2          R1K = TP[RK]  */ CHECK K OPERAND 
          LX2    RN.TPP 
          UX7    B4,X3
          NE     B4,B5,IS3   IF OC[R1K] " OC.IA 
          LX3    -R1.RJP
          BX7    X1-X3
          LX3    R1.RJP-R1.RKP     RJX = RK[R1K]
          BX7    -X0*X7 
          ZR     X7,I.XMTC   IF RJ[R1K] = RJ  */ REDUCE J-(J+K) TO -K 
          BX7    X1-X3
          BX7    -X0*X7 
          NZ     X7,IS4      IF RK[R1K] " RJ  */ NOT J-(K+J)
          LX3    R1.RKP-R1.RJP     RJX = RJ[R1K]
          EQ     I.XMTC 
  
 IS3      NE     B4,B3,IS4   IF OC[R1K] " OC.IS 
          BX7    X3-X5
          LX7    -R1.RJP
          BX7    -X0*X7 
          NZ     X7,IS4      IF RJ[R1K] " RJ */ NOT J-(J-K) 
          LX3    -R1.RKP     RJX = RK[R1K]
          BX6    X2 
  
 IS3A     LX6    59-RN.INCP 
          PL     X6,I.XMT    IF ^INC[RJW] 
          SX7    A3 
          SB5    X3 
          SA3    JPXA 
          IX6    X7-X3
          SX3    B5 
          PL     X6,I.XMT    IF R1P > JPXA */ IN THE SAME BLOCK 
          EQ     IS4
          EQ     I.XMT
  
 IS4      BX6    X2 
          LX6    59-RN.CP 
          MI     X6,CIA      IF C[RK] 
          BX6    X1+X2
          LX6    59-RN.INCP 
          PL     X6,SUB      IF ^( INC[RJ] ! INC[RK] )
  
*         I = I + 1  $  IF( I .RO. N ) , MARK *IS* AS *INC* 
  
          SA3    "RN"+B6
          SX7    B1 
          LX7    RN.INCP
          BX6    X7+X3       INC[RI] = 1
          SA6    A3 
  
 SUB      LX2    59-RN.XMTCP
          PL     X2,SRCH     IF ^XMTC[RK] 
          LX2    1+RN.XMTCP-RN.TPP
          SA3    X2          R1P = TP[RK] 
          S"OC"  "OC"-B1     CHANGE SUBTRACT TO AN ADD
          LX5    -R1.RJP
          BX6    -X0*X5      RJ 
          LX3    -R1.RJP
          BX5    -X0*X3      RK = RJ[R1P] 
  
 SUB1     IX7    X6-X5
          PL     X7,SUB2     IF RJ \ RK 
          SX7    X5 
          BX5    X6 
          LX6    X7 
  
 SUB2     LX6    R1.RJP 
          LX5    R1.RKP 
          BX6    X5+X6
          EQ     CAO2        GO UPDATE AND PROCESS CHANGED INSTRUCTION
 ISZ      SPACE  2,14 
*         ISZ - ADD 0 AND CHANGE SIGN PRIOR TO USE IN CONDITIONAL JUMP
*         THE RJ OPERAND SHOULD BE A  *CLR  RJ,0* 
  
          PROCESS ISZ 
  
*         SEE IF THE PRED ( *RK* ) IS AN *IS*, AND IF SO ELIMINATE THE
*         *ISZ* BY REVERSING THE OPERANDS.
  
          LX2    -RN.TPP
          SA3    X2          R1P = TP[RK] 
          S"OC"  OC.IS
          UX6    B4,X3
          NE     B4,"OC",SRCH      IF OC[R1P] " OC.IS 
          LX1    59-RN.ZP 
          PL     X1,SRCH     IF ^ Z[RJ] 
          LX6    -R1.RJP
          BX7    -X0*X6      J = RJ[R1P]
          SA1    "RN"+X7     RJW = RND(J) 
          LX2    59-RN.IACP+RN.TPP
          MI     X2,ISZ1     IF IAC[RK] 
          MX2    2
          LX1    58-RN.IACIP
          BX2    X2*X1
          ZR     X2,SRCH     IF ^( IAC[RJW] ! INC[RJW] )
  
 ISZ1     LX3    -R1.RKP
          BX3    -X0*X3 
          LX7    R1.RKP 
          LX3    R1.RJP 
          BX6    X3+X7
          RJ     URI         URI(  IS  RI,RK[R1P],RJ[R1P] ) 
          SX3    B1 
          LX3    D.USIP 
          BX6    X3+X4       USI[DI] = 1   */ INHIBIT FURTHER REDUCTION 
          SA6    A4 
          BX4    X3+X4
          EQ     SRCH 
 CIA      EJECT 
**        CIA - CHECK IA/IS INSTRUCTION WITH A CONSTANT OPERAND 
*         SET *IAC* BIT IF NOT AN INCREMENT ( I = I +-CON ) 
  
 RN.CP    EQU    58 
 CIA      BX7    X4 
          LX7    59-D.INCP
          MI     X7,CIA2A    IF INC[DI] 
  
          BX7    X2          RCW = RK;  RVW = RJ
          LX3    B1,X1
          PL     X3,CIA1     IF ^C[RJ]
          BX7    X1          RCW = RJ 
          BX1    X2          RVW = RK 
  
 CIA1     LX7    -RN.TPP
          SA3    X7          R1P = TP[RCW]
          UX6    B4,X3
          LX3    -R1.INP
          SB4    B4-OC.FMA
          SX6    X3-60
          NZ     B4,CIA2     IF OC[R1P] " OC.FMA
          PL     X6,CIA4     IF IN[R1P] \ 60  */ A -0 
  
*         CONSTANT OPERAND NOT -0, AND CANT BE A *CLR*, SET IAC/INC BIT 
  
 CIA2     SA3    A4+B2       R1S = DI + 2  */ NEXT INSTRUCTION
          SB4    RN.IACP     BIT = IAC
          BX6    X5-X3
          BX6    -X0*X6 
          NZ     X6,CIA3     IF RI[R1S] " RI[R1]
          UX6    B3,X3
          SB5    OC.ST
          NE     B3,B5,CIA3  IF OC[R1S] " OC.ST  */  NOT ST RI, 
  
          SA3    A3+B1       R2S = R1S + 1
          LX1    -RN.TPP
          SA2    X1+B1       R2P = TP[RVW] + 1
          BX6    X2-X3
          NZ     X6,CIA3     IF [R2P] " [R2S]  */ NOT I = I + CON 
          SA2    A2-B1       R1P = R2P - 1
          UX6    B3,X2
          SB5    OC.SA
          EQ     B3,B5,CIA5  IF OC[R1P] = OC.SA 
  
 CIA2A    SB4    RN.INCP     BIT = INC
  
 CIA3     SA3    "RN"+B6
          SX6    B1 
          LX7    B4,X6
          BX6    X7+X3       BIT[RND(RI)] = 1 
          SA6    A3 
          EQ     SRCH 
  
*         CON IS -0, CHANGE TO IAZ/ISZ SO *GPO* DOESNT THINK ITS AN *INC
  
 CIA4     BX6    X0*X5
          S"OC"  "OC"-OC.IA+OC.IAZ
          RJ     URI         CHANGE INSTRUCTION 
          EQ     SRCH 
  
*         DEF/SA/INC/ST VAR SEQUENCE, CHANGE THE *INC* TO A *STT*.
  
 CIA5     SA3    X7          R1C = TP[RCW]
          RJ     DCV         C = DCV( R1C ) 
          BX6    X4 
          LX6    59-D.CMP 
          AX6    59 
          BX7    -X6-X7      C = XOR( C , ^CM[DI] ) 
          MX6    -IH.CAL
          BX7    -X6*X7 
          LX2    -R1.RJP
          BX6    -X0*X2      RF = RJ[R1P] 
          LX7    IH.CAP 
          LX6    IH.RFP 
          BX7    X6+X7
          SA7    A5+B1       [R1+1] = IHW(RF,C,0) 
          S"OC"  OC.STT 
          MX6    0
          RJ     URI         URI( STT  RI,RF,C )
          EQ     .STT 
 PK/UP    TITLE  MASTER SQUEEZE LOOP - PACK/UNPACK
          PROCESS PK
          LX1    59-RN.ZP 
          PL     X1,IRCH     IF ^Z[RJ]     */ DONT OVERSQZ RJ USES
          LX0    R1.RJP 
          BX6    X0*X5
          BX5    X0*X5       RJ[R1] = 0    */ INCASE RJ " 0 
          SA6    A5 
          LX0    -R1.RJP
          LX2    59-RN.ZP 
          PL     X2,SRCH     IF ^Z[RK]     */ NOT A PACKED  ZERO
  
          SX7    B1 
          SA3    "RN"+B6
          LX7    RN.PZP 
          BX6    X7+X3
          SA6    A3          PZ[RI] = 1 
          EQ     SRCH 
 NR       SPACE  3
          PROCESS (NR,RNZ)
          BX3    X2 
          LX3    59-RN.CP 
          PL     X3,NR0      IF ^C[RND(RK)] 
          SB4    X1 
          LE     B4,B1,ECO.NR      IF RJ @ 1
          EQ     ECO4 
  
 NR0      LX1    59-RN.ZP 
          PL     X1,NR1      IF ^Z[RJ]
          LX3    RN.CP-RN.PZP 
          MI     X3,ZERO     IF PZ[RK]
          LX3    RN.PZP-RN.NRP
          SX6    B1 
          MI     X3,SRCH4    IF NR[RK]
          SA3    "RN"+B6
          LX6    RN.NRP 
          BX7    X6+X3       NR[RI] = 1 
          SA7    A3 
          EQ     SRCH 
  
 NR1      SB4    X1 
          NE     B4,B1,UP4   IF RJ " 1     */ NOT *PNR* 
  
          LX2    -RN.TPP
          SA2    X2          R1P = TP[RK] 
          UX7    B4,X2
          NE     B4,"OC",SRCH      IF OC[R1P] " OC[R1]
          LX7    -R1.RJP
          BX6    -X0*X7 
          SX3    B1 
          SB4    X6 
          GT     B4,B1,UP4   IF RJ[R1P] > 1 
  
          LX3    R1.RJP 
          BX6    X2+X3       RJ[R1P] = 1
          SA6    A2 
          BX2    X2+X3
          EQ     SRCH4             */ GO ELIMINITE THE INSTRUCTION
 UP       SPACE  3
          PROCESS UP
          BX3    X2 
          LX3    59-RN.CP 
          MI     X3,ECO4     IF C[RK] 
          LX2    -RN.TPP
          SB4    B2+B2
          SA3    X2+B4       R1S = TP[RK] + 4 
          SB5    A5 
          SA2    UPA
          BX5    X2*X5       KEY = TYI(UP,0,RK,0) 
  
 UP1      BX6    X2*X3
          SA3    A3+B4       R1S = R1S + 4
          IX7    X5-X6
          NZ     X7,UP1      IF [R1S-4] " KEY 
          SA5    A5 
          SB3    A3-B4
          GE     B3,B5,UP4   IF R1S \ R1   */ INSTRUCTION NOT REDUNDANT 
  
          SA3    A3-B4
          LX1    59-RN.ZP 
          MI     X1,UP2      IF Z[RJ]      */ BI,B0 CASE
          LX3    -R1.RJP
          BX2    -X0*X3 
          ZR     X2,UP4      IF Z[RJ[R1S]]  */ CANNOT HANDLE B0,BI CASE 
  
          MX6    60 
          SA6    A4+4        [DI+4] = -0   */ MARK FOLLOWING *RS* AS DEA
          SA2    "RN"+X2
          BX6    X2 
          LX5    -R1.RJP
          BX2    -X0*X5 
          SA6    "RN"+X2     RND(RJ[R1]) = RND(RJ[R1S]) 
          LX3    R1.RJP 
  
 UP2      BX2    -X0*X3 
          SA1    "RN"+X2
          BX6    X1          RND(RI[R1]) = RND(RI[R1S]) 
          SA3    A3+B2       DJ = R1S + 2 
          SA6    "RN"+B6
          BX6    X3+X4       DJ = DJ ! DI 
          SA7    A4          [DI] = 0 
          SA6    A3 
          EQ     MSL1 
  
 UP4      LX5    R1.RJP-R1.RKP
          EQ     AUC.RJ 
  
 UPA      VFD    12/-0,16/0,16/-0,16/0
 ILS      SPACE  3
 TEMP     IFNE   0,0
          PROCESS (ILS,IRS) 
          BX6    X1+X2
          SB3    B3-OC.ILS
          LX6    59-RN.CP 
          PL     X6,SRCH     IF ^( C[RJ] ! C[RK] )
          LX2    59-RN.ZP 
          MI     X2,ZERO     IF Z[RK] 
          LX1    59-RN.ZP 
          PL     X1,SRCH     IF ^Z[RJ]
          BX1    X2 
          S"OC"  OC.XMT 
          EQ     C.XMT2      GO OUTPUT XMT( RI , RK ) 
 TEMP     ELSE
 IRCH     SPACE  4,8
*         THIS TEMPORARY CODE IS NECESSARY UNTIL MCG/JAM IS ABLE TO 
*         CODE SEQUENCES CONTAINING B-REGISTER JAMS.  THIS ILS/IRS
*         PROCESSOR USES A SPECIAL SEARCH/SQUEEZE LOOP (IRCH) THAT
*         SUPPRESSES ELIMINATION OF B-REG TRANSMITS (SHORT ADDS) PRE- 
*         CEDING INDEXED SHIFTS.  ONLY S, SA, OR STT PREDECESSORS ARE 
*         CORRECTLY HANDLED AND THEY MUST DIRECTLY PRECEDE THE SHIFT IN 
*         THE SEQUENCE ALONG WITH THE RS. 
  
          PROCESS (ILS,IRS) 
          LX2    59-RN.ZP 
          MI     X2,ZERO     IF Z[RK] 
          LX1    59-RN.ZP 
          PL     X1,IRCH     IF ^Z[RJ]
          BX1    X2 
          S"OC"  OC.XMT 
          EQ     C.XMT2      GO OUTPUT XMT( RI , RK ) 
          SPACE  4,8
 IRCH     BX6    X0*X5       KEY = TYI(OC,RJ,RK,0)
          LX5    -R1.RKP
          BX3    -X0*X5 
          SB4    B2+B2       (B4) = 4 
          LX5    R1.RKP-R1.RJP
          SA2    "RN"+X3
          BX3    -X0*X5 
          LX2    -RN.TPP
          SA1    "RN"+X3
          SB5    X2 
          LX1    -RN.TPP
          SB3    X1          R1S = TP[RJ] 
          GE     B3,B5,IRCH1 IF R1S \ TP[RK]
          SB3    B5          R1S = TP[RK] 
  
 IRCH1    SA3    B3+4        R1S = R1S + 4
          SB5    A2 
  
*         SEARCH FORWARD FROM MAX OF DEF ADDRESS OF OPERANDS. 
  
 IRCH2    BX7    X0*X3
          SA3    A3+B4
          IX5    X6-X7
          NZ     X5,IRCH2    IF [R1S] " KEY 
          SA2    A3-B2
          SB3    A3-B4
          ZR     X2,IRCH2    IF [DS] = 0   */ DEAD INSTRUCTION
          SB3    A5-B3
          GT     B3,SRCH3    IF R1S < R1M  */ INSTRUCTION IS REDUNDANT
  
          SA2    A5          R1J = R1      */ SEARCH FOR J OPERAND
 IRCH2A   SA2    A2-B4       R1J = R1J - 4
          UX7    B3,X2
          SX2    B3-OC.RS 
          NZ     X2,IRCH2A   IF OC[R1J] " OC.RS 
          SB3    A2-B4       R1J = R1J - 4 */ POINT TO J OPERAND
          MX2    -RN.USESL
          LX1    RN.TPP-RN.USESP
          BX5    -X2*X1 
          ZR     X5,IRCH5    IF USES[RND(RJ)] = 0 
          SA2    B3+B2       DI = R1J + 2 ;  DIW = [DI] 
          SA3    B3          R1I = R1J ;  R1W = [R1I] 
          MX7    1
          NZ     X2,IRCH5    IF DIW .NE. 0 */ INS. NOT SQUEEZED 
          LX7    1+D.PRSP 
          UX5    B6,X3       OCI = OC[R1W]
          SA3    =XF.RDT+B6 
          BX6    X3+X7
          SA6    A2          [DI] = RDT(OCI) .OR. D.PRS 
          LX6    58-D.TYP 
          MI     X6,IRCH3    IF TY[DIW] = 3  */ STT 
          LX2    B1,X6
          MI     X2,IRCH4    IF TY[DIW] = 2  */ S 
          BX6    X5 
          LX6    -R1.RJP
          BX2    -X0*X6 
          SA3    "RN"+X2
          MX6    1
          LX6    1+RN.USESP 
          IX6    X3+X6
          SA6    A3          USES[RND(RJ[R1W])] = USES[RND(RJ[R1W])] + 1
          EQ     IRCH4
  
 IRCH3    SA3    B3+B1       R2I = R1I + 1 ;  R2W = [R2]
          LX3    -IH.RFP
          SA3    "RN"+X3
          MX6    1
          LX6    1+RN.USESP 
          IX6    X3+X6
          SA6    A3          USES[RND(RF[R2W])] = USES[RND(RF[R2W])] + 1
  
 IRCH4    SA3    =XF.RDT+OC.RS
          BX6    X3 
          SA6    A2+B4       [DI+4] = RDT(OC.RS)
          BX5    -X0*X5      RIJ = RI[R1W]
          SA2    A5 
          LX2    -R1.RJP
          BX2    X0*X2
          BX6    X2+X5
          LX6    R1.RJP 
          SA6    A2 
          SX2    X5 
          LX5    RN.RNP 
          LX7    RN.USESP-D.PRSP
          BX6    X5+X7
          SX5    B3 
          LX5    RN.TPP 
          BX6    X6+X5
          SA6    "RN"+X2     RND(RJ) = RNW(RIJ,1,R1J) 
          SA2    B5 
          IX7    X7+X2       USES[RK] = USES[RK] +1 
          SA7    A2 
          EQ     MSL1 
  
 IRCH5    LX1    RN.USESP 
          SX5    B1 
          LX5    RN.USESP 
          IX6    X5+X1       USES[RJ] = USES[RJ] + 1
          SA6    A1 
          SA2    B5 
          IX7    X5+X2       USES[RK] = USES[RK] + 1
          SA7    A2 
          EQ     MSL1 
 TEMP     ENDIF 
 SRCH     TITLE  SRCH - SEARCH FOR PREVIOUS OCCURANCE OF TYPE I INST
**        SRCH - SEARCH FOR PREVIOUS OCCURRENCE OF TYPE I INSTRUCTION.
*         ENTRY  (X5) = R1 WORD , (B6) = RI 
  
          PROCESS (CX,SS) 
 SRCH     BX6    X0*X5       KEY = TYI(OC,RJ,RK,0)  */ SEARCH KEY 
          LX5    -R1.RKP
          BX3    -X0*X5 
          SB4    B2+B2       (B4) = 4 
          LX5    R1.RKP-R1.RJP
          SA2    "RN"+X3
          BX3    -X0*X5 
          LX2    -RN.TPP
          SA1    "RN"+X3
          SB5    X2 
          LX1    -RN.TPP
          SB3    X1 
          GE     B3,B5,SRCH1 R1S = MAX( TP[RJ] , TP[RK] ) */ MIN SRCH AD
          SB3    B5+
 SRCH1    SA3    B3+4        R1S = R1S + 4
          SB5    A2 
  
*         SEARCH FORWARD FROM MAX OF DEF ADDRESS OF OPERANDS. 
  
 SRCH2    BX7    X0*X3
          SA3    A3+B4
          IX5    X6-X7
          NZ     X5,SRCH2    IF [R1S] " KEY 
          SA2    A3-B2
          SB3    A3-B4
          ZR     X2,SRCH2    IF [DS] = 0   */ DEAD INSTRUCTION
          SB3    A5-B3
          GT     B3,SRCH3    IF R1S < R1M  */ INSTRUCTION IS REDUNDANT
  
*         INSTRUCTION NOT REDUNDANT, BUMP USES OF OPERANDS
  
          LX1    RN.TPP 
          SX5    B1 
          LX5    RN.USESP 
          IX6    X5+X1       USES[RJ] = USES[RJ] + 1
          SA6    A1 
          SA2    B5 
          IX7    X5+X2       USES[RK] = USES[RK] + 1
          SA7    A2 
          EQ     MSL1 
  
*         SRCH4 - REDUNDANT INSTRUCTION FOUND, ATTEMPT TO ELIMINATE IT
*         ENTRY  (X2) = WORD WITH RJ, RIGHT JUSTIFIED 
*                (X4) = INSTRUCTION DESCRIPTOR
*                (B6) = RI OF CURRENT INSTRUCTION 
  
 SRCH3    SA1    A3-B2       DIS = R1S - 2
          SA5    A5          REFETCH R1 WORD
          SA4    A4          REFETCH DESCR
          SA2    A1-B2       RJ = RI[R1S-4] 
          BX6    X1-X4
          LX6    59-D.USIP
          PL     X6,SRCH4    IF USI[DIS] = USI[DI]
          UX6    "OC",X5
          SX6    "OC"-OC.IM 
          NZ     X6,SRCH4    IF OC[R1] " OC.IM
  
          SX6    B1 
          LX6    D.USIP 
          BX7    -X6*X1      USI[DIS] = 0  */ SAFE IF ONE IS ALWAYS EXEC
          SA7    A1 
  
  
 SRCH4    MX6    -D.STRSL 
          BX2    -X0*X2 
          LX6    D.STRSP
          SA1    "RN"+X2
          BX7    -X6*X4 
          NZ     X7,SRCH5    IF STRS[DI] " 0
          SA7    A4          [DI] = 0 
          BX6    X1 
          SA6    "RN"+B6     RND(RI) = RND(RJ)
          EQ     MSL1 
  
*         STRS[DI] " 0, CHANGE TO AN XMT AND LET THE *XMT* PROCESSOR
*         DO THE REST OF THE DIRTY WORK.
  
 SRCH5    SA3    "RN"+B6
          LX3    59-RN.INCP 
          PL     X3,SRCH5A   IF ^INC[RI]
          SX7    B1 
          LX7    RN.INCP
          BX1    X7+X1       INC[RJ] = 1
          LX7    RN.IACP-RN.INCP
          BX6    -X7*X1      IAC[RJ] = 0
          SA6    A1 
  
 SRCH5A   MX7    -RN.XMTP 
          BX1    -X7*X1      XMT[RJ] = 0   */ SO WE CAN SQUEEZE XMITS 
  
 SRCH6    LX2    R1.RJP 
          S"OC"  OC.XMT 
          BX6    X2 
          RJ     URI         GENERATE AN XMT
          RJ     CTI         TRY AND ELIMINATE IT 
          EQ     AUC.RJ 
 C.XMT    SPACE  3
**        F.XMTC/F.XMT - FLOATING POINT ADD/SUB REDUCES TO AN XMT/XMTC
  
 F.XMTC   S"OC"  OC.XMTC
          EQ     F.XMT1 
  
 F.XMT    S"OC"  OC.XMT 
 F.XMT1   SA3    "RN"+B6
          SX6    B1 
          LX6    RN.NRP 
          BX7    X6+X3       NR[RI] = 1    */ RESULT IS NORMALIZED FLAG 
          SA7    A3 
          EQ     C.XMT1 
 C.XMT    SPACE  3
*         C.XMT / C.XMTC - CHANGE INSTRUCTION TO XMT / XMTC 
  
 C.XMTC   S"OC"  OC.XMTC
          EQ     C.XMT1 
  
 C.XMT    S"OC"  OC.XMT 
 C.XMT1   SA1    A1 
          LX1    59-RN.ZP 
          PL     X1,C.XMT2   IF ^Z[RJ]
          SA1    A2 
          LX1    59-RN.ZP 
 C.XMT2   LX1    1+RN.ZP
          BX6    -X0*X1 
          LX6    R1.RJP 
          RJ     URI         UPDATE REDUCED INSTRUCTION 
          SA1    "RN"+X1     (X1) = RND(RJ) 
          JP     SBB.JT+"OC" JUMP( OC ) 
 CTI      TITLE  CTI - CHECK TRANSMIT INSTRUCTION 
**        CTI - CHECK *XMT* INSTRUCTION TO SEE IF IT CAN BE ELIMINATED. 
* 
*         ENTRY  (X1) = RND(RJ) 
*                X4,X5,B6 AS FROM THE MAIN LOOP 
* 
*         EXIT   (X5) = [R1] IF XMT CANNOT BE ELIMINATED, ELSE TO MAIN L
  
 CTI      ROUTINE 
  
*         ELIMINATE XMT/XMT SEQUENCES 
  
 CTI0     LX1    59-RN.XMTP 
          PL     X1,CTI1     IF ^XMT[RJ]
          LX1    1+RN.XMTP-RN.TPP 
          SA2    X1          R1J = TP[RJ] 
          S"OC"  OC.XMT 
          SX5    B6 
          LX2    -R1.RJP
          BX3    -X0*X2      RJ = RJ[R1J] 
          SA1    "RN"+X3
          LX3    R1.RJP 
          PX6    "OC",X3
          IX7    X6+X5
          SA7    A5          [R1] = TYI(XMT,RJ,0,RI)
          BX5    X6+X5
          EQ     CTI0 
  
*         DETERMINE PRECEDENCE BIT SETTING AND JUMP TO PROCESSOR. 
  
 CTI1     LX1    1+RN.XMTP-RN.TPP 
          SA3    X1+B2       DJ = [TP[RJ]+2]
          MX2    -D.STRSL 
          LX4    -D.STRSP 
          BX6    -X2*X4 
          SB4    X6 
          LX3    -D.STRSP 
          BX7    -X2*X3 
          LX1    RN.TPP 
          SB5    X7 
          JP     CTI2+B4     JUMP( STRS[DI] )  */ 0 - 2 = -/PRS/PS
  
 CTI2     EQ     CTI3        STRS[DI] = 0 
  
          ZR     B5,CTI4     IF STRS[DJ] = 0
          EQ     CTI5 
  
          ZR     B5,CTI6     IF PS[DI]
          EQ     B5,B1,CTI5  IF PS[DI] & PRS[DJ]
  
*         STRS[DI] = 0 OR PS[DI] & PS[DJ] , ELIMINATE *XMT* 
  
 CTI3     SA2    "RN"+B6
          SX7    B1 
          LX7    RN.NRP 
          BX2    X7*X2
          BX6    X2+X1       RND(RI) = RND(RJ) ! NR[RI] 
          SA6    A2 
          MX7    0
          SX4    B4 
          SA7    A4          [DI] = 0 
          BX6    X3+X4
          LX6    D.STRSP
          SA6    A3          DJ = DJ ! STRS[DI] 
          EQ     MSL1 
  
*         PRS[DI] AND STRS[DJ] = 0
*         KEEP XMT IF RJ IS A *DEF* OR *KS*, OR A *LD* AND THE *RS* IS
*         NOT TO A LD REGISTER .
  
 CTI4     SA2    CTIB 
          LX7    X3 
          BX6    X2*X3
          NZ     X6,CTI5     IF PI[DJ] ! KS[DJ] 
          LX7    D.STRSP+59-D.LDP 
          MX6    -SO.RNL
          PL     X7,CTI3     IF ^LD[DJ] 
  
 #DAL     IFNE   .DAL,0 
          LX7    D.LDP-D.XMTP 
          MI     X7,CTI4A    IF XMT[DJ]    */ LEVEL 0 *LD*
          LX7    D.XMTP-D.L2P 
          MI     X7,CTI3     IF L2[DJ]
  
 CTI4A    BSS    0
 #DAL     ENDIF 
  
          SA2    A4+B2       R1RS = DI + 2
          MX7    5
          LX2    -R1.SOP
          BX6    -X6*X2      REGN = SORN[R1RS]
          LX7    -1 
          SB5    X6 
          LX7    B5,X7
          MI     X7,CTI3     IF 1 @ REGN @ 5  */ A LD REG 
  
*         KEEP *XMT*
  
  
 CTI5     SA2    CTIC 
          LX3    D.STRSP
          BX6    -X2+X3 
          ZR     X6,CTI8     IF ZP[DJ] & (SZ[DJ] = 1) & (TY[DJ] = II) 
          SA2    "RN"+B6
          SA4    A5+B2       DI = R1 + 2   */ RESTORE X4
          SX3    B1 
          LX3    RN.XMTP
          BX6    X3+X2       XMT[RI] = 1
          LX3    RN.CP-RN.XMTP
          BX3    X3*X1
          BX6    X6+X3       C[RI] = C[RJ]
          SA6    A2 
          EQ     CTI
  
*         *XMT* PRECEDES A STORE. ELIMINATE IF PRED CAN PRECEDE A STORE.
  
 CTI6     SA2    CTIA 
          BX6    X2*X3
 #DAL     IFEQ   .DAL,0 
          NZ     X6,CTI5     IF LD[DJ] ! KS[DJ] 
 #DAL     ELSE
          ZR     X6,CTI7     IF ^( LD[DJ] ! KS[DJ] )
          BX2    X3 
          LX2    D.STRSP-1-D.L2P
          PL     X2,CTI5     IF ^L2[DJ] 
          LX2    D.L2P-D.XMTP                                           001350
          MI     X2,CTI5     IF XMT[DI]    */ LEVEL 0 LD                001360
          LX2    D.XMTP-D.FPP 
          PL     X2,CTI7     IF NOT FP[DJ] */ ELIMINATE XMT 
          SA2    =XHO$OPT 
          MI     X2,CTI5     IF OPT .EQ. 2
  
*         FP LOAD MAY CHANGE TO A LOAD OF A LC. , KEEP THE XMT
  
 CTI7     BSS    0
 #DAL     ENDIF 
          BX2    X3 
          LX2    D.STRSP-1-D.PIP
          PL     X2,CTI3     IF ^PI[DJ]    */ RJ NOT A *DEF*
  
          SA2    A3-B2       R1J = DJ - 2 
          MX6    -SO.RNL
          LX2    -R1.SOP
          BX7    -X6*X2 
          SX6    X7-6 
          MI     X6,CTI5     IF SORN[R1J] < 6  */ NOT A STORE REG 
          SB4    B0          STRS[DI] = 0 
          EQ     CTI3 
  
*         CLR OR FMA THAT PRS IN 2 REGS, DUPLICATE IT INSTEAD OF AN XMT 
  
 CTI8     SA2    A3-B2
          SA4    A5+B2       DESCR OF XMT 
          BX6    X0*X2       OC AND IN OF R1J 
          UX7    "OC",X2
          RJ     URI         CHANGE INSTRUCTION 
          JP     SBB.JT+"OC"
  
 CTIA     BFMW   D,(LD,KS),60-D.STRSP 
 CTIB     BFMW   D,(KS,PI),60-D.STRSP 
 CTIC     VFD    D.TYL/1     TYPE = II
          POS    D.ZPP+1
          VFD    1/1
          POS    D.SZP+D.SZL
          VFD    D.SZL/1,*P/0 
 STT      TITLE  MISCELLANEOUS INSTRUCTION PROCESSING 
**        MISCELLANEOUS INSTRUCTION SQUEEZING 
*         INSTRUCTIONS MAY BE REGISTER STORED TO X OR B REGISTERS.
*         OR THEY ARE TYPE II ( NO PREDECESSORS ).
  
          PROCESS STT 
          SA2    A5+B1       R2 = R1 + 1
          SA3    ARFA 
          LX2    -IH.RFP
          SA1    "RN"+X2     RFW = RND(RF[R2])
          BX6    X0*X2       R2W = [R2] 
          SX7    X1          RF[R2W] = RN[RFW]
          BX3    X3*X1
          ZR     X3,STT0     IF ^(C,SA,IAC,XMT)[RFW]
          RJ     ARF         ADJUST RF,CA 
  
 STT0     ZR     X6,STT5     IF CAIH[R2W] = 0  */ REDUCE TO SA
          BX6    X6+X7
          SB4    X7          R = RF[R2W]
          LX6    IH.RFP 
          BX5    X6 
          SX7    X6 
          SA6    A5+B1       [R2] = R2W 
          SB5    STT4 
          SA2    MIC
          GT     B4,B1,STT2  IF R > 1 
          NZ     B4,STT1     IF R " 0 
          NZ     X7,STT1     IF IH[R2W] " 0 
  
*         RF & IH = 0 , CHANGE INST TO A *S*
  
          LX6    -IH.CAP
          SX7    X6          VAL = CA[R2] 
          MX6    0
          SA6    A5+B1       [R2] = 0 
          EQ     SA0
  
 STT1     SX3    B1 
          LX3    D.ZPP
          BX7    X4+X3       ZP[DI] = 1 
          SA7    A4 
  
 STT2     LX1    -RN.TPP
          SB3    X1+3        DEFA = TP[RFW] + 3 
          SB4    X2          I = MIC
          SX6    X5 
          ZR     X6,STT3     IF IH[R2] = 0 */ NO IH 
  
 .FTN     IFEQ   HC.ID,2                                                001050
          SA2    =XS=TRACE                                              001060
          BX7    X2-X6                                                  001070
          ZR     X7,STT3     IF IH[R2] = TRACE.  */ A-GOTO ERROR CHECK  001080
 .FTN     ENDIF                                                         001090
  
 .LCM     IFNE   .DAL,0 
          SA2    LCM#G
          LX2    1+D.STP
          BX7    X2*X4
          NZ     X7,STT3     IF LCM = G AND L2[DI] /* 21 BIT ARITHMETIC 
 .LCM     ENDIF 
  
          SA2    X1+B2       DF = TP[RFW] + 2 
          SX6    B1 
          LX6    D.RFP
          BX7    X6+X2       RF[DF] = 1    */ SET SHORT USE FOR PRED
          SA7    A2 
  
*         SEARCH *MIC* FOR PREVIOUS OCCURANCE OF THE *STT*
  
 STT3     LE     B4,B3,SMI5  IF I @ DEFA
          SA1    B4-B2       R2W = [I-2]
          BX6    X5-X1
          SA2    B4          I = [I]
          SB4    X2 
          NZ     X6,STT3     IF [R2W] " [R2]
  
          SA2    A1-B1       R1W = R2W - 1
          SA3    A5          R1 = R1
          BX6    X2-X3
          BX7    X0*X6
          NZ     X7,STT3     IF (OC,H2)[R1] " (OC,H2)[R1W]
  
          SA3    A1+B1       DJ = R2W + 1 
          EQ     SMI2        GO TRY TO ELIMINATE IT 
  
 STT4     LX5    R1.RJP-IH.RFP     INST ^ REDUNDANT 
          EQ     AUC.RJ 
          EQ     STT3        RETRY ADDRESS
  
*         CAIH = 0 , REDUCE *STT* TO *SA* OR *S*
  
 STT5     MX6    0           [R2] = 0 
          SA6    A5+B1
          ZR     X7,SA0      IF RF[R2W] = 0 
  
          S"OC"  OC.SA
          BX6    X7 
          SA1    "RN"+X7
          LX6    R1.RJP 
          SA2    "RN" 
          RJ     URI         URI( SA  RI, RF[R2W] ) 
 SA       SPACE  3,14 
          PROCESS SA
          BX6    X4 
          SB5    SA.JT
          LX6    59-D.TYP 
          MI     X6,SMI      IF TYPE[DI] = II  */ SA RI,A0
          LX2    59-RN.ZP 
          PL     X2,SRCH     IF ^Z[RK]
          SB3    X1+
          EQ     B3,B1,SAA0  IF RJ[R1] = 1
  
          BX6    X1 
          LX1    -RN.TPP
          SA2    X1+B2       DJP = TP[RJ] + 2 
          SB3    X1+3        DEFA = TP[RJ] + 3
          LX6    59-RN.CP 
          PL     X6,SA1      IF ^C[RJ]
          SA3    X1          R1J = TP[RJ] 
          RJ     DCV         VAL = DVC(R1J) 
          SX7    X7+
  
*         SA0 - REDUCE SHORT CONSTANT TO A *S* INSTRUCTION
  
 SA0      MX2    -18
          BX1    X7 
          S"OC"  OC.S 
          BX6    -X2*X7 
          LX6    R1.INP 
          RJ     URI         URI(  S  RI,VAL )
          NZ     X1,.S       IF VAL " 0 
          SX3    B1 
          LX3    D.SZP
          IX6    X4-X3       SZ[DI] = 1 
          BX4    X6 
          SA6    A4 
          EQ     .CLR        GO SET Z BIT FOR RI
  
  
 SA1      LX6    RN.CP-RN.IACP
          PL     X6,SMI      IF ^IAC[RJ]
          SA3    ARFAIL                                                 002611
          NZ     X3,SMI      IF SECOND TRIP                             002612
  
          LX2    59-D.CMP 
          MI     X2,SA2      IF CM[DJP]    */ *IA*
          SA3    A2-B2       R1P = DJP - 2
          LX3    -R1.RJP
          BX6    -X0*X3 
          SA2    "RN"+X6     RNJ = RND(RJ[R1P]) 
          LX2    59-RN.CP 
          MI     X2,SMI      IF C[RNJ]     */ CON - I CASE
  
*         CHANGE INSTRUCTION TO AN *STT*, LET *ARF* ADD THE CA. 
  
 SA2      LX5    -R1.RJP
          BX7    -X0*X5 
          LX7    IH.RFP 
          SA7    A5+B1       R2 = R1 + 1;  [R2] = IHW(0,RJ[R1],0,0) 
          SX6    0
          S"OC"  OC.STT 
          RJ     URI         URI(  STT  RI,RJ  )
          EQ     .STT 
  
*         SA NOT REDUNDANT, SET *SA* BIT
  
 SA5      SX2    B1 
          LX2    RN.SAP 
          BX6    X2+X3       SA[RND(RI)] = 1
          SA6    A3 
          EQ     AUC.RJ 
  
 SA.JT    SA3    "RN"+B6
          EQ     SA5
  
          EQ     SMI1        RETRY
  
*         SA  RI,A0 - CHANGE TO A TYPE II INST SO *BDT* AND *MCG* 
*         HANDLE IT PROPERLY. 
  
 SAA0     SX7    B1 
          LX7    D.ZPP
          BX4    X7+X4       ZP[DI] = 1 
          LX7    D.TYP-D.ZPP
          BX4    X7+X4       TYPE[DI] = II
          BX7    X4 
          SA7    A4+
          EQ     SMI
 CLR      SPACE  3,14 
*         ZERO - INSTRUCTION REDUCES TO A ZERO
*         CHANGE IT TO A *CLR* AND TRY TO ELIMINATE IT
  
 ZERO     S"OC"  OC.CLR 
          MX6    0
          SA6    A5+B1       [R2] = 0 
          RJ     URI         URI( CLR  RI,0 ) 
 CLR      SPACE  3
          PROCESS CLR 
          SA3    "RN"+B6
          MX6    RN.CZL 
          LX6    RN.CZL+RN.CZP  C[RI] = Z[RI] = 1 
          BX7    X6+X3
          SA7    A3 
          SB3    A0+3        DEFA = TXT + 3 
          SB5    FMA1 
          EQ     SMI
 FMA      SPACE  3
 FMA      PROCESS (FMA,S) 
          UX6    X5 
          AX6    R1.INP 
          NZ     X6,FMA0     IF IN[R1] " 0 */ VAL(RI) NOT 0 
          BX6    X4 
          LX6    59-D.PRSP
          PL     X6,ZERO     IF ^PRS[DI]
          EQ     .CLR                      */ GO SET *Z* BIT
  
 FMA0     SA3    "RN"+B6
          MX6    1
          LX6    1+RN.CP
          BX7    X6+X3       C[RI] = 1
          SA7    A3 
          SB3    A0+3        DEFA = TXT + 3 
          SB5    FMA1 
          EQ     SMI
  
 FMA1     EQ     MSL1        FAIL EXIT
          EQ     SMI1        RETRY
 FMA60    SPACE  3
*         FMA60 - CHANGE INSTRUCTION TO  FMA  RI,60 
  
 FMA60    S"OC"  OC.FMA 
          SX6    60 
          LX6    R1.INP 
          RJ     URI         URI( FMA  RI,60 )
          EQ     FMA
 LDC      SPACE  3,14 
**        LDC - LOAD CONSTANT ( LD  RI,0,CA,CON. )
  
          PROCESS LDC 
          SA3    A5+B1       R2 = R1 + 1
          SA2    O.CVT
          LX3    -IH.CAP
          SB4    X3 
          SA1    X2+B4
          BX6    X1          VAL = CVT(CA[R2])
          SX7    X3 
          LX7    I.CAP
          SA7    A4+B1       CA[DI+1] = CA[R2]
          EQ     CCV         ATTEMPT TO REDUCE VAL TO A SHORT CONST.
  
*         CCV RETURNS TO LDC1 IF LDC INSTR. NOT REDUCED TO
*         *CLR*,*S* OR *FMA* INSTR. 
  
 LDC1     SA3    LDCC 
          SA6    A5+B1       R2 = CONVAL   */ SAVE CONSTANT IN R2 WORD
          SB4    X3          I = LDCC 
          SA1    LDCN 
          SX7    X1          LDCN = SETX(LDCN)  */ CLEAR SIGN BIT 
          SA7    A1 
  
 LDC2     SA2    B4          L = [I]
          ZR     B4,LDC4     IF I = 0      */ END OF CHAIN
          SA3    A2-B2       R2P = [L-2]
          BX7    X3-X6
          SB4    X2          I = IC[L]
          NZ     X7,LDC2     IF NO MATCH
          MI     X7,LDC2     IF COMPLEMENTS 
  
*         MATCH FOUND, TRY TO ELIMINATE THE CURRENT LDC 
  
          SA3    A2-B1       DIM = LIP-1
          BX6    X3*X4
          LX6    59-D.PRSP
          BX7    X3+X4
          MI     X6,LDC3     IF PRS[DIM] & PRS[DI]
          MX6    -D.STRSL 
          LX7    -D.STRSP 
          BX6    X6+X7
          LX7    D.STRSP
          ZR     X6,LDC3     IF PS AND PRS */ IXI CANT HANDLE 
  
          SA7    A3          DIM = DIM ! DI 
          MX6    0
          SA6    A4          DI = 0        */ KILL CURRENT LDC
          SA2    A3-B2       R1M = DIM - 2
          SA1    "RN"+X2
          BX7    X1 
          SA7    "RN"+B6     RND(RI[R1]) = RND(RI[R1M]) 
          EQ     MSL1 
  
*         BOTH PRS, GO CHANGE TO AN *XMT* 
  
 LDC3     SA1    A3-B2
          BX2    -X0*X1      RJ = RI[R1M] 
          SA1    "RN"+X2     X1 = RND(RJ)  */FOR CTI
          MX7    0
          SA7    A5+B1       [R2] = 0 
          SA7    A4+B1       [DI+1] = 0 
          SX2    X1          X2 = RN[RND(RJ)] 
          EQ     SRCH6
  
*         LDC NOT REDUNDANT, ADD TO THE CHAIN 
  
 LDC4     SA3    "RN"+B6
          MX7    1
          LX7    1+RN.CP
          BX7    X7+X3
          SA7    A3          C[RND(RI)] = 1 
          SA2    A4+B1
          SA3    LDCC 
          BX6    X2+X3       IC[LI] = LDCC
          SA6    A4+B1
          SX7    A4+B1       LDCC = LI     */ CHAIN POINTS TO LAST
          SA7    A3 
          NZ     X2,MSL1     IF CA[LI] " 0 */ NOT GENERATED BY SQZ
          SA3    LDCN 
          SX7    X3+B1
          SA7    A3          LDCN = LDCN + 1
          EQ     MSL1 
 SMI      EJECT 
**        SMI - SQUEEZE MISCELLANEOUS INSTRUCTIONS
* 
*         ENTRY  (B3) = MIN SEARCH ADDRESS
*                (B5) = FAIL EXIT PROCESSOR ADDRESS 
*                X4,X5,B6 AS FROM MAIN LOOP 
*         NOTE - IN CASE OF RETRY THIS SUBROUTINE MAY BE ENTERED
*         AGAIN AT SMI1 / SMI2
  
 SMI      SA2    MIC
          SB4    X2          I = MIC
  
*         SEARCH *MIC* FOR A PREVIOUS OCCURANCE OF CURRENT INSTRUCTION. 
  
 SMI1     LE     B4,B3,SMI5  IF I @ DEFA
          SA1    B4-3 
          BX6    X5-X1
          SA2    B4          I = [I]
          BX7    X0*X6
          SB4    X2 
          NZ     X7,SMI1     IF MASK(-R1.RIL) & XOR(R1W,R1) " 0 
          SA3    A1+B2       DJ = R1W + 2 
  
*         ELIMINATE REDUNDANT INSTRUCTION , (X3) = [DJ] + ABOVE REG ASSI
  
 SMI2     BX6    X3+X4
          SX1    B4 
          MX7    -D.STRSL 
          LX6    -D.STRSP 
          BX6    -X7*X6 
          SB4    X6 
          BX6    X3*X4
          LX6    -D.STRSP 
          BX7    -X7*X6 
          JP     SMI3+B4     JUMP( STRS[DI] ! STRS[DJ] )
  
 SMI3     EQ     SMI6        STRS[DJ] & STRS[DI] = 0
  
          NZ     X7,SMI7     IF PRS[DJ] & PRS[[DI]
          EQ     SMI8 
  
          EQ     SMI6        PS[DI] ! PS[DJ]
  
 SMI3A    SB4    X1+
*         EQ     SMI4        PS & PRS 
  
 SMI4     ZR     B4,SMI5     IF I = 0 
          JP     B5+1        */ EXIT FOR A RETRY
  
*         INSTRUCTION NOT REDUNDANT, RETURN TO FAIL EXIT
  
 SMI5     SA2    MIC
          BX6    X2 
          SA6    A4+B1       [DI+1] = MIC 
          SX7    A4+B1
          SA7    A2          MIC = DI + 1 
          JP     B5          */ RETURN TO FAIL EXIT 
  
*         INSTRUCTION REDUNDANT, ELIMINATE SECOND OCCURANCE 
  
 SMI6     SA2    A3-B2       R1J = DJ - 2 
          BX6    X3+X4
          SA6    A3          DJ = DJ ! DI 
          BX1    -X0*X2 
          MX7    0
          SA2    "RN"+X1
          BX6    X2 
          SA7    A4          [DI] = 0      */ MARK INST AS DEAD 
          SA6    "RN"+B6     RND(RI) = RND(RI[R1J]) 
          EQ     MSL1 
  
*         BOTH INSTRUCTIONS PRECEDE A REGISTER STORE. 
  
 SMI7     SB4    X1 
          SA1    A3+B1
          SA2    A4+B2       RSI = R1 + 4 
          LX1    -I.RSP 
          SA1    X1          RSJ = [RSL[DJ+1]]
          BX6    X1-X2
          BX6    X0*X6
          NZ     X6,SMI4     IF REG[RSJ] " REG[RSI] 
  
          MX7    60 
          SA7    A4+4        [DI+4] = -0   */ MARK FOLLOWING *RS* AS DEA
          EQ     SMI6 
  
*         ONE OF THE INSTRUCTIONS PRECEDES AN RS.  IF IT IS TO A B REG, 
*         WE CANNOT REDUCE IT.
  
 SMI8     LX4    59-D.PRSP
          SA2    A4+B1       R1RS = DI + 1
          MI     X4,SMI9     IF PRS[DI] 
          SA2    A3+B1
          LX2    -36
          SA2    X2          R1RS = [RSL[DJ+1]] 
  
 SMI9     LX4    1+D.PRSP 
          MX6    -SO.RTL
          LX2    -R1.SOP-SO.RTP 
          BX7    -X6*X2 
          NZ     X7,SMI6     IF SORT[R1RS] " 0  */ ^ A B-REG
          EQ     SMI3A
 URI      TITLE  COMPILE TIME INSTRUCTION EVALUATION
**        URI - UPDATE REDUCED INSTRUCTION
*         UPDATES CORE IMAGE AND REGISTERS OF A CHANGED TYPE I/II INST
* 
*         ENTRY  (B3) = OPCODE
*                (X4) = OLD DESCRIPTOR
*                (X6) = RJ/RK OR IN/SO FIELDS OF NEW WORD 1 
* 
*         EXIT   (X4) = [DI] = ( NEW )
*                (X5) = [R1] ( NEW )
* 
*         USES   X - 3, 6, 7
*                A - 3, 6, 7
  
 URI      ROUTINE 
          SA3    F.RDT+"OC" 
          MX7    -D.STRSL 
          SX5    B6 
          LX7    D.STRSP
          IX6    X6+X5
          BX4    -X7*X4 
          PX6    "OC",X6     [R1] = NEW WORD 1
          SA6    A5 
          BX7    X3+X4       [DI] = RDT(OC) ! STRS[DI]
          LX5    X6 
          SA7    A4 
          LX4    X7 
          EQ     URI
 ECO      SPACE  2,14 
**        ECO PROCESSORS - EVALUATE INSTRUCTION WITH CONSTANT OPERANDS
* 
*         ENTRY  CURRENT INSTRUCTIONS IS A TYPE I INSTR AND 
*         X1,X2,X4,X5,B3,B6 ARE AS SET IN THE MAIN LOOP 
* 
  
          EPROC  IM 
          S"OC"  OC.DFM 
  
          EPROC  (FA,FS,DFA,DFS,RFA,RFS,FM,RFM,DFM,FD,RFD)
 ECO1     SA3    ECOA 
          SX6    "OC" 
          LX6    54          */ SET OP
          BX7    X6+X3
          SA7    ECO2        */ PLUG CODE FOR CURR."OC" AT ECO2 
          RJ     GCV         X6 = JVAL
*                            X7 = KVAL
          OR     X6,SRCH     IF ^RANGE(JVAL)
          ID     X6,SRCH     IF  INDEF(JVAL)
          OR     X7,SRCH     IF ^RANGE(KVAL)
          ID     X7,SRCH     IF  INDEF(KVAL)
          SX1    "OC"-44B    X1 = PL IF DIVIDE INSTRUCTION
          UX3    X6,B4       B4 = EXPONENT OF 1OP 
          SB4    B4+60B-1771B-60B 
          UX3    X7,B5       B5 = EXPONENT OF 2OP 
          SB5    B5+60B 
          MI     X1,ECO1A    IF NOT DIVIDE INSTRUCTION
          NX3    X7 
          ZR     X3,SRCH     IF DIVIDE BY ZERO
          SB4    B4-B5
          PL     B4,SRCH     IF RESULT OF DIVIDE WOULD BE BAD 
          EQ     ECO2 
  
 ECO1A    SX3    "OC"-40B    ADD AND SUBTRACT OP CODES ARE .LT. 40B 
          MI     X3,ECO2     IF ADD OR SUBTRACT 
          SB4    B4+B5
          PL     B4,SRCH     IF RESULT OF MULTIPLY WOULD BE BAD 
  
 ECO2     BX6    X6+X7       VAL = JVAL .OP. KVAL  */ EVALUATE INSTRUCTION
  
+         ID     X6,SRCH     IF INDEF(VAL)
          OR     X6,SRCH     IF ^RANGE(VAL) 
          EQ     CCV         GO CHANGE A NEW CONSTANT 
  
 ECOA     VFD    6/0B,9/667B
  
          EPROC  CX 
          BX2    X1 
          EQ     ECO.AND
  
          EPROC  SS 
          RJ     GCV
          SB4    X6 
          SB5    X7 
          SX6    B4-B5
          EQ     CCV
  
          EPROC  (IAZ,ISZ)
          S"OC"  "OC"-OC.IAZ+OC.IA
  
          EPROC  (AND,OR,XOR,IA,IS) 
 ECO.AND  SX6    667B 
          EQ     ECO3 
  
          EPROC  (STR,IMP,EQV)
          SX6    676B 
          EQ     ECO3 
  
          EPROC  (ILS,IRS,PK) 
          SX6    657B 
          EQ     ECO3 
  
 ECO.NR   EPROC  (NR,RNZ,UP)
          SX6    607B 
 ECO3     SA3    ECOB 
          SX7    "OC" 
          LX6    30 
          LX7    39 
          BX7    X6+X7
          BX7    X3+X7
          SA7    ECO3A
          RJ     GCV         X6 = JVAL
*                            X7 = KVAL
 ECO3A    SB5    X6          B5 = LOW18[JVAL] 
          NO
          EQ     CCV
  
 ECOB     SB5    X6 
          VFD    15/0 
          EQ     CCV
  
*         PROCESS NR,RNZ,UP WITH TWO RESULTS
  
 ECO4     SA3    ECOC 
          SX6    "OC" 
          LX6    54 
          BX7    X6+X3
          SA7    ECO4A
          LX2    -RN.TPP
          SA3    X2 
          RJ     DCV         X7 = KVAL
  
 ECO4A    UX1    B5,X7       EVALUATE INSTRUCTION 
          SX6    B5 
          S"OC"  OC.S        OC = OC.S
          MX7    -18
          BX6    -X7*X6 
          LX6    R1.INP      IN = VAL1
          SA5    A4+B2       R1RS = DI + 2
          MX7    -R1.SOL
          LX7    R1.SOP 
          SX3    SO.TLOCK 
          LX3    R1.SOP 
          BX7    -X7*X5 
          BX7    X7+X3       SO = SO[R1RS] + SO.TLOCK 
          BX6    X6+X7
          SA4    A5+B2       DIRS = R1RS + 2
          BX3    -X0*X5 
          SB6    X3          RIRS = RI[R1RS]
          MX7    0
          SA7    A5+B1       [R2RS] = 0 
          RJ     URI         URI( S  R1RS,VAL1 )
          SA4    A5-B2       DI = R1RS - 2
          SA5    A4-B2       R1 = DI - 2
          BX3    -X0*X5 
          SB6    X3          RI = RI[R1]
          BX6    X1 
          SX7    B1 
          SA7    IXF
          EQ     CCV         CCV( LDC RI,VAL2 ) 
  
 ECOC     VFD    6/0,9/157B 
          SX6    B5 
          S"OC"  OC.S 
 GCV      SPACE  2,14 
**        GCV - GET CONSTANT VALUES ( CONSTANT FOLDING )
* 
*         ENTRY  (X1/X2) = RND(RJ/RK) 
* 
*         EXIT   (X6,X7) = VAL[RJ/RK] 
  
 GCV      ROUTINE 
          LX1    -RN.TPP
          SA3    X1          R1P = TP[RJ] 
          RJ     DCV
          LX2    -RN.TPP
          BX6    X7          (X6) = VAL[RJ] 
          SA3    X2          R1P = TP[RK] 
          RJ     DCV         (X7) = VAL[RK] 
          EQ     GCV
 DCV      SPACE  3,14 
**        DCV - DETERMINE CONSTANT VALUE
* 
*         ENTRY  (X3) = R1 WORD OF *S*,*FMA* OR *LDC* INSTRUCTION 
*                (A3) = ADDRESS OF R1 WORD
* 
*         EXIT   (X7) = VALUE OF CONSTANT 
*                (B5) = OPCODE  ( USED BY *XMTC* PROCESSOR )
* 
*         USES   X3, X7, B4, B5 
  
 DCV0     RJ     GIV
  
 DCV      ROUTINE 
  
 DCV1     UX7    B4,X3
          SB5    OC.XMTC
          LX7    -R1.RJP
          EQ     B4,B5,DCV2  IF OC = OC.XMTC
          SB5    OC.XMT 
          NE     B4,B5,DCV0  IF OC " OC.XMT 
          BX7    -X0*X7 
          SA3    "RN"+X7
          LX3    -RN.TPP
          SA3    X3 
          EQ     DCV1 
  
 DCV2     BX7    -X0*X7 
          SA3    "RN"+X7
          LX3    -RN.TPP
          SA3    X3 
          RJ     GIV         GET VALUE
          BX7    -X7         VAL = -VAL 
          EQ     DCV
 GIV      SPACE  2,14 
 GIV0     SB4    X7-1 
          ZR     X7,GIV      IF IN[R1] = 0
          MX7    1
          AX7    B4          VAL = MASK(IN[R1]) 
 GIV      ROUTINE 
  
 GIV1     UX3    B4,X3
          SB5    OC.CLR 
          MX7    0           VAL = 0
          EQ     B4,B1,GIV   IF OC.BOS
          EQ     B4,B5,GIV   IF OC = OC.CLR 
          LX3    -R1.INP
          SX7    X3          VAL = IN[R1] 
          SB5    OC.S 
          EQ     B4,B5,GIV   IF OC = OC.S 
          SB5    OC.FMA 
          EQ     B4,B5,GIV0  IF OC = OC.FMA 
          SB5    OC.LDC 
          NE     B4,B5,GIV2  IF OC " OC.LDC 
          SA3    A3+B1
          BX7    X3          VAL = [R2] 
          EQ     GIV
  
 GIV2     SB5    OC.XMT 
          NE     B4,B5,*+1S17 
          LX3    R1.INP-R1.RJP
          BX7    -X0*X3 
          SA3    "RN"+X7
          LX3    -RN.TPP
          SA3    X3 
          EQ     GIV1 
 CCV      SPACE  3
**        CCV - CONVERT CONSTANT VALUE
* 
*         ENTRY  (X6) = VAL 
*                (B6) = RI
  
*         TRY TO REDUCE CONSTANT TO A *FMA* 
  
 CCV      PL     X6,CCV1     IF VAL > 0 
          CX7    X6 
          MX3    1
          SB4    X7-1 
          AX7    B4,X3
          BX3    X7-X6
          NZ     X3,CCV1     IF VAL " MASK( COUNT(VAL) )
          S"OC"  OC.FMA      OC = OC.FMA
          SX6    B4+B1       VAL = COUNT(VAL) 
          EQ     CCV2 
  
*         TRY TO REDUCE CONSTANT TO A *S* 
  
 CCV1     ZR     X6,ZERO     IF VAL = 0 
          LX7    X6 
          AX7    17 
          NZ     X7,CCV3     IF VAL " SMALL CONSTANT
          S"OC"  OC.S        OC = OC.S
          MX3    42 
          BX6    -X3*X6 
  
 CCV2     LX6    R1.INP 
          RJ     URI         URI( OC  VAL,RI )
          MX7    0
          SA7    A5+B1       [R1+1] = 0 
          EQ     FMA
  
 CCV3     SB4    "OC"-OC.LDC
          ZR     B4,LDC1     IF OC = OC.LDC  */ CALLED BY *LDC* 
  
          S"OC"  OC.LDC      OC = OC.LDC
          SA6    A5+B1       [R2] = VAL 
          SX6    B1+B1
          LX6    R1.INP      IN[R1] = 2    */ LD ONLY *UDT* INDEX 
          RJ     URI         URI( OC.LDC  RI,VAL )
          SA3    A5+B1
          BX6    X3          VAL = [R2] 
          EQ     LDC1 
 BTERM    TITLE  PSEUDO AND JUMP INSTRUCTION PROCESSING 
*         BOS - BEGINNING OF STMT MARKER
  
          PROCESS BOS 
          LX5    -R1.INP
          SX6    X5 
          SA6    =XHO$CSN     HO$CSN  = IN[R1]  */ LINE NO OF THIS STMT 
  
          PROCESS NOP 
          MX7    0
          SA7    A4          [DI] = 0 
          EQ     MSL1 
  
          PROCESS EOS 
          SX3    X5 
          ZR     X3,MSL1     IF IH[R1] = 0 */ NOT A OPT=2 *EOS* 
          SA2    A5-B2       DIP = R1 - 2 
          LX2    59-D.BMP 
          MI     X2,MSL1     IF BM[DIP]    */ LAST INST IS A *BM* 
          EQ     .NOP 
  
*         RS - REGISTER STORE 
  
          PROCESS RS
          ZR     X4,MSL1     IF [DI] = 0   */ DEAD INSTRUCTION
  
          SA1    "RN"+B6     RI = RND(RI) 
          BX6    X0*X5
          BX2    -X0*X1 
          IX7    X6+X2
          SA7    A5 
          BX6    X7-X5
          BX5    X7 
          LX7    59-R1.INP
          MI     X7,MSL1     IF IN[R1] " 0  */ RJ *RS*
  
          LX1    -RN.TPP
          SA2    X1+3 
          SX3    A5 
          LX3    I.RSP
          BX7    X3+X2       RSL[TP[RI]+3] = R1 
          SA3    RSS
          SA7    A2                        */ LINK DEF TO *RS*
          ZR     X6,RS1      IF RI DIDN"T CHANGE
  
          BX6    X3 
          SA6    A4+B1       [DI+1] = RSS  */ 
          SB5    "TXT"
          SX7    A5-B5
          SA7    A3          RSS = R1 - TXT */
  
*         BUMP USES COUNT OF OPERAND IF *UJP* OR FULL LOCK *RS*.
  
 RS1      BX6    X5 
          LX6    59-R1.SOP-SO.LKP 
          MI     X6,MSL1     IF IF SOTLK[R1]   */ DONT COLLECT USES 
          LX5    R1.RJP 
          LX6    -1 
          MI     X6,AUC.RJ   IF FULL LOCK 
          SA2    FAC
          SA3    A4+B1
          LX2    18 
          BX7    X2+X3       AC[LI] = FAC 
          SA7    A3 
          SX6    A4+B1
          SA6    A2          FAC = DI+1 
          EQ     AUC.RJ 
RJ3       SPACE  3,14 
*         RJ3 - ELIMINATE REDUNDANT BEF CALLS 
  
          PROCESS RJ3 
 .F       IFEQ   HC.ID,2     FTN ONLY 
          SX6    1
          SA6    CC$XR       CC$XR = 1
          MX7    0
          SA7    RJCA 
          SA3    RJ3C 
          SA7    A7+1 
 RJ1      ZR     X3,RJ7      IF I = 0  */ END OF CHAIN
          SA2    X3+         R1 = [I] 
          SA3    X3+3        LI = [I+3] 
          BX7    X3 
          SX3    X3          I = RJ3C[LI] 
          SA1    A2+4        R1 = R1 + 4
          UX6    B3,X1
          SB4    OC.DEF 
          NE     B3,B4,RJ1                 */ IF NO OC.DEF AFTER RJ3
          BX6    X2-X5
          NZ     X6,RJ1      IF IH'S .NE. 
  
          SX6    A3          RJ3T = LI     */ SAVE PTR TO LINK WORD 
          SA6    RJ3T 
  
*         IH'S MATCH, SEE IF ARG LISTS MATCH
  
          AX7    36          FACI = AC[LI]
          SA2    FAC
          SB6    B1          SI = 1 
          MX6    0
          SA6    STK         STK(0) = 0 
  
*         X2,X7 = PTRS TO LINK WDS OF RS'S (THIS,PREVIOUS)
  
 RJ2      SA3    X2 
          AX3    18 
          SX6    X3          LWA = AC[LWA]
          SA3    X7 
          AX3    18 
          SX3    X3          LWB = AC[LWB]
          LX6    18 
          BX6    X6+X3
          SA6    FACS        FACS = LW(0,0,LWA,LWB) 
          SA1    X2-3 
          BX1    -X0*X1      RIA = RI[LWB-3]
          SA2    X7-3 
          BX2    -X0*X2      RIB = RI[LWB-3]
  
 RJ3      ZR     X1,RJ8      IF RIA = 0 
          ZR     X2,RJ8      IF RIB = 0 
          SA1    B7+X1
          LX1    -RN.TPP
          SA1    X1          R1A = TP[RND(RIA)] 
          SA2    B7+X2
          LX2    -RN.TPP
          SA2    X2          R1B = TP[RND(RIB)] 
          BX6    X1-X2
          SA3    A1+B2
          MX7    D.TYL
          LX3    58-D.TYP 
          BX7    X7*X3
          ZR     X7,RJ5      IF TY[R1A+2] = I 
          AX6    R1.INP 
          NZ     X6,RJ6      IF (OC,IN)[R1A] .NE. (OC,IN)[R1B]
          MI     X3,RJ3A     IF TY[R1A+2] = III 
          UX6    B3,X1
          SX6    B3-OC.DEF
          ZR     X6,RJ6      IF OC = OC.DEF  */ NESTED FUNCTION CALLS 
          EQ     RJ4
 RJ3A     RJ     MMR         MATCH MEM REFS 
          NZ     X3,RJ3      IF INDEXED REFS   */ FOLLOW PRED 
  
*         POP STACK 
  
 RJ4      SB6    B6-B1       SI = SI - 1
          SA2    STK+B6 
          SX1    X2 
          AX2    18          RIA,RIB = STK(I) 
          EQ     RJ3
  
*         TYPE I - PUSH STACK 
  
 RJ5      AX6    R1.OCP 
          NZ     X6,RJ6      IF OC[R1A] .NE. OC[R1B]
          LX3    1+D.TYP-D.LDP
          MI     X3,RJ3A     IF LD[DI]
          AX1    R1.RIL 
          AX2    R1.RIL 
          BX3    -X0*X1 
          BX6    -X0*X2 
          LX6    18 
          BX6    X6+X3
          SA6    STK+B6      STK(SI) = STKW(RKA,RKB)
          SB6    B6+B1       SI = SI + 1
          AX1    R1.RIL 
          AX2    R1.RIL 
          BX1    -X0*X1      RIA = RJ[R1A]
          BX2    -X0*X2      RIB = RJ[R1B]
          NZ     X1,RJ3      IF RIA .NE. 0
          NZ     X2,RJ6      IF RIB .NE. 0
          EQ     RJ4         GO POP THE OTHER OPERAND 
  
*         FAIL EXIT, TRY AGAIN
  
 RJ6      SA3    RJ3T 
          SA3    X3 
          SX3    X3          I = SETX([RJ3T])  */ RESTORE LINK TO NEXT
          EQ     RJ1
  
*         FAIL, NO MATCH OF CURRENT ENTRY ON RJ3 CHAIN
  
 RJ7      SA1    FAC
          SA2    MRC
          SA3    RJ3C 
          LX1    36 
          LX2    18 
          BX6    X1+X2
          BX6    X6+X3
          SA6    A4+B1       [LI] = LW(0,FAC,MRC,RJ3C)
          CLEAR              CLEAR CHAIN POINTERS 
          SX7    A5 
          SA7    A3          RJ3C = R1
          EQ     MSL1 
  
*         ONE OR BOTH RI ARE ZERO 
  
 RJ8      BX6    X1-X2
          NZ     X6,RJ6      IF NOT(RIA = 0 AND RIB = 0)
          GT     B6,B1,RJ4   IF SI > 1     */ STACK NON-EMPTY 
  
*         SUCCESS 
  
          SA3    FACS 
          ZR     X3,RJ9      IF FACS = 0   */ NO MORE ARGS
          SX7    X3 
          AX3    18 
          SB6    B1          SI = 1 
          SX2    X3 
          EQ     RJ2         GO CHECK NEXT ARG
  
*         ELIMINATE THIS RJ, STORE RESULT OF PREVIOUS IF NECESSARY
  
 RJ9      SA1    FAC         I = FAC
          SX5    B1 
          LX5    RN.USESP 
          MX7    0           RSSV = 0 
          SA7    A1          FAC = 0
 RJ10     SA2    X1          LI = I 
          MX6    60 
          SA6    A2-B1       [LI-1] = -0  */ CLEAR DESCR OF RS
          SA3    A6-B2       R1 = LI - 3
          BX3    -X0*X3 
          SA3    B7+X3
          IX6    X3-X5       USES[RND(RI)] = USES[RND(RI)] - 1
          SA6    A3 
          LX6    -RN.TPP
          SA3    X6+B2       DIP = TP[RND(RI)] + 2
          SX6    B1 
          LX6    D.PRSP 
          BX6    -X6*X3 
          SA6    A3          PRS[DIP] = 0 
          SX3    X2+         RSC = RSS[LI] */ SEPERATED RS CHAIN
          ZR     X3,RJ11     IF RSC = 0 
          SX7    X3+         RSSV = RSC 
 RJ11     LX2    -18
          SX1    X2          I = AC[LI] 
          NZ     X1,RJ10     IF I .NE. 0
          ZR     X7,RJ12     IF RSSV = 0
          SA7    RSS         RSS = RSSV    */ UPDATE RS CHAIN 
  
 RJ12     SA3    RJ3T 
          SB5    X3+B1       R1D = RJ3T+1 
          SB6    B1          PREC = 1 
          MX7    59 
          SA7    CAS         CAS = -1 
          SA7    A7+B1
          SA3    B5+4        R1S = R1D+4   */ SKIP OVER FIRST DEF 
          SB4    OC.ST
          UX6    B3,X3
          SA2    B5+B1       R2D = R1D+1
          ZR     X2,RJ13     IF [R2D] = 0 
  
          LX2    -IH.CAP
          SX6    X2 
          SA6    CAS         CAS = CA[R2D] */ CA FROM PREVIOUS SQZ
          NE     B3,B4,RJ12A IF OC[R1S] .NE. OC.ST
          SA3    A3+4        R1S = R1S + 4
 RJ12A    UX6    B3,X3
          SB4    OC.DEF 
          SB5    A2          FIRST = R2D
          SX7    4
          NE     B3,B4,RJ13A  IF OC[R1S] .NE. OC.DEF  */ NOT DBL PREC 
          SB6    B1+B1       PREC = 2 
          SA3    A3+B1
          LX3    -IH.CAP
          SX6    X3          CAS(2) = CA[R1S+1] 
          SA6    CAS+1
          EQ     RJ13A
  
 RJ13     NE     B3,B4,RJ15  IF OC[R1S] .NE. OC.ST
          SA1    =XS=ST 
          SA2    A3+B1
          BX6    X1-X2
          SX7    X6+
          NZ     X7,RJ14     IF IH[R1S+1] .NE. ST.
          LX2    -IH.CAP
          SX6    X2 
          SA6    CAS         CAS = CA[R1S+1]
          SA3    A3+4        R1S = R1S+4
          UX6    B3,X3
          SB5    A2          FIRST = R2S
          MX3    R1.CAL 
          SA2    A2-1                         */ R1W
          LX3    18+R1.CAP
          BX6    X3*X2                         */ LINK TO UDI 
          SA6    RJCA                           */ USED IN GTL
          SX7    8
          SB4    OC.DEF 
          NE     B3,B4,RJ13A  IF OC[R1S] .NE. OC.DEF  */ NOT DBL PRECISI
          SA2    A3+5 
          LX2    -IH.CAP
          SX6    X2 
          SA6    CAS+1       CAS(2) = CA[R1S+5] 
          SB6    B1+B1       PREC= 2
          SA2    A2-1                               */ R1W
          BX6    X3*X2
          SA6    RJCA+1                               */ GTL
  
*         RESULT OF RJ3 IS STORED TO AN ST. , ENSURE THAT THERE IS NO 
*         REDEFINITION OF THE ST. BETWEEN THE CURRENT AND THE FIRST RJ3.
*         B5 = LOC OF R2 OF FIRST ST., X7 = INCREMENT BETWEEN ST.'S 
  
 RJ13A    SA7    RJ3T        SAVE INCREMENT IN CASE DBL PREC
          SB3    B5          B3 = FIRST 
          MX7    0           PASS = 0 
          SA3    B3+B1
          NZ     X3,RJ13B    IF [DI] .NE. 0  */ STORE IS LIVE 
          SA3    B3-B1
          UX3    B4,X3
          BX3    -X0*X3 
          SA3    B7+X3       RND(RI[R1])
          SX2    B1 
          LX2    RN.USESP 
          IX6    X3+X2       BUMP USES CNT OF ST PRED 
          SA6    A3 
          SA3    F.RDT+B4 
          BX6    X3 
          SA6    B3+B1       RESTORE DESCRIPTOR 
  
 RJ13B    MX2    -IH.CAIHL
          SA3    B3          R2W = [FIRST] */ R2W OF ST TO ST.
          BX4    -X2*X3      PAT = CAIH[R2W]
          SB5    B0          LOC = 0  */ NO INTERFERENCE
          SA3    A4-1-4      R2I = DI-1-4 
  
*         SEARCH BACKWARD FOR REDEF OF THIS ST. 
  
 RJ13C    SA3    A3-4        R2I = R2I - 4
          BX5    X3-X4
          BX6    -X2*X5 
          NZ     X6,RJ13C    IF CAIH[R2I] .NE. PAT
  
          SB4    A3 
          LE     B4,B3,RJ13D IF R2I = FIRST  */ IF FINISHED 
          SA1    A3-B1
          UX6    B4,X1
          SX6    B4-OC.ST 
          NZ     X6,RJ13C    IF OC[R2I-1] .NE. OC.ST  */ NOT A REDEF
          SA1    A3+B1
          ZR     X1,RJ13C    IF DESCR = 0  */ INSTRUCTION IS DEAD 
  
          SB5    A3          LOC = R2I
          EQ     RJ13C
  
 RJ13D    SX7    X7+B1       PASS = PASS + 1
          ZR     B5,RJ13X    IF LOC = 0  */ NO REDEFINITIONS
  
*         ST.+C IS REDEFINED, PICK A NEW CA AND UPDATE REFS 
  
          MX6    0
          SA6    RJCA 
          SA6    RJCA+1 
          SA1    STBASE      N = STBASE 
          BX6    X1 
          SA6    CAS-1+X7    CAS(PASS) = N
          SX6    X1+B1       STBASE += 1
          SA6    A1 
          SA5    S=ST 
          LX1    IH.CAP 
          BX1    X1+X5       NEWPAT = CAIH(N,ST.) 
          SA3    B5          R2J = LOC
  
 RJ13E1   MX2    -IH.CAIHL
  
 RJ13E    SA3    A3-4        R2J = R2J - 4
          BX5    X3-X4
          BX6    -X2*X5 
          NZ     X6,RJ13E    IF CAIH[R2J] .NE. PAT
          SA2    A3+B1
          ZR     X2,RJ13E1   IF DESCR = 0 
  
          MX2    -IH.CAIHL
          BX3    X2*X3
          BX6    X3+X1       CAIH[R2J] = NEWPAT 
          SA6    A3 
          SB4    A3 
          GT     B4,B3,RJ13E IF R2J GT FIRST
  
 RJ13X    SB4    X7 
          EQ     B4,B6,RJ18  IF PASS = PREC 
  
*         SETUP FOR SECOND HALF OF DOUBLE PREC
  
          SA1    RJ3T 
          SB3    B3+X1
          EQ     RJ13B
  
  
 RJ14     SA3    A3+4        R1S = R1S+4
          UX6    B3,X3
 RJ15     SB4    OC.DEF 
          NE     B3,B4,RJ16 
          SB6    B1+B1       PREC = 2 
 RJ16     SA1    STBASE 
          BX6    X1 
          SA6    CAS         CAS = STBASE 
          SX6    X6+B1
          SA6    A6+B1       CAS(2) = STBASE+1
          SX7    X1+B6       STBASE = STBASE + PREC 
          SA7    A1 
          SA2    S=ST 
          LX1    IH.CAP 
          SX3    B1 
          LX3    58 
          BX6    X1+X2
          BX6    X6+X3
          SA6    IXF         IXF = NON_ZERO 
          SA6    B5+B1       [R1D+1] = IHW(F,0,CAS,ST.) 
          RJ     BDU         BUMP USES OF DEF 
          EQ     B6,B1,RJ18  IF PREC = 1
          SB4    OC.DEF 
          UX7    X6          CLEAR FLAG BIT 
          SA7    A6 
 RJ17     SB5    B5+4        R1D = R1D+4
          SA3    B5 
          UX7    B3,X3
          NE     B3,B4,RJ17  IF OC[R1D] .NE. OC.DEF 
          SX3    B1 
          LX3    IH.CAP 
          IX6    X6+X3
          LX3    57-IH.CAP
          IX6    X6+X3
          SA6    A3+B1       [R1D+1] = IHW(F,0,CAS+1,ST.) 
          RJ     BDU         BUMP USES OF DEF 
  
*         CHANGE CURRENT RJ3/DEF TO LD/XMT
  
 RJ18     SA3    A4+B2       R1D = DI+2 
          SB3    OC.DEF 
          UX6    B5,X3
          EQ     B3,B5,RJ19                           */ IF OC.DEF
          MX7    -0 
          SA7    A4                                 */RJ3 IS DEAD 
          EQ     RJ7
  
 RJ19     BX6    -X0*X3 
          SB5    X6          R = RI[R1D]
          SX6    B5-B1
          SA2    CAS
          SB4    A4-B2
          SA1    RJCA 
          BX7    X1 
          SA7    GTLC                                */ USED IN GTL 
          RJ     GTL         GTL( R-1 , CAS , DI-2 )
          SX6    B5-B1
          SB4    B4+4 
          RJ     GXI         GENERATE XMT 
          SA4    A4-4        DI = DI - 4   */ BACKUP TO PROCESS LD ST.
          EQ     B6,B1,RJ20  IF PREC = 1
          SA2    MRC
          ZR     X2,RJ19A                    */ IF REFERENCE CHAIN ZERO 
          BX7    -X2
          SB3    A4+1                       */ LI = DI + 1
          SX1    X7+B3
          NZ     X1,RJ19A                  */ IF MRC DOESN'T POINT HERE 
          SA1    B3 
          SX6    X1 
          SA6    A2                           */ UPDATE REFERENCE CHAIN 
  
 RJ19A    SX6    B5-2 
          SA2    CAS+1
          SB4    B4-8 
          SA1    RJCA+1 
          BX7    X1 
          SA7    GTLC                                    */ USED IN GTL 
          RJ     GTL         GENERATE SECOND LOAD 
          SA3    B4+8 
+         SA3    A3+4 
          UX6    B3,X3
          SX7    B3-OC.DEF
          NZ     X7,*-1 
          SB4    A3 
          SX6    B5-2        RJ = RI OF LOAD
          BX7    -X0*X3 
          SB5    X7 
          RJ     GXI         REPLACE SECOND DEF WITH XMT
          SA4    A4-4        DI = DI - 4   */ BACKUP
 RJ20     BSS    0
          EQ     MSL1 
 BDU      SPACE  3,14 
**        BDU - BUMP *DEF* USES, (A6) = R2
  
 BDU      ROUTINE 
          SA3    A6-B1       GET R1 WORD
          BX2    -X0*X3 
          SA3    B7+X2
          SX2    B1 
          LX2    RN.USESP 
          IX7    X2+X3
          SA7    A3 
          EQ     BDU
 GTL      SPACE  3,14 
**        GTL - GENERATE TEMP LOAD
*         ENTRY X6 = RI 
*                X2 = CA
*                B4 = R1 ADDR 
  
 GTL      ROUTINE 
          SB3    OC.LD
          SX7    B4 
          LX7    RN.TPP 
          BX7    X6+X7
          SA7    B7+X6       RND(RI) = RNDW(0,0,R1,RI)
          PX6    B3,X6
          SA1    GTLC 
          IX6    X6+X1                        */ INCLUDE LINK TO UDI
          SA6    B4 
          SA1    S=ST 
          LX2    IH.CAP 
          BX7    X1+X2
          SA7    B4+B1
          SA3    =XF$RDT+B3 
          BX6    X3 
          SA6    A7+B1
          MX7    0
          SA7    A6+B1       LINK = 0 
          EQ     GTL
 GTLC     BSS    1
 GXI      SPACE  3,14 
**        GXI - GENERATE XMT INSTRUCTION
*         ENTRY X6 = RJ 
*                B5  RI 
*                B4 = R1 ADDR 
  
 GXI      ROUTINE 
          SB3    OC.XMT 
          SA3    F$RDT+B3 
          SA2    B4+B2       DESCR
          SX7    B1 
          LX7    D.PSP
          BX2    X7*X2
          BX3    X2+X3       MOVE TO XMT DESCR
          LX6    R1.RJP 
          SX5    B5 
          BX6    X6+X5
          PX6    B3,X6
          SA6    B4 
          MX7    0
          SA7    B4+B1       R2W = 0
          BX6    X3 
          SA6    A7+B1
          SA7    A6+B1       LINK = 0 
          SX6    B4 
          LX6    RN.TPP 
          BX6    X5+X6
          SX5    B1 
          LX5    RN.XMTP
          BX6    X5+X6
          SA6    B7+B5       RND(RI) = RNDW(XMT,0,R1,RI)
          EQ     GXI
 MMR      SPACE  3,14 
**        MMR - MATCH MEMORY REFS 
*         ENTRY A1,A2 = R1 WORD ADDRESS'S OF THE MEM REFS 
*         EXIT TO RJ6 IF NO MATCH OR INTERFERENCE 
*         X1,X2,X3 = RF1,RF2,SUM OF RFS 
  
 MMR      ROUTINE 
          UX6    B3,X1
          SA1    A1+B1       IHA = R1A+1
          SA2    A2+B1       IHB = R1B+1
          BX6    X1-X2
          SX3    B3-OC.LDC
          NZ     X3,MMR1     IF OC[R1A] .NE. OC.LDC 
          NZ     X6,RJ6      IF [IHA] .NE. [IHB]
          MI     X6,RJ6      IF COMPLEMENTS 
          MX3    0
          EQ     MMR
  
 MMR1     MX7    -IH.CAIHL
          BX7    -X7*X6 
          NZ     X7,RJ6      IF NO MATCH OF CA AND IH 
          SA6    MMRA 
          BX7    X2          SAVE DIFF AND RF OF IHB
          LX7    -IH.RFP
          SX7    X7 
          SA7    A6+B1
  
*         SCAN BACKWARD FOR INTERFERING STORE 
  
          SB4    A2-B1       B4 = R1B 
          SB4    -B4
          SA2    MRC         I = MRC
          SA3    RJ3C 
          SB3    X3          J = RJ3C 
          MX5    -IH.IHL
 MMR2     ZR     X2,MMR3
          SA2    X2          LW = [I] 
          SX2    X2          I = MRC[LW]
          SX6    A2+B4
          MI     X6,MMR4     IF I < R1B 
          SA3    A2-B1       DI = LW - 1
          LX3    59-D.STP 
          PL     X3,MMR2     IF NOT ST[DI]
          SA3    A3-B1       IHW = [DI-1] 
          BX6    X1-X3
          BX7    -X5*X6 
          NZ     X7,MMR2     IF IH[IHW] .NE. IH[R2W]
          LX6    -IH.RFP
          BX7    -X5*X6 
          NZ     X7,RJ6      IF RF'S DIFFERENT
          LX6    IH.RFP-IH.CAP
          BX7    -X5*X6 
          ZR     X6,RJ6      IF CA'S THE SAME 
          EQ     MMR2 
  
 MMR3     ZR     B3,MMR4                     */ IF END OF CHAIN 
          SA3    B3+3        LI = [J+3] 
          SB3    X3          J = RJ3C[LI] 
          LX3    -18
          SX2    X3          I = MRC[LI]
          EQ     MMR2 
  
 MMR4     LX1    -IH.RFP
          SX1    X1 
          SA2    MMRA+1 
          BX3    X1+X2
          BX6    X1-X2
          ZR     X6,MMR5     IF RF'S =
          ZR     X3,MMR      IF BOTH = 0
          EQ     RJ6
  
 MMR5     SX4    X1-1 
          NZ     X4,MMR      IF RF .NE. 1 
          MX3    0           INDICATE BOTH ARE 0
          EQ     MMR
  
 MMRA     BSS    2
 RJCA     BSS    2
 .F       ENDIF 
 BTERM    EJECT 
*         BLOCK TERMINATORS 
  
          PROCESS RJ6 
          SX6    1
          SA6    =XCC$XR     CC$XR = 1
  
          PROCESS (UJP,LAB,ENT) 
          CLEAR              CLEAR LINKED LISTS 
          EQ     MSL1 
  
          PROCESS JIN 
          CLEAR              CLEAR LINKED LISTS 
          SA1    "RN"+B6
          BX6    X0*X5
          BX5    -X0*X1 
          IX6    X6+X5
          SA6    A5 
          ZR     X5,MSL1     IF RI = 0
          EQ     JPX6 
  
*         CONDITIONAL JUMPS 
  
          PROCESS JPX 
          SA1    "RN"+B6
          BX6    X0*X5
          BX5    -X0*X1      RI = RND(RI) 
          LX1    59-RN.XMTCP
          PL     X1,JPX1     IF ^XMTC[RNI]
  
*         CHANGE *JPX* TO OMIT *XMTC* IF *PL/MI* JUMPS
  
          SA3    A5+B1       R2 = R1 + 1
          LX3    -IH.CAP     JT = CA[R2]   */ JUMP TYPE 
          SB5    X3 
          LT     B5,B2,JPX1  IF JT < 2     */ ZR, NZ
          SB5    B5-B2
          GE     B5,B2,JPX1  IF JT > 3     */ RANGE CHECK JUMPS 
          SX7    B1 
          BX7    X3-X7
          LX7    IH.CAP      JT = XOR(JT,1)   */ TOGGLE *JT*
          SA7    A3 
          LX1    1+RN.XMTCP-RN.TPP
          SA3    X1          R1P = TP[RNI]
          LX3    -R1.RJP
          BX5    -X0*X3      RI = RJ[R1P]  */ SUBSTITUTE OPERAND OF XMTC
          SB6    X5 
  
 JPX1     IX6    X6+X5
          SA6    A5 
          SA1    "RN"+B6
          LX1    59-RN.CP 
          PL     X1,JPX6     IF ^C[RI]
          SB3    OC.UJP 
          RJ     ECJ         EVALUATE CONDITIONAL JUMP
          SA2    =XCC$OPF 
          SA3    =XO$CFT
          LX1    -R1.INP
          MX7    0
          PL     B5,JPX2     IF TV \ 0     */ JUMP CONDITION TRUE 
  
          NZ     X2,MSL1     IF CC$OPF " 0 */ ^OPT=2 & BRIDGE PHASE 
          SX1    X1 
          ZR     X1,MSL1     IF IN[R1] = 0 */ NO FLOW INFO
          IX1    X1+X3
          SA7    X1          CFT(IN[R1]) = 0  */ CLEAR FLOW TABLE ENTRY 
          EQ     MSL1 
  
*         JUMP CONDITION TRUE, MARK REST OF BLOCK AS DEAD 
  
 JPX2     SB4    OC.LAB 
          SB5    OC.JPX 
          SB6    X3 
          SX6    X1          LCI = IN[R1] 
          SA3    B6+X6       LCIA = CFT(LCI)
  
 JPX3     SA5    A5+4        R1 = R1 + 4
          UX1    "OC",X5
          ZR     "OC",JPX5   IF OC[R1] = 0
          EQ     "OC",B4,JPX5      IF OC[R1] = OC.LAB 
          NE     "OC",B5,JPX4      IF OC[R1] " OC.JPX 
          NZ     X2,JPX4     IF CC$OPF " 0 */ ^OPT=2 & BRIDGE PHASE 
          LX5    -R1.INP
          SX6    X5          LCI = IN[R1] 
          ZR     X6,JPX4     IF LCI = 0 
          SA3    B6+X6       LCIA = CFT(LCI)
          SA7    A3          [LCIA] = 0    */ CLEAR FLOW TABLE ENTRY
 JPX4     SA7    A5+B2       [R1+2] = 0 
          EQ     JPX3 
  
 JPX5     SA4    A5-B2       DI = R1 - 2
          ZR     X6,MSL1     IF LCI = 0 
          NZ     X2,MSL1     IF CC$OPF " 0 */ ^OPT=2 ^ BRIDGE PHASE 
          SX6    X6+B1
          SA2    B6+X6       LCIA = CFT(LCI+1)
          MI     X2,MSL1     IF JP[LCIA]
          BX6    X2-X3
          LX6    -30
          SB3    X6 
          NZ     B3,MSL1     IF FROM"S NE 
          SA7    A2          [LCIA+1] = 0  */ CLEAR FALL THROUGH EDGE 
          EQ     MSL1 
  
 JPX6     SA2    MRC
          SX7    A5          JPXA = R1
          LX5    R1.RJP 
          SA7    JPXA 
          MX4    1
          ZR     X2,AUC.RJ   IF MRC = 0 
          BX6    X4+X2
          SA6    A4+B1       [DI+1] = 1S59 ! MRC
          SX7    A4+B1
          SA7    A2          MRC = DI + 1 
          EQ     AUC.RJ 
 DEF      SPACE  3
          PROCESS DEF 
          SX3    B1 
          LX3    D.PSP
          BX6    -X3*X4      PS[DI] = 0    */ PS BIT SET IN SBB8 LOOP 
          SA6    A4 
          EQ     MSL1 
 RJXJ     SPACE  2,14 
**        RJXJ  RTEST,RFREE,CA,IH  , CA = 12/BIAS,6/JUMP TYPE 
  
          PROCESS RJXJ
          SA3    A5+B1       R2 = R1 + 1
          SA1    "RN"+X5     RIW = RND(RI[R1])
          LX3    -IH.RFP
          BX5    X0*X5
          SA2    "RN"+X3     RFW = RND(RF[R2])
          BX3    X0*X3
          SX6    X1 
          SX7    X2 
          IX6    X5+X6       RI[R1] = RN[RIW] 
          BX5    X6 
          SA6    A5 
          BX7    X3+X7
          LX7    IH.RFP      RF[R2] = RN[RFW] 
          SA7    A3 
          LX1    59-RN.CP 
          PL     X1,RJXJ1    IF ^C[RIW] 
  
 .HC      IFNE   HC.RJ6,0 
          SB3    OC.RJ6 
 .HC      ELSE
          SB3    OC.RJ3 
 .HC      ENDIF 
  
          RJ     ECJ         EVAL CONDITIONAL JUMP
          MI     B5,MSL1     IF TV < 0     */ JUMP CONDITION FALSE
          SA5    A5-4        R1 = R1 - 4   */ BACKUP
          EQ     MSL1 
  
*         SEARCH FOR A PREVIOUS OCCURANCE OF THIS INSTRUCTION 
  
 RJXJ1    SA3    A5+B1       R2W = [R1+1] 
          SA2    CRJC 
          SA1    "RN"+X5
          BX6    X3 
          LX1    -RN.TPP
          SB5    X1+3        DEFA = TP[RIW] + 3 
  
 RJXJ2    SB4    X2          I = CRJC 
          SA2    X2          CRJC = [I]    */ NEXT
          LE     B4,B5,RJXJ3 IF I @ DEFA
          SA3    A2-B2       R2C = [I-2]
          BX7    X6-X3
          NZ     X7,RJXJ2    IF R2C " R2W 
          SA3    A3-B1       R1C = [I-3]
          BX7    X3-X5
          NZ     X7,RJXJ2    IF R1C " R1W 
  
*         MATCH FOUND, ELIMINATE THE SECOND INSTRUCTION 
  
          MX7    60 
          SA7    A4          [DI] = 0 
          EQ     MSL1 
  
*         INSTRUCTION NOT REDUNDANT, ADD IT TO THE CHAIN, UPDATE *USES* 
  
 RJXJ3    SA2    CRJC 
          BX7    X2 
          SA7    A4+B1       [DI+1] = CRJC */ POINT THIS TO LAST
          SX7    A4+B1
          SA7    A2          CRJC = DI+1   */ LIST POINTS TO LAST 
  
          SA1    "RN"+X5     RIW = RND(RI[R1])
          SX4    B1 
          LX4    RN.USESP 
          IX7    X4+X1       USES[RIW] = USES[RIW] + 1
          SA7    A1 
          LX6    -IH.RFP
          SA2    "RN"+X6     RFW = RND(RF[R2])
          IX6    X4+X2       USES[RFW] = USES[RFW] + 1
          SA6    A2 
          EQ     MSL1 
 ECJ      SPACE  3,14 
**        ECJ - EVALUATE CONDITIONAL JUMP 
* 
*         ENTRY  (X1) = SHIFT(RIW,59-RN.CP) 
*                (B3) = OPC , OPCODE TO BE GENERATED IF JUMP CONDITON 
*                     IS TRUE 
* 
*         EXIT   (B5) = TV, TRUTH VALUE, < 0 IF JUMP CONDITION IS FALSE 
*                (X1) = R1S , OLD VALUE OF R1 WORD
  
 ECJ3     MX7    60 
          SA1    A5 
          SB5    -B1         TV = -1       */ INDICATE CONDTION FALSE 
          SA7    A4          [DI] = -0     */ MARK AS REDUNDANT 
  
 ECJ      ROUTINE 
          LX1    1+RN.CP-RN.TPP 
          SA3    X1 
          RJ     DCV         CV = DCV( TP[RIW] )
          SA3    A5+B1       R2W = [R1+1] 
          MX1    -3 
          LX3    -IH.CAP
          BX2    -X1*X3 
          SB5    X2          TV = JT[CA[R2W]] 
          JP     ECJ1+B5
  
 ECJ1     BSS    0
          ECHO   2,XX=("XJUMPS")
          XX     X7,ECJ2
          EQ     ECJ3 
  
*         JUMP CONDITION IS TRUE, CHANGE INST TO A *UJP/RJ6*
  
 ECJ2     LX3    -6 
          MX1    -12
          BX6    -X1*X3 
          LX6    R1.CAP 
          LX3    IH.CAP+6-IH.IHP
          MX1    -IH.IHL
          BX2    -X1*X3 
          BX6    X6+X2
          SA1    A5          R1S = [R1] 
          SB6    B0 
          RJ     URI         CHANGE INSTRUCTION TO A UJP/RJ6
          MX7    0
          SA7    A5+B1
          EQ     ECJ
 SMR      TITLE  SMR - SQUEEZE MEMORY REFERENCES
**        MEMORY REFERENCE PROCESSING 
  
          PROCESS (TLD,TST,ILD,LDV) 
          SA3    A5+B1       R2 = R1 + 1
          SB5    "TXT"+3     DEFA = TXT + 3  */  MIN SEARCH ADDRESS 
          BX6    X3          R2W = [R2] 
          EQ     SMR
 DRL      SPACE  2
 .LCM     IFNE   .DAL,0 
          PROCESS (DRL,DWL) 
          LX1    -RN.TPP
          SA2    X1          R1J = TP[RJW]
          SB5    X1+3        DEFA = TP[RJW] + 3 
          SA3    A5+B1       R2 = R1 + 1
          UX6    B4,X2
          SX6    B4-OC.STT
          NZ     X6,SLD1     IF OC[R1J] " OC.STT
          SA3    A2+B1       R2 = R14 + 1  */ SUBSTITUTE R2 OF STT
          EQ     SLD1 
 .LCM     ENDIF 
 PLD      SPACE  2
          PROCESS (PLD,PST) 
          LX1    -RN.TPP
          SA3    X1+B2       DJ = RP[RJW] + 2 
          SX6    1
          LX6    D.RFP
          BX7    X6+X3       RF[DJ] = 1 
          LX1    RN.TPP 
          SA7    A3 
 SLD      SPACE  2
          PROCESS (SLD,SST,SDL,SDS) 
          SA3    A5+B1       R2 = R1 + 1
          LX1    -RN.TPP
          SB5    X1+3        DEFA = TP[RJW] + 3 
 SLD1     LX3    -IH.RFP
          BX7    -X0*X3 
          SA2    "RN"+X7     RFW = RND(RF[R2])
          BX6    X0*X3
          S"OC"  B0          OC = 0        */ INDICATE SHORT MEM REF
          SX7    X2 
          BX6    X6+X7       RF[R2] = RN[RFW] 
          LX6    IH.RFP      R2W = [R2] 
          SA6    A5+B1
          EQ     SMR
 LD       SPACE  2
          PROCESS (LD,ST) 
          SA2    A5+B1       R2 = R1 + 1
          SA3    ARFA 
          LX2    -IH.RFP
          SA1    "RN"+X2     RFW = RND(RF[R2])
          BX6    X0*X2       R2W = [R2] 
          SX7    X1          RF[R2W] = RN[RFW]
          BX3    X3*X1
          ZR     X3,LD1      IF ^(C,SA,IAC,XMT)[RFW]
          RJ     ARF         ADJUST RF,CA 
  
 LD1      BX6    X6+X7
          LX6    IH.RFP 
          SA6    A5+B1       [R2] = R2W 
          LX1    -RN.TPP
          SB5    X1+3        DEFA = TP[RFW] + 3  */ MIN SRCH ADDRESS
          ERRNZ  59-IH.LDP
          PL     X6,SMR      IF ^LD[R2W]   */ ^PREFETCH ! APL *LD*
  
          LX4    59-D.STP 
          EQ     SMR2 
 SMR      EJECT 
**        SMR - SQUEEZE MEMORY REFERENCES 
* 
*         ENTRY  (X6) = R2W , R2 WORD OF INSTRUCTION WITH *RF* ADJUSTED 
*                (B5) = DEFA, MIN SEARCH ADDRESS
*                (B3) = 0 IF A TYPE I MEM REF, ELSE *OC*
*                (A4,X4,A5,X5) AS FROM MAIN LOOP
  
 SMR      SA2    MRC
          LX4    59-D.STP 
          MX1    -IH.IHL
  
*         SEARCH *MRC* BACKWARDS FOR REF TO SAME MEMORY LOCATION
*         OR INTERFERING STORE INTO THE SAME *IH* CLASS 
*         NOTE THAT ONLY THE *IH* WORDS ARE CHECKED.
  
 SMR1     SB4    X2          I = MRC
          SA2    X2          MRC = [MRC]
          LE     B4,B5,SMR2  IF I @ DEFA   */ END OF CHAIN
          BX7    X2*X4
          SA3    A2-B2       R2M = MRC - 2
          MI     X7,SMR2     IF JP[MRC] & ST[DI]
          BX7    X3-X6
          ZR     X7,SMR7     IF [R2M] = R2W  */ REFS TO SAME MEMORY LOC 
  
*         CHECK FOR DATA INTERFERENCE 
  
          LX7    -IH.IHP
          BX3    -X1*X7 
          NZ     X3,SMR1     IF IH[R2M] " IH[R2W] 
          LX7    IH.IHP-IH.RFP
          BX7    -X0*X7 
          SA3    A3+B1
          ZR     X7,SMR1     IF RF[R2M] = RF[R2W] 
          LX3    59-D.STP 
          BX7    X3+X4
          PL     X7,SMR1     IF ^( ST[DI] ! ST[DM] )
 SMR      SPACE  2
*         LD/ST NOT REDUNDANT, ADD TO *MRC*, AND BUMP USES OF OPERANDS
  
 SMR2     SA2    MRC
          SA3    A4+B1
          LX6    -IH.RFP
          BX7    X2+X3       LINK[DI+1] = MRC 
          SA7    A3 
          SB5    X6          R = RF[R2W]
          SX7    A4+B1
          SX6    1
          SA7    A2          MRC = DI + 1  */ CHAIN POINTS TO LAST
          LX6    RN.USESP 
          ZR     B3,SMR5     IF OC = 0     */ TYPE I MEM REF
 SMR      SPACE  2,12 
*         ADVANCE USES FOR TYPE III MEM REF 
  
          SA1    "RN"+B5     RFW = RND(R) 
          IX7    X6+X1       USES[RFW] = USES[RFW] + 1
          LX1    -RN.TPP
          SA7    A1 
          LE     B5,B1,SMR3        IF R @ 1 
  
 .LCM     IFNE   .DAL,0 
          SA2    LCM#G
          BX7    X2*X4
          NZ     X7,SMR3     IF LCM = G AND L2[DI]  */ 21 BIT SUBSCRIPT 
 .LCM     ENDIF 
          SA2    X1+B2       DIP = TP[RFW] + 2
          SX3    B1 
          LX3    D.RFP
          BX7    X3+X2       RF[DIP] = 1
          SA7    A2 
  
 SMR3     MI     X4,SMR4     IF ST[DI]
  
          GT     B5,B1,MSL1  IF R > 1 
          LX4    1+D.STP
          LX6    D.ZPP-RN.USESP 
          BX7    X6+X4       ZP[DI] = 1 
          SA7    A4 
          EQ     MSL1 
  
*         ADVANCE USES FOR *RI* IN STORE INSTRUCTION
  
 SMR4     SA1    "RN"+B6
          BX3    X0*X5
          SA1    "RN"+X1     RIW = RND(RI)
          SX2    X1 
          IX7    X6+X1       USES[RIW] = USES[RIW] + 1
          SA7    A1 
          BX6    X3+X2       RI[R1] = RN[RIW] 
          SA6    A5 
          EQ     MSL1 
  
*         ADVANCE USES FOR TYPE I MEM REF 
  
 SMR5     LX5    -R1.RJP
          BX7    -X0*X5 
          SA1    "RN"+X7     RNJ = RND[RJ[R1])
          LX5    R1.RJP-R1.RKP
          IX7    X6+X1       USES[RNJ] = USES[RNJ] + 1
          SA7    A1 
          BX3    -X0*X5 
          SA1    "RN"+X3     RNK = RND(RK[R1])
          IX7    X6+X1       USES[RNK] = USES[RNK] + 1
          SA7    A1 
          PL     X4,MSL1     IF ^ST[DI] 
  
          LX5    R1.RKP 
          EQ     SMR4 
 SMR      SPACE  2,10 
*         2 MEMORY REFERENCES TO THE SAME LOCATION
  
 SMR7     SA1    A3-B1       R1M = R2M - 1
          SA3    A3+B1       DM = R2M + 1 
          SB4    OC.ILD 
          LX3    59-D.STP 
          MI     X4,SMR11    IF ST[DI]
          MI     X3,SMR9     IF ST[DM]
  
*         LD / LD - ELIMINATE THE SECOND
  
          NE     "OC",B4,SMR8      IF OC[R1] " OC.ILD 
          SA2    JPXA 
          SX6    A3 
          IX7    X6-X2
          MI     X7,SMR8     IF DM < JPXA  */ FIRST IS BEFORE LAST *JPX*
          UX7    "OC",X1
          SX6    "OC"-OC.LD 
          NZ     X6,SMR8     IF OC[R1M] " OC.LD 
  
          PX7    B4,X1       OC[R1M] = OC.ILD 
          SA7    A1 
  
 SMR8     BX7    X3*X4
          LX7    D.STP-D.PRSP 
          MI     X7,SMR10    IF PRS[DM] & PRS[DI] 
  
*         KILL THE SECOND AND OR IN THE PRECEDENCE BITS 
  
          BX7    X3+X4
 #DAL     IFNE   .DAL,0 
          MX3    -D.STRSL 
          LX3    D.STRSP+59-D.STP 
          BX6    -X3*X7 
          NZ     X6,SMR10    IF STRS[DI] ! STRS[DM] 
 #DAL     ENDIF 
          MX6    0
          LX7    1+D.STP
          SA7    A3          DM = DM ! DI 
          SA6    A4          [DI] = 0 
          SA1    "RN"+X1
          BX7    X1 
          SA7    "RN"+B6     RND(RI) = RND(RI[R1M]) 
          EQ     MSL1 
 SMR      SPACE  2,12 
*         ST / LD - CHANGE TO AN *XMT*
  
 SMR9     SA6    STLDS       STLDS = R2W   */ SET FLAG FOR *AUV*
          NE     B3,B4,SMR10 IF OC[R1] " OC.ILD 
          SA2    JPXA 
          SX6    A3 
          IX7    X6-X2
          MI     X7,SMR10    IF DM < JPXA  */ *ST* BEFORE LAST *JPX*
  
          RJ     EFS         ELIMINATE FIRST STORE
  
 SMR10    BX2    -X0*X1      RJ = RI[R1M] 
          LX4    1+D.STP
          SA1    "RN"+X2     (X1) = RND(RJ) FOR CTI 
          MX7    0
          SA7    A5+B1       [R2] = 0 
  
*         SET BIT IN *SUVA* FOR REMOVED *LD* IF CALLED FROM GPO/AUV.
  
          SA2    SUVA 
          ZR     X2,SMR10A   IF SUVA = 0   */ NOT CALL FROM *AUV* 
          LX5    -R1.INP
          SB5    X5+B1       I = IN[R1] 
          EQ     B5,B1,SMR10A      IF I = 0  */ NO *UDT* INDEX
          SA3    =XO$UDT
          SB4    X2 
          SA3    X3+B5       U2 = UDT(I+1)
          UX7    B3,X3       (B,WI) = BIT,WI)[U2] 
          SA2    B4+X3
          SX6    B1 
          LX6    B3,X6
          BX7    X6+X2       B[SUVA(WI)] = 1
          SA7    A2 
  
 SMR10A   SX2    X1          RJ = RN[RND(RJ)] 
          EQ     SRCH6             */ CHANGE *LD* TO AN *XMT* 
 SMR      SPACE  3,14 
 SMR11    MI     X3,SMR12    IF ST[DM]
  
*         LD / ST - CHECK FOR A = A 
  
          SA2    "RN"+B6
          SA2    "RN"+X2     RI = RND(RI) 
          LX2    59-RN.XMTP 
          PL     X2,SMR2     IF ^XMT[RI]
          LX2    1+RN.XMTP-RN.TPP 
          SA2    X2          R1X = TP[RND(RI)]
          LX2    -R1.RJP
          BX3    X1-X2
          BX7    -X0*X3 
          NZ     X7,SMR2     IF RJ[R1X] " RI[RIM] 
          SA7    A4          [DI] = 0   ( KILL SECOND STORE ) 
          EQ     MSL1 
  
*         ST / ST - ELIMINATE THE FIRST STORE 
  
 SMR12    RJ     EFS         ELEMINATE FIRST STORE
          EQ     SMR2 
 EFS      SPACE  3
**        EFS - ELIMINATE FIRST STORE, ADJUST *PS* BIT FOR *RI* IN ST 
* 
*         ENTRY  (X1) = RIM , R1 OF FIRST STORE 
*                (A3) = DM , DESCRIPTOR ADDR
* 
*         EXIT   (X1) = R , RI[R1M] 
*                (X6) = 0 
  
 EFS      ROUTINE 
          BX1    -X0*X1      R = RI[R1M]
          SA2    "RN"+X1     RNI = RND(R) 
          MX6    60          D = [DM] 
          SX7    B1 
          SA6    A3          [DM] = -0     */ KILL FIRST *ST* 
          ZR     X3,EFS      IF D = 0      */   ST,ILD,ILD SITUATION
          LX7    RN.USESP 
          IX7    X2-X7       USES[RNI] = USES[RNI] - 1
          SA7    A2 
          BX3    X4 
          LX3    D.STP-D.L2P
          MI     X3,EFS      IF L2[DI]     */ PS BIT NOT SET
          LX2    -RN.TPP
          SB4    X2          DEFA = TP[RNI]  */ R1 ADDR OF DEF
          SA3    STC
          SB5    X3          LINK = STC 
  
*         SEARCH *STC* TO SEE IF *RI* IS USED BY ANOTHER *ST* 
  
 EFS1     SA2    B5-B1       DL = LINK - 1
          SA3    B5          LW = [LINK]
          ZR     X2,EFS2     IF [DL] = 0   */ DEAD INSTRUCTION
          SA2    A2-B2       R1L = DL - 2 
          BX7    -X0*X2 
          SA2    "RN"+X7     RL = RN[RND(RI[R1L])]
          BX7    X2-X1
          BX2    -X0*X7 
          ZR     X2,EFS      IF RL = R     */ USED BY ANOTHER *ST*
 EFS2     LX3    -I.STCP
          SB5    X3          LINK = STC[LW] 
          GT     B5,B4,EFS1  IF LINK > DEFA 
  
          SA2    B4+B2       DIP = DEFA + 2  */ DESCR OF DEF
          SX7    B1 
          LX7    D.PSP
          BX7    -X7*X2      PS[DIP] = 0
          SA7    A2 
          EQ     EFS
 ARF      TITLE  ARF - ADJUST RF,CA OF INDEXED MEM REFERENCE
**        ARF - ADJUST RF,CA OF INDEXED MEMORY REFERENCE TO FOLD IN 
*                CONSTANT PART OF *RF*
* 
*         ENTRY  (X1) = RND(RF) 
*                (X3) = (C,SA,IAC)[RFW] 
*                (X6) = SHIFT( R2W , -IH.RFP ) AND RF[R2W] = 0
*                (X7) = RF
* 
*         EXIT   *RF* ADJUSTED AND X1,X6,X7 AS ON ENTRY 
  
 ARFA     BFMW   RN,(C,SA,IAC,XMT)
 ARFAIL   BSS    1                                                      002601
  
 ARF1     SA3    X1          R1P = TP[RFW]
          RJ     DCV         SVAL = DCV(R1P)
  
 ARF0     BX3    X7 
          AX3    17 
          NZ     X3,ARF7     IF SHIFT(SVAL,-17) " 0  */ FULL WORD CONSTANT
  
          LX6    IH.RFP-IH.CAP
          SB4    X7 
 #DAL     IFNE   .DAL,0 
          LX4    17-D.L2P 
          BX7    X4*X6
          LX4    D.L2P-17 
          MI     X7,ARF7     IF L2[DI] & IND[CA[R2]]
 #DAL     ENDIF 
          SX3    X6+B4       CAV = CA[R2] + SVAL
          MX7    -IH.CAL
          BX3    -X7*X3 
          BX7    X7*X6
          BX6    X3+X7       CA[R2] = CAV 
          LX6    IH.CAP-IH.RFP
          SA1    "RN"+X6     RFW = RND(RF[R2W]) 
          BX6    X0*X6       RF[R2W] = 0
          SA3    ARFA 
          SX7    X1+         RF = RN[RFW] 
          SB4    X7 
          BX3    X3*X1
          LE     B4,B1,ARF   IF RF .LE. 1  */ NO RF 
          NZ     X3,ARF+1    ITERATE TO REMOVE REPEATED INCREMENTS
  
 ARF      ROUTINE 
          BX2    X7                                                     002603
          MX7    0                                                      002604
          SA7    ARFAIL                                                 002605
          BX7    X2                                                     002606
          LX3    59-RN.CP 
          LX1    -RN.TPP
          MI     X3,ARF1     IF C[RFW]
          LX3    RN.CP-RN.IACP
          MI     X3,ARF3     IF IAC[RFW]
          LX3    RN.IACP-RN.XMTP
          MI     X3,ARF2     IF XMT[RFW]
  
*         RF IS RESULT OF *  SA  RI,RJ*, SUBSTITUTE *RJ*
  
          SB4    OC.STT 
          NE     "OC",B4,ARF2      IF OC[R1] " OC.STT 
          BX2    X4 
          LX2    59-D.PRSP
          PL     X2,ARF2     IF ^PRS[DI]   */ NO DEADLOCK POSSIBLE
  
          LX1    RN.TPP 
          EQ     ARF
  
 ARF2     SA3    X1          R1P = TP[RFW]
          BX6    X0*X6       RF[R2W] = 0
          LX3    -R1.RJP
          BX7    -X0*X3      RF = RJ[R1P] 
          SA1    "RN"+X7     RFW = RND(RF)
          EQ     ARF
  
*         *RF* IS *IAC*, ADD THE CONSTANT PART OF THE *RF* TO THE CA
  
 ARF3     SA3    X1          R1P = TP[R1W]
          SA1    X1+B2       DIP = R1P + 2
          LX3    -R1.RJP
          BX7    -X0*X3 
          LX1    59-D.CMP 
          SA2    "RN"+X7     RNJ = RND(RJ[R1P]) 
          LX3    R1.RJP-R1.RKP
          BX7    -X0*X3 
          SA3    "RN"+X7     RNK = RND(RK[R1P]) 
          LX2    59-RN.CP 
          PL     X2,ARF4     IF ^C[RNJ] 
  
          PL     X1,ARF7     IF ^CM[DIP]   */ IS
          SX7    X3 
          LX2    1+RN.CP-RN.TPP 
          BX6    X6+X7       RF[R2W] = RN[RNK]
          SX3    X2 
          EQ     ARF5 
  
 ARF4     LX2    1+RN.CP
          SX7    X2 
          BX6    X7+X6       RF[R2W] = RN[RNJ]
          LX3    -RN.TPP
  
 ARF5     SA3    X3          R1P = TP[RNJ]
          AX1    59          SGN = SHIFT( CM[DI] , -59 )
          RJ     DCV
          BX7    -X1-X7      SVAL = XOR( VAL[R1P] , ^SGN )
          EQ     ARF0 
  
*         CON - I CASE, LEAVE INSTRUCTION ALONE ( *LD* SQZ IN *PRE* ) 
  
 ARF7     SA3    A5+B1       R2 = R1 + 1
          LX3    -IH.RFP
          SA1    "RN"+X3     RFW = RND(RF[R2])
          BX6    X0*X3
          MX7    1                                                      002608
          SA7    ARFAIL                                                 002609
          SX7    X1          RF = RN[RFW] 
          EQ     ARF
 EDD      TITLE  EDD - ELIMINATE DEAD DEFINITIONS 
**        EDD - ELIMINATE DEAD DEFINITIONS ( USES = 0 ).
*         SCAN *TXT* BACKWARDS AND TRANSFER USES COUNTS TO DEFINITIONS. 
*         IF USES = 0 THEN MARK THE INSTRUCTION AS REDUNDANT. 
  
 EDD0     SA3    EDDA 
          BX6    X3 
          SA6    A5          RESTORE BOS
 EDD      ROUTINE 
          TRACE  EOQ,RLIST
          SA3    "TXT"
          BX6    X3 
          SA6    EDDA 
          SA4    L.TXT
          SX5    "TXT"-4
          IX4    X4+X5
          MX7    0
          SA7    "TXT"       (O.TXT) = 0
          SA5    X4          TA = TXT(L.TXT-4)  */ EOQ ADDRESS
          SB4    OC.LDC 
          SB5    59-D.^DP 
          SB6    60-IH.RFP
          MX1    -D.USESL 
          LX1    RN.USESP 
          SX2    B1 
          LX2    RN.USESP 
          EQ     EDD2 
  
*         TRANSFER USES COUNTS FROM *RND* TO INSTRUCTION DESCRIPTORS. 
  
 EDD1     LX6    D.USESP-RN.USESP 
          BX7    X4+X6       USES[DI] = USES
          SA7    A4 
  
*         SCAN *TXT* BACKWARDS FOR DEAD INSTRUCTIONS
  
 EDD2     SA4    A5-B2       DI = R1 - 2
          SA5    A4-B2       R1 = DI - 2
          ZR     X4,EDD2     IF [DI] = 0   */ DEAD INSTRUCTION
          LX6    B5,X4
          BX7    -X0*X5 
          ZR     X5,EDD0     IF [R1] = 0   */ LOOP TERMINATOR 
          MI     X6,EDD2     IF ^D[DI]     */ RI NOT A DEF
          SA3    "RN"+X7
          BX6    -X1*X3      USES = USES[RI]
          NZ     X6,EDD1     IF USES " 0
  
*         USELESS DEFINITION.  MARK IT REDUNDANT AND DECREMENT USES 
*         OF ITS OPERANDS.
  
          LX4    59-D.RJRSP 
          MI     X4,EDD2     IF RJRS[DI]   */ PRECEDES LIVE RJ RS 
          LX4    D.RJRSP-D.PRSP 
          SA6    A4 
          PL     X4,EDD2A    IF ^PRS[DI]
          SA6    A4+4        [DI+4] = 0    */ KILL FOLLOWING REG STORE
 EDD2A    LX4    1+D.PRSP+58-D.TYP [DI] = 0 
          IX7    X4+X4
          MI     X7,EDD4     IF TYPE[DI] = II 
          MI     X4,EDD3     IF TYPE[DI] = III
  
*         TYPE I
  
          LX5    -R1.RJP
          BX6    -X0*X5 
          SA3    "RN"+X6
          IX7    X3-X2       USES[RJ] = USES[RJ] - 1
          SA7    A3 
          LX5    R1.RJP-R1.RKP
          BX6    -X0*X5 
          SA3    "RN"+X6
          IX7    X3-X2       USES[RK] = USES[RK] - 1
          SA7    A3 
          EQ     EDD2 
  
*         TYPE III
  
 EDD3     UX5    "OC",X5
          EQ     "OC",B4,EDD2 IF OC = LDC 
          SA3    A5+B1       R2 = R1 + 1
          LX6    B6,X3
          SA3    "RN"+X6
          IX7    X3-X2       USES[RF] = USES[RF] - 1
          SA7    A3 
          EQ     EDD2 
  
*         TYPE II , CHECK FOR AN RJ *RS*
  
 EDD4     LX4    D.TYP+1-D.PIP
          PL     X4,EDD2     IF ^PI[DI] 
          LX5    59-R1.INP
          PL     X5,EDD2     IF IN[R1] = 0 */ NOT A *RJRS*
  
          SA3    A5-B2       DJP = R1 - 2 
          SA4    A3-B2       R1J = DJP - 2
          SX5    B1 
          LX5    D.RJRSP
          BX6    -X5*X3      RJRS[DJP] = 0
          LX4    -R1.RJP
          SA6    A3 
          BX7    X0*X4       RJ[R1J] = 0
          LX7    R1.RJP 
          SA7    A4 
          EQ     EDD2 
  
 EDDA     BSS    1
 UCT      TITLE  UCT - UPDATE CVT/CUT TABLES
**        UCT - UPDATE CUT/CVT TABLES TO ADD NEW CONSTANTS
  
 UCT      ROUTINE 
          SA1    LDCN 
          MI     X1,UCT      IF LDCN < 0   */ NO LDC"S ENCOUNTERED
  
          ALLOC  CVT,X1      ALLOC( CVT,LDCN )
          SB5    X2 
          SB7    B6          L = OLD(L.CVT) 
          SB4    OC.LDC 
          SA5    O.TXT
          SB2    B1+B1
          SA4    X5+B2       DI = TXT + 2 
          SA1    =XS$CON     (X1) = CON.
          MX0    0           SD = 0 
  
*         SCAN SEQUENCE FOR LIVE LDC"S, MOVE CONSTANT VALUE TO CVT, 
*         ADJUST IH WORD
  
 UCT1     SA4    A4+4        DI = DI + 4
          ZR     X4,UCT1     IF DI = 0     */ DEAD INSTRUCTION
          SA5    A4-B2       R1 = DI - 2
          UX7    "OC",X5
          ZR     "OC",UCT4   IF OC[R1] = 0 */ EOQ 
          NE     "OC",B4,UCT1 IF OC[R1] " OC.LDC
  
          SA3    A4+B1       LI = DI + 1
          BX0    X0+X4
          LX3    -I.CAP 
          SX7    X3          C = CA[LI] 
          NZ     X7,UCT3     IF C " 0      */ LDC NOT GENERATED BY SQZ
  
*         SEARCH CVT FOR MATCH, ENTER IN TABLE
  
          SA3    A5+B1
          BX6    X3 
          SA6    B5+B7       CVT(L) = [DI - 1]
          MX7    59          C = -1 
  
 UCT2     SX7    X7+1        C = C + 1
          SA2    B5+X7       VALM = CVT(C)
          BX6    X3-X2
          NZ     X6,UCT2
          MI     X6,UCT2     IF VAL " VALM */ NO MATCH
  
          SB3    X7 
          LT     B3,B7,UCT3  IF C < L      */ MATCHING CVT ENTRY
          SB7    B7+B1       L = L + 1
  
 UCT3     LX7    IH.CAP 
          BX6    X7+X1
          SA6    A4-1        [DI-1] = IH( 0,C,CON. )
          EQ     UCT1 
  
 UCT4     MX1    -D.STRSL 
          LX0    -D.STRSP 
          BX6    -X1*X0 
          ZR     X6,UCT5     IF STRS[SD] = 0  */ NO PS ! PRS LDC"S
          SA6    IXF
 UCT5     SX6    B7 
          SA6    L.CVT       L.CVT = L
          SX1    B7-B6       L = L - OLD(L.CVT) 
          ZR     X1,UCT      IF NO NEW ENTRIES ADDED
          ALLOC  CUT,X1      ALLOC ( CUT,L )
          SETZERO X2+B6,X1
          EQ     UCT
  
 EDI      TITLE  EDI - ELIMINATE DEAD INSTRUCTIONS
*         EDI - ELIMINATE DEAD INSTRUCTIONS ( COMPRESS *TXT* )
  
 EDI0     SX6    B6-B5
          SA6    L.TXT
 EDI      ROUTINE 
          SA1    O.TXT
          SA2    O.RND
          S"TXT" X1 
          S"RN"  X2 
          MX0    -R1.RIL
          MX7    0
          SA7    "TXT"+3     TXT(3) = 0    */ CLEAR LINK OF BOS 
          SA5    RSS
          SB2    B1+B1
          SB4    B2+B2
          MX1    -D.USESL 
          LX1    D.USESP
          SB3    -3 
          ZR     X5,EDI4     IF RSS = 0 
          SB5    "TXT"
          SA4    "RN" 
          LX4    -RN.TPP
          SB6    X4 
          SB6    B5-B6       BIAS = NEW(O.TXT)-OLD(O.TXT) 
*         MOVE THE SEPARATED REGISTER STORES NEXT TO THEIR DEFINITIONS. 
  
 EDI1     SA4    B5+X5       R1 = TXT + RSS 
          SA3    A4+B2       DI = R1 + 2;  D = [DI] 
          MX7    0
          SA7    A3          [DI] = 0 
          BX6    -X1*X3 
          LX6    R1.INP+1-D.USESP 
          BX2    -X0*X4 
          IX7    X4+X6       */ SAVE R1 OF RS & USES IN LINK WD OF DEF
          SA5    A4-B3       RSS = [RSS+3]
          SA2    "RN"+X2     RIA = O.RND + RI[R1]  */ RND WORD
          ZR     X3,EDI1A    IF D = 0      */ DEF IS DEAD 
          LX2    -RN.TPP
          SA3    X2+B6       R1P = TP[R1A] + BIAS 
          SA4    A4+B1       R2 = R1 + 1
          BX6    -X3         [R1P] = -[R1P]  */ SEP RS FLAG 
          SA6    A3 
          SA7    A6-B3       [R1P+3] = [R1] + USES[D] 
          BX6    X4 
          SA6    A2          [RIA] = [R2]  */ SAVE R2 OF RS IN *RND*
 EDI1A    SX5    X5 
          NZ     X5,EDI1     IF RSS .NE. 0
  
*         NOW MOVE THE SEQUENCE UP
  
          MX6    0
          SA6    "TXT"       [O.TXT] = 0
          MX1    -D.USESL 
          LX1    R1.INP+1 
          SA2    F.RDT+OC.RS
          SA3    L.TXT
          SB5    X3 
          SX3    "TXT"+B5 
          SB5    X3-6        TA = EOQA - 2
          SA5    X3-4 
          SB6    X3          LWA+1
          EQ     EDI3 
  
 EDI2     SA3    A4+B1       R1RS = DI + 1
          BX6    X1*X3
          BX3    -X1*X3 
          SA6    B5-B2       [TA-2] = [R1RS]
          LX3    D.USESP-R1.INP-1 
          BX7    X2+X3       D = RDT(OC.RS) ! USES[R1RS]
          ZR     X3,EDI2A    IF USES[R1RS] = 0
          SX3    B1 
          LX3    D.^DP
          BX7    -X3*X7      ^D[D] = 0
 EDI2A    BX6    -X0*X6 
          SA3    "RN"+X6     R2W = RND(RI[R1RS])
          BX5    -X5         [R1] = -[R1] 
          BX6    X3 
          SA7    B5          [TA] = D 
          SA6    B5-B1       [TA-1] = R2W 
          MX7    0
          SA7    A7+B1       [TA+1] = 0 
          SB5    B5-B4       TA = TA - 4
          EQ     EDI3A
  
 EDI3     SA4    A5-B2       DI = R1 - 2
          SA5    A4-B2       R1 = DI - 2
          ZR     X4,EDI3     IF [DI] = 0
 EDI3A    MI     X5,EDI2     IF [R1] < 0
          SA3    A5+B1       R2 = R1 + 1
          MX7    0
          SA7    B5+B1       [R1+3] = 0 
          BX6    X4 
          SA6    B5 
          LX7    X3 
          SA7    B5-B1
          BX6    X5 
          SB5    B5-B4
          SA6    A6-B2
          NZ     X5,EDI3     IF [R1] " 0
  
          SA4    EDDA 
          SB5    A6          FWA
          SX6    A6 
          SA6    O.TXT
          BX7    X4 
          SA7    B5 
          EQ     EDI0 
 EDI      EJECT 
*         DEAD INSTRUCTION ELIMINATION WHEN NO SEPARATED REG STORES.
  
 EDI4     SA4    "TXT"+B2    DI = TXT + 2 
          SB5    "TXT"+6     TA = O.TXT + 6  */ STORE ADDRESS 
  
 EDI5     SA4    A4+B4       DI = DI + 4
          SA5    A4-B2       R1 = DI - 2
          ZR     X4,EDI5     IF [DI] = 0
          SA3    A4-B1       R2 = DI - 1
          MX7    0
          BX6    X4 
          SA7    B5+B1       [R1+3] = 0 
          UX2    "OC",X5
          SA6    B5 
          BX7    X3 
          SA7    B5-B1
          LX6    X5 
          SA6    B5-B2
          SB5    B5+B4       TA = TA + 4
          NZ     "OC",EDI5   IF OC[R1] " OC.EOQ 
          SB6    A6+B4
          SB5    "TXT"
          EQ     EDI0 
 IXI      TITLE  IXI - INSERT EXTRA INSTRUCTIONS
          DESCRIBE L. 
 OC       DEFINE 12          P(OC) XMT OR RS
 STU      DEFINE 12          N. ST USES 
 RST      DEFINE 18          R-NUM IN A STORE REGISTER
 RN       DEFINE 18          GENERAL R-NUMBER 
  
**        IXI - INSERT EXTRA INSTRUCTIONS FOR *LDC* OPCODES THAT *PS* 
*         OR *S* THAT HAVE A NON-ZERO *SO* FIELD ( SEE *ECO4* CODE )
*         OR *IM*"S THAT NEED A UNPACK OF ONE OF ITS OPERANDS.
  
 PRCS     MACRO  NAM
          BSS    0
 (NAM     EQU    *-IXI1 
          ENDM
  
 IXI      ROUTINE 
          SA5    IXF
          ZR     X5,IXI      IF IXF = 0 
  
          SX7    B1 
          SB4    4
          LX7    58          N = 0
          SX0    B4 
          LX0    L.RSTP 
          SX6    B4 
          IX0    X6+X0
          SA1    O.TXT
          MX2    -R1.SOL
          LX2    R1.SOP 
          SA5    X1          R1 = O.TXT 
  
*         SCAN *TXT* FOR -
*                1) LDC INSTRUCTIONS THAT *PS* OR *PRS* TO X0, X6 OR X7 
*                2) S INSTRUCTIONS WITH *SO* " 0
*                3) IM INSTRUCTIONS WITH THE *USI* BIT SET
*                4) DEF INSTRUCTIONS WIH NON-ZERO R2 WORD 
  
 IXI1     SA5    A5+B4       R1 = R1 + 4
          SA4    A5+2        DI = R1 + 2
          UX6    "OC",X5
          SA3    SBB.JT+"OC"
          IX7    X7+X0       N = N + 4
          LX3    30 
          SA7    A4+B1       LI = DI + 1;  [LI] = LW(0,0,N,N) 
          UX6    "OC",X3
          JP     IXI1+"OC"   JUMP TO PROCESSOR
  
          PRCS   LDC
          LX4    59-D.PSP 
          MI     X4,IXI1A    IF PS[DI]
          LX4    D.PSP-D.PRSP 
          PL     X4,IXI1     IF ^PRS[DI]
          SA3    A4+2        R1RS = DI + 2
          MX5    -SO.RNL
          LX3    -R1.SOP
          BX5    -X5*X3 
          SB7    X5 
          MX5    5
          LX5    -1 
          LX5    B7,X5
          MI     X5,IXI1     IF SORN[R1RS] IS 1 - 5 
  
 IXI1A    SB7    P.XMT       PA = P.XMT    */ SET PROCESSOR ADDRESS 
  
 IXI2     PX6    B7,X7
          SX4    B4 
          LX4    L.RSTP 
          IX6    X4+X6
          SA6    A4+B1       [LI] = LW(PA,0,N+4,N)
          IX7    X7+X0       N = N + 4
          EQ     IXI1 
  
          PRCS   S
          BX3    -X2*X5 
          ZR     X3,IXI1     IF SO[R1] = 0
          SB7    P.RS        PA = P.RS
          EQ     IXI2 
  
          PRCS   DEF
          SA3    A5+B1       R2 = R1 + 1
          LX5    B1,X3
          PL     X5,IXI1     IF NOT BIT58[R2]  */ NOT BEF STORE 
          SB7    P.ST 
          PX6    B7,X7
          SA6    A4+B1       [LI] = LW(P.ST,0,N,N)
          IX7    X7+X0       N = N + 4
          LX5    1
          PL     X5,IXI1
          IX7    X7+X0       N = N + 4
          EQ     IXI1 
  
          PRCS   IM 
          LX4    59-D.USIP
          PL     X4,IXI1     IF ^USI[DI]
          IX7    X7+X0       N = N + 4
          SB7    P.IM 
          PX6    B7,X7
          SA6    A7          [LI] = LW(P.IM,0,N,N)
          EQ     IXI1 
  
          PRCS   EOQ
          SA2    L.TXT
          SX7    X7+B4       N = N + 4
          IX1    X7-X2       NX = N - L.TXT 
          ALLOC  TXT,X1      ALLOC( TXT , NX )
          SB5    X3-4        SI = L.TXT - 4  */ STORE INDEX 
          SB6    B6-4        FI = OLD(L.TXT)-4  */ FETCH INDEX
          SB7    X2+3        TB = TXT + 3 
          ZR     X1,IXI20    IF NX = 0     */ NO EXTRA INSTRUCTIONS 
          TRACE  IXI,RLIST
          SX0    RN.MASK
          MX1    D.TYL
          SB5    B7+B5       SI = TB + SI 
          SB4    59-D.STP 
  
*         MOVE THE SEQUENCE UP IN *TXT* AND INSERT THE EXTRA INSTRUCTIONS 
  
 IXI4     SA5    B7+B6       LI = TB + FI 
          UX4    B3,X5
          NZ     B3,IXI9     IF OC[LI] " 0
  
 IXI5     SA4    A5-B1       DI = LI - 1
          SA3    A4-B1
          BX2    X3                                */  R2 WORD
          BX7    X4 
          LX3    -IH.RFP
          SA7    B5-B1       [SI-1] = [DI]
          BX7    X2                                */  R2 WORD
          BX2    -X1+X4 
          ZR     X2,IXI6     IF TY[DI] = IV 
          BX6    -X0*X3 
          SA2    B7+X6       ADJ RF AND MOVE R2 WORD
          BX3    X0*X3
          SX2    X2 
          IX7    X2+X3
          LX7    IH.RFP 
  
 IXI6     SA7    A7-B1
  
          SA3    A3-B1       ADJ R1 WORD
          BX2    -X1+X4 
          ZR     X2,IXI7     IF TY[DI] = IV 
          BX5    X1*X4
          BX6    -X0*X3 
          SA2    B7+X6       LII = [TB+RI[R1]]
          BX3    X0*X3
          LX6    B4,X4
          PL     X6,IXI7     IF ^ST[DI] 
          IFNE   .DAL,0,2 
          LX6    D.STP-D.L2P
          MI     X6,IXI7     IF L2[DI]
  
          SX6    B1 
          LX6    L.STUP 
          IX6    X2+X6       STU[LII] = STU[LII] + 1
          SA6    A2 
          LX2    -L.RSTP
  
 IXI7     SX2    X2 
          BX3    X3+X2
          NZ     X5,IXI8     IF TY[DI] " I
  
          LX3    -R1.RJP
          BX6    -X0*X3 
          SA2    B7+X6
          BX3    X0*X3
          SX2    X2 
          BX3    X2+X3
          LX3    R1.RJP-R1.RKP
          BX6    -X0*X3 
          SA2    B7+X6
          BX3    X0*X3
          SX2    X2 
          BX3    X2+X3
          LX3    R1.RKP 
          LX4    59-D.RJRSP 
          PL     X4,IXI8     IF ^RJRS[DI] 
  
*         CORRECT THE VALUE OF THE *RJ* FIELD SINCE THE BACKWARD
*         PROCESSSING OF THE SEQUENCE HAS ALREADY CLEARED THE LINK WORD 
  
          BX7    -X0*X3 
          SX7    X7+4 
          LX7    R1.RJP      RJ[R1] = RI[R1] + 4
          BX3    X7+X3
  
 IXI8     BX7    X3 
          SA7    A7-B1
          MX6    0
          SA6    B5          [SI] = 0 
          SB5    B5-4        SI = SI - 4
          SB6    B6-4        FI = FI - 4
          GT     B6,IXI4     IF FI > 0
  
          TRACE  IXIX,RLIST 
          EQ     IXI
  
*         ADD AN INSTRUCTION AFTER/BEFORE THE CURRENT INSTRUCTION 
  
          PURGMAC PRCS
 PRCS     MACRO  NAM
          BSS    0
 P.NAM    EQU    *-IXI9 
          ENDM
  
 IXI9     MX7    0
          SA7    B5          [LI] = 0 
          JP     IXI9+B3
  
*         ADD AN *XMT* AFTER AN *LDC* THAT *PS* OR *PRS*                002450
  
          PRCS   XMT
          SA3    F.RDT+OC.XMT 
          SB3    OC.XMT 
          SA4    A5-B1       DI = LI - 1
          BX6    X4                                                     002470
          LX6    59-D.PSP                                               002480
          MI     X6,IXI10          IF PS[DI]                            002490
          SA2    B5+B1       R1RS = SI + 1                              002500
          SX7    4                                                      002510
          IX6    X2+X7       RI[R1RS] = RI[R1RS] + 4                    002520
          SA6    A2                                                     002530
          SX2    B1                                                     002540
          LX6    -R1.SOP-SO.LKP                                         002550
          BX6    -X7*X2      B = ^SOLK[R1RS] & 1                        002560
          LX2    D.PRSP                                                 002570
          BX3    X3+X2       PRS[DI] = 1                                002580
          BX7    X3+X6       USES[XMT] = B */ =1 IF UJP/FULL LOCK       002590
          SA7    B5-B1                                                  002600
          BX4    -X2*X4      PRS[DI] = 0                                002610
          IX6    X4-X6       USES[DI] = USES[DI] - B                    002620
          SA6    A4                                                     002630
          LX5    -L.STUP                                                002640
          EQ     IXI11                                                  002650
                                                                        002660
 IXI10    SX2    B1                                                     002670
          IX4    X4+X2       USES[DI] = USES[DI] + 1
          LX2    D.PSP
          BX3    X3+X2       PS[XMT] = 1
          BX4    -X2*X4      PS[DI] = 0 
          LX5    -L.STUP
          MX6    -D.USESL 
          BX6    -X6*X5 
          BX7    X3+X6       USES[XMT] = STU[LI]
          SA7    B5-B1
          IX6    X4-X6       USES[DI] = USES[DI] - STU[LI]
          SA6    A4 
                                                                        002690
 IXI11    MX7    0                                                      002700
          SA7    A7-B1
          LX5    L.STUP-L.RSTP
          SX6    X5 
          LX5    L.RSTP 
          SX5    X5 
          PX6    B3,X6
          LX5    R1.RJP 
          BX7    X6+X5
          SA7    A7-B1       TYI(OC.XMT,0,RN,SRN) 
          SB5    B5-4        SI = SI - 4
          EQ     IXI5 
  
*         ADD A ST TO ST. AFTER DEF ( RJ3 SQZ ) 
  
          PRCS   ST 
          SB2    A5 
          RJ     IFT         INSERT FIRST STORE 
          SA2    A5-7 
          UX2    B3,X2
          SX2    B3-OC.DEF
          NZ     X2,IXI5     IF NOT DBL PREC
          SB2    A5-4 
          RJ     IFT
          EQ     IXI5 
  
 IFT      ROUTINE 
          SA3    F$RDT+OC.ST
          SB3    OC.ST
          BX6    X3 
          SA3    B2-2 
          SA6    B5-B1       DESCR
          UX6    X3 
          SA6    A6-B1       R2W = CAIH[R2DEF]
          SA3    B2          LINK WORD OF DEF 
          BX6    -X0*X3 
          PX6    B3,X6
          SA6    A6-B1       R1W = TYIII(OC.ST,0,0,RI[R1DEF]) 
          MX6    0
          SA6    B5          CLEAR LINK OF ST 
          SA6    B2-2        R2DEF = 0
          SB5    B5-4        SI = SI - 4
          EQ     IFT
  
*         ADD AN *RS* AFTER A *S* WITH *SO* " 0 
  
          PRCS   RS 
          SA3    F.RDT+OC.RS
          SB3    OC.RS
          BX6    X3 
          SA6    B5-B1
          SA7    A6-B1
          SX6    X5 
          SA3    A5-3        R1 = LI - 3
          PX7    B3,X6
          MX6    -R1.SOL
          LX6    R1.SOP 
          BX5    -X6*X3 
          BX7    X5+X7
          SA7    A7-B1       TYII(OC.RS,0,SO,RI)
          BX6    X6*X3
          SA6    A3          CLEAR SO FIELD OF *S*
          SB5    B5-4 
          EQ     IXI5 
  
*         *IM* WITH AN UNSAFE OPERAND, ADD A *UP* BEFORE
  
          PRCS   IM 
          SA3    F.RDT+OC.IM
          SB3    OC.IM
          SA3    A5-B1       DESCR OF IM
          SX2    B1 
          LX2    D.USIP 
          BX6    -X2*X3      CLEAR USI BIT IN *IM*
          SA6    B5-B1
          SA7    A6-B1       R2 = 0 
          SX7    X5          I = RN[LI]    */ NEW RI
          SA5    A5-3        R1 = LI - 3
          LX5    -R1.RJP
          BX2    -X0*X5      J = RJ[R1] 
          LX5    R1.RJP-R1.RKP
          BX3    -X0*X5 
          SA4    B7+X2
          SA5    B7+X3
          SX4    X4          NJ = RN[TB(J)] 
          SX5    X5          NK = RN[TB(K)] 
          SX3    X7                (X3) = I 
          SA2    A4-B1       DJ = LJ - 1
          CALL   CMO
          ZR     X6,IXI12    IF J IS SAFE 
          SX2    X4          UK = NJ
          SX4    X3-4        NJ = I - 4 
          EQ     IXI13
  
 IXI12    SX2    X5          UK = NK
          SX5    X3-4        NK = I - 4 
  
 IXI13    PX6    B3,X3
          LX4    R1.RJP 
          LX5    R1.RKP 
          BX4    X4+X5
          BX6    X6+X4
          SA6    A7-B1       NEW R1 = TYI(OC.IM,I,NJ,NK)
          SB3    OC.UP
          SX5    X3-4 
          SA4    F.RDT+B3 
          MX6    0
          SA6    A6-B1       LINK WD = 0
          SX7    B1 
          BX7    X7+X4
          SA7    A6-B1             DESCR + USES 
          SA6    A7-B1       R2 =  0
          PX7    B3,X5
          LX2    R1.RKP 
          BX6    X7+X2
          SA6    A6-B1       R1 UP = TYI(OC.UP,I-4,0,UK)
          SB5    B5-8        SI = SI - 8
          SB6    B6-4        FI = FI - 4
          EQ     IXI4 
  
*         NO INSTRUCTIONS TO BE MODIFIED, CLEAR LINK WORDS
  
 IXI20    MX7    0
          SB3    B5+B7
          SB4    4
  
 IXI21    SA7    B7          [LI] = 0 
          SB7    B7+B4       LI = LI + 4
          LE     B7,B3,IXI21
          EQ     IXI
 CMO      SPACE  3,14 
**        CMO - CHECK MULTIPLY ( IM ) OPERAND TO SEE IF IT IS "SAFE"
*         SO THAT THE *IM* CAN BE MOVED FROM THE SIDE BRANCH OF A LOOP. 
* 
*         ENTRY  (A2,X2) = D, DESCRIPTOR WORD 
* 
*         EXIT   (X6) = 0 IF OPERAND IS SAFE
* 
*         USES   A2, B2, X2, X6, X7 
  
 CMO      ROUTINE 
          LX2    59-D.ZPP 
          MX6    1           CMO = 1S59    */ UNSAFE
          PL     X2,CMO      IF ^ZP[D]     */ UNKNOWN OPERAND 
          SA2    A2-2        R1 = D - 2 
          UX7    B2,X2
          MX6    0           CMO = 0
          SX7    B2-OC.LD 
          NZ     X7,CMO      IF OC[R1] " OC.LD */ FMA OR S
 .VD      IF     -DEF,VD.MATP 
          MX6    1
 .VD      ELSE
          SA2    A2+B1       R2 = R1 + 1
          SX7    X2 
          SA2    =XS$VD 
          BX6    X2-X7       CMO = IH[R2] - VD. 
 .VD      ENDIF 
          EQ     CMO
 JUMPT    EJECT 
**        OPR - DEFINE MACRO TO FORM JUMP TABLE FOR OPCODES 
  
          MACRO  OPR,NAM
          IF     -DEF,.NAM,2
          EQ     *+1S17 
          SKIP   9
*                            SBB OP CODE JUMP 
+         VFD    12/0400B,18/.NAM 
*                            IXI RELATIVE JUMP ADDRESS
          IF     DEF,(NAM,2 
          VFD    12/1S10+(NAM 
          SKIP   1
          VFD    12/1S10
*                            SBB JUMP FOR CONSTANT OPERANDS CASE
          IF     DEF,)NAM,2 
          VFD    18/)NAM
          SKIP   1
          VFD    18/.NAM
          ENDM
  
  
 SBB.JT   BSS    0
          LOC    0
*CALL     OPRDEFS 
          LOC    *O 
          LIST   -G 
  
          QUAL
 CMO      EQENT  /SQUEEZE/CMO 
  
          ECHO   2,Z=(SBB,SIE,SQZB) 
          ENTRY  ;A#
 ;A#      EQU    /SQUEEZE/;A
  
          END 
