*DECK     SQZ 
          IDENT  SQZ
 SBB      TITLE  SQZ - REDUNDANT OPERATION ELIMINATION
*CALL     SSTCALL 
          PASS2TM 
 B=SQZ    RPVDEF
  
*IF       DEF,SQZ,1 
          TRACER (INITX,EDD,SQZ.X)
          TABLES TXT,RND
  
          EXT    F.RDT,BRN,BIR
  
**        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
          ENTRY  SBB
          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 
          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           SMALL CONSTANT ( S / FMA ) 
 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    /TABLES/ 
 RNBT     BSS    2           R-NUMBER BIAS TABLE
  
 MRC      BSS    1           MEMORY REFERENCE CHAIN POINTER 
 MIC      BSS    1           MISCELLANEOUS INSTRUCTION CHAIN
 SXTC     BSS    1           SXT CHAIN
 N.CHAIN  EQU    *-MRC
 EOQA     BSS    1           ADDR OF FINAL *EOQ*
 RN.MASK  EQU    600001B
 IXF      BSS    1           "0 IF *IM* WITH *USI* BIT SET
 RSS      BSS    1           RS SEPARATION FLAG 
 STC      BSS    1           ADDRESS OF FINAL STORE ( ^L2 ) 
 JPXA     BSS    1           R1 ADDRESS OF LAST *JPX* 
          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 
          EQ     STS
          LOC    *O 
  
          QUAL
  
 STLDS    ENTRY. 0           ST/LD SQUEEZE FLAG, "0 IF ST/LD SQZ DONE 
 SUVA     ENTRY. 0           SQUEEZED USE *BV* ADDR ( *AUV* CALL )
  
          ENTRY  SIE,SQZB 
 SIE      EQU    /SQUEEZE/SIE 
 SQZB     EQU    /SQUEEZE/SQZB
  
          QUAL   SQUEEZE
 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 PROSEQ. 
* 
*         ENTRY  (BRN) = BASE,LIMIT R-NUMBERS IN SEQUENCE 
*                (BIR) = BASE LIMIT INTERMEDIATE R-NUMBERS IN SEQUENCE. 
 SBB      ROUTINE 
          SA1    BRN
          SA3    BIR
          SA2    A1+B1
          SA4    A3+B1
          IX2    X2-X1       DEL(R) = BRN(2) - BRN(1) 
          SX0    B1+B1
          IX4    X4-X3       DEL(IR) = BIR(2) - BIR(1)
          IX7    X2+X4
          IX6    X0-X1
          IX1    X7+X0
          IX7    X0-X3
          SA6    RNBT        RNBT(0) = 2 - BRN(1) 
          IX7    X2+X7
          SA7    A6+B1       RNBT(1) = 2 + DEL(R) - BIR(1)
          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 
 SBB      SPACE  3           SBB
**        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
  
          SB5    R1.RIL-1 
          SB6    RNBT 
          SB2    B1+B1
          MX0    -R1.RIL     (X0) = MASK FOR EXTRACTING R-NUMBERS 
          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
 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 A *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] 
          IFNE   .DAL,0,2                                        LVL 2
          LX4    D.STP-D.L2P
          MI     X4,SBB8     IF L2[DI]
          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     SX6    A5 
          SA6    EOQA        EOQA = R1     */ SAVE *EOQ* ADDRESS
          LX7    -I.STCP     STC = LINK    */ ADDRESS OF 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    1
          LX6    1+RN.ZP
          SX4    B1 
          BX6    X5+X6
          IX7    X5+X4
          LX4    RN.USESP+3 
          BX6    X4+X6
          SA6    "RN"        RND(0) = RNDT(Z,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 
          TRACE  INITX,RLIST
          EQ     MSL1 
 EOQ      SPACE  3
*         EOQ - END OF REDUCTION PHASE
  
          PROCESS EOQ 
          RJ     EDD         XFER USES COUNTS, MARK DEAD DEFINITIONS
          TRACE  EDD,RLIST
          RJ     EDI         COMPRESS SEQUENCE
          TRACE  SQZ.X,RLIST
  
          SA2    BIAS 
          SA0    B5+
          CALL   RNI         RENUMBER THE INSTRUCTIONS
          SX6    0
          SA6    L.RND       L.RND = 0
          RJ     IXI         INSERT EXTRA INSTRUCTIONS
          EQ     SBB         RETURN 
 MSL      TITLE  MASTER SQUEEZE LOOP
**        MSL - MASTER SQUEEZE LOOP 
*         REPLACE INSTRUCTIONS WHOSE RESULTS ARE KNOWN WITH SIMPLER 
*         INSTRUCTIONS, OR ELIMINATE REDUNDANT INSTRUCTIONS 
*         MOST OF THE SPECIAL CASING HERE CENTERS ABOUT REDUCING
*         INSTRUCTIONS WHOSE OPERANDS ARE ZERO.  THIS IS NECESSARY
*         BECAUSE IN PASS 1, *ARITH* OUTPUTS MIXED MODE COMPUTATIONS AS 
*         (REAL,0) OP COMPLEX , ETC.
  
  
 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
          SA7    A5+0        [R1] = TYI(OC,RJ,RK,RI)
  
**        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     BX3    -X0*X5 
          SB6    X3          (B6) = RI
          JP     SBB.JT+"OC" JUMP( SBB.JT(OC[R1]) ) 
 SXT      TITLE  MASTER SQUEEZE LOOP - TYPE I INSTRUCTIONS
**        SPECIAL PROCESSING OF TYPE I INSTRUCTIONS 
  
          PROCESS SXT        CONSTANT SHIFT PREDECESSOR 
          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
          SX3    X6 
          BX7    X6-X3
          NZ     X7,SXT0     IF VAL " SXIXJ(VAL)
  
          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 
  
          PROCESS (KLS,KRS)  NON REDUNDANT CON SHIFT
          SA2    A5+B1       R2 = R1 + 1
          SX3    B1 
          LX2    -IH.RFP
          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*
  
 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 
  
 XMTC     PROCESS XMTC
          BX6    X1 
          LX6    59-RN.CP 
          MI     X6,XMTC1    IF C[RJ] 
          LX6    RN.CP-RN.XMTCP 
          PL     X6,XMTC2    IF ^XMTC[RJ] 
  
          LX1    -RN.TPP
          SA2    X1          R1P = R1[TP[RJ]] 
          LX2    -R1.RJP
          BX6    -X0*X2 
          SA1    "RN"+X6
          LX6    R1.RJP 
          EQ     XMT0 
  
 XMTC1    LX1    -RN.TPP
          SA3    X1          R1J = TP[RJ] 
          RJ     DCV         VAL = DCV(R1J) 
          BX6    -X7         VAL = -VAL 
          MI     X6,CCV      IF VAL < 0 
          SX3    X6 
          BX7    X6-X3
          NZ     X7,XMTC2    IF SETX(VAL) " VAL 
          ZR     B5,CCV      IF OC[RJ] = OC.S 
          LX1    RN.TPP 
          SA3    "RN"+B6
          BX7    -X0*X1 
          SX2    B1 
          SA7    A5+B1       [R2] = RJ[R1J]  */ POINT TO RJ FOR *AND* 
          LX2    RN.FMAP
          BX7    X2+X3       FMA[RI] = 1
          SA7    A3 
          LX6    R1.INP 
          S"OC"  OC.S 
          RJ     URI         URI(  S  RI,VAL )
          EQ     FMA
  
 XMTC2    SA2    "RN"+B6
          SX6    B1 
          LX6    RN.XMTCP 
          BX7    X6+X2       XMTC[RI] = 1 
          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.CP
          PL     X6,AND3     IF ^( C[RJ] ! C[RK] )
          BX7    X1*X2
          LX7    59-RN.CP 
          MI     X7,ECO      IF C[RJ] & C[RK] 
  
*         SEE IF CON IS A *FMA* CHANGED TO A *S*
*         IF SO, THEN CHANGE TO STR( FMA , RK ) 
  
          BX7    X6 
          LX7    RN.CP-RN.FMAP
          PL     X7,AND3     IF ^(FMA[RJ] ! FMA[RK] ) 
  
          BX6    X1 
          LX6    59-RN.FMAP 
          MI     X6,AND2     IF FMA[RJ] 
          BX1    X2 
          LX6    1+RN.FMAP   SWAP( RJ , RK )
          BX2    X6 
  
 AND2     LX1    -RN.TPP
          BX2    -X0*X2 
          SA1    X1+B1       RJ = [TP[RJ]+1]  */ R2 OF *S*
          LX2    R1.RKP 
          S"OC"  OC.STR 
          LX1    R1.RJP 
          BX6    X1+X2
          EQ     CAO2 
  
 AND3     LX6    RN.CP-RN.XMTCP 
          PL     X6,SRCH     IF ^XMTC[RJ] & ^XMTC[RK] 
          S"OC"  OC.STR 
          SB5    R1.RJP 
          EQ     CAO
 DFM      EJECT 
          PROCESS IM
          BX6    X4 
          LX6    59-D.USIP
          PL     X6,DFM      IF ^USI[DI]
          SX6    B1 
          SA6    IXF         IXF = 1
  
 DFM      PROCESS DFM 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,ZERO     IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.CP
          PL     X6,SRCH     IF ^( C[RJ] ! C[RK] )
          BX7    X1*X2
          LX7    59-RN.CP 
          PL     X7,DFM1     IF ^( C[RJ] & C[RK] )
  
          S"OC"  OC.DFM 
          EQ     ECO
  
 DFM1     BX7    X1 
          LX7    59-RN.CP 
          MI     X7,DFM2     IF C[RJ] 
          BX1    X2 
          LX7    1+RN.CP
          BX2    X7 
  
 DFM2     LX1    -RN.TPP
          SA3    X1 
          RJ     DCV         VAL = VAL[RJ/RK] 
          MX6    59 
          IX3    X7-X6
          ZR     X7,ZERO     IF VAL = -0
          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 
          EQ     B4,B2,DFM3  IF VAL = 2 
          EQ     B4,B1,XMT0  IF VAL = 1 
          S"OC"  OC.XMTC
          RJ     URI         URI(  XMTC  RI,RJ )
          EQ     XMTC 
  
 DFM3     BX7    X6 
          LX7    R1.RKP-R1.RJP
          IX6    X6+X7
          S"OC"  OC.IA
          RJ     URI
          EQ     SRCH 
 FM       SPACE  3,7
          PROCESS (FM,RFM)
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,ZERO     IF Z[RJ] ! Z[RK] 
          EQ     SRCH 
  
          PROCESS (FD,RFD)
          LX1    59-RN.ZP 
          MI     X1,ZERO     IF Z[RJ] 
          LX1    RN.ZP-RN.PZP 
          MI     X1,ZERO     IF PZ[RJ]
          EQ     SRCH 
  
          PROCESS OR
          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 
          BX6    X1+X2
          LX6    59-RN.ZP 
          MI     X6,C.XMT    IF Z[RJ] ! Z[RK] 
          LX6    RN.ZP-RN.XMTCP 
          PL     X6,SRCH
          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,ZERO     IF Z[RJ] & Z[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
 IA0      RJ     GCV         GET CONSTANT VALUES
          IX6    X6+X7       VAL[RI] = VAL[RJ] + VAL[RK]
          EQ     CCV
  
          PROCESS IA
          BX7    X1*X2
          LX7    59-RN.CP 
          MI     X7,IA0      IF C[RJ] & C[RK] 
          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 
          BX7    X1*X2
          LX7    59-RN.CP 
          MI     X7,IA0      IF C[RJ] & C[RK] 
          MX7    2
          BX6    X1+X2       RJK = RJ ! RK
          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.CP 
          MI     X6,ECO      IF C[RJ] & C[RK] 
          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 ) 
          BX6    X1*X2
          LX6    59-RN.ZP 
          IX7    X1-X2
          MI     X6,FMA60    IF Z[RJ] & Z[RK] 
          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 
          BX7    X1*X2
          LX7    59-RN.CP 
          MI     X7,ECO      IF C[RJ] & C[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
  
 IS0      RJ     GCV         GET CONSTANT VALUES
          IX6    X6-X7       VAL[RI] = VAL[RJ] - VAL[RK]
          EQ     CCV
  
          PROCESS IS
          BX6    X1-X2
          SB4    X6 
          ZR     B4,ZERO     IF RN[RJ] = RN[RK] 
          BX7    X1*X2
          LX7    59-RN.CP 
          MI     X7,IS0      IF C[RJ] & C[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
*         ISZ - ADD 0 AND CHANGE SIGN PRIOR TO USE IN CONDITIONAL JUMP
*         THE RJ OPERAND IS ASSUMED TO BE A *CLR  RJ,0* IN THE BELOW. 
  
          PROCESS ISZ 
          BX6    X1*X2
          LX6    59-RN.CP 
          MI     X6,IS0      IF C[RJ] & C[RK] 
  
*         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 
          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)
          LX1    59-RN.ZP 
          PL     X1,NR1      IF ^Z[RJ]
          BX3    X2 
          LX3    59-RN.ZP 
          MI     X3,ZERO     IF Z[RK] 
          LX3    RN.ZP-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
          LX2    59-RN.ZP 
          MI     X2,ZERO     IF Z[RK] 
          LX2    1+RN.ZP-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] )
          BX7    X1*X2
          LX7    59-RN.CP 
          PL     X7,ILS1     IF ^( C[RJ] & C[RK] )
  
          RJ     GCV         GET CONSTANT VALUES
          SB4    X6 
          LX6    B4,X7
          ZR     B3,CCV      VAL[RI] = SHIFT( VAL[RJ] , VAL[RK] ) 
          AX6    B4,X7
          EQ     CCV
  
 ILS1     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) 
          BX6    X1+X2
          SB3    B3-OC.ILS
          LX6    59-RN.CP 
          PL     X6,IRCH     IF ^( C[RJ] ! C[RK] )
          BX7    X1*X2
          LX7    59-RN.CP 
          PL     X7,ILS1     IF ^( C[RJ] & C[RK] )
  
          RJ     GCV         GET CONSTANT VALUES
          SB4    X6 
          LX6    B4,X7
          ZR     B3,ICV      VAL[RI] = SHIFT( VAL[RJ] , VAL[RK] ) 
          AX6    B4,X7
          EQ     ICV
  
 ILS1     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
**        ICV - TEMPORARY CCV FOR ILS/IRS 
*         FAIL EXIT IS IRCH RATHER THAN SRCH. 
*         ENTRY  (X6) = VAL , TO BE REFORMED AS *S*/*FMA* INSTRUCTION 
  
*         TRY TO REDUCE CONSTANT TO A *FMA* 
  
 ICV      PL     X6,ICV1     IF VAL > 0 
          CX7    X6 
          MX3    1
          SB4    X7-1 
          AX7    B4,X3
          BX3    X7-X6
          NZ     X3,ICV1     IF VAL " MASK( COUNT(VAL) )
          S"OC"  OC.FMA 
          SX6    B4+B1
          EQ     ICV2 
  
*         TRY TO REDUCE CONSTANT TO A *S* 
  
 ICV1     ZR     X6,ZERO     IF VAL = 0 
          MX3    42 
          LX7    X6 
          BX6    -X3*X6 
          AX7    17 
          NZ     X7,IRCH     IF SHIFT(VAL,-17) " 0
          S"OC"  OC.S 
  
 ICV2     LX6    R1.INP 
          RJ     URI
          MX7    0
          SA7    A5+B1       [R1+1] = 0 
          EQ     FMA
          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
  
          SB3    A5-8        R1J = R1 - 8 
          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.L2P
          MI     X7,CTI3     IF L2[DJ]
 #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
          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] 
 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 
 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 
  
          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
          LX2    59-RN.ZP 
          PL     X2,SRCH     IF ^Z[RK]
  
          BX6    X1 
          LX1    -RN.TPP
          SA2    X1+B2       DJP = TP[RJ] + 2 
          SB3    X1+3        DEFA = TP[RJ] + 3
          SB5    SA.JT
          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]
  
          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
 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
 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    -36
          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      EJECT 
**        URI - UPDATE REDUCED INSTRUCTION
*         UPDATES CORE IMAGE AND REGISTERS OF A CHANGED TYPE I/II INST
* 
 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 
*         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 - EVALUATE INSTRUCTION WITH CONSTANT OPERANDS 
* 
*         ENTRY  (B3) = INSTRUCTION OPCODE ( = MACHINE OPCODE ) 
  
 ECO      SA3    ECOA 
          SX6    "OC" 
          LX6    54 
          BX7    X6+X3
          SA7    ECO1 
          RJ     GCV         GET CONSTANT VALUES ( ALSO FLUSH STACK ) 
          SB4    20B
          LT     B3,B4,ECO1  IF OC[R1] < 20B   */ BOOLEAN INSTRUCTION 
          OR     X6,SRCH     IF ^RANGE(VAL[RJ]) 
          ID     X6,SRCH     IF INDEF(VAL[RJ])
          OR     X7,SRCH     IF ^RANGE(VAL[RK]) 
          ID     X7,SRCH     IF INDEF(VAL[RK])
 ECO1     FX6    X6+X7       VAL = VAL[RJ] .OP. VAL[RK] 
          LT     B3,B4,CCV   IF OC[R1] < 20B
  
+         OR     X6,SRCH     IF ^RANGE(VAL) 
          ID     X6,SRCH     IF INDEF(VAL)
          EQ     CCV
  
 ECOA     VFD    6/00B,9/667B 
          LT     B3,B4,CCV
          NO
 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* OR *FMA* INSTRUCTION 
* 
*         EXIT   (X7) = VALUE OF CONSTANT 
*                (B5) = 0 IF OC = OC.S
  
 DCV      ROUTINE 
          UX3    B4,X3
          SB5    B4-OC.S
          LX3    -R1.INP
          SX7    X3          VAL = IN[R1] 
          ZR     B5,DCV      IF OC[R1] = OC.S 
          SB4    X3-1                      */ ASSUME A *FMA*
          MX3    1
          AX7    B4,X3       VAL = MASK(IN[R1]) 
          PL     B4,DCV      IF IN[R1] \ 1
          MX7    0           VAL = 0
          EQ     DCV
 CCV      SPACE  3
**        CCV - CONVERT CONSTANT VALUE
* 
*         ENTRY  (X6) = VAL , TO BE REFORMED AS *S*/*FMA* INSTRUCTION 
*                (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 
          MX3    42 
          LX7    X6 
          BX6    -X3*X6 
          AX7    17 
          NZ     X7,SRCH     IF SHIFT(VAL,-17) " 0
          S"OC"  OC.S        OC = OC.S
  
 CCV2     LX6    R1.INP 
          RJ     URI         URI( OC  VAL,RI )
          MX7    0
          SA7    A5+B1       [R1+1] = 0 
          EQ     FMA
 BTERM    EJECT 
*         BOS - BEGINNING OF STMT MARKER
  
          PROCESS BOS 
          LX5    -R1.INP
          SX6    X5 
          SA6    =XLINENR    LINENR = 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    36 
          BX7    X3+X2       RSL[TP[RI]+3] = R1 
          SA7    A2                        */ LINK DEF TO *RS*
          ZR     X6,RS1      IF RI DIDN"T CHANGE
  
          SA2    RSS
          BX6    X2 
          SA6    A4+B1       [DI+1] = RSS ( ADD TO CHAIN OF SEPARATED 
          SX7    A4+B1                      REGISTER STORES ) 
          SA7    A2          RSS = DI + 1 
  
*         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 
          EQ     AUC.RJ 
 BTERM    EJECT 
*         BLOCK TERMINATORS 
  
          PROCESS (UJP,RJ3,RJ6,LAB,ENT) 
          CLEAR              CLEAR LINKED LISTS 
          EQ     MSL1 
  
          PROCESS JIN 
          CLEAR              CLEAR LINKED LISTS 
          SA1    "RN"+B6
          LX1    59-RN.ZP 
          PL     X1,.JPX     IF ^Z[RI]
          BX6    X0*X5       RI[R1] = 0 
          SA6    A5 
          EQ     MSL1 
  
*         CONDITIONAL JUMPS 
  
          PROCESS JPX 
          SA1    "RN"+B6
          BX6    X0*X5
          SA2    MRC
          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
  
 JPX1     IX6    X6+X5
          LX5    R1.RJP 
          SA6    A5 
          SX7    A5          JPXA = R1
          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 
 .PLI     IFNE   .PLI,0                                          ?PL/I
  
          PROCESS RJXJ
          SA3    A5+B1       R2 = R1 + 1
          SA1    "RN"+X5     RIW = RND(RI[R1])
          BX5    X0*X5
          LX3    -IH.RFP
          SA2    "RN"+X3     RFW = RND(RF[R2])
          BX3    X0*X3
          SX6    X1 
          SX7    X2 
          IX6    X5+X6       RI[R1] = RN[RIW] 
          SA6    A5 
          BX7    X3+X7       RF[R2] = RN[RFW] 
          LX7    IH.RFP 
          SA7    A3 
  
          SX3    B1 
          LX3    RN.USESP 
          IX6    X1+X3       USES[RIW] = USES[RIW] + 1
          SA6    A1 
          SA2    A2 
          IX7    X2+X3       USES[RFW] = USES[RFW] + 1
          SA7    A2 
          EQ     MSL1 
  
 .PLI     ENDIF                                                  'PL/I
 SMR      TITLE  SMR - SQUEEZE MEMORY REFERENCES
**        MEMORY REFERENCE PROCESSING 
  
          PROCESS (TLD,TST,ILD) 
          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 
  
          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)
  
 ARF1     SA3    X1          R1P = TP[RFW]
          RJ     DCV         GET CONSTANT VALUE 
  
 ARF0     LX6    IH.RFP-IH.CAP
          SB4    X7 
          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
          SX7    X1+         RF = RN[RFW] 
  
 ARF      ROUTINE 
          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
          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 
          SA3    "TXT"
          MX7    0
          BX6    X3 
          SA6    EDDA 
          SA4    EOQA 
          SA7    "TXT"       (O.TXT) = 0
          SA5    X4          TA = EOQA
          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     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
 EDI      TITLE  EDI - ELIMINATE DEAD INSTRUCTIONS
*         EDI - ELIMINATE DEAD INSTRUCTIONS ( COMPRESS *TXT* )
  
 EDI0     SX6    B6-B5
          SA6    L.TXT
 EDI      ROUTINE 
          SA5    RSS
          SB4    B2+B2
          MX1    -D.USESL 
          LX1    D.USESP
          SB3    -3 
          ZR     X5,EDI4     IF RSS = 0 
  
*         MOVE THE SEPARATED REGISTER STORES NEXT TO THEIR DEFINITIONS. 
  
 EDI1     SA4    X5+B3       R1 = [RSS-3] 
          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    X5          RSS = [RSS]
          SA2    "RN"+X2     RIA = O.RND + RI[R1]  */ RND WORD
          ZR     X3,EDI1A    IF D = 0      */ DEF IS DEAD 
          LX2    -RN.TPP
          SA3    X2          R1P = TP[RIA]
          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    NZ     X5,EDI1     IF RSS " 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    EOQA 
          SB5    X3-2        TA = EOQA - 2
          SA5    X3 
          SB6    X3+B4       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)   IM OR 0
          DEFINE 30 
 RN       DEFINE 18          GENERAL R-NUMBER 
**        IXI - INSERT EXTRA INSTRUCTIONS OF  *IM* OPCODES THAT HAVE A OPERAND
*         THAT MAY BE INDEFINITE ( NEEDS TO BE UNPACKED ) 
  
 IXI      ROUTINE 
          SA5    IXF
          ZR     X5,IXI      IF IXF = 0 
          SA2    O.TXT
          SB5    OC.IM
          SB4    4
          MX1    0           NC = 0 
          SX7    B0          N = 0
          SB6    59-D.USIP
          SA5    X2          R1 = O.TXT 
          SA7    X2+3 
          TRACE  IXI,RLIST
  
 IXI1     SA5    A5+B4       R1 = R1 + 4
          SX7    X7+B4       N = N + 4
          SA7    A5+3 
          UX6    "OC",X5
          ZR     "OC",IXI3   IF OC[R1] = 0
          NE     "OC",B5,IXI1      IF OC[R1] " OC.IM
          SA4    A7-B1       DI = LI - 1
          LX3    B6,X4
          PL     X3,IXI1     IF ^USI[DI]
  
*         UNSAFE *IM*, MARK LINK WORD 
  
          SX1    X1+B4       NC = NC + 4
          SX7    X7+B4       N = N + 4
          PX6    "OC",X7
          SA6    A7          [LI] = PACK(OC,N)
          EQ     IXI1 
  
*         NO INSTRUCTIONS TO BE MODIFIED, CLEAR LINK WORDS
  
 IXI20    MX7    0
          SB2    X2 
          SB3    A5 
 IXI21    SA7    B2+3 
          SB2    B2+4 
          LE     B2,B3,IXI21
          EQ     IXI
  
 IXI3     ZR     X1,IXI20    IF NC = 0     */ NO EXTRA INSTRUCTIONS NEEDED
          ALLOC  TXT,X1      ALLOC( TXT , NC )
          SX0    RN.MASK
          SB7    X2+3        TB = TXT + 3 
          SB6    B6-4        FI = OLD(L.TXT)-4  */ FETCH INDEX
          SB5    X3-4        SI = L.TXT - 4 
          MX1    D.TYL
          SB5    B7+B5
          SB4    OC.IM
  
*         MOVE THE SEQUENCE UP IN *TXT* AND INSERT EXTRA INSTRUCTIONS 
  
 IXI4     SA5    B7+B6       LI = TB + FI 
          UX4    B3,X5
          EQ     B3,B4,IXI9 
  
 IXI5     SA4    A5-B1       DI = LI - 1
          SA3    A4-B1
          BX7    X4 
          LX3    -IH.RFP
          SA7    B5-B1       [SI-1] = [DI]
          BX6    -X0*X3 
          SA2    B7+X6       ADJ RF AND MOVE R2 WORD
          BX3    X0*X3
          SX2    X2 
          IX7    X2+X3
          LX7    IH.RFP 
          SA7    A7-B1
  
          SA3    A3-B1       ADJ R1 WORD
          BX2    -X1+X4 
          ZR     X2,IXI8     IF TY[DI] = IV 
          BX5    X1*X4
          BX6    -X0*X3 
          SA2    B7+X6       LII = [TB+RI[R1]]
          BX3    X0*X3
          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] 
  
          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
  
 IXI9     SA3    F.RDT+B3 
          MX7    0
          SA7    B5          [SI] = 0 
  
          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 
 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) = :, DESCRIPTOR WORD 
*         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
          SA2    A2+B1       R2 = R1 + 1
          SX7    X2 
          SA2    =XVD.
          BX6    X2-X7       CMO = IH[R2] - VD. 
          EQ     CMO
 JUMPT    SPACE  2
**        OPR - DEFINE MACRO TO FORM JUMP TABLE FOR OPCODES 
  
          MACRO  OPR,NAM
          IF     DEF,.NAM,2 
          EQ     .NAM 
          ELSE   1
          EQ     SBB+4S15 
          ENDM
  
 SBB.JT   BSS    0
          LOC    0
*CALL     OPRDEFS 
          LOC    *O 
          LIST   -G 
  
          QUAL
 CMO      EQENT  /SQUEEZE/CMO 
 SBB      EQU    /SQUEEZE/SBB 
          END 
