*DECK CODGK1S 
USETEXT   TSOURCE 
USETEXT   TTARGET 
USETEXT   TCEXECQ 
USETEXT   TSYMCNS 
USETEXT   TREGNOS 
USETEXT   TCOM39Q 
USETEXT   TCOM78Q 
USETEXT   TCEXEC
USETEXT   TCOM88
USETEXT   TCOM88K 
      PROC CODGK1S; 
      BEGIN 
#**********************************************************************#
#     CODGK1S - A COLLECTION OF SUPPORT ROUTINES USED (PRIMARILY) BY   #
#               CODGK1.                                                #
#**********************************************************************#
  
  
  
  
*CALL COMEX 
  
  
  
  
#     DEFS                                                             #
  
      DEF J860 #860#;              # SYMABT DIAGNOSTIC 860             # CODGK1S
  
  
  
  
#     XREFS                                                            #
  
      XREF
          BEGIN 
          PROC BINDEC;
          PROC CHRCHR;
          LABEL CFC00;       #WRITE OUT CODE FILE#
          PROC CG2ABT;       #ISSUE ABORT FROM CG2                     #
          LABEL CSCAN;       #CONTINUE SCANNING READY SET FROM FOL[INX]#
          PROC DB;           #DEBUG TRACE ROUTINE#
          FUNC GETEMP;
          LABEL RESCAN;      #CONTINUE SCANNING READY SET FROM INX# 
          PROC RPC00;        #REDUCE PREDECESSOR COUNTS#
          END 
  
  
  
  
#     XDEFS                                                            #
  
      XDEF
          BEGIN 
          PROC CAS00;        #SELECT BEST STORE REGISTER# 
          PROC CRU00;        #TEST FOR RECOMPUTABILITY# 
          PROC CSU00;        #CHECK OPERAND FOR SINGLE USE# 
          FUNC FNDBREG;      #FIND B-REG CORRESPONDING TO I#
          PROC GBR00;        #SELECT BEST DEAD TRANSIENT B-REG# 
          PROC GIU00;        #SELECT BEST INCREMENT UNIT# 
          PROC GLR00;        #SELECT BEST LOAD REGISTER#
          PROC GMU00;        #SELECT BEST MULTIPLY UNIT#
          PROC GWR00;        #SELECT BEST DEAD X-REG# 
          PROC IINSK;        #INSERT INSTRUCTION INTO ICFT# 
          PROC INN00;        #CALCULATE INSOPA-INSOPE AND NINSA-NINSE#
          PROC IRM00;        #INITIALIZE REG MEMORIES BEFORE SCHEDULING#
          PROC IRS00;        #INITIALIZE READY SET BEFORE SCHEDULING #
          PROC ISL00;        #INSERT LOAD INTO ICFT#
          PROC NCA00;        #ENCODE ADDRESS# 
          PROC SAC00;        #SEARCH A-REGS FOR ADDRESS#
          PROC SBC00;        #SEARCH B-REGS FOR ADDRESS#
          PROC SBK00;        #SEARCH B-REGS FOR CONSTANT# 
          PROC SXAC;         #SEARCH X-REGS FOR ADDRESS#
          PROC SXK00;        #SEARCH X-REGS FOR CONSTANT# 
          PROC TRO00;        #COMPUTE AVAILABILITY OF REG#
          END 
  
  
      $BEGIN
      XDEF
          BEGIN 
          PROC EEOS00;
          END 
      $END
  
  
  
  
#     LOCAL DATA                                                       #
  
#        INSERTED LOAD LOCATION OK                                     #
         ITEM     ILDLOK  B  = FALSE  ; 
CONTROL EJECT;
    PROC CAS00    (SR,TTR,TTO) ;
         BEGIN #CAS00#
#**********************************************************************#
#     CAS00 - CHECK FOR AVAILABLE STORE REGISTER                       #
#                                                                      #
#     PURPOSE-                                                         #
#         CHECK TO SEE IF THERE IS AN AVAILABLE STORE REGISTER.        #
#                                                                      #
#     INPUT-                                                           #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#         REGFT ARRAY - THE REGISTER TIME-TO-BE-FREE ARRAY             #
#         CLOCK - CURRENT TIME                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         SR - SELECTED REGISTER OR 0 IF NONE AVAILABLE.               #
#         TTR - TIME BEFORE SR CAN BE USED AS A RESULT                 #
#         TTO - TIME BEFORE SR CAN BE USED AS AN OPERAND               #
#**********************************************************************#
  
         ITEM  SR ; # X-REG (6 OR 7) OUTPUT  #
         ITEM     TTR ; # TIME TO USE AS RESULT  #
         ITEM     TTO ;  # TIME TO USE AS OPERAND # 
         ITEM  T1;  # TEMPS # 
         ITEM  T2;
$BEGIN
DB("( 9X17H CAS00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
$END
         SR =  0 ;
         T1 =  131071  ;
         T2 =  131071 ; 
         IF  RGMEM [XREG6]  LT  0 THEN
                  BEGIN 
                  T1 = RRFT [XREG6] - CLOCK  ;
                  SR = XREG6 ;
                  END 
         IF  RGMEM [XREG7]  LT  0 THEN
                  BEGIN 
                  T2 = RRFT [XREG7] - CLOCK  ;
                  IF T2 LT T1 THEN
                      BEGIN 
                      T1 = T2;
                      SR = XREG7; 
                      END 
                  END 
         IF  T1 LT 0  THEN T1  = 0 ;
         IF T1 LT 131071 THEN 
                  BEGIN 
                  TTR = T1 ;
                  TTO = ROFT [SR] - CLOCK ; 
                  IF TTO LT 0 THEN TTO = 0  ; 
                  END 
         END   #CAS00#
CONTROL EJECT;
#        CRU00                                                         #
#        RECOMPUTABLE  X-REG  OPERAND                                  #
      PROC CRU00((KPTR),REG); 
         BEGIN    #      CRU00                                         #
         ITEM     REG   ; 
         ITEM     KPTR  I ; 
         ITEM     REGF  I ; 
         ITEM     TXOP  I ; 
         REG  =  -1 ; 
      IF XREGL[KPTR] LT XREG0 THEN RETURN;
          IF TSYM[KPTR] GT 0                                             SMP0088
          AND NOT RLISS[KPTR]    THEN                                    SMP0088
            GOTO CRUFX;                                                  SMP0088
         TXOP  =  OPCD [KPTR] ; 
         IF  TXOP EQ QICFOP"LDSC"  OR 
             TXOP EQ QICFOP"MASK"  THEN GOTO CRUFX  ; 
         IF   TXOP  EQ  QICFOP"SAVE"  OR
              TXOP  EQ  QICFOP"TSSV"  OR
              TXOP  EQ  QICFOP"PISR"    THEN
                  BEGIN 
                  TX1 =  GETEMP ( BI - KPTR ) ; 
                  TSYM  [KPTR]  = TX1  ;
                  OPN1  [KPTR]  = TX1  ;
                  AINVS [KPTR]  = TRUE ;
                  TLUS  [TX1] = TRUE ;
                  GOTO  CRUFX  ;
                  END 
             TXOP = OPCD[CNO[KPTR]] ; 
             IF TXOP EQ QICFOP"MSKL"
             OR TXOP EQ QICFOP"MSKC" THEN GOTO CRUFX; 
      RETURN; 
CRUFX:  
         REGF =   XREGL [KPTR]  ; 
         CALL  TRO00 ( REGF ) ; 
         REG  =  REGF  ;
         END      #      CRU00                                         #
CONTROL EJECT;
#        CHECK FOR A SINGLE USE OF AN OPERAND - INDICATE IF SUCH  # 
#        AND RETURN TIME TO USE AS RESULT REGISTER #
      PROC CSU00((R),US,TRR,TRO); 
         BEGIN #CSU00#
               ITEM  R ;     #X-REGISTER IN QUESTION #
               #OUTPUT   #
               ITEM  US;      # US = 0 MEANS SINGLE USE LEFT #
         ITEM     TRR ;  # TIME TO USE AS RESULT  # 
         ITEM     TRO ;  # TIME TO USE AS OPERAND # 
         ITEM     USCNT I ;         #   USE COUNT 1 OR 2               #
         IF  CDBLU  THEN  USCNT = 2 ;   #    DOUBLE USE                #
           ELSE USCNT = 1 ;         #        SINGLE USE                #
$BEGIN
DB("( 9X17H CSU00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
$END
         IF REFCT [ RGMEM [R]]  GT USCNT THEN               BEGIN #1# 
               US = 1 ;       # SET MULTIPLE USES # 
               RETURN ; 
                                                            END   #1# 
         TRR =  RRFT [ R ] - CLOCK  ; 
         TRO =  ROFT [ R ] - CLOCK  ; 
         IF TRR LT 0 THEN TRR = 0 ; 
         IF  TRO  LT  0  THEN  TRO = 0 ;
               US = 0 ;  # SET SINGLE USE # 
               END  #CSU00# 
      CONTROL EJECT;
      $BEGIN
    PROC EEOS00   ; 
         BEGIN    #      EEOS00                                        #
         ITEM  CC I  ;
  
      CONTROL FASTLOOP; 
  
         FOR  I =  0  BY 1  UNTIL  7  DO
                                                            BEGIN #1# 
               SDC  [I]  =  " "  ;
                                                            END   #1# 
         CC  =  1 ; 
         CALL  CHRCHR (SDLINE,CC,"C",1) ; 
         CC = CC + 1 ;
         CALL  BINDEC (SDLINE,CC,TCLOCK,7) ;
         CC = CC + 7 ;
         CALL  BINDEC (SDLINE,CC,CLOCK,5) ; 
         CC = CC + 5 ;
         CALL  CHRCHR (SDLINE,CC," D",2)  ; 
         CC = CC + 2 ;
         CALL  BINDEC (SDLINE,CC,TDLY,6) ;
         CC = CC + 6 ;
         CALL  BINDEC (SDLINE,CC,SDLY,4) ;
         CC = CC + 4 ;
         CALL  CHRCHR (SDLINE,CC," P",2) ;
         CC = CC + 2 ;
         CALL  BINDEC (SDLINE,CC,SQPC,4) ;
         CC =  CC + 4 ; 
         CALL  CHRCHR (SDLINE,CC," N",2) ;
         CC  = CC + 2 ; 
         CALL  BINDEC (SDLINE,CC,NTNOP,5) ; 
         CC = CC + 5 ;
         CALL  BINDEC (SDLINE,CC,NSNOP,3) ; 
         CC = CC + 3 ;
         CALL  CHRCHR (SDLINE,CC," S",2) ;
         CC = CC + 2 ;
         CALL  BINDEC (SDLINE,CC,NTSV,4) ;
         CC = CC + 4 ;
         CALL  BINDEC (SDLINE,CC,NSSV,2) ;
         CC = CC + 2 ;
         CALL CHRCHR (SDLINE,CC,"*R",2) ; 
         CC = CC + 2 ;
         CALL BINDEC (SDLINE,CC,NTOR,4) ; 
         CC = CC + 4 ;
         CALL  BINDEC ( SDLINE,CC,NSOR,2) ; 
  
      CONTROL SLOWLOOP; 
  
      END 
      $END
      CONTROL EJECT;
         FUNC FNDBREG (( I )) ; 
  
           BEGIN
           ITEM I,J,K;
           # FIND THE B REGISTER ASSOCIATED WITH OPERAND I  # 
  
      CONTROL FASTLOOP; 
  
           IF I GT 0 THEN 
             BEGIN    # SYMBOL TABLE INDEX  # 
             IF BREG[I] NQ 0 THEN 
               FNDBREG = BREG[I]; 
             ELSE 
               FNDBREG = -1;
             RETURN;
             END
  
         # ELSE ITS AN ICF OPERAND  # 
           K = BI - I;
           FNDBREG =0;
           FOR J = BREG1 STEP 1 UNTIL  BREG7 DO 
             IF RGMEM[J] NQ -1
             AND RGMEM[J] LS  ICFTW1
             THEN 
             IF K EQ RGMEM[J] 
             OR ( OPCD[RGMEM[J]] EQ QICFOP"INVI"
                AND I EQ OPN1[RGMEM[J]]      )
               THEN 
               FNDBREG = J; 
  
           RETURN;
  
      CONTROL SLOWLOOP; 
  
           END
CONTROL EJECT;
    PROC GBR00    ( REG, TR, TO ) ; 
         BEGIN
#**********************************************************************#
#     GBR00 - GET B-REGISTER                                           #
#                                                                      #
#     PURPOSE-                                                         #
#         SELECTS THE MOST AVAILABLE DEAD B-REG IF ONE EXISTS.  USED BY#
#         THOSE INSTRUCTIONS REQUIRING B-REG OUTPUT (NRMB,NRRB,UNPB)   #
#         SEARCHES ONLY THE TRANSIENT (NOT DEDICATED) BREGS.           #
#                                                                      #
#     INPUT-                                                           #
#         BRJ - NUMBER OF LAST DEDICATED B-REG                         #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#         REGFT ARRAY - THE REGISTER TIME-TO-BE-FREE ARRAY             #
#         CLOCK - CURRENT TIME                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         REG - SELECTED REGISTER OR -1 IF NONE AVAILABLE              #
#         XWRTR - TIME BEFORE REG CAN BE USED AS A RESULT              #
#         XWRTO - TIME BEFORE REG CAN BE USED AS AN OPERAND            #
#**********************************************************************#
  
  
         ITEM   REG,         #        OUTPUT REGISTER                  #
           TR,               #        TIME TO USE AS RESULT            #
           TO;               #        TIME TO USE AS OPERAND           #
         ITEM   BWR , 
           BWRT;
  
  
#     NOTICE THAT IF WE EVER ALLOW BRJ GE 6 THEN THE FOLLOWING CONTROL #
#     FASTLOOP WILL HAVE TO BE REMOVED.                                #
  
         CONTROL FASTLOOP;
  
  
             $BEGIN 
             DB("( 9X17H GBR00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,
               REGK,"."); 
             $END 
  
         REG  =  - 1   ;     #ASSUME NONE AVAILABLE                    #
         BWR  =   -1 ;
  
#     SEARCH THROUGH THE NON-DEDICATED B-REG MEMORY LOOKING FOR THE    #
#     MOST AVAILABLE REG (THE ONE WITH THE SMALLEST DELAY BEFORE IT CAN#
#     BE USED).                                                        #
  
         FOR I =  BRJ + 1 BY 1 UNTIL  BREG7  DO 
             BEGIN
             IF  RGVAL  [I]  LT  0  THEN
                 BEGIN       #FOUND AN AVAILABLE REG# 
  
#     IF THIS IS THE FIRST AVAILABLE REG FOUND OR IF IT IS THE BEST -  #
#     KEEP TRACK OF IT                                                 #
  
                 IF BWR LT 0 OR (RRFT[I] - CLOCK LS BWRT) THEN
                     BEGIN
                     BWR  = I  ;
                     BWRT  =  RRFT [I] - CLOCK ;
                     END
                 END
             END
  
#     FINISHED SEARCH.  IF WE FOUND A REG WE SET THE OUTPUT PARAMS.    #
#     OTHERWISE REG = -1 INDICATES FAILURE.                            #
  
         IF BWR GE BREG0  THEN
             BEGIN
             REG  =  BWR ;
             TR   =  BWRT;
             TO   =  ROFT [ BWR ] - CLOCK ; 
             IF TR LS 0 THEN
                 TR = 0 ; 
             IF TO LS 0 THEN
                 TO = 0 ; 
             END
  
         CONTROL SLOWLOOP;
  
  
         END
      CONTROL EJECT;
    PROC GIU00    ; 
         BEGIN    #  GIU00    # 
#**********************************************************************#
#     GIU00 - GET INCREMENT UNIT                                       #
#                                                                      #
#     PURPOSE-                                                         #
#         SELECT MOST FREE INCREMENT UNIT                              #
#                                                                      #
#     INPUT-                                                           #
#         NONE                                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         FUNU = SELECTED UNIT                                         #
#**********************************************************************#
  
         IF FACL [ INCU1 ]  LE  FACL [ INCU2 ]
         THEN     FUNU = INCU1  ; 
         ELSE     FUNU = INCU2  ; 
  
      $BEGIN
      DB("(10X16HGIU00      IJK  3(O2,2X),6HFUNU= ,O6)",REGI,REGJ,REGK
          ,FUNU,"."); 
      $END
  
         RETURN   ; 
         END      #  GIU00    # 
CONTROL EJECT;
    PROC GLR00    ( REG )  ;
         BEGIN
#**********************************************************************#
#     GLR00 - GET LOAD REGISTER                                        #
#                                                                      #
#     PURPOSE-                                                         #
#         SELECTS THE MOST AVAILABLE LOAD REGISTER (X1-X5) IF ONE      #
#         EXISTS.  SEARCH BEGINS WITH THE LAST PREVIOUS LOAD REGISTER  #
#         CHOSEN.                                                      #
#                                                                      #
#     INPUT-                                                           #
#         LLRCH - LAST LOAD REGISTER CHOSEN                            #
#         LRINX ARRAY - THE CIRCULAR LOAD REGISTER ARRAY               #
#         FREZA1 - TRUE IF THIS IS PROLOG CODE (CAN"T ASSIGN X1)       #
#         FREZA2 - TRUE IF THIS IS PROLOG CODE AND ONE OF THE FORMALS  #
#                  IS A LONG CHAR ITEM (CAN"T ASSIGN X2)               #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#         REGFT ARRAY - THE REGISTER TIME-TO-BE-FREE ARRAY             #
#         CLOCK - CURRENT TIME                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         REG - SELECTED REGISTER OR -1 IF NONE AVAILABLE              #
#         XWRTR - TIME BEFORE REG CAN BE USED AS A RESULT              #
#         XWRTO - TIME BEFORE REG CAN BE USED AS AN OPERAND            #
#**********************************************************************#
  
  
         ITEM   REG  ;
         ITEM   TT1 I ; 
         ITEM   TT2 I ; 
  
  
         CONTROL FASTLOOP;
  
  
             $BEGIN 
             DB("( 9X17H GLR00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,
               REGK,"."); 
             $END 
  
         REG  =   -1 ;       #ASSUME NONE AVAILABLE                    #
         IF  LLRCH  GT 5  THEN
             LLRCH =  0  ;
  
#     SEARCH THROUGH THE X-REG MEMORY STARTING WITH THE LAST ONE CHOSEN#
#     LOOKING FOR AN AVAILABLE ONE.                                    #
  
         FOR   I =  LLRCH + 1 BY 1  UNTIL LLRCH + 5  DO 
             BEGIN
             TT2  =   LRIX [I]  ;   #NEXT X-REG NUMBER                 #
             IF  FREZA1 AND  TT2 EQ XREG1  THEN 
                 TEST;       #PROC PROLOG CODE - CAN"T ASSIGN X1       #
             IF FREZA2 AND TT2 EQ XREG2 THEN
                 TEST;
             IF  RGMEM [TT2]  LT  0  THEN 
                 BEGIN       #FOUND AVAILABLE REG#
                 IF  RRFT [TT2] LT  CLOCK  THEN 
                     BEGIN   #NO DELAY NECESSARY BEFORE REG CAN BE USED#
                     REG = TT2  ; 
                     XWRTR =  0 ; 
                     XWRTO =  0 ; 
                     RETURN;
                     END
                 ELSE 
  
#     FOUND AN AVAILABLE REGISTER BUT HAVE TO WAIT UNTIL IT CAN BE USED#
#     PICK THE BEST ONE OF THIS TYPE.                                  #
  
                     BEGIN
                     TT1 =  RRFT [TT2] - CLOCK ;
  
#     IF THIS IS THE FIRST AVAILABLE-BUT-HAVE-TO-WAIT REGISTER WE HAVE #
#     FOUND OR IF IT IS BETTER (LESS TIME TO WAIT) THAN ANY PREVIOUS   #
#     ONE THAT WE HAVE COME ACROSS THEN SET OUTPUT VALUES.             #
  
                     IF REG LT 0  OR TT1 LT XWRTR  THEN 
                         BEGIN
                         REG = TT2 ;
                         XWRTR = TT1 ;
                         XWRTO = ROFT [TT2] - CLOCK ; 
                         IF XWRTO LT 0 THEN 
                             XWRTO = 0 ;
                         END
                     END
                 END
             END
  
         CONTROL SLOWLOOP;
  
         END
CONTROL EJECT;
    PROC GMU00    ; 
         BEGIN    #  GMU00    # 
#**********************************************************************#
#     GMU00 - GET MULTIPLY UNIT                                        #
#                                                                      #
#     PURPOSE-                                                         #
#         SELECT MOST FREE MULTIPLY UNIT                               #
#                                                                      #
#     INPUT-                                                           #
#         NONE                                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         FUNU = SELECTED UNIT                                         #
#**********************************************************************#
  
         IF FACL [ MULU1 ]  LE  FACL [ MULU2 ]
         THEN     FUNU  =  MULU1  ; 
         ELSE     FUNU  =  MULU2  ; 
  
      $BEGIN
      DB("(10X16HGMU00      IJK  3(O2,2X),6HFUNU= ,O6)",REGI,REGJ,REGK
          ,FUNU,"."); 
      $END
  
         END      #  GMU00    # 
CONTROL EJECT;
    PROC GWR00    ( REG )  ;
         BEGIN
#**********************************************************************#
#     GWR00 - GET WORK REGISTER                                        #
#                                                                      #
#     PURPOSE-                                                         #
#         SELECTS THE MOST AVAILABLE DEAD X-REGISTER IF ONE EXISTS.    #
#         CALLED BY ALL OF THE STATUS ROUTINES TO OBTAIN A REGISTER TO #
#         HOLD A COMPUTATION RESULT                                    #
#                                                                      #
#     INPUT-                                                           #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#         REGFT ARRAY - THE REGISTER TIME-TO-BE-FREE ARRAY             #
#         CLOCK - CURRENT TIME                                         #
#                                                                      #
#     OUTPUT-                                                          #
#         REG - SELECTED REGISTER OR -1 IF NONE AVAILABLE              #
#         XWRTR - TIME BEFORE REG CAN BE USED AS A RESULT              #
#         XWRTO - TIME BEFORE REG CAN BE USED AS AN OPERAND            #
#**********************************************************************#
  
  
         ITEM   REG ; 
         ITEM   TT1 ;        #        TEMP                             #
  
  
         CONTROL FASTLOOP;
  
  
         REG  =   -1  ;      #ASSUME NONE AVAILABLE                    #
  
#     SEARCH THROUGH THE X-REGISTER MEMORY LOOKING FOR AN AVAILABLE ONE#
  
         FOR  I  = XREG0  STEP 1  UNTIL XREG7   DO
             BEGIN
             IF RGMEM [I]  LT  0  THEN
                 BEGIN       #FOUND AVAILABLE X-REG#
                 IF ROFT [I] LT CLOCK THEN
                     BEGIN   #NO DELAY NECESSARY BEFORE REG CAN BE USED#
                     REG = I ;
                     XWRTO = 0  ; 
                     XWRTR = RRFT [I] - CLOCK  ;
                     IF XWRTR LT 0 THEN 
                         XWRTR = 0  ; 
  
      $BEGIN
      DB("(10X16HGWR00      IJK  3(O2,2X),5HREG= ,O6,8H XWRTO= ,O6, 
          8H XWRTR= ,O6)",REGI,REGJ,REGK,REG,XWRTO,XWRTR,".");
      $END
                     RETURN ; 
                     END
                 ELSE 
  
#     FOUND AN AVAILABLE REGISTER BUT HAVE TO WAIT UNTIL IT CAN BE USED#
#     PICK THE BEST ONE OF THIS TYPE.                                  #
  
                     BEGIN
                     TT1 = ROFT [I] - CLOCK  ;
  
#     IF THIS IS THE FIRST AVAILABLE-BUT-HAVE-TO-WAIT REGISTER WE HAVE #
#     FOUND OR IF IT IS BETTER (LESS TIME TO WAIT) THAN ANY PREVIOUS   #
#     ONE THAT WE HAVE COME ACROSS THEN SET OUTPUT VALUES.             #
  
                     IF REG LT 0 OR TT1 LS XWRTO THEN 
                         BEGIN
                         REG = I ;
                         XWRTO = TT1  ; 
                         XWRTR = RRFT [I] - CLOCK  ;
                         IF XWRTR LT 0 THEN 
                             XWRTR = 0  ; 
                         END
                     END
                 END
             END
  
         CONTROL SLOWLOOP;
  
         END
CONTROL EJECT;
#        CREATE AN ENTRY IN ICFT    # 
#        IINSK WILL SET  CNO OF THE OP TO ITSELF                       #
#              WILL SET REFCT OF THE  OP TO 1                          #
#                        PFF1  TO  PRIOP                               #
#        THE ABOVE IS USUALLY CORRECT                                  #
#        WHEN NOT THE CALLER MUST FIX IT                               #
#                                                                      #
      PROC IINSK((OPC),(OP1),(OP2));
         BEGIN    #  IINSK  # 
         ITEM     OPC,
                  OP1,
                  OP2;
  
      $BEGIN
      DB("(10X16HIINSK      IJK  3(O2,2X),5HOPC= ,A4,6H OP1= ,O6, 
          6H OP2= ,O6,8H ICFTJ= ,O6)",REGI,REGJ,REGK,BCDOP[OPC],OP1,OP2 
          ,ICFTJ,".");
      $END
  
         IF ICFTJ LE ICFTI THEN 
                                                            BEGIN #1# 
                   XREF PROC ICOVRFL; 
                   ICOVRFL;    # CALL ICFT OVERFLOW ROUTINE TO RESCHED #
                  GOTO  CFC00  ;
                                                            END   #1# 
         ICFW0 [ICFTJ] = 0 ;
         ICFW1 [ICFTJ] = 0 ;
         ICFW2[ICFTJ] = 0 ; 
         ICFW3[ICFTJ] = 0 ; 
         ICFW4[ICFTJ] = 0 ; 
         ICFW5[ICFTJ] = 0;
         OPCD [ICFTJ] = OPC ; 
         OPN1 [ICFTJ] = OP1 ; 
         OPN2 [ICFTJ] = OP2 ; 
         PFF  [ICFTJ]  = PRIOP ;    #   PRIORITY                       #
         REFCT [ICFTJ] = 1 ;        #   REF COUNT                      #
         CNO  [ICFTJ]  = ICFTJ ;    #   COMPUTATION NUMBER             #
      BCHN[ICFTJ] = ICFTJ;   #BASE ONLY CHAIN#
      BSCHN[ICFTJ] = ICFTJ;  #BASE+SUBS CHAIN#
         ICFTJ = ICFTJ - 1 ;
         END      #  IINSK  # 
CONTROL EJECT;
#        GET SOME POTENTIAL INSERTION NUMBERS     A  - D               #
    PROC INN00    ; 
         BEGIN    #      INN00                                         #
#                                                                      #
         INSOPA = ICFTJ   ; 
         INSOPB = ICFTJ-1 ; 
         INSOPC = ICFTJ-2 ; 
         INSOPD = ICFTJ-3 ; 
         INSOPE = ICFTJ-4 ; 
#                                                                      #
         NINSA  = BI  -  INSOPA  ;  #   ICF  NEGATIVE POINTERS         #
         NINSB  = BI  -  INSOPB  ;
         NINSC  = BI  -  INSOPC  ;
         NINSD  = BI  -  INSOPD  ;
         NINSE  = BI  -  INSOPE  ;
         END      #      IIN00                                         #
CONTROL EJECT;
     PROC   IRM00   ; 
         BEGIN               #IRM00                                    #
  
#        INITIALIZE REGISTER MEMORIES AT START OF SEQUENCE             #
  
         CONTROL FASTLOOP;
  
#        SET ALL REGISTER CONTENTS UNKNOWN                             #
  
         FOR  I =  BRI   BY  1  UNTIL  SUDOR  DO
             BEGIN
             RGMEM  [I]  = -1 ; 
             END
  
#        AT EACH  SEQUENCE  DESTROY REGISTER MEMORY HISTORY            #
  
         FOR  I  =  0  BY  1  UNTIL  RHENT   DO 
             BEGIN
             RHIST [I] =  -1 ;
             END
         FOR  I  =  0  BY 1 UNTIL NOFACL DO 
             BEGIN
             FACL  [I]  =  0  ; 
             END
      FOR I = 0 STEP 1 UNTIL SUDOR DO 
             BEGIN
             REGFTI  [I]  =  0  ; 
             END
         CLOCK =  0 ; 
         BRDVN =  0 ;        #         DEDICATED B-REG INVIS           #
      BRK = 0;               #NUM OF B-REGS RESERVED FOR BPSB S#
         RPFRC =  FALSE ; 
         NUNOP  =  0  ; 
         CLCI  =  CLC [0]  ; #          SAVE INITIAL CLC               #
         SAVECLC = CLC[0];   #   SAVE FOR JAM MODE                     #
         WDT  =   4  ;
         WDP  =  WDT + 1  ; 
         LGEN  =  PSOS   ;
         LLRCH  =  0 ;
         LODPINP = FALSE; 
         LCMINP = FALSE;                                                 LCMISC 
         ICFTJ = ICFTJ - 1  ;   #       SKIP LAST INSERTED BY PASS 1   # LCMISC 
             $BEGIN 
             NSNOP  = 0 ; 
             NSOR   = 0 ; 
             NSSV   = 0 ; 
             SDLY   = 0 ; 
             NREDY  = 0 ; 
             NSCN   = 0 ; 
             $END 
  
         CONTROL SLOWLOOP;
  
         END                 #IRM00                                    #
CONTROL EJECT;
#        INITIALIZE READY SET AT  START OF SEQUENCE                    #
PROC     IRS00    ; 
         BEGIN    #      IRS00                                         #
IRS05:  
#        INDEX OF FIRST READY ICFT OP                                  #
         XPRS  =  ICFTJ ; 
#        MAKE FIRST READY OP A PSEUDO  DUMMY OP                        #
         CALL  IINSK ( QICFOP"PSCP", 0, 0 ) ; 
         FOL  [XPRS] = PSOS ;       #  START OF SEQUENCE               #
         FOL  [PSOS] = PSOS ; 
         INXA  =  XPRS ;
         INX   =  PSOS ;
IRS10:  
#        THE FIRST READY OP IN THE READY SET WILL ALWAYS BE THE        #
#        INSERTED DUMMY PSEUDO COMPUTATION                             #
#        THE PURPOSE OF THIS IS TO INSURE THAT THERE IS ALWAYS A       #
#        PREVIOUS OP IN THE READY SET                                  #
#        NOW REDUCE  PREDECESSOR COUNT OF THE INITIAL SOS              #
         CALL  RPC00 ;
#        A READY SET NOW EXISTS                                        #
         END      #      IRS00                                         #
CONTROL EJECT;
#        ISL00    INSERT LOAD       # 
#        INSERTION OF A LOAD            # 
#        DUE TO AN UNLOADED X OPERAND   # 
#        INX IS CAUSING INSTRUCTION # 
#        TOP IS COMPUTATION         # 
#        IF TOP IS IN TEMP :        # 
#                 INSERT SIMPLE LOAD OF TEMP      # 
#                 CNO  IS  TOP                    # 
#                 INX IS SUCCESSOR                # 
#                 INX IS REMOVED FROM  READY SET  # 
#                 WITH PREDECESSOR COUNT SET TO 1 # 
#        IF TOP IS A SIMPLE LOAD    # 
#                 INSERT THE LOAD JUST AS IN #
#                 TEMP LOAD ABOVE   # 
#        IF TOP IS A SPECIAL CONSTANT        #
#        INSERT THE ONE OR TWO REQUIRED INSTRUCTIONS   #
#        THE LAST INSERTED INSTRUCTION  # 
#        WILL HAVE CNO AS TOP AND INX AS SUCCESSOR     #
#        LIKE ABOVE                 # 
    PROC ISL00    ( KPOP, SOP ) ; 
         BEGIN    #  ISL00   #
         ITEM     KPOP I ;          #   COMP                           #
         ITEM     SOP  I ;          #   COMP TO SAVE                   #
         ITEM     POP  I ;
  
      $BEGIN
      DB("(10X12HISL00,KPOP= ,O6,6H SOP= ,O6)",KPOP,SOP,"."); 
      $END
  
         POP  =   KPOP ;
ISL01:  
         IF NOT LIP [POP] THEN GOTO ISL015  ; 
         CALL  PRK00 (POP)  ; 
#        PRK00 MAY NOT RETURN                                          #
         IF ILDLOK AND SPRISL THEN GOTO ISLSXR ; #  SPECIAL RETURN     #
         SPRISL = FALSE  ;
         IF ILDLOK THEN GOTO CSCAN  ; 
ISL015: 
#        INSERT A LOAD OF POP                                          #
         INSOPA  =  ICFTJ  ;
ISL02:  
         IF  BREGL [POP] GT 0   THEN    #  COMP(POP) IS IN A B-REG     #
                                                            BEGIN #1# 
#        COMP IS  NOW IN B-REG                                         #
         CALL  IINSK ( QICFOP"LODP", BI-POP, SOP ) ;
               GOTO ISL20 ; 
                                                            END   #1# 
ISL05:  
         IF  TSYM [POP] GT 0 THEN 
                                                            BEGIN #1# 
         CALL  IINSK ( QICFOP"LODP", TSYM [POP], SOP ) ;
                  GOTO  ISL10 ; 
                                                            END   #1# 
#        EITHER A CONSTANT LOAD OR A SCALAR LOAD  # 
         IF OPCD [POP] NE QICFOP"LDSC" AND
                   OPCD[POP] NE QICFOP"MSKL" AND
                   OPCD[POP] NE QICFOP"MSKC" AND
            OPCD [POP] NE QICFOP"MASK" THEN 
                                                            BEGIN #1# 
             CG2ABT(J860,"CANT INSERT LOAD(ISL00 IN CODGK1S) LINE XXXXX"
                    ,45); 
                    GOTO CFC00 ;
                                                            END   #1# 
         CALL  IINSK ( OPCD [POP], OPN1 [POP], SOP ) ;
         KDES  [INSOPA]  =  KDES  [POP]   ; 
ISL10:  
ISL20:  
         CNO [INSOPA]  =  POP  ;
#        INSOPA HAS NO PREDECESSORS                                    #
#        INSERT INTO READY SET  BUT LEAVE INX IN READY SET             #
         LIP [POP] = TRUE  ;        #   LOAD IN PROCESS                #
         AINVS [POP] = TRUE  ;      #   LOADED FROM TEMP IF SAVE       #
         AT  [INSOPA] =  AT [ POP ] ; 
         CISR  [INSOPA] =  CISR [POP] ; 
IRSIA:  
         FOL [INXA] = INSOPA  ; 
         FOL [INSOPA] =  INX ;
         INX  =  INSOPA ; 
         GOTO  RESCAN ; 
ISLSXR: 
         SPRISL = FALSE  ;
         END      #      ISL00                                         #
CONTROL EJECT;
#        ENCODE AN ADDRESS REFERENCE         #
#        INPUT:                              #
#                 OPER :  ICFT PTR TO LOAD, STORE, LOC      # 
#        OUTPUT:                                                       #
#                 ABAJ              # 
#                 OFFST             # 
#                 ASUB              # 
#                 ABSO              # 
      PROC NCA00((LSLP)); 
         BEGIN    # NCA00  #
         ITEM 
                  LSLP ,
                  OPER ,
                  OPER2  ;
         OFFST =  0 ; 
         ABAS  =  0 ; 
         ASUBI = 0 ;
         ABOF  =  0 ; 
         SUBRG =  0 ; 
         ABSO  =  0  ;
         SCOMP =  -1 ;
         OPER  =  OPN1 [LSLP] ; 
         IF  OPER LT 0  THEN GOTO  NCA15  ; 
#        OPERAND IS SYMBOL TABLE POINTER                               #
         ABAS =   OPER  ; 
         GOTO     NCA30 ; 
NCA15:  
         OPER  =  BI - OPER  ;
         IF  OPCD[OPER] NE QICFOP"OFFS" 
         AND OPCD[OPER] NE QICFOP"PFUN" THEN GOTO NCA20;
#        OFFSET TYPE OF ADDRESSING                                     #
         ABAS  =  OPN1 [ OPER ] ; 
         OFFST =  OPN2 [ OPER ] ; 
         GOTO     NCA30 ; 
#        SUBS                                                          #
NCA20:  
         IF  OPCD [OPER] NE  QICFOP"SUBS" THEN GOTO  NCA35 ;
         ASUBI = OPN2[OPER];
         SCOMP =  ASUB  ; 
         SUBRG  =  XREGL  [ASUB]   ;
         SRUSC  = REFCT [ASUB]  ; 
         ABAS =   OPN1 [ OPER ] ; 
         IF  ABAS  GE 0 THEN GOTO NCA30   ; 
#        SUBS USES OFFSET                                              #
         OPER2 =   BI - ABAS  ; 
         ABAS  =   OPN1 [ OPER2 ] ; 
         OFFST =   OPN2 [ OPER2 ] ; 
#        PACK THE  ENCODED ADDRESS  # 
NCA30:  
         CALL  PWA00 ( ABAS ) ;     #   PART WORD ADJUSTMENT           #
         ACTQ  [1]  = AT [LSLP] ;   #   ACCESS TYPE                    #
         ABASP [1]  = ABAS   ;
         AOFSP [1]  = OFFST  ;
#                                                                      #
         ASUBP[1] = ASUBI;
         ABSO  =  ABSOP  [1]  ; 
         ABOF  =  ABSOP [1]   LAN  NOSUBM   ;     # BASE + OFFSET      #
NCA35:  
$BEGIN                                                                   LCMISC 
DB("(9H    NCA00 2X,O2,2X,O2,2X,O2, 7H  ABSO= O20, 7H  LSLP= O6 )",      LCMISC 
     REGI,REGJ ,REGK,ABSO,LSLP,"." );                                    LCMISC 
$END                                                                     LCMISC 
         END      # NCA00 # 
CONTROL EJECT;
#        RKOP IS  RECOMPUTED COMP                                      #
#        SCAN READY SET FROM THE TOP FOR THE COMP OF  RKOP             #
#        IF IT EXISTS BEFORE  INX THEN CONTINUE SCAN   (CSCAN)         #
#        OTHERWISE FIND THE COMP OF RKOP AND PUT IT IN FRONT OF        #
#        INX AND RESCAN                                                #
#                                                                      #
      PROC PRK00((KOMP)); 
         BEGIN    #      PRK00                                         #
         ITEM     KOMP I ;
         ITEM     RKOP I ;
         ITEM     CMPSCA I  ;       #   PREVIOUS COMP SEARCH NO.       #
         ITEM     CMPSC  I  ;       #   CURRENT                        #
         RKOP  =  KOMP  ; 
         ILDLOK = FALSE  ;
         CMPSCA = XPRS  ;           #   PREVIOUS COMP                  #
         CMPSC =  FOL [XPRS]  ;     #   COMP BEING SCANNED             #
PRK10:  
      IF CMPSC LT 0 THEN RETURN;       #RKOP NOT THERE# 
         IF CMPSC EQ INX THEN GOTO PRK43 ;  # RKOP BELOW INX           #
         IF  CNO [CMPSC] EQ RKOP  THEN  GOTO PRK50 ;   # RKOP FOUND    #
#        RKOP NOR INX REACHED YET                                      #
         CMPSCA = CMPSC  ;          #   PREVIOUS                       #
         CMPSC =  FOL [CMPSC] ;     #   NEXT COMP IN READY SET         #
         GOTO  PRK10 ;
#                                                                      #
#        RKOP NOT ABOVE INX                                            #
PRK41:  
         IF  CNO [CMPSC] EQ RKOP THEN  GOTO  PRK45  ;  # RKOP FOUND    #
PRK43:  
         CMPSCA = CMPSC  ;
         CMPSC  = FOL [CMPSC] ;     #   NEXT COMP IN READY SET         #
         IF CMPSC GE 0  THEN GOTO PRK41 ; 
#        END OF READY SET                                              #
      RETURN; 
#        RKOP AT  CMPSC                                                #
#        MOVE IT TO ABOVE INX IN READY SET                             #
PRK45:  
         FOL  [CMPSCA]  = FOL [CMPSC]  ;
         FOL  [INXA] = CMPSC  ; 
         FOL  [CMPSC] =  INX ;
#        GO RIGHT BACK TO MASTER CONTROL AT RESCAN ENTRY POINT         #
         INX = CMPSC ;
         GOTO  RESCAN  ;
#        COMP IS ABOVE CURRENT INX                                     #
#        GO BACK TO CONTINUE THE SCAN                                  #
PRK50:  
         ILDLOK = TRUE  ; 
#                                                                      #
#        RETURN  TO INSERT THE LOAD                                    #
         END      #      PRK00                                         #
CONTROL EJECT;
         PROC PWA00((SPI)); 
         BEGIN    #      PWA00                                         #
#**********************************************************************#
#     PWA00 - PART WORD ADDRESS MODIFICATION                           #
#                                                                      #
#     PURPOSE-                                                         #
#         ENCODED ADDRESSES OF TITMS ARE ALWAYS OFFSETS FROM THEIR     #
#         MAMAS.  GIVEN A S.T.P. TO AN ITEM, IF IT IS A TITM- PWA00    #
#         SETS ABAS TO THE TITM"S MAMA AND ADJUSTS OFFST.              #
#                                                                      #
#     INPUT-                                                           #
#         SPI - SYMBOL TABLE POINTER TO ITEM                           #
#         OFFST - OFFSET TO SPI SO FAR                                 #
#                                                                      #
#     OUTPUT-                                                          #
#         ABAS - S.T.P. TO MAMA IF SPI IS A TITM                       #
#         OFFST - OFFSET OF SPI TO ITS MAMA IF SPI IS A TITM           #
#**********************************************************************#
  
  
         ITEM     SPI  I ;          #   S.T.P OF ITEM IN QUESTION      #
  
  
         IF SPI EQ 0 THEN  RETURN;                                       LARRY-R
         IF CLAS[SPI] EQ QCLAS"TITM"
         THEN 
                 BEGIN
                  ABAS =  MAMA [SPI] ;  #  NEW ENCODED BASE            #
                 OFFST = OFFST + (LOCN[SPI] - LOCN[ABAS]);
                 END
         END      #      PWA00                                         #
CONTROL EJECT;
    PROC SAC00    ((ENCAD),REG , KOF ) ;
         BEGIN
#**********************************************************************#
#     SAC00 - SEARCH A-REGISTER CONTENTS                               #
#                                                                      #
#     PURPOSE-                                                         #
#         SEARCH THE A-REG MEMORY FOR A GIVEN ENCODED ADDRESS.  IF AN  #
#         A-REG CONTAINS THE SPECIFIED ADDRESS RETURN REG NUMBER AND   #
#         ANY OFFSET REQUIRED.                                         #
#                                                                      #
#     INPUT-                                                           #
#         ENCAD - ENCODED ADDRESS                                      #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#                                                                      #
#     OUTPUT-                                                          #
#         REG - NUMBER OF REG CONTAINING ENCAD OR -1 IF NONE FOUND     #
#         KOF - OFFSET REQUERED FROM THE ADDRESS IN REG                #
#**********************************************************************#
  
         ITEM   ENCAD ;      #        ENCODED ADDRESS                  #
         ITEM   REG   ;      #        REGISTER                         #
         ITEM   KOF   ;      #        OFFSET                           #
  
         CONTROL FASTLOOP;
  
         $BEGIN 
         DB("(9X17H SAC00      IJK  3(O2,2X),7HENCAD= ,O20)",REGI,REGJ, 
             REGK,ENCAD,"."); 
         $END 
  
         RGVAL[SUDOR+1] = ENCAD;   #USE SPARE WORD AT END OF REGMEM#
         REG   =  -1 ;       #ASSUME FAILURE                           #
         KOF   =  0  ;
  
#     SEARCH THROUGH THE A-REG MEMORY LOOKING FOR ENCAD (OR AT LEAST   #
#     ENCAD WITH SOME OTHER OFFSET).                                   #
  
         FOR I =  AREG1 BY 1  UNTIL AREG7   DO
             IF BRBSBA[I] EQ BRBSBA[SUDOR+1]
             THEN 
                 BEGIN       #SAME (BASE,SUBS,AT)#
                 REG = I; 
                 KOF = BROFS[SUDOR+1] - BROFS[I]; 
                 $BEGIN 
                 DB("(10X11HSAC00,REG= O2,5H KOF= O20)",REG,KOF,"."); 
                 $END 
                 IF KOF EQ 0
                 THEN 
                     RETURN; #SAME (BASE,SUBS,AT,OFFS)# 
                 END
  
         CONTROL SLOWLOOP;
  
         END
CONTROL EJECT;
    PROC SBC00    ((ENCAD),REG, KOF ) ; 
         BEGIN
#**********************************************************************#
#     SBC00 - SEARCH B-REGISTER CONTENTS                               #
#                                                                      #
#     PURPOSE-                                                         #
#         SEARCH THROUGH THE B-REG ADDRESS MEMORY FOR A GIVEN ENCODED  #
#         ADDRESS.  THE B-REG ADDRESS MEMORY INDICATES THOSE B-REGS    #
#         THAT CONTAIN AN ADDRESS.  THIS ARISES VIA BRAIS OR BPSB      #
#         COMPUTATIONS.                                                #
#                                                                      #
#     INPUT-                                                           #
#         ENCAD - ENCODED ADDRESS                                      #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#                                                                      #
#     OUTPUT -                                                         #
#         REG - NUMBER OF REG CONTAINING ENCAD OR -1 IF NONE FOUND     #
#         KOF - OFFSET REQUERED FROM THE ADDRESS IN REG                #
#**********************************************************************#
  
         ITEM   ENCAD,
           REG  , 
           KOF  ; 
  
         CONTROL FASTLOOP;
  
         $BEGIN 
         DB("(9X17H SBC00      IJK  3(O2,2X),7HENCAD= ,O20)",REGI,REGJ, 
             REGK,ENCAD,"."); 
         $END 
  
         RGVAL[SUDOR+1] = ENCAD;   #USE SPARE WORD AT END OF REGMEM#
         REG   =  -1 ;       #ASSUME FAILURE                           #
         KOF   =  0  ;
  
#     SEARCH THROUGH THE B-REGS TRYING TO FIND ENCAD.                  #
#     FAILING THAT TRY TO FIND ENCAD WITH A DIFFERENT OFFSET.          #
  
      FOR I = BREG1+BADOFS STEP 1 UNTIL BREG7+BADOFS DO 
             IF BRBSBA[I] EQ BRBSBA[SUDOR+1]
             THEN 
                 BEGIN       #SAME (BASE,SUBS,AT)#
                 REG = I - BADOFS;     #RETURN A B-REG NUMBER#
                 KOF = BROFS[SUDOR+1] - BROFS[I]; 
                 $BEGIN 
                 DB("(10X11HSBC00,REG= O2,5H KOF= O20)",REG,KOF,"."); 
                 $END 
                 IF KOF EQ 0
                 THEN 
                     RETURN; #SAME (BASE,SUBS,AT,OFFS)# 
                 END
  
         CONTROL SLOWLOOP;
  
         END                 #SBC00                                    #
          CONTROL EJECT;
      PROC SBK00((K),REG);
      BEGIN 
#**********************************************************************#
#         SBK00 - SEARCH B-REGISTER CONTENTS                           #
#                                                                      #
#         PURPOSE-                                                     #
#                SEARCH B-REG CONTENTS FOR A GIVEN CONSTANT            #
#                                                                      #
#         INPUT-                                                       #
#                K = CONSTANT TO SEARCH FOR                            #
#                REGMEM ARRAY - THE REGISTER MEMORY ARRAY              #
#                                                                      #
#         OUTPUT-                                                      #
#                REG = -1 IF K NOT FOUND ELSE = NUM OF REG HOLDING K   #
#**********************************************************************#
  
  
      ITEM K;                #CONSTANT TO SEARCH FOR# 
      ITEM REG;              #RESULT# 
      ITEM I;                #TEMP - INDUCTION VARIABLE#
      ITEM J;                #TEMP - RGMEM[I]                          #
  
  
      CONTROL FASTLOOP; 
  
  
      IF K EQ 0 
      THEN
          REG = BREG0;       #B0 ALWAYS CONTAINS 0# 
      ELSE
          BEGIN 
          REG = -1;          #ASSUME FAILURE# 
          FOR I = BREG1 STEP 1 UNTIL BREG7 DO 
              BEGIN 
              J = RGMEM[I]; 
              IF J NQ -1     #NOT A DEAD REG# 
                  AND J LS ICFTW1      #NOT AN ENCODED ADDRESS# 
                  AND OPCD[J] EQ QICFOP"INVI" 
                  AND K EQ KDES[J]
                  AND CLAS[OPN1[J]] EQ QCLAS"CONS"
                  THEN
                      REG = I;
              END 
          END 
  
          $BEGIN
          DB("(10H SBK00,K= ,O6,6H REG= ,O6)",K,REG,"."); 
          $END
  
      CONTROL SLOWLOOP; 
      END 
CONTROL EJECT;                                                           LARRY-R
    PROC SXAC ( (ENCAD) , REG , KOF );                                   LARRY-R
         BEGIN                                                           LARRY-R
#**********************************************************************#
#     SXAC - SEARCH X-REG ADDRESS CONTENTS                             #
#                                                                      #
#     PURPOSE-                                                         #
#         SEARCHES THE X-REG ADDRESS MEMORY FOR A GIVEN ENCODED        #
#         ADDRESS.  THE X-REG ADDRESS MEMORY INDICATES THOSE X-REGS    #
#         THAT CONTAIN AN ADDRESS AS A RESULT OF ISSUING A LODP OR A   #
#         REPL INTO A PFUN.  THIS ROUTINE IS CALLED BY THE PROCESSORS  #
#         OF LOAD/REPL/BRAI/LOC OF INDIRECT VARIABLES IN ORDER TO SAVE #
#         ISSUING LODP S.                                              #
#                                                                      #
#     INPUT-                                                           #
#         ENCAD - ENCODED ADDRESS                                      #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY                      #
#                                                                      #
#     OUTPUT -                                                         #
#         REG - NUMBER OF X-REG CONTAINING ENCAD OR -1 IF NONE FOUND   #
#         KOF - OFFSET REQUERED FROM THE ADDRESS IN REG                #
#**********************************************************************#
                                                                         LARRY-R
         ITEM ENCAD ,        # ENCODED ADDRESS                         # LARRY-R
           REG ,             # REGISTER (OUTPUT PARAM )                # LARRY-R
           KOF  ;            # OFFSET                                  # LARRY-R
  
         CONTROL FASTLOOP;
  
                 $BEGIN 
         DB("(9X17H SXAC       IJK  3(O2,2X),7HENCAD= ,O20)",REGI,REGJ, 
             REGK,ENCAD,"."); 
         $END 
                                                                         LARRY-R
         REG = -1;                                                       LARRY-R
         KOF  =0;            #BY DEFINITION                            #
         RGVAL[SUDOR+1] = ENCAD;   #USE SPARE WORD AT END OF REGMEM#
         IF BRBA[SUDOR+1] EQ 0 THEN 
             RETURN;         #ALL ZREOS LOOK ALIKE                     #
                                                                         LCMISC 
         FOR I = XREG0+XADOFS STEP 1 UNTIL XREG7+XADOFS DO               LARRY-R
          IF BRBSB[I] EQ BRBSB[SUDOR+1]     #SAME (BASE,SUBS)#
               AND BRAT[I] EQ LOCACS[BRAT[SUDOR+1]] THEN
                 BEGIN
                 REG = I - XADOFS;   #          RETURN AN X-REG        # LARRY-R
                 KOF = BROFS[SUDOR+1] - BROFS[I]; 
         $BEGIN 
         DB("(10X11HSXAC ,REG= O2,5H KOF= O20)",REG,KOF,"."); 
         $END 
                 IF KOF EQ 0 THEN                                        LARRY-R
                     RETURN;                                             LARRY-R
                 END                                                     LARRY-R
                                                                         LARRY-R
         CONTROL SLOWLOOP;
  
         END
      CONTROL EJECT;
      PROC SXK00((K),REG);
      BEGIN 
#**********************************************************************#
#     SXK00 - SEARCH X-REGISTER CONTENTS                               #
#                                                                      #
#     PURPOSE-                                                         #
#         SEARCH THE X-REG CONTENTS FOR A GIVEN CONSTANT               #
#                                                                      #
#     INPUT-                                                           #
#         K = CONSTANT TO SEARCH FOR                                   #
#         REGMEM ARRAY - THE REGISTER MEMORY ARRAY                     #
#                                                                      #
#     OUTPUT-                                                          #
#         REG = -1 IF K NOT FOUND, ELSE = NUM OF REG HOLDING K         #
#**********************************************************************#
  
  
      ITEM K;                #CONSTANT# 
      ITEM REG;              #RESULT# 
      ITEM I;                #TEMP- INDUCTION VARIABLE# 
      ITEM J;                #TEMP- RGMEM[I]                           #
  
  
      CONTROL FASTLOOP; 
  
  
      REG = -1;              #ASSUME FAILURE# 
      FOR I= XREG1 STEP 1 UNTIL XREG7 DO
          BEGIN 
              J = RGMEM[I]; 
              IF J NQ -1     #NOT DEAD# 
                  AND OPCD[J] EQ QICFOP"LDSC" 
                  AND K EQ KDES[J]
          THEN
              REG = I;
          END 
  
      $BEGIN
          DB("(10H SXK00,K= ,O6,6H REG= ,O6)",K,REG,"."); 
      $END
  
      CONTROL SLOWLOOP; 
  
      END 
CONTROL EJECT;
      PROC TRO00((REG));
         BEGIN    #      TRO00                                         #
#**********************************************************************#
#     TRO00 - COMPUTE AVAILABILITY OF A REGISTER.                      #
#                                                                      #
#     PURPOSE-                                                         #
#         COMPUTES THE TIME REQUIRED FOR A REGISTER TO BECOME FREE AS  #
#         EITHER A RESULT OR OPERAND REGISTER.                         #
#                                                                      #
#     INPUT-                                                           #
#         REG = REGISTER NUMBER                                        #
#                                                                      #
#     OUTPUT-                                                          #
#         XWRTR = TIME REQUIRED BEFORE REG CAN BE USED AS A RESULT     #
#         XWRTO = TIME REQUIRED BEFORE REG CAN BE USED AS AN OPERAND   #
#**********************************************************************#
  
  
         ITEM     REG  I  ; 
  
  
         XWRTR = RRFT[REG] - CLOCK; 
         XWRTO = ROFT[REG] - CLOCK; 
         IF XWRTR LT 0 THEN XWRTR = 0  ;
         IF XWRTO LT 0 THEN XWRTO = 0  ;
  
         $BEGIN 
         DB("(9X17H TRO00      IJK  3(O2,2X),5HREG= ,O2,8H XWRTR= O20,
            8H XWRTO= O20)",REGI,REGJ,REGK,REG,XWRTR,XWRTO,".");
         $END 
         END       #      TRO00                                        #
      END 
      TERM
