*DECK CODGK3                                                             LARRY-R
USETEXT   TSOURCE 
USETEXT   TTARGET 
USETEXT   TCEXECQ 
USETEXT   TSYMCNS 
USETEXT   TREGNOS 
USETEXT   TCOM39Q 
USETEXT   TCOM78Q 
USETEXT   TCEXEC
USETEXT   TCOM88
USETEXT   TCOM88K 
  PROC CODGK3   ;                                                        LARRY-R
       BEGIN                # CODE GENERATION CONTROL   #                LARRY-R
                            # ENTERED AT CG00 AND CGIE   #               LARRY-R
  
  
  
  
*CALL COMEX 
  
  
  
  
#     DEFS                                                             #
  
      DEF J869 #869#;              # SYMABT DIAGNOSTIC 869             # CODGK3 
  
  
  
  
#     XREFS                                                            #
  
      XREF
          BEGIN 
          FUNC ACSTYPE;      #CALCULATE ACCESS TYPE#
          PROC BGA00;        #REGISTER AVAILABILITY SIMULATION# 
          PROC BGB00;        #LINK INSTR INTO GENERATED CODE CHAIN# 
          PROC CFW00; 
          LABEL CG2XIT;      #RETURN TO K1 AND THENCE TO J1#
          PROC CG2ABT;       #ISSUE ABORT FROM CG2                     #
          PROC CIE00;        #COMPUTE ISSUE AND EXECUTION TIMES#
          PROC CNO00;        #PROCESS NOP GENERATION# 
          LABEL CSCAN;       #CONTINUE SCANNING READY SET FROM FOL[INX]#
          PROC DB;           #DEBUG TRACE ROUTINE#
          PROC FGR00;        #FORGET REGISTERS# 
          PROC IINSK;        #INSERT INSTRUCTION INTO ICFT# 
          LABEL ISCAN;       #CONTINUE SCANNING READY SET FROM XPRS#
          PROC LINKOB;       #LINK ENTRY OUT OF BASE ONLY CHAIN#
          PROC LINKOBS;      #LINK ENTRY OUT OF BASE+SUBS CHAIN#
          PROC NCA00;        #ENCODE ADDRESS# 
          PROC ORP00;        #OUT OF REGISTER PROCESSOR#
          PROC RMH00;        #MAINTAIN REGISTER MEMORY HISTORY# 
          PROC RMI00;        #RECORD MINIMUM ISSUE INSTRUCTIONS#
          PROC RPC00;        #REDUCE PREDECESSOR COUNTS#
          PROC RRC00;        #REDUCE REFERENCE COUNT OF OPERANDS# 
          PROC SP00;         #TRY TO PREVENT NOP GENERATION#
          PROC SRP00; 
          PROC SSDH00;
          PROC SST00;        #COMPUTE STATUS OF INSTRUCTION#
          LABEL XX00;        #END OF INSTRUCTION TYPE SWITCH #
          END 
  
  
  
  
#     XDEFS                                                            #
  
      XDEF
          BEGIN 
          LABEL CFC00;       #CODE FILE WRITER CONTROL# 
          LABEL CGIE;        #CALCULATE ISSUE, EXECUTION TIMES AND     #
                             #STATUS BEFORE GENERATING INSTR           #
          LABEL CG00;        #SELECT INSTR FOR GENERATION              #
          LABEL NX00;        #NO EXECUTABLE OPS IN READY SET- PICK BEST#
                             #SCHED OR ISSUABLE OP AND GENERATE IT     #
          END 
  
  
  
  
#     SWITCHES                                                         #
  
#        CODE GENERATION SWITCH                                        #
SWITCH   CGSW 
         GU00,    #    TYPE 0  TREAT AS NULL STATEMENT                 #
         GA00 ,   #                                                    #
         GB00 ,   #                                                    #
         GC00 ,   #                                                    #
         GD00 ,   #                                                    #
         GE00 ,   #                                                    #
         GF00 ,   #                                                    #
         GG00 ,   #                                                    #
         GH00 ,   #                                                    #
#                                                                      #
         GVI00,   #                                                    #
         GVS00,   #                                                    #
         GVT00,   #                                                    #
         GVB00,   #                                                    #
#                                                                      #
         GJ00 ,   #                                                    #
         GK00 ,   #                                                    #
         GL00 ,   #                                                    #
         GM00 ,   #                                                    #
         GN00 ,   #                                                    #
         GP00 ,   #                                                    #
         GQ00 ,   #                                                    #
         GR00 ,   #                                                    #
         GS00 ,   #                                                    #
         GT00 ,   #                                                    #
         GU00 ,   #                                                    #
         GV00 ,   #                                                    #
#                                                                      #
         GPI00,   #                                                    #
         GPJ00,   #                                                    #
         GPK00,   #                                                    #
#                                                                      #
         GX00 ,   #      TYPE X   LOAD                                 #
         GX00 ,   #      LODP                                          #
         GX00 ,   #      REPL                                          #
         GX00 ,   #      LOC                                           #
         GX00 ,   #      BRAI                                          #
         GLISC  , #      LISC                                          #
         GBSLD ,  #      BSLD                                          #
         GBSLC ,  #      BSLC                                          #
         GBSRP ,  #      BSRP                                          #
         GU00 ,   #      IAOR (NOT USED HERE) (FILLER)                 #
         GU00 ,   #      ISMP (NOT USED HERE) (FILLER)                 #
         GLIN ,   #      LINE                                          #
         GU00  ,  #      MULTIPLY  ONLY FOR TMUL                       #
         GRL00 ,  #      RLAY                                          #
         GBPSB ,  #      BPSB                                          #
         XX00  ;  #      END  OF SUITCH                                #
  
  
  
  
#     LOCAL DATA                                                       #
  
      ITEM BCJP B;
      ITEM KNO;              #CNO FOR TYPE X INSTRUCTIONS              #
      ITEM MIX;              #MINIMUM ISSUE INDEX#
CONTROL EJECT;
#        NO EXECUTABLE OPS IN READY SET                                #
NX00: 
#        CHECK FOR  ISSUABLE  OP                                       #
         IF MINSZ [0] + MINSZ [1] EQ  0 THEN
                  BEGIN 
         $BEGIN 
                  CALL SRP00 ;      #   SET  REGISTER PROBLEM FLAG     #
         $END 
                  MIX  = 2 ;
                  IF MINSZ [2] GT 0 THEN GO TO NX20  ;
                  GOTO  RFP00 ; 
                  END 
         IF PARCEL EQ 3  THEN   GOTO  NX15  ; 
#        EITHER SIZE INSTRUCTION  IS OK                                #
         IF  MINSZ [ 0 ] EQ 0  THEN GOTO NX17  ;
         IF  MINSZ [ 1 ] EQ 0  THEN GOTO  NX16  ; 
#        BOTH SIZE INSTRUCTIONS ISSUABLE                               #
         IF MISUT  [0]  EQ  MISUT [1]  THEN 
          BEGIN 
         IF MEXUT[0] GR 0 THEN
           BEGIN
           IF MEXUT[1] EQ 0 THEN
             GOTO NX17; 
           END
         ELSE 
           IF MEXUT[1] GR 0 THEN
             GOTO NX16; 
           # BOTHE ZERO OR BOTH NON-ZERO  # 
           IF MPFF [0]  GE  MPFF [1]  THEN  GOTO  NX16 ;
                  GOTO NX17  ;
          END 
         IF  MISUT [0]  LE  MISUT [1]  THEN  GOTO  NX16 ; 
         GOTO  NX17  ;
#                                                                      #
NX15: 
         IF  MINSZ [0]  GT 0  THEN
          BEGIN 
NX16: 
         MIX  =   0 ;               #   1 PARCEL  OP                   #
         GOTO  NX20 ; 
          END 
         ELSE 
            BEGIN                                                        LCMISC 
            END                                                          LCMISC 
              # FALL THRU  WITH  CLC ADJUSTED IF POSSIBLE     #          LARRY-R
NX17: 
         MIX  =   1 ;               #   2 PARCEL  OP                   #
#        RECONSTRUCT THE ISSUABLE INSTRUCTION                          #
NX20: 
         INSIZ   =  MINSZ  [ MIX ] ;
         REGI    =  MRI    [ MIX ] ;
         REGJ    =  MRJ    [ MIX ] ;
         REGK    =  MRK    [ MIX ] ;
         ABSO    =  MABSO  [ MIX ] ;
         INXA    =  MINXA  [ MIX ] ;
         INX     =  MINX   [ MIX ] ;
         ISUT    =  MISUT  [ MIX ] ;
         EXUT    =  MEXUT  [ MIX ] ;
         IETIM   =  MIETM  [ MIX ] ;
         FUNU  =  MFUNU  [ MIX ] ;  #   FUNCTIONAL UNIT                #
         ITYPE   =  MITYP  [ MIX ] ;
         KACON   =  MKCON  [ MIX ] ;
         TOP1  =  MTOP1  [ MIX ] ;
         TOP2  =  MTOP2  [ MIX ] ;
         OPCOD =  MOPC  [MIX]  ;
         FTIM  =  MFTIM [MIX]  ;
         LSTYP  = MLSTYP [MIX]  ; 
         PRIOP  = MPFF   [MIX]  ; 
         CDROP  =  FALSE   ;
         FORCE  = TRUE   ;
         GOTO  CG00  ;
CONTROL EJECT;
#        REGISTER FULL PROBLEM   OUT OF REGISTERS                      #
RFP00:  
      IF NUNOP NQ 0 THEN
          BEGIN 
         $BEGIN 
         CALL  SRP00  ;             #   SET REGISTER PROBLEM FLAG      #
         $END 
         PROTECT = OPN2[UNSTI[0] ] ;
         CALL  ORP00  ; 
         GOTO  ISCAN  ; 
          END 
         CG2ABT(J869,"NO SCHEDULABLE INSTRUCTIONS(RFP00 IN CODGK3) LINE 
XXXXX", 55);
         GOTO  CFC00 ;
#**********************************************************************#
#        CODE GENERATION COMPUTE ISSUE  EXECUTION TIME FIRST           #
CGIE: 
         INSTAT = 1  ;              #   SCHEDULABLE                    #
         CALL  CIE00  ;             #   ISSUE AND EXECUTION TIME       #
         CALL  SST00  ;             #   STATUS                         #
#        NOW FALL INTO CG00                                            #
#**********************************************************************#
#        CODE  GENERATION  CONTROL                                     #
CG00: 
#                                                                      #
         NSKED =  NSKED + 1 ;       #   SCHEDULABLE OPS                #
$BEGIN
DB("( 9X9HCG00 IEF O4,2X,O4,2X,O4)",ISUT,EXUT,FTIM,".");
$END
#                                                                      #
          IF NOSKED THEN GOTO CG20 ;    #  NO SCHEDULING               #
         IF  RPFRC  THEN GOTO CG20 ;    #  REGISTER PROBLEM FORCE      #
         IF FORCE  THEN GOTO  CG20 ;
         IF OPCOD EQ QICFOP"BRAI" THEN GOTO CG20 ;
         IF NOCOD THEN GOTO CG20  ; 
         IF  CDROP THEN GOTO CG08 ; #   TREAT AS LAST RESORT           #
#        BIAS  FOR  ONE  PARCEL OP                                     #
         IF  INSIZ  EQ  2  AND  PARCL EQ 3  THEN  GOTO  CG08  ; 
         IF  INSTAT  EQ 3  THEN  GOTO CG20  ; 
CG08: 
        IF JAM THEN 
  
          IF NSKED EQ 3 THEN
          # ONLY LOOK AT 3 INSTRUCS   # 
            BEGIN 
            NSKED = 4;      # PASS THIS ONE UP NEXT TIME ARROUND  # 
            GOTO NX00;
            END 
  
          ELSE
            IF NSKED EQ 4 THEN
              GOTO CG20;    # ACCEPT THE BEST OF THE 3  # 
  
         CALL  RMI00 ;   #  RECORD MINIMUM ISSUE INSTRUCTIONS          #
         GOTO  CSCAN ;              #  CONTINUE SCAN                   #
#                                                                      #
#                                                                      #
CG20: 
         IF INSIZ EQ 2 AND PARCL EQ 3 THEN     #SEE IF WE CAN AVOID NOP#
              SP00;                            #IN BOTTOM PARCEL       #
      CURSEQF = ((PFF1[INX] - FUDGE) + CURSEQF) / 2;
                # A LIMIT FOR THE FOLLOWING INST# 
         RPFRC =  FALSE ;           #   RESET                          #
         LASTXRG = THISXRG ;
         THISXRG = -1;
$BEGIN
DB("( 2X10HGENERATED O4,8H CLOCK= O4)",INX,CLOCK,".");
         NREDY = NREDY - 1   ;
         $END 
         CALL  RPC00  ;             #   REDUCE PREDECESSOR COUNT       #
         GOTO  CGSW [ ITYPE ] ; 
CONTROL EJECT;
#**********************************************************************#
#                                                                      #
#        GENERATE   TYPE A  INSTRUCTIONS               #
#   1    REDUCE COUNT OF OPN1, OPN2  COMPUTATIONS      #
#   2    SET   REG J ,K  FREE RESULT TIME =            #
#                 ISUT  + EXUT  + 1                    #
#   3    SET   REGI   FREE AS OPERAND =                #
#                 ISUT + EXUT + TIME(FUNU)             #
#   4    SET FREE-TIME(FUNU) =  ISUT + EXUT +  TIME(FUNU)+1 # 
#   5    INCREMENT CLOCK BY ISUT                       #
#   6    CREATE 15 BIT INSTRUCTION                     #
#   7    LINK INSTRUCTION IN  (FOL)                    #
#   8    INCREMENT LOCATION COUNTER BY 1                               #
#   9    IF PARCEL COUNTER IS ZERO INCREMENT CLOCK BY WORD TIME  #
#  10    SET XREG OF INX TO  REGI            #
#  11    SET REGI OF X-R-MEMORY TO INX       #
#        FOR TYPE F :                        #
#  12    SET REGJ OF  B-R MEMORY TO OPN2 OF INX   # 
#  13    SET BREG OF OPN2 OF INX TO REGJ     #
#        THE ABOVE SIMPLIFIES SELB  PROCESSING    # 
#**********************************************************************#
GA00: 
GA01: 
         CALL  CN000 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         CALL  RRC00  ( TOP2 )  ;   #   REDUCE REF COUNT OF OPERAND-2  #
         IF OPCOD EQ QICFOP"LNND" OR OPCOD EQ QICFOP"LIMP" OR 
            OPCOD EQ QICFOP"LEQV" THEN
              BEGIN 
              T1 = REGJ ; 
              REGJ = REGK ; 
              REGK = T1 ; 
              END 
#        REG J,K  FREE AS RESULT TIME   # 
GA02: 
         CALL  BGA00 ;              #   BASIC GENERATION A             #
GA04: 
         CALL  BGB00  ;             #   BASIC GENERATION B             #
GA10: 
         IF  ITYPE  EQ  XTYPE  THEN  GOTO  GA39  ;
#        SET APPROPRIATE  REGISTER VALUE                               #
         KNO  =   CNO [INX]  ;      #   USUALLY = INX  BUT ORIGINAL    #
#        CNO  FOR MASKL MASKC  OR INSERTED RECOMPUTATIONS              #
         LIP  [KNO] = FALSE  ;      #   RELOAD NOT IN PROCESS NOW      #
         LUSE [KNO] = FALSE  ;      #   NOT  USED  YET                 #
          IF REGI GT BREG7 THEN 
           BEGIN
         IF REFCT [KNO] LE 0 THEN 
                  BEGIN 
                  XBREG [KNO] = 0 ; 
                  RGMEM [REGI] = -1 ; 
                  GOTO GA12  ;
                  END 
           END
         ELSE 
          BEGIN 
#        I AM ABOUT TO PUT A COMP IN BREGI                             #
#        IF THERE IS A LIVE COMP THERE  FORGET IT                      #
         T1  =  RGMEM [REGI]  ; 
         IF T1 GE 0 AND REGI GT BRJ   THEN BREGL [T1] = 0 ; 
                  BREGL [KNO] = REGI  ; 
                  GOTO GA11  ;
          END 
#        I AM ABOUT TO PUT A COMP IN REGI   (X-REG)                    #
#        THERE MAY BE A LIVE COMP IN REGI  ( CDROP)                    #
#        IF  THERE IS IT MUST BE FORGOTTEN HERE ( IT IS RECOMPUTABLE)  #
         T1  =  RGMEM [REGI]  ; 
         IF MOP[INX] NQ QCFOP"WXJ" THEN                                  LARRY-R
          # WXJ DOES NOT CAUSE A FORGET  #                               LARRY-R
         IF T1 GE 0 THEN XREGL [T1] = 0 ; 
         XREGL [KNO] = REGI ; 
GA11: 
      IF REGI GT BREG0 THEN 
         RGMEM  [REGI] = KNO  ;     #   REGISTER CONTAINS KNO          #
GA12: 
         IF  ITYPE  EQ  GTYPE  THEN   #  UNPB, NRMB, NRRB - B RESULT   #
          BEGIN 
         RGMEM  [REGJ] =  OPN2 [INX]  ;  #   SELB COMP                 #
         BREGL [ OPN2 [INX] ]  = REGJ ;  #   BREG OF SELB              #
          END 
GA39: 
                                                                         LARRY-R
#        IF THIS INSTRUCTION IS A STORE INTO A PFUN THEN WE MUST         LARRY-R
         ADJUST ANY B-REGS OR A-REGS DEDICATED TO ADDRESSES IN           LARRY-R
         THIS ARRAY                                                    # LARRY-R
                                                                         LARRY-R
         IF OPCD[INX] EQ QICFOP"REPL"                                    LARRY-R
         AND OPN1[INX] LS 0                                              LARRY-R
         AND OPCD[BI-OPN1[INX]] EQ QICFOP"PFUN"  THEN                    LARRY-R
                                                                         LARRY-R
           BEGIN                                                         LARRY-R
                                                                         LARRY-R
           T1 = OPN1[BI-OPN1[INX]] ;        # TABL  #                    LARRY-R
                                                                         LARRY-R
          FOR I = BRI+BADOFS STEP 1 UNTIL BRJ+BADOFS DO 
                 # LOOK AT ALL DEDICATED BREGS    #                      LARRY-R
             IF T1 EQ BRBA[I] THEN                                       LARRY-R
               BEGIN                                                     LARRY-R
                   # GOT ONE   #                                         LARRY-R
               T2 = T1;                                                  LARRY-R
          IF BROFS[I] NQ 0 OR BRAT[I] GT QAT"LCM" THEN
                 BEGIN                                                   LARRY-R
                 IINSK ( QICFOP"OFFS" , T1 , BROFS[I] );                 LARRY-R
                 T2 = BI - ICFTJ -1;                                     LARRY-R
                 END                                                     LARRY-R
                                                                         LARRY-R
              IINSK(QICFOP"BRAI",T2,I-BADOFS);
               AT[ICFTJ+1] = ACSTYPE (T1);     #  IN J1  #               LARRY-R
                                                                         LARRY-R
               RGVAL[I] = -1;                                            LARRY-R
          RGVAL[I-BADOFS] = -1; 
                                                                         LARRY-R
               FOL[ICFTJ+1] = FOL[XPRS];                                 LARRY-Y
               FOL[XPRS] = ICFTJ+1;    # MAKE NEXT READY OP   #          LARRY-R
                                                                         LARRY-R
               END                                                       LARRY-R
                                                                         LARRY-R
                                                                         LARRY-R
            FOR I = AREG1 STEP 1 UNTIL XREG7+XADOFS DO                   LARRY-R
                 # LOOK AT AREGS    #                                    LARRY-R
             IF T1 EQ BRBA[I] THEN                                       LARRY-R
                # DESTROY KNOWLEGE OF CONTENTS OF A-REG   #              LARRY-R
               RGVAL[I] = -1;                                            LARRY-R
             RGVAL[REGI+XADOFS] = ABSO;   # SET PFUN REGISTER   #        LARRY-R
  
#     IF WE DIDN"T PUT OUT A BRAI                                      #
#     WE BUMP REFCT OF THE STOREE BY THE MAX NO. OF TIMES WE MIGHT MAKE#
#     USE OF THE                                                       #
#     BASE = THE NO. OF ENTRIES ON OUR BASE ONLY CHAIN                 #
#     NOTE THAT WE HAVE ALREADY TAKEN THIS REPL OFF THE BASE ONLY CHAIN#
#     BUT ITS BCHN STILL POINTS TO THE ENTRY THAT USED TO FOLLOW IT    #
  
          IF OPCD[ICFTJ+1] NQ QICFOP"BRAI"
          THEN
              BEGIN 
      K = BCHN[INX];
      IF K EQ INX 
      THEN
          J = 0;             #NOTHING ELSE ON CHAIN#
      ELSE
          BEGIN 
      I = BCHN[K];
      FOR J = 1 STEP 1 WHILE (I NQ K) DO
          I = BCHN[I];
          END 
      REFCT[TOP2] = REFCT[TOP2] + J;
      IF REFCT[TOP2] GT 0 
      THEN
          BEGIN 
      XREGL[TOP2] = REGI;    #IF REFCT=0 THEN IT WAS DESTROYED# 
      RPFUN[TOP2] = TRUE;    #NOTE THAT STOREE WENT INTO A PFUN#
      RGVAL[REGI] = TOP2;    #REFCT = 0 DESTROYED IT# 
          END 
      ELSE
          RGVAL[REGI+XADOFS] = -1;
              END 
  
                                                                         LARRY-R
           END    # REPL OF PFUN    (OR A MOVE OF A BASED ARRAY IN PLAIN LARRY-R
                        SYMPL  )      #                                  LARRY-R
                                                                         LARRY-R
         ELSE                                                            LARRY-R
      BEGIN 
         IF OPCD[INX] EQ QICFOP"LODP" THEN                               LARRY-R
           BEGIN                                                         LARRY-R
             IF MOP[INX] NQ QCFOP"RXJ"
             THEN 
               BEGIN
               ARMEM[REGI LAN 7] = ABSO;  #REFCT EQ 0 DESTROYED IT     #
               END
           RGVAL[REGI+XADOFS] = ABSO;     # SET INTERMEDIATE ADDRESS #   LARRY-R
           LODPINP = FALSE;   # NOW THAT ONES ISSUED-LOOK FOR ANOTHER #  LARRY-R
           END                                                           LARRY-R
                                                                         LARRY-R
         ELSE                                                            LARRY-R
         BEGIN
      IF OPCOD EQ QICFOP"LOC" 
      THEN
          BEGIN 
          RGVAL[REGI+XADOFS] = ABSO;
          BRAT[REGI+XADOFS] = LOCACS[BRAT[REGI+XADOFS]];
          END 
      ELSE
          BEGIN 
      IF LDFRLC[INX]
      THEN                   #THIS LOAD IS REALLY A LOC- SET XA MEM#
        RGVAL[REGI+XADOFS] = ABSO;
      ELSE
        BEGIN 
      IF OPCOD NQ QICFOP"BPSB"
          AND (OPCOD NQ QICFOP"REPL") 
      THEN
          BEGIN 
           IF REGI GE XREG0                                              LARRY-R
           AND REGI LQ XREG7 THEN                                        LARRY-R
         RGVAL[REGI+XADOFS] = -1;                                        LARRY-R
           END
              END 
          END 
      END 
          END 
         GOTO  ISCAN  ; 
      CONTROL EJECT;
#**********************************************************************#
#        GENERATE TYPE B INSTRUCTION              # 
#        ONE X OPERAND   COMP , SUM1              # 
#        ONE X RESULT                             # 
#        REDUCE  REFERENCE COUNT OF OPN1          # 
#        IF COUNT GOES TO ZERO , ZERO OUT XREG OF OPN1 #
#        NOW SINCE  REGJ = REGK                   # 
#        AND  ZERO  XREG OF X-R-MEM               # 
#        BRANCH RIGHT INTO TYPE A  GENERATION     # 
#        AT  ENTRY  2                                                  #
#        COMP , SUM1     #
#**********************************************************************#
  
GB00: 
         CALL  CN000 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        GENERATE                                      #
#        TYPE C INSTRUCTION                            #
#        MASK -   NO OPERANDS                          #
#        1 X-REG  RESULT                               #
#        REGJ AND REGK ARE  CONSTANT VALUE             #
#        TYPE C  CAN BRANCH INTO TYPE A AT ENTRY 3     #
#        HOWEVER  I PRETEND THAT J AND K ARE REAL      #
#        AND ENTER AT ENTRY 2                          #
#        MASK     # 
#**********************************************************************#
  
GC00: 
          IF STI[INX] NQ 0 AND CNO[ISUC[STI[INX]]] EQ CNO[INX] THEN 
                           CNO[INX] = INX;
           #DELINK MASK FROM ITS MSKL OR MSKC#
         CALL  CN000 ;
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        GENERATE TYPE D INSTRUCTIONS   # 
#        CONSTANT SHIFT                 # 
#        1 X OP                         # 
#        1 X RESULT                     # 
#        REDUCE REFERENCE COUNT OF      # 
#        OPN1 (THIS WILL MAKE IT ZERO ) # 
#        REGJ AND REGK  ARE SHIFT VALUE # 
#        I WILL ASSUME NOW  THAT  J AND K ARE     # 
#        TREATED LIKE REAL REGISTERS    # 
#        BRANCH  TO  ENTRY 2  OF TYPE  A INSTRUCTION   #
#        CONSTANT SHIFT       # 
#**********************************************************************#
  
GD00: 
         CALL  CN000 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        GENERATE TYPE E INSTRUCTIONS                                  #
#        VARIABLE SHIFTS AND PACK                                      #
#        REQUIRING A B-REG OPERAND                                     #
#        I PROCESS THIS JUST LIKE A                                    #
#        TYPE A INSTRUCTION                                            #
#        VARIABLE SHIFT AND PAKB                                       #
#        X-REG  AND B-REG OPERAND                                      #
#**********************************************************************#
  
GE00: 
#                                                                      #
         GOTO  GA01 ; 
  
  
  
  
#**********************************************************************#
#        GENERATE TYPE F  INSTRUCTIONS      # 
#        NO  BREG RESULT                                               #
#        REDUCE COUNT OF OPN1 COMPUTATION    #
#        SET REG K  FREE FOR RESULT TIME =   #
#                 ISUT + EXUT +1             #
#        SET REG I ,J  ( J IS A B-REG) FREE AS OPERAND TIME      #
#               = ISUT + EXUT + TIME(SHIFT)  #
#        I CAN GO TO TYPE A GENERATION  AFTER     # 
#        SETTING  F SWITCH          # 
#        NORM, NRMR,  UNPACK        # 
#        X AND B REG RESULT         # 
#**********************************************************************#
  
GF00: 
#        NORM, NRMR, UNPK   NO B-RESULT   B0 IS USED                   #
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        GENERATE TYPE G INSTRUCTIONS             # 
#                                                                      #
#        NRMB,NRRB, UNPB                                               #
#        THIS PRODUCES 2 RESULTS    X AND B                            #
#**********************************************************************#
  
GG00: 
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         ROFT [REGI]  = IEFTM + CLOCK + 1 ;  #  XI RESULT              #
         ROFT [REGJ]  = IEFTM + CLOCK + 1 ;  #  BJ RESULT              #
         RRFT [REGK]  = IETIM + CLOCK + 1 ;  #  XK OPERAND             #
         GOTO  GA04 ; 
  
  
  
  
#**********************************************************************#
#        SELB                                                          #
#        BREGL OF THIS INSTRUCTION HAS BEEN SET                        #
#        NOT NECESSARY TO REDUCE REFCT OF TOP1                         #
#**********************************************************************#
  
GH00: 
         GOTO  ISCAN  ;             #   INITIALIZE AND SCAN AGAIN      #
  
  
  
  
#**********************************************************************#
#        UNCONDITIONAL JUMP                                            #
#**********************************************************************#
  
GJ00: 
         CALL RMH00 ;   #   OPN1 = STP LABL REGISTER MEMORY HISTORY    #
         CALL  CNO00 ;
#        OPN1 IS JUMP ADDRESS                                          #
         MOP [INX]  =  QCFOP"EQ"  ; 
#                                                                      #
#                                                                      #
GJ10: 
         CALL  BGA00  ;             #   BASIC GENERATION A             #
         CALL  BGB00  ;             #   BASIC GENERATION B             #
         IF PARCEL NE 0 AND NOT BCJP THEN 
                  BEGIN 
                  IF PARCEL EQ 3 THEN          #CHECK IF CAN EXPAND INS#
                      SP00; 
                  PARCEL = 0 ;
                  CLC [0] = CLC [0] + 4 ; 
                  CLOCK  =  CLOCK + WPTIM ; 
                  END 
         IF MOP [INX] EQ CJP THEN 
          BEGIN 
         MOP [INX] =  MOP [INX] + (REGI LAN  O"7") ;
         IDES [INX] = 0  ;
          END 
         FREZA1  = FALSE ;          #   A1  ALL USED BY NOW            #
          FREZA2 = FALSE;                                                NEWFEAT
         BCJP = FALSE ; 
         GOTO  ISCAN ;
  
  
  
  
#**********************************************************************#
#        CONDITIONAL  JUMP                                             #
#**********************************************************************#
  
GK00: 
         BCJP = TRUE ;                 #  CONDITIONAL JUMP             #
         CALL  CNO00 ;
         CALL  RRC00  ( TOP2 )  ;   #   REDUCE REF COUNT OF OPERAND-2  #
         CALL RMH00 ;   #   OPN1 = STP LABL REGISTER MEMORY HISTORY    #
#        OPN1 IS JUMP ADDRESS                                          #
         IF MOP [INX] NE CJP THEN GOTO GJ10 ; 
         REGI  =  JTYPE [OPCODE] ;
         GOTO  GJ10  ;
  
  
  
  
#**********************************************************************#
#        INDEXED  JUMP                                                 #
#**********************************************************************#
  
GL00: 
         CALL  CNO00  ; 
         CALL  RRC00 ( TOP2 ) ;     #  INDEX VALUE                     #
#        OPN1  IS JUMP ADDRESS                                         #
         MOP [INX] = IJMP ; 
#                                                                      #
         GOTO  GJ10 ; 
  
  
  
  
#**********************************************************************#
#                                                                      #
#        TMBR, TMSR, TMWR                                              #
#**********************************************************************#
  
GM00: 
         IF NOT NOCOD THEN
          BEGIN 
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         IF OPCOD EQ QICFOP"TMBR" AND 
                   TOP1 EQ CNO [INX] AND
                   REFCT [TOP1] LQ 1   THEN 
                   BEGIN
                   XREGL [TOP1] = 0 ; 
                   RGMEM [REGJ] = -1 ;
                   END
         IF OPCOD EQ QICFOP"TMSR" THEN
               BEGIN
               IF TOP1 EQ CNO [INX] THEN
                    BEGIN 
                    IF XREGL [TOP1] GT 0 THEN 
                         RGMEM [XREGL [TOP1]] = -1 ;
                    END 
               END
         GOTO  GA02 ; 
         END
         CALL  RRC00 (TOP1) ; 
         GOTO  GA10  ;
  
  
  
  
#**********************************************************************#
#        TYPE N OPS DISAPPEAR                                          #
#**********************************************************************#
  
GN00: 
         GOTO  CSCAN  ; 
  
  
  
  
#**********************************************************************#
#        LDSC                                                          #
#**********************************************************************#
  
GP00: 
         CALL  CNO00 ;
         GOTO  GA02  ;
  
  
  
  
#**********************************************************************#
#                                                                      #
#        ADD SHORT CONSTANT                                            #
#**********************************************************************#
  
GQ00: 
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        LUAU                                                          #
#**********************************************************************#
  
GPI00:  
         CALL  CNO00  ; 
         ARMEM  [ REGI LAN O"7" ] = 0 ; 
         GOTO  GA02  ;
  
  
  
  
#**********************************************************************#
#        DRV      DEFINE REGISTER VALUE                                #
#     THIS INSTR GENERATES NO CODE.  IT SIMPLY PUTS AN ENTRY INTO      #
#     THE REGISTER MEMORY.                                             #
#**********************************************************************#
  
GPJ00:  
      T1 = OPN2[INX]; 
      IF T1 GQ XREG0
      THEN
          BEGIN 
         XREGL [INX]  =  T1 ; 
         RGMEM [T1] = INX ; 
          END 
      ELSE
          BEGIN              #SET UP B-REG MEM (BRAI BEFORE REPL PFUN)# 
          NCA00(INX);        #ENCODE ADDRESS# 
          RGMEM[T1] = INX;
          RGMEM[T1+BADOFS] = ABSO;
          END 
      GOTO ISCAN; 
  
  
  
  
#**********************************************************************#
#        SRV                                                           #
#**********************************************************************#
  
GPK00:  
         IF  REGI NE REGJ THEN  CALL CNO00  ; 
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         XREGL[RGMEM[REGI]] = 0 ; # KILL OLD VALUE WHICH WAS IN REGI #
         IF  REGI NE REGJ THEN GOTO  GA02 ; 
#        NO CODE IS NECESSARY                                          #
         RGMEM [REGI]  =  INX  ;
         XREGL [INX] =  REGI  ; 
         GOTO  ISCAN  ; 
  
  
  
  
#**********************************************************************#
#        BXND                                                          #
#**********************************************************************#
  
GR00: 
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#        RLAY                                                          #
#**********************************************************************#
  
GRL00:  
         IF  REGI  GT 0  THEN  RGMEM [REGI]  =  INX  ; # X-REG         #
         IF  REGJ  GT 0  THEN  RGMEM [REGJ]  =  INX  ; # B-REG         #
         TSYM [INX] = TSYM [TOP2]  ;
         XBREG [INX] = XBREG [TOP2] ; 
         GOTO  ISCAN  ; 
#                                                                      #
  
  
  
  
#**********************************************************************#
#        SAVE                                                          #
#        SAVE  GENERATION                                              #
#        TOP2  POINTS TO A COMPUTATION WITH A SINGLE USE               #
#        TOP2  IS  IN  REGI   MAY BE  ANY REGISTER   0-5  OR  6-7      #
#        OR A BREGISTER  ICFOP = SAVE, TSSV, OR PISR FOR I=SR,WR,BR    #
#        REGJ IS AN AVAILABLE STORE REGISTER AT THIS  POINT            #
#        I  WANT TO SAY  THAT  TOP2 IS  NOWHERE                        #
#        AND  THE SAVE  (INX)  IS IN  REGI                             #
#**********************************************************************#
  
GS00: 
         TSYM  [INX] =  OPN1 [INX] ;
         XBREG  [TOP2] = 0 ;        #   FORGET TOP2  BEING SAVED       #
         MOP   [INX] =  QCFOP"CODE" ; 
         IF REGI  LE BREG7  THEN  BREGL [INX] = REGI   ;
                  ELSE  XREGL [INX] = REGI  ; 
         RGMEM [REGI] =  INX ;
         IDES  [INX] =  REGI ;
         JDES  [INX] =  REGJ ;
         $BEGIN 
         NREDY  = NREDY - 1 ; 
         $END 
         FOL  [LGEN] =  INX  ;
         FOL  [INX]  =  PSOS  ; 
         LGEN  =  INX  ;
         GOTO  ISCAN ;
  
  
  
  
#**********************************************************************#
#                                                                      #
#        SUBS/OFFS                                                     #
#        NULL                                                          #
#**********************************************************************#
  
GT00: 
GU00: 
         GOTO  ISCAN  ; 
  
  
  
  
#**********************************************************************# LCMISC 
#        LABEL                                                         #
#**********************************************************************#
  
GV00: 
         PLABL  = OPN1 [INX]  ;     #  S.T.P. TO LABEL                 #
          IF NOT UNRLB[INX] THEN                                         NEWFEAT
                   # BOTH A1 AND A2 MAY BE USED NOW#                     NEWFEAT
           BEGIN                                                         NEWFEAT
              FREZA1 = FALSE;                                            NEWFEAT
              FREZA2 = FALSE;                                            NEWFEAT
           END                                                           NEWFEAT
         IF CLAS [PLABL] NQ QCLAS"LABL" THEN GOTO GV40 ;
         FRGT [PLABL] = TRUE ;
         IF  UNRLB [INX] THEN GOTO GV50  ;   #  UNREFERENCED           #
         FOR   I  =  0  BY RMESZ   UNTIL  EORGM   DO
                  BEGIN 
                  IF RHIST[I] NQ PLABL THEN TEST; 
                  RHIST [I] = 0 ;   #   FREE RGHISTORY ENTRY           #
         I  = I + BRJ + 2 ; 
         J  = BRJ  + 1 ;
         IF FRGH [INX] THEN GOTO GV40 ; #  FORGET REGISTERS HERE       #
                  IF  FTHRU [INX] THEN  GOTO GV35 ; 
#                 NOT FALL THROUGH                                     #
      FGR00(J,XAMEM7);
      FGR00(J+BADOFS,SUDOR);
GV34: 
      T1 = RHIST[I];
      IF (T1 LS 0)
        OR (J GQ AREG0
          AND J LQ (BREG7 + BADOFS))
      THEN
        BEGIN 
        IF (J GQ XREG0 + XADOFS)
          AND (J LQ XREG7 + XADOFS) 
          AND (RGMEM[J - XADOFS] EQ -1) 
        THEN
          BEGIN 
          T1 = -1;
          END 
        ELSE
          BEGIN 
          IF (J GQ BREG0 + BADOFS)
            AND (J LQ BREG7 + BADOFS) 
            AND (RGMEM[J - BADOFS] EQ -1) 
          THEN
            BEGIN 
            T1 = -1;
            END 
          END 
        RGMEM[J] = T1;
        GOTO GV348; 
        END 
         IF REFCT [T1] LE 0 THEN GOTO GV348 ; 
         RGMEM [J] = T1 ; 
         IF J LT XREG0 THEN BREGL [T1] = J ;
                   ELSE XREGL [T1] = J ;
GV348:  
                    I = I + 1;
                    J = J + 1;
                    IF J LT SUDOR THEN GOTO GV34; 
                    GOTO   GV50  ;  # ALL DONE                         #
#        FALL  THRU                                                    #
GV35: 
                  IF RGMEM [J]  NE  RHIST [I]  THEN 
                   CALL FGR00 ( J, J ) ;
                  I = I + 1 ; 
                  J = J + 1 ; 
                    IF J LT SUDOR THEN GOTO GV35; 
                  GOTO  GV50 ;      #   ALL DONE                       #
                  END 
#        IF NOT FOUND  CLEAR ALL REGISTER MEMORY                       #
GV40: 
#        FORGET REGISTERS                                              #
      FGR00(BRJ+1,XAMEM7);   #FORGET ALL REGS (EXCEPT DEDICATED B-REGS)#
      FGR00(BRJ+1+BADOFS,SUDOR);
#        LINK INTO GEN ORDER                                           #
GV50: 
         MOP  [INX]  =  QCFOP"LABL"   ; 
GV51: 
         $BEGIN 
         NREDY  =  NREDY - 1   ;
         IF  SKRMK  THEN            #   SCHEDULE REMARKS               #
         CALL  SSDH00   ; 
         $END 
         FOL  [LGEN] = INX  ; 
         LGEN =  INX  ; 
         FOL  [INX]  = -1  ;
         GOTO  ISCAN  ; 
  
  
  
  
#**********************************************************************#
GLIN: 
#**********************************************************************#
  
         MOP  [INX] =  QCFOP"LINE"  ; 
         GOTO GV51  ; 
  
#**********************************************************************#
#        LISC                                                          #
#**********************************************************************#
  
GLISC:  
#        TREAT JUST AS TYPE  C  OP - MASK                              #
         GOTO  GC00 ; 
  
  
  
  
#**********************************************************************#
#        INVI                                                          #
#**********************************************************************#
  
GVI00:  
         CALL  CNO00  ; 
         IF  OPN2 [INX]  LT  0  THEN  CALL  RRC00 (TOP2) ;
         GOTO  GA02   ; 
  
  
  
  
#**********************************************************************#
#        INVS                                                          #
#**********************************************************************#
  
GVS00:  
         CALL  CNO00  ; 
         CALL  RRC00  ( TOP1 )  ;   #   REDUCE REF COUNT OF OPERAND-1  #
#        GA00 MUST  MAKE SOME SPECIAL TESTS                            #
         GOTO  GA02  ;
  
  
  
  
#**********************************************************************#
#        INVT                                                          #
#        NO CODE                                                       #
#**********************************************************************#
  
GVT00:  
         GOTO  ISCAN  ; 
  
  
  
  
#**********************************************************************#
#        INVB                                                          #
#                                                                      #
#        BGE      I J   K                                              #
#        OPN1 IS LABEL   OPN2  IS  ICFT PTR  TO  INVT                  #
#**********************************************************************#
  
GVB00:  
         CALL  CNO00  ; 
         ISUT  =  0 ; 
         IEFTM =  0 ; 
         FUNU  =  BRNU ;
         CALL  BGB00 ;
#                                                                      #
         GOTO  ISCAN   ;
  
  
  
  
#**********************************************************************#
#        BSLD, BSLC                                                    #
#**********************************************************************#
  
GBSLD:  
GBSLC:  
         CALL  CNO00 ;
         CALL  RRC00 ( TOP1 ) ; 
         TX  =  KDES [ INX ]  ; 
         IF  TX GT 0  THEN  CALL  RRC00 ( TX ) ;
         KNO  =  CNO [INX]  ; 
GBSLC1: 
         XREGL [KNO] =  REGI  ; 
         RGMEM [REGI] =  KNO  ; 
         IF  OPCODE  EQ  QICFOP"BSLC"  THEN  GOTO GBSLC5   ;
#        LOAD                                                          #
GBSLC2: 
         CALL  NCA00 ( KNO )  ; 
         ARMEM [ REGI  LAN  O"7" ] = ABSO ; 
         MOP  [INX]  =  SAI53   ; 
GBSLC3: 
         ITYPE =  XTYPE ; 
         GOTO  GA02  ;
#        LOC                                                           #
GBSLC5: 
         MOP [INX] = SXI73   ;
         GOTO GBSLC3 ;
#                                                                      #
#        BSRP                                                          #
GBSRP:  
         CALL  CNO00 ;
         CALL  RRC00  ( TOP1 )  ; 
         CALL  RRC00  ( TOP2 )  ; 
         TX  =  KDES [INX]  ; 
         IF  TX GT 0  THEN  CALL RRC00 ( TX )  ;  #   SUBSCRIPT        #
         KNO = CNO [INX]  ; 
         IF  REFCT  [ INX ]  LE  0   THEN  GOTO GBSLC2  ; 
         GOTO  GBSLC1  ;
  
  
  
  
#**********************************************************************#
#     BPSB                                                             #
#         THIS REPRESENTS AN ADD OF A BASE+SUBS.  THE GENERATED CODE   #
#         CAN BE-                                                      #
#             IXI  XJ+XK                                               #
#             SBI  NJ+BK  (WHERE N= A,B OR X)                          #
#**********************************************************************#
  
GBPSB:  
      CNO00;
      ISUED[INX] = TRUE;     #BPSB NOW ISSUED#
  
#     SET REFCT = THE MAXIMUM NUMBER OF TIMES WE MIGHT MAKE USE OF THIS#
#     BPSB (= THE NUMBER OF ENTRIES ON THE BASE+SUBS CHAIN)            #
  
      I = BSCHN[INX]; 
      FOR J = 1 STEP 1 WHILE BSCHN[I] NQ INX DO 
          I = BSCHN[I]; 
      REFCT[INX] = J; 
  
      IF SXREG[INX] 
      THEN
          BEGIN 
  
#     WE HAVE TO ENCODE THE ADDRESS THAT THIS BPSB REPRESENTS.  IT IS  #
#     ALMOST THE SAME AS THE INSTR THAT CAUSED THIS BPSB TO BE         #
#     GENERATED (IN CNO). , EXCEPT THE AT AND OFFST OF THIS BPSB ARE   #
#     THE SAME AS THAT OF THE BASE                                     #
  
          I = CNO[INX];      #INSTR CAUSING BPSB TO BE GENERATED# 
          CNO[INX] = INX;    #RESTORE CNO TO ITS USUAL USE# 
          J = AT[I];
          AT[I] = LOCACS[J]; #SET AT TO AT OF BASE# 
          NCA00(I);          #ENCODE ADDRESS# 
          AT[I] = J;
          END 
      ELSE
          BEGIN 
#     WE HAVE TO ENCODE THE ADDRESS THAT THIS BPSB REPRESENTS.  IT IS  #
#     ALMOST THE SAME AS THE ADDRESS OF THE INSTR THAT CAUSED THIS BPSB#
#     TO BE GENERATED (IN CNO) EXCEPT THE OFFST IS THE SAME AS THE BASE#
  
          NCA00(CNO[INX]);
          CNO[INX]=INX; 
          END 
  
#     NOTE- WE USE THE SPARE WORD AT THE END OF THE REG MEM ARRAY      #
#     INSTEAD OF RGVAL[REGI+N] TO STORE THE ENCODED ADDRESS SINCE      #
#     WHEN WE REDUCE THE REFCTS OF REGJ AND REGK IF ONE OF THESE IS THE#
#     SAME AS REGI AND ITS REFCT GOES TO ZERO THIS WILL DESTROY        #
#     RGVAL[REGI+N] (SET IT TO -1). AFTER WE HAVE REDUCED THE          #
#     REFCTS OF REGJ AND REGK WE CAN SET THE ENCODED ADDRESS WHERE IT  #
#     BELONGS.  NOTICE WE CAN"T REDUCE THE REFCTS OF REGJ AND REGK     #
#     FIRST SINCE WE NEED THE OFFSET OF WHICHEVER ONE OF THESE THAT    #
#     CONTAINS THE BASE AND REDUCING ITS REFCT MIGHT MAKE IT = -1.     #
#     (N = XADOFS OR BADOFS)                                           #
  
          RGVAL[SUDOR+1] = ABSO;   #CORRECT ADR EXCEPT FOR OFFST# 
          IF JEQB[INX]
          THEN
              BEGIN          #BASE IN REGJ# 
              IF REGJ LQ BREG7
              THEN
                BROFS[SUDOR+1] = BROFS[REGJ+BADOFS];
              ELSE
                BROFS[SUDOR+1] = BROFS[REGJ+XADOFS];
              END 
          ELSE
              BEGIN          #BASE IN REGK# 
              IF REGK LQ BREG7
              THEN
                BROFS[SUDOR+1] = BROFS[REGK+BADOFS];
              ELSE
                BROFS[SUDOR+1] = BROFS[REGK+XADOFS];
              END 
  
#     SINCE ALL OF THE INSTRUCTIONS ON THE BASE+SUBS CHAIN WILL FIND   #
#     THEIR REQUIRED ADDRESSES VIA THIS BPSB AND NOT HAVE TO REFERENCE #
#     THE REGISTERS CONTAINING EITHER THE BASE OR SUBS DIRECTLY, WE    #
#     CAN NOW DECREMENT THE BASE AND SUBS BY THE NUMBER OF ENTRIES ON  #
#     THE CHAIN.                                                       #
  
      K = REFCT[INX]; 
  
      FOR I = 1 STEP 1 UNTIL K DO 
          BEGIN 
          RRC00(TOP1);
          RRC00(TOP2);
          END 
      IF SXREG[INX] 
      THEN
          RGVAL[REGI+XADOFS] = RGVAL[SUDOR+1];
      ELSE
          RGVAL[REGI+BADOFS] = RGVAL[SUDOR+1];
          GOTO GA02;
  
  
  
  
#**********************************************************************#
#        SPECIAL TYPE X INSTRUCTIONS #
#        LOAD/STORE/LOC/BRAI                                           #
#**********************************************************************#
  
GX00: 
         KNO  =   CNO [INX]  ;
         CALL CN000 ; 
  
#     IF THIS INSTRUCTION FOUND ITS ADDRESS COURTESY OF A BPSB, WE MUST#
#     DECREMENT THE REFCT OF THE BPSB.                                 #
  
      IF AT[INX] GT QAT"LCM"
      THEN
          BEGIN 
          IF OPN1[INX] LQ 0 
              AND OPCD[TOP1] NQ QICFOP"OFFS"
              AND OPCD[TOP1] NQ QICFOP"PFUN"
          THEN
              BEGIN 
          J = 0;             #ASSUME WE DON"T REF A BPSB# 
          K = RGVAL[REGJ];
          IF (REGJ GT BREG0)
              AND (K LS ICFTW1)    #ICFT POINTER AND NOT ENCODED ADDR  #
              AND OPCD[K] EQ QICFOP"BPSB" 
          THEN
              BEGIN 
              IF MOP[INX] NQ QCFOP"WXJ" 
                AND MOP[INX] NQ QCFOP"RXJ"
              THEN
                RRC00(K); 
              J = 1;         #FOUND BPSB# 
              END 
          ELSE
              BEGIN 
              K = RGVAL[REGK];
              IF (REGK GT BREG0)
                  AND (K LS ICFTW1)  #ICFT POINTER AND NOT ENCODED ADDR#
                  AND OPCD[K] EQ QICFOP"BPSB" 
              THEN
                  BEGIN 
                  RRC00(K); 
                  J = 1;     #FOUND BPSB# 
                  END 
              END 
  
#     IF WE DIDN"T FIND OUR ADDRESS VIA A BPSB AND THERE IS ONE ON OUR #
#     BASE+SUBS CHAIN, THEN WE MUST DECREMENT ITS REFCT  SINCE WHEN IT #
#     WAS ISSUED WE ASSUMED EVERYTHING ON ITS CHAIN WOULD REFERENCE IT #
#     AND WE SET ITS REFCT ACCORDINGLY. HENCE ITS REFCT INCLUDES THIS  #
#     INSTRUCTION                                                      #
  
          IF J EQ 0 
          THEN
              BEGIN          #DIDN"T REF BPSB#
              FOR I = BSCHN[INX] WHILE (I NQ INX)      #FIND BPSB#
                  AND ((OPCD[I] NQ QICFOP"BPSB") OR (NOT ISUED[I])) DO
                  I = BSCHN[I]; 
              IF I NQ INX 
              THEN
                  BEGIN      #FOUND BPSB# 
                  RRC00(I);  #REDUCE REFCT OF BPSB# 
                  USBCN[INX] = FALSE;  #REFCT OF SUBS ALREADY DECREMNTD#
                  END 
              END 
              END 
          ELSE
              BEGIN          #CONSTANT OFFSET#
              K = RGVAL[REGJ];
              IF (REGJ GT BREG0)
                  AND (K GQ 0)     #REG NOT DEAD# 
                  AND (K LS ICFTW1)  #ICFT POINTER AND NOT ENCODED ADDR#
                  AND (OPCD[K] EQ QICFOP"LODP" OR RPFUN[K]) 
                 AND (MOP[INX] NQ QCFOP"WXJ") 
                 AND (MOP[INX] NQ QCFOP"RXJ") 
              THEN
                  RRC00(K); 
              ELSE
                  BEGIN 
                  K = RGVAL[REGK];
                  IF (REGK GT BREG0)
                      AND (K GQ 0)     #REG NOT DEAD# 
                      AND (K LS ICFTW1)  #ICFT PTR AND NOT ENCODED ADDR#
                      AND (OPCD[K] EQ QICFOP"LODP" OR RPFUN[K]) 
                  THEN
                      RRC00(K); 
                  END 
              END 
          END 
  
#     IF THIS WAS AN LCM INSTR WE MUST DECREMENT THE REFCT OF THE REG  #
#     CONTAINING THE LCM ADRESS.                                       #
  
      IF MOP[INX] EQ QCFOP"WXJ" 
          OR MOP[INX] EQ QCFOP"RXJ" 
      THEN
          RRC00(RGVAL[REGJ]); 
  
      LINKOB(INX);           #LINK INSTR OUT OF BASE ONLY CHAIN#
      LINKOBS(INX);          #LINK INSTR OUT OF BASE+SUBS CHAIN#
  
#     IF INSTR IS VARIABLY SUBSCRIPTED WE MUST DECREMENT THE REFCT OF  #
#     OF THE SUBSCRIPT COMPUTATION                                     #
  
         IF USBCN[INX]
         THEN 
             RRC00(BI - OPN2[TOP1]);
  
#     IF INSTR USES OPN2 OF CNO (A STORE OPERATION) WE MUST DECREMENT  #
#     THE REFCT OF THE STOREE                                          #
  
         IF UP2CN[INX]
         THEN 
             BEGIN
             TX = BI - OPN2[KNO]; 
             CISR[TX] = FALSE;
             RRC00(TX); 
             END
  
#        IF THIS INSTR SETS A-REG MEMORY (LOAD/STORE/LODP) WE DO IT NOW#
  
         IF SAREG[INX]
         THEN 
             ARMEM[REGI LAN O"7"] = ABSO; 
  
#     IF THIS INSTR SETS B-REG MEMORY (BRAI) WE DO IT NOW              #
  
         IF SBREG[INX]
         THEN 
             BEGIN
             IF KNO NQ INX
             THEN 
                 NCA00(KNO);
             RGMEM[REGI] = INX; 
             RGMEM[REGI+BADOFS] = ABSO; 
             END
  
         IF  REFCT  [KNO]  LE  0   THEN  GOTO   GX20  ; 
         IF  SXREG [INX]  THEN
          BEGIN 
         IF  RGMEM  [REGI]  GE  0  THEN 
         BEGIN
         IF LSTYP EQ QLT"STOR" THEN GOTO GX20 ; 
         ELSE 
                  XREGL [ RGMEM [ REGI ] ]  =  0  ; 
         END
         RGMEM  [REGI]  =  KNO  ; 
         XREGL [KNO]  =  REGI  ;
         LIP  [KNO]  =  FALSE  ;
          END 
#        USE GA00  BUT  NOTE THAT GA  MUST TEST FOR TYPE X  OPS        #
GX20: 
#        UPDATE LAST LOAD REGISTER CHOSEN                              #
         IF  LSTYP  EQ  QLT"LOAD"  THEN 
                  LLRCH =  REGI LAN O"7"  ; 
         ITYPE  =  XTYPE  ; 
         LUSE  [KNO] = FALSE ;      #   NOT USED YET                   #
         IF  LSTYP EQ QLT"STOR"  AND  TSYM [KNO] GT 0 THEN
            LUSE [KNO] =  TRUE ;    #   SCALAR REPL IS A USE           #
         GOTO  GA02 ; 
  
  
  
  
#**********************************************************************#
#                                                                      #
#        CODE FILE WRITER  CONTROL                                     #
#**********************************************************************#
  
CFC00:  
         #BEFORE WE WRITE THE CODE FILE CHECK TO SEE IF THERE IS A     #
         #NOP LYING AROUND THAT COULD BE REMOVED BY EXPANDING AN INST  #
         IF B<59,1>CLC EQ 1 THEN               #ONLY TRY ON ODD PARCELS#
              SP00; 
         CLC [0] = CLCI  ;          #   INITIAL  CLC                   #
         CALL  CFW00 ( FOL [PSOS] ) ; 
#        ERASE ALL BREGS                                               #
         T1   =   BRDVN - 1 ; 
         FOR I = 0  BY 1 UNTIL  T1    DO
                  BREG [BRDVP [I]] = 0 ;
         GOTO  CG2XIT  ;
         END
         TERM 
