*DECK     GPO 
          IDENT  GPO
 GPO      TITLE  GPO - GLOBAL PROGRAM OPTIMIZATION
*CALL     SSTCALL 
 B=GPO    RPVDEF
          PASS2TM 
  
*IF       DEF,GPO,2 
          TRACER (GPO,FUD,RDD,AUV,MIP,FXI,SHB,MPB)
          TRACER (CIF,FIM)
 GPO      SPACE  2
**        GPO - GLOBAL PROGRAM OPTIMIZATION 
* 
*         S. I. JASIK - CDC - SUNNYVALE - WINTER 73 
* 
*         ON ENTRY TO *GPO* THE FIRST PASS OF FIVE HAS BEEN PERFORMED 
*         BY *PRE*.  IT CONSISTS OF SUBDIVIDING THE INTERMEDIATE *TEXT* 
*         INTO BASIC BLOCKS AND WRITING THEM TO A RANDOM FILE,
*         COLLECTING CONTROL FLOW INFORMATION, AND BUILDING A DICTIONARY
*         OF REFERENCED VARIABLES FOR USE/DEFINITION ANALYSIS.
*         IN THE INITIALIZATION OF *GPO* THE USE/DEF DICTIONARY IS
*         RESOLVED AND THE CONTROL FLOW INFORMATION PROCESSED TO FIND 
*         LOOPS, ETC. 
*           PASS 2 READS THE RANDOM FILE SEQUENTIALLY TO FORM THE 
*         USE/DEF BIT VECTORS FOR EACH BLOCK, AND THEN PROCESS"S THEM 
*         TO FORM THE *LIVE EXIT* VECTORS, WHICH ARE USED TO ELEMINATE
*         DEAD DEFINITIONS AND TO DETERMINE ENTRY/EXIT CONDITIONS 
*         DURING REGISTER ASSIGNMENT. 
*           PASS 3  PROCESSES THE PROGRAM LOOPS IN AN INNER TO OUTER
*         ORDER, MOVING OUT INVARIANT AND STRENGTH REDUCABLE CODE,
*         ASSIGNING REGISTERS ACCROSS THE LOOP AND PROPAGATING THE
*         ENTRY/EXIT CONDITIONS OUT.  FINALLY THE REMAINING STRAIGHT
*         LINE CODE IS PROCESSED AS A SERIES OF EXTENDED BASIC BLOCKS 
*         AND CODED.
*           PASS 4  REORDERS THE CODED BLOCKS TO BRING THEM BACK TO 
*         SOURCE PROGRAM ORDER, ASSIGNS ADDRESS"S, AND PACKS THE
*         COMPILER CREATED TEMPORARIES. 
*           PASS 5  IS THE ASSEMBLY PASS. 
  
**        DEBUGGING SNAP LABELS - 
* 
*         TRACER (GPO,FUD,RDD,MII,FII,MIP,FXI,MIE,SHB,DIF,EIE,MPB)
          SPACE  3
 OF.MP    EQU    3           *MATERIALIZE* BIT IN *FLG* FIELD OF WORD B 
*                            OF LOOP GENERATED LABELS ( *XX* ) .
  
          LIST   -R,X 
  
          TABLES BLK,TXT,GST,UDI,TET,PIT
          TABLES BST,IIT,MLT,MOD,RND,PSI,RXI
  
*CALL     CFTBLD
*CALL     IOTBLD
*CALL     UDTBLD
*CALL     GPOCOM
 FLAGS    TITLE  VARIABLES
*         GLOBAL FLAGS
  
          ENTRY  DMASK,O.UDT
 DMASK    BFMW   D,(STRS,USES)     FIELD CLEAR MASK 
  
*                        PRE
 N.GL0    ENTRY. =XN.GL      NEXT AVAIL GL-1 FOR MULT PRED LOOPS
*                        AUT
          USE    /BVINFO/ 
 VL       BSS    1           BIT VECTOR LENGTH
 N.VAR    ENTRY. 0           N. VARS IN *UDT* 
 BVL      ENTRY. 0           VL - 1 
 RCV      BSSZ   1           =1 IF *UDT* CONTAINS COMMON VARIABLES
          USE    0
*                        DGS
 CBN      ENTRY. 2           CURRENT BLOCK NUMBER 
 NPB      ENTRY. 3           N.PROGRAM BLOCKS 
 M.GRL    ENTRY. 0           MAX GRAPH LENGTH 
 N.DG     ENTRY. 0           N.DERIVED GRAPHS ( MAX LOOP NESTING LEVEL )
 GIC      ENTRY. 0           GRAPHS IN CORE FLAG , =0 IF INCORE 
 O.IST    ENTRY. =XPRE       FWA OF GRAPH STRUCTURE TABLES AFTER MOVE DO
 M.LP     ENTRY. 0           MAX N.LOOPS IN A GRAPH 
 N.FTH    ENTRY. 0           N. FTH LOOPS 
  
*                        GPO
 M.BBL    ENTRY. 60B         MAX BASIC BLOCK LENGTH 
 M.EBL    ENTRY. 0           MAX EXTENDED BLOCK LENGTH
 N.GT     ENTRY. 0           N. GLOBAL TEMPS ( IT."S )
 O.BIT    ENTRY. O.UDB       FWA OF BLOCK INDEX TABLE 
 L.BIT    ENTRY. 8           LENGTH 
 O.BVT    ENTRY. 0           FWA OF BIT VECTOR TABLE
 L.BVT    ENTRY. 0           LENGTH 
 L.SBV    BSS    1           LENGTH OF SPECIAL BIT VECTORS
 L.PTXT   ENTRY. 0           LENGTH OF *FTNOPT* AT START OF *GPO* 
 O.LCT    ENTRY. 0           FWA OF LABEL CHANGE TABLE
 L.LCT    ENTRY. 0           LENGTH  ( SET IN *CFA* ) 
 O.ELT    ENTRY. 0           ORIGIN OF ELIMINATED LABEL DEF TABLE 
 L.ELT    ENTRY. 0           LENGTH      24/,18/IH PROG LAB,18/H OF GL
*                        PCC
 O.SEQ    ENTRY. 0           FWA OF BLOCK BEING PROCESSED 
 L.SEQ    ENTRY. 0           LEN OF BLOCK BEING PROCESSED 
 BN       ENTRY. 0           *BIT* INDEX OF BLOCK NUMBER
 BSI      ENTRY. 0           *BST* INDEX
 BSW      ENTRY. 0           WORD 2 OF *BST* FOR CURRENT BLOCK
*                        SHB
 L.HB     ENTRY.             LENGTH OF HOLDING BLOCK
  
*         INTERVAL STRUCTURE TABLE POINTERS 
  
 O.BTT    BSS    1           FWA OF BLOCK TRANSITION TABLE
 O.HNT    BSS    1           FWA HEADER NODE TABLE
 L.HNT    BSS    1           LWA+1 OF *HNT* 
*                        IGP
 GP       VFD    42/,18/=XPRE      GRAPH POINTER
 EIT      BSS    1           EDGE INDEX TABLE ADDRESS 
 N.LP     BSS    1           N. UNPROCESSED LOOPS IN CURRENT GRAPH
 IBA      VFD    42/,18/COLA+1,60/1  INTERVAL BASE ADDR ( HEADER NODE ) 
 NN       EQU    IBA+1       N. NODES IN INTERVAL 
  
 BBV      CON    0           BUILD BIT VECTOR FLAG FOR *FUD*
*                            =0 IF TO FORM BIT VECTORS. 
 FLAGS    EJECT 
 NBIP     ENTRY. 0           "0 IF LOOP CONTAINS NON-BASE *IP*S 
  
*         LOCAL VARIABLES 
  
 HBI      ENTRY. 0           BN OF HOLDING BLOCK, 0 IF OUTSIDE ALL LPS
          BSS    1           R1 OF HEADER, 12/P(OC.BOS),18/LINE,30/BN 
 MRA.X    BSS    1           *MRA* NOT REDUCED BY EXT REFS IN CASE ALL
*                            ARE MOVED OUT OF THE LOOP AS INVARIANT 
 UXR      BSS    2           =1 IF EXT REFS IN BLOCK / REGION 
 FTH      BSSZ   1           < 0 IF FALL THROUGH TO HEADER LOOP 
  
          USE    /TABLES/ 
          BSS    100B        SCRATCH FOR *BDT* , ETC
  
*                        IRP
 NTP      BSS    1           N. TERMINAL POLYNOMIALS
 PIC      BSS    1           POLYNOMIAL INCREMENT FORMULA LIST POINTER
 TTI      BSS    1           *TET* INDEX FOR CURRENT BLOCK ( *UPB* )
  
*                        FUD
 BVI      BSS    1           BIT VECTOR INDEX 
  
*                        CHB
 VI2      BSS    2           *BVT* INDICES OF THE SECOND AND FIRST BLOCK
 BSIS     BSS    1           30/BST OF PRED,30/BSI OF CURRENT BLOCK 
  
*                        MII
 AN       BSS    1           1S59 IF BLOCK IS AN ARTICULATION NODE
 UBD      BSS    1           BLOCK *UBD* BIT VECTOR ADDRESS 
 IJP      BSS    2           INVARIANT JUMP ENCOUNTERED FLAG
 UIC      EQU    IJP+1       UNSAFE INVARIANT CODE ENCOUNTERED
  
*                        FII
 IIL      BSS    1           INITIAL *IIT* LENGTH 
  
*                        MIE
 MINC     BSS    1           MIN COST *IP* VALUES THAT WE WILL MOVE 
 IC       BSS    1           INSTRUCTION CHAIN
 ISV      BSS    1           SAVED VALUE OF I ( MULTIPLE DEF"S )
 TBB      BSS    1           FWA OF HOLDING BLOCK 
  
*                        CIF
 CAS      BSS    1           *CA* OF TERMINAL POLYNOMIAL
 TSC      BSS    1           TEMP STORE CHAIN POINTER 
 CNI      EQU    TSC         CLASS NUMBER INCREMENT 
  
*                        FIM
 SC       BSS    1           *TXT* INDEX OF *ST*
 J        BSS    1           *UDI* INDEX OF *ST*
 EV       BSS    1           EXPRESSION VALUE 
 PI       BSS    2           POLYNOMIAL INCREMENT FORMULA INDEX 
 ITB      BSS    1           L.IIT WHEN START TO PROCESS A *ST* 
          USE    0
 STRUCT   TITLE  TABLE FORMATS
*         BS. - BLOCK STATUS INFORMATION WORD ( *MII* TO *UPB* )
*         INITIALLY THE *BS* WORD CONTAINS THE *IM* WORD OF THE BLOCK 
  
          DESCRIBE BS.,60 
          DEFINE 2
 NIS      DEFINE 10          P(N.INCREMENT STORES/N.POLYNOMIAL INCRS) 
 BM       DEFINE 1           BLOCK MODIFIED 
 NTET     DEFINE 11          N.TET"S IN BLOCK 
 STC      DEFINE 18          *RD* STORE CHAIN 
 IIC      DEFINE 18          INVARIANT / INTEGER POLYNOMIAL CHAIN 
 LINK     SPACE  3,14 
*         I. - LINK INFORMATION WORD FORMAT DURING *GPO*
*         THE LINK WORD IS IN I. FORMAT FROM *MII* TO *UPB* 
  
          DESCRIBE I.,60
 INV      DEFINE 1           INVARIANT INSTRUCTION
 M        DEFINE 1           MARKED ( IN *DIF* )
 TI       DEFINE 1           TERMINAL EXPRESSION
  
 IA       DEFINE 1           INTEGER ADD
 IP       DEFINE 1           INTEGER POLYNOMIAL 
 AIP      DEFINE 1           ABNORMAL IP, TERMINAL IP USES OLD VALUE OF 
*                            RD VAR & IS PAST AN INCR OF IT.
 COST     DEFINE 9           *COST* OF AN *IP*
 USES     DEFINE 9           COUNT OF REMOVED USES
 IIC      DEFINE 18          INV INST CHAIN, ETC
 HBP      DEFINE 18          HOLDING BLOCK POINTER
  
 LDI      DEQU   HBP         *UDI* INDEX OF *LD* IF INST IS *IA* / *IP* 
 STC      DEQU   IIC         STORE CHAIN OF RECURSIVELY DEFINED VARS
  
 C1       DEQU   COST,1      LOW BIT OF FIELD 
  
 IAIP     DEQU   IP,2        IA & IP BITS 
 HNT      SPACE  3
**        H. - HEADER NODE TO *HB* TRANSITION TABLE ( IGP, FXI )
  
          DESCRIBE H.,60     HNW(NIP,HBI,HNI) 
          DEFINE 6
 NIP      DEFINE 18          N.INTERNAL PRED OF INTERVAL HEADER 
 HBI      DEFINE 18          BIT INDEX OF HB HEADER 
 HNI      DEFINE 18          BIT INDEX OF HEADER OF INTERVAL
  
          LIST   R,-X 
 AFB      TITLE  SUBROUTINES
**        AFB - ALLOCATE FIXED BLOCK AT LOW MEMORY
* 
*         ENTRY  (X1) = LEN , OF BLOCK
*         EXIT   (X6) = FWA OF BLOCK
*                (X3) = (X7) = LEN
  
 AFB      ROUTINE 
          ALLOC  BLK,X1      ALLOC( BLK , LEN ) 
          IX6    X2+X3
          SA6    A2          O.BLK = O.BLK + LEN
          SA6    LM          LM = O.BLK 
          MX7    0
          SA7    A3          L.BLK = 0
          BX6    X2 
          BX7    X3 
          EQ     AFB
 STO      SPACE  3
**        STO - SET MANAGED TABLES ORIGIN ( LOW MEMORY LIMIT )
* 
*         ENTRY  (X7) = NLM , NEW LOW MEMORY ADDRESS
*         EXIT   LM = O.TXT = NLM , L.TXT = 0 
  
 STO      ROUTINE 
          SA5    =XLM 
          CALL   AMU=        ACCUMULATE MEMORY USED 
          IX6    X6+X5       NEW = LM + MU
          SA4    =XP2.FL
          IX0    X6-X4
          MI     X0,STO1     P2.FL = MAX( NEW , P2.FL ) 
          SA6    A4+
  
 STO1     SA7    A5          LM = NLM 
          SA7    =XO.TXT     O.TXT = LM 
          MX6    0
          SA6    =XL.TXT     L.TXT = 0
          SA6    =XMU        MU = 0 
          EQ     STO
 WTB      SPACE  2
**        WTB - WRITE *TXT* BLOCK BACK TO *BLK* 
  
 WTB      ROUTINE 
          SA1    O.TXT
          SA2    L.TXT
          SA3    X1+B1       R2 = [O.TXT+1] 
          MX4    -R2.TXTLL
          LX3    -R2.TXTLP
          BX5    X4*X3
          IX6    X5+X2       TXTL[R2] = L.TXT 
          LX6    R2.TXTLP 
          SA6    A3 
          CALL   WMB         REWRITE THE BLOCK
          SX6    4
          SA6    L.TXT       L.TXT = 4
          EQ     WTB
 PCC      TITLE  PCC - PROCESS COROUTINE CALL 
**        PCC - PROCESS COROUTINE CALL
*                CALL *RTN* FOR ALL BLOCKS IN THE *BST* BUT THE FIRST.
* 
*         ENTRY  (X7) = RTN , SUBROUTINE NAME 
*                (X5) = BSFM , BLOCK STATUS FIELD MASK
*                IF = 0, THEN CALL *RTN* FOR ALL BLOCKS.
* 
*         THE CALLED COROUTINE IS ENTERED WITH -
*                (X0) = R-NUMBER EXTRACTOR MASK 
*                (X4) = BSW , SECOND WORD OF *BST* ENTRY
*                (X5) = O.SEQ = FWA OF BLOCK
*                (L.SEQ) = BLOCK LENGTH 
*                (BN) = *BIT* INDEX OF BLOCK
 PCC      SPACE  2
 PCCA     SA5    O.SEQ
          RJ     0
          BSS    1           BSFM SAVE WORD 
  
 PCC      ENTRY. ** 
          SA1    PCCA 
          LX6    X5 
          BX7    X1+X7
          SA6    A1+B1
          SA7    PCC5        [PCC5] = *  RJ RTN * 
          SX6    B1+B1       BSI = 2
          RJ     *+1         VOID INSTRUCTION STACK 
 +        EQ     *
  
 PCC1     SA5    O.BST
          IX7    X5+X6
          SA1    X7          BAW = BST(BSI) 
          SA2    X7+1        BSW = BST(BSI+1) 
          SA3    PCCA+1 
          ZR     X1,PCC      IF BAW = 0    */ END OF *BST*
          ZR     X3,PCC2     IF BSFM = 0   */ NO FIELD MASK 
          BX4    X3*X2
          ZR     X4,PCC6     IF BSFM[BSW] = 0  */ FIELDS NOT SET
  
 PCC2     BX7    X2 
          SA6    BSI
          LX1    -BA.BIP
          SX6    X1 
          SA7    BSW
          LX1    59-BA.BLKP+BA.BIP
          SA6    BN          BN = BI[BAW] 
          MI     X1,PCC3     IF BLK[BAW]   */ BLOCK IS IN *BLK* 
  
          CALL   RTB         READ IT INTO *BLK* 
          EQ     PCC4 
  
 PCC3     LX1    1+BA.BLKP-BA.FWAP
          SX6    X1 
          SA6    O.SEQ       O.SEQ = FWA[BAW] 
          LX1    BA.FWAP-BA.LENP
          SX7    X1+
          SA7    L.SEQ
 PCC      SPACE  1,10 
*         SETUP REGISTERS AND CALL COROUTINE
  
 PCC4     MX0    -R1.RIL+1
          SA4    BSW
          LX0    1
 PCC5     SA5    O.SEQ
          RJ     *           CALL COROUTINE 
          SA1    O.BST
          SA2    BSI
          SA3    BSW
          IX5    X1+X2
          BX7    X3 
          SX6    X2+
          SA7    X5+1        BST(BSI+1) = BSW 
  
 PCC6     SX6    X6+2        BSI = BSI + 2
          EQ     PCC1 
 SRI      SPACE  3,14        SRI
**        SRI/SII - STORE RLIST/INCREMENT INSTRUCTION 
* 
*         ENTRY  (B2,X6,X7) = OC, R1, R2
*                (B6,B7) = TI, TB ( BLOCK STORE INDEX , BLOCK FWA ) 
* 
*         EXIT   (X7) = 0 , TI = TI + 4 
* 
*         USES   A - 4, 6, 7   X - 4, 6, 7
  
 SRI      ENTRY. ** 
          SA4    =XF.RDT+B2 
          PX6    B2,X6
          SA6    B7+B6       TA = TB + TI;  [TA] = PACK(OC,R1)
          SB6    B6+4        TI = TI + 4
          SA7    A6+B1       [TA+1] = R2
          BX6    X4 
          SA6    A7+B1       [TA+2] = RDT(OC) 
          SX7    0
          SA7    A6+B1       [TA+3] = 0 
          EQ     SRI
  
 SII      ROUTINE 
          SA4    F.RDT+B2 
          PX6    B2,X6
          SA6    B7+B6       TA = TB + TI;  [TA] = PACK(OC,R1)
          SB6    B6+4        TI = TI + 4
          SX6    B1 
          SA7    A6+B1       [TA+1] = R2
          LX6    D.INCP 
          MX7    0
          BX6    X6+X4
          SA6    A7+B1       [TA+2] = RDT(OC) ! *INC* 
          SA7    A6+B1       [TA+3] = 0 
          EQ     SII
 SMI      SPACE  3,14 
**        SMI - STORE MEMORY REFERENCE INSTRUCTION, SET FP/LVL BITS 
*                IN DESCRIPTOR. 
* 
*         ENTRY/EXIT - SAME AS *SRI/SII*
  
 SMI      ROUTINE 
          SA4    F.RDT+B2    D = RDT(OC)
          PX6    B2,X6
          SA6    B7+B6       TA = TB + TI;  [TA] = PACK(OC,R1)
          SA7    A6+B1       [TA+1] = R2
          BX6    X4 
          LX7    1
          SA4    O.SYM
          SB6    X7+B1
          SB2    X4 
          SA4    B2-B6       WORDB = [O.SYM-2*IH[R2]-1] 
          LX4    -P.FPB 
          SX7    B1 
          BX7    X7*X4
          LX7    D.FPP       FP[D] = FP[WORDB]
          BX6    X7+X6
          SX7    B1+B1
          BX7    X7*X4
          LX7    D.L2P-1
          BX6    X7+X6       L2[D] = L2[WORDB]
          SA6    A7+B1       [TA+2] = D 
          MX7    0
          SA7    A6+B1       [TA+3] = 0 
          SB6    A7+B1
          SB6    B6-B7       TI = TI + 4
          EQ     SMI
 COL      TITLE  COL - CODE OPTIMIZABLE LOOP ( OPT=1 )
**        COL - CODE OPTIMIZABLE LOOP ( OPT=1 ) 
* 
*         PROCESS INNERMOST *DO* LOOPS THAT ARE SINGLE ENTRY/ SINGLE
*         EXIT, AND HAVE NO EXTERNAL REFERENCES OR BACKWARDS BRANCHES.
*         OPTIMIZATIONS PERFORMED ARE CODE MOTION, STRENGTH REDUCTION,
*         THE ASSIGNMENT OF INTEGER VARIABLES TO B-REGISTERS AND
*         TEST REPLACEMENT. 
*         SINCE WE DO NOT HAVE THE LIVE EXIT INFORMATION AVAILABLE, WE
*         ASSUME THAT ALL VARIABLES DEFINED IN THE LOOP ARE LIVE ON 
*         EXIT FROM IT. 
  
          USE    // 
 O.UDB    BSS    1B          FWA OF *USE/DEF* HASH, FWA OF WORKING STORA
          USE    0
  
 SPC      BSS    1           SAVED PARCEL COUNT 
  
*         INTERVAL INFORMATION
  
 COLA     VFD    42/3,18/1   PB = 3 , NODE = 1
          VFD    6/77B,18/4,18/,18/2
  
 COL      ENTRY. ** 
          QUAL   CODE 
  
          SA2    PARCEL 
          SX6    X2+         SPC = PARCEL  */ SAVE PARCEL COUNT 
          SA6    SPC
          CALL   AFT=        ACTIVATE *BLK* 
          ALLOC  BLK,100B    ALLOC( BLK , 100B )  */ ALLOC FOR *UDB*
          SETZERO O.UDB,X1
          ALLOC  UDI,2       ALLOC( UDI , 2 ) 
          MX6    0
          SA6    X2          UDI(0) = 0 
          SA6    X2+1        UDI(1) = 0 
          CALL   CMR         CHAIN MEM REFS TO *UDI*
          CALL   AUT         ADJUST USE TABLE 
          SX6    0
          SA6    L.BLK       L.BLK = 0
          SX1    8
          RJ     AFB         AFB( 8 )      */ ALLOCATE FOR *BIT*
          SETZERO O.UDB,8 
          MX0    1
          LX0    1+BI.RBP 
          SX1    B1 
          LX1    BI.ILP 
          BX6    X0+X1
          SA6    O.UDB+4     (RB,IL)BIT(4) = 1
          EQ     IGO0        GO SETUP *UDT* 
  
 COL1     CALL   IMPD        SETUP *BLK* , MOVE LOOP BODY TO BLK
          RJ     IRP         INITIALIZE REGION PROCESSING 
          MX7    UD.MVL 
          LX7    UD.MVL+UD.MVP
          SA7    BCM         BCM = *BLOCK CLEAR BITS* 
          CLCM   FUD         FORM USE/DEF INFO
  
*         SETUP SPECIAL BIT VECTORS AND *RXI* SO AS TO COMPENSATE FOR 
*         THE LACK OF LIVE EXIT INFO. SET TO CODE POST STORE IN EPILOGUE
  
          SA4    O.UDB+4
          SA3    O.BVT
          SA1    VL 
          SA2    DVA
          LX4    -BI.BVIP 
          SB7    X4          VI = BVI[BIT(4)] 
          SB2    B0          I = 0
          SB3    X1 
          SB4    B3+B3
          SA5    X3+B7       DV = BVT + VI
          SA4    A5+B4       UV = DV + 2*VL 
          SX0    X1 
 COL2     BX6    X5 
          BX7    X4+X5
          SA6    X2+B2       DEF
          SA6    A6+B3       LU 
          SA7    A6+B3       USE
          SA6    A7+B3       LX 
          SA7    A6+B3       LE 
          SA6    A7+B3       MD 
          SB2    B2+B1       I = I + 1
          LT     B2,B3,COL2  IF I < VL
  
          ALLOC  RXI,B2+3    ALLOC( RXI , VL+3 )
          SX6    B0 
          MX7    1
          LX7    1+E.SCRP 
          SA6    X2          RXI(0) = 0 
          SA7    X2+B1       RXI(1) = E(SCR,0,0,0)
          SA2    DVA
          SB2    X0+B1
          SA6    A7+B2       RXI(VL+2) = 0
          MOVE   X0,X2,A7+B1   MOVE( VL , DVA , RXI(2) )
          SX7    2
          SA7    EPSI        EPSI = 2 
  
          CLCM   MII         MARK INVARIANT INSTRUCTIONS
          RJ     IHB         INITIALIZE HOLDING BLOCK 
          PLUG   AT=GPO7,TO=COL4,VOID=NO
          SX6    100
          SA6    MAXW        MAXW = 100    */ INHIBIT X-ASSIGNMENT IN *GRA* 
          EQ     GPO3A       FINISH OFF CODE MOTION & CODE THE LOOP 
  
*         NOW CONVERT THE *HB* TO CODE
  
 COL4     SX6    0
          SA6    BSI         BSI = 0
          CALL   RTB
          SA1    =XL.ALS
          SX5    3
          SX1    X1-1 
          ZR     X1,COL5     IF L.ALS = 1  */ OUTSIDE OF ALL LOOPS
          SX5    2
 COL5     SX6    B1 
          CALL   ESR         EXPAND FP/LVL REFS IN *HB* 
          SX6    2
          SA6    BSI         BSI = 2
          CALL   RTB         GET THE CODED LOOP BODY
  
          SA5    SPC
          SA4    L.TXT
          MX6    0
          BX7    X5          PARCEL = SPC 
          SA7    PARCEL 
          SX3    X4-8 
          NZ     X3,COL6     IF L.TXT " 8  */ *HB* IS NOT EMPTY 
  
          SA1    L.SEQ
          ALLOC  PIT,X1      ALLOC( PIT , L.SEQ ) 
          SX3    X2 
          SA2    O.SEQ
          MOVE   X1,X2,X3    MOVE (L.SEQ , O.SEQ , O.PIT )
          EQ     COL7 
  
 COL6     CALL   MCG         CODE THE *HB*
  
*         COMBINE THE CODED INSTRUCTIONS FOR THE *HB* AND LOOP BODY 
*         AND CALL *CII* TO CONVERT THEM. 
  
          SA1    L.SEQ
          ALLOC  PIT,X1-1    ALLOC( PIT , L.SEQ-1 ) 
          SX3    X2+B6
          SA2    O.SEQ
          MOVE   X1,X2+B1,X3 MOVE( L.SEQ-1 , O.SEQ+1 , PIT+OLD(L.PIT) ) 
  
 COL7     SX6    O.UDB
          SA6    =XLM        LM = O.UDB 
          SA6    O.BLK       O.BLK = O.UDB
          SA6    O.TXT       O.TXT = O.UDB
          SX7    0
          SA7    L.BLK       L.BLK = 0
          SA7    L.TXT       L.TXT = 0
          SA7    L.BST       L.BST = 0
          SA7    L.IIT       L.IIT = 0
          SA7    N.GT        N.GT = 0 
          CALL   CII         CONVERT THE ISSUED INSTRUCTIONS
          CALL   AFT=        DEACTIVATE *BLK* 
          SX7    0
          SA7    N.GT        N.GT = 0 
          SA7    L.TET       L.TET = 0
          EQ     COL
  
          QUAL
 GPO      TITLE  GPO - CONTROL / INITIALIZATION 
**        GPO - GLOBAL PROGRAM OPTIMIZATION 
*         INITIALIZATION, MAIN LOOP, CODE LINEARIZATION PASS. 
  
 GPO      ENTRY. ** 
  
          QUAL   CODE 
  
          CALL   IMPB        INITIALIZE MASSIO FOR PHASE 2
  
          SX7    =XF.UDT
          CALL   STO
          CALL   AUT         REFORMAT *UDI* 
  
          SX7    =XF.CFA
          CALL   STO
          CALL   DGS         DERIVE GRAPH STRUCTURE 
  
*         MOVE GRAPH TABLE DOWN TO BEGIN OF WORKING STORAGE 
  
          SA1    L.GST
          SA2    O.GST
          SA3    O.IST
          IX0    X1+X3
          SX6    X3+B1
          SA6    GP          GP = [O.IST] + 1  */ POINT TO GA WORD
          MOVE   X1,X2,X3    MOVE( L.GST , O.GST , O.IST )
          BX7    X0          LM = O.IST + L.GST 
          CALL   STO
  
          CALL   AFT=        ACTIVATE FIRST TABLE ( *BLK* ) 
  
*         SETUP FIXED TABLES IN LOW MEMORY, LAYOUT -
*                IST, BIT, LCT, UDT, MVL, BVT, SBV, BTT, HNT
  
          SX1    2
          RJ     AFB         AFB( 2 )      */ SEARCH TERM FOR GRA/CIS 
          MX7    -BI.ILP
          SA7    X6          [FWA] = MASK(3)  */ SO INIT PARCEL CNT OK
          MX7    0
          SA7    A7+B1
          SA2    CBN
          LX2    1
          SX1    X2+4        L.BIT = 2*CBN + 4
          RJ     AFB         AFB( L.BIT ) 
          SA6    O.BIT       O.BIT = FWA
  
*         MOVE *BIT* TO LOW CORE AND CLEAR OUT HOLDING BLOCKS WORDS 
  
          SA1    L.BST
          SA7    L.BIT
          SA2    O.BST
          IX0    X7-X1       LHB = L.BIT - L.BST
          IX5    X6+X1
          MOVE   X1,X2,X6    MOVE( L.BST , O.BST , O.BIT )
          SETZERO X5,X0      FOR I = L.BST TO L.BIT; BIT(I) = 0 
          SA6    L.BST       L.BST = 0
  
          SA1    L.LCT       L = L.LCT
          SA6    A1          L.LCT = 0     */ CLEAR COUNTER 
          RJ     AFB         AFB( L ) 
          SA6    O.LCT       O.LCT = FWA
  
          SA2    N.FTH
          SX1    X2+B1
          RJ     AFB         AFB( N.FTH + 1 ) 
          SA6    O.ELT       O.ELT = FWA
*         MOVE *UDI* TO LOW CORE, ALLOCATE FOR *MVL*. 
  
 IGO0     SA1    L.UDI
          RJ     AFB         AFB( L.UDI ) 
          SA2    O.UDI
          SA6    O.UDT       O.UDT = FWA
          SA7    L.UDT
          MOVE   X1,X2,X6    MOVE( L.UDI , O.UDI , O.UDT )
          MX7    0           L.UDI = 0
          SA7    L.UDI
  
          SA2    N.VAR
          SX1    X2+3 
          RJ     AFB         ALLOCATE FOR *MVL* 
          SA6    O.MVL       O.MVL = FWA
  
*         ALLOCATE FOR BIT VECTORS, MOVE VECTORS FORMED IN *AUT* TO 
*         *BVT*.
  
          SA1    CBN
          SA2    VL 
          LX1    2
          IX1    X1*X2       L.BVT = CBN * 4*VL  */ BIT VECTORS 
          RJ     AFB         AFB( L.BVT ) 
          SA6    O.BVT       O.BVT = FWA
  
          SA1    L.RXI
          SA2    O.RXI
          SX3    X6 
          BX7    X1 
          SA7    L.BVT       L.BVT = L.RXI */  *BVT* INDEX FOR *FUD*
          MX6    0
          SA6    A1          L.RXI = 0
          MOVE   X1,X2,X3    MOVE( L.BVT , O.RXI , O.BVT )
          SA1    =XOPT2 
          ZR     X1,IGO1     IF OPT2 = 0   */ OPT=1 
  
*         PHASE 2 OF OPT=2 - FORM BIT VECTORS FOR ALL PROGRAM BLOCKS. 
  
          CALL   FBV         FORM BIT VECTORS 
  
*         SETUP ADDRESS"S OF SPECIAL BIT VECTORS
  
 IGO1     SA2    VL 
          SX0    N.SBV
          IX1    X0*X2
          IX6    X1-X2       L.SBV = VL * ( N.SBV-1 ) 
          SA6    L.SBV
          IX1    X1+X2
          RJ     AFB         AFB( VL * (N.SBV+1) )
          SA1    VL 
          SB2    B0          I = 0
          SB3    X0 
 IGO2     SA6    DVA+B2      DVA(I) = FWA 
          SB2    B2+B1       I = I + 1
          IX6    X6+X1       FWA = FWA + VL 
          LT     B2,B3,IGO2  IF I < N.SBV 
          SA1    OPT2 
          ZR     X1,COL1     IF OPT2 = 0
  
*         ALLOCATE FOR *BTT* AND *HNT*
  
          SA1    CBN
          RJ     AFB         AFB( CBN ) 
          SA6    O.BTT       O.BTT = FWA
          SA5    M.LP 
          SX1    X5+1 
          RJ     AFB         AFB( M.LP+1 )
          SA6    O.HNT       O.HNT = FWA
 GPO      SPACE  1,14 
*         COMPUTE AN UPPER BOUND FOR *BLK* LENGTH 
  
          PRINT  GPOFL,(* CWS= CALLED BY GPO; CWS,MWS =*2Z7),(X6,X7)
 IGO3     CALL   CWS= 
          SX1    2000B
          SB4    X7          B4 = MWS */ MAX. AVAIL. STORAGE
          IX7    X7-X1
          AX7    2
          SX4    14000B 
          IX2    X4-X7
          SB2    X6          B2 = CWS */ CURRENT WORKING STORAGE
          PL     X2,IGO3A    IF (MWS - 2000B)/4 @ 14000B
          BX7    X4 
 IGO3A    SA7    M.EBL       M.EBL = MIN((MWS-2000B)/4,14000B)
          SA3    =XM.BBL     */ MAX.BASIC BLOCK SIZE
          PRINT  GPOFL,(* M.BBL =*Z7),(X3)
          LX3    3
          SB3    X3          B3 = 8*M.BBL 
          SX1    10000B 
          IX2    X3-X1
          PL     X2,IGO3B    IF   8*M.BBL > 10000B
          BX3    X1 
          SB3    X1          RWS = MAX(  8*M.BBL,10000B) */ REASONABLE
*                                                           STORAGE 
 IGO3B    GE     B2,B3,IGO5  IF CWS \ RWS 
          GT     B3,B4,IGO4  IF RWS > MWS 
  
*                            CWS < RWS @ MWS
  
          IX1    X3-X6
          CALL   MOREFL      */ WN = RWS - CWS
          PL     X7,IGO3     IF REQUIRED MEMORY GRANTED 
  
 IGO4     SA1    =7LGPO 
          CALL   PUNT        GO TO ABORT THE COMPILATION
  
 IGO5     BX1    X6 
          PRINT GPOFL,(*CWS,RWS=*2Z7),(X6,X3) 
          AX1    3
          AX6    1
          IX7    X6-X1       X7 = 3/8 * CWS 
          IX2    X4-X7
          PL     X2,IGO5A 
          BX7    X4 
 IGO5A    SA7    =XMX.BLN    MX.BLN = MAX BLK.TABLE SIZE
          PRINT  GPOFL,(* MAX BLK. LEN =*Z7),(X7) 
          CALL   IMPC        MX.BLN  = MIN(3/8*CWS,14000B)
  
 .T       IFNE   TEST,0                                    * TEST MODE *
          SA1    =XR=FLAG 
          ZR     X1,IGO6     IF LIST = 0
  
*         LIST OPTIMIZER MEMORY USEAGE STATISTICS 
  
          USE    STAT 
  
 IGOA     DATA   1H ,38LOPTIMIZER MEMORY USEAGE STATISTICS
 IGOB     DATA   1H ,40LEXEC STMTS  N.BLOCKS   N.LOOPS    N.VARS
          DATA   20H   MAX-BLK  N.GRAPHS
          DATA   50L   L.GRAPH L.BIT VEC     L.BLK WRK SPACE L.PRG TXT
 IGOC     DATA   8L 
  
 ZOD      ROUTINE 
          RJ     =XCOD
          LX6    6
          SX7    1RB-1R 
          IX6    X6+X7
          EQ     ZOD
  
          USE    0
 STAT     MACRO  A,B,C,M
          SA1    A
          IFC    NE,/B//,2
          SA2    B
          IX1    X1-X2
          IFC    NE,/M//,1
          SX1    X1+M 
          RJ     =X;C 
          SA6    IGOB+.1
 .1       SET    .1+1 
          ENDM
 .1       SET    1
          LISTL  IGOC,1 
          LISTL  IGOA,IGOB-IGOA 
          LISTL  IGOB,IGOC+1-IGOB 
          STAT   =XN.EXST,,CDD     N.STMTS
          STAT   NPB,,CDD 
          STAT   CBN,NPB,CDD,-1    N.LOOPS
          STAT   N.VAR,,CDD,-1
          STAT   M.BBL,,ZOD        MAX BASIC BLK LEN
          STAT   N.DG,,COD         N.GRAPHS 
          STAT   O.BIT,GP,ZOD      L.GRAPH
          STAT   O.BTT,O.BVT,ZOD   L.BIT VEC
          STAT   L.BLK,,ZOD 
          STAT   O.TEND,O.TXT,ZOD  WORK SPACE 
          STAT   L.PTXT,,ZOD
          PURGMAC STAT
  
          LISTL  IGOB,IGOC+1-IGOB 
  
 IGO6     BSS    0
  
 .T       ENDIF                                            * TEST MODE *
 GPO      SPACE  2
*         SET FLAGS FOR PHASE 3 OF GLOBAL OPTIMIZATION
  
          SX6    1
          SA6    BBV         BBV = 1       */ SET FOR NO BIT VECTORS
          MX7    UD.MVL 
          LX7    UD.MVL+UD.MVP
          SA7    BCM         BCM = *MV*    */ SET FOR BLOCK BIT CLEAR 
  
*         SETUP A *BOS* AT THE BEGINNING OF *TXT* 
  
          ALLOC  TXT,4       ALLOC( TXT , 4 ) 
          SA5    =XF.RDT+OC.BOS 
          MX6    0           T = O.TXT
          SA6    X2+B1       [T+1] = 0
          BX7    X5 
          SA7    A6+B1       [T+2] = RDT(BOS) 
          SA6    A7+B1       [T+3] = 0
 GPO      TITLE  GPO - MAIN LOOP
*         PHASE 3 - INNER TO OUTER PASS OVER THE LOOPS TO MOVE OUT
*         INVARIANT / STRENGTH REDUCABLE CODE AND ASSIGN REGISTERS. 
  
 GPO1     RJ     IGP         INITIALIZE GRAPH PROCESSING
          ZR     X6,GPO10    IF N.LP = 0   */ NO LOOPS IN THIS GRAPH
  
 GPO2     RJ     FNL         FIND NEXT LOOP 
          RJ     IRP         INITIALIZE REGION PROCESSING 
  
          CLCM   FUD         FORM USE/DEF INFO FOR REGION 
          SA1    UXR+1
          ZR     X1,GPO3     IF UXR(2) = 0 */ NO USER EXT REFS
          MX7    1
          SA7    XRF         XRF = 1S59 
          SA2    RCV
          ZR     X2,GPO3     IF RCV = 0    */ NO REFED COMMON VARIABLES 
          SA4    O.BVT
          SA5    RDB
          CALL   EBV         SET REGION DEF BITS FOR COMMON VARS, ETC 
  
 GPO3     CLCM   RDD         REMOVE DEAD DEFINITIONS
  
          RJ     FEI         FORM LIVE ENTRY VECTOR 
  
          CLCM   MII         MARK INVARIANT INSTRUCTIONS
  
          RJ     IHB         INITIALIZE HOLDING BLOCK 
          RJ     FXI         FORM EXIT INFORMATION
  
 GPO3A    CLCM   FII,(STC)   FORM INCREMENT INFO
          SA1    L.IIT
          BX6    X1          PIC = L.IIT
          SA6    PIC
          ZR     X1,GPO4     IF PIC = 0    */ NO RECURSIVE DEFS 
  
          CLCM   MIP         MARK INTEGER POLYNOMIALS 
  
 GPO4     SA1    MRA
          SX2    376B 
          SX6    B1+B1       MINC = 2      */ MIN *IP* COST 
          BX3    X2*X1
          CX4    X3          NABR = COUNT(MRA&376B)  */ N.AVAIL B-REGS
          AX4    1
          NZ     X4,GPO5     IF NABR \ 2
          SX6    3           MINC = 3 
 GPO5     SA6    MINC 
          CLCM   MIE,(IIC)   MOVE INV/SR INSTRUCTIONS TO *HB* 
          MX6    0
          CALL   SHB         SQUEEZE HOLDING BLOCK
          SA2    NTP
          ZR     X2,GPO6     IF NTP = 0    */ NO TERMINAL *IP*"S
  
          RJ     CIF         COLLECT INCREMENT FORMULAS 
          SA2    NTP
          ZR     X2,GPO6     IF NTP = 0 
  
          CLCM   FIM,(STC)   FORM *TP* INCREMENT MODS 
          SA1    L.MOD
          SX2    X1-4 
          ZR     X2,GPO6     IF L.MOD = 4  */ NO VARIABLE INCR CODE 
          SX6    B1 
          CALL   SHB         SQUEEZE VARIABLE INCREMENT CODE
  
 GPO6     SX6    4           L.TXT = 4
          SA6    L.TXT
          CLCM   UPB,(NIS,BM,NTET)   UPDATE MODIFIED BLOCKS 
          RJ     ATT         ADJUST *TET* 
  
          RJ     CBB         COMBINE BASIC BLOCKS 
  
          CALL   GRA         ASSIGN REGISTERS, CODE THE LOOP
  
 GPO7     RJ     TRP         TERMINATE REGION PROCESSING
          SA2    N.LP 
          SX7    X2-1        N.LP = N.LP - 1
          SA7    A2+
          NZ     X7,GPO2     IF N.LP " 0
  
          SX7    4           EMF = 4       */ EXPAND STT"S IN OUTER LPS 
          SA7    EMF
          RJ     GNG         GET NEXT GRAPH 
          EQ     GPO1 
 GPO      SPACE  2,14 
*         PROCESS BLOCKS OUTSIDE OF ALL LOOPS AND CONVERT THEM TO CODE. 
  
 GPO10    MX6    -UD.STCP 
          SX7    B0 
          SA7    HBI         HBI = 0       */ OUTSIDE OF ALL LOOPS
          SA7    NBIP        NBIP = 0 
          SA6    BCM         BCM = *REGION CLEAR MASK*
  
 GPO11    SA1    IBA
          SA2    X1          IP = [IBA] 
          SX6    X1+B1       IBA = IBA + 1
          ZR     X2,GPO12    IF [IP] = 0   */ END OF INTERVAL LIST
          LX2    -IP.NODEP
          SA6    A1 
          SX7    X2          NN = NODE[IP]
          SA7    A1+B1
          CALL   CIC         CONVERT INTERVAL TO CODE 
          EQ     GPO11
  
*         ADJUST *GL* TABLE FOR GL"S ADDED FROM MULTIPLE PRED IF LOOPS. 
  
 GPO12    SA1    N.GL0
          SA2    N.GL 
          IX1    X1-X2       L = N.GL0 - N.GL 
          ZR     X1,GPO13    IF L = 0      */ NO GL"S ADDED 
          ALLOC  TEND-1,X1   ALLOC( TEND-1 , L )
          SA5    =XO.GLT
          SX7    B6 
          SA7    A3 
          IX6    X5-X1       O.GLT = O.GLT - L
          SA6    A5 
          SX7    X6-1        LW = O.GLT - 1 
          SA7    =XLWAWORK   LWAWORK = LW 
          SA7    =XO.TEND    O.TEND = LW
 GPO      SPACE  2,20 
*         PHASE 4 - LINEARIZE THE CODE BLOCKS TO BRING THEM BACK TO 
*         SOURCE PROGRAM ORDER AND OUTPUT THEM. 
  
          DESCRIBE BI.,60 
 BEF      DEQU   BVI         BN OF BLOCK THAT COMES BEFORE CURRENT BLOCK
  
 GPO13    SA1    CBN
          SA2    O.BIT
          MX0    -BI.BEFL 
          SB2    B1+B1
          LX0    BI.BEFP
          SB3    B0          I = 0
          LX1    1
          SB4    X1          L = 2*CBN
          SA3    NPB
          SB7    X2                        (B7) = [O.BIT] 
  
 GPO14    SA5    B7+B3       BEF[BIT(I)] = 0
          SB3    B3+B2       I = I + 2
          BX6    X0*X5
          SA6    A5 
          LT     B3,B4,GPO14 IF I < L 
  
*         SEARCH FOR HOLDING BLOCKS THAT WERE CODED ( NOT COALESCED ) 
*         AND SET THE *BEF* FIELD FOR THE HEADER BLOCK THAT COMES 
*         AFTER THE *HB* IN THE CODE OUTPUT.
  
          LX3    1
          SB3    X3          I = 2*NPB
  
 GPO15    SB3    B3+B2       I = I + 2
          SA5    B7+B3       BIW = BIT(I) 
          GE     B3,B4,GPO18 IF I \ L 
          LX5    59-BI.CBP
          PL     X5,GPO15    IF ^CB[BIW]
  
          LX5    1+BI.CBP-BI.PBNP 
          SX7    B3          P = I
          SB6    X5          J = PBN[BIW]  */ BN OF HEADER NODE 
          SA4    B7+B6       BJW = BIT(J) 
          LX4    59-BI.RBP
          MI     X4,GPO15A   IF RB[BJW]    */ HEADER IS A PROGRAM BLOCK 
          LX4    BI.RBP-BI.FJP
          MI     X4,GPO17    IF FJ[BJW]    */ *HB* IS REMOTE
  
 GPO15A   LX5    59-BI.FJP+BI.PBNP
          PL     X5,GPO16    IF ^FJ[BIW]   */ ^ FALL THROUGH TO HEADER
          SB6    B0          J = 0         */ ADD *HB* TO EXIT NODE LIST
 GPO16    SA4    B7+B6       BJW = BIT(J);  JL = J
          LX4    -BI.BEFP 
          SB6    X4          J = BEF[BJW] 
          NZ     B6,GPO16    IF J " 0 
  
          BX6    X4+X7       BEF[BIT(JL)] = P  */ LINK HEADER TO *HB* 
          LX6    BI.BEFP
          SA6    A4 
          EQ     GPO15
  
*         *HB* FROM NEST OF *FTH* LOOPS, MAKE *HB* COME BEFORE HEADER.
  
 GPO17    LX5    BI.PBNP
          SX6    B6 
          LX6    BI.BEFP
          BX6    X6+X5       BEF[BIT(I)] = J  */ HB BEFORE HEADER 
          SB5    B0          K = 0
  
 GPO17A   SA4    B7+B5       BKW = BIT(K);  KL = K
          LX4    -BI.BEFP 
          SB5    X4          K = BEF[BKW] 
          NE     B5,B6,GPO17A      IF K " J 
  
          SA6    A5 
          LX4    BI.BEFP
          BX4    X0*X4
          BX7    X4+X7       BEF[BIT(KL)] = I  */ LINK PREV TO HB 
          SA7    A4 
          EQ     GPO15
  
*         FINAL SCAN OF PROGRAM BLOCKS IN *BIT* TO FORM A TABLE OF
*         ADDRESSES OF THE BLOCKS IN THEIR OUTPUT ORDER.
  
 GPO18    SA4    O.UDT
          SB3    B0          I = 0
          SA0    X4          SI = [O.UDT]  */ RIW STORE INDEX 
          SB4    X3+B2       L = 2*NPB + 2
          EQ     GPO20
  
 GPO19    SX6    A5+B1
          SA6    A0 
          SA0    A0+B1       SI = SI + 1
  
 GPO20    SB3    B3+B2       I = I + 2
          SA5    B7+B3       BIW = BIT(I) 
          GE     B3,B4,GPO23 IF I \ L 
          LX5    -BI.BEFP 
          SX2    X5          JF = BEF[BIW]
          LX5    59-BI.CBP+BI.BEFP
          PL     X5,GPO20    IF ^CB[BIW]   */ NOT CODED 
          ZR     X2,GPO19    IF JF = 0     */ NO HEADER NODE BEFORE 
  
*         SEARCH TO END OF *BEF* CHAIN, COUNT NUMBER OF BLOCKS BEFORE.
  
          SB6    X2          J = JF 
          SB5    B1          K = 1
 GPO21    SA4    B7+B6       BJW = BIT(J) 
          SB5    B5+1        K = K + 1
          LX4    -BI.BEFP 
          SB6    X4          J = BEF[BJW] 
          NZ     B6,GPO21    IF J " 0 
  
*         RESCAN THE LIST AND STORE *RI* WORDS IN REVERSE ORDER.
  
          SA0    A0+B5       SI = SI + K
          SB6    X2+B1       J = JF 
          SX7    A5+B1
          SA7    A0-B1       SJ = SI - 1;  [SJ] = BIT(I+1)
  
 GPO22    SX7    B7+B6
          SA4    X7-1 
          SA7    A7-B1       SJ = SJ - 1;  [SJ] = BIT(J+1)
          LX4    -BI.BEFP 
          SB6    X4+B1       J = BEF[BIT(J)]
          NE     B6,B1,GPO22 IF J " 0 
  
          EQ     GPO20
  
*         ADD HOLDING BLOCKS FOR FALL THROUGH TO HEADER LOOPS TO LIST 
  
 GPO23    SB6    0           J = 0
  
 GPO24    SA5    B7+B6       BIW = BIT(J) 
          LX5    -BI.BEFP 
          SB6    X5          J = BEF[BIW] 
          ZR     B6,GPO25    IF J = 0      */ END OF CHAIN
          SB5    B6+B1
          SX7    B7+B5
          SA7    A0 
          SA0    A0+B1       SI = SI + 1
          EQ     GPO24
 GPO      SPACE  1,10 
*         ALLOCATE TABLES FOR *CII* AND ASSIGN *CA"S* TO THE IT.S IN TET
  
 GPO25    MX7    0
          SA7    A0          [SI] = 0      */ TERMINATE THE *RIW* LIST
          SA7    =XPARCEL    PARCEL = 0 
          SA2    M.PL 
          ALLOC  PIT,X2+1    ALLOC( PIT , M.PL+1 )
          LX1    2
          ALLOC  TXT,X1      ALLOC( TXT , 4*(M.PL+1) )
          SA1    L.TET
          ZR     X1,GPO35    IF L.TET = 0  */ NO IT. S
 MAXT     DEQU   BVI         MAX IT. S IN LOOP
  
          SA2    O.BIT
          SA3    L.BIT
          SA4    NPB
          MX7    0
          SA7    X2          BIT(0) = 0 
          MX0    -BI.MAXTL
          LX4    1
          SB3    X4          I = 2*NPB
          SB4    X3 
 GPO26    SA5    X2+B3
          BX6    X0*X5       MAXT[BIT(I)] = 0 
          SB3    B3+2        I = I + 2
          SA6    A5 
          LT     B3,B4,GPO26 IF I < L.BIT 
  
*         FORM SORT TABLE AND GROUP IT.S BY THE LOOP THEY ARE DEFINED IN
  
          ALLOC  CFT,X1+B1   ALLOC( CFT , L.TET+1 ) 
          SA5    O.TET
          SB3    X1-1        LIM = L.TET
          MX0    -T.HBNL
          MX7    0
          LX0    T.HBNP 
          SA7    X2          CFT(0) = 0;  J = 1 
          SB2    B0          I = 0
          SA5    X5 
  
 GPO27    BX6    -X0*X5 
          LX5    59-T.EQVP
          ZR     X6,GPO28    IF HBN[TET(I)] = 0  */ NOT MATERIALIZED
          MI     X5,GPO28    IF EQV[TET(I)] 
          SX1    B2+
          BX7    X6+X1
          SA7    A7+B1       J = J + 1;  CFT(J) = HBN[TET(I)] ! I 
 GPO28    SB2    B2+B1       I = I + 1
          SA5    A5+B1
          LT     B2,B3,GPO27 IF I < LIM 
  
          SB7    X2+B1       FWA = CFT(1) 
          SB6    A7+B1
          SX1    B6-B7       LEN = CFT(I+1) - FWA 
          SA0    A7                        (A0) = CFT(N)
          ZR     X1,GPO33    IF LEN = 0 
          SX6    X1+B1
          SA6    A3          L.CFT = LEN + 1
          CALL   SHL         SORT( CFT , LEN )
  
*         SCAN THE SORTED TABLE BACKWARDS ( OUTERMOST LOOPS FIRST ) AND 
*         ASSIGN *CA"S* TO THE IT. S, AND ACCUMULATE THE AMOUNT OF
*         STORAGE USED. 
  
          SA5    A0          I = N;  CI = CFT(N)
          MX0    -T.CAL 
          SA3    O.BIT
          SA4    O.TET
          SX7    B0          C = 0
          SX1    B1 
          SB5    B0          MIT = 0       */ MAX IT. S 
          LX1    T.FAP
          SB6    X3                        (B6) = O.BIT 
          SB7    X4                        (B7) = O.TET 
          SB4    T.HBNP 
          AX2    B4,X5       LHB = HBN[CI]
  
 GPO30    AX3    B4,X5       H = HBN[CI]
          BX6    X2-X3
          ZR     X6,GPO32    IF H = LHB    */ SAME LOOP 
  
          SA4    B6+X2
          BX6    X4+X7       MAXT[BIT(LHB)] = C  */ SAVE OLD MAX
          SA6    A4+
+         SB2    X7 
          LE     B2,B5,*+1   MIT = MAX( MIT , C ) 
          SB5    B2 
          BX3    -X3
          SB2    X3 
  
 GPO31    SX2    X2-2        LHB = LHB - 2
          SA4    B6+X2
          MX3    -BI.OLNL 
          LX4    -BI.OLNP 
          BX3    -X3*X4      J = OLN[BIT(LHB)]
          SA3    B6+X3
          LX3    -BI.MAXTP
          SX7    X3          C = MAXT[BIT(J)]  */ SET BASE *CA* 
          SX6    X2+B2
          ZR     X6,GPO32    IF LHB = H 
          LX4    BI.OLNP
          BX6    X4+X7       MAXT[BIT(OLN)] = C  */ PROPAGATE TO INER LP
          SA6    A4 
          EQ     GPO31
  
*         ASSIGN A *CA* TO THIS *TET* ENTRY 
  
 GPO32    SA4    B7+X5       I = SETX([CI]) 
          SA5    A5-B1       CI = CI - 1
          BX6    X1+X7
          BX3    X0*X4
          BX6    X6+X3       (FA,CA)TET(I) = (1,C)
          SA6    A4 
          SX7    X7+1        C = C + 1
          NZ     X5,GPO30    IF [CI] " 0   */ NOT END OF SORT TABLE 
  
+         SB2    X7 
          GE     B2,B5,*+1   N.IT = MAX( MIT , C )
          SX7    B5 
          SA7    =XN.IT 
  
 GPO33    SX7    0
          SA7    =XL.CFT     L.CFT = 0
 GPO      SPACE  1,14 
*         LOOP THROUGH THE TABLE OF *RI* WORDS AND CALL *CII* TO
*         CONVERT THE BLOCKS TO COMPASS INSTRUCTIONS AND ASSIGN 
*         ADDRESS"S.
  
 GPO35    SA1    O.UDT
          SA3    O.PIT
          SA5    X1          RIWA = [SI]
          ZR     X5,GPO36    IF RIWA = 0     */ END OF TABLE
          SA5    X5          RIW = [RIWA] 
          LX5    -RI.LENP 
          SX6    X1+B1       SI = SI + 1
          SA6    A1 
          SX7    X5          L.PIT = LEN[RIW] 
          LX5    RI.LENP
          SA7    L.PIT
          CALL   GMB         READ BLOCK TO *PIT*
          SA1    O.PIT       R1 = [O.PIT] 
          SA2    X1 
          SX6    X2          BN = IH[R1]   */ SET *BN* FOR TET PACKING
          SA6    BN 
          CALL   CII         CONVERT THE INSTRUCTIONS 
          EQ     GPO35
  
 GPO36    SX6    0
          SA6    L.PIT       L.PIT = 0
          SA6    L.TXT       L.TXT = 0
  
          EQ     GPO
 IGP      TITLE  GRAPH PROCESSING SUBROUTINES 
**        IGP - INITIALIZE GRAPH PROCESSING 
* 
*         ENTRY  (GP) = GRAPH POINTER, FWA OF GRAPH TABLE 
* 
*         EXIT   (X6) = N.LP , N. LOOPS IN GRAPH
  
 IGP      ROUTINE 
          SA1    GP 
          SA2    X1+B1       GB = [GP] + 1;  GBW = [GB] 
          SX6    A2+B1
          SA6    EIT         EIT = [GP] + 2  */ EDGE INDEX TABLE
  
*         BUMP PRED COUNT OF PROGRAM EXIT NODE SO IT DOESNT BECOME A
*         INSERTION POINT FOR POST STORE CODE ( FXI ).
  
          SX5    B1 
          SA4    A2+B1
          LX5    EI.NPP 
          IX7    X5+X4       NP[EIT] = NP[EIT] + 1
          SA7    A4 
  
          LX2    -GB.ILIP 
          SX3    X2 
          IX7    X6+X3
          SB3    X7 
          SA7    IBA         IBA = EIT + ILI[GBW] 
          LX2    GB.ILIP-GB.NLPP
          SX6    X2 
          SA6    N.LP        N.LP = NLP[GBW]
          MX7    0
          SA7    NN          NN = 0 
  
*         SETUP *BTT* AND *HNT*, SET *HN* BIT FOR HEADER NODES. 
*         SETUP BVI FOR *HB"S* SO AS TO SIMPLIFY *FXI* LOGIC. 
*         BTT - NODE NUMBER TO *BI* TRANSITION TABLE
*         HNT - HEADER NODE TO *HB* SEARCH TABLE. 
  
          SA0    X6 
          SA1    O.BTT
          SA3    O.HNT
          SA2    O.BIT
          SB7    X1                        (B7) = O.BTT 
          SB6    X3          HI = O.HNT 
          SB5    IM.BIP 
          SB4    X2                        (B4) = O.BIT 
          MX0    -IP.NODEL
          SA5    B3          IP = IBA 
          MX7    0
          SA7    B7          BTT(0) = 0 
  
 IGP1     BX1    X0*X5       HNI = (NIP,PB)[IP] 
          LX5    -IP.NODEP
          SB2    X5          N = NODE[IP] 
          SA5    A5+B1       IP = IP + 1   */ HEADER NODE 
          BX2    X5          IPF = [IP] 
  
 IGP2     AX4    B5,X5
          LX5    -IM.BNP
          SX7    X4 
          SA7    B7+X5       BTT(BN[IP]) = BI[IP] 
          SB2    B2-B1       N = N - 1
          SA5    A5+B1       IP = IP + 1
          NZ     B2,IGP2     IF N " 0 
  
          LX2    59-IM.SCRP 
          PL     X2,IGP3     IF ^SCR[IPF]  */ HEADER ^ IN SCR 
          LX2    1+IM.SCRP-IM.BIP  I = BI[IPF]
          SX2    X2 
          BX7    X1+X2
          SA7    B6          [HI] = HNW(HNI,I)
          SB6    B6+B1       HI = HI + 1
  
          LX1    -IP.PBP+1   HBI = 2*PB[HNI]
          SX4    B1 
          SA3    B4+X2
          LX4    BI.HNP 
          BX6    X4+X3       HN[BIT(I)] = 1 
          SA6    A3 
          LX3    -BI.BVIP 
          SX7    X3 
          LX7    BI.BVIP
          SA7    B4+X1       BVI[BIT(HBI)] = BVI[BIT(I)]
  
 IGP3     NZ     X5,IGP1     IF [IP] " 0   */ ^ END OF INTERVAL LIST
  
          SX6    A0 
          SX7    B6 
          SA7    L.HNT       L.HNT = HI    */ LWA+1 OF HNT
          EQ     IGP
 FNL      SPACE  3,14        FNL
**        FNL - FIND NEXT LOOP ( STRONGLY CONNECTED REGION  ) 
* 
*         EXIT   (IBA) = INTERVAL LIST ADDRESS FOR *SCR*
*                (NN) = N.NODES IN INTERVAL 
*                (X4) = IM = [IBA] , FIRST INTERVAL MEMBER WORD 
  
 FNL0     SX6    A4 
          SA6    A1          IBA = IM 
          SX7    B2 
          SA7    A2          NN = NODE[IP]
          LX4    1+IM.SCRP
  
 FNL      ROUTINE 
          SA1    IBA
          SA2    A1+B1
          IX7    X1+X2
          SA5    X7          IP = IBA + NN */ POINT TO IP WORD OF NEXT
  
 FNL1     SA4    A5+B1       IM = IP + 1
          LX5    -IP.NODEP
          SB2    X5          N = NODE[IP] 
          LX4    59-IM.SCRP 
          MI     X4,FNL0     IF SCR[IM]    */ HEADER IN A *SCR* 
          SA5    A4+B2       IP = IM + N   */ ADVANCE TO NEXT HEADER
          EQ     FNL1 
 GNG      SPACE  2,14        GNG
**        GNG - GET NEXT GRAPH TABLE
* 
*         EXIT   (X6) = 0 IF END OF GRAPHS, ELSE (GP) = FWA OF GRAPH
  
 GNG0     SA2    GP 
          SA3    X2 
          LX3    -GA.LFP
          SX6    X3 
          ZR     X6,GNG      IF LF[GP] = 0 */ LEAVE *GP* ALONE
          IX7    X2+X6       GP = GP + LF[GP] 
          SA7    A2 
 GNG      ROUTINE 
          SA1    GIC
          ZR     X1,GNG0     IF GIC = 0    */ ALL GRAPHS ARE INCORE 
  
          SA4    X1+B1       RAW = [GIC+1] */ RANDOM INDEX WORD 
          SX7    X1+B1       GIC = GIC + 1
          MX6    0
          SA7    A1 
          ZR     X4,GNG      IF RAW = 0    */ END OF GRAPHS 
          SA2    GP 
          LX4    -RI.LENP 
          SX5    X4          L = LEN[RAW] 
          LX4    RI.LENP
          CALL   GBD         GBD( FSCM = GP , RAW , L ) 
          SX6    B1 
          EQ     GNG
 IRP      TITLE  IRP - INITIALIZE REGION PROCESSING 
**        IRP - INITIALIZE REGION PROCESSING FOR A *SCR*
  
 IRP      ROUTINE 
          SA5    NN 
          LX4    B1,X5
          ALLOC  BST,X4+3    ALLOC( BST , 2*NN+3 )
  
*         SETUP *BST* FOR PROCESSING OF *SCR* 
*         INITIALIZE *BST,BIT* ENTRIES FOR HOLDING BLOCK
  
          SA4    IBA
          SA3    O.BIT
          SB5    X5          N = NN 
          SA1    X4          IP = [IBA] 
          SA5    A1-B1       IHW = [IBA-1]
          LX5    -IP.PBP+1
          SX6    X5          HN = 2*PB[IHW]  */ *BN* OF HOLDING BLOCK 
          MX7    0
          SA6    HBI         HBI(1) = HN
          MX0    -BA.HBBL 
          LX6    BA.BIP 
          LX0    BA.HBBP
          BX6    -X0+X6 
          SA6    X2          BST(0) = BAW(HBB,HN,0,0) 
          SB7    X2 
          SA7    X2+B1       BST(1) = 0;  I = 2 
          MX0    -IM.BIL
          SB3    X3+B1
          SB2    X5 
          LX0    IM.BIP 
          SA2    X3+B2
          BX7    -X0*X1      BN = BI[IP]   */ BN OF HEADER
          LX7    BI.PBNP-IM.BIP 
          BX7    X7+X2       PBN[BIT(HN)] = BN  */ LINK *HB* TO HEADER
          MX6    -BI.BVIL 
          LX6    BI.BVIP
          BX7    X6*X7       BVI[BIT(HN)] = 0 
          SA7    A2 
          SB2    B0          TLEN = 0 
  
 IRP1     LX1    59-IM.SCRP 
          PL     X1,IRP2     IF ^SCR[IP]   */ BLOCK NOT IN *LOOP* 
          LX1    1+IM.SCRP
          BX6    -X0*X1 
          BX7    X1 
          LX1    -IM.BIP
          SA2    B3+X1       RIW = BIT(BI[IP]+1)
          LX2    -RI.LENP 
          SB2    B2+X2       TLEN = TLEN + LEN[RIW] 
          LX6    BA.BIP-IM.BIP
          SA6    A6+2        BST(I) = BAW(0,BI[IP],0,0) 
          SA7    A6+1        BST(I+1) = 0;  I = I + 2 
  
 IRP2     SB5    B5-B1       N = N - 1
          SA1    A1+B1       IP = IP + 1
          NZ     B5,IRP1     IF N " 0 
  
          MX6    0
          SA6    A7+B1       BST(I) = 0    */ TABLE TERMINATOR
          SB6    A6+B1
          SX7    B6-B7       L.BST = I + 1
          SA7    L.BST
 IRP      SPACE  1,10 
*         INITIALIZE FLAGS, CLEAR REGION BIT VECTORS
  
          SA1    L.SBV
          SA2    DVA
          SETZERO X2,X1      SETZERO( [DVA] , L.SBV ) 
          MX5    -24
          BX7    -X5         MRA = ^MASK(36)
          SA7    MRA
          SA7    MRA.X       MRA.X = MRA
          SETZERO N.HB,N.CLC SETZERO( N.HB , N.CLC )
          SA1    L.TET
          MX6    0
          BX7    X1 
          SA7    ITL         ITL = L.TET
          SA7    TTI         TTI = L.TET
          SA6    NTP         NTP = 0
          SA6    LGL         LGL = 0
          SA6    UXR+1       UXR(2) = 0 
          SA6    NBIP        NBIP = 0 
  
*         GET HEADER NODE, SET LINENR OF *BOS*, LOOP LABEL, ETC.
  
          SX7    2
          SA7    BSI         BSI = 2
          CALL   RTB         READ FIRST BLOCK INTO *BLK*
  
          SA1    O.SEQ       T = [O.SEQ]
          SA3    IBA
          SA5    X1+5 
          SA4    X1 
          LX7    X5          LIH(2) = [T+5]  */ R2 WORD OF LOOP *LAB* 
          SA5    A5-B1       R1 = [T+4]      */ R1 WORD OF *LAB*
          BX6    X4 
          SA6    HBI+1       HBI(2) = [T]  */ R1 WORD OF *BOS*
          SA7    LIH+1
          LX6    -R1.INP
          SX6    X6          LINENR = IN[T]  */ LINE NUMBER OF LOOP 
          SA6    =XLINENR 
          SX7    X5 
          SA7    A7-B1       LIH(1) = IH[R1]
          MX7    0
          SA7    A5+B1       [T+5] = 0     */ CLEAR R2 WORD OF LABEL DEF
          SA3    X3-1        IPW = [IBA-1]
          LX3    59-IP.GLP
          PL     X3,IRP      IF ^GL[IPW]   */ NO LABEL TRANSFER NECESSAR
  
          LX3    IP.GLP-IP.FTP
          BX6    X3 
          SA6    FTH         FTH = FT[IPW] */ SAVE FOR *TRP*
 IRP      SPACE  1,10 
*         REGION HAS MORE THAN 1 PRED, SETUP *LGL* TO INDICATE CREATION 
*         OF A GENERATED LABEL FOR THE TRANSFERS INSIDE THE LOOP. 
  
          SA4    N.GL0
          UX5    B2,X5
          SX6    X4+B1       N.GL0 = N.GL0 + 1
          SA6    A4 
          SX5    X5          LL = IH[R1]
          SX6    X6+I.GL     GIH = I.GL + N.GL0 
          IX2    X6-X5
          LX2    18 
          BX7    X2+X5       LGL = SHIFT(GIH-LL,18) ! LL
          PX6    B2,X6
          SA7    LGL
          SA6    X1+4        [T+4] = TYIV(OC.LAB,0,GIH) 
  
          SA2    HBI
          SA1    O.BIT
          SX0    B1 
          SB3    X2 
          SA3    X1+B3
          LX0    BI.ILP 
          BX6    X0+X3       IL[BIT(HN)] = 1  */ SET *INIT* LAB BIT 
          SA6    A3 
  
*         SETUP INFO IN SYMTAB AND *LCT* IN CASE THERE ARE TRANSFERS
*         FROM LOOPS INSIDE THIS LOOP TO THE HEAD OF IT THAT WILL BE
*         ADJUSTED IN *POST*. 
  
          SA3    N.GL0
          LX3    LC.GLNP
          BX6    X3+X2
          SA4    L.LCT       L = L.LCT
          SA3    O.LCT
          SB3    X3 
          SA6    B3+X4       LCT(L) = LC(0,N.GL0,HBI) 
          SX7    X4+B1       L.LCT = L.LCT + 1
          SA7    A4 
          SA1    O.SYM
          LX5    1
          IX7    X1-X5
          SA5    X7          WORDA = SYM(IH)
          SX0    B1 
          LX0    P.LC 
          BX7    X0+X5
          MX0    -L.LCO 
          SA1    A5-B1       WORDB = WORDA-1
          LX5    59-P.LC
          PL     X5,IRP4     IF ^LC[WORDA] */ FIRST TIME
  
          BX7    -X0*X1      J = LCO[WORDB] 
+         SA2    B3+X7       JL = J 
          LX2    -LC.NEXTP
          SX7    X2+         J = NEXT[LCT(JL)]
          NZ     X7,*-1      IF J " 0 
  
          BX6    X4+X2       NEXT[LCT(JL)] = L.LCT - 1
          LX6    LC.NEXTP 
          SA6    A2 
          EQ     IRP5 
  
 IRP4     SA7    A5          LC[WORDA] = 1
          BX1    X0*X1
          BX7    X4+X1       LCO[WORDB] = L 
          SA7    A1 
  
 IRP5     EQ     IRP
 IHB      SPACE  3,14        IHB
**        IHB - INITIALIZE HOLDING BLOCK
  
 IHB      ROUTINE 
          SA2    HBI         HN = HBI(1)
          SA1    A2+B1
          MX0    -18
          SA4    O.TXT       R1 = [O.TXT] 
          SA5    LGL
          BX3    X0*X1
          IX6    X3+X2       [R1] = TYIV(OC.BOS,LINENR,HN)
          SA6    X4+
          ZR     X5,IHB      IF LGL = 0    */ NO GENERATED LABEL
  
          ALLOC  TXT,4       ALLOC( TXT , 4 ) 
          SB7    X2 
          SB2    OC.LAB 
          SX4    X5          LL = SETX(LGL)  */ CURRENT LOOP LABEL
          AX5    18 
          IX7    X4+X5       LIH = GLB[LGL]  */ SAVE GEN LABEL IN R2
          SA7    LIH         UPDATE LIH 
          SX6    X4 
          RJ     SRI         SRI(  LAB  0,LL )  */ MOVE LABEL OUT 
          EQ     IHB
 TRP      TITLE  TRP - TERMINATE REGION PROCESSING
**        TRP - TERMINATE REGION PROCESSING FOR A LOOP
  
 TRP      ROUTINE 
  
*         CHECK LOOP CONTROL VAR AND SET *M* BIT IN SYMTAB IF IT IS ^RD 
  
          SA4    LIH+1
          ZR     X4,TRP1     IF LIH(2) = 0 */ NOT A DO LOOP 
          SA1    O.UDT
          LX4    -IH.ICVP 
          SB4    X4 
          SB3    I.GL 
          GT     B4,B3,TRP1  IF LIH > I.GL */ LAB IH FROM FTH LOOP
          SA3    X1+B4       UI = UDT(ICV[LIH]) 
          LX3    59-UD.^RDP 
          PL     X3,TRP1     IF RD[UI]
          SA4    A4-B1       IH = LIH(1)   */ *IH* OF )XX 
          SA5    O.SYM
          SX7    B1 
          LX4    1
          IX5    X5-X4
          SA3    X5-1        WORDB = [O.SYM-2*IH-1] 
          LX7    P.FLG+OF.MP
          BX6    X3+X7       MAT[WORDB] = 1  */ SET MATERIALIZATION FLAG
          SA6    A3 
  
 TRP1     SA4    L.BST
          SX5    X4-5 
          RJ     CRB         RESET *UDT*
          SX6    0
          SA6    L.IIT       L.IIT = 0
          SA6    BSI         BSI = 0
          SA6    BBV         BBV = 0
  
          CALL   RTB         GET HOLDING BLOCK
          SA4    HBI
          SA5    O.SEQ
          MX7    -UD.STCP 
          BX6    X4 
          SA7    BCM         BCM = *REGION CLEAR MASK*
          SA6    BN          BN = HBI(1)
          CALL   FUD         FORM BIT VECTORS FOR *HB*
          SX6    1
          SA6    BBV         BBV = 1
          MX7    UD.MVL 
          LX7    UD.MVL+UD.MVP
          SA7    BCM         BCM = *MV* 
  
*         *HB* LIVE EXIT VECTOR IS REGION LIVE ENTRY VECTOR 
  
          SA1    VL 
          SA2    O.BVT
          SA3    L.BVT
          SA4    LEA
          IX7    X3-X1
          SB4    X2                        (B4) = [O.BVT] 
          SB5    B4+X7       LVA = O.BVT + L.BVT - VL 
          SB2    B0 
          SB3    X1 
 TRP2     SA5    X4+B2       MOVE( VL , [LEA] , LVA ) 
          BX6    X5 
          SA6    B5+B2
          SB2    B2+B1
          LT     B2,B3,TRP2 
  
*         SAVE REGION BIT VECTORS ( DEF, LU, USE, LX ) IN THE HEADER
*         NODE BIT VECTOR SLOT. 
  
          SA4    O.BIT
          SA5    HBI+1       BN = HBI(2)   */ BN OF HEADER
          SA2    DVA
          LX1    2
          SB6    X4 
          SA3    B6+X5       BIW = BIT(BN)
          LX3    -BI.BVIP 
          MOVE   X1,X2,B4+X3 MOVE( 4*VL , [DVA] , O.BVT + BVI[BIW] )
  
          SA1    FTH
          MI     X1,TRP3     IF FTH < 0    */ FALL THROUGH TO *HN*
          SA3    B6+X5       BIW = BIT(HN)
          LX3    59-BI.RBP
          MI     X3,TRP4     IF RB[BIW]    */ PROGRAM BLOCK 
          LX3    BI.RBP-BI.FTHP 
          PL     X3,TRP4     IF ^FTH[BIW]  */ INNER LP NOT *FTH*
  
*         LOOP CONTAINS A FALL THROUGH TO THE HEADER NODE, AND REMOTE 
*         ENTRY BY A JUMP, SET *FJ* IN *BIT* AND APPEND A FINAL *UJP* 
*         TO THE *HB*.
  
 TRP3     MX7    0           FTH = 0
          SA7    A1 
          SA1    HBI
          SA3    B6+X1
          SX0    B1 
          LX0    BI.FTHP
          BX6    X0+X3       FTH[BIT(HBI)] = 1
          SA6    A3 
          LX0    BI.FJP-BI.FTHP 
          BX6    X0+X6       FJ[BIT(HBI)] = 1 
          SA6    A3 
          CALL   MBT         MOVE *HB* TO *TXT* 
          ALLOC  TXT,4       ALLOC( TXT , 4 ) 
          SA5    N.GL0
          SB6    X3-8        TI = L.TXT - 8 
          SB2    OC.UJP 
          SX6    I.GL+X5
          SB7    X2          TB = O.TXT 
          MX7    0
          RJ     SRI         SRI(  UJP  0,I.GL+N.GL0 )
          R=     B2,OC.EOQ
          MX6    0
          RJ     SRI         SRI(  EOQ  0,0 ) 
          CALL   WTB         REWRITE THE BLOCK
          CALL   RTB         RESET *SEQ* POINTERS 
  
 TRP4     SA5    O.SEQ
          SA4    X5-1        BHW = [O.SEQ-1]
          SX0    B1 
          LX0    BH.PRIP
          BX4    -X0*X4      PRI[BHW] = 0 
          LX0    BH.BSTP+BH.BSTL-1-BH.PRIP
          BX6    X0+X4       BST[BHW] = 1S17  */ INDICATE NOT IN *BST*
          SA6    A4 
          RJ     CBT         CLEAR BLOCK TABLE
          EQ     TRP
 CBT      SPACE  3,14 
**        CBT - CLEAR *BST*, RELEASE BLOCKS THAT WERE NOT CODED 
*         INSERT *HB* NUMBER OF THIS LOOP IN *BIT* ENTRIES OF THIS
*         REGION. THIS INFO IS USED ON THE BACK PASS IN *POST*. 
  
 CBT0     SX6    0
          SA6    L.BST       L.BST = 0
 CBT      ROUTINE 
          SX6    0
          SA6    BSI         BSI = 0
  
 CBT1     SA1    BSI
          SA2    O.BST
          SA3    O.BIT
          SX6    X1 
          SB4    X2 
  
 CBT2     SX6    X6+2        BSI = BSI + 2
          SA5    B4+X6       BAW = BST(BSI) 
          SB5    X3 
          ZR     X5,CBT0     IF BAW = 0    */ END OF *BST*
          LX5    -BA.FWAP 
          SB6    X5-CBT 
          LX5    BA.FWAP-BA.BIP    J = BI[BAW]
          SA4    B5+X5       BIW = BIT(J) 
          SA2    HBI
          MX0    -BI.OLNL 
          BX7    X4 
          LX7    -BI.OLNP 
          BX7    X0*X7
          BX7    X2+X7       OLN[BIT(J)] = HBI
          LX7    BI.OLNP
          SA7    A4 
  
 CBT3     MI     B6,CBT2     IF FWA[BAW] < CBT  */ DUMMY BLOCK
          LX4    59-BI.CBP
          MI     X4,CBT2     IF CB[BAW] 
          SA6    A1 
          CALL   RBS         RELEASE THE BLOCK
          EQ     CBT1 
 CIC      TITLE  CIC - CONVERT INTERVAL TO CODE 
**        CIC - CONVERT INTERVAL TO CODE
* 
*         ENTRY  (IBA) = POINTER TO *IM* WORD OF INTERVAL 
*                (NN) = N. NODES IN INTERVAL
* 
*         EXIT   (IBA) = POINTS TO *IP* WORD OF NEXT INTERVAL 
*                INTERVAL CODED AND WRITTEN TO SCRATCH FILE.
  
 CIC      ROUTINE 
  
*         SCAN INTERVAL LIST TO FORM AN *EBB* 
  
 CIC1     SA1    IBA
          SA3    O.BIT
          SA2    A1+B1
          SB3    X3                        (B3) = [O.BIT] 
          SA5    X1          IP = [IBA] 
          SB2    X2          N = NN 
          BX2    X5          FIP = [IP] 
          LX5    -IM.BIP     I = BI[IP] 
          SA4    B3+X5
          BX0    X4          FBIW = BIT(I)
          LX4    59-BI.RBP
          PL     X4,CIC3     IF ^RB[BIT(I)]  */ A HOLDING BLOCK 
  
*         ADD SUCCESSORS THAT DO NOT HAVE AN INITIAL LABEL, ETC.
  
 CIC2     SB2    B2-B1       N = N - 1
          SA5    A5+B1       IP = IP + 1
          ZR     B2,CIC4     IF N = 0      */ END OF LIST 
          BX6    X2-X5
          LX6    59-IM.SCRP 
          MI     X6,CIC4     IF SCR[IP] " SCR[FIP]  */ DIFF REGIONS 
          LX5    -IM.BIP     I = BI[IP] 
          SA4    B3+X5       BIW = BIT(I) 
          LX4    59-BI.RBP
          PL     X4,CIC3     IF ^RB[BIW]   */ A HOLDING BLOCK 
          LX4    BI.RBP-BI.ILP
          PL     X4,CIC2     IF ^IL[BIW]
          EQ     CIC4 
  
*         TERMINATE LIST AFTER THIS NODE
  
 CIC3     SX6    A5+B1       IPL = IP + 1 
          EQ     CIC5 
  
 CIC4     SX6    A5+         IPL = IP      */ TERMINATE BEFORE
  
 CIC5     LX0    59-BI.CBP
          IX6    X6-X1       K = IPL - IBA */ N. NODES IN *EBB* 
          PL     X0,CIC7     IF ^CB[FBIW]  */ NOT YET CODED 
  
*         ADVANCE POINTERS TO UNPROCESSED PART OF THE INTERVAL
  
 CIC6     SA2    A1+B1
          IX7    X6+X1       IBA = IBA + K
          SA7    A1 
          IX6    X2-X6       NN = NN - K
          SA6    A2 
          NZ     X6,CIC1     IF NN " 0
  
          EQ     CIC
  
*         SET FP/LVL EXPANSION MODE, AND SETUP A *BST* FOR THIS *EBB*.
  
 CIC7     SX0    B1 
          LX2    -IM.SCRP 
          BX3    X0*X2
          SX7    X3+3        EMF = 3+SCR[FIP]  */ FP/LVL EXPANSION FLG
          SA7    EMF
          BX5    X6 
          LX2    B1,X6
          SA6    CICA 
          MX0    -IM.BIL
          ALLOC  BST,X2+3    ALLOC( BST , 2*K+3 ) 
          SA1    IBA
          SB2    X5          N = K
          MX7    0
          SA5    X1          IP = [IBA] 
          SA7    X2          BST(0) = 0 
          LX0    IM.BIP 
          SA7    X2+B1       BST(1) = 0;  I = 2 
  
 CIC8     BX6    -X0*X5 
          LX6    BA.BIP-IM.BIP
          SA6    A7+B1       BST(I) = BAW(0,BI[IP],0,0) 
          BX7    X5 
          SA7    A6+B1       BST(I+1) = [IP];  I = I + 2
          SB2    B2-B1       N = N - 1
          SA5    A5+B1       IP = IP + 1
          NZ     B2,CIC8     IF N " 0 
  
          MX7    0
          SA7    A7+B1       BST(I) = 0    */ *BST* TERMINATOR
          SA7    MAXW        MAXW = 0 
          SA7    N.EBB       N.EBB = 0
  
          CLCM   CHB         COMBINE HOLDING BLOCKS 
  
          CLCM   RDD         REMOVE DEAD DEFS 
  
          CALL   CBB         COMBINE BASIC BLOCKS 
  
          CLCM   CXB         CODE EXTENDED BLOCKS 
  
          RJ     CBT         CLEAR *BST*
          SA2    CICA 
          SA1    IBA
          BX6    X2 
          EQ     CIC6 
  
 CICA     BSS    1
 CBB      TITLE  CBB - COMBINE BASIC BLOCKS TO FORM EXTENDED BLOCK
**        CBB - COMBINE BASIC BLOCKS TO FORM AN EXTENDED BLOCK. 
* 
*         ENTRY  (EMF) = FP/LEVEL EXPANSION MODE
* 
*         EXIT   EXTENDED BLOCK WRITTEN BACK TO *BLK* 
*                MAXW, N.EBB UPDATED. 
  
 CBB      ROUTINE 
          SX6    2           BSIL = 2 
          SA6    BSIL 
  
 CBB1     SA1    BSIL        I = BSIL 
          SA2    O.BST
          SA3    O.BIT
          SA4    M.EBL
          SB3    X2                        (B3) = [O.BST] 
          BX6    X1          BSI = BSIL 
          SA6    BSI
          SB4    X3                        (B4) = [O.BIT] 
          SB7    X4                        (B7) = M.EBL 
          SA5    B3+X1       BAW = BST(I) 
          SA0    X1 
          ZR     X5,CBB      IF BAW = 0    */ END OF *BST*
  
          LX5    -BA.LENP 
          SB6    X5          TLEN = LEN[BAW]  */ TOTAL LENGTH OF EBB
          LX5    BA.LENP-BA.BIP 
          SA4    B4+X5       BIW = BIT(BI[BAW]) 
          LX4    59-BI.RBP
          PL     X4,CBB3     IF ^RB[BIW]   */ HOLDING BLOCK 
          SB2    2
          SX7    X5+         LBN = BI[BAW]
  
*         ADD SUCCESSORS OF THIS BLOCK UNTIL *IL*, SPACE OVERFLOW, ETC. 
  
 CBB2     SX1    X1+B2       I = I + 2
          LX4    BI.RBP-BI.FJP
          GT     B6,B7,CBB3A IF TLEN > M.EBL  */ SPACE OVERFLOW 
          MI     X4,CBB4     IF FJ[BIW] 
          SX7    X7+B2       LBN = LBN + 2
          SA5    B3+X1       BAW = BST(I) 
          ZR     X5,CBB4     IF BAW = 0    */ END OF *BST*
          LX5    -BA.BIP     BN = BI[BAW] 
          SA4    B4+X5       BIW = BIT(BN)
          LX4    59-BI.ILP
          MI     X4,CBB4     IF IL[BIW] 
          BX6    X5-X7
          SB5    X6 
          LX5    BA.BIP-BA.LENP 
          SB6    B6+X5       TLEN = TLEN + LEN[BAW] 
          LX4    BI.ILP-BI.RBP
          PL     X4,CBB3B    IF ^RB[BIW]
          ZR     B5,CBB2     IF BN[BAW] = LBN  */ BLOCKS CONTIGIOUS 
          EQ     CBB4 
  
 CBB3     SX6    X1+2        LIM = I + 2
          EQ     CBB5 
  
 CBB3A    SB7    B7+300B
          LE     B6,B7,CBB4  IF TLEN @ M.EBL + 300B 
  
          SX2    A0+B2
          IX7    X1-X2
          ZR     X7,CBB4     IF I = BSIL + 2  */ ONLY 1 BIG BLOCK 
          SX1    X1-2        I = I - 2
          EQ     CBB4 
  
*         ENCOUNTERED *HB* IN SEQ - CHECK IF THE LOOP HEADER BLK
*         IS A DIRECT SUCCESSOR OF THE PREV. BLK IN THE BST.
*         IF SO INCLUDE THE *HB* IN THE *EBB*.
  
 CBB3B    LX4    BI.RBP-BI.PBNP+1       HDRBLK = PBN[BIW] 
          SB5    X1-2 
          SA2    B3+B5
          LX2    -BA.BIP     PBLK = BI[BST(I-2)]
          IX7    X4-X2
          SB5    X7 
          NE     B5,B2,CBB4  IF PBLK+2 " HDRBLK 
          SX1    X1+B2
  
  
 CBB4     SX6    X1+         LIM = I
  
 CBB5     SA6    A1+B1       BSIL(2) = LIM
          SX7    4
          SB5    B0          J = 0
          SA7    L.TXT       L.TXT = 4
          SB6    A0          I = BSIL 
          SB7    X6 
  
*         COUNT NUMBER OF NON-EMPTY BLOCKS IN *EBB* 
  
 CBB6     SA5    B3+B6       BAW = BST(I) 
          SB6    B6+2        I = I + 2
          LX5    -BA.LENP 
          SB2    X5-8 
          LE     B2,CBB7     IF LEN[BAW] @ 8
  
          NZ     B5,CBB8     IF J " 0      */ MORE THAN 1 NON-EMPTY BLOCK 
          SB5    B6-2        J = I - 2     */ BST INDX OF FIRST 
  
 CBB7     LT     B6,B7,CBB6  IF I < BSIL(2) 
  
          ZR     B5,CBB15    IF J = 0      */ NO NON-EMPTY BLOCKS 
  
          SX6    B5+         BSI = J
          SA6    BSIL        BSIL = J 
          SA6    BSI
          EQ     CBB10
  
*         FORM AN EXTENDED BASIC BLOCK ( *EBB* )
  
 CBB8     SA5    O.BST
          SA4    BSI
          SB5    X5 
          SA1    B5+X4       BAW = BST(BSI) 
          LX1    -BA.LENP 
          SB2    X1-8 
          LE     B2,CBB9     IF LEN[BAW] @ 8  */ EMPTY BLOCK
  
          CALL   RTB         READ BLOCK IN
          SA2    O.SEQ       T = [O.SEQ]
          SB2    OC.EOS 
          SA4    =XF.RDT+B2 
          SA3    X2 
          PX7    B2,X3       OC[T] = OC.EOQ 
          SA7    A3 
          MX6    0
          BX7    X4 
          SA7    A7+2        [T+2] = RDT(OC.EOS)
          CALL   MPB ( 0 )   MERGE BLOCKS 
  
          CALL   RBS         RELEASE THE BLOCK
 CBB9     SA1    BSI
          SA2    BSIL+1 
          SX6    X1+2        BSI = BSI + 2
          IX7    X6-X2
          SA6    A1 
          MI     X7,CBB8     IF BSI < BSIL(2) 
  
          SA1    O.TXT
          SA2    X1          T = [O.TXT]
          PX7    B1,X2       OC[T] = OC.BOS 
          SA7    A2+
          SA1    BSIL 
          MX6    0
          BX7    X1          BSI = BSIL(1)
          SA7    BSI
          CALL   SQZB        SQUEEZE THE EXTENDED BLOCK 
          SA1    EMF
          SA2    =XESRA-1+X1
          SA3    X2 
          ZR     X3,CBB13    IF [ESRA(EMF)] = 0  */ NO FP OR L2 IN PROG 
          CALL   WTB         MOVE EBB FROM *TXT* TO *BLK* 
  
*         EXPAND SPECIAL MEMORY REFS AND MERGE/SQZ BLOCK
  
 CBB10    CALL   RTB         READ BLOCK IN
          SA5    EMF
          MX6    1
          CALL   ESR         ESR( EMF , 1S59 )  */ EXPAND SPECIAL REFS
          SA1    L.MLT
          ZR     X1,CBB11    IF L.MLT = 0  */ NO MODS TO THIS BLOCK 
          SX6    B1 
          CALL   MPB ( 1 )   MERGE MODS AND SQUEEZE THE BLOCK 
          EQ     CBB13
  
 CBB11    CALL   MBT         MOVE BLOCK TO *TXT*
  
 CBB13    SX6    B1 
          CALL   RIO         REORDER THE INSTRUCTIONS 
          SA2    MAXW 
          SA4    N.EBB
          IX3    X2-X6
          PL     X3,CBB14    MAXW = MAX( MAXW , SIO.MAX ) 
          SA6    A2 
 CBB14    SX6    X4+B1       N.EBB = N.EBB + 1
          SA6    A4 
          CALL   WTB         WRITE BLOCK BACK TO *BLK*
  
 CBB15    SA5    BSIL+1 
          BX7    X5          BSIL(1) = BSIL(2)
          SA7    A5-B1
          EQ     CBB1 
  
 BSIL     BSS    2           *BST* LIMITS 
 ATT      EJECT 
**        ATT - ADJUST *TET* TABLE FOR *GRA* AND *BDT*.  CLEAR *REG* FIE
*         FIELD, UPDATE INFO OF EQUIVALENCED ENTRIES. 
  
 ATT      ROUTINE 
          SA2    ITL
          SA3    N.GT 
          SA1    O.TET
          SB2    X2          I = ITL
          SB3    X3          L = N.GT 
          EQ     B2,B3,ATT3  IF ITL = N.GT */ NO TET"S CREATED
  
*         CLEAR *REG* FIELD OF *TET*"S CREATED IN THIS LOOP FOR *GRA*.
  
          MX0    -T.REGL
          LX0    T.REGP 
          MX4    -1 
          LX4    T.CALP                          */ SEE STS IN SQZ
          BX0    X0*X4                           */ UNLOCK CA FIELD 
 ATT2     SA2    X1+B2
          BX6    X0*X2       REG[TET(I)] = 0
          SB2    B2+B1       I = I + 1
          SA6    A2 
          LT     B2,B3,ATT2  IF I < L 
  
 ATT3     SA4    L.TET
          SB5    X1 
          SB4    X4          I = L.TET
          EQ     B4,B3,ATT   IF L.TET = N.GT  */ NO TST SQUEEZING 
  
*         MOVE *IP* FIELDS OF THE EQUIVED ENTRIES TO THEIR BASE MEMBERS.
  
          MX0    -T.IPFL
          SX6    B3          L.TET = N.GT 
          LX0    T.IPFP 
          MX1    1+T.CAL
          SA6    A4 
          LX1    T.CAL
  
 ATT4     SB4    B4-B1       I = I - 1
          SA2    B5+B4       TI = TET(I)
          BX7    X1*X2       C = CA[TI] 
          SA3    B5+X2
          BX4    -X0*X3      IPI = IPF[TET(C)]
          IX6    X4+X7       TET(C) = TETW(INV[TI],IPI,0,C) 
          SA6    A3+
          GT     B4,B3,ATT4  IF I > L 
  
          EQ     ATT
 CRB      SPACE  3,18        CRB
**        CRB - CLEAR REGION BITS IN *UDT*
* 
*         ENTRY  (X5) = 0 IF N.BLK IN REGION = 1
  
 CRB2     SA1    O.UDT
          SA2    N.VAR
          SA4    X1+4        UI = O.UDT + 4 
          SB4    X2-2        I = N.VAR - 2
  
 CRB3     BX6    -X0*X4      RBITS[UI] = 0
          SA6    A4 
          SB4    B4-1        I = I - 1
          SA4    A4+2        UI = UI + 2
          GT     B4,CRB3     IF I > 0 
  
 CRB      ROUTINE 
          MX0    -UD.RFP
          SA2    UXR+1
          NZ     X5,CRB2     IF N.BLK > 1 
          NZ     X2,CRB2     IF UXR(2) " 0 */ EXT REF 
  
          SA1    O.MVL
          SA5    X1+1        MI = [O.MVL] + 1 
          ZR     X5,CRB      IF [MI] = 0
  
 CRB1     SA4    X5          UI = [MI]
          SA5    A5+B1       MI = MI + 1
          BX6    -X0*X4      RBITS[UI] = 0
          SA6    A4 
          NZ     X5,CRB1     IF [MI] " 0
  
          EQ     CRB
 EBV      TITLE  EBV - EXPAND BIT VECTOR TO *UDI* 
**        EBV - EXPAND BIT VECTOR TO SET BITS IN *UDI*
* 
*         ENTRY  (X4) = BVA , BIT VECTOR ADDRESS
*                (X5) = BITS  , TO BE SET 
  
 EBV      ROUTINE 
          SA4    X4-1        BI = BVA - 1 
          SA1    BVL
          SA2    O.UDT
          BX0    X5 
          SB6    X1+B1       L = BVL + 1
          SB7    X2+4-120    U0 = O.UDT + 4 - 120 
  
 EBV1     SB6    B6-B1       L = L - 1
          SA4    A4+B1       BI = BI + 1;  BV = [BI]
          SB7    B7+120      U0 = U0 + 120
          MI     B6,EBV      IF L < 0      */ END OF VECTOR 
          NZ     X4,EBV2     IF BV " 0
          PL     X4,EBV1     IF BV = +0 
  
 EBV2     MX1    12 
          BX5    X1*X4       TB = MASK(12) & BV 
          ZR     X5,EBV4     IF TB = 0
  
          LX5    -12
          MX7    13                        */ EXPAND UPPER 12 BITS
          SB3    59 
 EBV3     PX5    X5 
          NX6    B2,X5       J = NORMC( PACK(0,TB) )
          SB4    B3-B2
          AX2    B2,X7
          SB5    B4+B4       K = 2*(59-J) 
          BX5    -X2*X5      TB = ^MASK(J+13) & TB
          SA3    B7+B5       UI = U0 + K
          BX6    X0+X3       [UI] = BITS ! [UI] 
          SA6    A3 
          NZ     X5,EBV3     IF TB " 0
  
          BX4    -X1*X4      BV = ^MASK(12) & BV
          ZR     X4,EBV1     IF BV = 0
  
 EBV4     SX1    B1 
          PX5    X4                        */ EXPAND LOWER 48 BITS
          SB3    47 
  
 EBV5     NX6    B2,X5
          SB4    B3-B2       J = 47 - NORMC( PACK(0,BV) ) 
          SB5    B4+B4
          LX2    B4,X1
          SA3    B7+B5       UI = U0 + 2*J
          IX4    X4-X2       BV = BV - SHIFT(1,J) 
          BX6    X0+X3       [UI] = BITS ! [UI] 
          PX5    X4 
          SA6    A3 
          NZ     X4,EBV5     IF BV " 0
  
          EQ     EBV1 
 FUD      TITLE  FUD - FORM USE/DEF BIT VECTORS 
**        FUD - FORM USE/DEF BIT VECTOR INFORMATION FOR A BLOCK 
*         FUD OPERATES IN TWO MODES, BUILD BIT VECTORS MODE, AND
*         USE/DEF ONLY MODE.  COLLECTION OF USE/DEF INFORMATION FOR 
*         SCALARS WHICH ARE NOT CLASS MEMBERS IS STRAIGHTFOWARD, AND
*         POSES NO PROBLEMS.  THE *CM* ( CLASS MEMBER ) CASE POSES MORE 
*         PROBLEMS SINCE WE DONT KNOW THE SET OF VALUES THAT A USE/DEF
*         OF A *CR* ACCESSES OR CHANGES.  LACKING THIS INFORMATION, WE
*         MAKE THE FOLLOWING ASSUMPTIONS, WHICH ENLARGE THE LIVE EXIT 
*         AND *UBD* BIT VECTORS.
*         A) A *CR* USE, USES EVERY MEMBER ( *CM* ) OF THE CLASS. 
*         B) A *CR* DEF DOESNT DEFINE ANY *CM* THAT WAS NOT EXPLICITELY 
*         DEFINED, HENCE WE SHOW A USE AT THE POINTS WERE A *CR* IS 
*         DEFINED BEFORE USEAGE.
* 
*         ENTRY  (X5) = [O.SEQ] 
*         (BBV) = 0 IF BUILDING BIT VECTORS 
* 
*         EXIT   DEFR, ^RD, IST, STC FIELDS SET IN *UDT*
*         DEF, UBD AND USE BIT VECTORS SETUP IN *BVT* ( BBV = 0 ) 
  
 .BCM     EQU    60-UD.STCP 
 BCM      VFD    .BCM/-0,*P/0  BLOCK CLEAR MASK 
  
 RDB      BFMW   UD,(DEFR,^RD,SMS) REGION DEF BITS FOR NO CODE MOTION 
 FUDA     BFMW   UD,(DEFR,DEF,^RD,IST)
 FUDB     BFMW   UD,(DEFR,DEF,USE,^RD,IST)
 FUDC     BFMW   UD,(DEF,CR)
 FUDD     BFMW   UD,(DEF,CM)
 FUDE     BFMW   UD,(DEF,^RD,IST) 
  
*         MCM - MARK CLASS MEMBERS TO SHOW A USE OF THEM
  
 MCM      MACRO  NEXT 
          LOCAL  MCM1,MCM2
          SB3    A0 
          LX6    59-UD.CRP
          NZ     B3,NEXT     IF BBV " 0 
          PL     X6,NEXT     IF ^CR[UI] 
          LX6    1+UD.CRP-UD.ECLP 
          SB3    X6          K = ECL[UI]
          ZR     B3,NEXT     IF K = 0      */ NO CLASS MEMBERS
* 
          SX4    B1 
          LX4    UD.USEP
          MX2    -UD.MVL
          LX2    UD.MVP 
* 
 MCM1     SA1    B5+B3       UI = UL = UDT(K) 
          BX6    X1+X4
          SA6    A1          USE[UI] = 1
          BX7    -X2*X1 
          NZ     X7,MCM2     IF MV[UL]
          SX7    A1 
          SA7    A7+B1       MI = MI + 1;  [MI] = UI
 MCM2     LX1    -UD.ECLP 
          SB3    X1          K = ECL[UI]
          NZ     B3,MCM1     IF K " 0 
          ENDM
 FUD      SPACE  3,14 
 FUD      ROUTINE 
          SA1    O.UDT
          SA2    X5+B1       R2 = O.SEQ + 1 
          SB2    B1+B1
          SA3    BBV
          LX2    -R2.TXTLP
          SB5    X1 
          SB6    B0          CDEF = 0 
          MX0    -D.LSJL
          IX6    X5+X2
          SA0    X3+                       (A0) = BBV 
          SA3    O.MVL
          SB7    X6          O.IOL = O.SEQ + TXTL[R2]  */ I/O LIST INFO 
          SA4    X5+B2       DI = TBA + 2 
          MX7    0
          LX0    D.LSJP 
          SA7    UXR         UXR = 0
          SA7    X3          MI = [O.MVL];  [MI] = 0 */ MARKED VAR LIST 
          EQ     FUD2 
  
*         SCAN 1 - SCAN BLOCK FOR LD/ST/RJX"S THAT ARE CHAINED TO *UDI* 
*         AND SET BITS IN *UDT*. FORM LIST OF MARKED VARIABLES. 
  
*         CHECK *UDT* ENTRY AND ADD TO MARKED LIST IF FIRST OCCURANCE 
  
 FUD1     LX3    D.LSJP-UD.MVP
          BX4    -X0*X3 
          NZ     X4,FUD2     IF MV[UL]     */ IF ON MARKED LIST 
          SX7    A3 
          SA7    A7+1        MI = MI + 1;  [MI] = UL  */ SAVE *UDI* ADDR
  
 FUD2     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          UX6    B3,X5
          BX7    -X0*X4 
          ZR     B3,FUD16    IF OC[R1] = 0 */ END OF BLOCK
          ZR     X7,FUD2     IF ^LSJ[DI]
  
*         PROCESS *LD*
  
          LX7    59-D.LDP 
          PL     X7,FUD3     IF ^LD[DI] 
          LX5    -R1.INP
          SB3    X5          I = IN[R1] 
          LE     B3,B2,FUD2  IF I @ 2      */ ^ IN UDT ! LD ONLY
          SA3    B5+B3       UI = UL = O.UDT + I
          LX7    1+UD.USEP
          BX6    X7+X3       USE[UI] = 1
          SA6    A3 
          BX7    X7*X3
          NZ     X7,FUD2     IF USE[UL] 
  
          MCM    FUD1        MARK CLASS REFS
          EQ     FUD1 
 FUD      SPACE  2,10 
*         PROCESS *ST*
  
 FUD3     LX7    D.LDP-D.STP
          PL     X7,FUD5     IF ^ST[DI] 
          LX5    -R1.INP
          SB3    X5          I = IN[R1] 
          ZR     B3,FUD2     IF I = 0 
          SA3    B5+B3       UI = UL = O.UDT + I
          MX1    UD.DEFBL 
          LX1    UD.DEFBL+UD.DEFBP
          BX6    X1+X3       DEFR[UI] = DEF[UI] = 1 
          SX5    B6 
          LX7    1+UD.STCP
          IX6    X7+X6       STC[UI] = STC[UI] + 1
          LX3    -UD.CBP
          BX5    X5+X3       CDEF = CDEF ! CB[UI] 
          SA6    A3 
          SB6    X5 
          LX3    UD.CBP+59-UD.USEP
          MI     X3,FUD2     IF USE[UI]    */ USE BEFORE DEF
          LX7    UD.DBUP-UD.STCP
          BX6    X7+X6       DBU[UI] = 1
          LX3    1+UD.USEP
          SA6    A6 
          MCM    FUD1        SHOW USES OF CLASS MEMBERS 
          EQ     FUD1 
  
*         PROCESS *RJX* ( FUNCTION CALL ) 
  
 FUD5     LX4    59-D.TYP 
          PL     X4,FUD2     IF TYPE[DI] " IV 
          SA3    A4-B1       R2 = DI - 1
          LX3    -FI.INDXP
          ZR     X3,FUD2     IF [R2] = 0   */ *UJP* OR SUCH 
          SA1    MRA
          SA2    B7+X3       LI = O.IOL + INDX[R2] */ PARAM LIST ADDR 
          LX3    FI.INDXP-FI.REGPP
          SX7    X3 
          BX6    X7*X1       MRA = MRA & REGP[R2] 
          LX3    FI.REGPP-FI.LENP 
          SA6    A1 
          SB4    X3          J = LEN[R2]   */ LIST LENGTH 
          MX7    -FI.FTL
          LX3    FI.LENP-FI.FTP 
          BX7    -X7*X3 
          SB3    X7 
          SA3    XRF
          SX6    B1 
          IX6    X3+X6       XRF = XRF + 1 */ COUNT N.EXT REFS
          SA6    A3 
          EQ     B3,B2,FUD2  IF FT[R2] = 2 */ *BEF* 
          EQ     B3,B1,FUD12 IF FT[R2] = 1 */ USER FUNCTION 
  
*         PROCESS I/O APLIST
  
          ZR     B4,FUD2     IF J = 0 
          LX0    UD.MVP-D.LSJP
  
 FUD7     SA3    B5+X2       UI = O.UDT + [LI]
          LX2    59-AP.IOP
          BX6    -X0*X3 
          SB4    B4-1        J = J - 1
          NZ     X6,FUD8     IF MV[UI]
          SX7    A3 
          SA7    A7+B1       MI = MI + 1;  [MI] = UI
  
 FUD8     SX5    B1 
          MI     X2,FUD9     IF IO[LI] " 0 */ AN INPUT OP 
          LX5    UD.USEP
          BX6    X5+X3       USE[UI] = 1
          SA6    A3 
          EQ     FUD11
  
 FUD9     SA1    FUDA 
          BX6    X1+X3       (DEFR,DEF,^RD,IST)[UI] = 1 
          LX3    59-UD.USEP 
          MI     X3,FUD10    IF USE[UI] 
          LX2    59-AP.USEP 
          PL     X2,FUD9A    IF ^USE[LI]   */ ^ USE FIRST IN LIST 
          LX5    UD.USEP
          BX6    X5+X6       USE[UI] = 1
          EQ     FUD10
  
 FUD9A    LX5    UD.DBUP     DBU[UI] = 1
          BX6    X5+X6
 FUD10    SX7    B6 
          LX3    1+UD.USEP-UD.CBP 
          BX4    X7+X3       CDEF = CDEF ! CB[UI] 
          SB6    X4 
          SA6    A3+
          LX3    UD.CBP 
  
 FUD11    LX3    59-UD.USEP 
          MI     X3,FUD11A   IF USE[UI]    */ PREVIOUS USE
          MCM    FUD11A      SHOW USES OF CLASS MEMBERS 
  
 FUD11A   SA2    A2+B1       LI = LI + 1
          NZ     B4,FUD7     IF J " 0 
  
          LX0    D.LSJP-UD.MVP
          EQ     FUD2 
  
*         PROCESS USER FUNCTION 
  
 FUD12    SX6    B1 
          SA6    UXR         UXR = 1       */ INDICATE COMMON VAR SPOIL 
          SA6    A6+B1       UXR(2) = 1 
          ZR     B4,FUD2     IF J = 0      */ NO ARG LIST 
          LX0    UD.MVP-D.LSJP
          SX5    B6 
  
 FUD13    SB3    X2+         I = [LI] 
          LE     B3,B2,FUD15 IF I @ 2      */ ^ IN UDT ! LD ONLY
          SA3    B5+X2       UI = O.UDT + I 
          SA1    FUDB 
          BX4    -X0*X3 
          NZ     X4,FUD14    IF MV[UI]
          SX7    A3 
          SA7    A7+B1       MI = MI + 1;  [MI] = UI
  
 FUD14    BX6    X1+X3       (DEFR,DEF,USE,^RD,IST)[UI] = 1 
          LX3    -UD.CBP
          BX5    X3+X5       CDEF = CDEF ! CB[UI] 
          SA6    A3 
          LX3    UD.CBP+59-UD.USEP
          MI     X3,FUD15    IF USE[UL]    */ PREVIOUS USES 
          MCM    FUD15       MARK CLASS MEMBERS AS USES 
  
 FUD15    SB4    B4-B1       J = J - 1
          SA2    A2+B1       LI = LI + 1
          NZ     B4,FUD13    IF J " 0 
  
          SB6    X5 
          LX0    D.LSJP-UD.MVP
          EQ     FUD2 
 FUD      SPACE  3,14 
*         SCAN 2 - IF *CDEF* " 0 , CLASS REFS ( INDEXED STORES ) OR 
*         CLASS MEMBERS WERE DEFINED IN THE BLOCK. PROPAGATE THE DEFS TO
*         THE CLASS.
  
 FUD16    MX2    -UD.CBL
          SX1    B6 
          BX6    -X2*X1 
          SB7    A7          ML = MI       */ END OF SCAN 1 LIST
          ZR     X6,FUD24    IF CDEF = 0
          LX6    UD.CBP+59-UD.CRP 
          SB6    X6 
          LX0    UD.MVP-D.LSJP
          SA2    FUDA 
          PL     X6,FUD20    IF ^CR[CDEF]  */ IF NO CLASS REFS
  
          SA5    B7+B1       I = ML + 1 
          SA1    FUDC 
 FUD17    SA5    A5-B1       I = I - 1
          SA4    X5          UI = [I] 
          ZR     X5,FUD20    IF [I] = 0 
          BX6    -X1+X4 
          NZ     X6,FUD17    IF ^( DEF[UI] & CR[UI] ) 
  
          BX6    X2+X4       (DEFR,DEF,^RD,IST)[UI] = 1 
          LX4    -UD.ECLP 
          SB4    X4          J = ECL[UI]   */ FOLLOW CHAIN TO MEMBERS 
          SA6    A4 
          ZR     B4,FUD17    IF J = 0      */ NO CLASS MEMBERS
  
 FUD18    SA4    B5+B4       UI = O.UDT + J 
          BX3    -X0*X4 
          NZ     X3,FUD19    IF MV[UI]
          SX7    A4 
          SA7    A7+B1       MI = MI + 1;  [MI] = UI
  
 FUD19    BX6    X2+X4       (DEFR,DEF,^RD,IST)[UI] = 1 
          LX4    -UD.ECLP 
          SB4    X4          J = ECL[UI]
          SA6    A4 
          NZ     B4,FUD18    IF J " 0 
          EQ     FUD17
 FUD      SPACE  2,10 
*         SEARCH  MARKED VARS LIST FOR CLASS MEMBERS THAT WERE DEFINED
*         AND PROPAGATE THE DEF TO THE *CLASS REF* MEMBER.
  
 FUD20    ZR     B6,FUD24    IF CM[CDEF] = 0  */ NO CLASS MEMBERS DEFINE
          SA1    FUDD 
          SA2    FUDE 
          SA5    B7+B1       I = ML + 1 
  
 FUD21    SA5    A5-B1       I = I - 1
          SA4    X5          UI = [I] 
          ZR     X5,FUD24    IF [I] = 0    */ END OF LIST 
          BX6    -X1+X4 
          NZ     X6,FUD21    IF ^( DEF[UI] & CM[UI] ) 
          LX4    -UD.BMIP 
          SA3    B5+X4       UI = O.UDT + BMI[UI]  */ BASE MEMBER 
          BX4    -X0*X3 
          NZ     X4,FUD22    IF MV[UI]
          SX7    A3 
          SA7    A7+B1       MI = MI + 1;  [MI] = UI
  
 FUD22    BX6    X2+X3       (DEF,^RD,IST)[UI] = 1
          SA6    A3 
          EQ     FUD21
  
*         TERMINATE MARKED VAR LIST AND FORM BIT VECTORS ( BBV = 0 )
  
 FUD24    SA1    BN 
          SA2    O.BIT
          SA3    BBV
          SB2    X1 
          SA4    X2+B2       BIW = BIT(BN)
          MX7    0
          SA7    A7+B1       MI = MI + 1;  [MI] = 0 
          NZ     X3,FUD35    IF BBV " 0    */ NOT BUILDING BIT VECTORS
  
          SA5    BVL
          SA3    L.BVT
          SA2    O.BVT
          SB6    X3          OL = L.BVT 
          LX3    BI.BVIP
          SX1    X5+B1
          BX6    X3+X4       BVI[BIT(BN)] = L.BVT 
          LX1    2
          SA6    A4 
          LX3    -BI.BVIP 
          IX7    X1+X3       L.BVT = L.BVT + 4*(BVL+1)
          SA7    A3 
  
          IF     DEF,/DEBUG/FUD,2 
          SX6    X3 
          SA6    BVI
          SB7    X5+B1       VL = BVL + 1  */ VECTOR LENGTH 
          SA1    O.MVL
          SB6    X2+B6       BI = O.BVT + OL  */ *BVT* ADDRESS
          SX0    B1 
          NZ     X5,FUD30    IF BVL " 0 
 FUD      SPACE  2,10 
*         SETUP BIT VECTORS FOR PROGRAM WITH @ 60 REFERENCED VARIABLES
  
          MX6    0           DV = 0 
          SA3    X1+B1       MI = O.MVL + 1 
          BX5    X5-X5       DUV = 0
          MX4    0           UV = 0 
          ZR     X3,FUD26    IF [MI] = 0   */ NO REFED VARS IN BLOCK
          SA2    X3+B1       U2 = [MI] + 1
          SA1    X3          UW = [MI]
  
 FUD25    UX7    B2,X2       J = BITN[U2] 
          LX1    -UD.DEFP 
          BX2    X0*X1
          LX7    B2,X2
          BX6    X7+X6       DV = DV ! SHIFT( DEF[UW] , J ) 
          LX1    UD.DEFP-UD.DBUP
          BX2    X0*X1
          LX7    B2,X2
          SA3    A3+B1       MI = MI + 1
          BX5    X7+X5       DUV = DUV ! SHIFT( DBU[UW] , J ) 
          LX1    UD.DBUP-UD.USEP
          BX2    X0*X1
          LX7    B2,X2
          SA2    X3+B1       U2 = [MI] + 1
          BX4    X7+X4       UV = UV ! SHIFT( USE[UW] , J ) 
          SA1    X3          UW = [MI]
          NZ     X3,FUD25    IF [MI] " 0
  
 FUD26    SA1    UXR
          ZR     X1,FUD26A   IF UXR = 0 
          SA2    O.BVT
          SA3    X2          SV = [O.BVT]  */ COMMON VAR SPOIL VECTOR 
          BX6    X3+X6       DV = SV ! DV 
          BX5    -X3*X5      DUV = ^SV & DUV
          BX4    X3+X4       UV = SV ! UV 
  
 FUD26A   SA6    B6          [BI] = DV
          BX7    -X5*X4 
          SA7    B6+B1       [BI+1] = ^DUV & UV  */ UBD 
          BX6    X4 
          SA6    A7+B1       [BI+2] = UV
          SX7    0
          SA7    A6+B1       [BI+3] = 0    */ LX = 0
  
*         CLEAR BLOCK RELATIVE BITS IN *UDT*
  
 FUD27    BSS    0
          IF     DEF,/DEBUG/FUD,1 
          DCALL  PRNTBV,([O.BVT],BVI,=3)
  
 FUD28    SA1    O.MVL
          SA4    BCM
          SA5    X1+1        MI = O.MVL + 1 
          ZR     X5,FUD      IF [MI] = 0
  
 FUD29    SA2    X5          UW = [MI]
          SA5    A5+B1       MI = MI + 1
          BX6    -X4*X2      BCM[UW] = 0   */ CLEAR BLOCK / REGION BITS 
          SA6    A2 
          NZ     X5,FUD29    IF [MI] " 0
  
          EQ     FUD
 FUD      SPACE  3,30 
*         SETUP BIT VECTORS FOR PROGRAM WITH N.VAR > 60 
*         FIRST CHAIN *MVL* ENTRIES ON THEIR WORD INDEX 
  
 FUD30    SB5    B7-B1
          SX6    B7+B7
          SB4    B6+B7
          SA0    X6+B4       BT = BI + 3*VL  */ BUCKET TABLE
          MX7    0
          SA3    X1+B1       MI = O.MVL + 1 
          SB2    A0 
          SA7    A0 
  
+         SB5    B5-B1       FOR I = 0 TO VL-1; BT(I) = 0 
          SA7    A7+B1
          GT     B5,* 
  
          SA2    UXR
          SA5    O.BVT
          SB3    X2 
          SB4    B0          WN = 0        */ WORD NUMBER ( 0,1,... ) 
          SB5    X5 
          ZR     X3,FUD32    IF [MI] = 0   */ NO REFED VARS IN BLOCK
  
 FUD31    SA4    X3+B1       U2 = [MI] + 1;  W = WI[U2] 
          SA5    B2+X4
          SX7    A3 
          LX5    18 
          BX6    X5+X3       LINK[MI] = BT(W)  */ LINK THIS TO LAST 
          SA6    A3 
          SA7    A5          BT(W) = MI    */ POINT BUCKET TO THIS
          SA3    A3+B1       MI = MI + 1
          NZ     X3,FUD31    IF [MI] " 0
  
*         NOW FORM THE BIT VECTORS
  
 FUD32    SA2    A0          LP = [BT]     */ LIST POINTER
          MX6    0           DV = 0 
          BX5    X5-X5       DUV = 0
          SA3    X2          MI = [LP]
          MX4    0           UV = 0 
          SA0    A0+B1       BT = BT + 1
          ZR     X2,FUD34    IF LP = 0     */ LIST EMPTY FOR THIS WORD
  
 FUD33    SA2    X3+B1       U2 = [MI] + 1
          SA1    X3          UW = [MI]
          AX3    18          L = LINK[MI] 
          UX7    B2,X2       J = BITN[U2] 
          LX1    -UD.DEFP 
          BX2    X0*X1
          LX7    B2,X2
          BX6    X7+X6       DV = DV ! SHIFT( DEF[UW] , J ) 
          LX1    UD.DEFP-UD.DBUP
          BX2    X0*X1
          LX7    B2,X2
          BX5    X7+X5       DUV = DUV ! SHIFT( DBU[UW] , J ) 
          LX1    UD.DBUP-UD.USEP
          BX2    X0*X1
          LX7    B2,X2
          SX1    X3 
          BX4    X7+X4       UV = UV ! SHIFT( USE[UW] , J ) 
          SA3    X3          MI = [L]      */ NEXT ON CHAIN 
          NZ     X1,FUD33    IF L " 0 
  
 FUD34    ZR     B3,FUD34A   IF UXR = 0 
          SA3    B5+B4       SV = BVT(WN) 
          BX6    X3+X6       DV = SV ! DV 
          BX5    -X3*X5      DUV = ^SV & DUV
          BX4    X3+X4       UV = SV ! UV 
  
 FUD34A   SA6    B6+B4       SA = BI + WN;  [SA] = DV 
          BX7    -X5*X4 
          SB4    B4+B1       WN = WN + 1
          SA7    A6+B7       SA = SA + VL;  [SA] = ^DUV & UV  */ UBD
          BX6    X4 
          SA6    A7+B7       SA = SA + VL;  [SA] = UV 
          MX7    0
          SA7    A6+B7       SA = SA + VL;  [SA] = 0  */ LX = 0 
          LT     B4,B7,FUD32 IF WN < VL 
  
          EQ     FUD27
 FUD      EJECT 
*         BBV " 0 , IF PROGRAM BLOCK , THEN CLEAR BLOCK BITS
  
 FUD35    BSS    0
          IF     DEF,/DEBUG/FUD,1 
          DCALL  PRNTUDI,([O.UDT],L.UDT)   PRINT BITS SET 
  
          LX4    59-BI.RBP
          MI     X4,FUD28    IF RB[BIW]    */ PROGRAM BLOCK 
  
*         PROCESS HOLDING BLOCK, PROPAGATE OUT INFORMATION FROM INNER 
*         LOOP.  SET *DEFR, ^RD, IST* BITS FOR ALL VARIABLES DEFINED
*         IN THE INNER LOOP.  ACCUMULATE THE LOOP USEAGE VECTOR FOR GRA.
*         NOTE THAT THE LOOP WE ARE PROCESSING MUST CONTAIN AT LEAST
*         2 BLOCKS, SO *CRB* WILL CLEAR ALL OF *UDT*
  
          SA5    O.SEQ       T = [O.SEQ]
          SA1    N.HB 
          SA5    X5+B1       R2 = [T+1]    */ R2 OF *BOS* 
          SX7    B1 
          SX6    X1+B1       N.HB = N.HB + 1
          LX5    59-R2.UXRP 
          SA6    A1 
          PL     X5,FUD36    IF ^UXR[R2]   */ NO USER EXT REFS IN LP
          SA7    UXR+1       UXR(2) = 1 
  
 FUD36    SA1    MRA
          LX5    1+R2.UXRP-R2.MRAP
          BX6    X1*X5       MRA = MRA & MRA[R2]
          SA6    A1 
          SA1    MRA.X
          BX6    X1*X5       MRA.X = MRA.X & MRA[R2]
          SA6    A1 
          LX4    1+BI.RBP-BI.PBNP 
          SB3    X4          HN = PBN[BIW] */ BN OF HEADER
          SB5    B0          I = 0
          FBVA   B3          BVA = O.BVT + BVI[BIT(HN)] 
          SA5    LUV
          SB6    X7+B2       RUA = BVA + VL  */ *LU* VECTOR OF LOOP 
 FUD37    SA1    X5+B5
          SA2    B6+B5       LUV = LUV ! [RUA]
          SB5    B5+B1
          BX6    X1+X2
          SA6    A1 
          LT     B5,B2,FUD37
  
          SX4    X7 
          SA5    RDB
          RJ     EBV         SET REGION DEF BITS IN *UDT* 
  
          SA5    O.SEQ
          RJ     CHB         CHECK HOLDING BLOCK FOR COMBINE WITH PRED
          EQ     FUD28
 CHB      TITLE  CHB - COMBINE HOLDING BLOCK WITH IMMEDIATE PRED
**        CHB - COMBINE HOLDING BLOCK WITH IMMEDIATE PRED 
*         COALESCE THE HOLDING BLOCK WITH ITS IMMEDIATE PREDECESSOR SO
*         INITIALIZATION CODE FROM INTEGER POLYNOMIALS IS REMOVED OF
*         ITS DEPENDENCY ON THE INNER LOOP INDUCTION VARIABLE, AND IS 
*         SUBJECT TO FURTHER MOTION, ETC. 
* 
*         ENTRY  (X5) = [O.SEQ] 
*                (BSI) = *BST* INDEX OF HOLDING BLOCK 
  
 CHB      ROUTINE 
          SA1    L.SEQ
          SB5    X1-8 
          SB4    4
          LE     B5,B4,CHB   IF L.SEQ @ 12 */ EMPTY OR *LAB* ONLY BLOCK 
  
*         CHECK CURRENT BLOCK 
  
          SA2    O.BIT
          SA3    X5          R1 = [[O.SEQ]] 
          SB2    X2 
          SA4    B2+X3       BIW = BIT(R1)
          LX4    -BI.BVIP 
          SX7    X4          VI2 = BVI[BIW] 
          LX4    59-BI.RBP+BI.BVIP
          MI     X4,CHB      IF RB[BIW]    */ NOT A *HB*
  
          SA1    O.BST
          SA2    BSI
          SA0    A4          B = BIT + R1  */ SAVE BIT ADDR OF *HB* 
          SA3    EIT
          SB3    X1+B1                     (B3) = BST+1 
          SB4    X2          I = BSI
          SB6    X3 
          SA5    B3+B4       IPW = BST(I+1) 
          LX5    -IM.BNP
          SA1    B6+X5       EIW = EIT + BN[IPW]
          LX1    -EI.PRIP 
          UX1    B7,X1
          NE     B7,B1,CHB   IF NP[EIW] " 1  */ MORE THAN 1 PRED
          SA3    B6+X1       PIW = EIT + PRI[EIW] 
          LX3    -ET.PREDP
          SA4    B6+X3       EIWP = EIT + PRED[PIW] 
          LX4    -EI.SUIP 
          UX4    B7,X4
          GT     B7,B1,CHB   IF NS[EIWP] > 1  */ MORE THAN 1 SUCC 
          SB6    X3          PBN = PRED[PIW]  */ BN OF PRED 
  
*         SEARCH *BST* FOR PRED OF *HB* 
  
 CHB0     SB4    B4-2        I = I - 2
          ZR     B4,CHB      IF I = 0      */ END OF *BST*
          SA4    B3+B4       IPW = BST(I+1) 
          LX4    -IM.BNP
          SB7    X4 
          NE     B7,B6,CHB0  IF BN[IPW] " PBN 
  
          LX4    IM.BNP-IM.BIP
          SX3    B4 
          SA5    B2+X4       BIWP = BIT(BI[IPW])
          LX3    30 
          BX6    X3+X2       BSIS = SHIFT(I,30) ! BSI 
          SA6    BSIS 
          LX5    59-BI.RBP
          PL     X5,CHB      IF ^RB[BIWP]  */ PRED IS A *HB*
          BX6    X5 
          SA6    A6+B1
          SA2    A0          BIW = [B]     */ REFETCH BIT WORD
          LX2    59-BI.RBP
          BX6    X2-X5
          LX6    BI.RBP-BI.FJP
          MI     X6,CHB      IF FJ[BIW] " FJ[BIWP]
  
*         SAVE ELIMINATED LABEL DEF INFO IN *ELT* FOR USE BY *POST* 
  
          LX2    BI.RBP-BI.ILP
          PL     X2,CHB0A    IF IL[B]      */ NO LABEL DEF
          LX2    BI.ILP-BI.FJP
          PL     X2,CHB      IF HB LABELED BUT NO UJP, DO NOT COMBINE 
  
          SA1    O.SEQ
          SA2    O.ELT
          SA4    X1+4        R1 = [SEQ+4]  */ IH OF PROG LABEL
          SA3    A4+B1       R2 = [SEQ+5]  */ IH OF GL
          SX4    X4 
          SX3    X3-I.GL
          LX4    18 
          SA1    L.ELT
          SB2    X2+B1
          BX6    X3+X4
          SA6    B2+X1       ELT(L.ELT+1) = 24/,18/IH-PROG,18/H-GL
          SX6    X1+B1       L.ELT = L.ELT + 1
          SA6    A1 
  
*         MERGE THE BLOCKS
  
 CHB0A    SA7    VI2
          SX7    X5          VI1 = BVI[BIWP]
          SA7    A7+B1
          ALLOC  MOD,B5      ALLOC (MOD,L.SEQ-8)
          SX3    X2 
          SA2    O.SEQ
          MOVE   X1+B6,X2,X3 MOVE( L.SEQ-4 , O.SEQ , O.MOD )
  
          CALL   RBS         RELEASE THE BLOCK
          SA4    BSIS 
          LX4    30 
          SX6    X4          BSI = SETX( SHIFT(BSIS,30) ) 
          SA6    BSI
          CALL   RTB         GET PREDECESSOR BLOCK
  
*         SETUP *MOD* CONTROL WORD
  
          SA5    O.SEQ
          SA3    L.MOD
          SX1    4           K = 4
          MX6    0           DEL = 0
          SA4    X5+B1       R2 = [O.SEQ+1] 
          LX4    -R2.TXTLP
          SX2    X4-8        II = TXTL[R2] - 8
          SA5    BSIS+1 
          LX5    BI.RBP-BI.FJP
          PL     X5,CHB1A    IF ^FJ[BIWP] 
          MX6    1           DEL = 1       */ SET TO DELETE UJP AND LAB 
          SX1    8           K = 8
 CHB1A    IX3    X3-X1
          LX1    ML.MTIP
          LX2    ML.IIP 
          LX3    ML.NIP-2 
          BX4    X2+X3
          IX1    X4+X1
          BX1    X6+X1
          ADDWRD MLT,X1      ADDWRD( MLT , MCW(DEL,II,(L.MOD-K)/4,K) )
  
*         NOW ADJUST THE BIT VECTORS OF BOTH BLOCKS 
*         USE1 = USE1 ! USE2 , DEF1 = DEF1 ! DEF2 
*         UBD1 = UBD1 ! (^DEF1&UBD2) , LX1 = LX2
  
          SA2    VI2
          SA3    VL 
          SA4    O.BVT
          SA1    A2+B1
          SB3    X3          L = VL 
          SB7    X4 
          SB6    B7+X1       V1A = O.BVT + VI1
          SB7    B7+X2       V2A = O.BVT + VI2
          SB2    B0          I = 0
          SB4    B3+B3
  
 CHB1     SA1    B6+B2
          SA2    B7+B2
          SA3    A1+B4
          SA4    A2+B4
          SB2    B2+B1       I = I + 1
          BX6    X1+X2       DEF1 = DEF1 ! DEF2 
          SA6    A1 
          MX7    0
          SA7    A2          DEF2 = 0 
          BX6    X3+X4       USE1 = USE1 ! USE2 
          SA6    A3 
          SA7    A4          USE2 = 0 
          LT     B2,B3,CHB1  IF I < L 
  
          SB2    B0          I = 0
          SB7    B7+B3
  
 CHB2     SA2    B6+B2       DEF1 = V1A(I)
          SA1    A2+B3       UBD1 = V1A(I+VL) 
          SA3    B7+B2
          SA4    A3+B4
          BX5    -X2*X3 
          BX6    X1+X5       UBD1 = UBD1 ! (^DEF1 & UDB2) 
          SA6    A1 
          SB2    B2+B1       I = I + 1
          BX7    X4          LX1 = LX2
          SA7    A1+B4
          LT     B2,B3,CHB2  IF I < L 
  
          SX5    B6 
          MX6    59 
          RJ     AUV         MERGE, SQZ BLOCK AND ADJUST BIT VECTORS
  
*         REWRITE THE HOLDING BLOCK AS AN EMPTY BLOCK ( BOS, EOQ )
  
          SA1    O.TXT
          SA2    O.MOD
          SB6    B0          TI = 0 
          SA5    X2          R1 = [[O.MOD]] 
          SB7    X1          TB = [O.TXT] 
          UX6    B2,X5
          SX7    8
          RJ     SRI         SRI(  BOS  [R1] )
          SB2    OC.EOQ 
          SX6    0
          RJ     SRI         SRI(  EOQ  0 ) 
          SA4    BSIS 
          SX7    B6 
          SX6    X4          BSI = SETX( BSIS ) 
          SA6    BSI
          SA7    L.TXT       L.TXT = 8
          CALL   WMB         WRITE THE BLOCK BACK TO *BLK*
          SX6    4
          SA6    L.TXT       L.TXT = 4
          EQ     CHB
 RDD      TITLE  RDD - REMOVE DEAD DEFINITIONS FROM A BLOCK 
**        RDD - REMOVE DEAD DEFINITIONS ( STORES ) FROM A BLOCK 
* 
*         ENTRY  *PCC* REGISTER CALL CONVENTIONS
* 
*         SCAN BLOCK FOR DEAD STORES ( ^(LX ! (DBU & USE ) )  ).
*         CHANGE THEM TO *NOP*"S, CALL *SQZB* IF BLOCK CONTAINS DEAD
*         COMPUTATIONS ( VERY UNLIKELY ). 
*         CALLED PRIOR TO LEVEL 2 / F.P. EXPANSION
  
 RDDA     CON    0           HEADER FOR LD LINKS
  
 RDD      ROUTINE 
  
          RJ     IPS         INSERT POST STORES 
          ZR     X6,RDD0     IF NPS = 0 
  
          SA4    BSW
          MX0    -R1.RIL+1
          LX4    -IM.BIP
          SA5    O.SEQ
          LX0    1
          FBVA   X4          BVA = O.BVT + BVI[BIT(BN)] 
  
 RDD0     S"TB"  X5+2        TB = O.SEQ + 2 
  
*         SV = LX ! ( DBU & USE ) , LIVE ON EXIT OR USED IN BLOCK 
*         AND DDB = ^SV & DEF , DEAD DEFINITIONS. 
  
          SA1    X7          DA = BVA 
          SB6    B2+B2
          SA2    X7+B2       UFA = BVA + VL 
          SA3    X7+B6       UA = BVA + 2*VL
          SA4    A3+B2       LXA = BVA + 3*VL 
          SA5    SVA
          BX2    -X2*X1      DBU = DEF & ^UBD 
          SB5    X5                        (B5) = SVA 
          BX2    X2*X3
          BX6    X4+X2       SV = LX ! ( DBU & USE )
          SA6    B5 
          BX7    -X6*X1      DDB = ^SV & DEF  */ DEAD DEF BITS
          EQ     B2,B1,RDD2  IF VL = 1
 RDD1     SA1    A1+B1
          SA2    A2+B1
          SA3    A3+B1
          SA4    A4+B1
          BX2    -X2*X1 
          SB2    B2-B1
          BX2    X2*X3
          BX6    X4+X2
          BX5    -X6*X1 
          SA6    A6+B1
          BX7    X5+X7
          GT     B2,B1,RDD1 
  
 RDD2     CX4    X7 
          ZR     X4,RDD      IF COUNT( DDB ) = 0  */ NO DEAD DEFS IN BLO
  
          PRNTABV  RDD,SVA
 RDD      SPACE  3,10 
*         NOW SCAN BACKWARDS FOR DEAD STORES, ADJUST THE *PS* BIT 
  
          SA3    "TB"-B1     R2 = TB - 1
          SA0    B0          DC = 0        */ DEAD CODE FLAG
          SA4    O.UDT
          SB6    X4+B1       UB = O.UDT + 1 
          LX3    -R2.TXTLP
          SB2    X3-4        L = TXTL[R2] - 4 
          SA4    "TB"+B2     DI = TB + L
          MX1    -D.USESL 
          LX1    D.USESP
          SB3    59-D.^DP 
          SB4    4
          EQ     RDD4 
  
*         INDICATE THAT R-NUM *PS* FOR A LIVE *ST*
  
 RDD3     LX4    59-D.L2P 
          MI     X4,RDD4     IF L2[DI]     */ LEVEL 2 *ST*
          SB2    X2+B1
          SX6    B1 
          SA6    "TB"+B2     [TB+R+1] = 1 
  
 RDD4     SA4    A4-B4       DI = DI - 4
          LX6    B3,X4
          MI     X6,RDD5     IF ^D[DI]
          LX6    D.^DP-D.PSP
          MI     X6,RDD4A    IF PS[DI]
          LX6    D.PSP-D.LDP
          PL     X6,RDD4     IF ^LD[DI] 
  
*         LD - SET BIT IN *SVA* SO WE DONT KILL DEFS THAT COME BEFORE 
*         AN EXTERNAL REF   ( USE,DEF EXTREF USE  SITUATION ).
*         FORM LINK LIST OF ALL LDS.  THIS WILL BE SCANNED TO 
*         DETERMINE IF ANY STORES INTERFERE WITH SUBSEQUENT LOADS.
  
          SA5    A4-2        R1 = DI - 2
          LX5    -R1.INP
          SA3    B6+X5       U2 = UDT(IN[R1]+1) 
          SX2    B1 
          SA5    B5+X3       SVW = SVA(WI[U2])
          UX7    B2,X3       B = BITN[U2] 
          LX2    B2,X2
          BX6    X2+X5       SVW = SVW ! SHIFT(1,B) 
          SA6    A5 
          SA3    RDDA 
          SX7    X3 
          SA7    A4+B1       LDLNK = DI + 1;[LDLNK] = RDDA
          SX6    A7 
          SA6    A3          RDDA = LDLNK 
          EQ     RDD4 
  
*         INSTRUCTION *PS* - CLEAR BIT IF ALL DEFS KILLED 
  
 RDD4A    SA5    A4+B1       LI = DI + 1;  PSF = [LI] 
          MX7    0
          SA7    A5          [LI] = 0 
          NZ     X5,RDD4     IF PSF " 0    */ STILL *PS*
          SX5    B1 
          LX5    D.PSP
          BX6    -X5*X4      PS[DI] = 0 
          SA6    A4 
          EQ     RDD4 
  
*         INSTRUCTION ^D
  
 RDD5     SA5    A4-2        R1 = DI - 2
          UX7    B2,X5
          LX6    D.^DP-D.STP
          EQ     B2,B1,RDD50 IF OC[R1] = OC.BOS 
          MI     X6,RDD6     IF ST[DI]
          SB2    B2-OC.RJ3
          MI     B2,RDD4     IF OC[R1] < OC.RJ3 
          GT     B2,B1,RDD4  IF OC[R1] > OC.RJ6 
          ERRNZ  OC.RJ3+1-OC.RJ6
  
          SA3    A5-8        R1P = R1 - 8 
          SA5    A5+B1       R2 = R1 + 1
          UX6    B2,X3
          SX7    B2-OC.JIN
          ZR     X7,RDD4     IF OC[R1P] = OC.JIN  */ COMPUTED GOTO
          MX7    -FI.FTL
          LX5    -FI.FTP
          BX6    -X7*X5      F = FT[R2]    FUNCTION TYPE
          SB2    X6-2 
          ZR     B2,RDD4     IF F = 2      */ *BEF* 
  
          EQ     RDD50       QUIT UNTIL WE ADD MORE CORE
  
 RDD6     BX2    "RN"X5      R = RI[R1] 
          LX5    -R1.INP
          SB2    X5          I = IN[R1] 
          SA5    B6+X5       U2 = UDT(I+1)
          ZR     B2,RDD3     IF I = 0      */ NO *UDT* INDEX
  
*         SEE IF STORE IS LIVE
  
          SA3    B5+X5       SW = [SVA+WI[U2]]
          UX7    B2,X5
          SB2    B2-59       B = 59-BITN[U2]
          SA5    A4-B1       R2 = DI - 1
          LX6    -B2,X3 
          MI     X6,RDD3     IF SHIFT(SW,B) < 0  */ STORE IS LIVE 
          LX5    -IH.RFP
          SB2    X5 
          GT     B2,B1,RDD3  IF RF[R2] > 1
          BX6    X5          R2ST = R2
          SA3    RDDA        LDLNK = RDDA 
          LX6    IH.RFP-IH.IHP
  
*         SEARCH THRU LINK LIST FOR INTERFERENCE BETWEEN THIS STORE 
*         AND SUBSEQUENT LOADS. 
  
 RDD10    ZR     X3,RDD30    IF LDLNK = 0   */END OF LIST 
          SA5    X3-2        R2LD = LDLNK - 2 
          LX5    -IH.IHP
          BX7    X5-X6
          LX6    IH.IHP-IH.CAP
          SX7    X7 
          NZ     X7,RDD20    IF IH[R2ST] " IH[R2LD] 
          LX5    IH.IHP-IH.RFP
          SX7    X5 
          NZ     X7,RDD3     IF RF[R2LD] " 0
          LX5    IH.RFP-IH.CAP
          BX7    X5-X6
          SX7    X7 
          ZR     X7,RDD3     IF CA[R2LD] = CA[R2ST] 
 RDD20    SA3    X3          LDLNK = [LDLNK]
          LX6    IH.CAP-IH.IHP
          EQ     RDD10
  
*         *ST* IS DEAD, CHANGE IT TO A *NOP* AND ADJUST USES OF PRED. 
  
 RDD30    SA3    "TB"+X2     DP = TB + R
          SX4    B1 
          IX6    X3-X4       USES[DP] = USES[DP] - 1
          SA6    A3 
          BX7    -X1*X6 
          SA0    A0+B1       DC = DC + 1   */ INC DEAD STORE COUNT
          LX3    59-D.RFP 
          AX3    59 
          BX7    -X3*X7 
          NZ     X7,RDD40    IF USES[DP] " 0 & ^RF[DP]
          SA0    1S17        DC = -377777B */ INDICATE DEAD COMPUTATIONS
  
 RDD40    SA5    F.RDT+OC.NOP 
          SB2    OC.NOP 
          PX6    B2,X2
          SA6    A4-2        [DI-2] = TYI(OC.NOP,0,0,R) 
          BX7    X5 
          SA7    A4          [DI] = RDT(OC.NOP) 
          EQ     RDD4 
  
 RDD50    SX1    A0 
          TRACE  RDD,RLIST,SEQ
  
*         CLEAR LOAD LINKS. 
  
          SA2    RDDA        LDLNK = RDDA 
          MX7    0
 RDD54    ZR     X2,RDD56    IF LDLNK = 0   */END OF LIST 
          SA7    A2          [LDLNK] = 0
          SA2    X2          LDLNK = OLD [LDLNK]
          EQ     RDD54
  
 RDD56    ZR     X1,RDD      IF DC = 0   */NO DEAD STORES 
          PL     X1,RDD60    IF DC > 0   */DEAD STORES ONLY 
  
          MX6    1           L.MOD = 0
          CALL   MPB         RE SQUEEZE AND REWRITE THE BLOCK 
          EQ     RDD
  
  
 RDD60    MX6    0
          CALL   MPB         MOVE THE BLOCK TO *TXT*
          CALL   CUC         RESET THE USES COUNTS
          CALL   WTB         REWRITE THE BLOCK
          EQ     RDD
 IPS      TITLE  IPS - INSERT POST STORES 
**        IPS - INSERT POST STORES INTO A BLOCK 
* 
*         ENTRY  (X4) = [BSW] 
* 
*         EXIT   (X6) = NPS = 0 IF NO POST STORES INTRODUCED
  
 IPS      ROUTINE 
          LX4    -IM.BIP
          FBVA   X4          BIW = BIT(BN);  BVA = O.BIT + BVI[BIW] 
          LX4    -BI.PIIP 
          MX3    -BI.PIIL 
          BX6    -X3*X4      PSI = PII[BIW]  */ INDEX TO POST ST INFO 
          ZR     X6,IPS      IF PSI = 0    */ NO POST STORES
  
*         SCAN POST STORE LIST AND ADJUST *DEF* AND *UBD* BIT VECTORS 
  
          SA1    O.PSI
          SA2    O.UDT
          IX3    X1+X6
          SA7    VI2
          SB7    X7          BVA = BVA
          SA5    X3-1        PI = O.PSI+PSI-1  */ HEADER WORD 
          SB6    X2+B1       UB = O.UDT + 1 
          SB4    X5          NPS = [PI]    */ N. POST STORES
          SB5    X5          N = NPS
          PX0    B4,X6
          SX1    B1 
  
 IPS1     SA5    A5+B1       PI = PI + 1
          SB5    B5-B1       N = N - 1
          LX5    -PS.UDIP 
          SA4    B6+X5       U2 = UDT( UDI[PI]+1 )
          UX7    B3,X4       B = BITN[U2];  W = WI[U2]
          SA2    B7+X4       BDA = BVA + W */ WORD OF DEF VECTOR
          LX4    B3,X1
          SA3    A2+B2       UFA = BDA + VL */ UBD WORD 
          BX6    X4+X2       [BDA] = [BDA] ! SHIFT(1,B) 
          SA6    A2 
          BX7    -X4*X3      [UFA] = ^SHIFT(1,B) & [UFA]
          SA7    A3 
          NZ     B5,IPS1     IF N " 0 
  
*         RESCAN LIST AND GENERATE A DEF, SA/XMT , ST FOR EACH ENTRY. 
  
          SA1    O.SEQ
          SA2    X1+4        R1 = [O.SEQ+4]  */ FIRST AFTER *BOS* 
          SX1    4
          UX6    B2,X2
          MX3    0           II = 0 
          SX7    B2-OC.LAB
          NZ     X7,IPS2     IF OC[R1] " OC.LAB 
          BX3    X1          II = 4 
 IPS2     LX3    ML.IIP 
          LX1    ML.MTIP
          SX2    B4+B4
          BX1    X1+X3
          SX5    X2+B4
          LX5    ML.NIP 
          BX1    X5+X1
          ADDWRD MLT,X1      ADDWRD( MLT , MCW(0,II,3*NPS,4) )
          LX5    -ML.NIP+2
          ALLOC  MOD,X5      ALLOC( MOD , 12*NPS )
          SA4    O.PSI
          SB7    X2          TB = O.MOD 
          UX6    B3,X0       N = NPS
          IX7    X6+X4
          SA5    X7          PI = O.PSI + IPSA
          SB4    B3+B3
          SB5    B6          MI = OLD(L.MOD)  */ INDEX FOR DEFS 
          SB4    B4+B4                     (B4) = 4*NPS 
  
 IPS3     MX1    PS.REGL
          LX1    PS.REGL+PS.REGP
          BX2    X1*X5
          LX2    R1.SOP-PS.REGP 
          SX1    B5 
          BX6    X2+X1
          SB2    OC.DEF 
          MX7    0
          SB6    B5          TI = MI
          LX2    58-R1.SOP-SO.RTP 
          RJ     SRI         SRI( DEF  MI,REG[PI] ) 
          SB6    B5+B4       TI = MI + 4*NPS
          SX6    B6 
          LX1    R1.RJP 
          BX6    X1+X6
          SB2    OC.XMT      OC = OC.XMT;  R2W = 0
          MI     X2,IPS4     IF REG[PI] \ 20B 
          SB2    OC.SA       OC = OC.SA 
          MX1    -PS.CAIHL
          BX7    -X1*X5      R2W = IHW(0,CAIH[PI])
 IPS4     RJ     SRI         SRI( OC  MI+4*NPS,MI, R2W )
          SX6    B6-4        R = TI - 4 
          SB6    X6+B4       TI = R + 4*NPS 
          MX1    -PS.CAIHL
          BX7    -X1*X5 
          LX5    -PS.UDIP 
          SB2    OC.ST
          SX5    X5 
          LX5    R1.INP 
          SB3    B3-B1       N = N - 1
          BX6    X5+X6
          SB5    B5+4        MI = MI + 4
          RJ     SMI         SMI( ST  R,,CAIH[PI],UDI[PI] ) 
          SA5    A5+B1       PI = PI + 1
          NZ     B3,IPS3     IF N " 0 
  
          SA5    VI2
          MX6    1
          RJ     AUV         MERGE, SQZ BLOCK AND ADJUST BIT VECTORS
          CALL   RTB         AND GET IT BACK
          SX6    B1 
          EQ     IPS
 AUV      TITLE  AUV - ADJUST USE VECTOR
**        AUV - ADJUST *USE* BIT VECTOR AFTER A *SQZB* CALL TO ACCOUNT
*                FOR ANY STORE/LOAD SQUEEZING THAT TOOK PLACE.
*         THIS IS DONE PRIOR TO THE *RDD* CALL SO AS TO GET RID OF
*         THE INTRA BLOCK USES. 
* 
*         ENTRY  (X5) = BVA , BLOCK BIT VECTOR ADDRESS
*                (X6) = *MPB* CALL FLAG 
  
 AUVA     BFMW   D,(LD,BM)
  
 AUV      ROUTINE 
          SA1    SVA
          SA2    VL 
          BX7    X5 
          SA7    VI2
          IX7    X1+X2
          SA7    =XSUVA      SUVA = SVA+VL  */ SET FLAG FOR SQZ/SMR 
          LX2    1
          SB6    X1 
          SB7    B6+X2
          MX7    0
 AUV1     SA7    B6          FOR I = 1 TO 2*VL;  SVA(I) = 0 
          SB6    B6+B1
          LT     B6,B7,AUV1 
  
          CALL   MPB         MERGE MODS AND SQZ BLOCK 
          SX7    0
          SA7    SUVA        SUVA = 0 
          SA5    VI2
          SA1    =XSTLDS
          ZR     X1,AUV      IF STLDS = 0  */ NO STORE/LD SQUEEZING 
  
          SA2    SVA
          SA3    VL 
          SA1    O.UDT
          SA4    O.TXT
          LX6    B1,X3
          SB4    X3                        (B4) = VL
          SB5    X2                        (B5) = SVA 
          SB7    X5+B4       UFA = BVA + VL  */ USE FIRST ADDRESS 
          SA0    X1+B1                     (A0) = O.UDT + 1 
          SA1    AUVA 
          SB2    B1+B1
          SA4    X4+B2       DI = O.TXT + 2 
          SX7    B1 
          EQ     AUV3 
  
*         SET BIT FOR REFERENCED VARIABLE 
  
 AUV2     LX5    -R1.INP
          SB3    X5          I = IN[R1] 
          ZR     B3,AUV3     IF I = 0 
  
          SA3    A0+B3       U2 = UDT(I+1);  W = WI[U2] 
          SA2    B5+X3
          UX5    B6,X3
          LX4    B6,X7
          BX6    X4+X2       SVA(W) = SVA(W) ! SHIFT(1,BITN[U2])
          SA6    A2 
  
*         ADVANCE TO NEXT INSTRUCTION 
  
 AUV3     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          BX6    X1*X4
          LX4    59-D.LDP 
          ZR     X6,AUV3     IF ^( LD[DI] ! BM[DI] )
          MI     X4,AUV2     IF LD[DI]
  
          UX6    B3,X5
          ZR     B3,AUV4     IF OC[R1] = OC.EOQ  */ END OF SEQ
          SX6    B3-OC.RJ6
          NZ     X6,AUV3     IF OC[R1] " OC.RJ6 
  
*         USER OR I/O REFERENCE, EXIT SINCE WE HAVE LOST THE PARAMETER
*         LIST INFORMATION AT THE END OF THE BLOCK DURING THE MERGE.
  
          EQ     AUV
  
*         ADJUST *USE* AND *UBD* BV"S, USE = USE & ^(SVA2 & ^SVA) 
  
 AUV4     SA2    B5+B3                     SVA
          SA3    A2+B4                     SVA2 
          SA1    B7+B3                     UBD
          SA4    A1+B4                     USE
          BX5    -X2*X3 
          BX6    -X5*X4      USE(I) = USE(I) & ^(SVA2(I) & ^SVA(I) )
          SA6    A4 
          BX7    X6*X1       UBD(I) = UBD(I) & USE(I) 
          SA7    A1 
          SB3    B3+B1       I = I + 1
          LT     B3,B4,AUV4  IF I < VL
  
          PRNTABV  AUV,SVA
          EQ     AUV
 FEI      TITLE  FEI - FORM ENTRY INFORMATION 
**        FEI - FORM ENTRY INFORMATION
*         COMPUTE REGION LIVE ENTRY BIT VECTOR. 
  
 FEI      ROUTINE 
          SA4    HBI+1       BN = BN[HBI(2)]   */ HEADER NODE 
          FBVA   X4          BVA = O.BVT + BVI[BIT(BN)] 
          SA2    LEA
          SB3    B2 
          SB4    B2+B2
          SA3    X7          BDA = BVA
          SA4    X7+B2       UFA = BVA + VL  */ UBD 
          SA5    A4+B4       LXW = BVA + 3*VL  */ LX
          BX0    -X3*X5 
          BX6    X0+X4       LEW = ^[BDA] & [LXW] ! [UFA] 
          SA2    X2 
          BX6    X6+X2       [LEA] = LEW ! [LEA] */ ACCNT FOR MOVED ST"S
          SA6    A2 
          SB2    B2-B1
          ZR     B2,FEI      IF VL = 1
 FEI1     SA3    A3+B1       = BDA
          SA4    A4+B1       = UFA
          SA5    A5+B1       = LXW
          SB2    B2-B1       VL = VL - 1
          SA2    A2+B1       = LEA
          BX0    -X3*X5 
          BX6    X0+X4
          BX6    X6+X2
          SA6    A2          LEA = ^[BDA] & [LXA] ! [UFA] 
          NZ     B2,FEI1
  
          EQ     FEI
 FXI      TITLE  FXI - FORM EXIT INFORMATION
**        FXI - FORM EXIT INFORMATION 
*         BUILD LIST OF SUCCESSORS OF *SCR* AND THEIR LIVE ENTRY VECTORS
*         FORM REGION LIVE EXIT AND MOVABLE DEF VECTORS.
  
 FXI      ROUTINE 
          SA4    HBI+1       BN = BN[HBI(2)]   */ HEADER NODE 
          FBVA   X4          BVA = O.BVT + BVI[BIT(BN)] 
          SB3    B0 
  
*         INITIALIZE *MD* VECTOR AS *DEF(R)* ( MOVABLE DEFS ) 
  
          SA1    DVA
          SA2    MDA
 FXI2     SA3    X1+B3       MOVE( VL , DVA , MDA ) 
          BX6    X3 
          SA6    X2+B3
          SB3    B3+B1
          LT     B3,B2,FXI2 
  
*         FORM *SCR* SUCCESSOR LIST. FIRST MARK THE NODES IN THE
*         *SCR* AS *SCR* IN *BTT*.
  
          SA1    IBA
          SA2    A1+B1
          MX0    1
          SA3    O.BTT
          IX6    X1+X2
          SB7    X3 
          SB6    X6          IPL = IBA + NN  */ LWA+1 OF INTERVAL LIST
          LX0    1+E.SCRP 
          SA5    B6          IP = IPL 
  
 FXI4     SA5    A5-B1       IP = IP - 1
          LX5    59-IM.SCRP 
          PL     X5,FXI4     IF ^SCR[IP]
  
          LX5    1+IM.SCRP-IM.BNP 
          SA4    B7+X5
          BX6    X0+X4       SCR[BTT(BN[IP])] = 1 
          LX5    IM.BNP+59-IM.HNP 
          SA6    A4+
          PL     X5,FXI4     IF ^HN[IP] 
  
*         RESCAN THE INTERVAL LIST AND FORM THE SUCCESSOR LIST IN *BTT* 
  
          SA1    EIT
          SA2    O.BIT
          MX6    0
          SA6    B7          BTT(0) = 0 
          SA0    B0          NX = 0        */ N. EXIT NODES 
          SB5    B0          LS = 0        */ LAST SUCCESSOR
          SA5    B6          IP = IPL 
          LX0    E.JPP-E.SCRP 
          SB6    X1          EIB = [EIT]   */ BASE OF EDGE INDEX TABLE
          SB4    X2                        (B4) = [O.BIT] 
  
 FXI5     SA5    A5-B1       IP = IP - 1
          LX5    59-IM.SCRP 
          PL     X5,FXI5     IF ^SCR[IP]
          LX5    1+IM.SCRP-IM.BNP 
  
          SA4    B6+X5       EII = EIB + BN[IP] 
          LX4    -EI.SUIP 
          UX6    B3,X4       N = NS[EII]
          SA3    B6+X4       SI = EIB + SUI[EII]
  
*         ADD SUCCESSORS OF NODE THAT ARE NOT *SCR* IN *BTT* TO EXIT LIS
  
 FXI6     LX3    -ET.SUCCP   J = SUCC[SI]  */ BN OF SUCCESSOR 
          SA2    B7+X3       B = BTT(J) 
          SB3    B3-B1       N = N - 1
          LX2    59-E.SCRP
          MI     X2,FXI8     IF SCR[B]     */ SUCC IS IN *SCR*
  
          MX1    -E.NPREDL
          LX2    1+E.SCRP-E.NPREDP
          BX6    -X1*X2 
          NZ     X6,FXI7     IF NPRED[B] " 0 */ NOT FIRST TIME REACHED
  
          SA4    B6+X3       EIJ = EIB + J
          LX4    -EI.NPP
          SA0    A0+B1       NX = NX + 1
          BX7    -X1*X4 
          SA4    B7+X5
          SX6    X4 
          BX2    X7+X2       NPRED[B] = NP[EIJ]  */ N.PRED OF SUCC
          LX6    E.PREDP-E.NPREDP 
          SX7    B5 
          BX2    X6+X2       PRED[B] = BTT(BN[IP])  */ FIRST PRED TO REACH
          LX7    E.LINKP-E.NPREDP 
          BX2    X7+X2       LINK[B] = LS  */ POINT THIS TO LAST
          SB5    A2          LS = BTT(J)
  
 FXI7     SX1    B1 
          LX3    E.JPP-ET.JPP+ET.SUCCP
          IX2    X2-X1       NPRED[B] = NPRED[B] - 1
          BX6    X0*X3
          LX2    E.NPREDP 
          BX7    X6+X2       JP[B] = JP[B] ! JP[SI] 
          SA7    A2 
  
 FXI8     SA3    A3+B1       SI = SI + 1
          NZ     B3,FXI6     IF N " 0 
  
          LX5    59-IM.HNP+IM.BNP 
          PL     X5,FXI5     IF ^HN[IP] 
  
          LX5    1+IM.HNP-IM.BIP
          SX6    X5 
          LX5    IM.BIP-IM.BNP
          SA6    B7+X5       BTT(BN[IP]) = BI[IP]  */ RESTORE HEADER ENT
  
          SX6    B5 
          SX7    A0 
          SA6    O.ENL
          SA7    N.ENL
  
*         SCAN THE EXIT NODE LIST AND MOVE THE LIST AND THE LIVE ENTRY
*         BIT VECTORS TO *RXI*.  FORMAT - 
*         0, BTT WORD,LE&DEFR,...,0 
*         COMPUTE THE REGION LIVE EXIT BIT VECTOR AND ADJUST *MD*.
  
          SA5    BVL
          SX3    X5+2 
          IX2    X7*X3
          ALLOC  RXI,X2+2    ALLOC( RXI , NX*(BVL+2)+2 )
          MX7    0
          SA7    X2          RI = [O.RXI];  [RI] = 0
          SA1    O.BIT
          SA2    LXA
          SA3    MDA
          SA4    O.ENL
          SB4    X5+B1       VL = BVL + 1 
          SB5    B4+B4
          SB6    X1 
          SB7    X2 
          SA0    X3 
          SA5    X4          XI = [O.ENL];  XW = [XI] 
          ZR     X4,FXI15    IF O.ENL = 0  */ LOOP WITHOUT EXITS
  
*         CHECK SUCCESSOR NODE, SEE IF POST STORES TO IT ARE POSSIBLE 
  
 FXI9     MX1    -E.BIL 
          SX0    B1          PSP = 1       */ POST STORES POSSIBLE
          BX6    -X1*X5      I = BI[XW] 
          SB2    X6 
          SA6    A5          [XI] = I      */ RESTORE *BTT* ENTRY 
          BX7    X5 
          MX4    -E.NPREDL
          LX7    -E.NPREDP
          BX7    -X4*X7 
          ZR     X7,FXI11    IF NPRED[XW] = 0 
          SA1    B6+B2
          LX1    59-BI.HNP
          PL     X1,FXI10    IF ^HN[BIT(I)] 
  
*         SUCCESSOR NODE IS THE HEADER NODE OF ANOTHER LOOP, SEARCH *HNT
*         FOR I, AND SUBSTITUTE THE *BI* OF THE *HB*. 
  
          SA2    L.HNT
          SA1    O.HNT
          SA6    X2          [L.HNT] = I   */ SEARCH TERMINATOR 
          SA1    X1          HI = [O.HNT] 
  
 FXI9A    BX2    X1          HIL = [HI] 
          SB3    X1 
          SA1    A1+1        HI = HI + 1
          NE     B2,B3,FXI9A IF HNI[HIL] " I
  
          LX2    -H.HBIP+1
          SB2    X2          I = 2*HBI[HIL]  */ SUBSTITUTE *HB* 
          MX4    -E.BIL 
          SX6    X2 
          BX5    X4*X5
          BX5    X5+X6       BI[XW] = I 
          LX2    H.HBIP-1-H.NIPP
          SX2    X2 
          PRINT FXI,(* HEADER,HB,N.PRED,NIP =*4Z7),(B3,B2,X7,X2)
          IX7    X7-X2
          ZR     X7,FXI11    IF NPRED[XW] = NIP[HIL]
  
 FXI10    BX7    X5 
          SX0    B0          PSP = 0
          LX7    59-E.JPP 
          MI     X7,FXI11    IF JP[XW]     */ REACHED BY A JUMP 
  
*         SUCC REACHED BY THE FALL THROUGH AND HAS AN ACTIVE INITIAL
*         LABEL, SETUP TO ISSUE POST STORES AFTER THE LOOP BACK JUMP. 
  
          SA1    EPSI 
 .SCR     BIT    E.SCRP-E.ALLPP 
          SX0    .SCR        PSP = 4       */ POST STORES POSSIBLE
          SX6    X1+B1       EPSI = EPSI + 1
          SA6    A1 
  
 FXI11    LX0    E.ALLPP
          BX7    X0+X5       ALLP[XW] = PSP & 1 
          SA7    A7+B1       RI = RI + 1;  [RI] = XW
          SA3    B6+B2
          SA2    O.BVT
          LX5    -E.LINKP 
          LX3    -BI.BVIP 
          SB2    X2 
          SB3    B0          J = 0
          SB2    B2+X3       BVA = O.BVT + BVI[BIT(I)]
  
 FXI12    SA1    B2          DV = BVA 
          SA2    B2+B4       UFA = BVA + VL 
          SA3    A2+B5       BXW = [UFA+2*VL]  */ BLOCK LIVE EXIT 
          SA4    B7+B3       RLX = LXA + J
          BX6    -X1*X3 
          BX7    X6+X2       LEW = ^DEF&BXW!UFW 
          SA7    A7+B1       RI = RI + 1;  [RI] = LEW 
          BX6    X4+X7       RLX = LEW ! RLX
          SA6    A4 
          NZ     X0,FXI13    IF PSP " 0 
          SA2    A0+B3       MDW = [MDA+J]
          BX6    -X7*X2      MDW = MDW & ^LEW 
          SA6    A2 
  
 FXI13    SB3    B3+B1       J = J + 1
          SB2    B2+B1       BVA = BVA + 1
          LT     B3,B4,FXI12 IF J < VL
  
          SX4    X5          XI = LINK[XW]
          SA5    X5          XW = [XI]
          NZ     X4,FXI9     IF XI " 0     */ NOT END OF LIST 
  
 FXI15    MX7    0
          SA7    A7+B1       RI = RI + 1;  [RI] = 0 
  
          IF     DEF,/DEBUG/FXI,2 
          DCALL  PRNTRXI,([O.RXI])
          PRNTABV  FXI,(LEA,MDA)
          EQ     FXI
 SHB      TITLE  SHB - SQUEEZE HOLDING BLOCK
**        SHB - SQUEEZE HOLDING BLOCK TO REMOVE REDUNDANT INSTRUCTIONS. 
* 
*         ENTRY  (X6) = CT = 0 FOR FIRST SQZ, 1 FOR VAR INCR SQZ
  
 SHB      ROUTINE 
          SX7    0           BSI = 0
          SA7    BSI
          ZR     X6,SHB1     IF CT = 0
  
*         SETUP FOR SQUEEZE OF VARIABLE INCREMENT CODE
  
          SA7    L.TXT       L.TXT = 0
          CALL   RTB         GET HOLDING BLOCK POINTERS 
          SA5    L.HB 
          SA4    L.MOD
          IX2    X4+X5
          ALLOC  TXT,X2-4    ALLOC( TXT , L.HB + L.MOD-4 )
          IX0    X2+X5       FM = O.TXT + L.HB
          SX3    X2 
          SA2    O.SEQ
          MOVE   X5,X2,X3    MOVE( L.HB , O.SEQ , O.TXT ) 
          SA1    L.MOD
          SA2    O.MOD
          MOVE   X1-4,X2+4,X0      MOVE( L.MOD-4 , O.MOD+4 , FM ) 
          SX6    4
          SA6    L.MOD       L.MOD = 4
  
*         TERMINATE THE HB WITH AN *EOQ* AND CALL *SQZ* TO REDUCE IT
  
 SHB1     ALLOC  TXT,4
          SB7    X2          TB = O.TXT; TI = OLD(L.TXT)
          MX6    0
          SB2    B0 
          MX7    0
          RJ     SRI         SRI( EOQ  0,0 )
          SX6    4
          SX7    B6-8 
          ZR     X7,SHB2     IF L.TXT = 8  */ NOTHING MOVED TO HB 
          SX6    1
          CALL   SQZB        SQUEEZE THE BLOCK
          SA1    L.TXT
          SX6    X1-4 
  
 SHB2     SA2    O.TXT
          SX7    X6+4 
          SA6    L.HB        L.HB = L.TXT - 4 
          LX7    R2.TXTLP    TXTL[TXT+1] = L.TXT
          SA7    X2+B1
          CALL   WMB         WRITE HOLDING BLOCK TO *BLK* 
  
          TRACE  SHB,RLIST
          EQ     SHB
 MII      TITLE  MII - MARK INVARIANT INSTRUCTIONS
**        MII - MARK INVARIANT INSTRUCTIONS, COLLECT INFORMATION FOR
*                STRENGTH REDUCTION.
* 
*         EXIT   [TBA+3] = 12/P(NI),12/0,18/STC,18/ICC
* 
*         REGISTER ASSIGNMENTS FOR MAIN LOOP OF *MII* 
* 
*                (A0) = FAC = FUNCTION ARGUMENT CHAIN 
*                (A5) = R1 , OF CURRENT INSTRUCTION 
*                (A7) = LII , ADDRESS OF LAST INVARIANT INSTRUCTION 
*                (B3) = 3 
 SC       MICRO  1,,/B4/     STORE CHAIN ( POSSIBLE RECURSIVE DEFS )
 NI       MICRO  1,,/B5/     N.INCREMENT STORES ( *RD* )
 UB       MICRO  1,,/B6/     O.UDT
  
          QUAL   MII
  
 MII      ROUTINE 
          BX6    X4 
          LX6    59-IM.APP
          SA6    AN          AN = AP[BSW]  */ SET ARTICULATION NODE INDI
  
          LX4    -IM.BIP
          FBVA   X4          BVA = O.BVT + BVI[BIT(BN)] 
          SX7    X7+B2
          SA7    UBD         UBD = BVA + VL 
          SB3    3
          SA4    O.UDT
          S"TB"  X5+B3       TB = TBA + 3  */ LINK WORD OF BASE 
          SA0    B0          FAC = 0       */ FUNCTION ARG CHAIN
          S"UB"  X4          UB = [O.UDT] 
          SA5    X5          R1 = TBA 
          MX7    IM.APLNL 
          BX3    X7*X6
          LX3    IM.APLNL+R1.H2P
          BX7    X3+X5       H2[R1] = APLN[BSW]  */ SAVE APLN FOR *GRA* 
          SA7    A5 
          MX6    0
          S"SC"  B0          SC = 0        */ STORE CHAIN 
          S"NI"  B0          NI = 0        */ N. RECURSIVE DEFINITIONS
          SA1    "TB"+B1
          MX7    1
          SA6    IJP         IJP = 0       */ INVARIANT JUMP FLAG 
          SA6    A6+B1       UIC = 0       */ UNSAFE INV CODE FLAG
          LX7    1+I.INVP 
          SA7    "TB"        LII = TB;  [LII] = *INV */ LAST INV INST 
  
          UX6    B2,X1
          SX7    B2-OC.LAB
          NZ     X7,MII2     IF OC[R1+4] " OC.LAB 
  
          SA5    A1          R1 = R1 + 4   */ SKIP INITIAL LABEL
          EQ     MII2 
 MII      SPACE  2,14 
*         OPERANDS *INV*, MARK INSTRUCTION AS *INV* 
  
 MII1     SA2    A5+2        DI = R1 + 2
          SA1    AN 
          LX2    59-D.USIP
          BX3    -X2+X1 
          MI     X3,MII1A    IF AN ! ^USI[DI]  */ SAFE TO MOVE
          SX6    1
          SA6    UIC         UIC = 1       */ INDICATE UNSAFE INV CODE
          EQ     MII2 
  
 MII1A    SX6    A7-"TB"     IIC[R1+3] = LII - TB 
          MX4    1
          LX6    I.IICP 
          LX4    1+I.INVP    INV[R1+3] = 1
          BX7    X4+X6
          SA7    A5+B3       LII = R1 + 3 
  
*         GET NEXT INSTRUCTION AND JUMP TO PROCESSOR
  
          PROCESS (DAR,DEF,NOP) 
 MII2     SA5    A5+4        R1 = R1 + 4
          UX6    B2,X5
          JP     MII.JT+B2   JUMP( MII.JT( OC[R1] ) 
 TYII     SPACE  2
 TYII     EQU    MII1A                     */ TYPE II ARE *INV* 
  
 TYIV     EQU    MII2                      */ TYPE IV ARE NOT INV 
 LD       SPACE  3,14 
*         LD - CHECK *UDI* TO SEE IF *INV* IN REGION
  
          PROCESS ILD 
          SB2    OC.LD       OC = OC.LD 
          SA4    IT.
          SA3    A5+B1
          BX6    X3-X4
          SX7    X6 
          NZ     X7,ILD1     IF IH[R2] " IT.
          SB2    OC.TLD 
  
 ILD1     PX6    B2,X5       OC[R1] = OC   */ INHIBIT ST/ILD SQZ
          SA6    A5 
  
          PROCESS (LD,TLD)
          SA4    A5+B1       R2 = R1 + 1
          LX5    -R1.INP
          SA3    "UB"+X5     UI = UB + IN[R1] 
          LX4    -IH.RFP
          BX7    "RN"X4 
          NZ     X7,LD1      IF RF[R2] " 0
          SA2    A4+B1       DI = R2 + 1
          SX6    B1 
          LX2    -D.RFP 
          BX6    X6*X2
          LX6    UD.RFP 
          BX6    X6+X3       RF[UI] = RF[UI] ! RF[DI] 
          SA6    A3 
 LD1      SA2    "TB"+X7     LF = TB + RF[R2] 
          LX3    59-UD.DEFRP
          LX2    59-I.INVP
          BX6    -X3*X2 
          PL     X6,MII2     IF ^( ^DEFR[UI] & INV[LF] )
          LX3    UD.DEFRP-UD.ISTP 
          MI     X3,MII2     IF IST[UI]    */ INTERFERING STORE 
          SA3    AN 
          MI     X3,MII1A    IF AN < 0     */ SAFE TO MOVE
          ZR     X7,MII1A    IF RF[R2] = 0 */ NO SUBSCRIPT
          SA3    =XUOFLAG 
          ZR     X3,MII2     IF UO = 0   */ DONT MOVE A(I)
          SA3    A2-B3       R1F = LF - 3 
          UX7    B2,X3
          SX6    B2-OC.LD 
          NZ     X6,MII1A    IF OC[R1F] " OC.LD 
          SA2    A3+B1
          LX2    -IH.RFP
          BX7    "RN"X2 
          NZ     X7,MII2     IF RF[R2F] " 0  */ DONT MOVE A(B(I)) 
          EQ     MII1 
 TYI      SPACE  3,14 
*         TYPE I , INV(I) = INV(J) & INV(K) 
  
 TYI      LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          SA4    "TB"+X6     LJ = TB + RJ[R1] 
          BX7    "RN"X5 
          SA3    "TB"+X7     LK = TB + RK[R1] 
          BX6    X3*X4
          LX6    59-I.INVP
          MI     X6,MII1     IF INV[LJ] & INV[LK] 
          EQ     MII2 
  
*         TYPE 1 - 2 RESULTS
  
          PROCESS (NR,UP,RNZ) 
          LX5    -R1.RKP
          BX6    "RN"X5 
          SA4    "TB"+X6     LK = TB + RK[R1] 
          LX4    59-I.INVP
          MI     X4,MII1     IF INV[LK] 
          EQ     MII2 
  
*         CONSTANT SHIFTS 
  
          PROCESS (KLS,KRS) 
          SA4    A5+B1       R2 = R1 + 1
          LX4    -IH.RFP
          SA3    "TB"+X4     LF = TB + RF[R2] 
          LX3    59-I.INVP
          MI     X3,MII1     IF INV[LF] 
          EQ     MII2 
 IM       SPACE  2,14 
**        IM - MAY BE UNSAFE IF CONDITIONALLY EXECUTED
  
          PROCESS IM
          LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          SA4    "TB"+X6     LJ = TB + RJ[R1] 
          BX7    "RN"X5 
          SA3    "TB"+X7     LK = TB + RK[R1] 
          BX6    X3*X4
          LX6    59-I.INVP
          PL     X6,MII2     IF ^(INV[LJ] & INV[LK])
          SA2    AN 
          MI     X2,MII1A    IF AN < 0     */ UNCONDITIONALLY EXECUTED
  
*         INV AND CONDITIONALLY EXECUTED, MARK AS *USI* SO *SQZ* WILL 
*         ADD A UNPACK OF VARIABLE OPERANDS PRIOR TO THE MULTIPLY.
*         NOTE *LD* IS UNSAFE IF IT IS A PROGRAMMER VAR, NOT A VD.
  
          SA2    A4-B1       DJ = LJ - 1
          CALL   CMO
          SA2    A3-B1       DK = LK - 1
          ZR     X6,IM1      IF CMO(DJ) = 0  */ J OP IS SAFE
          CALL   CMO
          ZR     X6,IM2      IF CMO(DK) = 0  */ K OP IS SAFE
          EQ     MII2 
  
 IM1      CALL   CMO
          ZR     X6,MII1A    IF CMO(DK) = 0  */ K OP IS SAFE
  
 IM2      SA4    A5+2        DI = R1 + 2
          SX3    B1 
          LX3    D.USIP 
          BX6    X3+X4       USI[DI] = 1   */ MARK AS UNSAFE
          SA6    A4 
          EQ     MII1A
 ADDS     SPACE  3,14 
*         STT , IA, IS - CHECK FOR =(I+INV) 
  
          PROCESS STT 
          SA3    A5+B1       R2 = R1 + 1
          LX3    -IH.IHP
          SB2    X3 
          LX3    IH.IHP-IH.RFP
          SA4    "TB"+X3     LJ = TB + RF[R2] 
          LX4    59-I.INVP
          MI     X4,MII1     IF INV[LJ] 
  
          SA1    A4-3        R1P = LJ - 3 
          ZR     B2,IA2      IF IH[R2] = 0
  
          EQ     MII2 
 ADDS     EJECT 
          PROCESS (IA,IS) 
          LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          SA4    "TB"+X6     LJ = TB + RJ[R1] 
          BX7    "RN"X5 
          SA3    "TB"+X7     LK = TB + RK[R1] 
          BX6    X3*X4
          LX6    59-I.INVP
          BX7    X3+X4
          MI     X6,MII1A    IF INV[LJ] & INV[LK] 
          LX7    59-I.INVP
          PL     X7,MII2     IF ^( INV[LJ] ! INV[LK] )
  
          SX7    A4-B3       R1P = LJ - 3 
          SA2    A3-B1       DP = LK - 1
          LX4    59-I.INVP
          PL     X4,IA1      IF ^INV[LJ]
          SB2    B2-OC.IS 
          ZR     B2,MII2     IF OC[R1] = OC.IS  */ INV - I CASE 
          SX7    A3-B3       R1P = LK - 3 
          SA2    A4-B1       DP = LJ - 1
  
 IA1      LX2    59-D.ZPP 
          SA1    X7 
          PL     X2,MII2     IF ^ZP[DP]    */ INV OP IS ^ZP 
  
*         ONE OPERATION IS INV, SEE IF THE OTHER IS A *LD* OF A *RD* VAR
  
 IA2      UX7    B2,X1
          SX4    B2-OC.LD 
          LX1    -R1.INP
          NZ     X4,MII2     IF OC[R1P] " OC.LD 
          SA2    "UB"+X1
          LX2    59-UD.^RDP 
          MI     X2,MII2     IF ^RD[ UDI(IN[R1P]) ] 
  
          SX5    B1 
          SX1    X1 
          LX5    I.IAP
          LX1    I.LDIP      LDI[R1+3] = IN[R1] 
          BX6    X5+X1
          SA6    A5+3        IA[R1+3] = 1  */ INDICATE  =(I+CON)
          EQ     MII2 
 UJP      SPACE  2,14 
*         JUMP PROCESSING, CHECK FOR LABEL SUBSTITUTION, BUMP N.LJ
  
          PROCESS UJP 
          SA3    LIH
          BX4    X5-X3
          SB2    X4 
          NZ     B2,JPX2     IF IH[R1] " LIH
  
          SA2    N.LJ 
          SA3    LGL
          MX7    1
          BX6    X7+X2       N.LJ = N.LJ ! 1S59  */ INHIBIT PREFETCHING 
          SA6    A2 
          ZR     X3,JPX2     IF LGL = 0    */ NO LABEL SUBSTITUTION 
          AX3    18 
          IX6    X3+X5       IH[R1] = SHIFT( LGL , -18 )
          SA6    A5 
          EQ     JPX2 
 JPX      SPACE  2
          PROCESS JPX 
          SA4    A5+B1       R2 = R1 + 1
          SA3    LIH
          BX7    X3-X4
          SB2    X7 
          NZ     B2,JPX1     IF IH[R2] " LIH
  
          SA2    N.LJ 
          SA3    LGL
          SX7    B1 
          IX6    X7+X2       N.LJ = N.LJ + 1
          SA6    A2 
          ZR     X3,JPX1     IF LGL = 0    */ NO LABEL SUBSTITUTION 
          AX3    18 
          IX6    X4+X3       IH[R2] = SHIFT(LGL,-18)
          SA6    A4+
  
 JPX1     BX6    "RN"X5 
          SA4    "TB"+X6     LI = TB + RI[R1] 
          LX4    59-I.INVP
          PL     X4,JPX2     IF ^INV[LI]
  
          SA6    IJP         IJP = RI[R1]  */ SAVE OPERAND ADDR OF JP 
  
*         LAB, JUMP - CLEAR *AN*, IN CASE OPT=1 ( NO CONTROL FLOW INFO )
  
          PROCESS (LAB,JPBB)
 JPX2     SX6    0
          SA6    AN          AN = 0 
          EQ     MII2 
 JIN      SPACE  2,14 
*         JIN - INDEXED JUMP ( COMPUTED OR ASSIGNED GOTO )
  
          PROCESS JIN 
          SA2    N.LJ 
          MX7    1
          BX6    X7+X2       N.LJ = 1S59 ! N.LJ  */ INHIBIT PREFETCHING 
          SA6    A2 
          SA3    AN 
          SA2    LGL
          LX3    IM.APP-IM.LNP
          SA4    A5+B1       R2 = R1 + 1
          PL     X3,JPX2     IF ^LN[AN] 
          ZR     X2,JPX2     IF LGL = 0    */ NO LABEL CHANGE 
          SB2    X4 
          NZ     B2,JPX2     IF IH[R2] " 0 */ ^ AN ASSIGNED GOTO
  
*         SET FLAGS ( N.LJ , B59 OF R2 WORD ) TO INDICATE TO *GRA*
*         THAT SPECIAL CODE MAY BE NECESSARY FOR THIS *JIN* . 
  
          LX7    -1 
          BX6    X7+X6       N.LJ = N.LJ + 1S58 
          SA6    A6 
          LX7    1
          BX6    X7+X4       [R2] = [R2] + 1S59 
          SA6    A4 
          EQ     JPX2 
 TST      SPACE  3,14 
*         TST -  DEFINITION POINT OF MOVED INSTRUCTION
  
          PROCESS TST 
          BX6    "RN"X5 
          SA4    "TB"+X6     LI = TB + RI[R1] 
          SA3    O.TET
          LX4    59-I.INVP
          PL     X4,MII2     IF ^INV[LI]
  
          SA1    A5+B1       R2 = R1 + 1
          SB2    X3 
          LX1    -IH.CAP
          SA2    B2+X1
          LX2    59-T.INVP
          PL     X2,MII2     IF ^INV[TET(CA[R2])] 
          EQ     MII1A
 RS       EJECT 
*         REGISTER STORE PROCESSING 
  
          PROCESS RS
          SA4    A5-B1       LI = R1 - 1
          MX7    -SO.LKL
          LX5    -R1.SOP-SO.LKP 
          BX6    -X7*X5      LKT = SOLK[R1] 
          LX4    59-I.INVP
          ZR     X6,RS1      IF LKT = 0    */ UJP LOCK
          SB2    X6-2 
          LT     B2,MII2     IF LKT = 1    */ TEMP LOCK 
          PL     X4,MII2     IF ^INV[LI]
  
          GT     B2,MII1     IF LKT = 3    */ *RJ RS* 
  
*         FULL LOCK *RS* AND OPERAND INVARIANT IN CURRENT LOOP
  
          SX7    B1 
          LX5    R1.SOP+SO.LKP
          LX7    R1.SOP+SO.INVCP
          BX6    X7+X5       INVC[R1] = 1  */ INDICATE INV IN THIS LOOP 
          SA6    A5 
          MX7    -SO.RTL
          LX5    -R1.SOP-SO.RTP 
          BX4    -X7*X5 
          ZR     X4,RS0      IF SORT[R1] = 0  */ RS TO A B-REG
          SA3    A5-B3       R2P = R1 - 3 
          LX3    59-IH.LDP
          PL     X3,MII2     IF ^LD[R2P]   */ MOVE IF NOT A PREFETCH
  
*         REMOVE PRED OF *RS* FROM INVARIANT CHAIN
  
 RS0      SA4    A5-B1       LIP = R1 - 1 
          LX4    -I.IICP     I = IIC[LIP] 
          SA3    "TB"+X4     LJP = TB + I 
          BX7    X3 
          SA7    A3          LII = LJP
          MX6    0
          SA6    A4          [LIP] = 0
          EQ     MII2 
  
*         *UJP* RS , PRECEEDING A FUNCTION CALL 
  
 RS1      MI     X4,RS2      IF INV[LI] 
          SA0    -1          FAC = 0       */ INDICATE ^INV OPERAND 
          EQ     MII2 
  
 RS2      SX6    A0 
          MI     X6,MII2     IF FAC < 0    */ PREVIOUS ARG NOT INV
          LX6    I.IICP 
          SA6    A5+B3       IIC[R1+3] = FAC  */ CHAIN THIS TO LAST 
          SA0    A6-"TB"     FAC = R1+3 - TB
          EQ     MII2 
 RJ3      SPACE  2,14 
*         RJ3 - CHECK FOR *BEF* AND ARGS INVARIANT
  
          PROCESS (RJ3,RJ6) 
          SA1    AN 
          SB2    A0          AC = FAC 
          SA0    B0          FAC = 0
          PL     X1,MII2     IF ^AN        */ ON A SIDE BRANCH
          LE     B2,MII2     IF AC @ 0     */ ARGS NOT INV
          SA4    A5+B1       R2 = R1 + 1
          MX7    -FI.FTL
          LX4    -FI.FTP
          BX6    -X7*X4 
          SX3    X6-2 
          NZ     X3,MII2     IF FT[R2] " 2 */ NOT A *BEF* 
 RJ3      SPACE  1,10 
*         MARK *RS"S* AS INV SO WE KNOW TO MOVE THEM OUT
  
 RJ31     SA3    "TB"+B2     LIP = TB + AC
          MX4    1
          LX4    1+I.INVP 
          BX6    X4+X3       INV[LIP] = 1 
          LX3    -I.IICP
          SB2    X3          AC = IIC[LIP]
          SA6    A3 
          NZ     B2,RJ31     IF AC " 0
  
*         MARK RJ3 AND DEFS FOLLOWING AS *INV*
  
 RJ32     SX3    A7-"TB"     IIC[R1+3] = LII - TB 
          LX3    I.IICP 
          BX7    X4+X3       INV[R1+3] = 1
          SA7    A5+B3       LII = R1 + 3 
          SA5    A7+B1       R1 = LII + 1 
          UX1    B2,X5
          SX2    B2-OC.DEF
          ZR     X2,RJ32     IF OC[R1] = OC.DEF 
  
          SA3    AN 
          ZR     X3,RJ33     IF AN = 0     */ MII CALLED FROM *CIF* 
          SA3    XRF
          SX4    B1 
          IX6    X3-X4       XRF = XRF - 1 */ DECR N.EXT-REFS IN LOOP 
          SA6    A3 
          NZ     X6,RJ33     IF XRF " 0 
  
          SA3    MRA.X
          BX6    X3          MRA = MRA.X   */ MAKE REGS AVAIL IN *GRA*
          SA6    MRA
  
 RJ33     JP     MII.JT+B2   JUMP( MII.JT( OC[R1] ) ) 
 ST       EJECT 
*         ST - SEE IF MOVABLE OR A RECURSIVE DEFINITION 
  
          PROCESS ST
          SA3    A5+B1       R2 = R1 + 1
          BX6    "RN"X5 
          LX5    -R1.INP
          SA4    "UB"+X5     UI = UDI(IN[R1]) 
          LX3    -IH.RFP
          SX7    X3 
          NZ     X7,MII2     IF RF[R2] " 0 */ LEAVE INDEXED STORES ALONE
  
          SA2    "TB"+X6     LI = TB + RI[R1] 
          LX2    59-I.INVP
          SA1    AN 
          SB2    X5 
          BX7    X1*X2
          ZR     B2,ST3      IF IN[R1] = 0 */ AP/IO LIST STORE
  
          PL     X7,ST1      IF ^( AN & INV[LI] ) 
          MX6    -UD.STCL 
          LX6    UD.STCP+1
          BX1    -X6*X4 
          NZ     X1,ST1      IF ^( STC[UI] = 1 & IST[UI] = 0 )
  
          SA3    A4+B1       U2 = UI + 1
          SA1    UBD
          SA4    LEA
          UX7    B2,X3       B = BITN[U2] 
          IX6    X1+X7
          SA3    UVA
          IX4    X4+X7
          IX7    X3+X7
          SA1    X6          UFW = UBD( WI[U2] )
          SA4    X4          LEW = LEA( WI[U2] )
          SA3    X7          PUW = UVA( WI[U2] )
          BX6    X3+X1
          BX6    X4+X6
          AX7    B2,X6
          LX7    59 
          SA4    "UB"+X5     RESET UI 
          MI     X7,ST1      IF SHIFT(PUW!UFW!LEW!,59-B)
  
*         *ST* IS MOVABLE, CLEAR BITS IN *UDT* AND BLOCK *DEF* VECTOR 
*         SET BIT IN REGION LIVE ENTRY BIT VECTOR FOR *RDD* AND *GRA* 
  
          SA3    STA
          BX6    -X3*X4      (DEFR,^RD,STC)[UI] = 0  */ SO LD"S CAN MOVE
          SA3    VL 
          SX7    B1 
          SA6    A4 
          LX7    B2,X7
          SB2    X3 
          SA1    A1-B2       DEFW = UFW - VL
          BX6    -X7*X1      DEFW = DEFW & ^SHIFT(1,B)
          SA6    A1 
          SA3    LEA
          SA4    A4+B1       U2 = UI + 1
          IX6    X3+X4
          SA4    X6          LEW = [LEA+WI[U2]] 
          BX6    X7+X4       LEW = LEW ! SHIFT(1,B)  */ MOVED ST IS *LE*
          SA6    A4 
          EQ     MII1 
 ST       SPACE  1,10 
*         CHECK TO SEE IF THIS *ST* IS A RECURSIVE DEFINITION 
*         THE RESTRICTION THAT THE *ST* IMMEDIATELY FOLLOW THE INCREMENT
*         IS A SIMPLE WAY OF DISALLOWING USES OF THE INC BETWEEN IT AND 
*         THE *ST*. WITHOUT THIS WE COULD GET INTO SOME NASTY SITUATIONS
*         AS THE RESULT OF REGISTER ASSIGNMENT. 
  
 ST1      LX4    59-UD.^RDP 
          MI     X4,MII2     IF ^RD[UI] 
          LX2    I.INVP-I.IAP 
          PL     X2,ST2      IF ^IA[LI]    */ PRED IS NOT  I+INV
  
          LX2    1+I.IAP-I.LDIP 
          SX6    "SC" 
          BX1    X5-X2
          SB2    X1 
          NZ     B2,ST2      IF LDI[LI] " IN[R1]  */ NOT  I = I+INV 
          SB2    A2+B1
          SX1    A5-B2
          NZ     X1,ST2      IF LI+1 " R1  */ INC OP NOT NEXT TO *ST* 
  
*         ADD *ST* TO *STC*, LIST OF POSSIBLE *RD*"S
  
          LX6    I.STCP      STC[R1+3] = SC 
          SA6    A5+B3
          S"NI"  "NI"+B1     NI = NI + 1
          S"SC"  A6-"TB"     SC = R1+3 - TB 
          EQ     MII2 
  
*         MARK VAR AS *^RD* IN *UDT*
  
 ST2      MX1    1
          BX6    X1+X4
          LX6    1+UD.^RDP   ^RD[UI] = 1
          SA6    A4 
          EQ     MII2 
  
*         AP / IO LIST STORE, MOVABLE IF ^EQUIVALENCED
  
 ST3      PL     X7,MII2     IF ^( AN & INV[R1] ) 
          LX3    IH.RFP-IH.IHP
          SX7    X3-I.IO
          PL     X7,MII1     IF I[R2] = I.IO  */ AN I/O LIST
          SA1    =XO.API
          SB2    X3-I.AP-1
          SA2    X1+B2       AI = API(H[R2])
          MX7    2
          BX3    X7*X2
          NZ     X3,MII2     IF EQV[AI] ! BASE[AI]
          EQ     MII1 
  
 STA      BFMW   UD,(DEFR,^RD,STC)
 EOQ      EJECT 
*         EOQ - END OF MARKING PHASE, SET CHAIN POINTERS IN *BSW* 
  
          PROCESS EOQ 
          SA1    BN 
          SX5    "SC" 
          SX7    A7-"TB"     IIC = LII - TB 
          LX5    BS.STCP     STC[BSW] = SC
          LX7    BS.IICP     IIC[BSW] = LII - TB
          BX6    X5+X7
          PX7    "NI",X6     NIS[BSW] = NI
          SA7    "TB"        [TB] = BSW 
          SA7    BSW
          ZR     X1,MII      IF BN = 0     */ CALL FROM *CIF* 
          TRACE  MII,RLIST,SEQ
  
*         ADD CONTRIBUTIONS FROM THIS BLOCK INTO REGION USE/DEF VECTORS.
  
          SA1    UBD
          SA2    VL 
          SA3    DVA
          SB2    B0          I = 0
          SB3    X2                        (B3) = VL
          SB4    B3+B3
          IX0    X1-X2       BDA = UBD - VL 
          SB6    X3                        (B6) = [DVA] 
  
 MII4     SA1    X0+B2
          SA2    B6+B2
          SA3    A1+B4
          SA4    A2+B4
          BX6    X1+X2       DVA(I) = DVA(I) ! BDA(I) 
          SA6    A2 
          BX7    X3+X4       UVA(I) = UVA(I) ! BUA(I) 
          SB2    B2+B1       I = I + 1
          SA7    A4 
          LT     B2,B3,MII4  IF I < VL
  
          ZR     "TB",MII5   IF TB = 0
          SA5    O.BIT
          SA4    "TB"-3      R1 = TB - 3
          SB2    X5 
          SA3    B2+X4       BIW = BIT(BN[R1])
          LX3    59-BI.RBP
          MI     X3,MII5     IF RB[BIW]    */ NOT A HOLDING BLOCK 
  
          LX3    1+BI.RBP-BI.PBNP 
          SA2    B2+X3       BIW = BIT(PBN[BIW])
          SA1    O.BVT
          LX2    -BI.BVIP 
          IX0    X1+X2       BDA = O.BVT + BVI[BIW] 
          SB2    B0          I = 0
          S"TB"  B0          TB = 0 
          EQ     MII4 
  
 MII5     SA2    IJP
          ZR     X2,MII      IF IJP = 0    */ NO INVARIANT JUMPS
  
          EQ     MII
 MII.JT   SPACE  3,14 
*         THE FOLLOWING OPCODES ARE NOT EXPECTED TO APPEAR
  
          ECHO   1,X=(PLD,PST,SLD,SST,SDS,DRL,DWL)
 .X       EQU    1S17+MII 
  
*         OPR - DEFINE MACRO TO FORM JUMP TABLE FOR *MII* 
  
          MACRO  OPR,NAM,SS 
          NOREF  .NAM 
 O        IF     DEF,.NAM 
 Z        MICRO  3,1,/NAM/
          IFC    NE,/"Z"//,2
          EQ     .NAM              NAM
          SKIP   1
          EQ     .NAM               NAM 
 O        ELSE   2
 TYP      MICRO  3,3,$SS$ 
          EQ     TY"TYP"     NAM
          ENDM
          SPACE  2
 MII.JT   BSS    0
          LOC    0
*CALL     OPRDEFS 
  
          LOC    *O 
          LIST   -G 
  
          QUAL   CODE 
  
 MII      EQU    /MII/MII 
 FII      TITLE  FII - FORM INCREMENT INFORMATION 
**        FII - FORM INCREMENT INFORMATION
*         SCAN *STC* TO FORM A LIST OF INCREMENT VALUES OF *RD* 
*         VARIABLES, AND SAVE THEM IN *IIT*.
* 
*         EXIT   *STC* IN BSW UPDATED 
*                *HBP* OF *ST* OF *RD* POINTS TO INCREMENT VALUE. 
  
 FII0     SA4    IIL
          SA5    BSW
          SX6    B5 
          LX0    BS.STCP
          SX3    B4 
          BX5    X0*X5
          SA6    L.IIT       L.IIT = IL    */ FINAL LENGTH
          LX3    BS.STCP     STC[BSW] = SC
          BX1    X3+X5
          PX7    X1          NIS[BSW] = 0 
          SA7    A5 
  
          TRACE  FII,IIT
  
 FII      ROUTINE 
          UX6    B2,X4
          ALLOC  IIT,B2      ALLOC( IIT , NIS[BSW] )
          SA5    O.SEQ
          SA4    BSW
          SA3    O.UDT
          S"TB"  X5+3        TB = O.SEQ + 3 
          SX6    B6          IIL = OLD(L.IIT) 
          SB5    B6          IL = IIL      */ *IIT* LENGTH
          SA6    IIL
          SA0    X2 
          S"UB"  X3          UB = O.UDT 
          LX4    -BS.STCP 
          SB3    X4          I = STC[BSW] 
          SB4    B0          SC = 0        */ LAST ON CHAIN 
          EQ     FII2 
  
*         SAVE INC VALUE IN *IIT*, SET *ST* TO POINT TO *IIT* 
  
 FII1     SA6    A0+B5       IIT(IL) = ITW
          SX4    B4 
          SX1    B5 
          LX4    I.STCP      STC[LI] = SC  */ POINT TO LAST 
          LX1    I.HBPP      HBP[LI] = IL  */ POINT TO INC VALUE
          PX6    X1          NPI[LI] = 0
          BX7    X4+X6
          SB5    B5+B1       IL = IL + 1
          SA7    A5 
          SB4    A5-"TB"     SC = LI - TB  */ CHAIN POINTS TO THIS
  
 FII2     SA5    "TB"+B3     LI = TB + I
          ZR     B3,FII0     IF I = 0 
          LX5    -I.STCP
          SA4    A5-3        R1 = LI - 3
          SB3    X5          I = STC[LI]   */ NEXT ON CHAIN 
          BX6    "RN"X4      R = RI[R1] 
          LX4    -R1.INP
          SA3    "UB"+X4     UI = UB + IN[R1] 
          LX3    59-UD.^RDP 
          SA2    A5-B1       DI = LI - 1
          MI     X3,FII2     IF ^RD[UI]    */ ^ RD IN REGION
  
*         *ST* IS STILL A *RD*, FIND THE INCREMENT VALUE
  
          MI     X3,FII2     IF ^RD[UI] 
          SB2    "TB"-B1
          SA3    B2+X6       DIP = TB-1 + R 
          SA4    A3-2        R1 = DIP - 2 
          SX1    B1 
          LX1    D.INCP 
          BX7    X1+X3       INC[DIP] = 1 
          SA7    A3 
          BX6    X1+X2       INC[DI] = 1
          UX5    B2,X4
          SA6    A2 
          SX7    B2-OC.STT
          NZ     X7,FII3     IF OC[R1] " OC.STT 
  
          SA3    A4+B1       R2 = R1 + 1
          MX1    -IH.CAL
          LX3    -IH.CAP
          BX4    -X1*X3 
          PX6    X4          ITW = PACK(0,CA[R2]) 
          EQ     FII1 
  
*         PROCESS IA, IS
  
 FII3     LX4    -R1.RJP
          BX6    "RN"X4 
          SA3    "TB"+X6     LP = TB + RJ[R1] 
          MX5    0           BIAS = 0 
          SX7    A3          LA = LP
          LX3    59-I.INVP
          MI     X3,FII4     IF INV[LP] 
          LX4    R1.RJP-R1.RKP
          BX6    "RN"X4 
          SX5    B2-OC.IA    BIAS = OC[R1] - OC.IA
          SX7    "TB"+X6     LA = TB + RK[R1] 
  
*         INC VALUE IS +- VAL OF *INV* PRED OF IA/IS
  
 FII4     SA4    X7-3        R1 = LA - 3
          UX6    B2,X4
          SX1    B2-OC.LD 
          NZ     X1,FII5     IF OC[R1] " OC.LD
  
          SA4    A4+B1       R2 = R1 + 1
          AX6    R1.INP 
          SB2    X5+B1
          LX6    IH.RFP 
          BX5    X6+X4       VAL = SHIFT(IN[R1],IH.RFP) + CAIH[R2]
          PX6    B2,X5       ITW = PACK( BIAS+1 , VAL ) 
          EQ     FII1 
 FII      SPACE  3,14 
*         OPERATION IS ZP , SHOULD BE A *S* OR *FMA*
  
 FII5     SX7    B2-OC.S
          MX1    -R1.INL
          LX4    -R1.INP     C = IN[R1] 
          ZR     X7,FII6     IF OC[R1] = OC.S 
          SX7    B2-OC.FMA
          NZ     X7,FII10    IF OC[R1] " OC.FMA 
          SB2    X4-1 
          MX2    1
          AX4    B2,X2       C = SHIFT( 1S59 , -(C-1) ) 
  
 FII6     ZR     X5,FII7     IF BIAS = 0
          BX4    -X4         C = -C 
 FII7     BX4    -X1*X4 
          PX6    X4          ITW = PACK( 0 , C )
          EQ     FII1 
  
 FII10    EQU    FII+1S17    COMPILER ERROR 
 MIP      TITLE  MIP - MARK INTEGER POLYNOMIALS 
**        MIP - MARK INTEGER POLYNOMIALS AND MERGE ONTO CHAIN OF *INV*
*         INSTRUCTIONS. 
*         FOWARD SCAN TO FORM A LIST OF INTEGER POLYNOMIALS ( *IP*"S ). 
*         FOLLOWED BY A BACKWARDS SCAN OVER THE LIST TO MERGE THEM
*         ONTO THE *IIC*.  DURING THE MARKING PHASE WE COMPUTE THE
*         *COST* OF AN *IP*, WHICH IS AN APPROXIMATE MEASURE OF THE 
*         NUMBER OF TERMS IN IT.  THE DIFFERENCE BETWEEN THE COST OF
*         AN *IP* AND ITS INCREMENT FORMULA ( 2 OR 3 ) IS AN APPROXIMATE
*         MEASURE OF THE PROFIT IN CREATING A COMPILER TEMPORARY .
  
          QUAL   MIP
  
 MIP0     BSS    0
          TRACE  MIP,RLIST,SEQ
  
 MIP      ROUTINE 
          SA1    L.SEQ
          AX1    2
          ALLOC  RND,X1      ALLOC( RND , L.SEQ/4 ) 
          SA3    O.UDT
          SA4    O.SEQ
          MX7    0
          SB5    B0          LEI = 0       */ LAST ENCOUNTERED *INC* ST 
          SA7    L.RND       L.RND = 0
          SA7    X2          PI = O.RND;  [PI] = 0
          SB4    59-D.INCP
          S"UB"  X3          UB = O.UDT 
          SB3    3
          MX1    -I.COSTL 
          S"TB"  X4+B3       TB = O.SEQ + 3 
          LX1    I.COSTP
          SA5    X4          R1 = O.SEQ 
          BX6    X5 
          LX6    -IM.APLNL-R1.H2P  ARTICULATION NODE TO SIGN BIT
          SA6    AN          MI IFF UNCONDITIONALLY EXECUTED (SAVED IN *
          EQ     MIP2 
 MIP      SPACE  3
*         ADD INSTRUCTION TO *IP* LIST, (A6,X6) = LI, [LI]
  
 MIP1     LX4    59-I.INVP
          MI     X4,MIP2     IF INV[LI] 
          SX7    A4-"TB"
          SA7    A7+B1       PI = PI + 1;  [PI] = LI - TB 
          ZR     B5,MIP2     IF LEI = 0    */ NO INCREMENTS YET 
          BX7    X6 
          LX7    59-I.LDIP
          MI     X7,MIP2     IF ODD[LDI[LI]]  */ USES NEW VALUE 
  
*         IP USES OLD VALUE OF INCREMENT VARIABLE, MARK IT AS *AIP* 
*         IF IT OCCURS PAST A REDEF OF THE INCREMENT VARIABLE.
  
          SA3    SC 
          SB2    X3          J = SC        */ FIRST INC ST IN BLOCK 
          LX6    -I.LDIP     L = LDI[LI]
  
 MIP1A    SA4    "TB"+B2     LIS = TB + J  */ LINK WD OF INC ST 
          SA3    A4-B3       R1S = LIS - 3 */ R1 WORD 
          LX3    -R1.INP
          BX5    X3-X6
          SX2    X5 
          ZR     X2,MIP1B    IF IN[R1S] = L  */ SAME VARIABLE 
          LX4    -I.STCP
          SB2    X4+         J = STC[LIS]  */ NEXT ON CHAIN 
          ZR     B2,MIP2     IF J = 0      */ END OF CHAIN
          LE     B2,B5,MIP1A IF J @ LEI 
          EQ     MIP2 
  
 MIP1B    SX4    B1 
          LX4    I.AIPP 
          LX6    I.LDIP 
          BX6    X4+X6       AIP[LI] = 1
          SA6    A6 
  
*         ADVANCE TO NEXT INSTRUCTION, JUMP TO PROCESSOR
  
 MIP2     SA5    A5+4        R1 = R1 + 4
          SA4    A5+B3       LI = R1 + 3
          UX6    B2,X5
          JP     MIP.JT+B2   JUMP( MIP.JT( OC[R1] ) ) 
  
 MIPA     BFMW   I,(IP,COST,LDI)
 MIPB     BFMW   I,(IIC,LDI)
 MIPC     BFMW   I,(IP,C1)
 MIPD     BFMW   I,(IP,LDI) 
 ST       SPACE  3
*         ST - SET *LEI* IF AN INCREMENT STORE
  
          PROCESS ST
          BX6    "RN"X5 
          LX5    -R1.INP
          SA3    "UB"+X5     UI = UDT(IN[R1]) 
          LX3    59-UD.RFP
          PL     X3,ST1      IF ^RF[UI]    */ NOT SHORT USE 
          SB2    "TB"-B1
          SA3    B2+X6       DIP = TB-1 + RI[R1]
          SX6    B1 
          LX6    D.RFP
          BX6    X6+X3       RF[DIP] = 1   */ PROPAGATE *RF* TO ST PRED 
          SA6    A3 
  
 ST1      SA3    A4-B1       DI = LI - 1
          LX3    59-D.INCP
          PL     X3,MIP2     IF ^INC[DI]
  
          NZ     B5,ST2      IF LEI " 0    */ ^ FIRST INC ST IN BLOCK 
          SX6    A4-"TB"
          SA6    SC          SC = LI - TB  */ TXT INDEX OF FIRST INC ST 
  
 ST2      SB5    A4-"TB"     LEI = LI - TB */ LAST INC ST 
          EQ     MIP2 
 BBM      SPACE 2 
*         BASIC BLOCK MARKER, CLEAR *LEI* 
  
          PROCESS (RJ3,RJ6,LAB) 
          SB5    B0          LEI = 0
          EQ     MIP2 
 EOQ      EJECT 
**        EOQ - MERGE *IP* LIST INTO *ICC* CHAIN
  
          PROCESS EOQ 
          SA2    O.RND
          SB5    X2+
          SB4    A7-B5       NP = PI - O.RND
          SA5    A7          PI = PI
          LE     B4,B1,MIP0  IF NP @ 1
  
          SA2    BSW
          SA1    MIPB 
          LX2    -BS.IICP 
          SB6    I.IICP 
          SB2    X2          IC = IIC[BSW]
          SB3    X5          PL = [PI]
          GT     B3,B2,MIP3  IF PL > IC 
          SB4    B2          LE = IC
          SA4    "TB"+B2     LI = TB + IC 
          AX7    B6,X4
          SB2    X7          IC = IIC[LI] 
          EQ     MIP4 
  
 MIP3     BX2    X0*X2
          BX6    X2+X5       IIC[BSW] = PL */ UPDATE CHAIN POINTER
          LX6    BS.IICP
          SA6    A2+
          SB4    X5          LE = PL
          SA5    A5-B1       PI = PI - 1
          SB3    X5          PL = [PI]
          SA4    "TB"+B4     LI = TB + LE 
  
 MIP4     GT     B2,B3,MIP5  IF IC > PL 
          SX3    B3 
          BX7    -X1*X4      HBP[LI] = 0
          LX3    I.IICP 
          BX6    X3+X7       IIC[LI] = PL 
          SA6    A4 
          SB4    B3          LE = PL
          SA5    A5-B1       PI = PI - 1
          SA4    "TB"+B3     LI = TB + PL 
          SB3    X5+         PL = [PI]
          NZ     X5,MIP4     IF PL " 0
          ZR     B2,MIP6     IF IC = 0
  
 MIP5     SX3    B2 
          BX7    -X1*X4      HBP[LI] = 0
          LX3    I.IICP 
          BX6    X3+X7       IIC[LI] = IC 
          SA6    A4 
          SB4    B2          LE = IC
          SA4    "TB"+B2     LI = TB + IC 
          AX7    B6,X4
          SB2    X7          IC = IIC[LI] 
          GT     B2,B3,MIP5  IF IC > PL 
          NZ     B3,MIP4     IF PL " 0
  
 MIP6     BX6    -X1*X4      IIC[LI] = HBP[LI] = 0
          SA6    A4 
          EQ     MIP0 
 TYII     SPACE  3,8
*         TYPE II - SET *IP* BIT
  
          PROCESS (FMA,S) 
          SX2    B1 
          LX2    I.IPP
          BX6    X2+X4       IP[LI] = 1 
          SA6    A4 
          EQ     MIP2 
 LD       SPACE  3,14 
*         LD - IF *RD* , THEN SET *IP* BIT , AND *LDI* FIELD IF ^INV
  
          PROCESS (LD,ILD)
          SA3    A5+B1       R2 = R1 + 1
          LX5    -R1.INP
          SA2    "UB"+X5     UI = UB + IN[R1] 
          LX3    -IH.RFP
          BX6    "RN"X3 
          NZ     X6,MIP2     IF RF[R2] " 0
          LX2    59-UD.^RDP 
          MI     X2,MIP2     IF ^RD[UI] 
  
          SA3    MIPC 
          BX6    X3+X4       IP[LI] = 1;  COST[LI] = 1
          LX4    59-I.INVP
          MI     X4,LD1      IF INV[LI] 
  
          SX7    A4-"TB"
          SX5    X5 
          SA7    A7+B1       PI = PI + 1;  [PI] = LI - TB 
          LX5    I.LDIP      LDI[LI] = IN[R1] 
          BX6    X6+X5
 LD1      SA6    A4 
          EQ     MIP2 
 XMTC     SPACE  2,8
          PROCESS XMTC
          LX5    -R1.RJP
          SA2    MIPA 
          BX6    "RN"X5 
          SA3    "TB"+X6     LJ = TB + RJ[R1] 
          SX7    B1 
          BX6    X2*X3
          LX3    59-I.IPP 
          PL     X3,MIP2     IF ^IP[LJ] 
  
          BX6    X6+X4       (IP,COST,LDI)[LI] = (IP,COST,LDI)[LJ]
          LX7    I.COSTP
          IX6    X7+X6       COST[LI] = COST[LI] + 1
          SA6    A4 
          EQ     MIP1 
 SXT      EJECT 
*         SXT - CONSTANT SHIFT PREDECESSOR
  
          PROCESS SXT 
          LX5    -R1.RJP
          SA2    MIPA 
          BX7    "RN"X5 
          SA3    "TB"+X7     LJ = TB + RJ[R1] 
          SA5    A4+B1       R1 = LI + 1   */ ADVANCE TO CON SHIFT
          BX6    X2*X3
          LX3    59-I.IPP 
          PL     X3,MIP2     IF ^IP[LJ] 
  
          UX2    B2,X5
          SA3    A5+B1       R2 = R1 + 1
          SB2    B2-OC.KLS
          NZ     B2,MIP2     IF OC[R1] " OC.KLS 
          LX3    -IH.CAP
          SB2    X3-17
          SX7    A4-"TB"
          PL     B2,MIP2     IF CA[R2] \ 17  */ SHIFT COUNT TOO BIG 
  
          LX4    59-I.INVP
          MI     X4,SXT1     IF INV[LI] 
          SA7    A7+B1       PI = PI + 1;  [PI] = LI - TB 
  
 SXT1     SA4    A5+B3       LI = R1 + 3
          SX7    B1 
          BX6    X6+X4       (IP,COST,LDI)[LI] = (IP,COST,LDI)[LJ]
          LX7    I.COSTP
          IX6    X7+X6       COST[LI] = COST[LI] + 1
          SA6    A4 
          EQ     MIP1 
 IM       SPACE  3,10 
          PROCESS IM
          LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          SA2    "TB"+X6     LJ = TB + RJ[R1] 
          BX7    "RN"X5 
          SA3    "TB"+X7     LK = TB + RK[R1] 
          BX6    X2*X3
          LX6    59-I.IPP 
          PL     X6,MIP2     IF ^( IP[LJ] & IP[LK] )
  
          BX7    X2+X3       LJK = [LJ] ! [LK]
          SX5    B3          ICOST = 3
          LX7    59-I.INVP
          PL     X7,MIP2     IF NEITHER INVARIANT 
          SA4    AN 
          MI     X4,IM5      IF UNCONDTIONALLY EXECUTED 
          SA2    A2-B1       DJ = LJ - 1
          CALL   CMO         CHECK SAFETY OF J OPERAND
          SA2    A3-B1       DK = LK - 1
          ZR     X6,IM1      IF J IS SAFE 
          CALL   CMO         CHECK SAFETY OF K OPERAND
          ZR     X6,IM2      IF K IS SAFE 
          EQ     MIP2        NOT SAFE (NEITHER OPERAND) 
  
 IM1      CALL   CMO         CHECK SAFETY OF K (J IS SAFE)
          ZR     X6,IM4      IF K IS SAFE 
  
*         ONE OPERAND SAFE.  MARK MULTIPLY UNSAFE SO *SQZ* WILL 
*         INSERT AN UNPACK, AND HOIST.
  
 IM2      SA4    A5+2        DI = RI + 2
          SX6    B1 
          LX6    D.USIP 
          BX6    X6+X4       USI[DI] = 1
          SA6    A4 
  
*         MULTIPLY CAN BE HOISTED WITH IMPUNITY.
  
 IM4      SA5    A5 
          LX5    -R1.RJP
          BX6    "RN"X5 
          SA2    "TB"+X6     RESTORE LJ 
          SA4    A5+3        RETORE LI
          BX7    X2+X3       RESTORE LJK
          SX5    B3          ICOST = 3
          EQ     IA1
  
 IM5      SA4    A5+3        RESTORE LI 
          EQ     IA1
 ADDS     EJECT 
**        ADDS - ONLY ALLOW *IP*"S IN 1 VARIABLE
  
          PROCESS (IA,IS) 
          SA3    A4-B1       DI = LI - 1
          LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          BX7    "RN"X5 
          SA2    "TB"+X6     LJ = TB + RJ[R1] 
          LX5    B4,X3
          SA3    "TB"+X7     LK = TB + RK[R1] 
          BX6    X2*X3
          LX6    59-I.IPP 
          PL     X6,IA3      IF ^( IP[LJ] & IP[LK] )
  
          BX7    X2+X3       LJK = [LJ] ! [LK]
          MI     X5,IA2      IF INC[DI] 
          SX5    B1          ICOST = 1
          LX7    59-I.INVP
          MI     X7,IA1      IF INV[LJ] ! INV[LK] 
  
*         BOTH ^INV, MAKE SURE VARIABLES ARE THE SAME 
  
          BX6    X2-X3
          LX6    -I.LDIP
          SB2    X6 
          NZ     B2,MIP2     IF LDI[LJ] " LDI[LK] 
  
          NZ     X6,IA1      IF [LJ] " [LK] 
          MX3    0           COST[LK] = 0  */ IN REGS ONLY
  
*         ADD INSTRUCTION TO *IP* LIST, COST = ICOST + SIGMA(COST[PRED])
  
 IA1      BX6    -X1*X2 
          SA2    MIPD 
          LX5    I.COSTP
          BX3    -X1*X3 
          IX4    X4+X5       COST[LI] = ICOST 
          LX7    1+I.INVP 
          BX7    X2*X7       IP[LI] = 1;  LDI[LI] = LDI[LJK]
          IX6    X3+X6
          BX4    X7+X4
          IX6    X6+X4       COST[LI] = COST[LI] + COST[LJ] + COST[LK]
          SA6    A4+
          EQ     MIP1 
  
*         INCREMENT, SET COST = 1, SINCE ANY USES OF IT ARE USES OF A 
*         LD OF THE REDEF VAR, BUMP LDI TO INDICATE NEW VARIABLE. 
  
 IA2      SA2    MIPC 
          LX7    -I.LDIP
          SX7    X7+B1       LDI[LI] = LDI[LJK] + 1 */ MARK NEW VAR 
          LX7    I.LDIP 
          BX4    X7+X4
          BX6    X2+X4       IP[LI] = 1;  COST[LI] = 1
          SA6    A4 
          EQ     MIP1 
 IA       SPACE  1,10 
*         CHECK FOR *IA* + *INV*, AND MARK *IA* IF SO 
  
 IA3      BX7    X2+X3
          LX7    59-I.INVP
          PL     X7,MIP2     IF ^( INV[LJ] ! INV[LK] )
          LX7    I.INVP-I.IAP 
          PL     X7,MIP2     IF ^( IA[LJ] ! IA[LK] )
  
          SX7    B1 
          LX7    I.IAP
          BX6    X7+X4       IA[LI] = 1 
          SA6    A4 
          EQ     MIP2 
 STT      SPACE  2,14 
*         STT - PROPAGATE *IA* BIT UP FOR USE BY *JPX* PROCESSOR
  
          PROCESS STT 
          SA3    A5+B1       R2 = R1 + 1
          SX7    B1 
          LX3    -IH.IHP
          SB2    X3 
          LX3    IH.IHP-IH.RFP
          LX7    I.IAP
          BX6    "RN"X3 
          SA2    "TB"+X6     LIP = TB + RF[R2]
          BX7    X7*X2
          BX6    X7+X4       IA[LI] = IA[LIP] 
          SA6    A4 
  
*         ADD TO *IP* LIST IF NOT *PS* OR *PRS* ( UNPROFITABLE CASES )
  
          SA3    A3+B1       DI = R2 + 1
          MX7    -D.STRSL 
          LX7    D.STRSP
          BX7    -X7*X3 
          NZ     X7,MIP2     IF STRS[DI] " 0  */ *INC* OR INIT CODE 
          ZR     B2,STT1     IF IH[R2] = 0
  
          SB2    A2-"TB"
          NZ     B2,MIP2     IF RF[R2] " 0
          EQ     .S 
  
 STT1     LX2    59-I.IPP 
          PL     X2,MIP2     IF ^IP[LIP]
          LX2    1+I.IPP
          SA3    MIPA 
          BX7    X2*X3
          BX6    X6+X7       (IP,COST,LDI)[LI] = (IP,COST,LDI)[LIP] 
          SA6    A6 
          EQ     MIP1 
 JPX      EJECT 
*         JPX - CHECK FOR LOOP BACK JUMP, AND IF SO COLLECT INFORMATION 
*         FOR TEST REPLACEMENT IN *GRA*.  STATEMENTS OF THE FORM -
*         IF( I @ LIM ) GO TO LIH  RI = LIM - I ;  PL  RI,LIH 
*         IF( I < LIM ) GO TO LIH  RI = I - LIM ;  MI  RI,LIH 
*         ARE THE PATTERNS THAT WE LOOK FOR HERE. 
  
          PROCESS JPX 
          SA2    N.LJ 
          SA3    LIH
          SA4    A5+B1       R2 = R1 + 1
          SB2    X2 
          BX7    X3-X4
          SX6    X7 
          NE     B2,B1,MIP2  IF N.LJ " 1
          NZ     X6,MIP2     IF IH[R2] " LIH
          LX4    -IH.CAP
          SB4    X4-2        JPT = CA[R2] - 2 
          SB2    "TB"-B3
          MI     B4,MIP2     IF JPT @ 0    */ ZR, NZ JUMPS
          GT     B4,B1,MIP2  IF JPT > 1    */ RANGE CHECK JUMPS 
  
*         FIND UPPER LIMIT VALUE AND SAVE IN *LUL*
  
          SA4    B2+X5       RIP = TB-3 + RI[R1]
          UX6    B2,X4
          SX7    B2-OC.STT
          NZ     X7,JPX1     IF OC[R1P] " OC.STT
  
          NE     B4,B1,MIP2  IF JPT " 1    */ NOT *MI* JUMP 
          SA3    A4+B1       R2P = R1P + 1
          LX3    -IH.CAP
          MX2    IH.CAL 
          SX4    X3+B1
          LX2    IH.CAL 
          BX7    -X4*X2 
          PX6    X7          ULW = PACK( 0 , -(CA[R2P]+1) ) 
          LX3    IH.CAP-IH.RFP
          BX5    "RN"X3      R = RF[R2P]
          EQ     JPX5 
  
 JPX1     SX7    B2-OC.IS 
          NZ     X7,MIP2     IF OC[R1P] " OC.IS 
  
*         CHECK LIMIT OPERAND OF *IS* 
  
          SA3    A4+B3       LIP = R1P + 3
          MX7    2
          LX3    58-I.IAIPP 
          BX7    X3*X7
          ZR     X7,MIP2     IF ^( IA[LIP] ! IP[LIP] )
  
          LX4    -R1.RJP
          NZ     B4,JPX2     IF JPT " 0 
  
          BX7    "RN"X4      LRN = RJ[R1P] */ LIMIT R-NUMBER
          LX4    R1.RJP-R1.RKP
          BX5    "RN"X4      R = RK[R1P]
          EQ     JPX3 
  
 JPX2     BX5    "RN"X4      R = RJ[R1P]
          LX5    R1.RJP-R1.RKP
          BX7    "RN"X4      LRN = RK[R1P]
  
 JPX3     SB2    "TB"-B1
          SA2    B2+X7       DIP = TB-1 + LRN 
          SA4    A2-2        R1P = DIP - 2
          LX2    59-D.ZPP 
          PL     X2,MIP2     IF ^ZP[DIP]   */ NOT *LD* OR *S* 
          LX2    D.ZPP-D.LDP
          PL     X2,JPX4     IF ^LD[DIP]
          LX2    D.LDP-D.TYP-1
          PL     X2,MIP2     IF TYPE[DIP] " III 
  
          NZ     B4,MIP2     IF JPT " 0    */ CANT ADD 1 TO UPPER LIMIT 
          SA3    A4+B1       R2P = R1P + 1
          MX2    -IH.CAIHL
          LX4    -R1.INP
          SX4    X4 
          BX2    -X2*X3 
          LX4    PS.UDIP
          BX7    X4+X2
          PX6    B1,X7       ULW = PACK( 1 , IN[R1P] , CAIH[R2P] )
          EQ     JPX5 
  
 JPX4     UX6    B2,X4
          SX7    B2-OC.S
          LX4    -R1.INP
          NZ     X7,MIP2     IF OC[R1P] " OC.S
          SB2    -B4
          SX4    X4+B2
          MX3    -IH.CAL
          BX7    -X3*X4 
          PX6    X7          ULW = PACK( 0 , IN[R1P]-JPT )
  
*         NOW CHECK FOR THE INDEX, IT MUST BE *RD* IN THE LOOP. 
  
 JPX5     SA4    "TB"+X5     LIP = TB + R 
          LX4    59-I.IAP 
          SA6    LUL         LUL = ULW
          PL     X4,JPX7     IF ^IA[LIP]
  
*         PRED IS *IA* ( IA,IS,STT ) , GET ^INV PRED OF THIS INSTRUCTION
  
          SA3    A4-B1       DIP = LIP - 1
          LX3    58-D.TYP 
          PL     X3,JPX6     IF TYPE[DIP] = I 
          SA2    A3-B1       R2P = DIP - 1
          LX2    -IH.RFP
          BX5    "RN"X2      R = RF[R2P]
          EQ     JPX7 
  
 JPX6     SA3    A4-B3       R1P = LIP - 3
          LX3    -R1.RJP
          BX5    "RN"X3      R = RJ[R1P]
          SA4    "TB"+X5     LIP = TB + R 
          LX4    59-I.INVP
          PL     X4,JPX7     IF ^INV[LIP] 
          LX3    R1.RJP-R1.RKP
          BX5    "RN"X3      R = RK[R1P]
  
*         CHECK FOR *LD* OF A *RD* VARIABLE 
  
 JPX7     SB2    "TB"-B3
          SA4    B2+X5       R1P = TB-3 + R 
          UX6    B2,X4
          LX4    -R1.INP
          SX7    B2-OC.LD 
          NZ     X7,MIP2     IF OC[R1P] " OC.LD 
          SA2    "UB"+X4     UI = UB + IN[R1] 
          LX2    59-UD.^RDP 
          MI     X2,MIP2     IF ^RD[UI]    */ VAR NOT ^RD IN LOOP 
  
*         TEST REPLACEMENT POSSIBLE, SET FLAGS FOR *GRA*
  
          SA3    A4+B1       R2P = R1P + 1
          MX2    -IH.CAIHL
          SA5    A5          R1 = R1
          SX4    X4 
          BX2    -X2*X3 
          SB2    "TB"-B1
          LX4    PS.UDIP
          BX7    X4+X2
          SA4    B2+X5       DIP = TB-1 + RI[R1]
          PX6    B1,X7
          SA6    LCV         LCV = PACK( 1 , IN[R1P] , CAIH[R2P] )
          SX6    B1 
          SA6    LTT         LTT = 1       */ LOOP TEST TYPE
          LX6    D.INCP 
          BX6    X4+X6       INC[DIP] = 1  */ PRED OF *JPX* IS TEST USE 
          SA6    A4 
          SA4    A5+2        DI = R1 + 2
          SX6    B1 
          LX6    D.INCP 
          BX6    X6+X4       INC[DI] = 1   */ MARK *JPX* AS LOOP TEST JUMP
          SA6    A4 
          EQ     MIP2 
  
          QUAL   *
  
 MIP      EQU    /MIP/MIP 
 MIE      TITLE  MIE - MOVE INVARIANT EXPRESSIONS 
**        MIE - MOVE INVARIANT EXPRESSIONS AND TERMINAL POLYNOMIALS TO
*         HOLDING BLOCK.
* 
*         THE CHIEF CONCERN OF *MIE* IS PROFIT. THE CRITERIA USED HERE
*         IS TO MOVE OUT AN INSTRUCTION IF IT HAS PREDECESSORS AND IS 
*         NOT AN *XMT* THAT *PS* OR A *SA*/*STT* THAT PRECEEDS A TEMP 
*         LOCK *RS* TO A B-REG. 
* 
*         SINCE THE MOTION OF *IP*"S INVOLVES PLACING AN INCREMENT
*         INSTRUCTION BACK IN THE LOOP, WE USE THE *COST* OF THE *IP* 
*         AS THE CHIEF PROFIT CRITERIA.  THE CONDITION THAT A *IP* BE 
*         *RF* IS NECESSARY FOR THE *IP* TO BE A B-REGISTER CANIDATE. 
* 
*         EXIT   INVARIANT EXPRESSIONS, TERMINAL POLYNOMIALS CODE MOVED 
*         TO HOLDING BLOCK ( *TXT* ). *TET* UPDATED.
  
 MIE      ROUTINE 
          SA3    MINC 
          S"TB"  X5+3        TB = TBA + 3 
          LX4    -BS.IICP 
          SA0    B0          LII = 0
          MX1    -D.USESL 
          SB2    X3                        (B2) = MINC
          SB4    B0          NTI = 0       */ N.TERMINAL INST 
          SB5    B0          NMI = 0       */ N.MOVED INST
          SB6    X4          I = IIC[BSW]  */ NEXT ON *IIC* CHAIN 
  
*         RESCAN *IIC* AND FORM A FOWARD CHAIN OF INST THAT ARE PROFITAB
*         TO MOVE, OR USED BY ANOTHER INSTRUCTION.
  
 MIE1     SA5    "TB"+B6     LI = TB + I
          ZR     B6,MIE14    IF I = 0      */ END OF CHAIN
          SA4    A5-B1       DI = LI - 1
          BX3    X5 
          LX5    -I.USESP 
          BX7    -X1*X5 
          LX5    I.USESP-I.IICP 
          BX6    X4          D = [DI] 
          SB6    X5          I = IIC[LI]   */ NEXT ON CHAIN 
          NZ     X7,MIE5     IF USES[LI] " 0  */ USED BY ANOTHER
  
          LX3    59-I.INVP
          MI     X3,MIE2     IF INV[LI] 
  
*         TERMINAL *IP*, SEE IF PROFITABLE TO MOVE
  
          LX6    59-D.RFP 
          LX3    1+I.INVP-I.COSTP 
          PL     X6,MIE1     IF ^RF[D]
          BX7    -X1*X3 
          SB3    X7 
          GE     B3,B2,MIE7  IF COST[LI] \ MINC 
  
          EQ     MIE1 
 MIE      SPACE  2,14 
*         TERMINAL INV INST, SEE IF PROFITABLE TO MOVE
  
 MIE2     LX6    58-D.STRSP 
          MX7    D.STRSL
          BX3    X7*X6
          NZ     X3,MIE3     IF STRS[D] " 0 
          LX6    1+D.STRSP-D.ZPP
          MI     X6,MIE1     IF ZP[D]      */ NO PRED 
          EQ     MIE7 
  
 MIE3     LX6    1+D.STRSP-D.PSP
          MI     X6,MIE4     IF PS[DI]
          SA3    A5+4 
          SX7    B1          IU = 1 
          LX3    59-I.INVP
          MI     X3,MIE6     IF INV[LI+4]  */ INV FUNCTION ARG
          SA2    A5+B1       R1RS = LI + 1
          LX2    59-R1.SOP-4
          PL     X2,MIE1     IF SORT[R1RS] " 2  */ ^ TO AN X-REGISTER 
  
*         ( PS ! PRS ) & USES = 0 
  
 MIE4     LX6    D.PSP-D.ZPP
          MI     X6,MIE1     IF ZP[D] 
          LX6    D.ZPP-D.XMTP 
          MI     X6,MIE1     IF XMT[D]
          EQ     MIE7 
 MIE      SPACE  2,10 
*         INSTRUCTION IS OPERAND OF ANOTHER THAT HAS BEEN MOVED OUT.
  
 MIE5     LX6    59-D.PRSP
          PL     X6,MIE7     IF ^PRS[D] 
  
          SA2    A5+B1       R1RS = LI + 1
          SA3    A5+4 
          MX7    0           IU = 0 
          LX3    59-I.INVP
          LX2    59-R1.SOP-SO.LKP 
          MI     X2,MIE6     IF SOLK[R1RS] " 0  */ TEMP LOCK
          PL     X3,MIE7     IF ^INV[LI+4]
          SX7    B1          IU = 1 
  
*         ADD *RS* TO CHAIN OF MOVED INST 
  
 MIE6     LX3    1+I.INVP-I.IICP
          SX6    A0 
          BX3    X0*X3
          IX6    X6+X3       IIC[LI+4] = LII
          LX6    I.IICP 
          SB5    B5+B1       NMI = NMI + 1
          SA6    A3 
          SA0    A3-"TB"     LII = LI+4 - TB
          LX7    I.USESP-I.IICP 
          IX5    X7+X5       USES[LI] = USES[LI] + IU 
 MIE      SPACE  1,10 
*         ADD INSTRUCTION TO CHAIN OF MOVED INSTRUCTIONS, MARK AS 
*         TERMINAL IF NOT ALL USES ARE CONTAINED IN THE *INV* CHAIN.
  
 MIE7     SX3    A0 
          BX5    X0*X5
          IX6    X3+X5
          SB5    B5+B1       NMI = NMI + 1
          LX6    I.IICP      IIC[LI] = LII
          SA0    A5-"TB"     LII = LI - TB
          SA6    A5 
          LX5    I.IICP-I.USESP+D.USESP 
          BX7    X5-X4
          LX7    -D.USESP 
          BX2    -X1*X7 
          ZR     X2,MIE8     IF USES[LI] = USES[DI] 
  
          SX7    B1 
          SB4    B4+B1       NTI = NTI + 1
          LX7    I.TIP
          BX6    X7+X6       TI[LI] = 1    */ MARK AS TERMINAL
          SA6    A6 
 MIE      SPACE  1,10 
*         BUMP USES COUNT OF OPERANDS OF INSTRUCTION
  
 MIE8     LX4    58-D.TYP 
          IX7    X4+X4
          SX6    B1 
          MI     X7,MIE1     IF TYPE[DI] = II ! IV
          LX6    I.USESP
          PL     X4,MIE10    IF TYPE[DI] = I
  
*         TYPE III INSTRUCTION
  
          SA3    A4-B1       R2 = DI - 1
          LX4    1+D.TYP-D.^DP
          LX3    -IH.RFP
          BX7    "RN"X3      R = RF[R2] 
          SA2    "TB"+X7     L = TB + R 
          ZR     X7,MIE9     IF R @ 1 
          IX7    X6+X2       USES[L] = USES[L] + 1
          SA7    A2 
  
 MIE9     PL     X4,MIE1     IF DEF[DI]    */ NOT A STORE 
          SA3    A3-B1       R1 = R2 - 1
          BX7    "RN"X3 
          SA2    "TB"+X7     L = TB + RI[R1]
          IX7    X6+X2       USES[L] = USES[L] + 1
          SA7    A2+
          EQ     MIE1 
  
*         TYPE I INSTRUCTION
  
 MIE10    MX7    -D.TYIOL 
          LX4    2+D.TYP-D.TYIOP
          BX2    -X7*X4 
          SA3    =XTYIOM+X2 
          SA5    A4-2        R1 = DI - 2
          UX7    B3,X3
          BX2    X7*X5
          AX5    B3,X2       RNUMS = TYIOM[DI] & [R1] 
  
 MIE11    BX4    "RN"X5      R = RI[RNUMS]
          AX5    R1.RIL      RNUMS = SHIFT( RNUMS , -16 ) 
          ZR     X4,MIE12    IF R = 0 
          SA3    "TB"+X4     L = TB + R 
          IX7    X6+X3       USES[L] = USES[L] + 1
          SA7    A3+
 MIE12    NZ     X5,MIE11    IF RNUMS " 0 
  
          EQ     MIE1 
 MIE      EJECT 
*         MOVE THE FINAL CHAIN OF INSTRUCTIONS TO THE HOLDING BLOCK 
  
 MIE14    ZR     B5,MIE      IF NMI = 0    */ NOTHING MOVED 
          SB4    B4+B4
          SX2    B5+B4
          LX2    2
          SX7    A0 
          SA7    IC          IC = LII 
          SX5    A0 
          ALLOC  TXT,X2+B1   ALLOC( TXT , 4*(NMI+2*NTI) + 1 ) 
          SA4    O.SEQ       HBI = OLD(L.TXT) 
          S"TB"  X4+3 
          SA4    L.TET
          SB3    X5          I = LII
          SA1    DMASK
          SB4    X4          TO = L.TET    */ TEMP ORDINAL
          SB5    X2          HB = O.TXT 
          MX0    -R1.RIL+1
          SA0    B0          TSC = 0
          SX6    X2+B6
          LX0    1
          SA6    TBB         TBB = O.TXT + HBI
          EQ     MIE16
  
*         INCREMENT MOVED, CHANGE IT TO AN *XMT* OF THE *RD* VARIABLE 
*         NOTE THAT AN *INC* CANNOT BE TERMINAL OR *PRS*
  
 MIE14A   SA4    F.RDT+OC.XMT 
          SB2    OC.XMT 
          BX7    X4 
          SA7    A6-B1       [HA-1] = RDT(OC.MXT) 
          LX3    -IH.RFP
          SA6    A7-B1       [HA-2] = 0    */ R2 WORD 
          BX7    "RN"X2 
          SX6    X3          R = RF[R2] 
          NZ     X6,MIE14B   IF R " 0 
          LX2    -R1.RJP
          BX6    "RN"X2      R = RJ[R1] 
          SA3    "TB"+X6     LIP = TB + R 
          LX3    59-I.INVP
          PL     X3,MIE14B   IF ^INV[LIP] 
          LX2    R1.RJP-R1.RKP
          BX6    "RN"X2      R = RK[R1] 
  
 MIE14B   LX6    R1.RJP 
          PX7    B2,X7
          BX6    X7+X6
          SA6    A6-B1       [HA-3] = TYI(OC.XMT,R,0,RI[R1])
  
  
*         ADVANCE TO NEXT ON CHAIN
  
 MIE15    LX5    -I.IICP
          SB3    X5          I = IIC[LI]   */ *BLK* INDEX OF INSTRUCTION
          ZR     B3,MIE20    IF I = 0 
  
*         MOVE INSTRUCTION TO HOLDING BLOCK 
 MIE16    RJ     MIH         MOVE INSTRUCTIONS TO *HB*
          LX4    59-D.INCP
          MI     X4,MIE14A   IF INC[D]
          LX7    59-I.TIP 
          PL     X7,MIE15    IF ^TI[LI]    */ NOT TERMINAL
          LX4    D.INCP-D.ZPP 
          MI     X4,MIE15    IF ZP[D]      */ NO PRED 
  
          LX7    1+I.TIP
          SX7    X7          R = HBP[LI]   */ OPERAND OF *XMT*
          SX6    B2-OC.DEF
          ZR     X6,MIE19    IF OC[R1] = OC.DEF 
          LX4    D.ZPP-D.PRSP 
          PL     X4,MIE18    IF ^PRS[DI]
  
*         TERMINAL AND PRS, CHECK FOR TEMP LOCK  *RS* TO A B-REG
*         IF THE ABOVE, THEN MAKE PRED TERMINAL IF COMPUTATION IS TO BE 
*         REMOVED FROM *BLK*. EXAMPLE J = SHIFT(INV,I+5)+SHIFT(VAR,I+5) 
  
          SA3    A5+B1       R1RS = LI + 1
          LX3    -R1.SOP-SO.LKP-1 
          MI     X3,MIE16A   IF SOLK[R1RS] = 1   */ A TEMP LOCK 
  
          SA3    A5+4        LIRS = LI + 4
          LX3    59-I.INVP
          PL     X3,MIE18    IF ^INV[LIRS] */ RS STAYS IN THE LOOP
  
          MX2    0           LINV = 0 
          EQ     MIE17A 
  
 MIE16A   LX4    1+D.PRSP+58-D.TYP
          LX2    -R1.RJP     I = RJ[R1] 
          PL     X4,MIE17    IF TYPE[DI] = I
          SA2    A2+B1       R2 = R1 + 1
          LX2    -IH.RFP     I = RF[R2] 
 MIE17    BX6    "RN"X2 
          SA3    "TB"+X6     LIP = TB + I 
          SB3    X6 
          SA2    A3-B1       DIP = LIP - 1
          SX7    X3          R = HBP[LIP] 
          LX3    59-I.TIP 
          MI     X3,MIE15    IF TI[LIP]    */ PRED IS TERMINAL
          LX2    59-D.ZPP 
          MI     X2,MIE15    IF ZP[DIP] 
  
*         CHAIN FOWARD AND MOVE THE RS OUT SO IT DOESNT GET SEPERATED 
  
          LX3    1+I.TIP
          MX2    1
          LX2    1+I.INVP 
          BX2    X2*X3       LINV = INV[LIP]
 MIE17A   LX5    -I.IICP
          SA5    "TB"+X5     LI = TB + IIC[LI]
          SA4    A5-B1       DI = LI - 1
          SA3    A5-3        R1 = LI - 3
          BX6    X3 
          SA6    A6+B1       HA = HA + 1;  [HA] = [R1]
          MX6    0
          SA6    A6+B1       HA = HA + 1;  [HA] = 0 
          BX6    X4 
          SA6    A6+B1       HA = HA + 1;  [HA] = [DI]
          MX6    0
          SA6    A6+B1       HA = HA + 1;  [HA] = 0 
          BX5    X2+X5       INV[LI] = LINV 
          SB6    B6+4        HBI = HBI + 4
  
*         CREATE *XMT* / *TST* TO SAVE RESULT IN A TEMPORARY
*         LINK WORD OF *TST* POINTS TO WHERE TO PLACE *TLD* 
  
 MIE18    SB2    OC.XMT 
          RJ     OST         OUTPUT XMT TST TO IT.
          EQ     MIE15
  
*         TERMINAL *DEF* MOVED TO *HB*, MOVE ALL FOLLOWING DEF"S TO 
*         THE *HB* BEFORE OUTPUTTING THE *TST*"S. 
  
 MIE19    SX7    B3 
          SA7    ISV         ISV = I
  
 MIE19A   LX5    -I.IICP
          SB3    X5-3        I = IIC[LI] - 3
          SA2    "TB"+B3     R1 = TB + I
          UX6    B2,X2
          SB3    X5          I = IIC[LI]
          SX7    B2-OC.DEF
          NZ     X7,MIE19B   IF OC[R1] " OC.DEF 
          RJ     MIH         MOVE INST TO *HB*
          EQ     MIE19A 
  
*         NOW OUTPUT THE XMT/SA AND TST INSTRUCTIONS
  
 MIE19B   SA2    ISV
          SB3    X2          I = ISV
  
 MIE19C   SA5    "TB"+B3     LI = TB + I
          SA2    A5-3        R1 = LI - 3
          UX7    B2,X2
          SX6    B2-OC.DEF
          NZ     X6,MIE19F   IF OC[R1] " OC.DEF 
  
          BX6    X5 
          LX6    59-I.TIP 
          PL     X6,MIE19E   IF ^TI[LI]    */ NOT TERMINAL
  
          SB2    OC.XMT      OC = OC.XMT
          LX2    59-R1.SOP-4
          MI     X2,MIE19D   IF REG[R1] \ 20B  */ DEF FROM AN X-REG 
          SB2    OC.SA       OC = OC.SA 
 MIE19D   SX7    X5          RJ = HBP[LI] 
          RJ     OST         OUTPUT XMT/SA AND TST
 MIE19E   LX5    -I.IICP
          SB3    X5          I = IIC[LI]
          EQ     MIE19C 
  
 MIE19F   NZ     B3,MIE16    IF I " 0      */ NOT END OF CHAIN
          EQ     MIE20
 MIE      SPACE  2,14 
**        MIH - MOVE INSTRUCTION TO HOLDING BLOCK 
* 
*         ENTRY  (B3) = I 
*         EXIT   B2,X2,X3,X4,X5,X7 SET
  
 MIH      ROUTINE 
          SA5    "TB"+B3     LI = TB + I
          SA4    A5-B1       DI = LI = 1; D = [DI]
          SA3    A4-B1       R2 = DI - 1
          SA2    A3-B1       R1 = R2 - 1
          BX6    X2 
          SA6    B5+B6       HA = HB + HBI;  [HA] = [R1]
          LX7    X3 
          SA7    A6+B1       HA = HA + 1;  [HA] = [R2]
          BX6    -X1*X4 
          SA6    A7+B1       HA = HA + 1;  [HA] = ^DMASK & D
          SX7    B6 
          BX7    X5+X7       HBP[LI] = HBI
          SA7    A5 
          SB6    B6+4        HBI = HBI + 4
          MX6    0
          SA6    A6+B1       HA = HA + 1;  [HA] = 0 
          UX2    B2,X2
          EQ     MIH
  
**        OST - OUTPUT XMT AND TST TO IT. 
* 
*         ENTRY  (B2,X7) = OC, RJ 
  
 OST      ROUTINE 
          LX7    R1.RJP 
          SX4    B6 
          PX3    B2,X4
          BX6    X7+X3
          SA6    A6+B1       HA = HA + 1;  [HA] = TYI(OC.XMT,R,0,HBI) 
          MX6    0
          SA6    A6+B1       HA + HA + 1;  [HA] = 0 
          SA6    A6+B1       HA + HA + 1;  [HA] = 0 
          SB2    OC.TST 
          SA6    A6+B1       HA + HA + 1;  [HA] = 0 
          SA3    =XIT.
          PX6    B2,X4
          SA6    A6+B1       HA = HA + 1;  [HA] = TYIII(OC.TST,0,0,HBI) 
          SX2    B4 
          LX2    IH.CAP 
          LX3    IH.IHP 
          BX6    X2+X3
          SA6    A6+B1       HA = HA + 1;  [HA] = IHW(0,TO,IT.) 
          SB4    B4+B1       TO = TO + 1
          MX6    0
          SA6    A6+B1       HA = HA + 1;  [HA] = 0 
          SX7    B3 
          LX7    T.BIP
          SX3    A0 
          BX6    X7+X3
          MX3    1
          LX3    1+I.INVP 
          BX2    X3*X5
          IX6    X2+X6
          SA6    A6+B1       HA = HA + 1;  [HA] = TETW(INV,0,I,TSC) 
          SA0    A6-B5       TSC = HA - HB
          SB6    A0+B1       HBI = TSC + 1  */ = HBI + 8
          EQ     OST
 MIE      SPACE  3,14 
*         RENUMBER THE INSTRUCTIONS ADDED TO THE HOLDING BLOCK
*         PRESERVE A0, B4 FOR *TET* UPDATE
  
 MIE20    MX7    0           [HB+HBI] = 0  */ SET HB TERMINATOR 
          SA7    B5+B6
          SX6    B6          L.TXT = HBI
          SB2    B1+B1
          SA6    L.TXT
          MX1    D.TYL
          SA2    TBB
          SA4    X2-2        DI = TBB - 2 
          EQ     MIE22
  
 MIE21    SA3    =XF.RDT+B3 
          BX6    X3          [DI] = RDT(OC[R1]) 
          SA6    A4 
  
 MIE22    SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          ZR     X5,MIE26    IF [R1] = 0   */ END OF BLOCK
          LX4    58-D.TYP 
          BX6    -X1+X4 
          UX7    B3,X5
          ZR     X4,MIE21    IF [DI] = 0   */ XMT/TST 
          ZR     X6,MIE22    IF TYPE[DI] = IV 
  
          BX7    "RN"X5 
          SA3    "TB"+X7
          BX5    X0*X5
          SX2    X3 
          BX4    X1*X4
          IX6    X2+X5       RI[R1] = HBP[TB+RI[R1]]
          NZ     X4,MIE25    IF TYPE[DI] " I
  
          LX6    -R1.RJP
          BX7    "RN"X6 
          ZR     X7,MIE23    IF RJ[R1] = 0
          SA3    "TB"+X7
          BX6    X0*X6
          SX2    X3          RJ[R1] = HBP[TB+RJ[R1]]
          BX6    X2+X6
 MIE23    LX6    R1.RJP-R1.RKP
          BX7    "RN"X6 
          ZR     X7,MIE24    IF RK[R1] = 0
          SA3    "TB"+X7
          BX6    X0*X6
          SX2    X3          RK[R1] = HBP[TB+RK[R1]]
          BX6    X2+X6
 MIE24    LX6    R1.RKP 
          SA6    A5 
          EQ     MIE22
  
 MIE25    SA3    A5+B1       R2 = R1 + 1
          SA6    A5 
          LX3    -IH.RFP
          BX7    "RN"X3 
          ZR     X7,MIE22    IF RF[R2] @ 1
          SA2    "TB"+X7
          BX3    X0*X3
          SX7    X2 
          IX6    X3+X7
          LX6    IH.RFP      RF[R2] = HBP[TB+RF[R2]]
          SA6    A3 
          EQ     MIE22
 MIE      SPACE  3,20 
*         RESCAN THE CHAIN OF MOVED INSTRUCTIONS AND CHANGE THE ONES
*         THAT ARE ^D AND NOT A TEMP LOCK *RS* TO *BOS*"S SO *SQZ*
*         WILL ELIMINATE THEM WHEN THE BLOCK IS SQUEEZED AGAIN. 
  
 MIE26    SA1    IC          I = IC 
          SA2    "TB"-B1
          SB2    B1+B1
          SA3    A2-B2
          MX0    -SO.LKL
          LX7    X2 
          BX6    X3 
          SB5    OC.RS
          LX0    R1.SOP+SO.LKP
  
 MIE27    SA5    "TB"+X1     LI = TB + I
          SA4    A5-B1       DI = LI + 1
          LX5    -I.IICP
          LX4    59-D.^DP 
          SX1    X5          I = IIC[LI]   */ NEXT ON CHAIN 
          PL     X4,MIE29    IF DEF[DI] 
  
          SA2    A4-B2       R1 = DI - 2
          UX3    B3,X2
          NE     B3,B5,MIE28 IF OC[R1] " OC.RS
          BX4    -X0*X2 
          NZ     X4,MIE29    IF SOLK[R1] " 0  */ TEMP LOCK
 MIE28    SA6    A4-2        [DI+2] = TYI(OC.BOS,0,XX)
          SA7    A4+         [DI] = [TB-1]
  
 MIE29    NZ     X1,MIE27    IF I " 0 
  
          TRACE  MIE,RLIST
          TRACE  MIE,RLIST,SEQ
 MIE      SPACE  3,14 
*         MOVE THE INFO IN THE LINK WORD OF THE *TST*"S TO *TET*
*         SET NTP " 0 IF TERMINAL POLYNOMIALS WERE MOVED TO HOLDING BLK.
  
          SA2    L.TET
          SX0    A0          I = TSC       */ TSC CHAIN INDEX 
          SX5    B4 
          IX1    X5-X2
          SA4    BSW
 .BMB     BIT    BS.BMP-BS.NTETP
          SX2    X1+.BMB     BM[BSW] = 1   */  INDCIATE BLOCK MODIFIED
          LX2    BS.NTETP 
          BX6    X2+X4       NTET[BSW] = T0 - L.TET 
          SA6    A4 
          ZR     X1,MIE      IF TO = L.TET */ NO TEMP STORES
  
          ALLOC  TET,X1      ALLOC( TET , TO - L.TET )
          SA4    O.TXT
          SB5    X2 
          SB2    B1+B1
          MX1    -T.CAL 
          SA2    NTP
          SB4    X4          HB = O.TXT 
          BX7    X7-X7
          MX3    1
          LX3    1+I.INVP 
  
 MIE30    SA5    B4+X0       LI = HB + I
          SA4    A5-B2       R2 = LI - 2
          BX6    -X5*X3 
          LX4    -IH.CAP
          BX2    X6+X2       NTP = ^INV[LI] ! NTP 
          SX0    X5          I = LINK[LI] 
          BX6    X1*X5
          SA6    B5+X4       TET(CA[R2]) = TETW(INV,0,BI,0) 
          SA7    A5          [LI] = 0 
          NZ     X0,MIE30    IF I " 0 
  
          BX6    X2 
          SA6    A2 
          TRACE  MIE,TET
          EQ     MIE
 CIF      TITLE  CIF - COLLECT INCREMENT FORMULAS 
**        CIF - COLLECT INCREMENT FORMULAS
* 
*         BUILD A TABLE OF INCREMENT AND POLYNOMIAL FORMULAS OF THE 
*         OF THE *IP*"S ( *IIT* LIST B FORMAT ).
*         THE INCREMENT FORMULAS ARE USED TO EVALUATE THE INCREMENT 
*         EXPRESSIONS. THE POLYNOMIAL FORMULAS ARE NECESSARY FOR TEST 
*         REPLACEMENT AND TO COMPUTE THE SYMBOLIC DIFFERENCE OF TWO 
*         SIMILAR *IP*"S ( A(I,J+1) AND A(I,J) , VARIABLE DIMENSIONS ). 
  
 CIF0     SX6    0
          SA6    NTP         NTP = 0
 CIF      ROUTINE 
  
*         CALL *MII* TO MARK THE *INV* INSTRUCTIONS IN THE *HB* FOR DIF.
  
          MX4    60          BSW = -0 
          SA5    O.TXT
          SX6    B0 
          MX0    -R1.RIL+1
          SA6    BN          BN = 0        */ INDICATE SPECIAL CALL 
          LX0    1
          RJ     MII         MARK INVARIANT INSTRUCTIONS
  
*         SCAN HOLDING BLOCK TO FORM A CHAIN OF *TST*"S TO *TP*"S.
  
          SA1    L.TXT
          SA2    O.TXT
          SB3    OC.TST 
          SB4    4
          S"TB"  X2+3        TB = O.TXT + 3 
          MX7    0           SC = 0 
          IX6    X1+X2
          SA5    X6-4        R1 = O.TXT + L.TXT-4 
          AX1    2
          SA2    X2          R1 = [O.TXT] 
          MX6    -R1.H2L
          LX6    R1.H2P 
          BX6    X6*X2       H2[R1] = 0 
          SA6    A2 
          SA3    O.TET
          MX2    1
          LX2    1+T.INVP 
          SB5    X3                        (B5) = TET 
  
 CIF1     SA5    A5-B4       R1 = R1 - 4
          UX6    B2,X5
          EQ     B2,B1,CIF2  IF OC[R1] = OC.BOS 
          NE     B2,B3,CIF1  IF OC[R1] " OC.TST 
          SA4    A5+3        LI = R1 + 3
          LX4    59-I.INVP
          MI     X4,CIF1     IF INV[LI] 
          SA3    "TB"+X5     LIP = TB + RI[R1]
          LX3    59-I.INVP
          MI     X3,CIF1A    IF INV[LIP]
          SA7    A4          [LI] = SC
          SX7    A4-"TB"     SC = LI - TB 
          EQ     CIF1 
  
*         TST IS *IP*, BUT EXPRESSION IS *INV* UPDATE *TET* TO REFLECT
*         THE REDUCTION OF THE EXPRESSION ( I+INVEXP-I, ETC ) BY *SQZ* .
  
 CIF1A    SA3    A5+B1       R2 = R1 + 1
          LX3    -IH.CAP
          SA4    B5+X3
          BX6    X2+X4       INV[TET(CA[R2])] = 1 
          SA6    A4 
          EQ     CIF1 
  
 CIF2     SA7    TSC         TSC = SC 
          ZR     X7,CIF0     IF SC = 0     */ NO TERMINAL POLYNOMIALS 
          ALLOC  RND,X1      ALLOC( RND , L.TXT/4 ) 
 CIF      SPACE  1,10 
*         FORM A LIST OF THE INCREMENT AND POLYNOMIAL FORMULAS IN *IIT* 
  
          SA5    TSC
          ADDWRD IIT,B0      ADDWRD( IIT , 0 )
          SX6    X3-1 
          SA6    ITB         ITB = L.IIT - 1  */ INDEX TO *PI* OF THIS
  
 CIF3     SA4    O.TXT
          IX7    X4+X5
          SA5    X7+B1       R2 = TXT(TSC+1)
          LX5    -IH.CAP
          SX6    X5          CAS = CA[R2]  */ SAVE *CA* OF THIS *IP*
          SA6    CAS
          SB6    0           MULT = 0 
          RJ     DIF         DEVELOP *INCR* FORMULA 
          SA1    LCV
          SA5    A0 
          LX5    -IA.UDIP 
          UX6    B2,X1
          AX6    PS.UDIP
          BX7    X6-X5
          SB2    X7+
          NZ     B2,CIF4     IF UDI[LCV] " UDI[IAW] 
          SA6    STP         STP = 1       */ AN *IP* IS A FUNCTION(LCV)
  
 CIF4     SA1    TSC
          SA4    O.TXT
          IX7    X4+X1
          SA5    X7+B1       R2 = TXT(TSC+1)
          SA3    X7+3 
          BX7    X3          TSC = TXT(TSC+3)  */ INDEX TO NEXT ON CHAIN
          SA7    A1 
          SB6    -1          MULT = -1
          RJ     DIF         DEVELOP *POLYNOMIAL* FORMULA 
          ADDWRD IIT,B0      ADDWRD( IIT , 0 )
  
          SA1    ITB
          SA4    CAS
          SB2    X2 
          SA2    O.TET
          SB4    X4 
          SX6    X3-1 
          LX6    PI.LFP 
          SA6    B2+X1       IIT(ITB) = L.IIT - 1  */ LINK TO NEXT
          LX1    T.ITIP 
          SA2    X2+B4
          BX7    X1+X2       ITI[TET(CAS)] = ITB  */ LINK *IP* TO *IIT* 
          SA7    A2 
          LX6    -PI.LFP
          SA6    A1          ITB = L.IIT - 1
  
          SA5    TSC
          NZ     X5,CIF3     IF TSC " 0 
 CIF      SPACE  1,10 
*         NOW SCAN THE *PI* LIST FOR SIMILAR *IP*"S, THOSE WHICH HAVE 
*         THE SAME INCREMENT FORMULAS.
  
          SA1    O.TET
          SA2    O.IIT
          SA3    PIC
          SB2    3
          SB7    X1                        (B7) = [O.TET] 
          SA0    X2                        (A0) = [O.IIT] 
          SB5    X3          J = PIC
          SB6    B1          CCN = 1       */ CURRENT CLASS NUMBER
          MX7    0
          SA7    CNI         CNI = 0
  
 CIF5     SA1    A0+B5       I = J;  PIW = IIT(I) 
          ZR     X1,CIF10    IF PIW = 0    */ END OF TABLE
          LX1    -PI.LFP
          SB5    X1          J = LF[PIW]
          LX1    59-PI.MIPP+PI.LFP
          MI     X1,CIF5     IF MIP[PIW]   */ SIMILAR TO ANOTHER
  
          SA1    A1+B1       IAW = IIT(I+1) 
          UX6    B3,X1       NW = NWD[IAW]
          LX6    -IA.CAP
          SX7    X6          CAS = CA[IAW]
          SA7    CAS
          SX0    B1 
          SA2    B7+X6
          LX0    T.BIPP 
          BX6    X0+X2       BIP[TET(CAS)] = 1  */ MARK THIS *IP* AS BAS
          SA6    A2 
          SB4    B5          K = J
          LX0    PI.MIPP-T.BIPP 
          MX7    0
          SA2    CNI
          SB6    B6+X2       CCN = CCN + CNI  */ SET CLASS NUMBER 
          SA7    A2          CNI = 0
  
*         SEARCH REST OF LIST FOR *IP*"S THAT ARE SIMILAR 
  
 CIF7     SA2    A0+B4       PIK = IIT(K) 
          ZR     X2,CIF5     IF PIK = 0    */ END OF LIST 
  
          SA5    A2+B1       IK = IIT(K+1)
          BX6    X1-X5
          SX3    B3-2        N = NW - 2 
          LX6    -IA.CAP
          MX7    -IA.CAL
          BX6    X7*X6
          NZ     X6,CIF9     IF (NWD,UDI)[IAW] " (NWD,UDI)[IK]
          SA4    A1+B1       II = IIT(I+2)
          SA5    A5+B1       IK = IK + 1
          BX6    X4-X5
          NZ     X6,CIF9     IF [II] " [IK]  */ IB WORDS  NE
          SA4    A4+B1       II = II + 1
          SA5    A5+B1       IK = IK + 1
  
 CIF8     BX6    X4-X5       DIF = [II] - [IK]
          SA4    A4+B1       II = II + 1
          SA5    A5+B1       IK = IK + 1
          BX7    X4-X5
          NZ     X6,CIF9     IF DIF " 0    */ R1 WORDS
          NZ     X7,CIF9     IF [II] " [IK] 
          SX3    X3-4        N = N - 4
          SA4    A4+B2       II = II + 3
          SA5    A5+B2       IK = IK + 3
          NZ     X3,CIF8     IF N " 0 
  
*         *IP*"S MATCH, MARK K AS SIMILAR TO I
  
          SA3    CAS
          LX3    PI.CAP 
          BX4    X0+X3       CA[IIT(K)] = CAS 
          SA5    A1-B1
          BX6    X4+X2       MIP[IIT(K)] = 1
          SX7    B6 
          LX7    PI.CNP 
          BX6    X7+X6       CN[IIT(K)] = CCN 
          SA6    A2 
          BX7    X7+X5       CN[IIT(I)] = CCN  */ SET *CN* IN BASE
          SA7    A5 
          SX6    B1 
          SA6    CNI         CNI = 1       */ SET FOR *CN* INCREMENT
          SA6    NBIP        NBIP = 1      */ SET FLAG FOR *BDT*
  
*         ADVANCE TO NEXT *IP* IN *IIT* 
  
 CIF9     LX2    -PI.LFP
          SB4    X2          K = LF[PIK]
          EQ     CIF7 
  
 CIF10    SX6    4           L.TXT = 4
          SA6    L.TXT
          SX7    0
          SA7    L.RND       L.RND = 0
  
          IF     DEF,/DEBUG/CIF,1 
          DCALL  DMPIIT,([O.IIT],L.IIT,PIC) 
  
          EQ     CIF
 DIF      TITLE  DIF - DEVELOP INCREMENT FORMULAS 
**        DIF - DEVELOP INCREMENT FORMULA OF AN *IP* IN A SINGLE VAR, 
*                OR EXTRACT AN  *IP* FORMULA. 
* 
*         ENTRY  (B6) = MULT , =0 IF TO FORM *INC* FORMULA, ELSE = -1 
*                (X4) = [O.TXT] 
*                (X0) = R-NUMBER EXTRACTOR MASK 
*                (A5) = R2 , OF *TST* OF *IP* 
*                (CAS) = CA OF THE *IP* 
*                *RND* ALLOCATION MADE FOR SCRATCH SPACE
* 
*         EXIT   (A0) = IB , ADDRESS OF *FORMULA IN *IIT* 
  
 DIF      ROUTINE 
          SA1    O.RND
          SA2    L.RND
          S"TB"  X4+3        TB = O.TXT + 3 
          IX2    X1+X2
          SB5    X1 
          SB3    -3 
          SA0    X2-2        SI = O.RND + L.RND-2  */ STACK ADDRESS 
          MX7    0
          SA7    "TB"        [TB] = 0 
          SA7    A0+B1       [SI+1] = 0    */ STACK TERMINATOR
          SA7    X1          OI = O.RND;  [OI] = 0  */ OUTPUT LIST
          SA5    A5-B1       R1 = R2 - 1
          BX6    "RN"X5 
          SX4    X6+B3
          SA5    "TB"+X4     R1 = TB + RI[R1]-3 
  
*         PHASE 1 - TOP DOWN TO FORM INCREMENT FORMULA IN OUTPUT LIST 
*         PROCESS NEXT INSTRUCTION
  
 DIF1     SA4    A5+2        DI = R1 + 2
          BX7    X5          R1W = [R1] 
          LX4    58-D.TYP 
          IX3    X4+X4
          MI     X4,DIF14    IF TYPE[DI] = III
          PL     X3,DIF5     IF TYPE[DI] = I
  
*         OUTPUT INSTRUCTION, PUSHUP STACK
  
 DIF2     SA3    A5-B3       LI = R1 + 3
          SX1    B1 
          LX1    I.MP 
          BX6    X1+X3
          SA0    A0+B1       SI = SI + 1
          LX3    59-I.MP
          MI     X3,DIF2A    IF M[LI]      */ ALREADY OUTPUT
  
          SA7    A7+1        OI = OI + 1;  [OI] = R1W 
          SA6    A3+         M[LI] = 1     */ INDICATE IN OUTPUT LIST 
  
 DIF2A    SA3    A0          R1W = [SI] 
          BX2    "RN"X3 
          ZR     X3,DIF15    IF R1W = 0    */ END OF STACK
          SB2    X2+B3
          SA5    "TB"+B2     R1 = TB + RI[R1]-3 
          BX5    X3 
          EQ     DIF1 
  
*         STACK INSTRUCTION, FOLLOW SELECTED OPERAND, (X6) = OP 
  
 DIF4     SX4    X6+B3
          BX6    X7 
          SA6    A0          [SI] = R1W; RIL = R1W
          UX7    B2,X7
          SA0    A0-B1       SI = SI - 1
          SX3    B2-OC.XMT
          SA5    "TB"+X4     R1 = TB + OP-3; R1W = [R1] 
          NZ     X3,DIF1     IF OC[R1L] " OC.XMT
          SA2    A0+2 
          NZ     X2,DIF1     IF [SI+2] " 0 */ NOT AT TOP OF STACK 
          SA0    A0+B1       SI = SI + 1;  */ ERASE XMT 
          EQ     DIF1 
  
*         PROCESS TYPE I INSTRUCTIONS 
  
 DIF5     LX5    -R1.RKP
          BX4    "RN"X5      K = RK[R1] 
          LX5    R1.RKP-R1.RJP
          BX6    "RN"X5      OP = J = RJ[R1]
          NZ     X6,DIF5A    IF RJ[R1] " 0
          BX6    X4          OP = RK[R1]
          EQ     DIF5B
  
 DIF5A    NZ     X4,DIF6     IF K " 0 
  
*         UNARY INSTRUCTION ( SXT, XMT, XMTC )
*         (PK AND NR WITH RJ = 0) 
  
 DIF5B    SA4    "TB"+X6     LJ = TB + OP 
          LX4    59-I.MP
          MI     X4,DIF2     IF M[LJ]      */ OPERAND PROCESSED 
          EQ     DIF4 
  
 DIF6     UX3    B2,X7
          SX2    B2-OC.IM 
          NZ     X2,DIF10    IF OC[R1W] " OC.IM 
  
*         PROCESS *IM*, SET MULT FLAG WHEN PROCESSING *INV* OPERAND 
  
          BX2    "RN"X7 
          SB2    X2 
          NE     B2,B6,DIF7  IF RI[R1W] " MULT
          SB6    0           MULT = 0 
  
 DIF7     SA3    "TB"+X6     LJ = TB + OP 
          LX3    59-I.MP
          PL     X3,DIF8     IF ^M[LJ]
          SA3    "TB"+X4     LJ = TB + K
          LX3    59-I.MP
          MI     X3,DIF2     IF M[LJ]      */ BOTH OPERANDS MARKED
  
 DIF8     SX6    A3-"TB"     OP = LJ - TB  */ INDEX OF OPERAND
          NZ     B6,DIF4     IF MULT " 0
          LX3    I.MP-I.INVP
          PL     X3,DIF4     IF ^INV[LJ]
          SB6    B2          MULT = RI[R1W]    */ INDICATE INV OP OF IM 
          EQ     DIF4 
 IA       SPACE  2,14 
*         PROCESS IA, IS . IGNORE *INV* TERMS IF MULT = 0 . 
  
 DIF10    SX2    B2-OC.UP 
          ZR     X2,DIF13    IF OC[R1W] = OC.UP 
  
          SA3    "TB"+X6     LJ = TB + J
          SA2    "TB"+X4     LK = TB + K
          NZ     B6,DIF12    IF MULT " 0
          BX1    X2+X3
          LX1    59-I.INVP
          PL     X1,DIF12    IF ^(INV[LJ] ! INV[LK])
  
*         ONE OPERAND IS *INV*, CHANGE INST TO AN *XMT/XMTC*
  
          SB4    OC.XMT      OC = OC.XMT
          LX3    59-I.INVP
          PL     X3,DIF11    IF ^INV[LJ]
          SB2    B2-OC.IA 
          SX6    X4+         J = K
          ZR     B2,DIF11    IF OC[R1W] = OC.IA 
          SB4    OC.XMTC     OC = OC.XMTC 
  
 DIF11    LX6    R1.RJP 
          BX1    "RN"X7 
          PX6    B4,X6
          BX7    X1+X6       R1W = TYI(OC,J,0,RI[R1W])
          LX6    -R1.RJP     OP = J 
          SA3    "TB"+X6     LJ = TB + J
          LX3    59-I.MP
          MI     X3,DIF2     IF M[LJ] 
          EQ     DIF4 
  
*         ONE OPERAND MARKED, OR IN SCOPE OF MULTIPLY 
  
 DIF12    LX3    59-I.MP
          PL     X3,DIF4     IF ^M[LJ]
          BX6    X4          OP = K 
          LX2    59-I.MP
          MI     X2,DIF2     IF M[LK]      */ BOTH OPERANDS MARKED
          EQ     DIF4 
  
 DIF13    SA3    "TB"+X4     LK = TB + K
          LX3    59-I.MP
          MI     X3,DIF2     IF M[LK] 
          SX6    X4          OP = K 
          EQ     DIF4 
 TYIII    SPACE  2,10 
*         TYPE III INSTRUCTION ( LD, KLS, STT ) 
  
 DIF14    SA3    A5+B1       R2 = R1 + 1
          LX3    -IH.RFP
          BX6    "RN"X3      OP = RF[R2]
          SA2    "TB"+X6     LJ = TB + OP 
          ZR     X6,DIF2     IF RF[R2] = 0
          LX2    59-I.MP
          UX4    B2,X7
          MI     X2,DIF2     IF M[LJ] 
          SX4    B2-OC.STT
          NZ     X4,DIF4     IF OC[R1W] " OC.STT
          NZ     B6,DIF4     IF MULT " 0
          SB4    OC.XMT      OC = OC.XMT   */ CHANGE STT TO AN XMT
          EQ     DIF11
 DIF      SPACE  3,14 
**        PHASE 2, ADD INCREMENT EXPRESSION TO *IIT*
  
 DIF15    MX7    0
          SX5    A7-B5       N = OI - O.RND  */ NUMBER OF INST
          SA7    A7+B1       OI = OI + 1;  [OI] = 0  */ TERMINATOR
          LX5    2
          ALLOC  IIT,X5+2    ALLOC( IIT , 4*N+2 ) 
          SA3    O.TXT
          SA4    O.RND
          SX1    4           RN = 4 
          SA0    X2+B6       IB = O.IIT + OLD(L.IIT)
          SB4    B0          NLD = 0
          SB5    X5+2        NWD = 4*N + 2
          SB6    A0+4        II = IB + 4   */ STORE ADDRESS 
          SA5    X4+1        R1 = [O.RND+1] 
          S"TB"  X3+3        TB = O.TXT + 3 
  
 DIF16    BX7    "RN"X5      R = RI[R1] 
          SA2    DIFA 
          SA3    "TB"+X7     LI = TB + R
          UX7    B2,X5
          BX6    -X2*X3      M[LI] = 0
          SA4    F.RDT+B2    DI = RDT(OC[R1]) 
          BX7    X6+X1       HBP[LI] = RN  */ SAVE NEW R-NUMBER 
          SA7    A3 
          BX6    X4          [II] = DI
          SA6    B6 
          LX4    58-D.TYP 
          MI     X4,DIF17    IF TYPE[DI] = III
          LX4    1
          MX7    0           R2W = 0
          MI     X4,DIF18    IF TYPE[DI] = II 
  
*         ADJUST OPERAND R-NUMBERS OF TYPE I INSTRUCTION
  
          LX5    -R1.RJP
          BX6    "RN"X5 
          SA4    "TB"+X6
          LX5    R1.RJP-R1.RKP
          SX6    X4          RJ[R1] = HBP[TB+RJ[R1]]
          BX5    "RN"X5 
          SA4    "TB"+X5
          LX6    R1.RJP 
          SX3    X4          RK[R1] = HBP[TB+RK[R1]]
          LX3    R1.RKP 
          PX6    B2,X6
          BX5    X6+X3
          EQ     DIF18
  
*         PROCESS TYPE III INSTRUCTION ( LD, KLS, STT ) 
  
 DIF17    SA2    A3-2        R2 = LI - 2;  R2W = [R2] 
          LX2    -IH.RFP
          BX7    "RN"X2 
          SA4    "TB"+X7
          BX2    X0*X2
          SX7    X4          RF[R2W] = HBP[TB+RF[R2W]]
          LX6    59-D.LDP 
          BX7    X2+X7
          LX7    IH.RFP 
          PL     X6,DIF18    IF ^LD[II] 
  
          SA4    A3-B1       DIT = LI - 1 
          SA2    DMASK
          BX6    -X2*X4      [II] = ^DMASK&[DIT]  */ PRESERVE FP,L2 
          SA6    B6 
          LX3    59-I.INVP
          SB4    B4+B1       NLD = NLD + 1
          MI     X3,DIF18    IF INV[LI] 
  
*         SETUP FIRST HEADER WORD 
  
          LX5    -R1.INP
          SA2    CAS
          SX6    X5 
          LX2    IA.CAP      CA[IB] = CAS 
          LX6    IA.UDIP     UDI[IB] = IN[R1] 
          PX3    B5,X6       NWD[IB] = NWD
          BX6    X2+X3
          SB3    X1          LDI = RN 
          LX5    R1.INP 
          SA6    A0 
  
 DIF18    SA7    B6-B1       [II-1] = R2W 
          BX5    X0*X5
          MX6    0
          BX7    X5+X1       RI[R1] = RN
          SA6    B6+B1       [II+1] = 0 
          SA7    A7-B1       [II-2] = [R1]
          SX1    X1+4        RN = RN + 4
          SA5    A5+B1       R1 = R1 + 1
          SB6    B6+4 
          NZ     X5,DIF16    IF [RI] " 0
  
*         SETUP SECOND HEADER WORD
  
          SX3    B3          ILD[IB+1] = LDI
          LX3    IB.ILDP
          PX6    B4,X3       NLD[IB+1] = NLD
          SA6    A0+B1
          EQ     DIF
  
 DIFA     BFMW   I,(M,HBP)
 FIM      TITLE  FIM - FORM INCREMENT MODIFICATION LISTS
**        FIM - FORM INCREMENT MODIFICATION LISTS 
*         SCAN *STC* ( *RD* VARS ) TO DEVELOP LIST OF *TP* INCREMENTS 
*         AT EACH RECURSIVE DEFINITION. 
  
          QUAL   FIM
  
 FIM      ROUTINE 
          S"TB"  X5+3        TB = O.SEQ + 3 
          PX6    X4          NIS[BSW] = 0 
          LX4    -BS.STCP 
          SA6    A4 
          SX7    X4          SC = STC[BSW]
          SA7    SC 
  
*         SEARCH *IIT* FOR FORMULAS DEPENDING ON THE VARIABLE IN THIS 
*         STORE.
  
 FIM1     SA1    O.IIT
          SA2    L.IIT
          SA4    "TB"+X7     LI = TB + SC 
          SB5    X1 
          LX4    -I.HBPP
          SA5    A4-3        R1 = LI - 3
          BX7    X2          ITB = L.IIT
          SA7    ITB
          SA4    B5+X4       EV = IIT(HBP[LI])  */ INC EXPR VALUE 
          BX6    X4 
          SA6    EV 
          LX5    -R1.INP
          SX7    X5          J = IN[R1]    */ *UDT* INDEX 
          SA7    J
          SA4    PIC         I = PIC
  
 FIM2     SX6    X4+B1       PI = I + 1 
          SA4    B5+X4       PIW = IIT(I) 
          ZR     X4,FIM5     IF PIW = 0    */ END OF LIST 
          SA1    A4+B1       PI = O.IIT + PI
          LX1    -IA.UDIP 
          BX7    X5-X1
          SX3    X7+
          LX4    -PI.LFP     I = LF[PIW]
          NZ     X3,FIM2     IF UDI[PA] " J 
  
*         GET THE VALUE OF THE INCREMENT OF THIS *IP* 
  
          SA6    PI 
          SX7    X4 
          SA7    A6+B1       PI(2) = I
          LX1    IA.UDIP
          RJ     EIE         EVALUATE  *DEL TP( EV ) *
  
          PRINT  FIM,(* -- INC VALUE = *O20),X7 
  
          UX5    B2,X7
          NZ     X5,FIM3     IF VAL[EW] " 0 
  
*         *IP* HAS A INC VALUE OF ZERO, CHANGE IT TO AN *INV* TEMP. 
  
          SB3    X6 
          SA1    O.TET
          MX4    -T.IPFL
          SA2    X1+B3       TI = TET(CAS)
          LX4    T.IPFP 
          MX5    1
          LX5    1+T.INVP 
          BX2    X5+X2       INV[TI] = 1
          BX6    X4*X2       IPF[TI] = 0
          SA6    A2 
          SX7    B6 
          SA7    A3          L.IIT = OLD(L.IIT) 
  
 FIM3     SA1    O.IIT
          SA1    O.IIT
          SA2    O.SEQ
          SA4    PI+1 
          SA5    J
          S"TB"  X2+3 
          SB5    X1 
          EQ     FIM2 
  
*         TERMINATE *TP* INC LIST, POINT FROM *ST* TO LIST. 
  
 FIM5     SA1    L.IIT
          SA2    ITB
          IX6    X1-X2
          PX5    X2 
          AX7    B1,X6       NPI = (L.IIT-ITB) / 2
          ZR     X6,FIM6     IF NPI = 0 
          SB4    X7 
          SA4    BSW
          PX5    B4,X5
          UX6    B2,X4
          SB3    B2+B4       NIS[BSW] = NIS[BSW] + NPI
          PX7    B3,X4
          SA7    A4 
          ADDWRD IIT,B0      ADDWRD( IIT , 0 ) */ LIST TERMINATOR 
          SA4    O.SEQ
          S"TB"  X4+3 
  
*         ADVANCE TO NEXT *ST* ON *STC* 
  
 FIM6     SA3    SC 
          SA2    "TB"+X3     LI = TB + SC 
          LX2    -I.STCP
          SX7    X2          SC = STC[LI] 
          SA7    A3 
          SX2    X2 
          LX2    I.STCP 
          BX6    X5+X2       NPI[LI] = NPI;  HBP[LI] = ITB
          SA6    A2 
          NZ     X7,FIM1     IF SC " 0
  
          EQ     FIM
 EIE      TITLE  EIE - EVALUATE INCREMENT EXPRESSION
**        EIE - EVALUATE INCREMENT EXPRESSION OF A POLYNOMIAL 
* 
*         ENTRY  (EV) = EXPRESSION VALUE ( 12/TYP,48/VAL )
*                (PI) = INDEX TO *IIT* OF INCREMENT FORMULA 
*                (A1,X1) = PA, [PA] = FIRST WORD OF INCREMENT FORMULA 
* 
*         EXIT   *TP* INCREMENT VALUE TERM ADDED TO *IIT* 
  
 EIE0     BX5    X7 
          ALLOC  IIT,2       ALLOC( IIT , 2 );  I = OLD(L.IIT)
          SA4    CAS
          BX7    X5 
          SX6    X4 
          SA6    X2+B6       IIT(I) = CAS  */ CA OF *IP*
          SA7    A6+B1       IIT(I+1) = EW */ EXPR VALUE
  
 EIE      ROUTINE 
          SA2    A1+B1       PB = PA + 1
          SA3    EV 
          UX6    B2,X1       NW = NWD[PA] 
          UX4    B3,X2       NLD = NLD[PB]
          LX6    -IA.CAP     CAS = CA[PA] 
          SB6    6
          BX7    X3          EW = EV
          SA6    CAS
          EQ     B2,B6,EIE0  IF NW = 6     */ MUST BE A *LD* ONLY 
  
          UX3    B4,X3       T = TYP[EV]
          NZ     B4,EIE1     IF T " 0      */ INCREMENT ^ A CON 
          EQ     B3,B1,EIE9  IF NLD = 1    */ ONLY 1 *LD* 
  
*         CHECK FOR *LD* / *XMTC* COMBINATION 
  
 EIE1     GT     B3,B1,EIE2  IF NLD > 1 
          SA4    A1+B6
          UX6    B6,X4
          SX5    B6-OC.XMTC 
          NZ     X5,EIE2     IF OC[PA+6] " OC.XMTC
          SB6    B2-10
          NZ     B6,EIE2     IF NW " 10 
  
          SB5    B4-3        TYPE[EW] = 3 - T 
          SB4    -B5
          PX7    B4,X7
          EQ     EIE0 
  
*         COMPLEX CASE, SETUP *TST* = DEL TP(INC VAL) IN *TXT* AND
*         CALL *SQZ* TO EVALUATE THE EXPRESSION.
  
 EIE2     ALLOC  TXT,14+B2   ALLOC( TXT , NW + 14 ) 
          SA1    EV 
          SB7    X2          TB = O.TXT;  TI = OLD(L.TXT) 
          UX7    B4,X1       R2W = VAL[EV]
          SB3    OC.XMT      OPC = OC.XMT 
          SX6    B1+B1       RI[R1] = 2 
          NZ     B4,EIE3     IF TYP[EV] " 0 
  
          SB2    OC.S        OC = OC.S
          LX7    R1.INP      IN[R1] = VAL[EV] 
          BX6    X7+X6
          SX7    0           R2W = 0
          EQ     EIE4 
  
 EIE3     MX5    -IH.CAIHL
          BX4    X5*X7
          SB2    OC.LD
          BX7    -X5*X7      R2 = CAIH[EV]
          LX4    R1.INP-IH.RFP
          BX6    X4+X6       R1 = TYII(0,RF[EV],0,2)
          EQ     B4,B1,EIE4  IF T = 1 
          SB3    OC.XMTC     OPC = OC.XMTC
  
*         MOVE THE FORMULA TO *TXT* 
  
 EIE4     RJ     SMI         SMI( OC , R1 , R2 )
          SA5    O.IIT
          SA2    PI 
          SB4    4
          IX7    X5+X2
          SA1    X7          PA = O.IIT + PI
          SB2    B1+B1
          UX6    B5,X1
          SB5    B5-B2       N = NWD[PA] - 2
          SA5    A1+B2       PI = PA + 2
  
 EIE5     SA4    A5+B1
          SA3    A4+B1
          LX6    X5 
          BX1    "RN"X5      R = RI[R1] 
          LX7    X4 
          SB5    B5-B4       N = N - 4
          SA6    B7+B6       TA = TB + TI; [TA] = [PI]
          SA7    A6+B1       [TA+1] = [PI+1]
          BX6    X3 
          SA6    A7+B1       [TA+2] = [PA+2]
          MX7    0
          SA7    A6+B1       [TA+3] = 0 
          SB6    B6+B4       TI = TI + 4
          SA5    A5+B4       PA = PA + 4
          NZ     B5,EIE5     IF N " 0 
  
          LX1    R1.RJP 
          SX5    B6 
          SB2    OC.XMT 
          BX6    X1+X5
          RJ     SRI         SRI( XMT  TI,R)
          SB2    OC.TST 
          SA3    L.TET
          SX6    B6-B4       R = TI - 4 
          SA4    =XIT.
          LX3    IH.CAP 
          BX7    X3+X4
          RJ     SRI         SRI( TST  R,L.TET,IT. )
          SB2    B0 
          MX6    0
          RJ     SRI         SRI( EOQ  0,0 )
  
*         CHANGE *LD* OF THE *RD* VARIABLE TO AN *XMT/XMTC* 
  
          SA2    A1+B1       PB = PA + 1
          LX2    -IB.ILDP 
          SB6    X2+4        TI = ILD[PB] + 4 
          SX6    B1+B1
          SB2    B3 
          LX6    R1.RJP 
          SX3    X2          RI = ILD[PB] 
          BX6    X6+X3
          RJ     SRI         SRI( OPC  2,0,RI ) 
  
          CALL   SIE         SQUEEZE INCREMENT EXPRESSION 
          TRACE  EIE,RLIST
          SA4    L.TXT
          SX6    X4-5*4 
          NZ     X6,EIE7     IF L.TXT " 20
  
*         *TXT* SHOULD CONTAIN * BOS, LD, XMT/XMTC, TST, EOQ *
  
          SA1    O.TXT       T = O.TXT
          SA2    X1+4        R1L = [T+4]   */ R1 OF *LD*
          UX7    B2,X2
          SX6    B2-OC.LD 
          AX7    R1.INP 
          NZ     X6,EIE7     IF OC[R1L] " OC.LD 
          SA3    X1+8        R1 = [T+8]    */ R1 OF XMT/XMTC
          SA2    A2+B1       R2L = [T+5]   */ R2 WORD OF *LD* 
          LX7    IH.RFP 
          BX2    X7+X2       VAL = SHIFT(IN[R1],IH.RFP) + CAIH[R2L] 
          UX5    B2,X3
          SB3    OC.XMT 
          PX7    B1,X2       EW = PACK(1,VAL) 
          EQ     B2,B3,EIE8  IF OC[R1] = OC.XMT 
          SB3    OC.XMTC
          SB4    B1+B1
          PX7    B4,X2       EW = PACK(2,VAL) 
          EQ     B2,B3,EIE8  IF OC[R1] = OC.XMTC
  
*         SAVE EXPRESSION IN *MOD* FOR LATER MOVE TO HOLDING BLOCK. 
  
 EIE7     ALLOC  MOD,X4-8    ALLOC( MOD , L.TXT - 8 ) 
          SA4    O.TXT
          SX3    X2+B6
          MOVE   X1,X4+4,X3  MOVE( L.TXT-8 , O.TXT+4 , O.MOD+OLD(L.MOD))
          MX1    1
          SA5    IT.
          LX1    1+T.INVP 
          ADDWRD TET,X1      ADDWRD( TET , TETW(1,0,0,0) )
          SX3    X3-1 
          SB4    3
          LX3    IH.CAP 
          PX6    B4,X5
          BX7    X3+X6       EW = PACK( 3 , CAIH[L.TET-1,IT.] ) 
  
 EIE8     SX6    4           L.TXT = 4
          SA6    L.TXT
          EQ     EIE0 
 EIE      EJECT 
*         EVALUATE EXPRESSION WITH CONSTANT INC VALUE AND 1 *LD*. 
  
 EIE9     SB7    A1+B1       TB = PA + 1
          SA0    X3          LDV = VAL[EV] */ CON VALUE OF INC VARIABLE 
          MX1    D.TYL
          SB3    B1+B1
          SB4    B3+B3
          SA4    "TB"-B1     DI = TB - 1
          SB6    B1+B1       I = 2
  
*         GET NEXT INSTRUCTION, JUMP TO PROCESSOR 
  
 EIE10    SA4    A4+B4       DI = DI + 4
          SA5    A4-B3       R1 = DI - 2
          LX4    58-D.TYP 
          BX6    X1*X4
          UX7    B5,X5
          NZ     X6,EIE11    IF TYPE[DI] " I
          LX5    -R1.RJP
          BX6    "RN"X5 
          LX5    R1.RJP-R1.RKP
          BX7    "RN"X5 
          SA2    "TB"+X6     VJ = [TB+RJ[R1]] 
          SA3    "TB"+X7     VK = [TB+RK[R1]] 
  
 EIE11    SA5    EIE.JT+B5
          SB5    X5+
          JP     B5          JUMP( EIE.JT( OC[R1] ) ) 
  
*         STORE VALUE OF THIS INSTRUCTION 
  
 EIE12    SB6    B6+B4       I = I + 4
          SA7    A4+B1       LI = DI + 1;  [LI] = V 
          LT     B6,B2,EIE10 IF I < NW
  
          MX1    -IH.CAL
          SX7    X7          V = SETX(V)   */ ELIMINATE -0
          BX6    -X1*X7 
          PX7    X6          EW = PACK(0,V) 
          EQ     EIE0 
  
*         INSTRUCTION PROCESSORS
  
          PROCESS (LD,ILD)
          SX7    A0          V = LDV
          EQ     EIE12
  
          PROCESS XMT 
          BX7    X2          V = VJ 
          EQ     EIE12
  
          PROCESS XMTC
          BX7    -X2         V = -VJ
          EQ     EIE12
  
          PROCESS IA
          IX7    X2+X3       V = VJ + VK
          EQ     EIE12
  
          PROCESS IS
          IX7    X2-X3       V = VJ - VK
          EQ     EIE12
  
          PROCESS IM
          IX7    X2*X3       V = VJ * VK
          EQ     EIE12
  
          PROCESS S 
          LX7    -R1.INP
          SX7    X7          V = IN[R1] 
          EQ     EIE12
  
          PROCESS FMA 
          LX7    -R1.INP
          SB5    X7-1 
          MX5    1
          AX7    B5,X5       V = SHIFT( 1S59 , -(IN[R1]-1) )
          EQ     EIE12
  
          PROCESS SXT 
          SA3    A4+3        R2 = DI + 3   */ ADVANCE TO *KLS*
          SA4    A4+B4       DI = DI + 4
          SB6    B6+B4       I = I + 4
          LX3    -IH.CAP
          SB5    X3 
          LX7    B5,X2       V = SHIFT( VJ , CA[R2] ) 
          EQ     EIE12
  
          PROCESS UP
          BX7    X3          V = VK 
          EQ     EIE12
  
 .STT     EQU    EIE2              */ CONTAINS AN *IH*
 EIE.JT   SPACE  2
*         COMBINED JUMP TABLE FOR *MIP* AND *EIE* 
  
          MACRO  OPR,NAM
          NOREF  /MIP/.NAM,.NAM 
          IF     DEF,/MIP/.NAM,2
          EQ     /MIP/.NAM         .NAM 
          ELSE   1
          EQ     /MIP/MIP2
          IF     DEF,.NAM,2 
-         VFD    30/.NAM
          ELSE   1
-         VFD    30/1S17+EIE
          ENDM
  
 EIE.JT   BSS    0
*CALL     OPRDEFS 
  
          QUAL
 MIP.JT   EQU    /FIM/EIE.JT
  
          QUAL   CODE 
  
 FIM      EQU    /FIM/FIM 
 UPB      TITLE  UPB - UPDATE PROGRAM BLOCK TO REFLECT MODIFICATIONS
**        UPB - UPDATE PROGRAM BLOCK TO REFLECT MODIFICATIONS FROM
*         CODE MOTION AND STRENGTH REDUCTION PROCESSORS.
*         MERGE IN *LD*"S OF REMOVED INVARIANTS, POLYNOMIALS AND
*         INCREMENT CODE. 
  
 UPB      ROUTINE 
          UX6    B2,X4       NPI = NIS[BSW]  */ N.POLY INCRS
          MX3    -BS.NTETL
          LX4    -BS.NTETP
          BX7    -X3*X4      NTL = NTET[BSW]  */ N.TEMP LDS 
          SX1    B2+X7
          SA7    NTL
          SX6    B2+B2
          IX5    X6+X7
          LX5    3
          ALLOC  MLT,X1      ALLOC( MLT , NTL + NPI ) 
          ALLOC  MOD,X5      ALLOC( MOD , 8*NTL + 16*NPI )
          SA3    O.MLT
          SA5    O.SEQ
          SB7    X2          MB = O.MOD;  MI = OLD(L.MOD) 
          SA2    IT.
          SA0    X3          MLI = O.MLT
          SB5    X5+3        SB = O.SEQ + 3 
  
*         SCAN *STC* AND SETUP INCREMENT CODE FOR THE *IP*"S. 
  
          SA4    BSW
          UX6    B4,X4
          ZR     B4,UPB8     IF NIS[BSW] = 0  */ NO INCREMENTS
          LX4    -BS.STCP 
          SA3    O.IIT
          SX4    X4          SI = STC[BSW]
          SA1    X3          (A1) = [O.IIT] 
  
 UPB1     SA3    B5+X4       LI = SB + SI 
          UX6    B3,X3       NPI = NIS[LI]
          LX3    -I.HBPP
          SB2    X3 
          LX3    I.HBPP-I.STCP
          SX7    X3          SC = STC[LI]  */ NEXT ON CHAIN 
          LX4    ML.IIP 
          SA7    SC 
          ZR     B3,UPB7     IF NPI = 0    */ NO INCS AT THIS *ST*
  
*         LOOP THROUGH C LIST IN *IIT* AND OUTPUT INCREMENTS
  
          SA5    A1+B2       ILI = O.IIT + HBP[LI];  C = [ILI]  */ CA 
          SX7    B6 
          LX7    ML.MTIP
          SB4    B6          MF = MI       */ INIT VALUE
          BX6    X4+X7
          SA6    A0          [MLI] = MCW(0,SI,0,MI) 
          SA0    A0+B1       MLI = MLI + 1
  
*         OUTPUT *TLD* OF *IP*
  
 UPB2     SB2    OC.TLD 
          SX6    B6 
          LX5    IH.CAP 
          BX7    X5+X2       R2W = CAIH[C,IT.]
          BX1    X7          R2WS = R2W 
          RJ     SRI         SRI( TLD  MI,R2W ) 
  
*         OUTPUT STT / LD OF INCREMENT VALUE
  
          SA5    A5+B1       ILI = ILI + 1
          UX7    B2,X5       T = TYP[ILI];  R2W = VAL[ILI]
          SA3    UPBB+B2
          SX6    B6 
          NZ     B2,UPB3     IF T " 0 
  
          LX7    IH.CAP 
          SX4    B6-4 
          LX4    IH.RFP      C = VAL[ILI]  */ INC VALUE 
          BX7    X4+X7       R2W = IHW(0,MI-4,C,0)
          SB2    X3 
          RJ     SII         SII( STT  MI,MI-4,C )
          EQ     UPB6 
  
*         TLD - REPLACE *CA* WITH EQUIVALENT
  
 UPB3     PL     X3,UPB4     IF T < 3 
          SA4    O.TET
          LX7    -IH.CAP
          SB2    X7 
          SA4    X4+B2
          LX4    -T.CAP 
          SX7    X4          CA[R2W] = CA[TET(CA[R2W])
          LX7    IH.CAP 
          BX7    X7+X2
          EQ     UPB5 
  
*         LD - SET *IN* FIELD IN R1 WORD
  
 UPB4     MX4    -IH.CAIHL
          BX5    X4*X7       IH[R1] = RF[R2W] 
          BX7    -X4*X7      R2W = CAIH[R2W]
          LX5    R1.INP-IH.RFP
          BX6    X5+X6
  
 UPB5     SB2    X3          OC = SETX( UPBB(T) ) 
          AX3    18 
          RJ     SMI         SMI( UPBB(T) , R1W , R2W ) 
  
*         OUTPUT INCREMENT OF POLYNOMIAL ( TP = TP + INCV ) 
  
          SX5    B6-8 
          SX4    B6-4 
          SX6    B6 
          LX5    R1.RJP 
          SB2    X3          OC = SHIFT( UPBB(T) , -18 )
          LX4    R1.RKP 
          BX3    X4+X5
          IX6    X3+X6
          RJ     SII         SII( OC  MI,MI-8,MI-4 )
  
 UPB6     SX6    B6-4 
          SB2    OC.TST 
          BX7    X1          R2W = R2WS 
          RJ     SII         SII( TST  MI-4,R2W ) 
          SA5    A5+B1       ILI = ILI + 1
          NZ     X5,UPB2     IF [ILI] " 0 
  
          SA4    A0-B1
          SX3    B6-B4       NI = (MI-MF)/4  */ N.INSTRUCTIONS IN MOD 
          LX3    ML.NIP-2 
          BX6    X3+X4
          SA6    A4          NI[MIL-1] = NI 
  
 UPB7     SA4    SC 
          NZ     X4,UPB1     IF SC " 0
 UPB      SPACE  2,10 
*         SCAN *TET* AND SETUP *TLD*"S OF REMOVED EXPRESSIONS 
  
 UPB8     SA3    NTL
          ZR     X3,UPB15    IF NTL = 0 
          SA1    TTI
          SA4    O.TET
          SB2    X1 
          SA5    X4+B2       TI = O.TET + TTI  */ *TET* INDEX 
          SX6    B2+X3       TTI = TTI + NTL  */ ADVANCE *TET* INDEX
          SA6    A1 
          SB4    X3          NT = NTL 
          SA1    UPBC 
  
 UPB9     LX5    -T.CAP 
          SX3    X5 
          LX5    T.CAP-T.BIP
          BX6    "RN"X5      R = BI[TI]    */ INSERT POINTER
          SA4    B5+X6       LI = SB + R
          LX3    IH.CAP 
          BX7    X2+X3       R2W = CAIH[CA[TI],IT.] 
          LX4    59-I.AIPP
          PL     X4,UPB11    IF ^AIP[LI]
  
*         *TP* IS *AIP*, SEARCH FOR *TLD* OF INCREMENT IN *MOD* AND 
*         FORM AN *XMT* FROM IT TO THE *TP*.  ( IO=I $ I=I+1 $ A(J,IO) )
  
          SB3    A0-B1       J = MLI - 1
          SB2    B7+B1
 UPB10    SA3    B3          MLW = [J]
          SB3    B3-B1       J = J - 1     */ BACKWARDS SEARCH
          LX3    -ML.IIP
          BX4    "RN"X3 
          IX5    X6-X4
          MI     X5,UPB10    IF II[MLW] > R 
          LX3    ML.IIP-ML.MTIP    I = MTI[MLW] 
          SA2    B2+X3
          LX3    ML.MTIP-ML.NIP    K = NI[MLW]
  
 UPB10A   BX4    X2-X7
          ZR     X4,UPB10B   IF MOD(I) = R2W
          SX3    X3-1        K = K - 1
          SA2    A2+4        I = I + 4
          NZ     X3,UPB10A   IF K " 0 
          EQ     UPB10
  
 UPB10B   SA3    A2-B1
          SX2    X7                RESTORE X2 
          BX5    "RN"X3      RJ = RI[MOD(I-1)]  */ RI OF TLD
          LX6    ML.IIP 
          SX7    B6 
          LX7    ML.MTIP
          BX6    X6+X7
          SX4    B1 
          LX4    ML.NIP 
          BX6    X4+X6
          MX4    1
          LX4    1+ML.DELP
          BX6    X4+X6
          SA6    A0          [MLI] = MCW(1,R,1,MI)
          SA0    A0+B1       MLI = MLI + 1
          EQ     UPB13
  
 UPB11    SA4    A4-B1       DI = LI - 1
          SB2    OC.TLD 
          BX3    X1*X4
          NZ     X3,UPB12    IF STRS[DI] ! PI[DI] " 0 
  
*         INSERT *TLD* DIRECTLY IN *SEQ*
  
          SA7    A4-B1       [DI-1] = R2W 
          PX6    B2,X6
          SA3    F.RDT+B2 
          BX7    X3 
          SA6    A7-B1       [DI-2] = TYIII(OC.TLD,0,0,R) 
          SA7    A4          [DI] = RDT(OC.TLD) 
          EQ     UPB14
  
*         SETUP *MOD* ENTRY FOR *TLD/XMT* 
  
 UPB12    SA3    UPBA 
          SX4    B6 
          LX6    ML.IIP 
          LX4    ML.MTIP
          IX4    X4+X6
          BX6    X3+X4
          SA6    A0          [MLI] = MCW(1,R,2,MI)
          SA0    A0+B1       MLI = MLI + 1
          SX6    B6 
          RJ     SRI         SRI( TLD  R,R2W )
          SX5    B6-4        RJ = MI-4
  
 UPB13    SX6    B6 
          LX5    R1.RJP 
          SB2    OC.XMT 
          MX7    0
          BX6    X5+X6
          RJ     SRI         SRI( XMT  MI,RJ )
  
 UPB14    SB4    B4-B1       NT = NT - 1
          SA5    A5+B1       TI = TI + 1
          NZ     B4,UPB9     IF NT " 0
 UPB      SPACE  2,10 
*         SET FINAL TABLE LENGTHS AND MERGE THE BLOCKS
  
 UPB15    SA1    O.MLT
          SX2    A0 
          SX6    B6 
          SA6    L.MOD       L.MOD = MI 
          IX7    X2-X1
          MX6    1
          SA7    L.MLT       L.MLT = MLI - O.MOD
          CALL   MPB         MERGE, SQUEEZE AND REWRITE BLOCK 
          EQ     UPB
  
 NTL      BSS    1           N.TET"S IN BLOCK 
 UPBA     BSS    0
          VFD    1/1
          POS    ML.NIP+2 
          VFD    2/2,*P/0 
  
*         UPBB - INCREMENT OPERATION TABLE
  
 INCOP    MACRO  A,B,C
          VFD    1/C,41/OC.B,18/OC.A
          ENDM
  
 UPBB     BSS    0
          LOC    0
          INCOP  STT,S
          INCOP  LD,IA
          INCOP  LD,IS
          INCOP  TLD,IA,1 
          INCOP  TLD,IS,1 
          LOC    *O 
  
 UPBC     BFMW   D,(STRS,PI)   PS , PRS AND PI ( *DEF* MAY *PS* ) 
 GPO      TTL    GPO - GLOBAL PROGRAM OPTIMIZATION / SUBROUTINES
 MPB      TITLE  MPB - MERGE PROGRAM BLOCK AND MOD LIST 
**        MPB - MERGE PROGRAM BLOCK AND MOD LIST
*         MERGES A PROGRAM BLOCK DEFINED BY O.SEQ, L.SEQ AND THE MOD
*         LIST ASSOCIATED WITH THE BLOCK, AND MOVES THE BLOCK TO *TXT*. 
* 
*         ENTRY  (X6) = 0 , MERGE BLOCK ONLY
*                (X6) > 0 , MERGE BLOCK AND CALL *SQZB* . 
*                (X6) < 0 , MERGE, CALL *SQZB* AND REWRITE TO *BLK* 
* 
*         EXIT   MERGED BLOCK IN *TXT*, R-NUMBERS IN CANONICAL ORDER. 
*                L.MLT = 0 , L.MOD = 4 AND L.TXT = 4 IF FLAG < 0 .
  
 SB       MICRO  1,,/B6/     O.SEQ + 3
  
 MPB0     SA1    MPBA 
          ZR     X1,MPB      IF MPBA = 0   */ NO SQZB CALL
          MX6    0
          CALL   SQZB 
  
          TRACE  MPB,RLIST
  
          SA1    MPBA 
          PL     X1,MPB      IF MPBA > 0
  
          CALL   WTB         WRITE BLOCK BACK TO *BLK*
  
 MPB      ROUTINE 
          SA6    MPBA 
          TRACE  MPB,MLT
          TRACE  MPB,RLIST,MOD
          SA5    L.MOD
          SA4    L.SEQ
          SX5    X5-8 
          IX1    X4+X5
          ALLOC  TXT,X1      ALLOC( TXT , L.SEQ + L.MOD-8 ) 
  
*         INSERT MOD LIST INFO IN *SEQ* 
  
          SA4    O.SEQ
          SA1    O.MOD
          SX7    B6-4        PTL = OLD(L.TXT) - 4 
          SB3    3
          IX6    X2+X7       TIA = O.TXT + PTL
          SA6    TIA
          S"TB"  X2+B3       TB = O.TXT + 3 
          MX0    1
          SA3    O.MLT
          S"SB"  X4+B3       SB = O.SEQ + 3 
          SA5    X3          I = [O.MLT]
          SA2    L.MLT
          SB4    B0          MIA = 0       */ MIN INSERT ADDRESS
+         NZ     X7,*+1      IF PTL = 0  THEN MIA = *INFINITY*
          SB4    377777B     MIA = *INFINITY*  */ MIN INSERT ADDRESS
          LX1    ML.MTIP
          ZR     X2,MPB2     IF L.MLT = 0 
          SB5    X2+         N = L.MLT
 MPB      SPACE  1,10 
 MPB1     IX6    X5+X1       MTI[I] = MTI[I] + O.MOD  */ RELOCATE 
          LX5    -ML.IIP
          SA6    "SB"+X5     SI = SB + II[I];  [SI] = [I]  */ SAVE INSRT
          SB2    X5 
+         SB5    B5-B1       N = N - 1
          GE     B2,B4,*+1   MIA = MIN( II[I] , MIA ) 
          SB4    B2 
          SA4    A6-B3       R1 = SI - 3
          SA5    A5+B1       I = I + 1
          BX7    X0+X4       [R1] = MASK(1) ! [R1]  */ SET MOD FLAG 
          SA7    A4 
          NZ     B5,MPB1     IF N " 0 
 MPB      SPACE  2,10 
*         MOVE INSTRUCTIONS FROM *SEQ* TO *TXT*, INSERT INSTRUCTIONS
*         FROM *MOD*
  
 MPB2     SA2    TIA
          SA1    DMASK
          SA0    X2          TI = TIA 
          SX6    X2+B4       FIA = TIA + MIA
          SA6    FIA
          SA5    "SB"-7      SI = SB-3 - 4
          SB4    4
          EQ     MPB4 
  
*         MOVE INSTRUCTION TO *TXT* 
  
 MPB3     SA4    A5+B1       R2 = SI + 1
          BX6    X5 
          SA3    A4+B1       D = R2 + 1 
          LX7    X4 
          SA6    A0          [TI] = [SI]
          UX5    B2,X5
          SA7    A6+B1       [TI+1] = [R2]
          BX6    -X1*X3 
          SA6    A7+B1       [TI+2] = ^DMASK & [D]
          MX7    0
          SA7    A6+B1       [TI+3] = 0 
          SX6    A7-"TB"     R = TI+3 - TB
          SA0    A0+B4       TI = TI + 4
          SA6    A5+B3       [SI+3] = R    */ NEW R-NUMBER
          ZR     B2,MPB7     IF OC[SI] = 0 */ END OF SEQ
  
 MPB4     SA5    A5+B4       SI = SI + 4
          PL     X5,MPB3     IF [SI] \ 0   */ NOT AN INSERT POINT 
          SA2    A5+B3       LW = [SI+3]
          BX6    -X0*X5 
          LX2    59-ML.DELP 
          MI     X2,MPB5     IF DEL[LW]    */ INST TO BE DELETED
  
          SA4    A5+B1       R2 = SI + 1
          SA3    A4+B1       D = R2 + 1 
          LX7    X4 
          SA6    A0          [TI] = [SI]
          SA7    A6+B1       [TI+1] = [R2]
          BX6    -X1*X3 
          SA6    A7+B1       [TI+2] = ^DMASK & [D]
          MX7    0
          SA7    A6+B1       [TI+3] = 0 
          SX6    A7-"TB"     R = TI+3 - TB
          SA0    A0+B4       TI = TI + 4
          SA6    A5+B3       [SI+3] = R 
  
*         MOVE INSTRUCTIONS FROM *MOD* TO *TXT* 
  
 MPB5     BX5    X2 
          LX2    1+ML.DELP-ML.MTIP
          SA4    X2          MI = MTI[LW] 
          LX2    ML.MTIP-ML.NIP 
          SB2    X2          N = NI[LW] 
  
 MPB6     SA3    A4+B1
          BX6    -X4
          SA2    A3+B1
          SB2    B2-B1       N = N - 1
          SA6    A0          [TI] = -[MI]  */ FLIP R1 WORD
          BX7    X3 
          SA7    A6+B1       [TI+1] = [MI+1]
          BX6    -X1*X2      [TI+2] = ^DMASK & [MI+2] 
          SA6    A7+B1
          MX7    0
          SA7    A6+B1       [TI+3] = 0 
          SX6    A7-"TB"     R = TI+3 - TB
          SA6    A4+B3       [MI+3] = R    */ NEW R-NUMBER
          SA0    A0+B4       TI = TI + 4
          LX2    -D.^DP+2 
          SA4    A4+B4       MI = MI + 4
          NZ     B2,MPB6     IF N " 0 
  
          PL     X5,MPB4     IF ^DEL[LW]   */ IF AN INSERT
          SX3    B4 
          BX2    X3*X2
          IX6    X6-X2       R = R - 4*^D[MI-2] 
          SA6    A5+B3       [SI+3] = R    */ FOR *EXTERNAL* USE
          EQ     MPB4 
 MPB      SPACE  2,14 
*         ADJUST R-NUMBERS TO BRING *TXT* TO CANONICAL FORM 
  
 MPB7     SB5    A0+B3
          SX6    B5-"TB"     L.TXT = TI+3 - TB
          SA5    O.MOD
          MX0    -R1.RIL+1
          SA6    L.TXT
          LX0    1
          TRACE  MPB7,RLIST 
          SA3    FIA
          MX1    D.TYL
          SB2    B1+B1
          MI     X3,MPB0     IF FIA < 0    */ NO MODS TO BLOCK
          SA4    X3-2        DI = FIA - 2 
          SB5    X5+B3       MB = O.MOD + 3 
          MX6    0
          SA0    "SB"-100000B      MSB = SB - 100000B */ MOD TO SEQ REFS
          SA6    "SB"        [SB] = 0 
          SA6    B5          [MB] = 0 
          EQ     MPB10
  
*         ADJUST OPERAND R-NUMBERS OF INSTRUCTION FROM *SEQ*
  
 MPB8     BX7    "RN"X5 
          SA3    "SB"+X7     R = [SB+RI[R1]]
          BX5    X0*X5
          SA2    A5+B1       R2 = R1 + 1
          IX6    X5+X3       RI[R1] = R 
          NZ     X4,MPB9     IF TYPE[DI] " I
  
          LX6    -R1.RJP
          BX7    "RN"X6 
          SA3    "SB"+X7     R = [SB+RJ[R1]]
          BX6    X0*X6
          IX5    X6+X3       RJ[R1] = R 
          LX5    R1.RJP-R1.RKP
          BX7    "RN"X5 
          SA3    "SB"+X7     R = [SB+RK[R1]]
          BX5    X0*X5
          IX6    X5+X3       RK[R1] = R 
          SB0    0
          LX6    R1.RKP 
  
 MPB9     LX2    -IH.RFP
          BX7    "RN"X2 
          SA3    "SB"+X7     R = [SB+RF[R2]]
          BX2    X0*X2
          SA6    A5 
          IX7    X2+X3       RF[R2] = R 
          LX7    IH.RFP 
          SA7    A2 
  
*         ADVANCE TO NEXT INSTRUCTION 
  
 MPB10    SA5    A4+B2       R1 = DI + 2;  RW = [R1]
          SA4    A5+B2       DI = R1 + 2
          LX4    58-D.TYP 
          BX6    -X1+X4 
          BX4    X1*X4
          ZR     X6,MPB16    IF TYPE[DI] = IV 
          PL     X5,MPB8     IF RW > 0
  
*         ADJUST OPERAND R-NUMBERS OF INSTRUCTION FROM *MOD*
  
          BX5    -X5         RW = -RW 
          BX2    "RN"X5      R = RI[RW] 
          UX7    B3,X5
          SB7    B5 
          LX7    -R1.RIL
          PL     X7,MPB11    B = IF R < 100000B THEN MB; ELSE MSB 
          SB7    A0 
 MPB11    SA2    B7+X2       RI[RW] = [B+R] 
          BX6    X0*X5
          NZ     X4,MPB14    IF TYPE[DI] " I
  
          BX4    "RN"X7 
          LX7    -R1.RIL
          SB7    B5 
          PX6    B3,X2
          BX5    "RN"X7 
          PL     X7,MPB12    B = IF R < 100000B THEN MB; ELSE MSB 
          SB7    A0 
 MPB12    SA2    B7+X4       RK[RW] = [B+RK[RW]]
          LX7    -R1.RIL
          SB7    B5 
          LX2    R1.RKP 
          BX6    X2+X6
          PL     X7,MPB13    B = IF R < 100000B THEN MB; ELSE MSB 
          SB7    A0 
 MPB13    SA2    B7+X5       RJ[RW] = [B+RJ[RW]]
          SB0    0
          LX2    R1.RJP 
  
 MPB14    SA3    A5+B1       R2 = R1 + 1
          BX6    X2+X6
          LX3    -IH.RFP
          SA6    A5          [R1] = RW
          BX7    "RN"X3 
          SB4    X7 
          LX7    -R1.RIL
          BX3    X0*X3
          SB7    B5 
          PL     X7,MPB15    B = IF R < 100000B THEN MB; ELSE MSB 
          SB7    A0 
 MPB15    SA2    B7+B4       RF[R2] = [B+RF[R2]]
          IX6    X2+X3
          LX6    IH.RFP 
          SA6    A3 
          EQ     MPB10
  
 MPB16    PL     X5,MPB17    IF RW > 0
          BX7    -X5         [R1] = -RW 
          SA7    A5 
  
 MPB17    UX6    B3,X5
          NZ     B3,MPB10    IF OC[R1] " 0
  
          MX7    0
          SX6    4
          SA7    L.MLT       L.MLT = 0
          SA6    L.MOD       L.MOD = 4
          EQ     MPB0 
  
 MPBA     BSS    1
 FIA      BSS    1           FIRST INSERT ADDRESS 
 TIA      BSS    1           *TXT* INSERT ADDRESS ( O.TXT+OLD(L.TXT)
 MBT      SPACE  3,14        MBT
**        MBT - MOVE BLOCK FROM *SEQ* TO *TXT*, CLEAR LINK WORDS. 
  
 MBT      ROUTINE 
          SA5    O.SEQ
          SA2    X5+B1       R2 = [O.SEQ+1] 
          LX2    -R2.TXTLP
          ALLOC  TXT,X2-4    ALLOC( TXT , TXTL[R2]-4 )
          SA1    O.SEQ
          SB4    4
          SA5    X1          R1 = [O.SEQ] 
          SB2    X3 
          SB7    X2          TI = [O.TXT] 
  
 MBT2     SA4    A5+B1
          SA3    A4+B1
          BX6    X5 
          SA5    A5+B4
          LX7    X4 
          SB2    B2-B4       I = I - 4
          SA6    B7 
          SB7    B7+B4
          SA7    A6+B1
          BX6    X3 
          SA6    A7+B1
          MX7    0
          SA7    A6+B1
          NZ     B2,MBT2     IF I " 0 
  
          EQ     MBT
          QUAL
  
          ECHO   2,X=(EBV,FUD,MBT,MPB)
          ENTRY  X
 X        EQU    /CODE/X
  
          END 
