*DECK     BDT 
          IDENT  BDT
 BDT      TITLE  BDT - FORM DEPENDENCY GRAPH
*CALL     SSTCALL 
 B=BDT    RPVDEF
          PASS2TM 
          TABLES TXT,TREE 
*IF       DEF,BDT,1 
          TRACER BDT
 BDT      SPACE  3
**        BDT - BUILD DEPENDENCY TREE ( FORM DEPENDENCY GRAPH ) 
*         BDT FORMS THE DEPENDENCY GRAPH OF A SEQUENCE OF *IL*
*         INSTRUCTIONS WHICH TAKES INTO ACCOUNT THE OPERAND, DATA 
*         INTERFERENCE, REGISTER REDEFINITION AND BLOCK CONSTRAINT
*         DEPENDENCIES ( LINKS ) OF THE INSTRUCTIONS.  IT ALSO COMPUTES 
*         THE PERT LATE START TIMES FOR EACH INSTRUCTION, AND SORTS THE 
*         THE SUCCESSOR INDEX LISTS ACCORDING TO THEM.
* 
*         S.I. JASIK - FEB 1973 
* 
*         ENTRY  (X6) = TREE MODE = 0/1 - PRIORITY CALC / JAM MODE
*                (SIOCALL) = 1 IF CALL FROM *RIO* FOR A PARTIAL TREE
*                *TXT* - INSTRUCTION SEQUENCE, LINK WORDS ARE ZERO. 
* 
*         EXIT   *TREE* = SUCCESSOR INDEX TABLE IN "U." FORMAT
*                LINK WORDS OF INSTRUCTIONS IN "I." FORMAT
*                N.INST, N.ST , SEQTIME SET 
          SPACE  3
          USE    /MCG/
 N.INST   BSS    1           NUMBER OF INSTRUCTIONS ( L.TXT/4 ) 
 N.ST     BSS    1           NUMBER OF STORES IN *TXT*
 SEQTIME  BSS    1           CRITICAL PATH TIME ( CALCULATED IN *CIP* ) 
          USE    0
 DEBUG    SPACE  3
**        DEBUGGING FACILITIES
* 
*         BASIC SNAPS - *IL* SEQUENCE AND *SIT* ON EXIT 
*         TRACER BDT
* 
*         TO SNAP THE FINAL DEPENDENCY TREE 
*         TRACER TREE 
* 
*         TO TRACE EACH PHASE - 
*         TRACER (RNI,IH,FIL,FOL,FTL,FJL) 
  
**        TREE - SNAPSHOT DUMP OF THE DEPENDENCY TREE 
*         NOTE - TREE MACRO MAY BE CALLED BETWEEN FIL2 AND FTL5 ONLY
  
 TREE     MACRO  LAB
          IF     DEF,/DEBUG/LAB,1 
 TREE-LAB SNAP   *A7,*TREEL,,,1,200,1 
          ENDM
 TABLES   TITLE  TABLE FORMATS
          LIST   -R 
  
**        DEPENDENCY TREE ( FIL,FOL,FTL, ETC) 
  
          DESCRIBE T.,60     TREE(EQVL,SUCC,PRED) 
          DEFINE 18 
 SUCC     DEFINE 18          INDEX TO *TXT* OF SUCCESSOR
          DEFINE 1
 RDL      DEFINE 1           REGISTER REDEFINITION LINK 
 EQVL     DEFINE 1           DATA INTERFERENCE LINK 
          DEFINE 3
 PRED     DEFINE 18          INDEX TO *TXT* OF PREDECESSOR
 IHINFO   SPACE  3
**        IH INFO TABLE ( FIL ) 
  
          DESCRIBE IH.,60    IHINFO(BITS,R2W) 
 LD       DEFINE 1
 ST       DEFINE 1
 BM       DEFINE 1
          DEFINE 57          R2 WORD OF MEM REF INSTRUCTION 
 USESI    SPACE  3
**        USES INDEX TABLE ( FINAL FORMAT OF TREE ) 
*                SORTED ON *PRED* , *LST* AND *SUCC* FIELDS.
  
          DESCRIBE U.,60     SIT(LAST,PRED,LST,SUCC)
 LAST     DEFINE 1           "0 IF LAST EDGE OF A *PRED* GROUP
 RDL      DEFINE 1           REGISTER REDEFINITION LINK 
 EQV      DEFINE 1           DATA INTERFERENCE LINK 
          DEFINE 3
 PRED     DEFINE 18          INDEX TO *TXT* OF PREDECESSOR
 LST      DEFINE 18          LATE START TIME
 SUCC     DEFINE 18          INDEX TO *TXT* OF SUCCESSOR
 INFO     SPACE  3
**        I. - LINK WORD FORMAT FOR INSTRUCTION SCHEDULING ( BDT EXIT ) 
  
          DESCRIBE I.,60     UINFO(USES,INDX,PRI,NPRED) 
          DEFINE 3
 USES     DEFINE 9           USES COUNT 
 INDX     DEFINE 15          ORDINAL TO SUCCESSOR LIST IN USES INDEX TBL
 LST      DEFINE 15          LATE START TIME
 NPRED    DEFINE 18          NUMBER OF UNISSUED PREDECESSORS
  
 PRIOR    DEQU   LST         PRIORITY ( NEGATIVE OF LATE START TIME ) 
 INIT     TITLE  INITIALIZATION 
**        LOCAL STORAGE 
  
          USE    /TABLES/ 
 BDTA     BSS    1           TREE BUILD MODE
 EQVL     BSS    1           "0 IF JAM MODE AND EQUIV LINKS 
 FBM      BSS    1           ORD OF FIRST BOUNDARY MARKER IN *TXT*
 LBM      BSS    1           DESCR ADDRESS OF LAST *BM* 
 FTREE    BSS    1           FWA OF TEMP TREE 
 TF       BSS    1           LWA+1 OF THE OPERAND LINKS ( TEMP TREE ) 
 TREEL    BSS    1           LWA+1 OF THE TREE
 TSTC     BSS    1           *TST* CHAIN ( NBIP " 0 & SIOCALL = 2 ONLY )
 REGS     BSS    24          REGISTER STORE ADDRESS TABLE 
          USE    0
  
  
 SIOCALL  BSSZ   1           "0 IF CALL FROM *RIO*
  
          LIST   R
  
 PI.CNP   EQU    36          IP. CLASS NUMBER 
 D.RDP    EQU    D.MUCP      REDEF ST (FIL10,SIO3)
  
 OC       MICRO  1,,/B3/
 BDT      SPACE  3
 BDT      ENTRY.
          QUAL   BDT
          SA1    L.TXT
          SA6    BDTA        SAVE TREE BUILD MODE 
          BX7    X1 
          AX7    2
          SA7    N.INST      N.INST = L.TXT/4 
          ZR     X6,BDT2     IF BDTA = 0   */ NOT JAM MODE
          SX1    X1+200B     L.TREE = L.TREE + 200B  */ FUDGE FACTOR
  
 BDT2     ALLOC  TREE,X1     ALLOC( TREE , L.TREE ) 
          SX3    X3-1 
          SA5    O.TXT
          IX6    X2+X3
          SA6    TREEL       TREEL = LWA+1 OF THE TEMP TREE 
  
          SA0    X5          (A0) = O.TXT 
          SB7    X2          (B7) = O.TREE
          SB2    B1+B1       (B2) = 2 
          SB4    4           (B4) = 4 
  
*         THE TEMPORARY TREE IS FORMED IN *TREE* STARTING AT THE END
*         OF THE TABLE AND WORKING TOWARDS THE BEGINNING. 
*         (A7) HOLDS THE ADDRESS OF THE LAST EDGE ADDED TO IT FROM
*         *FIL3* TO *FTL7*.  DURING FIL THE *IHINFO* TABLE IS SETUP AT
*         THE BEGINNING OF *TREE*.
 FIL      TITLE  FIL - FORM DATA INTERFERENCE LINKS 
**        FORM THE *IH* INFO TABLE
*                60/*TXT* INDEX OF INSTRUCTION
*                60/*IH* INFO WORD
  
 FIL      SA2    O.TREE 
          MX6    60 
          SA6    X2          IH = O.TREE,  [IH] = -0
          MX0    -1 
          MX1    -D.LDSTL 
          SB5    A0+B2       BASE = O.TXT + 2 
          LX1    D.LDSTP
          SB6    59-D.BMP 
          SB7    B0          N.ST = 0 
          SA4    A0+B2       DI = O.TXT + 2 
          SA2    TREEL
          SA3    BDTA 
          MX7    0
          SA7    TSTC        TSTC = 0 
          SA7    X2          T = TREEL;  [T] = 0
          SX6    A0 
          MX5    -IH.BMP
          BX7    X5+X6
          SA7    A7-B1       T = T - 1;  [T] = BM[IH] ! O.TXT 
  
*         SET FLAG FOR FULL EQUIV LINKING ( BETWEEN CONDITIONAL JUMPS ) 
*         IF JAM MODE OR CALLED FROM *RIO*. 
  
          SX2    B1 
          LX2    D.TYP       FET = TY      */TY IV BM"S ONLY
          NZ     X3,FIL2     IF BDTA " 0
          SA3    SIOCALL
          NZ     X3,FIL2     IF SIOCALL " 0 
          LX2    D.BMP-D.TYP FEL = BM      */ DONT LINK ACROSS TY IIIJPS
          EQ     FIL2 
  
*         SCAN THE SEQUENCE AND FORM AN *IH* INFO TABLE ENTRY FOR EACH
*         LD, ST AND BOUNDARY MARKER. 
  
 FIL1     SA5    A4-B1       R2 = DI - 1
          LX4    -D.STP 
          BX3    -X0*X4 
          IFNE   .DAL,0,2                                      LEVEL 2
          LX4    D.STP-D.L2P
          BX3    -X4*X3 
  
          SA6    A6+B1       IH = IH + 1;  [IH] = DI - BASE 
          LX7    IH.STP-D.LDSTP 
          SB7    B7+X3       N.ST = N.ST + (ST[DI]&^L2[DI]) 
          BX6    X7+X5
          SA6    A6+B1       IH = IH + 1;  [IH] = IHINFO(LDST[DI],[R2]) 
          ZR     X3,FIL2     IF (ST[DI]&^L2[DI]) = 0
          SX7    A4-B2
          SA7    A7-B1       T = T - 1;  [T] = R1 
  
 FIL2     SA4    A4+B4       DI = DI + 4
          BX7    -X1*X4 
          SX6    A4-B5
          LX3    B6,X4
          NZ     X7,FIL1     IF LDST[DI]
          PL     X3,FIL2     IF ^BM[DI] 
          SA5    A4-B2       R1 = DI - 2
          BX3    X2*X4
          ZR     X3,FIL2     IF FEL[DI] = 0  */ JAM MODE & TY III BM
          SX7    A4-B2
          SA6    A6+B1       IH = IH + 1;  [IH] = DI - BASE 
          UX3    "OC",X5
          MX6    -IH.BMP
          BX7    X6+X7
          SA6    A6+B1       IH = IH + 1;  [IH] = IHINFO(BM,0)
          SA7    A7-B1       T = T - 1;  [T] = BM[IH] ! R1
          NZ     "OC",FIL2   IF OC[R1] " 0
  
          SB6    A6          IHS = IH 
          SX6    B7 
          SA6    N.ST 
  
          IF     DEF,/DEBUG/IH,1
 IH-INFO  SNAP   *O.TREE,B6 
 CSP      SPACE  3,14 
**        CSP - COUNT NUMBER OF STORE PREDECESSORS PER BASIC BLOCK
*         AND SAVE THE COUNTS IN THE USES FIELD OF THE DESCR OF THE 
*         BOS/UJP/RJX/LAB STARTING THE BLOCK. 
  
          ZR     B7,CSP6     IF N.ST = 0   */ IF NO STORE PREDECESSORS
          MX0    -R1.RIL
          SB5    B0          NSP = 0       */ NUMBER OF STORE PRED
          SA5    A7+B1       TI = T + 1 
          BX1    -X0         RMIN = 177777B 
          SB3    60-D.TYL 
          SB7    T.SUCCP
          EQ     CSP2 
  
 CSP1     SA5    A5+B1       TI = TI + 1
          BX1    X3          RMIN = R 
          SB5    B5+1        NSP = NSP + 1
  
 CSP2     MI     X5,CSP4     IF BM[TI]
          SA4    X5          R1 = [TI]
          BX3    -X0*X4      R = RI[R1] 
          LX6    B7,X3
          BX7    X6+X5       [TI] = TREE(R,R1)
          IX4    X3-X1
          SA7    A5 
          MI     X4,CSP1     IF R < RMIN
  
*         POSSIBLE PS REVERSAL, SCAN BACKWARDS TO FIND *RI* IN STORE. 
  
          SA4    A5-B1       TJ = TI - 1
          SA5    A5+B1       TI = TI + 1
 CSP3     AX6    B7,X4
          IX7    X6-X3
          ZR     X7,CSP2     IF SUCC[TJ] = R
          SA4    A4-B1       TJ = TJ - 1
          PL     X4,CSP3     IF ^BM[TJ] 
          SB5    B5+B1       NSP = NSP + 1
          EQ     CSP2 
  
*         BOUNDARY MARKER ENCOUNTERED, SAVE *NSP* IN IT IF TYPE = IV
  
 CSP4     SA4    X5+B2       DI = [TI] + 2
          SA5    A5+1        TI = TI + 1
          LX4    58-D.TYP 
          AX6    B3,X4
          ZR     X6,CSP5     IF TYPE[DI] = IV 
          SX7    A4-B2
          SA7    A5-B1       [TI-1] = DI - 2 */ REMOVE BM BITS
          EQ     CSP2 
  
 CSP5     SX3    B5          USES[DI] = NSP 
          MX7    -D.USESL 
          LX4    2+D.TYP
          SB5    B0          NSP = 0
          BX4    X7*X4
          BX6    X3+X4
          SA6    A4 
          NZ     X5,CSP2     IF [TI] " 0
  
 CSP6     SA1    TREEL                     */ REINTIALIZE THE TREE
          SX7    0
          SA7    EQVL        EQVL = 0 
          SA7    X1          T = TREEL;  [T] = 0
  
*         IF IN A LOOP, THEN CHECK *IHINFO* TABLE FOR *SRF* MEMORY
*         REFERENCES, AND INVENT AN *RF* FOR THEM.
*         *SRF* MEMORY REFS ARE THE RESULT OF ADDRESS DIFFERENCING
*         SIMILAR *IP"S*, AND REFERENCES TO THE NON-BASE MEMBERS OF 
*         THE CLASS DO NOT HAVE A REAL *RF* ASSOCIATED WITH THEM. 
  
  
          SA1    =XGRASRF 
          ZR     X1,IRF5     IF GRASRF = 0 */ ^(IN LOOP & ADDR DIFF)
  
          MX0    -IH.RFL
          SA1    SIOCALL
          LX0    IH.RFP 
          MX7    -2*R1.RIL
          SA5    B6          IH = IHS 
          LX7    R1.RIL 
          SB3    A0 
          SB5    59-IH.SRFP 
          SB7    B1          IRN = 1       */ INVENTED R-NUMBER INDEX 
  
*         SEARCH *IHINFO* FOR *SRF* MEM REFS, AND INVENT A *RF* 
*         FOR EACH UNIQUE ORDERED PAIR - *(RJ,RK)* .
  
 IRF1     SA5    A5-B2       IH = IH - 2
          LX6    B5,X5
          PL     X6,IRF1     IF ^SRF[IH]
          ZR     X5,IRF5     IF [IH] = 0   */ END OF *IHINFO* 
  
          SA4    A5-B1       R = [IH-1] 
          SA2    B3+X4       R1W = TXT(R) 
          BX6    -X7*X2      KEY = RJRK[R1W]
          SA6    A7-B7       T(-IRN) = KEY */ SET SEARCH TERMINATOR 
          BX5    X0*X5
          SA3    A7          TJ = T 
 IRF2     SA3    A3-B1       TJ = TJ - 1   */ SEARCH ORDERED PAIR LIST
          BX2    X3-X6
          NZ     X2,IRF2     IF [TJ] " KEY
  
          SB4    A3 
          SB4    A7-B4       J = T - TJ 
          LT     B4,B7,IRF3  IF J < IRN 
          SB7    B7+B1       IRN = IRN + 1
 IRF3     SX2    B4 
          LX2    2
          SX2    X2+B2
          LX2    IH.RFP      JR = 4*J+2    */ INVENTED R-NUM
          BX6    X2+X5       RF[IH] = JR   */ SET IN *IHINFO* 
          SA6    A5 
          SA4    A2+B1       R2 = TXT(R+1)
          BX6    X0*X4       RF[R2] = 0 
          SA6    A4 
          NZ     X1,IRF1     IF SIOCALL " 0  */ CALL FROM *RIO* 
  
          BX6    X2+X6       RF[R2] = JR
          SA6    A6 
          EQ     IRF1 
  
 IRF5     BSS    0
          TRACE  IRF,RLIST
          IF     DEF,/DEBUG/IRF,1 
 IH-IRFX  SNAP   *O.TREE,*B6
 FIL      EJECT 
**        SCAN THE *IH* INFO TABLE FOR INTERFERING LD/ST, ST/ST 
*         COMBINATIONS AND FORM TREE LINKS FOR THEM.
  
          MX0    -IH.IHL
          SA5    B6          IH = IHS 
          SB5    59-IH.BMP
          SA1    BDTA 
          LX1    T.EQVLP     EQVB = SHIFT(BDTA,T.EQVLP) 
  
 FIL3     SA5    A5-B2       IH = IH - 2
          LX6    B5,X5
          ZR     X5,FIL6     IF [IH] = 0   */ IF TABLE TERMINATOR 
          MI     X6,FIL3     IF BM[IH]
          SA4    A5          J = IH 
          SA3    A5-B1
          LX3    T.SUCCP
          IX2    X1+X3
  
 FIL4     SA4    A4-B2
          LX3    B5,X4
          MI     X3,FIL3     IF BM[J] 
          BX6    X4-X5       DIFF = XOR(IH,J) 
          LX6    -IH.IHP
          BX7    -X0*X6 
          NZ     X7,FIL4     IF IH[DIFF] " 0
          BX3    X4*X5
          LX6    IH.IHP-IH.RFP
          LX3    59-IH.LDP
          MI     X3,FIL4     IF LD[IH] & LD[J]
          BX7    -X0*X6 
          SA3    A4-B1       R1[J]
          NZ     X7,FIL5     IF RF[DIFF] " 0
          LX6    IH.RFP-IH.CAP
          BX7    -X0*X6 
          NZ     X7,FIL4     IF CA[DIFF] " 0
  
*         THE MEMORY REFERENCES INTERFERE, FORM A LINK BETWEEN THEM 
  
 FIL5     IX7    X2+X3
          SB3    A7 
          SA7    A7-1        T = T - 1;  [T] = TREE(EQVB,R1[IH],R1[J])
          GE     B3,B6,FIL4  IF STORE ADDR \ LOWER LIMIT
  
 FIL6     SA1    O.TREE                    */ CHECK WORKING STORAGE 
          TREE   FIL
          SA2    N.INST 
          IX1    X1+X2
          LX2    1
          SA3    N.ST 
          IX1    X1+X2
          IX2    X1+X3       TM = O.TREE + 3*N.INST + N.ST
          SX4    A7-B1
          IX1    X2-X4
          MI     X1,FIL8     IF TM < T     */ ENOUGH SPACE FOR REST 
  
          EQ     GAS         REALLOCATE 
 FIL8     SPACE  3
**        RESCAN THE *IH* INFO TABLE, SETUP INFORMATION FOR *MCG* 
*         SCAN FOR LD/ST COMBINATIONS INTO THE SAME MEMORY LOCATION 
*         WHEN THE SECOND HAS THE *SZ* BIT SET, AND SET THE *SR*
*         ( SIZE REDUCABLE ) BIT FOR IT.
  
 FIL8     SA5    B6          I = IHS
          SX1    B1 
          MX0    -IH.BMP
          LX1    D.SRP
          SA4    SIOCALL
          SB3    58-D.SZP 
          SB6    A0+B2       BASE = O.TXT + 2 
          AX4    1
          SB4    X4                        (B4) = SIOCALL - 1 
          SB7    A0                        (B7) = TXT 
  
 FIL9     SA5    A5-B2       I = I - 2
          ZR     X5,FIL11    IF [I] = 0 
          LX6    B5,X5
          MI     X6,FIL9     IF BM[I] 
  
          SA3    A5-B1
          SA2    X3+B6       DI = BASE + [I-1]
          LX6    B3,X2
          PL     X6,FIL9     IF SZ[DI] = 1 */ A 1 PARCEL INSTRCUTION
          LX2    58-D.TYP 
          PL     X2,FIL9     IF TYPE[DI] " III  */ NOT A *LD* OR *ST* 
          LX2    2+D.TYP
          SA4    A5+         J = I
  
 FIL10    SA4    A4-B2       J = J - 2
          BX6    X4-X5
          LX3    B5,X4
          BX7    -X0*X6 
          MI     X3,FIL10C   IF BM[J] 
          NZ     X7,FIL10    IF IHINFO[J] " IHINFO[I] 
  
*         IH"S,RF"S AND CA"S MATCH, SET *SR* BIT FOR MASTER MEM REF.
  
          BX6    X1+X2
          SA6    A2          SR[DI] = 1 
          ZR     B4,FIL9     IF SIOCALL < 2 
          LX5    -IH.RFP
          SX7    X5 
          NZ     X7,FIL9     IF RF[I] " 0  */ INDEXED ST
  
*         MASTER IS A REDEF OF J, I MUST BE A *ST*, SAVE *RI* THAT IS 
*         REDEFINED IN THE LINK WORD OF THE *ST* FOR *FTL*. 
  
          SA3    A4-B1       R = [J-1]
          LX4    59-IH.LDP
          MI     X4,FIL10B   IF LD[J] 
          SA3    B7+X3       R = RI[TXT+R]
 FIL10B   SA4    A2-B2       R1 = DI - 2
          SX6    X3 
          SX5    X4 
          IX7    X5-X6
          MI     X7,FIL9     IF RI[R1] < R */ ST NOT A FUNCTION OF *LD* 
  
          SA6    A2+B1       [DI+1] = R    */ SAVE *RI* OF *LD* 
          SA2    A2 
          LX1    D.RDP-D.SRP
          BX6    X1+X2       RD[DI] = 1 
          SA6    A2 
          LX1    D.SRP-D.RDP
          SX6    X3 
  
*         FORM CHAIN *TST*"S IF THEIR ARE ANY SIMILAR *IP*"S IN THE LOOP
  
          AX4    R1.OCP 
          SA3    =XNBIP 
          SX7    X4-OC.TST-1S10 
          NZ     X7,FIL9     IF OC[R1] " OC.TST 
          ZR     X3,FIL9     IF NBIP = 0   */ NO SIMILAR *IP*"S IN SEQ
  
          SA3    TSTC 
          BX6    X3+X6       [DI+1] = TSTC ! [DI+1]  */ ADD TO CHAIN
          SA6    A2+B1
          SX6    A6 
          LX6    36          TSTC = SHIFT(DI+1,36)  */ CHAIN PTS TO THIS
          SA6    A3+
          EQ     FIL9 
  
*         CONTINUE SCAN IF J IS A CONDITIONAL JUMP OR *EOS* 
  
 FIL10C   SA3    A4-B1
          ZR     X4,FIL9     IF [J] = 0 
          SA3    B6+X3       DJ = BASE + [I-1]
          LX3    59-D.TYP 
          PL     X3,FIL10    IF TYPE[DJ] = III  */ JPX OR JIN 
          SA3    A3-B2       R1J = DJ - 2 
          AX3    R1.OCP 
          SX6    X3-OC.EOS-2000B
          ZR     X6,FIL10    IF OC[R1J] = OC.EOS
          EQ     FIL9 
  
**        SCAN THE EQV LINKS AND UP THE *FT* OF PREDECESSORS TO FORCE 
*         THEM TO START BEFORE OTHER COMPUTATIONS THAT WOULD HAVE 
*         THE SAME *LST* .
  
 FIL11    SA5    A7          TI = T 
          LX1    D.FTP-D.SRP
          ERRNZ  D.EQVP-D.FTP 
          ZR     X5,IPL      IF [TI] = 0   */ NO EQUIV LINKS
  
 FIL12    SA4    B6+X5       DI = BASE + PRED[TI] 
          SA5    A5+B1       TI = TI + 1
          BX6    X4+X1       FT[DI] = FT[DI] ! 1
          SA6    A4 
          NZ     X5,FIL12    IF [TI] " 0
  
          SA3    BDTA 
          SX6    X3+
          SA6    EQVL        EQVL = BDTA   */ " 0 IF JAM AND EQV LINKS
 IPL      EJECT 
**        IPL - FORM *IP* REDEFINITION LINKS BETWEEN MEMBERS OF A CLASS 
*         OF SIMILAR *IP*"S, SO ANY REORDERING THAT *RIO* DOES WILL NOT 
*         CAUSE INCORRECT CODE TO BE GENERATED IF GRA DOES ANY ADDRESS
*         DIFFERENCING ( *MFA12* ). 
  
 IPL      SA1    TSTC 
          ZR     X1,FOL      IF TSTC = 0   */ NO INCREMENT TST"S
  
          SA2    =XO.TET
          SA3    =XO.IIT
          SA4    O.TREE 
          SB5    X2                        (B5) = TET 
          SB6    X3                        (B6) = IIT 
          SB7    X4                        (B7) = TREE
          AX1    36          I = SHIFT(TSTC,-36)
          SB4    A0+B2       BASE = O.TXT + 2 
          MX0    -D.USESL+1 
  
 IPL1     SA4    X1          LI = I;  LIW = [LI]
          SA3    A4-B2       R2W = [I-2]
          SA5    A3-B1       R1W = [I-3]
          LX3    -IH.CAP
          SA2    B5+X3       TETW = TET(CA[R2W])
          LX2    -T.ITIP
          SX3    X2          J = ITI[TETW]
          ZR     X3,IPL3     IF J = 0      */INVARIANT TEMP 
  
          SA3    B6+X3       PIW = IIT(J) 
          LX2    59-T.BIPP+T.ITIP 
          LX3    -PI.CNP     N = CN[PIW]   */ CLASS NUMBER
          SX6    X5          R = RI[R1W]   */ RI OF INCREMENT 
          PL     X2,IPL2     IF ^BIP[TETW]
  
*         BASE *IP* INCR, ALWAYS BEFORE ^BASE INCR BECAUSE OF *GPO*.
  
          SA6    B7+X3       TREE(N)  = R  */ SAVE *RI* OF INCR 
          EQ     IPL3 
  
*         ^BASE INCR, SETUP LINK WORD TO FORM REDEF LINKS FROM USES OF
*         *TLD* TO INCREMENT OF BASE IN *FTL* BY SETTING ALTERNATE
*         SUCCESSOR FIELD IN LINK WORD IF THE *TLD* IS "USED".
  
 IPL2     SA2    B7+X3       RB = TREE(N)  */ R-NUM OF BASE INCR
          SX2     X2
          LX6    T.SUCCP
          BX7    X6+X2
          SA7    A7-B1       T = T - 1;  [T] = TREE(0,R,RB) 
          SA3    B4+X4       DI = BASE + RI[LIW]  */ DESCR OF *TLD* 
          LX2    18 
          LX3    -D.USESP-1 
          BX7    -X0*X3 
          ZR     X7,IPL3     IF USES[DI] = 1  */ ONLY USED IN INCR INST 
          BX6    X2+X4       [LI] = [LI] ! SHIFT(RB,18) 
          SA6    A4 
  
 IPL3     AX4    36 
          SX1    X4          I = SHIFT(LIW,-36)  */ ADVANCE TO NEXT 
          NZ     X1,IPL1     IF I " 0      */ NOT END OF CHAIN
  
          TRACE  IPL,RLIST
 FOL      TITLE  FOL - FORM OPERAND LINKS 
**        FOL - FORM OPERAND LINKS, FORM *BMC* ( INST LINKED TO *EOQ* ) 
  
 FOL      MX0    -R1.RIL+1
          SB4    OC.RS
          LX0    1           (X0) = R-NUM EXTRACTION MASK ( A0 => 0 ) 
          SB5    A0+B2       BASE = O.TXT + 2 
          SB6    B0          ZPA = 0       */ ZERO PRED ADDRESS 
          SB7    B0          N.RS = 0      */ N. *RS"S* 
          SA4    A0+B2       DI = O.TXT + 2 
          SX6    A7 
          SA6    TF          TF = T        */ LWA + 1 OF OPERAND LINKS
          MX1    D.TYL
          SA3    O.TREE 
          MX6    0
          SA6    X3          BMC = O.TREE;  [BMC] = 0 
          SA0    X3 
          EQ     FOL2 
  
*         SAVE ADDR OF *SINK* INSTRUCTION ON *BMC* LIST 
  
 FOL1     SX7    A4 
          PX6    "OC",X7
          SA6    A0+B1       BMC = BMC + 1;  [BMC] = PK(OC,DI)
          SA0    A0+B1
  
*         GET NEXT INSTRUCTION, AND JUMP TO APPROPIATE PROCESSOR
  
 FOL2     SA5    A4+B2       R1 = DI + 2
          SA4    A5+B2       DI = R1 + 2
          LX4    58-D.TYP 
          BX7    X1*X4
          SX6    A4-B5       LA = DI - BASE 
          LX6    T.SUCCP
          NZ     X7,FOL5     IF TYPE[DI] " I
  
*         PROCESS TYPE I INSTRUCTION
  
          LX5    -R1.RKP
          BX3    -X0*X5 
          LX5    R1.RKP-R1.RJP
          BX2    -X0*X5 
          LX5    R1.RJP-R1.RIP
          ZR     X3,FOL3     IF RK[R1] = 0
          IX7    X6+X3
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RK[R1])
 FOL3     IX3    X2-X3
          LX4    1+D.TYP-D.^DP
          ZR     X2,FOL4     IF RJ[R1] = 0
          ZR     X3,FOL4     IF RJ = RK 
          IX7    X6+X2
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RJ[R1])
 FOL4     PL     X4,FOL2     IF DEF[DI] 
          UX3    "OC",X5
          BX5    -X0*X5 
          IX7    X6+X5
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RI[R1])
          EQ     FOL1 
  
 FOL5     UX3    "OC",X5
          IX7    X4+X4
          MI     X4,FOL8     IF TYPE[DI] = III ! IV 
  
**        TYPE II PROCESSING ( S, FMA, CLR , DEF, RS )
  
          LX4    1+D.TYP-D.PIP
          MI     X4,FOL5A    IF PI[DI]     */ RS OR DEF 
          SX2    B6 
          IX7    X6+X2
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,ZPA) 
          EQ     FOL2 
  
 FOL5A    BX3    -X0*X5 
          EQ     "OC",B4,FOL6      IF OC[R1] = OC.RS
          SB6    A4-B5       ZPA = LA 
          EQ     FOL1 
  
*         PROCESS REGISTER STORE
  
 FOL6     LX5    59-R1.INP
          SB7    B7+B1       N.RS = N.RS + 1
          PL     X5,FOL7     IF IN[R1] = 0
  
          SX3    X3-4 
          IX7    X6+X3
          SA7    A7          T = TREE(LA,LA-4) */ ERASE BAD *RJ* LINK 
          SX6    A7 
          SA6    A4+B1       [DI+1] = T 
          EQ     FOL1 
  
 FOL7     IX7    X6+X3
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RI[R1])
          SX6    A7 
          SA6    A4+B1       [DI+1] = T 
          EQ     FOL1 
  
*         PROCESS TYPE III / IV INSTRUCTIONS
  
 FOL8     MI     X7,FOL10    IF TYPE[DI] = IV 
  
          SA3    A5+B1       R2 = R1 + 1
          LX4    1+D.TYP-D.^DP
          BX5    -X0*X5      RI = RI[R1]
          LX3    -IH.RFP
          MI     X4,FOL9     IF ^D[DI]
  
          BX3    -X0*X3      RN = (RF[R2]/2)*2
          NZ     X3,FOL8A    IF RN " 0
          SX3    B6          RN = ZPA 
 FOL8A    IX7    X6+X3
          SA7    A7-B1       T = T + 1;  [T] = TREE(LA,RN)
          EQ     FOL2 
  
 FOL9     BX3    -X0*X3 
          IX7    X6+X5
          LX4    1+D.^DP+58-D.TYP 
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RI[R1])
          ZR     X3,FOL10    IF RF[R2] = 0
          IX7    X6+X3
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,RF[R2])
  
 FOL10    LX4    1+D.TYP-D.BMP
          PL     X4,FOL1     IF ^BM[DI] 
          SB6    A4-B5       ZPA = LA 
          NZ     "OC",FOL1   IF OC[R1] " 0
  
          TREE   FOL
 FTL      TITLE  FTL - FORM TERMINAL ( END OF SEQ ) LINKS 
**        FTL - FORM TERMINAL LINKS.
*         LINK DATA SINKS ( STORES ) AND BOUNDARY MARKERS ( JUMPS, LAB
*         DEFS, ETC ) TO LATER BOUNDARY MARKERS.
*         FORM REDEF LINKS FOR REG STORES THAT REDEFINE A REGISTER. 
  
          SA1    N.INST                    */ CHECK WORKING STORAGE 
          SB3    X1 
          SB3    A0+B3
          SB3    A7-B3
          SX1    B2-B3
          PL     X1,GAS      IF BMC + N.INST + 2 \ T
  
          SA1    A7          TFO = T       */ FWA OF OPERAND LINKS
          SX1    B6 
          SA5    A0+B1       II = BMC + 1 
          LX1    T.SUCCP     LA = ZPA      */ LA = *EOQ* ADDR 
          SA3    A0 
          SA0    B0          FBM = 0
          BX6    X3 
          SA6    LBM         LBM = [BMC]   */ DI OF LAST *BM* 
          MX4    23 
          MX6    0
          ZR     B7,FTL3     IF N.RS = 0
  
          SA3    BDTA 
          SA6    REGS 
+         LX4    1           FOR I = 0 TO 23;  REGS(I) = 0
          SA6    A6+B1
          MI     X4,* 
  
*         IF JAM MODE, THEN LINK THE *RI* IN UJP AND FULL LOCK *RS"S* 
*         TO THE FOLLOWING RJX/EOQ SO *SNU* WILL CORRECTLY SET THE NEXT 
*         USE ADDRESS, IN CASE THE PRED HAS TO BE REISSUED. 
  
          ZR     X3,FTL3     IF BDTA = 0   */ NOT JAM MODE
          SA4    A5          I = II 
          BX6    X1          JLA = LA 
          SB7    OC.JIN 
          EQ     FTL1 
  
 FTL0     SB3    X4 
          SX6    B3-B5       JLA = [I] - BASE 
          LX6    T.SUCCP
  
 FTL1     SA4    A4-B1       I = I - 1
          ZR     X4,FTL3     IF [I] = 0 
          UX5    "OC",X4
          GE     "OC",B7,FTL0      IF OC[I] \ OC.JIN
          NE     "OC",B4,FTL1      IF OC[I] " OC.RS 
  
          SA3    X4-2        R1 = [I] - 2 
          BX7    -X0*X3      R = RI[R1] 
          LX3    59-R1.SOP-SO.LKP 
          MI     X3,FTL1     IF SOLK[R1] = 1!3  */ ^(UJP ! FULL LOCK) 
          IX7    X6+X7
          SA7    A7-B1       T = T - 1;  [T] = TREE(JLA,R)
          EQ     FTL1 
 FTL      SPACE  3,14 
*         FORM THE BOUNDARY MARKER LINKS
  
 FTL2     SX1    A4-B5       LA = DI - BASE 
          SA0    A4-B5       FBM = LA 
          LX1    T.SUCCP
  
 FTL3     SA5    A5-B1       II = II - 1
          SB3    A5+40B 
          SB3    A7-B3
          MI     B3,GAS0     IF II + 40 > T  */ POSSIBLE TABLE OVERLAP
          SA4    X5          DI = [II]
          ZR     X5,FTL6     IF DI = 0
          UX3    "OC",X5
          SX6    A4-B5       LINK = DI - BASE 
          IX7    X1+X6
          LX4    59-D.BMP 
          SA7    A7-B1       T = T - 1;  [T] = TREE(LA,LINK)
          MI     X4,FTL2     IF BM[DI]
          SA2    A4+B1       LW = [DI+1]
          EQ     "OC",B4,FTL3C     IF OC[R1] = OC.RS
          ZR     X2,FTL3     IF LW = 0     */ *ST* NOT A REDEF
  
*         ST IS A REDEFINITION OF PREVIOUS LD/ST, *RD* IS THE R-NUMBER
*         BEING REDEFINED.  FORM REDEF LINKS TO FORCE ALL USES OF *RD*
*         TO COME BEFORE THIS *ST*. 
  
          SA3    A4-B2       R1 = DI - 2
          SB7    X2          RD = RI[LW]   */ R-NUM BEING REDEF 
          AX2    18 
          BX5    -X0*X3      R = RI[R1]    */ SUCCESSOR 
          SX2    X2          ARD = SHIFT(LW,-18)  */ BASE INCR R-NUM
          SB7    -B7                       (B7) = -RD 
          SB6    0           RD2 = 0
          ZR     X2,FTL3B    IF ARD = 0    */ NO ALTERNATE
          SB6    X5          RD2 = R       */ NO LINKS FROM RD2 TO ARD
          SX5    X2          R = ARD
  
 FTL3B    MX6    0
          SA6    A2          [DI+1] = 0    */ CLEAR LINK WORD 
          SX2    B1 
          LX5    T.SUCCP
          SA4    A1          TI = TFO 
          LX2    T.RDLP 
          BX6    X5+X2
          LX5    -T.SUCCP 
          SA6    EQVL        EQVL = 1 
  
*         SEARCH OPERAND LINKS FOR USES OF *RD* AND FORM REDEF LINKS
  
 FTL3A    BX7    X4          TL = [TI]
          SX2    X4+B7
          AX7    T.SUCCP
          SA4    A4+B1       TI = TI + 1
          SB3    X7+B7
          LE     B3,FTL3     IF SUCC[TL] @ RD  */ END OF SEARCH 
          BX3    X5-X7
          NZ     X2,FTL3A    IF PRED[TL] " RD  */ NOT A USE OF *RD* 
          ZR     X3,FTL3A    IF SUCC[TL] = R  */ DONT FORM LINKS TO SELF
          SB3    X7 
          EQ     B3,B6,FTL3A IF SUCC[TL] = RD2  */ NO LINK BACK TO INCR 
  
          BX7    X6+X7
          SA7    A7-B1       T = T - 1;  [T] = TREE(RDL,R,SUCC[TL]) 
          ZR     B6,FTL3A    IF RD2 = 0    */ NO ALTERNATE
  
*         FORM REDEF LINK FROM NON-BASE INCR TO USE 
  
          LX7    -T.SUCCP 
          BX7    X7-X5
          SX2    B6 
          BX7    X2+X7
          LX7    T.SUCCP
          SA7    A7-B1       T = T - 1;  [T] = TREE(RDL,RD2,SUCC[TL]) 
          EQ     FTL3A
 FTL      SPACE  1,10 
*         REGISTER STORE PROCESSING 
  
 FTL3C    SA3    A4-B2       R1 = DI - 2
          BX5    -X0*X3      R = RI[R1] 
          MX2    -SO.REGL 
          LX3    -R1.SOP
          BX7    -X2*X3      REGNO = SOREG[R1]
  
 FTL3D    SA3    REGS+X7     L = REGS(REGNO) */ ORD OF LAST RS INTO REGN
          SA6    A3          REGS(REGNO) = LINK 
          SA2    A4+B1       TA = [DI+1]
          SA4    A4-B1       R2 = DI - 1
          MX6    0
          SA6    A2          [DI+1] = 0 
          LX4    -IH.RFP
          SX4    X4 
          ZR     X4,FTL4     IF RF[R2] = 0
          BX6    X5          LINK = R 
          SX5    X4          R = RF[R2] 
          SA2    TF          TA = TF
          EQ     FTL4A
  
 FTL4     ZR     X3,FTL3     IF L = 0      */ NO PREVIOUS *RS* INTO REGNO 
          SX6    X3-4        LINK = L - 4 
          LX3    T.SUCCP
          IX7    X3-X1
          MI     X7,FTL4A    IF L < LA     */ LAST RS IN THIS BLOCK 
  
          SA4    A4-B1       R1 = R2 - 1
          LX4    59-R1.SOP-SO.LKP 
          MI     X4,FTL3     IF SOLK[R1] = 1 ! 3  */ TEMP OR RJRS LOCK
  
*         2 *RS*"S INTO THE SAME REGISTER IN A BLOCK, MAKE THE
*         SECOND A REDEFINITION OF THE FIRST. 
  
 FTL4A    SA2    X2 
          SA3    BDTA 
          BX5    -X5
          LX6    T.SUCCP           (X6) = LINK
          SB7    X5                (B7) = R 
          LX3    T.RDLP 
          BX6    X6+X3       EQVB = SHIFT(BDTA,T.RDLP)
          SA6    EQVL        EQVL = 1 
 FTL      SPACE  1,10 
*         SEARCH FOR USES OF THE R-NUMBER IN INSTRUCTIONS FOLLOWING THE 
*         CURRENT *RS*, AND FORM LINKS BETWEEN THEM AND THE INSTRUCTIION
*         PRECEEDING THE SECOND *RS*. 
  
 FTL5     SA2    A2-B1       TA = TA - 1
          BX7    X2-X6
          SX3    X2+B7
          AX7    T.SUCCP
          ZR     X7,FTL3     IF SUCC[TA] = LINK  */ END OF SEARCH 
          NZ     X3,FTL5     IF PRED[TA] " R     */ IF NOT A USE
          AX2    T.SUCCP
          IX7    X6+X2
          SA7    A7-B1       T = T - 1;  [T] = TREE(EQVB,LINK,SUCC[TA]) 
          EQ     FTL5 
  
 FTL6     SA4    N.INST 
          BX7    X1 
          SA7    A7-B1       T = T - 1;  [T] = TREE(FBM,0)
  
          SB6    X4                        */ CHECK WORKING STORAGE 
          SB6    A5+B6
          SB7    A7          FTREE = T
          SX1    B6-B7
          GE     B6,B7,GAS   IF O.TREE + N.INST \ T 
          TREE   FTL
  
*         SORT THE TEMPORARY TREE TO GROUP EDGES BY SUCCESSOR 
  
          SA2    TREEL
          SA3    EQVL 
          SX6    A0 
          SX7    A7 
          SA6    FBM
          SA7    FTREE       FTREE = T
          IX1    X2-X7       LEN = TREEL - FTREE
          NZ     X3,FTL8     IF EQVL " 0
          CALL   SHL         SORT( TREE , [SUCC,PRED] ) 
          EQ     FTL10
  
*         JAM MODE AND EQUIV LINKS, USE MASK SORT 
  
 FTL8     MX0    -2 
          SB6    B0 
          MX5    0
          LX0    T.EQVP 
          CALL   SST         SORT( TREE , [SUCC,PRED] ) 
  
 FTL10    BSS    0
 FJL      TITLE  FJL - FORM JUMP LINKS
**        FJL - FORM LINKS TO JUMPS FROM BELOW TO CONSTRAIN INSTRUCTIIONS 
*         TO BE TIED TO THE BLOCK THEY APPEAR IN. 
  
          SA1    FTREE
          SA3    O.TREE 
          SA4    FBM
          SA5    L.TXT
          SX6    X4+8 
          MX7    0
          IX6    X6-X5
          ZR     X4,FJL      IF FBM = 0    */ NO BOUNDARY MARKERS 
          NZ     X6,FJL1     IF FBM+8 < L.TXT  */ SEQ HAS AN INTERIOR JP
  
*         NO JUMPS
  
 FJL      BX6    X1 
          SA6    A3          O.TREE = FTREE 
          SA7    X1-1        [FTREE-1] = 0
          EQ     FJL6 
  
*         MOVE THE TEMP TREE DOWN AND ADD JUMP LINKS WHERE NECESSARY
*         ADD *JP* LINK IF ALL PREDECESSORS LIE BELOW THE *JP*
  
 FJL1     SA5    X1-1        TI = FTREE - 1 
          SA2    O.TXT
          MX0    -T.SUCCL 
          SB7    X4          JPL = FBM
          SB5    X2+2        BASE = O.TXT + 2 
          SB6    60-T.SUCCP 
          LX0    T.SUCCP
          SA7    X3          TS = O.TREE;  [TS] = 0 
          SX6    X3+B1
          SA6    A3          O.TREE = O.TREE + 1
  
*         MOVE LINKS PRECEEDING THE FIRST *BM* DOWN 
  
 FJL2     SA5    A5+B1       TI = TI + 1
          LX4    B6,X5
          BX7    X5 
          SB3    X4 
          SA7    A7+B1       TS = TS + 1;  [TS] = [TI]
          LE     B3,B7,FJL2  IF SUCC[TI] @ JPL
  
*         SCAN THE SET OF EDGES FOR EACH INSTRUCTION ( GROUPED BY SUCC )
*         AND IF THE MAX OF THE PRED < R, LINK TO A NODE BELOW THE
*         LAST ENCOUNTERED *BM* , FORM A LINK TO IT.
  
 FJL3     BX6    -X0*X5      R = SUCC[TI] 
          LX4    B6,X5
          SB3    X4 
          SB4    B0          M = 0
  
 FJL4     SB2    X5 
          GT     B2,B3,FJL4A IF PRED[TI] > R  */ A REDEFINITION LINK
          SB4    X5          M = PRED[TI] 
 FJL4A    SA5    A5+1        TI = TI + 1
          BX4    X6-X5
          LX7    X5 
          BX3    -X0*X4 
          SA7    A7+B1       TS = TS + 1;  [TS] = [TI]
          ZR     X3,FJL4     IF SUCC[TI] = R
  
          SX3    B7+
          SA2    B5+B3       DI = BASE + R
          IX6    X6+X3
          GE     B4,B7,FJL5  IF M \ JPL 
          SA6    A7          [TS] = TREE(R,JPL) 
          SA7    A7+B1       TS = TS + 1;  [TS] = [TI]
  
 FJL5     LX2    59-D.BMP 
          PL     X2,FJL3     IF ^BM[DI] 
          SB7    B3          JPL = R
          NZ     X5,FJL3     IF [TI] " 0
  
          SX6    A7          TREEL = TS 
          SA6    TREEL
  
          IF     DEF,/DEBUG/FJL,1 
 TREE-FJL SNAP   *O.TREEL,*TREEL
  
 FJL6     SA1    SIOCALL
          ZR     X1,CIP      IF SIOCALL = 0 
  
*         BDT CALLED FROM *RIO*, SET *TREE* LENGTH AND EXIT 
  
          SA2    O.TREE 
          SA3    TREEL
          IX6    X3-X2
          SA6    L.TREE      L.TREE = TREEL - O.TREE
          MX7    0
          SA7    A1          SIOCALL = 0
          EQ     BDT
 CIP      TITLE  CIP - CALCULATE INSTRUCTION PRIORITIES 
**        CIP - CALCULATE INSTRUCTION PRIORITIES
*         CALCULATES TIME TO TRAVEL FROM *EOQ* TO *BOS* OF NETWORK
*         THROUGH THE NODES. NODE TIME IS EITHER THE INSTRUCTION TIME 
*         FUN UNIT ) OR 1 ( FOR A NODE DEPTH CALCULATION ). 
*         THEN CHANGE THE THE "PRIORITIES" INTO "LATE START TIMES", 
*         WHERE  LST[LI] = SEQTIME - PRIOR[LI] , IS THE LATEST TIME 
*         THAT AN INSTRUCTION MAY START WITHOUT LENGTHING THE SCHEDULE. 
  
 CIP      MX0    -D.FTL 
          SA1    BDTA 
          LX0    D.FTP
          SA4    O.TXT
          SB4    I.PRIORP-D.FTP 
          SA0    X4+3        BASE = O.TXT + 3 
          NZ     X1,CIP6     IF BDTA " 0   */ JAM MODE
  
 CIP1     SA3    TREEL
          SA7    A1+         LBM = JPA
          SA5    X3-1        TI = TREEL - 1 
          MX1    -D.USESL 
          LX1    D.USESP
          SB7    60-T.SUCCP 
          SB6    X5          P = PRED[TI] 
          LX5    -T.SUCCP 
          SB5    X5          R = SUCC[TI] 
          SB3    A5          TL = TI
          SA4    A0+B5       PI = BASE + R
          SA3    A0+B6       PTI = BASE + P 
          SA2    A4-B1       DI = PI - 1   */ FT[*EOQ*] = 1 
  
*         CALCULATE TIME TO REACH THIS INSTRUCTION
  
 CIP2     BX6    -X0*X2 
          LX5    B4,X6
          IX7    X4+X5       TOTIME = PRIOR[PI] + FT[DI]
          BX6    -X1*X2 
  
*         PROPAGATE TIME TO REACH THIS INSTRUCTION TO ITS PREDECESSORS
  
 CIP3     SA5    A5-B1       TI = TI - 1
          IX4    X3-X7
          SB6    X5          P = PRED[TI] 
          LX3    B7,X5
          SB2    X3 
          PL     X4,CIP4     PRIOR[PTI] = MAX( PRIOR[PTI] , TOTIME )
          SA7    A3 
 CIP4     SA3    A0+B6       PTI = BASE + P 
          EQ     B2,B5,CIP3  IF SUCC[TI] = R
  
*         SET PRIORITY INFO IN LAST WORD OF INSTRUCTION 
  
          LX6    I.USESP-D.USESP
          SX4    A5-B3       NPRED[PI] = -( TI - TL ) 
          BX7    X7+X6       USES[PI] = USES[DI]
          LX4    I.NPREDP 
          IX6    X7-X4
          SA6    A4 
  
          SB5    B2          R = SUCC[TI] 
          SA4    A0+B2       PI = BASE + R
          SB3    A5          TL = TI
          SA2    A4-B1       DI = PI - 1
          NZ     X5,CIP2     IF [TI] " 0
          BX7    X4 
          AX7    I.PRIORP 
          SA7    SEQTIME     SEQTIME = PRIOR[PI]  */ TIME TO REACH *BOS*
  
*         CONVERT THE PRIORITIES TO *LATE START TIMES*, SET THE *LST"S* 
*         OF *RS* INSTRUCTIONS TO ZERO TO FORCE THEM TO BE ISSUED 
*         IMMEDIATELY AFTER THEIR PREDECESSORS IN *MCG*.
  
          MX0    -I.PRIORL
          LX7    I.PRIORP 
          SA1    N.INST 
          SB4    4
          SB2    X1-1        I = N - 1
          SA4    A4+B4       LI = BASE + 4
          LX0    I.PRIORP 
          SB5    OC.RS
          BX5    -X0*X4      PR = PRIOR[LI] 
  
 CIP5     IX2    X7-X5       LST[LI] = SEQTIME - PR 
          SA1    A4+B1       R1 = LI + 1   */ R1 WORD OF NEXT 
          BX3    X0*X4
          SA4    A4+B4       LI = LI + 4
          IX6    X2+X3
          SB2    B2-B1       I = I - 1
          UX1    B3,X1
          BX5    -X0*X4      PR = PRIOR[LI] 
          SA6    A4-B4
          NE     B3,B5,CIP5A IF OC[R1] " OC.RS
          BX5    X7          PR = SEQTIME  */ FORCE LST = 0 
 CIP5A    NZ     B2,CIP5     IF I " 0 
  
 DBG      IF     DEF,/DEBUG/TREE
          SNAPRL BDT-X
          SA1    O.TREE 
          SA5    TREEL
          IX6    X5-X1
          BX7    X1 
          SA6    L.TREE      L.TREE = TREEL - O.TREE
          SA7    DTSA+1 
          SX6    A0-3 
          SA6    A7+2 
          SA1    DTSA 
          RJ     =XDMPTREE   SNAP THE DEPENDENCY TREE 
          RJ     =XRESET= 
 DBG      ENDIF 
  
          EQ     SIT
 CIP-JAM  EJECT 
**        JAM MODE "PRIORITY" CALCULATION 
*         ELIMINATE DUPLICATE EDGES FROM THE TREE. ( FOR MCG/RIL )
*         REFORMAT IT AS A USES INDEX TABLE.
*         SETUP THE USES, LST AND NPRED FIELDS IN THE LINK WORD.
  
 CIP6     SA3    O.TREE 
          MX1    -D.USESL 
          SX0    B1+B1       PR = 2 
          LX1    D.USESP
          SB7    X3          TF = O.TREE
          MX7    0
          LX0    U.LSTP 
          SA7    B7-B1       UI = O.TREE - 1;  [UI] = 0 */ STORE ADDR 
          SB6    60-T.SUCCP 
          SA5    X3          TI = O.TREE   */ FETCH ADDR
          SB5    B7-B1       UF = O.TREE - 1
          SB2    I.LSTP-U.LSTP
          BX2    X0 
          SB3    A0-B1
  
*         COUNT PREDECESSORS OF CURRENT SUCCESSOR 
  
 CIP7     BX6    X5          TL = [TI]
          SA5    A5+B1       TI = TI + 1
          LX7    B6,X6
          BX4    X6-X5
          ZR     X4,CIP7     IF [TI] = TL  */ DUP EDGE
  
          IX7    X0+X7
          AX4    T.SUCCP
          SA7    A7+B1       UI = UI + 1;  [UI] = SIT(PRED[TL],PR,SUCC[TL]) 
          ZR     X4,CIP7     IF SUCC[TI] = SUCC[TL] 
  
*         SETUP INFO IN LINK WORD 
  
          SA3    B3+X7       DI = O.TXT+2 + SUCC[TL]
          SX4    A7-B5       NPRED[LW] = UI - UF
          LX7    B2,X0       LST[LW] = PR 
          LX4    I.NPREDP 
          BX3    -X1*X3 
          IX0    X0+X2       PR = PR + 2
          LX3    I.USESP-D.USESP   USES[LW] = USES[DI]
          BX4    X4+X7
          SB5    A7          UF = UI
          IX6    X4+X3
          SA6    A3+B1       LW = DI + 1
          NZ     X5,CIP7     IF [TI] " 0
  
          BX6    X0 
          SA6    A0          LST[BASE] = PR 
          MX7    0
          SA7    A7+B1       UI = UI + 1;  [UI] = 0 
          SX6    A7 
          SA6    TREEL       TREEL = UI 
          SX1    A7-B7       L.TREE = UI - O.TREE 
          BX7    X1 
          SA3    EQVL 
          ZR     X3,SIT1A    IF EQVL = 0
  
          MX0    -2 
          SB6    B0 
          MX5    0
          LX0    U.EQVP 
          SA7    L.TREE 
          CALL   SST         SORT( TREE , [PRED,SUCC] ) 
          EQ     SIT1B
 SIT      SPACE  2           SIT
**        SIT - REFORMAT THE TREE AS A *USES INDEX* TABLE.
*                24/PRED,18/LST[SUCC],18/SUCC 
  
 SIT      SA1    TREEL
          SA5    X1-1        UI = TREEL - 1 
          MX0    -I.LSTL
          SB4    A0          BASE = O.TXT + 3 
          LX0    I.LSTP 
          SB5    60-T.SUCCP 
          LX6    B5,X5
  
 SIT1     SA4    B4+X6       PW = BASE + SUCC[UI] 
          SA5    A5-B1       UI = UI - 1
          BX3    -X0*X4 
          LX3    U.LSTP-I.LSTP
          IX7    X3+X6       LST[UI+1] = LST[PI]
          LX6    B5,X5
          SA7    A5+B1
          NZ     X5,SIT1     IF [UI] " 0
  
          SX6    A5+B1
          SB7    A5+B1       O.TREE = UI + 1
          IX7    X1-X6       L.TREE = TREEL - O.TREE
          BX1    X7 
 SIT1A    SA7    L.TREE 
          CALL   SHL         SORT( TREE , [PRED,LST[SUCC],SUCC] ) 
 SIT      SPACE  2
*         NOW SETUP THE USES INDEX INFO IN THE LINK WORD OF THE INST
  
 SIT1B    MX0    1
          SB3    U.PREDP
          LX0    1+U.LASTP
          SA5    B7          UI = O.TREE
          MX1    -U.PREDL 
          SB6    B7          UF = O.TREE
          LX1    U.PREDP
          SB5    A0          BASE = O.TXT + 3 
          EQ     SIT3 
  
 SIT2     BX6    X2+X3       [LW] = UINFO(USES,INDX,LST,NPRED)
          SA6    A3+
  
 SIT3     LX4    X5          UL = UI
          SA5    A5+B1       UI = UI + 1
          BX6    X4-X5
          BX7    -X1*X6 
          ZR     X7,SIT3     IF PRED[UI] = PRED[UL] 
  
          AX6    B3,X4
          SX2    B6-B7       INDX = UF - O.TREE 
          BX7    X0+X4       LAST[UI-1] = 1 
          SA3    B5+X6       LW = BASE + PRED[UL] 
          LX2    I.INDXP
          SB6    A5          UF = UI
          SA7    A5-B1
          NZ     X5,SIT2     IF [UI] " 0
          BX6    X2+X3
          SA6    A3 
  
 DBG      IF     DEF,/DEBUG/BDT 
          SNAPRL BDT-X
          SA2    O.TREE 
          SX7    A0-3 
          BX6    X2 
          SA6    DTSA+1 
          SA7    A6+2 
          SA1    DTSA 
          CALL   DMPSIT 
          CALL   RESET= 
 DBG      ENDIF 
          EQ     BDT
  
 .T       IFNE   TEST,0 
          USE    DEBUG
 DTSA     CON    DTSB,0,L.TREE
          BSSZ   2
 DTSB     BSSZ   1           SNAP COUNT 
          USE    0
 .T       ENDIF 
 GAS      SPACE  3           GAS
**        GAS - GET ADDITIONAL SPACE TO BUILD THE TREE AND RESTART
*         NOTE - THIS SUBROUTINE SHOULD ALMOST NEVER BE CALLED IF THE 
*         INITIAL STORAGE REQUEST IS SUFFICIENT.
*         ENTRY  (X1) = MIN SPACE NEEDED
*         EXIT   *TREE* SPACE INCREASED, POINTERS ADJUSTED, TO *FIL*
  
 GAS0     SX1    140B 
  
 GAS      SX1    X1+40B 
          ALLOC  TREE,X1     GET SPACE
          SA5    O.TXT
          SX3    X3-1 
          IX6    X2+X3
          SA6    TREEL
          SA0    X5          (A0) = O.TXT 
          SB2    B1+B1       (B2) = 2 
          SB4    B2+B2       (B4) = 4 
          SX7    X3-70000B
          MI     X7,FIL      IF L.TREE < 70K
  
          LISTL  BDTM,L.BDTM LIST ERROR MESSAGE 
          EQ     =XPS2ABT 
  
 BDTM     DIS    ,/ * PROGRAM CONTAINS SEQUENCES THAT ARE TOO LONG, CANN
,OT BE COMPILED / 
 L.BDTM   EQU    *-BDTM 
  
          QUAL
 RIO      TITLE  RIO - RESET INSTRUCTION ORDER
**        RIO - RESET INSTRUCTION ORDER 
* 
*         RIO REORDERS THE INSTRUCTIONS TO BRING THEM TO AN ORDER THAT
*         IS "MINIMUM" WIDTH WITH RESPECT TO ITS X-REGISTER 
*         REQUIREMENTS.  THE ALGORITHM USED HERE IS STRAIGHT FROM 
*         AHO-ULLMAN VOLUME II, AND ACHIEVES A MINIMUM ONLY IN THE
*         CASE OF NO MULTIPLE USES. 
* 
*         ENTRY  SEQUENCE TO BE REORDERED IN *TXT*, LINK WORDS ARE ZERO,
*                USES COUNTS AND PRECEDENCE BITS SET IN DESCRIPTORS.
*                (X6) = RMODE, 0 IF CALL FROM MCG, 1 IF CALL FROM GPO 
* 
*         EXIT   (X6) = MAX REG WIDTH OF THE SEQUENCE 
*                *REGW* FIELD SET IN THE DESCRIPTORS OF ALL INSTRUCTIONS. 
*                LINK WORDS CLEARED.
  
*         JT. - RIO TREE AFTER REFORMATTING 
  
          DESCRIBE JT.,60    JT(SUCC,LVL,PRED)
 SUCC     DEFINE 18 
          DEFINE 6
 LVL      DEFINE 18          LEVEL OF PRED  ( NODE LABEL OR WEIGHT )
 PRED     DEFINE 18 
  
*         I. - FORMAT OF LINK WORD DURING DEPTH FIRST SEARCH ( *SIO* )
  
          DESCRIBE I.,60     LW(FLAGS,PRI,LVL,NP) 
 MI       DEFINE 1           MARKED INSTRCUTION ( VISITED ) 
 II       DEFINE 1           ISSUED INSTRUCTION 
 RDST     DEFINE 1           =1 IF A REDEF ST BELOW INST IN THE STACK 
 STCP     DEFINE 1           =1 IF ST CHAIN PROCESSED 
          DEFINE 2
 PRI      DEFINE 18          ADDRESS OF PRED LIST IN *TREE* 
 LVL      DEFINE 18          LEVEL / ST CHAIN POINTER 
 NP       DEFINE 18          N.PRED NOT YET VISITED 
  
 OI       DEQU   NP          OUTPUT INDEX ( FINAL ORED OF INSTRUCTION ) 
  
 MIN.PR   EQU    10B         MIN PRIORITY FOR NON-TERMINAL INSTRUCTIONS 
 RIO      SPACE  2
 RIO      ENTRY. ** 
          NZ     X6,RIO1     IF RMODE " 0  */ CALL FROM *GPO* 
          SA1    =XHBI
          ZR     X1,SIO10    IF HBI = 0    */ OUTSIDE OF ALL LOOPS
  
 RIO1     SA6    RMODE
          SX7    X6+B1
          MX6    0
          SA7    SIOCALL
          CALL   BDT         FORM THE DEPENDENCY GRAPH
  
*         ALLOCATE EXTRA SPACE IN *TREE* FOR THE STACK, AND MOVED INSTS.
  
          SA3    N.INST 
          SA4    L.TREE 
          SA5    L.TXT
          SB3    X3+B1
          IX1    X5-X4
          SB4    X1+B1
          GT     B4,B3,RIO2  L = MAX( N.INST+2 , L.TXT - L.TREE ) 
          SX1    B3+B1
 RIO2     ALLOC  TREE,X1     ALLOC( TREE , L )
          MX6    0
          SA0    X2                        (A0) = TREE
          SA6    X2+B6       TREE(OLD(LTREE)) = 0 
 RIO      SPACE  2,14 
*         REFORMAT THE TREE, CALCULATE THE INSTRUCTION NODE LABELS AS 
*         PER AHO-ULLMAN, SETUP LINK WORDS FOR DEPTH FIRST SEARCH.
  
          MX7    2
          SA4    O.TXT
          SB2    MIN.PR                    (B2) = MIN.PR
          SX6    B2 
          SB7    X4+3        TB = TXT + 3 
          LX6    I.LVLP 
          BX7    X7+X6
          SA7    B7          [TB] = LW(II,MI,0,MIN.PR,0)
          MX0    -T.SUCCL 
          SB6    A0          TF = TREE
          LX0    T.SUCCP
          MX1    0           DLV = 0       */ DIFFERENCE OF LEVELS
          SX2    B2          LLV = MIN.PR  */ LAST *LV* 
          SB4    B2          MLV = MIN.PR  */ MAX LVL OF PRED 
          SA5    A0          TI = TREE
          SB5    B7-B1       DB = TB - 1
          EQ     RIO5 
  
*         STORE REFORMATTED EDGE, ADVANCE TO NEXT EDGE
  
 RIO4     SA7    A5          [TI] = TN
          BX4    X5          TL = [TI]
          SB4    B3          MLV = LV 
          SA5    A5+B1       TI = TI + 1
          BX6    X4-X5
          BX7    -X0*X6 
          NZ     X7,RIO6     IF SUCC[TI] " SUCC[TL] 
  
*         REFORMAT EDGE, UPDATE DLV, MLV
  
 RIO5     LX5    -T.PREDP    R = PRED[TI] 
          SA3    B7+X5       LI = TB + R
          LX3    -I.LVLP     LV = LVL[LI] 
          BX2    X2-X3
          BX1    X1+X2       DLV = DLV ! XOR(LLV,LV)
          SB3    X3 
          SX2    X3          LLV = LV 
          SX6    X5 
          LX5    T.PREDP
          LX6    JT.PREDP 
          BX4    -X0*X5 
          LX4    JT.SUCCP-T.SUCCP 
          SX3    X3 
          BX6    X4+X6
          LX3    JT.LVLP
          BX7    X6+X3       TN = JT(SUCC[TI],LV,R) 
          GE     B3,B4,RIO4  IF LV \ MLV
  
*         LV < MLV , SWAP EDGES 
  
          SA4    A5-B1       TLL = [TI-1] 
          SB3    B4+         LV = MLV 
          SA7    A4          [TI-1] = TN
          BX7    X4          TN = TLL 
          EQ     RIO4 
  
*         TERMINATE EDGE GROUP, INITIALIZE FOR NEW GROUP
  
 RIO6     SX6    B6          PRI = TF 
          SX3    A5-B6       NP = TI - TF  */ N.PRED
          LX6    I.PRIP 
          LX3    I.NPP
          SX1    X1 
          BX7    X6+X3
          LX4    -T.SUCCP    S = SUCC[TI] 
          NZ     X1,RIO7     IF DLV " 0    */ PRED AT DIFF LEVELS 
          AX3    I.NPP+1
          ZR     X3,RIO7     IF NP = 1
          SB4    B4+B1       MLV = MLV + 1
  
*         IF INSTRUCTION IS TERMINAL ( ST OR *PRS* ) THEN ADJUST *LVL*
*         SO THE ORDER OF THE INSTRUCTIONS WILL BE - ST"S, PRS TO X0,6,7
*         AND PRS TO A LD-REG. IF THE INSTRUCTION PRS TO A B-REG AND IT 
*         IS A TEMP LOCK, THEN SET *LVL* TO 0 TO FORCE IT TO COME 
*         JUST BEFORE ITS USES. THIS IS THE INDEXED SHIFT KLUDGE. 
  
 RIO7     SA3    B5+X4       DI = DB + S
          SX2    B4+
          LX3    59-D.PRSP
          MI     X3,RIO7AA   IF PRS[DI] 
          LX3    D.PRSP-D.STP 
          PL     X3,RIO7B    IF ^ST[DI] 
  
*         FORCE STORES TO COME BEFORE RS"S TO X-REGISTERS 
  
          GE     B4,B2,RIO7B MLV = MAX( MLV, MIN.PR ) 
          SX2    B2 
          EQ     RIO7B
  
 RIO7AA   LX3    D.PRSP-D.ZPP 
          SX2    B0          SAVE = MLV;  MLV = 0  */ FORCE LATE OUTPUT 
          MI     X3,RIO7B    IF ZP[DI]
          SA1    A3+2        R1RS = DI + 2
          LX1    58-R1.SOP-SO.RTP 
          PL     X1,RIO7A    IF SORT[R1RS] " 2  */ ^RS TO AN X-REGISTER 
  
          LX1    2+SO.RTP-SO.RNP
          MX3    -SO.RNL
          BX1    -X3*X1 
          SB3    X1 
          SX3    301B 
          AX3    B3,X3
          MX1    -1 
          BX2    -X1*X3      MLV = 1 & SHIFT(301B,-SORN[R1RS])
          SX2    X2+2        MLV = MLV + 2
          EQ     RIO7B
  
 RIO7A    LX1    SO.RTP-SO.LKP
          PL     X1,RIO7B    IF SOLK[R1RS] < 2  */ IF TEMP OR UJP LOCK
          SX2    B4          MLV = SAVE 
  
 RIO7B    LX2    I.LVLP 
          BX6    X2+X7
          SA6    B7+X4       [TB+S] = LW(0,PRI,MLV,NP)
          LX5    -T.PREDP    R = PRED[TI] 
          SA2    B7+X5
          SB6    A5          TF = TI
          LX2    -I.LVLP     LLV = LVL[TB+R]
          MX1    0           DLV = 0
          SB4    X2          MLV = LLV
          LX5    T.PREDP
          NZ     X5,RIO5     IF [TI] " 0   */ NOT END OF TREE 
 RIO      SPACE  1,10 
*         DETERMINE THE LIMITS OF THE TREE THAT HAVE TO BE SORTED, AND
*         SORT THAT SUBSET ( USUALLY THE NULL SET ).
  
          SA1    A0          TL = [TREE]
          SA2    A0+B1       TJ = TREE + 1
          SB7    B0          FWA = 0       */ FWA OF SORT SET 
          SB2    B1+B1
  
 RIO10    IX3    X2-X1       DIF = [TJ] - TL
          BX1    X2          TL = [TJ]
          SA2    A2+1        TJ = TJ + 1
          PL     X3,RIO10    IF DIF \ 0    */ ELEMENTS IN ORDER 
  
          SB6    A2-1        LWA = TJ - 1 
          ZR     X1,RIO11    IF TL = 0     */ END OF TREE 
          NZ     B7,RIO10    IF FWA " 0    */ NOT FIRST REVERSAL
          SB7    A2-B2       FWA = TJ - 2 
          EQ     RIO10
  
 RIO11    BSS    0
          IF     DEF,/DEBUG/RIO,1 
 TREE-RIO SNAP   *A0,*A5
          TRACE  RIO,RLIST
  
          SA0    B6          ST = LWA      */ STACK ADDR FOR SIO
          ZR     B7,RIO12    IF FWA = 0    */ NO REVERSALS
  
          SA2    B7          T = [FWA]
          SA3    O.TXT
          SB5    X3+3 
          LX2    -JT.SUCCP
          SA4    B5+X2       LI = TB + SUCC[T]
          LX4    -I.PRIP
          SB7    X4          FWA = PRI[LI] */ FWA OF EDGE GROUP 
          SX1    B6-B7
          CALL   SHL         SORT( FWA , LWA-FWA )
  
*         IF CALL FROM *GPO*, THEN LINK ST PRED TO ST"S SO THAT *SIO* 
*         CAN ARRANGE THE INSTRUCTIONS SO THAT THE ST,S FOLLOW THEIR RI.
  
 RIO12    SA2    O.TXT
          SA1    RMODE
          SB7    X2+3        TB = O.TXT + 3 
          ZR     X1,SIO      IF RMODE = 0 
  
          SA3    L.TXT
          SB4    4
          SB3    X3-4        I = L.TXT - 4
          MX1    -I.LVLL
          SA5    B7          LI = TB
          LX1    I.LVLP 
          SB6    B7-B1
  
*         CLEAR *LVL* FIELDS OF LINK WORDS
  
 RIO13    SA5    A5+B4       LI = LI + 4
          SB3    B3-B4       I = I - 4
          BX6    X1*X5
          SA6    A5          LVL[LI] = 0
          NZ     B3,RIO13    IF I " 0 
  
          SA4    B7-B1
          SX7    B1 
          LX7    D.BMP
          BX6    X7+X4       BM[TXT+2] = 1
          SA6    A4 
          MX0    -R1.RIL
  
*         SCAN PRED OF BM"S FOR ST"S, AND FORM CHAIN FROM ST PRED TO ST"
  
 RIO14    LX5    -I.NPP 
          SB5    X5          N = NP[LI] 
          LX5    I.NPP-I.PRIP 
          SA3    X5+         TI = PRI[LI];  TE = [TI] 
  
*         SCAN EDGE LIST FOR PREVIOUS *BM*
  
 RIO15    LX3    -JT.PREDP
          SA4    B6+X3       DI = TB-1 + PRED[TE] 
          SB3    X3          RMIN = PRED[TE]  */ TXT INDEX OF PREV *BM* 
          SA3    A3+B1       TI = TI + 1;  TE = [TI]
          LX4    59-D.BMP 
          PL     X4,RIO15    IF ^BM[DI] 
  
          SA3    X5-1        TI = PRI[LI] - 1 
          SX7    B3 
          SA7    RL          RL = RMIN
          LX7    I.LVLP 
  
*         CHECK FOR MULTIPLE DEFS, AND LINK THEM TO LAST DEF
  
 RIO16    LX4    D.BMP-D.^DP
          MI     X4,RIO16A   IF ^D[DI] */NOT A DEF
          SA4    A4-B4       DI = DI - 4
          SA5    A4+B1       LI = DI + 1
          SB3    B3-B4       RMIN = RMIN - 4
          LX4    59-D.BMP 
          BX6    X7+X5       LVL[LI] = RL  */ LINK THIS DEF TO LAST DEF 
          SA6    A5 
          MI     X4,RIO16    IF BM[DI]     */ NOT END OF *BM*"S 
  
 RIO16A   SX7    B3 
          SA7    A7+B1       RL(2) = RMIN 
          EQ     RIO17
  
*         SCAN EDGE LIST OF *BM* FOR *ST*"S THAT ARE LINKED TO IT 
  
 RIO16B   SB3    X3          RMIN = PRED[TI]
  
 RIO17    ZR     B5,RIO19    IF N = 0      */ END OF EDGE LIST
          SA3    A3+B1       TI = TI + 1;  TE = [TI]
          SB5    B5-B1       N = N - 1
          LX3    -JT.PREDP
          SA4    B6+X3       DI = TB-1 + PRED[TE] 
          LX4    59-D.BMP 
          MI     X4,RIO16B   IF BM[DI]
          LX4    D.BMP-D.STP
          PL     X4,RIO17    IF ^ST[DI]    */ NOT A STORE 
          IFNE   .DAL,0,2 
          LX4    D.STP-D.L2P
          MI     X4,RIO17    IF L2[DI]
          SA4    A4-2        R1 = DI - 2
          BX6    -X0*X4      R = RI[R1] 
          SB2    X6 
          LT     B2,B3,RIO17 IF R< RMIN */PRED BEFORE PREV *BM* 
  
*         DO NOT ADD ST TO CHAIN IF IT IS LINKED TO AN INTERFERING
*         LD OR ST BETWEEN IT AND ITS PRED ( RI ).
  
          SA5    A4+3        LI = R1 + 3
          LX5    -I.NPP 
          SB2    X5          NSP = NP[LI] 
          LX5    I.NPP-I.PRIP 
          MX2    -D.LDSTL 
          SA5    X5          TJ = PRI[LI] 
          LX2    D.LDSTP
  
 RIO17A   LX5    -JT.PREDP   J = PRED[TJ] 
          SX5    X5 
          IX7    X6-X5
          PL     X7,RIO17B   IF J @ R      */ PRED IS BEFORE RI 
          SA4    B6+X5       DJ = TB-1 + J
          BX7    -X2*X4 
          ZR     X7,RIO17B   IF ^LDST[DJ]  */ NOT A MEM REF 
          LX4    59-D.EQVP
          MI     X4,RIO17    IF EQV[DJ]    */ INTERFERING MEM REF 
 RIO17B   SB2    B2-B1       NSP = NSP - 1
          SA5    A5+B1       TJ = TJ + 1
          NZ     B2,RIO17A   IF NSP " 0 
  
*         DO NOT LINK *ST* TO PRED IF IT IS A *DEF*, AND RF IS AN EXPR
*         SINCE WE MAY GET IN TROUBLE WHEN THERE ARE REDEFINITION LINKS.
  
          SA4    B6+X6       DIP = TB-1 + R 
          LX4    59-D.PIP 
          PL     X4,RIO18    IF ^PI[DIP]   */ RI NOT A *DEF*
  
          SA4    B6+X3       DI = TB-1 + PRED[TI] 
          LX4    58-D.TYP 
          SA2    A4-B1       R2 = DI - 1
          LX2    -IH.RFP     RF = RF[R2]
          MI     X4,RIO17C   IF TYPE[DI] = III
          SA2    A2-B1       R1 = R2 - 1
          LX2    -R1.RJP     RF = RJ[R1]
 RIO17C   BX2    -X0*X2 
          SB2    X2 
          LE     B2,B1,RIO18 IF RF @ 1     */ NO RF 
          SA4    B6+B2       DIF = TB-1 + RF
          LX4    59-D.ZPP 
          PL     X4,RIO17    IF ^ZP[DIF]   */ NOT A SIMPLE *LD* 
  
*         SCAN ST PRED CHAIN FOR END, AND ADD ST TO IT. 
  
 RIO18    SA5    B7+X6       LI = TB + R
          BX6    -X1*X5      R = LVL[LI]
          LX6    -I.LVLP
          NZ     X6,RIO18    IF R " 0      */ NOT END OF CHAIN
  
          SX7    X3 
          LX7    I.LVLP 
          BX6    X7+X5       LVL[LI] = PRED[TE] 
          SA6    A5 
          EQ     RIO17
  
*         CLEAR ST CHAIN PTRS FOR ALL BUT LAST DEF IN A SUB-SEQUENCE
  
 RIO19    SA3    RL 
          SA4    A3+B1
          SB5    X3 
          SB3    X4          RMIN = RL(2) 
 RIO20    EQ     B3,B5,RIO21 IF RL = RMIN 
          SB5    B5-B4       RL = RL - 4
          SA4    B7+B5       LI = TB + RL 
          BX7    X1*X4       LVL[LI] = 0   */ CLEAR *ST* CHAIN LINK 
          SA7    A4 
          EQ     RIO20
  
*         ADVANCE TO PREVIOUS *BM*
  
 RIO21    SA5    B7+B3       LI = TB + RMIN 
          NZ     B3,RIO14    IF RMIN " 0   */ NOT *BOS* 
  
          SA4    B7-B1
          SX7    B1 
          LX7    D.BMP
          BX6    -X7*X4      BM[TXT+2] = 0
          SA6    A4 
          LX7    D.PSP-D.BMP
          SX6    B1 
          LX6    D.PIP
          BX7    X6+X7
          SA7    RMODE       RMODE = (PS,PI)
 SIO      EJECT              SIO
*         SIO - SET INSTRUCTION ORDER BY A DEPTH FIRST SEARCH 
  
 SIO      SA3    L.TXT
          SB4    60-I.PRIP
          SX7    X3-4        N = L.TXT - 4 */ CURRENT INSTRUCTION 
          SB5    4           ON = 4        */ OUTPUT INDEX
          SA4    RMODE
          MX0    1
          LX0    1+I.MIP
          SX1    B1 
          SB6    0           LII = 0       */ LAST ISSUED INSTRUCTION 
          NZ     X4,SIO2     IF RMODE " 0  */ CALL FROM *GPO/CBB* 
  
*         SEARCH FOR NEXT TERMINAL INSTRUCTION
  
 SIO1     SA2    RIOA 
          SB3    4
          SB2    B7-B1       DB = TB - 1
          SA4    B2+B6       DI = DB + LII
  
 SIO1A    SA4    A4+B3       DI = DI + 4
          BX6    X2*X4
          ZR     X6,SIO1A    IF ^( BM[DI] ! ST[DI] )
  
          SB6    A4-B2       LII = DI - DB
          SX7    A4-B2       N = LII
  
*         VISIT CURRENT INSTRUCTION 
  
 SIO2     SA5    B7+X7       LI = TB + N
          SA2    RMODE
          SA4    A5-B1       DI = LI - 1
          BX6    X2*X4
          ZR     X6,SIO2D    IF ^RMODE[DI] */ NOT *PS* ! *PI* 
          BX6    X5 
          LX6    59-I.STCPP 
          MI     X6,SIO2D    IF STCP[LI]   */ STC PROCESSED 
          LX6    1+I.STCPP-I.LVLP 
          SX2    X6 
          ZR     X2,SIO2D    IF LVL[LI] = 0  */ NO ST CHAIN (EOQ/EOS) 
  
*         ADD ST"S TO THE STACK SO WE OUTPUT THEM IMMEDIATELY AFTER 
*         THEIR PREDECESSORS ( RI AND RF )
  
          LX1    I.STCPP
          BX6    X1+X5       STCP[LI] = 1 
          SX1    X7          T = N         */ SAVE N
          LX6    -I.LVLP
          SX7    X6          N = LVL[LI]
          BX6    X6-X7
          LX6    I.LVLP      LVL[LI] = 0
          SA6    A5 
  
 SIO2A    SA5    B7+X7       LI = TB + N
          BX6    X0*X5
          NZ     X6,SIO2C    IF MI[LI]     */ ST PROCESSED
  
          SA7    A0+B1       [SI+1] = N    */ STACK N 
          SA0    A0+B1       SI = SI + 1
  
          SA4    A5-B1       DI = LI - 1
          SA3    A4-B1       R2 = DI -1 
          LX4    58-D.TYP 
          LX3    -IH.RFP     R = RF[R2] 
          MI     X4,SIO2AA   IF TYPE[DI] = III
          SA3    A3-B1       R1 = R2 - 1
          MX4    -R1.RIL
          LX3    -R1.RJP
          BX3    -X4*X3      R = RJ[R1] 
 SIO2AA   SB2    X3 
          LE     B2,B1,SIO2C IF R @ 1      */ NO RF 
  
          SA4    B7+B2       LIP = TB + R 
          LX4    59-I.MIP 
          MI     X4,SIO2A1   IF M[LIP]
          SX4    B2 
          IX4    X4-X1
          MI     X4,SIO2C    IF T > R 
  
          SA0    A0-B1       SI = SI - 1   */ REMOVE N FROM STACK 
          PRINT  SIO,(* REMOVE STORE STACK --*) 
          EQ     SIO2C
  
 SIO2A1   LX4    I.MIP-I.IIP
          MI     X4,SIO2C    IF II[LIP]    */ ISSUED
  
*         RF MARKED BUT NOT OUTPUT, ADD *N* BELOW IT IN THE STACK 
  
          SA4    A0-B1       SJ = SI - 1
          SB2    -B2
 SIO2B    BX6    X4          S = [SJ] 
          SX3    B2+X4
          SA6    A4+B1       [SJ+1] = S 
          SA4    A4-B1       SJ = SJ - 1
          NZ     X3,SIO2B    IF S " R 
          SA7    A4+B1       [SJ+1] = N    */ INSERT N BELOW R
  
 SIO2C    LX5    -I.LVLP
          SX7    X5          N = LVL[LI]
          NZ     X7,SIO2A    IF N " 0      */ NOT END OF ST CHAIN 
  
          SX7    X1          N = T */ RESTORE N 
          SX1    B1 
          SA5    B7+X7       LI = TB + N
  
 SIO2D    LX4    B4,X5
          BX5    X0+X5       MI[LI] = 1 
          LX3    B1,X5
          ERRNZ  58-I.IIP 
          SB3    X4-1        EI = PRI[LI] - 1  */ EDGE INDEX
          MI     X3,SIO5     IF II[LI]     */ ISSUED
  
*         SEARCH PRED TO SEE IF ALL ARE MARKED
  
 SIO3     SA2    B3+X5       TI = EI + NP[LI] 
          SB2    X5 
          ZR     B2,SIO4     IF NP[LI] = 0
  
          IX5    X5-X1       NP[LI] = NP[LI] - 1
          LX2    -JT.PREDP   R = PRED[TI] 
          SA3    B7+X2       LIP = TB + R 
          LX4    B1,X3
          SX2    X2 
          MI     X4,SIO3     IF II[LIP]    */ ISSUED
          LX3    59-I.MIP 
          MI     X3,SIO3A    IF MI[LIP] 
          IX6    X2-X7
          PL     X6,SIO3A    IF R > N      */ REDEF LINK
  
 SIO3H    SA7    A0+B1       [SI+1] = N    */ STACK CURRENT INST
          SA0    A0+B1       SI = SI + 1
          BX6    X5 
          SA6    A5 
          SX7    X2          N = R         */ FOLLOW PRED 
          EQ     SIO2 
  
 SIO3G    IX6    X2-X7
          PL     X6,SIO3     IF R > N      */ REDEF LINK
          PRINT  SIO,(* STACK N --- MARKED INST ---*) 
          EQ     SIO3H
  
*         *R* NOT OUTPUT, IF TOP OF STACK IS A REDEF *ST*, THEN SET *XU*
*         BIT IN IT, OR MOVE IT DOWN IN THE STACK AFTER R, SO WE AVOID
*         THE PROBLEM OF USES EXTENDING PAST A DEFINITION IN *GRA*. 
*         SEE SECTION ON DEADLOCKS IN THE *IMS* FOR FURTHER INFORMATION.
  
 SIO3A    SA3    A0          SJ = SI;  S = [SJ] 
          BX4    X5 
          SB2    B7-B1
          LX4    59-I.RDSTP 
          MI     X4,SIO3B    IF RDST[LI]   */ NOT FIRST REDEF EDGE
          SA4    B2+X3       DIS = TB-1 + S 
          LX4    59-D.RDP 
          PL     X4,SIO3G    IF ^RD[DIS]   */ NOT A REDEF STORE 
          SA4    A4-2 
          MX6    -R1.RIL
          BX6    -X6*X4 
          BX4    X7-X6
          NZ     X4,SIO3G    IF RI[R1S] " N  */ TOP OF STK ^ *ST N,,* 
  
          SX4    B1 
          LX4    I.RDSTP
          BX5    X4+X5       RDST[LI] = 1  */ INDICATE REDEF ST ST IN STK 
          LX3    I.LVLP 
          BX5    X3+X5       LVL[LI] = S
          LX3    -I.LVLP
  
 SIO3B    RJ     MSD         MOVE THE STORE DOWN / SET THE *XU* BIT 
          EQ     SIO3 
  
*         OUTPUT INSTRUCTION
  
 SIO4     LX1    I.IIP       II[LI] = 1 
          SA4    A5-B1       DI = LI - 1
          SX2    B5          OI[LI] = ON
          LX2    I.OIP
          BX3    X1+X2
          SX1    B1 
          BX6    X3+X5
          LX4    59-D.PRSP
          SA6    A5 
          SB5    B5+4        ON = ON + 4
          MI     X4,SIO4A    IF PRS[DI] 
          LX4    D.PRSP-D.RJRSP 
          MI     X4,SIO4A    IF RJRS[DI]
          LX4    D.RJRSP-D.XMTP 
          PL     X4,SIO5     IF ^XMT[DI]
          SA4    A4+4        DI = DI + 4   */ CHECK NEXT FOR *KS* 
          LX4    59-D.KSP 
          PL     X4,SIO5     IF ^KS[DI] 
  
*         INSTRUCTION *PRS*, *RJRS* OR IS A *SXT*, OUTPUT THE NEXT INST 
  
 SIO4A    SA5    A5+4        LI = LI + 4
          MX2    -I.OIL 
          LX2    I.OIP
          BX6    X2*X5
          BX5    X0+X6       MI[LI] = 1 
          EQ     SIO4 
  
 SIO5     SA3    A0          N = [ST] 
          SA0    A0-1        ST = ST - 1
          SX7    X3 
          NZ     X3,SIO2     IF N " 0 
  
          SA4    A5-3        R1 = LI - 3
          SA0    A0+B1       ST = ST + 1
          UX6    B2,X4
          NZ     B2,SIO1     IF OC[R1] " OC.EOQ 
  
          TRACE  SIO,RLIST
 SIO      SPACE  2,10 
*         MOVE THE INSTRUCTIONS TO THEIR FINAL ORDER
  
          SA1    L.TXT
          SA3    O.TREE 
          SB6    B7-B1                     (B6) = TXT + 2 
          MOVE   X1-8,B7+B1,X3     MOVE( L.TXT-8 , TXT+4 , TREE ) 
          SA1    N.INST 
          SA2    O.TXT
          SA3    O.TREE 
          SB3    3
          SA5    X3+B3       TI = TREE + 3
          SB7    X3                        (B7) = TREE
          SX1    X1-2        N = N.INST - 2 
          SX0    B1 
  
 SIO8     SA4    A5-B1       D = [TI-1] 
          SA3    A4-B1       R2 = [TI-2]
          SA2    A5-B3       R1 = [TI-3]
          LX5    -I.OIP 
          SB5    X5          J = OI[TI] 
          SA5    A5+4        TI = TI + 4
          BX6    X4 
          LX7    X3 
          SA6    B6+B5       TXT(J+2) = D 
          IX1    X1-X0       N = N - 1
          SA7    A6-B1       TXT(J+1) = R2
          BX6    X2 
          SA6    A7-B1       TXT(J) = R1
          NZ     X1,SIO8     IF N " 0 
  
          MX7    0
          SA7    L.TREE      L.TREE = 0 
          SA0    B6-2 
          SX2    0
          CALL   RNI         RENUMBER THE INSTRUCTIONS
  
 SIO10    SA5    O.TXT
          RJ     CRW         COMPUTE X-REGISTER WIDTH OF NEW ORDER
          EQ     RIO
  
 RIOA     BFMW   D,(BM,ST)
 RMODE    BSS    1           *RIO* MODE 
 RL       BSS    2           *TXT* INDEX OF LAST *BM*  ( RIO16 - RIO17 )
 MSD      SPACE  3
**        MSD - MOVE STORE ( TOP OF STACK ) DOWN TO A POINT BELOW *R*.
  
 MSD      ROUTINE 
          SA4    B7+X2       LIP = TB + R 
          LX4    59-I.MIP 
          PL     X4,MSD5     IF ^MI[LIP]   */ R NOT IN THE STACK
  
*         SEE IF WE CAN MOVE *TOS* BELOW *R* SO IT COMES OUT AFTER IT 
  
          SA4    A0          SJ = SI       */ SEARCH FOR STORE IN STK 
          LX5    -I.LVLP
          SX3    X5          S = LVL[LI]   */ TXT INDEX OF *ST* 
          LX5    I.LVLP 
 MSD1     BX6    X3-X4
          SA4    A4-B1       SJ = SJ - 1
          NZ     X6,MSD1     IF [SJ+1] " S
  
          SX4    A4+B1       SS = SJ + 1
          SA3    A0+         SJ = SI       */ SEARCH FOR *R*
 MSD2     BX6    X2-X3
          SA3    A3-B1       SJ = SJ - 1
          NZ     X6,MSD2     IF [SJ+1] " R
          SX3    A3+B1
          IX6    X4-X3
          MI     X6,MSD      IF SS < SJ+1  */ S IS ALREADY BELOW R
          PRINT  SIO,(21X*MOVE STORE DOWN*) 
  
          SA3    X4          SJ = SS       */ MOVE THE STORE DOWN 
          SX1    X3          S = [SJ] 
 MSD3     SA3    A3-B1       SJ = SJ - 1
          SA4    B2+X3       DIS = TB-1 + [SJ]
          BX6    X3 
          SA6    A3+B1       [SJ+1] = [SJ]
          LX4    59-D.BMP 
          MI     X4,MSD4     IF BM[DIS]    */ CANT MOVE ST PAST A *BM*
          IX4    X2-X3
          NZ     X4,MSD3     IF [SJ] " R   */ IF NOT FINISHED 
  
          SX6    X1 
          SA6    A3          [SJ] = S 
          SX1    B1 
          EQ     MSD
  
 MSD4     SX6    X1 
          SA6    A6          [SJ+1] = S 
          SX1    1
  
*         REDEF CANNOT BE MOVED BACK, SET *XU* BIT IN DESCR FOR *GRA* 
  
 MSD5     BX6    X5 
          LX6    -I.LVLP
          SA4    B2+X6       DIS = TB-1 + LVL[LI]  */ DESCR OF STORE
          PRINT  SIO,(21X*SET XU*Z5),X6 
          SX3    B1 
          LX3    D.XUP
          BX6    X3+X4       XU[DIS] = 1
          SA6    A4 
          EQ     MSD
 CRW      TITLE  CRW - COMPUTE REGISTER WIDTH OF A SEQUENCE 
**        CRW - COMPUTE THE X-REGISTER WIDTH OF A INSTRUCTION SEQUENCE
*         AND INSTALL IT IN THE DESCRIPTORS.
* 
*         ENTRY  (X5) = FWA OF RLIST INSTRUCTION BLOCK
* 
*         EXIT   (X6) = MAX REG WIDTH OF SEQUENCE 
  
 CRW      ENTRY. ** 
          MX0    -R1.RIL+1
          SB4    B0          RW = 0        */ REG WIDTH 
          MX1    -D.REGWL 
          LX0    1
          SB5    B0          MW = 0        */ MAX WIDTH 
          LX1    D.REGWP
          MX2    -D.USESL 
          SB7    X5+3        TB = TXT + 3 
          SA4    B7-B1       DI = TB - 1
          SB3    OC.RS
          MX7    0
          SA7    B7          [TB] = 0 
          EQ     CRW1 
  
*         ^D OR PRS TO A B-REG, INSTALL REGW, CLEAR LINK WORD 
  
 CRW0     LX4    1+D.^DP
          SX3    B4 
          BX4    X1*X4
          LX3    D.REGWP
          MX7    0
          BX6    X3+X4       REGW[DI] = RW
          SA6    A4 
          SA7    A4+B1       [DI+1] = 0 
  
*         ADVANCE TO NEXT INSTRUCTION, JUMP ON TYPE 
  
 CRW1     SA5    A4+2        R1 = DI + 2
          SA4    A5+2        DI = R1 + 2
          UX5    B2,X5
          LX4    58-D.TYP 
          IX7    X4+X4
          MI     X4,CRW3     IF TYPE[DI] = III ! IV 
          MI     X7,CRW2     IF TYPE[DI] = II 
  
*         TYPE I
  
          LX7    1+D.TYP-D.TYIOP
          MX3    -D.TYIOL 
          LX4    1+D.TYP-D.^DP
          LT     B2,B3,CRW1A IF OC[R1] < OC.RS  */ *DAR*
          BX6    -X3*X7 
          SA3    =XTYIOM+X6 
          UX7    B2,X3
          BX6    X7*X5
          AX5    B2,X6
          AX5    B2,X6       RNUMS = TYIOM[DI,R1] 
          EQ     CRW7 
  
*         PROCESS *DAR* 
  
 CRW1A    AX5    R1.RJP 
          BX7    -X0*X5      R = RJ[R1] 
          SA3    B7+X7       LI = TB + R
          SX6    X3-1        [LI] = [LI] - 1
          SA6    A3 
          NZ     X6,CRW0     IF [LI] " 0   */ NOT LAST USE
          SB4    B4-B1       RW = RW - 1
          EQ     CRW0 
  
*         TYPE II 
  
 CRW2     BX6    X4 
          LX4    1+D.TYP-D.^DP
          LX6    1+D.TYP-D.PIP
          PL     X6,CRW9     IF ^PI[DI] 
  
          EQ     B2,B3,CRW0  IF OC[R1] = OC.RS
          LX5    58-R1.SOP-SO.RTP 
          PL     X5,CRW0     IF SORT[R1] " 2  */ DEF NOT TO AN X-REG
  
          EQ     CRW9 
  
*         TYPE IV 
  
 CRW3     PL     X7,CRW4     IF TYPE[DI] " IV 
          ZR     B2,CRW11    IF OC[R1] = OC.EOQ 
  
          LX4    1+D.TYP-D.^DP
          SX6    B2-OC.ENT
          MI     X6,CRW0     IF OC[R1] < OC.ENT  */ EOS OR LAB
          SB4    0           RW = 0        */ CLEAR UJP LOCKS 
          EQ     CRW0 
  
*         TYPE III
  
 CRW4     LX4    1+D.TYP-D.^DP     RNUMS = RI[R1] 
          MI     X4,CRW5     IF ^D[DI]
          MX5    0           RNUMS = 0
 CRW5     SA3    A5+B1       R2 = R1 + 1
          BX5    -X0*X5 
          LX3    -IH.RFP
          BX6    -X0*X3      R = RF[R2] 
          ZR     X6,CRW7     IF R = 0 
          LX5    R1.RIL 
          BX5    X6+X5       RNUMS = SHIFT(RNUMS,R1.RIL) ! R
  
*         DECREMENT USES OF OPERANDS ( RNUMS )
  
 CRW7     BX7    -X0*X5      R = RI[RNUMS]
          SA3    B7+X5       LI = TB + R
          SX6    X3-1        [LI] = [LI] - 1
          AX5    R1.RIL      RNUMS = SHIFT(RNUMS,-R1.RIL) 
          NZ     X6,CRW8     IF [LI] " 0   */ NOT LAST USE
          SB4    B4-B1       RW = RW - 1
 CRW8     SA6    A3 
          NZ     X5,CRW7     IF RNUMS " 0 
 RIO      SPACE  1,10 
*         ADVANCE *RW* TO ACCOUNT FOR THE NEW RESULT
  
 CRW9     MI     X4,CRW0     IF ^D[DI]
          BX6    X4 
          LX6    D.^DP-D.PRSP 
          PL     X6,CRW10    IF ^PRS[DI]
          SA3    A4+2        R1RS = DI + 2
          LX3    58-R1.SOP-SO.RTP 
          PL     X3,CRW0     IF SORT[R1RS] " 2  */ NOT TO AN X-REG
  
 CRW10    LX4    1+D.^DP
          SB4    B4+B1       RW = RW + 1
          BX4    X1*X4
          SX3    B4 
          BX7    -X2*X4 
          SA7    A4+B1       [DI+1] = USES[DI]
          LX3    D.REGWP
          BX6    X3+X4       REGW[DI] = RW
          SA6    A4 
          LE     B4,B5,CRW1  IF RW @ MW 
  
          SB5    B4          MW = RW
          EQ     CRW1 
 CRW      SPACE  1,10 
*         EOQ - SET MAX WIDTH IN DESCR OF *BOS* AND CLEAR LINK WORDS
  
 CRW11    SA3    B7-B1       DI = TB - 1
          SX6    B5 
          LX6    D.REGWP
          BX3    X1*X3
          MX7    0
          BX6    X3+X6       REGW[TB-1] = MW  */ SET MAXW IN *BOS*
          SA6    A3 
  
          SA7    A3+B1
          SB2    A3+B1
          SB3    A4+B1
          SB4    4
+         SB2    B2+B4       FOR I = 3 TO L.TXT BY 4;  TXT(I) = 0 
          SA7    A7+B4
          LT     B2,B3,*
          TRACE  CRW,RLIST
  
          SX6    B5          RIO.MAX = MW 
          EQ     CRW
 RNI      TITLE  RNI - RENUMBER INSTRUCTIONS
**        RNI - RENUMBER INSTRUCTIONS 
*         RELABEL THE R-NUMBERS IN THE INSTRUCTIONS SO THAT FOR EACH
*         *RI* WHICH DEFINES A RESULT, RI = R1 - O.TXT ( THE INDEX TO 
*         *TXT* OF THE INSTRUCTION ). WITH THIS LABELING, R-NUMBERS 
*         APPEARING AS OPERANDS ARE POINTERS TO THE INSTRUCTIONS WHICH
*         ARE THE OPERANDS. 
* 
*         ENTRY  (B7) = FWA OF SCRATCH TABLE USED FOR RENUMBERING 
*                (A0) = (O.TXT) 
*                (X2) = M = NEW BASE R-NUMBER 
* 
*         EXIT   A0, B7 PRESERVED 
*                (B2) = 2 
*                (B4) = 4 
*                (X0) = M(-R1.RIL)
  
 RNI      ENTRY.
          TRACE  RNI,RLIST
          SB2    B1+B1       (B2) = 2 
          MX0    -R1.RIL
          SB5    59-D.^DP 
          SB4    B2+B2       (B4) = 4 
          SA4    A0+B2       DI = O.TXT + 2 
          SX1    B4 
          BX7    X2 
          PX5    B2,X2
  
*         SETUP THE EQUIVALENCE TABLE BETWEEN THE R-NUMBERS 
  
 RNI1     UX6    "OC",X5
          ZR     "OC",RNI3   IF OC[R1] = 0 */ END OF *TXT*
  
 RNI2     SA4    A4+B4       DI = DI + 4
          IX2    X2+X1       M = M + 4
          SA5    A4-B2       R1 = DI - 2
          LX6    B5,X4
          MI     X6,RNI1     IF ^D[DI]
          BX3    -X0*X5      RI = RI[R1]
          IX6    X2-X3
          LX7    X2          MAXR = M 
          SA6    B7+X3       T(RI) = M - RI 
          EQ     RNI2 
 RNI      SPACE  3
*         RELABEL THE R-NUMBERS IN THE INSTRUCTIONS USING THE EQV TABLE 
  
 RNI3     MX6    0
          SA4    A0+B2       DI = O.TXT + 2 
          SB6    R1.RIL 
          SA6    B7          T(0) = 0 
          SA6    B7+B1       T(1) = 0 
          EQ     RNI5 
 RNI      SPACE  1,10 
*         PROCESS TYPE II / III INSTRUCTIONS
  
 RNI4     SA2    A5+B1       R2 = R1 + 1
          BX7    -X0*X5 
          SA3    B7+X7       RI = T(RI[R1]) 
          IX6    X5+X3
          LX2    -IH.RFP
          SA3    B7+X2
          IX7    X2+X3       RF = T(RF[R2]) 
          SA6    A5 
          LX7    IH.RFP 
          SA7    A2+
  
 RNI5     SA4    A4+B4       DI = DI + 4
          LX4    58-D.TYP 
          SA5    A4-B2       RI = DI - 2
          IX6    X4+X4
          BX7    X4-X6
          MI     X7,RNI4     IF TYPE[DI] = II ! III 
          MI     X4,RNI6     IF TYPE[DI] = IV 
  
*         PROCESS TYPE I INSTRUCTIONS 
  
          LX5    -R1.RJP
          BX1    -X0*X5 
          SA2    B7+X1
          IX3    X5+X2       RJ = T( RJ[R1] ) 
          LX4    B6,X3
          BX5    -X0*X4 
          SA1    B7+X5
          IX7    X1+X4       RK = T( RK[R1] ) 
          SA2    A5+B1       R2 = R1 + 1
          LX6    B6,X7
          BX3    -X0*X6 
          SA1    B7+X3
          IX7    X1+X6       RI = T( RI[R1] ) 
          SA7    A5 
          ZR     X2,RNI5     IF [R2] = 0
          LX2    -IH.RFP
          BX7    -X0*X2 
          SA3    B7+X7
          IX6    X2+X3       RF = T(RF[R2]) 
          LX6    IH.RFP 
          SA6    A2 
          EQ     RNI5 
  
 RNI6     UX7    "OC",X5
          NZ     "OC",RNI5   IF OC[R1] " 0
          EQ     RNI
  
          END 
