*DECK INSTGEN                                                            INSTGEN
USETEXT DNTEXT
          PROC  INSTGEN;                                                 INSTGEN
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   INSTGEN -  PROCESS INSTRUCTION SEQUENCE                           #
 #                                                                     #
 #   GIVEN - SEQUENCE OF INSTRUCTIONS                                  #
 #                                                                     #
 #   DOES - SUBSTITUTES MACHINE REGISTERS FOR VIRTUAL REGISTERS,       #
 #          CONTROLS PROCESSING OF CERTAIN SPECIAL INSTRUCTIONS        #
 #          COPIES COMPLETED INSTRUCTION TO OUTPUT WSA                 #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #        NESTED PROC DIRECTORY                                        #
 #                                                                     #
 #        AVAILX                   CHECK FOR AVAILABLE X REGISTER      #
#         COPYREG                  COPY REAL REGISTER ATTRIBUTES       #
 #        EPRCPR                   PROCESS END OF PROCEDURE            #
 #        GENREGMOVE               OUTPUT A REGISTER MOVE INSTRUCTION  #
 #        GNATEMP                  ASSIGN ASSEMBLER TEMPORARY          #
 #        FREES                    RETURN A FREE STORE REGISTER NUMBER #
 #        GENSATEMP                OUTPUT A LOAD OR STORE OF TEMPORARY #
 #        SAVEA                    SAVE AN A REGISTER IN TEMPORARY     #
 #        SAVEB                    SAVE A B REGISTER IN TEMPORARY      #
 #        SAVEX                    SAVE AN X REGISTER IN TEMPORARY     #
 #        FREEB                    RETURN A FREE B REGISTER NUMBER     #
 #        FREEL                    RETURN A FREE LOAD REGISTER NUMBER  #
 #        FREEX                    RETURN A FREE X REGISTER NUMBER     #
 #        ASSIGN                   ASSIGN VIRTUAL REGISTER TO REAL REG #
 #        RESTRAX                  LOAD A AND/OR X REGISTER FROM TEMP  #
 #        RESTRB                   LOAD A B REGISTER FROM TEMPORARY    #
 #        GETREG                   RETURN REAL REGISTER ASSIGNED       #
 #        REGASG                   SELECT REAL REGISTER FOR DEFINITION #
 #            FREESX               RETURN FREE X STORE REGISTER NUMBER #
 #            LOCKPR               PROCESS LOCKED REGISTER DEFINITION  #
 #            HOLDPR               PROCESS HELD REGISTER DEFINITION    #
 #        RESTORE                  RELOAD HELD REGISTERS               #
 #        SAVREG                   SAVE REGISTERS ACROSS OBJECT ROUTINE#
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
*CALL ASMCOMM                                                            INSTGEN
*CALL ASMINST                                                            INSTGEN
*CALL VREGCOM                                                            INSTGEN
*CALL AREGS                                                              INSTGEN
*CALL TABLETYP                                                           INSTGEN
*CALL PNAT1 
          DEF  FULLSEQ  #1#;
*CALL SEQCOM
*CALL USETAB
*CALL DNATVALS
*CALL RALINE
          ARRAY  BLDINST [0:1];                                          INSTGEN
              ITEM                                                       INSTGEN
                  BCONST DCONS, 
                  BMOD   DMOD,                                           INSTGEN
                  BINDX  DINDEX,                                         INSTGEN
                  BTABLE DTABLE,                                         INSTGEN
                  OP     DOC,                                            INSTGEN
                  RI     DRI,                                            INSTGEN
                  RJ     DRJ,                                            INSTGEN
                  RK     DRK;                                            INSTGEN
  
          STATUS  REGCON  NULL, CONSTANT, ADDRESS, STORAGE, MASK; 
          ARRAY  [-1:23];    #REGISTER CONTENTS                        #
             BEGIN
              ITEM TYPECON S:REGCON (0,0,6);
              ITEM CONTENTDNAT    (0,6,1);
              ITEM CONTENTSUBM    (0,30,10);
              ITEM CONTENTWORD    (0,40,17);
              ITEM  CONTENTS   (0,12,48); 
              ITEM  REGCONTENT; 
              END 
                                                                         INSTGEN
          STATUS  REG  L,S,X,B,A0;                                       INSTGEN
                                                                         INSTGEN
          DEF  FFB  #3#;
          DEF  FINDR(A,B)  #A#; 
          DEF  NEXTLOCK(R) #LOCKINST[FIRSTLOCK[R]]#;
          DEF   NEW #-1#; 
          DEF  CHANGECORE 
               #FOR KK = 0 STEP 1 UNTIL 7 DO IF TYPECON[KK+OFFSETX] EQ
                S"STORAGE"  THEN REGCONTENT[KK+OFFSETX] = 0 #;
          DEF    ZEROREGCON 
               #FOR KK = 0 STEP 1 UNTIL 23 DO REGCONTENT[KK] = 0 #; 
          ITEM  BXFLAG;                                                  INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  DF     B;                                                INSTGEN
          ITEM  I;                                                       INSTGEN
          ITEM  IINPUT; 
          ITEM  INC;                                                     INSTGEN
          ITEM  JINPUT; 
          ITEM  KINPUT; 
          ITEM KK;
          ITEM  MREG;                                                    INSTGEN
          ITEM  OBJCALL B;
          ITEM  OPC    S:OPNAMES;                                        INSTGEN
          ITEM  R;                                                       INSTGEN
          ITEM  VREG;                                                    INSTGEN
                                                                         INSTGEN
          XREF                                                           INSTGEN
              BEGIN                                                      INSTGEN
              PROC  ADDSUBL;
              PROC  ADJADDR;                                             INSTGEN
              PROC  ASMABT;                                              INSTGEN
              PROC  INCADDR;                                             INSTGEN
              PROC  INSTOUT;
              PROC  LABELPR;                                             INSTGEN
              FUNC  VIRTUAL;
              END                                                        INSTGEN
                                                                         INSTGEN
          SWITCH  INSTPR:OPNAMES
                  ERR:     NULL,
                  $XMIT:   XMIT,
                  $CLASS1: LAND,
                  $CLASS1: LOR, 
                  $CLASS1: LXOR,
                  $CLASS1: COMPL, 
                  $CLASS1: LIMP,
                  $CLASS1: STRK,
                  $CLASS1: LEQV,
                  $CLASS1: SHLB,
                  $CLASS1: SHRB,
                  $CLASS1: NORM,
                  $CLASS1: RNRM,
                  $CLASS1: UNP, 
                  $CLASS1: PACK,
                  $CLASS1: FADD,
                  $CLASS1: FSUB,
                  $CLASS1: DADD,
                  $CLASS1: DSUB,
                  $CLASS1: RADD,
                  $CLASS1: RSUB,
                  $CLASS1: IADD,
                  $CLASS1: ISUB,
                  $CLASS1: FMUL,
                  $CLASS1: RMUL,
                  $CLASS1: DMUL,
                  $CLASS1: IMUL,
                  $CLASS1: FDIV,
                  $CLASS1: RDIV,
                  $CLASS1: SUM1,
                  $CLASS1: SAXPB, 
                  $CLASS1: SAAPB, 
                  $CLASS1: SAAMB, 
                  $CLASS1: SABPB, 
                  $CLASS1: SABMB, 
                  $CLASS1: SBXPB, 
                  $CLASS1: SBAPB, 
                  $CLASS1: SBAMB, 
                  $SBBPB:  SBBPB, 
                  $CLASS1: SBBMB, 
                  $CLASS1: SXXPB, 
                  $CLASS1: SXAPB, 
                  $CLASS1: SXAMB, 
                  $CLASS1: SXBPB, 
                  $CLASS1: SXBMB, 
                  $CLASS1: SLRXPB,
                  $SLRAPB: SLRAPB,
                  $CLASS1: SLRAMB,
                  $CLASS1: SLRBPB,
                  $CLASS1: SLRBMB,
                  $INDSTORE: SSRXPB,
                  $SSRAPB: SSRAPB,
                  $INDSTORE: SSRAMB,
                  $INDSTORE: SSRBPB,
                  $INDSTORE: SSRBMB,
                  $RDEF:   RDEF,
                  $TEST:   RSTOR, 
                  $RFREE:  RFREE, 
                  $TEST:   HOLDR, 
                  $CLASS2: NO$, 
                  $CLASS2: PS$, 
                  $CLASS2: SHL, 
                  $CLASS2: SHR, 
                  $MASK:   MASK,
                  ERR:     BSS$,
                  ERR:     DATA$, 
                  ERR:     VFD$,
                  $LINE:   LINE,
                  ERR:     REPL,
                  ERR:     OBJ, 
                  ERR:     LOOP,
                  ERR:     ENDL,
                  ERR:     MD$, 
                  $CMU:    DM$, 
                  $CMU:    CC$, 
                  $CMU:    CU$, 
                  $CLASS2: PLUS,
                  $CLASS2: MINUS, 
                  $JP$:    JP$, 
                  $CLASS3: ZR$, 
                  $CLASS3: NZ$, 
                  $CLASS3: PL$, 
                  $CLASS3: NG$, 
                  $CLASS3: IR$, 
                  $CLASS3: OR$, 
                  $CLASS3: DF$, 
                  $CLASS3: ID$, 
                  $EQ$:    EQ$, 
                  $CLASS3: NE$, 
                  $CLASS3: GE$, 
                  $CLASS3: LT$, 
                  $CLASS3: SAAPK, 
                  $CLASS3: SABPK, 
                  $CLASS3: SAXPK, 
                  $CLASS3: SBAPK, 
                  $SBBPK:  SBBPK, 
                  $CLASS3: SBXPK, 
                  $CLASS3: SXAPK, 
                  $SXBPK:  SXBPK, 
                  $CLASS3: SXXPK, 
                  $CLASS3: SLRAPK,
                  $SLRBPK: SLRBPK,
                  $CLASS3: SLRXPK,
                  $CL3STORE: SSRAPK,
                  $SSRBPK: SSRBPK,
                  $CL3STORE: SSRXPK,
                  $IM$:    IM$, 
                  $RJ$:    RJ$, 
                  $LABEL$: LABEL$,
                  $CLASS4: IDENT$,
                  $END$:   END$,
                  $CLASS4: USE$,
                  $EPRC:   EPRC,
                  $CXMIT:  CXMIT, 
                  $DXMIT:  DXMIT, 
                  $CSBBPB: CSBBPB,
                  $DSBBPB: DSBBPB,
                  $TEST:   RPREF, 
                  $RESTR:  RESTR, 
                  ERR:     PLIST, 
                  $CLASS2: OVCAP, 
                  $CLASS2: OVLY,
                  $FREEINP: FREEINP,
                  $NOTED:  NOTED, 
                  $RSAVE:  RSAVE, 
                  ERR:     ENDOP; 
          CONTROL  EJECT; 
          FUNC  AVAILX; 
 #     DETERMINE IF AN X REGISTER IS AVAILABLE                         #
          ITEM  J;
          ITEM  K;
          ITEM  L;
          BEGIN 
          AVAILX = -1;
          FOR J = 0 STEP 1 UNTIL 6 DO 
              BEGIN 
              K = J + OFFSETX;
              L = J + OFFSETA;
              IF  NOT INUSE[K] AND NOT INPUT[K] 
                  AND (J EQ 0 OR NOT INUSE[L] AND NOT INPUT[L]) 
              THEN
                  BEGIN 
                  AVAILX = J; 
                  RETURN; 
                 END
              END 
          RETURN; 
          END 
          CONTROL  EJECT;                                                INSTGEN
          PROC  COPYREG((I),(J),(RTYPE)); 
          ITEM  I;                                                       INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  RTYPE  S:REGTYPE;                                        INSTGEN
          BEGIN                                                          INSTGEN
          K = REGOFF[RTYPE];                                             INSTGEN
          USECNT[I+K] = USECNT[J+K];                                     INSTGEN
          HOLD[I+K] = HOLD[J+K];                                         INSTGEN
          LOCK[I+K] = LOCK[J+K];                                         INSTGEN
          VREGN[I+K] = VREGN[J+K];
          REGCONTENT[I+K] = REGCONTENT[J+K];
          AREG[VREGN[J+K]] = I;                                          INSTGEN
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  GENREGMOVE((OPN),(I),(J));
          ITEM  I;                                                       INSTGEN
          ITEM   J;                                                      INSTGEN
          ITEM   OPN  S:OPNAMES;                                         INSTGEN
          BEGIN                                                          INSTGEN
          ADJADDR(OPN,TRUE);                                             INSTGEN
          OP[0] = OPN;                                                   INSTGEN
          RI[0] = I;                                                     INSTGEN
          RJ[0] = J;                                                     INSTGEN
          RK[0] = 0;                                                     INSTGEN
          INCADDR(OPN);                                                  INSTGEN
          INSTOUT(LOC(BLDINST),1);
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          FUNC  GNATEMP;                                                 INSTGEN
 #   ASSIGN ASSEMBLER TEMPORARY                                        # INSTGEN
          BEGIN                                                          INSTGEN
          ATEMPCNT = ATEMPCNT + 1;                                       INSTGEN
          GNATEMP = ATEMPCNT; 
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT; 
          FUNC  MIN(A1,A2); 
          ITEM  A1; 
          ITEM  A2; 
          BEGIN 
          IF  A1 LS  A2  THEN  MIN = A1; ELSE  MIN = A2;
          RETURN; 
          END 
          CONTROL  EJECT;                                                INSTGEN
                                                                         INSTGEN
          FUNC  FREES(RESULT);
          ITEM  FARLOCK;
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  L;                                                       INSTGEN
          ITEM  M;
          ITEM  RESULT  B;
                                                                         INSTGEN
          PROC  GETSTORE(STREG);                                         INSTGEN
          ITEM  STREG;                                                   INSTGEN
 #   FREE A STORE REGISTER BY SAVING IN TEMPORARY                      # INSTGEN
          ITEM  TEMP;                                                    INSTGEN
          ITEM  VREG;                                                    INSTGEN
          BEGIN                                                          INSTGEN
          IF  USECNT[STREG+OFFSETX] NQ 0                                 INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              IF  USECNT[STREG+OFFSETA] NQ 0                             INSTGEN
              THEN  GENREGMOVE(OPNAMES"SBAPB",ASMREG,STREG);             INSTGEN
              TEMP = GNATEMP;                                            INSTGEN
              GENSATEMP(OPNAMES"SSRBPK",STREG,TEMP);                     INSTGEN
              VREG = VREGN[STREG+OFFSETX];
              USES[VREG] = USECNT[STREG+OFFSETX];                        INSTGEN
              USECNT[STREG + OFFSETX] = 0;
              TEMPNO[VREG] = TEMP;                                       INSTGEN
              TEMPF[VREG] = TRUE; 
              REGCONTENT[STREG+OFFSETX] = 0;
              END                                                        INSTGEN
          IF  USECNT[STREG+OFFSETA] NQ 0                                 INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              IF  USECNT[STREG+OFFSETX] NQ 0                             INSTGEN
              THEN  GENREGMOVE(OPNAMES"SXBPB",STREG,ASMREG);             INSTGEN
              ELSE  GENREGMOVE(OPNAMES"SXAPB",STREG,STREG);              INSTGEN
              VREG = VREGN[STREG+OFFSETA];
              TEMP = GNATEMP;                                            INSTGEN
              GENSATEMP(OPNAMES"SSRBPK",STREG,TEMP);                     INSTGEN
              USESA[VREG] = USECNT[STREG+OFFSETA];                       INSTGEN
              USECNT[STREG+OFFSETA] = 0;                                 INSTGEN
              USECNT[STREG + OFFSETX] = 0;
              REGCONTENT[STREG+OFFSETA] = 0;
              REGCONTENT[STREG+OFFSETX] = 0;
              TEMPANO[VREG] = TEMP;                                      INSTGEN
              TEMPAF[VREG] = TRUE;
              END                                                        INSTGEN
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
                                                                         INSTGEN
          BEGIN                                                          INSTGEN
          FARLOCK = 0;
          FOR  J = 6 STEP 1 UNTIL 7  DO                                  INSTGEN
              BEGIN                                                      INSTGEN
              K = J + OFFSETX;                                           INSTGEN
              L = J + OFFSETA;                                           INSTGEN
              IF  NOT INUSE[K] AND NOT INUSE[L] 
                  AND  (NOT(INPUT[L] OR INPUT[K]) OR RESULT)
               THEN                                                      INSTGEN
                  BEGIN                                                  INSTGEN
                  M = NEXTLOCK(K);
                  IF  M GR FARLOCK
                  THEN
                      BEGIN 
                      FREES = J;
                      FARLOCK = M;
                      END 
                  END                                                    INSTGEN
              END                                                        INSTGEN
          IF  FARLOCK NQ 0 THEN  RETURN;
          M = -1; 
          FOR  J = 6 STEP 1 UNTIL 7  DO                                  INSTGEN
              BEGIN                                                      INSTGEN
              K = J + OFFSETA;                                           INSTGEN
              L = J + OFFSETX;
              IF  NOT(HOLD[K] OR INPUT[K] OR HOLD[L] OR INPUT[L]) 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  IF  M EQ -1 OR USECNT[L] EQ 0  THEN  M = J; 
                  END                                                    INSTGEN
              END                                                        INSTGEN
          IF  M EQ -1  THEN  ASMABT("STORE REGISTER OVERCOMMITMENT",29);
          IF  OBJCALL  THEN J = -1; ELSE  J = AVAILX; 
          IF  J LS 0 OR USECNT[M + OFFSETA] NQ 0
          THEN
              GETSTORE(M);
          ELSE
              BEGIN 
              GENREGMOVE(OPNAMES"XMIT",J,M);
              COPYREG(J,M,REGTYPE"TYPEX");
              USECNT[M+OFFSETX] = 0;
              END 
          FREES = M;
          RETURN; 
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  GENSATEMP((OPC),REG,TEMP);
 #   GENERATE INSTRUCTION TO LOAD OR STORE AN ASSEMBLER TEMPORARY      # INSTGEN
          ITEM  OPC  S:OPNAMES;                                          INSTGEN
          ITEM  REG;                                                     INSTGEN
          ITEM  TEMP;                                                    INSTGEN
          BEGIN                                                          INSTGEN
          ADJADDR(OPC,TRUE);                                             INSTGEN
          OP[0] = OPC;                                                   INSTGEN
          RI[0] = REG;                                                   INSTGEN
          RJ[0] = 0;                                                     INSTGEN
          BTABLE[1] = S"ATEMP$";
          BMOD[1] = S"NULL";
          BINDX[1] = TEMP;
          BCONST[1] = 0;
          INCADDR(OPC);                                                  INSTGEN
          INSTOUT(LOC(BLDINST),2);
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  SAVEA((SVREG)); 
 #    SAVE AN A REGISTER IN ASSEMBLER TEMPORARY                        # INSTGEN
          ITEM  STREG;                                                   INSTGEN
          ITEM  SVREG;                                                   INSTGEN
          ITEM  TEMP;                                                    INSTGEN
          ITEM  VREG;                                                    INSTGEN
          BEGIN                                                          INSTGEN
          VREG = VREGN[SVREG+OFFSETA];
          REGCONTENT[SVREG+OFFSETA] = 0;
          IF  NOT REDEFA[VREG] AND TEMPANO[VREG] NQ 0 
              AND  NOT RHOLD[VREG]
          THEN
              BEGIN          #REGISTER VALUE ALREADY EXISTS IN TEMP    #
              TEMPAF[VREG] = TRUE;
              USESA[VREG] = USECNT[SVREG+OFFSETA];
              USECNT[SVREG+OFFSETA] =0; 
              RETURN; 
              END 
          STREG = FREES(FALSE); 
          TEMP = GNATEMP;                                                INSTGEN
          GENREGMOVE(OPNAMES"SXAPB",STREG,SVREG);                        INSTGEN
          GENSATEMP(OPNAMES"SSRBPK",STREG,TEMP);                         INSTGEN
          USESA[VREG] = USECNT[SVREG+OFFSETA];                           INSTGEN
          USECNT[SVREG+OFFSETA] = 0;
          TEMPANO[VREG] = TEMP;                                          INSTGEN
          TEMPAF[VREG] = TRUE;
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          PROC  SAVEB((SVREG)); 
 #    SAVE A B REGISTER IN ASSEMBLER TEMPORARY                         # INSTGEN
          ITEM  STREG;                                                   INSTGEN
          ITEM  SVREG;                                                   INSTGEN
          ITEM  TEMP;                                                    INSTGEN
          ITEM  VREG;                                                    INSTGEN
          BEGIN                                                          INSTGEN
          VREG = VREGN[SVREG+OFFSETB];
          REGCONTENT[SVREG+OFFSETB] = 0;
          IF  NOT REDEF[VREG] AND TEMPNO[VREG] NQ 0 
              AND  NOT RHOLD[VREG]
          THEN
              BEGIN          #REGISTER VALUE ALREADY EXISTS IN TEMP    #
              TEMPF[VREG] = TRUE; 
              USES[VREG] = USECNT[SVREG+OFFSETB]; 
              USECNT[SVREG+OFFSETB] = 0;
              RETURN; 
              END 
          STREG = FREES(FALSE); 
          TEMP = GNATEMP;                                                INSTGEN
          GENREGMOVE(OPNAMES"SXBPB",STREG,SVREG);                        INSTGEN
          GENSATEMP(OPNAMES"SSRBPK",STREG,TEMP);                         INSTGEN
          USES[VREG] = USECNT[SVREG+OFFSETB];                            INSTGEN
          USECNT[SVREG+OFFSETB] = 0;
          TEMPNO[VREG] = TEMP;                                           INSTGEN
          TEMPF[VREG] = TRUE; 
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          PROC  SAVEX((SVREG)); 
 #    SAVE AN X REGISTER IN ASSEMBLER TEMPORARY                        # INSTGEN
          ITEM  STREG;                                                   INSTGEN
          ITEM  SVREG;                                                   INSTGEN
          ITEM  TEMP;                                                    INSTGEN
          ITEM  VREG;                                                    INSTGEN
          BEGIN                                                          INSTGEN
          VREG = VREGN[SVREG+OFFSETX];
          REGCONTENT[SVREG+OFFSETX] = 0;
          IF  NOT REDEF[VREG] AND  TEMPNO[VREG] NQ 0
              AND  NOT RHOLD[VREG]
          THEN
              BEGIN          #REGISTER VALUE ALREADY EXISTS IN TEMP    #
              TEMPF[VREG] = TRUE; 
              USES[VREG] = USECNT[SVREG+OFFSETX]; 
              USECNT[SVREG+OFFSETX] = 0;
              RETURN; 
              END 
          IF  SVREG EQ 6 OR SVREG EQ 7
          THEN
              STREG = SVREG;
          ELSE
              BEGIN 
              STREG = FREES(FALSE); 
              GENREGMOVE(OPNAMES"XMIT",STREG,SVREG);
              END 
          TEMP = GNATEMP;                                                INSTGEN
          GENSATEMP(OPNAMES"SSRBPK",STREG,TEMP);                         INSTGEN
          USES[VREG] = USECNT[SVREG+OFFSETX];                            INSTGEN
          USECNT[SVREG+OFFSETX] = 0;
          TEMPNO[VREG] = TEMP;                                           INSTGEN
          TEMPF[VREG] = TRUE; 
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          FUNC  FREEB(RESULT);
          ITEM  FARLOCK;
          ITEM  FARLOCKZERO;
          ITEM  FARTHEST; 
          ITEM  FARTHESTZERO; 
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  RESULT  B;
          BEGIN                                                          INSTGEN
          FARLOCK = 0;
          FARLOCKZERO = 0;
          IF  NOT RESULT
          THEN
              FOR  J = FFB STEP 1 UNTIL 7 DO
                  BEGIN 
                  K = J + OFFSETB;
                  IF NOT  INUSE[K]
                      AND NOT INPUT[K]
                  THEN
                      BEGIN 
                      IF  NEXTLOCK(K) GR FARLOCKZERO
                          AND REGCONTENT[K] EQ 0
                      THEN
                          BEGIN 
                          FARTHESTZERO = J; 
                          FARLOCKZERO = NEXTLOCK(K);
                          END 
                     ELSE 
                         IF  NEXTLOCK(K) GR FARLOCK 
                         THEN 
                             BEGIN
                             FARTHEST = J;
                             FARLOCK = NEXTLOCK(K); 
                             END
                      END 
                  END 
          ELSE
              FOR  J = FFB  STEP 1 UNTIL 7 DO 
                  BEGIN 
                  K = J + OFFSETB;
                  IF  NOT INUSE[K]
                  THEN
                      BEGIN 
                      IF  NEXTLOCK(K) GR FARLOCKZERO
                          AND REGCONTENT[K] EQ 0
                      THEN
                          BEGIN 
                          FARTHESTZERO = J; 
                          FARLOCKZERO = NEXTLOCK(K);
                          END 
                     ELSE 
                         IF  NEXTLOCK(K) GR FARLOCK 
                         THEN 
                             BEGIN
                             FARTHEST = J;
                             FARLOCK = NEXTLOCK(K); 
                             END
                      END 
                  END 
          IF  FARLOCKZERO NQ 0
          THEN
              BEGIN 
              FREEB = FARTHESTZERO; 
              RETURN; 
              END 
          IF  FARLOCK NQ 0
          THEN
               BEGIN
               FREEB = FARTHEST;
               RETURN;
               END
          FOR  J = 1 STEP 1 UNTIL 7  DO                                  INSTGEN
              BEGIN                                                      INSTGEN
              K = J + OFFSETB;                                           INSTGEN
              IF  NOT(HOLD[K] OR RESERVED[K] OR INPUT[K])                INSTGEN
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  SAVEB(J); 
                  FREEB = J;                                             INSTGEN
                  RETURN;                                                INSTGEN
                  END                                                    INSTGEN
              END                                                        INSTGEN
          ASMABT("B REGISTER OVERCOMMITMENT",25);                        INSTGEN
          END                                                            INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          FUNC  FREEL(RESULT,LIMIT);
          ITEM  FARLOCK;
          ITEM  FARLOCKZERO;
          ITEM  FARTHEST; 
          ITEM  FARTHESTZERO; 
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  L;                                                       INSTGEN
          ITEM  LIMIT;
          ITEM  M;                                                       INSTGEN
          ITEM  RESULT  B;
          BEGIN                                                          INSTGEN
          FARLOCKZERO = 0;
          FARLOCK = 0;
          IF  NOT RESULT
          THEN
          FOR J = 1 STEP 1 UNTIL 5 DO 
                  BEGIN 
                  K = J + OFFSETA;
                  L = J + OFFSETX;
                  IF  NOT INUSE[K] AND NOT INUSE[L] 
                      AND NOT INPUT[K] AND NOT INPUT[L] 
                  THEN
                      BEGIN 
                      M = NEXTLOCK(L);
                      IF  M GR FARLOCKZERO AND REGCONTENT[L] EQ 0 
                      THEN
                          BEGIN 
                          IF  M GR LIMIT
                          THEN
                              BEGIN 
                              FREEL = J;
                              RETURN; 
                              END 
                          FARTHESTZERO = J; 
                          FARLOCKZERO = M;
                          END 
                     ELSE 
                         IF  M GR FARLOCK 
                          THEN
                              BEGIN 
                              FARTHEST = J; 
                              FARLOCK = M;
                              END 
                      END 
                  END 
          ELSE
          FOR J = 1 STEP 1 UNTIL 5 DO 
                  BEGIN 
                  K = J + OFFSETA;
                  L = J + OFFSETX;
                  IF  NOT INUSE[K] AND NOT INUSE[L] 
                  THEN
                      BEGIN 
                      M = NEXTLOCK(L);
                      IF  M GR FARLOCKZERO AND REGCONTENT[L] EQ 0 
                      THEN
                          BEGIN 
                          IF  M GR LIMIT
                          THEN
                              BEGIN 
                              FREEL = J;
                              RETURN; 
                              END 
                          FARTHESTZERO = J; 
                          FARLOCKZERO = M;
                          END 
                      ELSE
                      IF  M GR FARLOCK
                          THEN
                              BEGIN 
                              FARTHEST = J; 
                              FARLOCK = M;
                              END 
                      END 
                  END 
          IF  FARLOCKZERO NQ 0
          THEN
              BEGIN 
              FREEL = FARTHESTZERO; 
              RETURN; 
              END 
          IF  FARLOCK NQ 0
          THEN
              BEGIN 
              FREEL = FARTHEST; 
              RETURN; 
              END 
          M = -1; 
          FOR  J = 1 STEP 1 UNTIL 5 DO                                   INSTGEN
              BEGIN                                                      INSTGEN
              K = J + OFFSETA;                                           INSTGEN
              L = J + OFFSETX;                                           INSTGEN
              IF  NOT(HOLD[K] OR INPUT[K] OR HOLD[L] OR INPUT[L]) 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  IF  M EQ -1 OR USECNT[K] EQ 0 THEN M = J; 
                  END                                                    INSTGEN
              END                                                        INSTGEN
          IF  M EQ -1 THEN  ASMABT("LOAD REGISTER OVERCOMMITMENT",28);
          IF  USECNT[M+ OFFSETA] NQ 0 
          THEN
              BEGIN 
              SAVEA(M); 
              IF  USECNT[M+OFFSETX] NQ 0 THEN  SAVEX(M);
              END 
          ELSE
              BEGIN 
              J = AVAILX; 
              IF  J LS 0
              THEN
                  BEGIN 
                  SAVEX(M); 
                  END 
              ELSE
                  BEGIN 
                  GENREGMOVE(OPNAMES"XMIT",J,M);
                  COPYREG(J,M,REGTYPE"TYPEX");
                  END 
              END 
          FREEL = M;
          RETURN; 
          END                                                            INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          FUNC  FREEX(RESULT,LIMIT);
          ITEM  FARLOCK;
          ITEM  FARLOCKZERO;
          ITEM  FARTHEST; 
          ITEM  FARTHESTZERO; 
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  L;
          ITEM  LIMIT;
          ITEM  M;
          ITEM  RESULT  B;
          BEGIN                                                          INSTGEN
          FARLOCK = 0;
          FARLOCKZERO = 0;
          IF  NOT RESULT
          THEN
              FOR J = 0 STEP 1 UNTIL 6 DO 
                  BEGIN 
                  K = J + OFFSETX;
                  L = J + OFFSETA;
                  IF  NOT INUSE[K]
                      AND NOT INPUT[K]
                      AND (J EQ 0  OR  NOT INUSE[L] 
                           AND NOT INPUT[L])
                  THEN
                      BEGIN 
                      IF  NEXTLOCK(K) LS NEXTLOCK(L)
                      THEN  M = NEXTLOCK(K);
                      ELSE  M = NEXTLOCK(L);
                      IF  M  GR FARLOCKZERO AND REGCONTENT[K] EQ 0
                      THEN
                          BEGIN 
                          IF  M GR LIMIT
                          THEN
                              BEGIN 
                              FREEX = J;
                              RETURN; 
                              END 
                          FARLOCKZERO = M;
                          FARTHESTZERO = J; 
                          END 
                      ELSE
                          IF  M GR FARLOCK
                          THEN
                              BEGIN 
                              FARTHEST = J; 
                              FARLOCK = M;
                              END 
                      END 
                  END 
          ELSE
              FOR J = 0 STEP 1 UNTIL 6 DO 
                  BEGIN 
                  K = J + OFFSETX;
                  L = J + OFFSETA;
                  IF  NOT INUSE[K]
                      AND (J EQ 0  OR  NOT INUSE[L])
                  THEN
                      BEGIN 
                      M = NEXTLOCK(K);
                      IF  M  GR FARLOCKZERO AND REGCONTENT[K] EQ 0
                      THEN
                          BEGIN 
                          IF  M GR LIMIT
                          THEN
                              BEGIN 
                              FREEX = J;
                              RETURN; 
                              END 
                          FARLOCKZERO = M;
                          FARTHESTZERO = J; 
                          END 
                      ELSE
                          IF  M GR FARLOCK
                          THEN
                              BEGIN 
                              FARTHEST = J; 
                              FARLOCK = M;
                              END 
                      END 
                  END 
          IF  FARLOCKZERO  NQ 0 
          THEN
              BEGIN 
              FREEX = FARTHESTZERO; 
              RETURN; 
              END 
          IF  FARLOCK NQ 0
          THEN
              BEGIN 
              FREEX = FARTHEST; 
              RETURN; 
              END 
          FARTHEST = 0; 
          FOR J = 6 STEP -1 UNTIL 0 DO
              BEGIN                                                      INSTGEN
              K = J + OFFSETX;                                           INSTGEN
              L = J + OFFSETA;
              IF  NOT  (HOLD[K] OR INPUT[K])
                  AND (J EQ 0 OR NOT(HOLD[L]
                  OR INPUT[L])) 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  IF LASTUSE[VREGN[K]] GR FARTHEST THEN 
                      BEGIN 
                      FARTHEST = LASTUSE[VREGN[K]]; 
                      M = J;
                      END 
                  END                                                    INSTGEN
              END                                                        INSTGEN
          IF FARTHEST NQ 0 THEN 
              BEGIN 
              SAVEX(M); 
              FREEX = M;
              END 
          ELSE
              ASMABT("X REGISTER OVERCOMMITMENT",25); 
          RETURN; 
          END                                                            INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  ASSIGN((RTYPE),(REGNO),(VR)); 
                                                                         INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  REGNO;                                                   INSTGEN
          ITEM  RTYPE S:REGTYPE;                                         INSTGEN
          ITEM  VR;                                                      INSTGEN
          SWITCH  ASG:REGTYPE                                            INSTGEN
                  A:TYPEA,                                               INSTGEN
                  B:TYPEB,                                               INSTGEN
                  X:TYPEX;                                               INSTGEN
                                                                         INSTGEN
          BEGIN                                                          INSTGEN
          AREG[VR] = REGNO;                                              INSTGEN
          J = REGOFF[RTYPE] + REGNO;                                     INSTGEN
              REGCONTENT[J] =0; 
          VREGN[J] = VR;                                                 INSTGEN
          GOTO  ASG[RTYPE];                                              INSTGEN
 A:                                                                      INSTGEN
          USECNT[J] = USESA[VR];                                         INSTGEN
          LOCK[J] = LOCKA[VR];                                           INSTGEN
          ASIGNDA[VR] = TRUE;                                            INSTGEN
          IF  RHOLD[VR]  THEN  HOLDA[VR] = TRUE;
          HOLD[J] = HOLDA[VR];
          RETURN;                                                        INSTGEN
 B:                                                                      INSTGEN
          USECNT[J] = USES[VR];                                          INSTGEN
          LOCK[J] = LOCKB[VR];                                           INSTGEN
          ASSIGND[VR] = TRUE;                                            INSTGEN
          IF  RHOLD[VR]  THEN  HOLDB[VR] = TRUE;
          HOLD[J] = HOLDB[VR];
          RETURN;                                                        INSTGEN
 X:                                                                      INSTGEN
          USECNT[J] = USES[VR];                                          INSTGEN
          LOCK[J] = LOCKX[VR];                                           INSTGEN
          ASSIGND[VR] = TRUE;                                            INSTGEN
          IF  RHOLD[VR]  THEN  HOLDX[VR] = TRUE;
          HOLD[J] = HOLDX[VR];
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  RESTRAX((REG),(VR));
 #    LOAD AN A AND/OR X REGISTER FROM ASSEMBLER TEMPORARY             # INSTGEN
          ITEM  REG;                                                     INSTGEN
          ITEM  VR;                                                      INSTGEN
          BEGIN                                                          INSTGEN
          IF  NOT TEMPAF[VR]
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              IF  REG EQ 0 OR REG GR 5
              THEN  J = FREEL(FALSE,I); 
              ELSE  J = REG;
              GENSATEMP(OPNAMES"SLRBPK",J,TEMPNO[VR]);                   INSTGEN
              IF  REG NQ J THEN GENREGMOVE(OPNAMES"XMIT",REG,J);
              TEMPF[VR] = FALSE;
              ASSIGN(REGTYPE"TYPEX",REG,VR);                             INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          IF  NOT(LOADED[VR] OR STORED[VR])                              INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              J = FREEL(FALSE,I); 
              GENSATEMP(OPNAMES"SLRBPK",J,TEMPANO[VR]);                  INSTGEN
              GENREGMOVE(OPNAMES"SLRXPB",REG,J);
              ASSIGN(REGTYPE"TYPEA",REG,VR);                             INSTGEN
              TEMPAF[VR] = FALSE; 
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          IF  STORED[VR]                                                 INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              INPUT[REG+OFFSETX] = TRUE;
              J = FREEL(FALSE,I); 
              INPUT[REG+OFFSETX] = FALSE; 
              GENSATEMP(OPNAMES"SLRBPK",J,TEMPANO[VR]);                  INSTGEN
              GENREGMOVE(OPNAMES"SLRXPB",J,J);
              GENREGMOVE(OPNAMES"XMIT",REG,J);                           INSTGEN
              GENREGMOVE(OPNAMES"SSRAPB",REG,J);
              TEMPANO[VR] = 0;                                           INSTGEN
              ASSIGN(REGTYPE"TYPEA",REG,VR);                             INSTGEN
              IF  TEMPF[VR] 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  GENSATEMP(OPNAMES"SLRBPK",J,TEMPNO[VR]);
                  GENREGMOVE(OPNAMES"XMIT",REG,J);                       INSTGEN
                  ASSIGN(REGTYPE"TYPEX",REG,VR);                         INSTGEN
                  TEMPF[VR] = FALSE;
                  END                                                    INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          IF  LOADED[VR]                                                 INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              IF  NOT TEMPF[VR] 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  GENSATEMP(OPNAMES"SLRBPK",REG,TEMPANO[VR]);            INSTGEN
              GENREGMOVE(OPNAMES"SLRXPB",REG,REG);
                  ASSIGN(REGTYPE"TYPEA",REG,VR);                         INSTGEN
                  TEMPAF[VR] = FALSE; 
                  END                                                    INSTGEN
              ELSE                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  INPUT[REG+OFFSETX] = TRUE;
                  GENSATEMP(OPNAMES"SLRBPK",REG,TEMPNO[VR]);             INSTGEN
              INPUT[REG+OFFSETX] = FALSE; 
                  J = FREEX(FALSE,I); 
                  GENREGMOVE(OPNAMES"XMIT",J,REG);                       INSTGEN
                  GENSATEMP(OPNAMES"SLRBPK",REG,TEMPANO[VR]);            INSTGEN
              GENREGMOVE(OPNAMES"SLRXPB",REG,REG);
                  GENREGMOVE(OPNAMES"XMIT",REG,J);                       INSTGEN
                  ASSIGN(REGTYPE"TYPEA",REG,VR);                         INSTGEN
                  ASSIGN(REGTYPE"TYPEX",REG,VR);                         INSTGEN
                  TEMPAF[VR] = FALSE; 
                  TEMPF[VR] = FALSE;
                  END                                                    INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  RESTRB((REG),(VR)); 
#    LOAD A B REGISTER FROM ASSEMBLER TEMPORARY                        # INSTGEN
          ITEM   REG;                                                    INSTGEN
          ITEM   VR;                                                     INSTGEN
          BEGIN                                                          INSTGEN
              J = FREEL(FALSE,I); 
          GENSATEMP(OPNAMES"SLRBPK",J,TEMPNO[VR]);                       INSTGEN
          GENREGMOVE(OPNAMES"SBXPB",REG,J);                              INSTGEN
          ASSIGN(REGTYPE"TYPEB",REG,VR);                                 INSTGEN
          TEMPF[VR] = FALSE;
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          FUNC  GETREG((VR),(TYPE));
 #    DETERMINE MACHINE REGISTER ASSIGNED TO A VIRTUAL REGISTER        # INSTGEN
 #        AND RELOAD FORM TEMPORARY IF NECESSARY                       # INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  TYPE  S:REGTYPE;                                         INSTGEN
          ITEM  VR;                                                      INSTGEN
          BEGIN                                                          INSTGEN
          IF  NOT TEMPFLG[VR] 
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              GETREG = AREG[VR];                                         INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          IF  TYPE EQ S"TYPEB"                                           INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              J = FREEB(FALSE); 
              RESTRB(J,VR);                                              INSTGEN
              GETREG = J;                                                INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          ELSE   # B OR  X# 
              BEGIN                                                      INSTGEN
              IF  TEMPANO[VR] EQ 0                                       INSTGEN
            THEN  J = FREEL(FALSE,LASTUSE[VR]); 
              ELSE                                                       INSTGEN
                  IF  STORED[VR]                                         INSTGEN
                  THEN  J = FREES(FALSE); 
                  ELSE                                                   INSTGEN
                      IF  LOADED[VR]                                     INSTGEN
                      THEN  J = FREEL(FALSE,LASTUSE[VR]); 
                      ELSE  J = 0;                                       INSTGEN
              RESTRAX(J,VR);                                             INSTGEN
              GETREG = J;                                                INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL EJECT;                                                 INSTGEN
          FUNC REGASG(V);                                                INSTGEN
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   REGASG - ASSIGN A VIRTUAL REGISTER TO A MACHINE REGISTER          #
 #                                                                     #
 #   GIVEN - A REGISTER DEFING INSTRUCTION, THE VIRTUAL REGISTER       #
 #           TABLE, AND THE MACHINE REGISTER STATUS TABLE              #
 #                                                                     #
 #   DOES - SELECTS AN AVAILABLE REGISTER OF THE PROPER CLASS          #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
                                                                         INSTGEN
          SWITCH  REGTYP:OPNAMES                                         INSTGEN
                  ERR:   NULL,                                           INSTGEN
                  XREG:  XMIT,                                           INSTGEN
                  XREG:  LAND,                                           INSTGEN
                  XREG:  LOR,                                            INSTGEN
                  XREG:  LXOR,                                           INSTGEN
                  XREG:  COMPL, 
                  XREG:  LIMP,                                           INSTGEN
                  XREG:  STRK,                                           INSTGEN
                  XREG:  LEQV,                                           INSTGEN
                  XREG:  SHLB,                                           INSTGEN
                  XREG:  SHRB,                                           INSTGEN
                  BXREGS:NORM,                                           INSTGEN
                  BXREGS:RNRM,                                           INSTGEN
                  BXREGS:UNP,                                            INSTGEN
                  XREG:  PACK,                                           INSTGEN
                  XREG:  FADD,                                           INSTGEN
                  XREG:  FSUB,                                           INSTGEN
                  XREG:  DADD,                                           INSTGEN
                  XREG:  DSUB,                                           INSTGEN
                  XREG:  RADD,                                           INSTGEN
                  XREG:  RSUB,                                           INSTGEN
                  XREG:  IADD,                                           INSTGEN
                  XREG:  ISUB,                                           INSTGEN
                  XREG:  FMUL,                                           INSTGEN
                  XREG:  RMUL,                                           INSTGEN
                  XREG:  DMUL,                                           INSTGEN
                  XREG:  IMUL,                                           INSTGEN
                  XREG:  FDIV,                                           INSTGEN
                  XREG:  RDIV,                                           INSTGEN
                  XREG:  SUM1,                                           INSTGEN
                  REGA0: SAXPB,                                          INSTGEN
                  REGA0: SAAPB,                                          INSTGEN
                  REGA0: SAAMB,                                          INSTGEN
                  REGA0: SABPB,                                          INSTGEN
                  REGA0: SABMB,                                          INSTGEN
                  BREG:  SBXPB,                                          INSTGEN
                  BREG:  SBAPB,                                          INSTGEN
                  BREG:  SBAMB,                                          INSTGEN
                  BREG:  SBBPB,                                          INSTGEN
                  BREG:  SBBMB,                                          INSTGEN
                  XREG:  SXXPB,                                          INSTGEN
                  XREG:  SXAPB,                                          INSTGEN
                  XREG:  SXAMB,                                          INSTGEN
                  XREG:  SXBPB,                                          INSTGEN
                  XREG:  SXBMB,                                          INSTGEN
                  LOAD:  SLRXPB,                                         INSTGEN
                  LOAD:  SLRAPB,                                         INSTGEN
                  LOAD:  SLRAMB,                                         INSTGEN
                  LOAD:  SLRBPB,                                         INSTGEN
                  LOAD:  SLRBMB,                                         INSTGEN
                  STREG: SSRXPB,                                         INSTGEN
                  STREG: SSRAPB,                                         INSTGEN
                  STREG: SSRAMB,                                         INSTGEN
                  STREG: SSRBPB,                                         INSTGEN
                  STREG: SSRBMB,                                         INSTGEN
                  REGDEF:RDEF,                                           INSTGEN
                  ERR:   RSTOR,                                          INSTGEN
                  ERR:   RFREE,                                          INSTGEN
                  ERR:   HOLDR,                                          INSTGEN
                  ERR:   NO$,                                            INSTGEN
                  ERR:   PS$,                                            INSTGEN
                  XREG:  SHL,                                            INSTGEN
                  XREG:  SHR,                                            INSTGEN
                  XREG:  MASK,                                           INSTGEN
                  ERR:   BSS$,                                           INSTGEN
                  ERR:   DATA$,                                          INSTGEN
                  ERR:   VFD$,                                           INSTGEN
                  ERR:   LINE,                                           INSTGEN
                  ERR:   REPL,                                           INSTGEN
                  ERR:   OBJ,                                            INSTGEN
                  ERR:   LOOP,                                           INSTGEN
                  ERR:   ENDL,                                           INSTGEN
                  ERR:   MD$,                                            INSTGEN
                  XREG:  DM$,                                            INSTGEN
                  XREG:  CC$,                                            INSTGEN
                  XREG:  CU$,                                            INSTGEN
                  ERR:   PLUS,                                           INSTGEN
                  ERR:   MINUS,                                          INSTGEN
                  ERR:   JP$,                                            INSTGEN
                  ERR:   ZR$,                                            INSTGEN
                  ERR:   NZ$,                                            INSTGEN
                  ERR:   PL$,                                            INSTGEN
                  ERR:   NG$,                                            INSTGEN
                  ERR:   IR$,                                            INSTGEN
                  ERR:   OR$,                                            INSTGEN
                  ERR:   DF$,                                            INSTGEN
                  ERR:   ID$,                                            INSTGEN
                  ERR:   EQ$,                                            INSTGEN
                  ERR:   NE$,                                            INSTGEN
                  ERR:   GE$,                                            INSTGEN
                  ERR:   LT$,                                            INSTGEN
                  REGA0: SAAPK,                                          INSTGEN
                  REGA0: SABPK,                                          INSTGEN
                  REGA0: SAXPK,                                          INSTGEN
                  BREG:  SBAPK,                                          INSTGEN
                  BREG:  SBBPK,                                          INSTGEN
                  BREG:  SBXPK,                                          INSTGEN
                  XREG:  SXAPK,                                          INSTGEN
                  XREG:  SXBPK,                                          INSTGEN
                  XREG:  SXXPK,                                          INSTGEN
                  LOAD:  SLRAPK,                                         INSTGEN
                  LOAD:  SLRBPK,                                         INSTGEN
                  LOAD:  SLRXPK,                                         INSTGEN
                  STREG: SSRAPK,                                         INSTGEN
                  STREG: SSRBPK,                                         INSTGEN
                  STREG: SSRXPK,                                         INSTGEN
                  XREG:  IM$,                                            INSTGEN
                  ERR:   RJ$,                                            INSTGEN
                  ERR:   LABEL$,                                         INSTGEN
                  ERR:   IDENT$,                                         INSTGEN
                  ERR:   END$,                                           INSTGEN
                  ERR:   USE$,                                           INSTGEN
                  ERR:   EPRC,                                           INSTGEN
                  ERR:   ENDOP;                                          INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  V;                                                       INSTGEN
          ITEM  VR;                                                      INSTGEN
          CONTROL  EJECT;                                                INSTGEN
                                                                         INSTGEN
                                                                         INSTGEN
          FUNC  FREESX; 
          ITEM  FARLOCK;
          ITEM J;                                                        INSTGEN
          ITEM K;                                                        INSTGEN
          ITEM  L;
          BEGIN                                                          INSTGEN
 #        FREESX NEED NOT EMPLOY FAIL LOGIC                            # INSTGEN
          FREESX = -1;                                                   INSTGEN
          FARLOCK = 0;
          FOR  J = 6 STEP 1 UNTIL 7  DO                                  INSTGEN
              BEGIN                                                      INSTGEN
              L = J + OFFSETA;
              K = J + OFFSETX;                                           INSTGEN
              IF  NOT INUSE[K] AND NOT INUSE[L] 
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  IF  NEXTLOCK(K) GR FARLOCK
                  THEN
                      BEGIN 
                      FREESX = J; 
                      FARLOCK = NEXTLOCK(K);
                      END 
                  END                                                    INSTGEN
              END                                                        INSTGEN
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          FUNC  LOCKPR(RTYPE);                                           INSTGEN
 #                                                                     #
 #        LOCKPR - ASSIGN A VIRTUAL REGISTER TO A SPECIFIC REAL        #
 #                 REGISTER, MOVING THEN CONTENTS OF THE REAL REGISTER #
 #                 IF NECESSARY                                        #
 #                                                                     #
          ITEM  J;
          ITEM  K;
          ITEM  RTYPE  S:REG;                                            INSTGEN
          ITEM  R;                                                       INSTGEN
          ITEM  S;                                                       INSTGEN
          SWITCH  PRLOCK: REG                                            INSTGEN
                  LOCKB$: B,                                             INSTGEN
                  LOCKX$: X,                                             INSTGEN
                  LOCKL$: L,                                             INSTGEN
                  LOCKS$:S;                                              INSTGEN
          BEGIN                                                          INSTGEN
          GOTO  PRLOCK[RTYPE];                                           INSTGEN
                                                                         INSTGEN
 LOCKB$:                                                                 INSTGEN
          J = AREG[VR] + OFFSETB; 
          $BEGIN
          IF  RESERVED[J] THEN                                           INSTGEN
              ASMABT("ATTEMPT TO LOCK RESERVED REGISTER",33);            INSTGEN
          IF  LOCK[J] AND (USECNT[J] NQ 0 OR HOLD[J])                    INSTGEN
          THEN  ASMABT("MULTIPLE LOCKS ON SINGLE REGISTER",33);          INSTGEN
          $END
          IF  USECNT[J] NQ 0                                             INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              R = FREEB(FALSE); 
              IF  R NQ AREG[VR] 
              THEN
                  BEGIN 
                  GENREGMOVE(OPNAMES"SBBPB",R,AREG[VR]);
                  COPYREG(R,AREG[VR],REGTYPE"TYPEB"); 
                  END 
              END                                                        INSTGEN
          LOCKPR = AREG[VR];                                             INSTGEN
          IF  FIRSTLOCK[J] NQ 0 AND LOCKB[VR] 
          THEN  FIRSTLOCK[J] =  LOCKLINK[FIRSTLOCK[J]]; 
          RETURN;                                                        INSTGEN
                                                                         INSTGEN
 LOCKX$:                                                                 INSTGEN
          J = AREG[VR] + OFFSETX; 
          $BEGIN
          IF  RESERVED[J] THEN                                           INSTGEN
              ASMABT("ATTEMPT TO LOCK RESERVED REGISTER",33);            INSTGEN
          IF  LOCK[J] AND (USECNT[J] NQ 0 OR HOLD[J])                    INSTGEN
          THEN  ASMABT("MULTIPLE LOCKS ON SINGLE REGISTER",33);          INSTGEN
          $END
          IF  USECNT[J] NQ 0                                             INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              R = FREEX(FALSE,LASTUSE[VREGN[J]]); 
              IF  R NQ AREG[VR] 
              THEN
                  BEGIN 
                  GENREGMOVE(OPNAMES"XMIT",R,AREG[VR]); 
                  COPYREG(R,AREG[VR],REGTYPE"TYPEX"); 
                  END 
              END                                                        INSTGEN
          LOCKPR = AREG[VR];                                             INSTGEN
          IF  FIRSTLOCK[J] NQ 0 AND LOCKED[VR]
          THEN  FIRSTLOCK[J] = LOCKLINK[FIRSTLOCK[J]];
          RETURN;                                                        INSTGEN
                                                                         INSTGEN
 LOCKL$:                                                                 INSTGEN
          $BEGIN
          IF  AREG[VR] LS 1 OR AREG[VR] GR 5                             INSTGEN
          THEN  ASMABT("BAD LOCK - WRONG TYPE",21);                      INSTGEN
          $END
          J = AREG[VR] + OFFSETX; 
          K = AREG[VR] + OFFSETA; 
          $BEGIN
          IF  RESERVED[J] OR RESERVED[K] THEN                            INSTGEN
              ASMABT("ATTEMPT TO LOCK RESERVED REGISTER",33);            INSTGEN
          IF  LOCK[J] AND (USECNT[J] NQ 0  OR HOLD[J]) OR                INSTGEN
              LOCK[K] AND (USECNT[K] NQ 0  OR HOLD[K])                   INSTGEN
          THEN  ASMABT("MULTIPLE LOCKS ON SINGLE REGISTER",33);          INSTGEN
          $END
          IF  USECNT[K] NQ 0  # A NOT FREE                             # INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              R = FREEL(FALSE,I); 
              IF  R NQ AREG[VR] 
              THEN
                  BEGIN 
                  GENREGMOVE(OPNAMES"SLRAPB",R,AREG[VR]); 
                  COPYREG(R,AREG[VR],REGTYPE"TYPEA"); 
                  IF  USECNT[J] NQ 0   # X NOT FREE                    #
                  THEN
                      BEGIN 
                      GENREGMOVE(OPNAMES"XMIT",R,AREG[VR]); 
                      COPYREG(R,AREG[VR],REGTYPE"TYPEX"); 
                      END 
                  END 
              END                                                        INSTGEN
          ELSE               # A FREE                                  # INSTGEN
              IF  USECNT[J] NQ 0  # X NOT FREE                         # INSTGEN
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  R = FREEX(FALSE,LASTUSE[VREGN[J]]); 
                  IF  R NQ AREG[VR] 
                  THEN
                      BEGIN 
                      GENREGMOVE(OPNAMES"XMIT",R,AREG[VR]); 
                      COPYREG(R,AREG[VR],REGTYPE"TYPEX"); 
                      END 
                  END                                                    INSTGEN
          LOCKPR = AREG[VR];                                             INSTGEN
          IF  FIRSTLOCK[J] NQ 0 AND LOCKED[VR]
          THEN  FIRSTLOCK[J] = LOCKLINK[FIRSTLOCK[J]];
          RETURN;                                                        INSTGEN
                                                                         INSTGEN
 LOCKS$:                                                                 INSTGEN
          $BEGIN
          IF  AREG[VR] LS 6  THEN  ASMABT("BAD LOCK - WRONG TYPE",21);   INSTGEN
          $END
          J = AREG[VR] + OFFSETA; 
          K = AREG[VR] + OFFSETX; 
          $BEGIN
          IF  RESERVED[J]  THEN                                          INSTGEN
              ASMABT("ATTEMPT TO LOCK RESERVED REGISTER",33);            INSTGEN
          IF  LOCK[J] AND (USECNT[J] NQ 0 OR HOLD[J])                    INSTGEN
          THEN  ASMABT("MULTIPLE LOCKS ON SINGLE REGISTER",33);          INSTGEN
          $END
          IF  USECNT[J] NQ 0  # A NOT FREE                             # INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              S = FREES(FALSE); 
              IF  S NQ AREG[VR] 
              THEN
                  BEGIN 
                  R = FREEL(FALSE); 
                  GENREGMOVE(OPNAMES"SLRAPB",R,AREG[VR]); 
                  GENREGMOVE(OPNAMES"XMIT",S,R);
                  GENREGMOVE(OPNAMES"SSRAPB",S,R);
                  COPYREG(S,AREG[VR],REGTYPE"TYPEA"); 
                  END 
              END                                                        INSTGEN
          ELSE
              IF  USECNT[K] NQ 0       #X NOT FREE                     #
              THEN
                  BEGIN 
                  R = FREEX(FALSE,LASTUSE[VREGN[K]]); 
                  IF  R NQ AREG[VR] 
                  THEN
                      BEGIN 
                      GENREGMOVE(OPNAMES"XMIT",R,AREG[VR]); 
                      COPYREG(R,AREG[VR],REGTYPE"TYPEX"); 
                      END 
                  END 
          LOCKPR = AREG[VR];                                             INSTGEN
          IF  FIRSTLOCK[K] NQ 0 AND LOCKED[VR]
          THEN  FIRSTLOCK[K] = LOCKLINK[FIRSTLOCK[K]];
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT; 
          FUNC  HOLDPR(RTYPE);
 #                                                                     #
 #        HOLDPR - ASSIGN A HELD (BUT NOT LOCKED) VIRTUAL REGISTER     #
 #                 TO A REAL REGISTER.  SELECT A REAL REGISTER WHICH   #
 #                 WILL NOT BE LOCKED BEFORE THE LASTUSE OF THE VIRTUAL#
 #                 REGISTER                                            #
          ITEM  FREEFOUND  B; 
          ITEM  J;
          ITEM  K;
          ITEM  L;
          ITEM  M;
          ITEM  RTYPE S:REG;
          SWITCH  PRHOLD: REG 
                  HOLDB$: B,
                  HOLDX$: X,
                  HOLDL$: L,
                  HOLDS$: S;
  
          BEGIN 
          FREEFOUND = FALSE;
          L=-1; 
          GOTO  PRHOLD[RTYPE];
 HOLDB$:  
          FOR  J = 0 STEP 1 WHILE J LS 8 AND NOT FREEFOUND  DO
              BEGIN 
              K = J + OFFSETB;
              IF  NOT HOLD[K] AND NOT RESERVED[K] 
              THEN
                  IF  NEXTLOCK(K) GR LASTUSE[VR]
                  THEN
                      BEGIN 
                      L = J;
                      IF  USECNT[K] EQ 0  THEN  FREEFOUND = TRUE; 
                      END 
              END 
          IF  L LS 0  THEN  ASMABT("B REGISTER OVERCOMMITMENT", 25);
          AREG[VR] = L; 
          HOLDPR = LOCKPR(RTYPE); 
          RETURN; 
 HOLDX$:  
          FOR  J = 0 STEP 1 WHILE J LS 8 AND NOT FREEFOUND  DO
              BEGIN 
              K = J + OFFSETX;
              M = J + OFFSETA;
              IF  NOT HOLD[K] 
              THEN
                  BEGIN 
                  IF  J NQ 0
                  THEN  IF HOLD[M]  THEN TEST;
                  IF  NEXTLOCK(K) GR LASTUSE[VR]
                  THEN
                      BEGIN 
                      L = J;
                      IF  USECNT[K] EQ 0 AND (J EQ 0 OR USECNT[M] EQ 0) 
                      THEN  FREEFOUND = TRUE; 
                      END 
                  END 
              END 
          IF  L LS 0  THEN  ASMABT("OVERCOMMITMENT OF X REGISTERS",29); 
          AREG[VR] = L; 
          HOLDPR = LOCKPR(RTYPE); 
          RETURN; 
 HOLDL$:  
          FOR  J = 1 STEP 1 WHILE  J LS 6 AND NOT FREEFOUND  DO 
              BEGIN 
              K = J + OFFSETX;
              M = J + OFFSETA;
              IF  NOT HOLD[K] AND NOT HOLD[M] 
              THEN
              IF  NEXTLOCK(K) GR LASTUSE[VR]
              THEN
                  BEGIN 
                  L = J;
                  IF  USECNT[K] EQ 0 AND USECNT[M] EQ 0 
                  THEN  FREEFOUND = TRUE; 
                  END 
              END 
          IF  L LS 0  THEN  ASMABT("OVERCOMMITMENT OF LOAD REGISTERS",
                                                                    35);
          AREG[VR] = L; 
          HOLDPR = LOCKPR(RTYPE); 
          RETURN; 
 HOLDS$:  
          FOR J = 6 STEP 1 WHILE J LS 8 AND NOT FREEFOUND  DO 
              BEGIN 
              K = J + OFFSETX;
              M = J + OFFSETA;
              IF  NOT HOLD[K] AND NOT HOLD[M] 
              THEN
                  IF  NEXTLOCK(K) GR LASTUSE[VR]
                  THEN
                      BEGIN 
                      L = J;
                      IF  USECNT[K] EQ 0 AND USECNT[M] EQ 0 
                      THEN  FREEFOUND = TRUE; 
                      END 
              END 
          IF  L LS 0  THEN  ASMABT("OVERCOMMITMENT OF STORE REGISTERS", 
                                                                    35);
          AREG[VR] = L; 
          HOLDPR = LOCKPR(RTYPE); 
          RETURN; 
          END 
          CONTROL  EJECT;                                                INSTGEN
          BEGIN                                                          INSTGEN
          VR = FINDR(V,J);                                               INSTGEN
          GOTO REGTYP[OPC];                                              INSTGEN
 BREG:                                                                   INSTGEN
          IF  ASSIGND[VR]                                                INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = GETREG(VR,REGTYPE"TYPEB");                        INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          $BEGIN
          IF  LOCKX[VR] OR LOCKA[VR]                                     INSTGEN
          THEN  ASMABT("BAD REGISTER LOCK - WRONG TYPE",30);             INSTGEN
          $END
          IF  LOCKB[VR] OR
              (RPREF[VR] AND (USES[VR] EQ 1 OR RHOLD[VR]))
          THEN  R = LOCKPR(REG"B"); 
          ELSE
              IF  RHOLD[VR] 
              THEN  R = HOLDPR(REG"B"); 
              ELSE  R = FREEB(TRUE);
          REGASG = R;                                                    INSTGEN
          ASSIGN(REGTYPE"TYPEB",R,VR);                                   INSTGEN
          REGCONTENT[R+OFFSETB] = REGCONTENT[NEW];
          RETURN;                                                        INSTGEN
 XREG:                                                                   INSTGEN
          IF  ASSIGND[VR]                                                INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = GETREG(VR,REGTYPE"TYPEX");                        INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          $BEGIN
          IF  LOCKB[VR]                                                  INSTGEN
          THEN  ASMABT("BAD REGISTER LOCK - WRONG TYPE",30);             INSTGEN
          $END
          IF  LOCKX[VR] OR LOCKA[VR] OR 
              (RPREF[VR] AND (USES[VR] EQ 1 OR RHOLD[VR]))
          THEN  R = LOCKPR(REG"X");                                      INSTGEN
          ELSE                                                           INSTGEN
              IF STORED[VR]                                              INSTGEN
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  IF  RHOLD[VR] 
                  THEN  R = HOLDPR(REG"S"); 
                  ELSE                                                   INSTGEN
                      BEGIN                                              INSTGEN
                      R = FREESX; 
                      IF  R LS 0  THEN R = FREEX(TRUE,LASTUSE[VR]); 
                      END                                                INSTGEN
                  END                                                    INSTGEN
              ELSE
                  IF  RHOLD[VR] 
                  THEN  R = HOLDPR(REG"X"); 
                  ELSE  R = FREEX(TRUE,LASTUSE[VR]);
          REGASG = R;                                                    INSTGEN
          ASSIGN(REGTYPE"TYPEX",R,VR);                                   INSTGEN
          REGCONTENT[R+OFFSETX] = REGCONTENT[NEW];
          RETURN;                                                        INSTGEN
 LOAD:                                                                   INSTGEN
          IF  ASIGNDA[VR]                                                INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = GETREG(VR,REGTYPE"TYPEA");                        INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          $BEGIN
          IF  LOCKB[VR]                                                  INSTGEN
          THEN  ASMABT("BAD REGISTER LOCK - WRONG TYPE",30);             INSTGEN
          $END
          IF  LOCKX[VR] OR LOCKA[VR] OR 
              (RPREF[VR] AND AREG[VR] NQ 0 AND  AREG[VR] LS 6 
              AND (USES[VR] EQ 1 OR RHOLD[VR])) 
          THEN   R = LOCKPR(REG"L");                                     INSTGEN
          ELSE
              IF  RHOLD[VR] 
              THEN  R = HOLDPR(REG"L"); 
              ELSE  R = FREEL(TRUE,LASTUSE[VR]);
          REGASG = R;                                                    INSTGEN
          ASSIGN(REGTYPE"TYPEA",R,VR);                                   INSTGEN
          ASSIGN(REGTYPE"TYPEX",R,VR);                                   INSTGEN
          REGCONTENT[R+OFFSETA] = REGCONTENT[NEW];
          REGCONTENT[R+OFFSETX] = REGCONTENT[NEW];
          IF TYPECON[NEW] NQ S"NULL"
          THEN  TYPECON[R+OFFSETX] = S"STORAGE";
          RETURN;                                                        INSTGEN
 STREG:                                                                  INSTGEN
          IF  ASIGNDA[VR]                                                INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = GETREG(VR,REGTYPE"TYPEA");                        INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          $BEGIN
          IF  LOCKB[VR]                                                  INSTGEN
          THEN  ASMABT("BAD REGISTER LOCK - WRONG TYPE",30);             INSTGEN
          $END
          IF  LOCKX[VR] OR LOCKA[VR]                                     INSTGEN
          THEN  R = LOCKPR(REG"S");                                      INSTGEN
          ELSE                                                           INSTGEN
          BEGIN                                                          INSTGEN
          IF AREG[VR] EQ 6 OR AREG[VR] EQ 7      #STORE REGISTER       # INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              J = AREG[VR] + OFFSETA;                                    INSTGEN
              IF  USECNT[J]  EQ 0 AND NOT HOLD[J]                        INSTGEN
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  REGASG = AREG[VR];                                     INSTGEN
                  ASSIGN(REGTYPE"TYPEA",AREG[VR],VR);                    INSTGEN
                  R = AREG[VR]; 
                  REGCONTENT[R+OFFSETA] = REGCONTENT[NEW];
                  REGCONTENT[R+OFFSETX] = REGCONTENT[NEW];
                  IF  TYPECON[NEW] NQ S"NULL" 
                  THEN  TYPECON[R+OFFSETX] = S"STORAGE";
                  RETURN;                                                INSTGEN
                  END                                                    INSTGEN
              END                                                        INSTGEN
          R = FREES(TRUE);
          GENREGMOVE(OPNAMES"XMIT",R,AREG[VR]); 
          J = AREG[VR];      # AREG CHANGED BY COPYREG                 #
          COPYREG(R,AREG[VR],REGTYPE"TYPEX");                            INSTGEN
          USECNT[J+OFFSETX] = 0;
          END                                                            INSTGEN
          REGASG = R;                                                    INSTGEN
          ASSIGN(REGTYPE"TYPEA",R,VR);                                   INSTGEN
          REGCONTENT[R+OFFSETA] = REGCONTENT[NEW];
          REGCONTENT[R+OFFSETX] = REGCONTENT[NEW];
          IF  TYPECON[NEW]  NQ S"NULL"
          THEN  TYPECON[R+OFFSETX] = S"STORAGE";
          RETURN;                                                        INSTGEN
 REGA0:                                                                  INSTGEN
          IF  ASIGNDA[VR]                                                INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = GETREG(VR,REGTYPE"TYPEA");                        INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
          $BEGIN
          IF  LOCKB[VR] OR LOCKX[VR] OR AREG[VR] NQ 0 
          THEN  ASMABT("BAD REGISTER LOCK - WRONG TYPE",30);             INSTGEN
          $END
          J = 0 + OFFSETA;                                               INSTGEN
          IF  USECNT[J] EQ 0 AND NOT HOLD[J]                             INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              REGASG = 0;                                                INSTGEN
              ASSIGN(REGTYPE"TYPEA",0,VR);                               INSTGEN
              RETURN;                                                    INSTGEN
              END                                                        INSTGEN
 #TEMP#   ASMABT("A0 NOT FREE",11);                                      INSTGEN
 BXREGS:                                                                 INSTGEN
          IF  BXFLAG EQ 0 THEN GOTO BREG;  ELSE  GOTO  XREG;             INSTGEN
 REGDEF:                                                                 INSTGEN
          IF  LOCKB[VR] THEN GOTO  BREG;                                 INSTGEN
          IF  LOCKA[VR]                                                  INSTGEN
          THEN                                                           INSTGEN
              BEGIN                                                      INSTGEN
              IF  AREG[VR] EQ 0 THEN GOTO  REGA0;                        INSTGEN
              IF  AREG[VR] LQ 5 THEN  GOTO  LOAD;                        INSTGEN
              GOTO  STREG;                                               INSTGEN
              END                                                        INSTGEN
          IF  LOCKX[VR]  THEN GOTO XREG;                                 INSTGEN
 ERR:                                                                    INSTGEN
          ASMABT("BAD CALL TO REGASG",18);                               INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT; 
          PROC  REGPR;
          LABEL  ERR; 
          SWITCH  USEDEF     #  DEF    USE                             #
              NONE, 
              ERR,           #           K                             #
              ERR,           #          J                              #
              ERR,           #          JK                             #
              UI,            #         I                               #
              ERR,           #         I K                             #
              UIJ,           #         IJ                              #
              ERR,           #         IJK                             #
              ERR,           #    J                                    #
              ERR,           #    J      K                             #
              ERR,           #    J     J                              #
              ERR,           #    J     JK                             #
              ERR,           #    J    I                               #
              ERR,           #    J    I K                             #
              ERR,           #    J    IJ                              #
              ERR,           #    J    IJK                             #
              DI,            #   I                                     #
              DIUK,          #   I       K                             #
              DIUJ,          #   I      J                              #
              DIUJK,         #   I      JK                             #
              ERR,           #   I     I                               #
              ERR,           #   I     I K                             #
              ERR,           #   I     IJ                              #
              ERR,           #   I     IJK                             #
              ERR,           #   IJ                                    #
              DIJUK,         #   IJ      K                             #
              ERR,           #   IJ     J                              #
              ERR,           #   IJ     JK                             #
              ERR,           #   IJ    I                               #
              ERR,           #   IJ    I K                             #
              ERR,           #   IJ    IJ                              #
              ERR;           #   IJ    IJK                             #
          BEGIN 
          GOTO   USEDEF[REGUSEDEF[OPC]];
 ERR: 
          ASMABT("ERROR IN REGPR",14);
          RETURN; 
 NONE:  
          RETURN; 
 UI:  
          VREG = IREG[I]; 
          MREG = GETREG(VREG,TYPEI[OPC]); 
          IREG[I] = MREG; 
          MREG = REGOFF[TYPEI[OPC]] + MREG; 
          USECNT[MREG] = USECNT[MREG] - 1;
          RETURN; 
 DI:  
          MREG = REGASG(IREG[I]); 
          IREG[I] = MREG; 
          RETURN; 
 DIUK:  
          VREG = KREG[I]; 
          MREG = GETREG(VREG,TYPEK[OPC]); 
          KREG[I] = MREG; 
          MREG = REGOFF[TYPEK[OPC]] + MREG; 
          USECNT[MREG] = USECNT[MREG] - 1;
          INPUT[MREG] = TRUE; 
          KINPUT = MREG;
          MREG = REGASG(IREG[I]); 
          IREG[I] = MREG; 
          INPUT[KINPUT] = FALSE;
          RETURN; 
 DIUJ:  
          IF  STORE[OPC]
          THEN
              BEGIN 
              VREG = IREG[I]; 
              IF  NOT  TEMPF[VREG] AND NOT TEMPAF[VREG] 
              THEN
                  BEGIN 
                  IINPUT = AREG[VREG] + OFFSETX;
                  INPUT[IINPUT] = TRUE; 
                  END 
              VREG = JREG[I]; 
              MREG = GETREG(VREG,TYPEJ[OPC]); 
              JREG[I] = MREG; 
              MREG = REGOFF[TYPEJ[OPC]] + MREG; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              JINPUT = MREG;
              VREG = IREG[I]; 
              MREG = GETREG(VREG,REGTYPE"TYPEX"); 
              MREG = MREG + OFFSETX;
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              IINPUT = MREG;
              MREG = REGASG(VREG);
              IREG[I] = MREG; 
              INPUT[IINPUT] = FALSE;
              INPUT[JINPUT] = FALSE;
              END 
          ELSE
              BEGIN 
              VREG = JREG[I]; 
              MREG = GETREG(VREG,TYPEJ[OPC]); 
              JREG[I] = MREG; 
              MREG = REGOFF[TYPEJ[OPC]] + MREG; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              JINPUT = MREG;
              MREG = REGASG(IREG[I]); 
              IREG[I] = MREG; 
              INPUT[JINPUT] = FALSE;
              END 
          RETURN; 
 DIUJK: 
          IF  STORE[OPC]
          THEN
              BEGIN 
              VREG = KREG[I]; 
              IF  NOT TEMPF[VREG] AND NOT TEMPAF[VREG]
              THEN
                  BEGIN 
                  KINPUT = AREG[VREG] + REGOFF[TYPEK[OPC]]; 
                  INPUT[KINPUT] = TRUE; 
                  END 
              VREG = IREG[I]; 
              IF  NOT TEMPF[VREG] AND NOT TEMPAF[VREG]
              THEN
                  BEGIN 
                  IINPUT = AREG[VREG] + OFFSETX;
                  INPUT[IINPUT] = TRUE; 
                  END 
              VREG = JREG[I]; 
              MREG = GETREG(VREG,TYPEJ[OPC]); 
              JREG[I] = MREG; 
              MREG = REGOFF[TYPEJ[OPC]] + MREG; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              JINPUT = MREG;
              VREG = KREG[I]; 
              MREG = GETREG(VREG,TYPEK[OPC]); 
              KREG[I] = MREG; 
              MREG = REGOFF[TYPEK[OPC]] + MREG; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              KINPUT = MREG;
              VREG = IREG[I]; 
              MREG = GETREG(VREG,REGTYPE"TYPEX"); 
              MREG = MREG + OFFSETX;
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              IINPUT = MREG;
              MREG = REGASG(IREG[I]); 
              IREG[I] = MREG; 
              INPUT[IINPUT] = FALSE;
              INPUT[JINPUT] = FALSE;
              INPUT[KINPUT] = FALSE;
              END 
          ELSE
              BEGIN 
              VREG = KREG[I]; 
              IF  NOT TEMPF[VREG] AND NOT TEMPAF[VREG]
              THEN
                  BEGIN 
                  KINPUT = AREG[VREG] + REGOFF[TYPEK[OPC]]; 
                  INPUT[KINPUT] = TRUE; 
                  END 
              VREG = JREG[I]; 
              MREG = GETREG(VREG,TYPEJ[OPC]); 
              JREG[I] = MREG; 
              MREG = REGOFF[TYPEJ[OPC]] + MREG; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              JINPUT = MREG;
              VREG = KREG[I]; 
              MREG = GETREG(VREG,TYPEK[OPC]); 
              KREG[I] = MREG; 
              MREG = MREG + REGOFF[TYPEK[OPC]]; 
              USECNT[MREG] = USECNT[MREG] - 1;
              INPUT[MREG] = TRUE; 
              KINPUT = MREG;
              MREG = REGASG(IREG[I]); 
              IREG[I] = MREG; 
              INPUT[JINPUT] = FALSE;
              INPUT[KINPUT] = FALSE;
              END 
          RETURN; 
 DIJUK: 
          VREG = KREG[I]; 
          MREG = GETREG(VREG,TYPEK[OPC]); 
          KREG[I] = MREG; 
          MREG = REGOFF[TYPEK[OPC]] + MREG; 
          USECNT[MREG] = USECNT[MREG] - 1;
          INPUT[MREG] = TRUE; 
          KINPUT = MREG;
          BXFLAG = 1; 
          MREG = REGASG(IREG[I]); 
          IREG[I] = MREG; 
          BXFLAG = 0; 
          MREG = REGASG(JREG[I]); 
          JREG[I] = MREG; 
          INPUT[KINPUT] = FALSE;
          RETURN; 
 UIJ: 
          VREG = JREG[I]; 
          IF NOT TEMPF[VREG] AND NOT TEMPAF[VREG] 
          THEN
              BEGIN 
              JINPUT = AREG[VREG] + REGOFF[TYPEJ[OPC]]; 
              INPUT[JINPUT] = TRUE; 
              END 
          VREG = IREG[I]; 
          MREG = GETREG(VREG,TYPEI[OPC]); 
          IREG[I] = MREG; 
          MREG = REGOFF[TYPEI[OPC]] + MREG; 
          USECNT[MREG] = USECNT[MREG] - 1;
          INPUT[MREG] = TRUE; 
          IINPUT = MREG;
          VREG = JREG[I]; 
          MREG = GETREG(VREG,TYPEJ[OPC]); 
          JREG[I] = MREG; 
          MREG = REGOFF[TYPEJ[OPC]] + MREG; 
          USECNT[MREG] = USECNT[MREG] - 1;
          INPUT[MREG] = FALSE;
          INPUT[IINPUT] = FALSE;
          RETURN; 
          END 
          CONTROL  EJECT;                                                INSTGEN
          PROC  RESTORE;                                                 INSTGEN
 #    RESTORE ALL HELD REGISTERS WHICH ARE IN TEMPORARIES              # INSTGEN
          ITEM  I;                                                       INSTGEN
          ITEM  J;                                                       INSTGEN
          BEGIN                                                          INSTGEN
          FOR I = 1 STEP 1 UNTIL 23  DO                                  INSTGEN
              BEGIN                                                      INSTGEN
              IF  HOLD[I]                                                INSTGEN
              THEN                                                       INSTGEN
                  BEGIN                                                  INSTGEN
                  J = VREGN[I]; 
                  IF  HOLDB[J] AND TEMPF[J] 
                  THEN  RESTRB(AREG[J],J);                               INSTGEN
                  IF  (HOLDA[J] OR HOLDX[J]) AND                         INSTGEN
                      (TEMPF[J] OR TEMPAF[J]) 
                  THEN  RESTRAX(AREG[J],J);                              INSTGEN
                  END                                                    INSTGEN
              END                                                        INSTGEN
          RETURN;                                                        INSTGEN
          END                                                            INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          PROC  SAVREG(INDX);                                            INSTGEN
 #    SAVE ALL REGISTERS IN TEMPORARY WHICH ARE DESTROYED BY OBJECT    # INSTGEN
 #        ROUTINE                                                      # INSTGEN
*CALL OBJCOMM                                                            INSTGEN
          ITEM  I;                                                       INSTGEN
          ITEM  INDX;                                                    INSTGEN
          ITEM  J;                                                       INSTGEN
          ITEM  K;                                                       INSTGEN
          ITEM  L;                                                       INSTGEN
          ITEM  NIN;                                                     INSTGEN
          ITEM  NOUT;                                                    INSTGEN
          ITEM  NSAVE;                                                   INSTGEN
          ITEM  OBASE;                                                   INSTGEN
          ITEM  PTR;                                                     INSTGEN
          ITEM  RWORD;                                                   INSTGEN
          ITEM  SBASE;                                                   INSTGEN
          XREF  FUNC  MOD;                                               INSTGEN
                                                                         INSTGEN
          CONTROL  EJECT;                                                INSTGEN
          BEGIN                                                          INSTGEN
          PTR = OBJPTR[INDEX[INDX]];                                     INSTGEN
          NIN = IN[PTR];                                                 INSTGEN
          NOUT = OUT[PTR];                                               INSTGEN
          NSAVE = SAVE[PTR];                                             INSTGEN
          OBASE = (NIN + 9)/RCNT + PTR + 1; 
          SBASE = (NOUT + 9)/RCNT + OBASE;
          FOR  J = 1 STEP 1 UNTIL NIN  DO 
              BEGIN 
              RWORD = (J-1)/RCNT + PTR + 1; 
              K = B<RSIZE*MOD(J-1,RCNT),RSIZE>PARAMS[RWORD];
              I = B<57,3>K; 
              L = REGOFF[B<54,3>K]; 
              OBJIN[I+L] = TRUE;
              END 
          FOR  J = 1 STEP 1 UNTIL NSAVE DO
              BEGIN 
              RWORD = (J-1)/RCNT + SBASE; 
              K = B<RSIZE*MOD(J-1,RCNT),RSIZE>PARAMS[RWORD];
              I = B<57,3>K; 
              L = REGOFF[B<54,3>K]; 
              OBJSAVE[I+L] = TRUE;
              END 
          OBJCALL = TRUE; 
          FOR  I = FFB STEP 1 UNTIL 7 DO
              BEGIN 
              K = I + OFFSETB;
              IF  (NOT OBJSAVE[K]) AND (USECNT[K] NQ 0
              OR  (HOLD[K] AND NOT OBJIN[K])) 
              THEN  SAVEB(I); 
              OBJREGS[K] = 0; 
              END 
          FOR  I = 0 STEP 1 UNTIL 7  DO 
              BEGIN 
              K = I + OFFSETX;
              IF  (NOT OBJSAVE[K]) AND (USECNT[K] NQ 0
              OR (HOLD[K] AND NOT OBJIN[K]))
              THEN  SAVEX(I); 
              OBJREGS[K] = 0; 
              END 
          FOR  I = 0 STEP 1 UNTIL 7 DO
              BEGIN 
              K = I + OFFSETA;
              IF  (NOT OBJSAVE[K]) AND (USECNT[K] NQ 0
                  OR (HOLD[K] AND NOT OBJIN[K]))
              THEN  SAVEA(I); 
              OBJREGS[K] = 0; 
              END 
          OBJCALL = FALSE;
          RETURN;                                                        INSTGEN
 ENTRY    PROC   FREEINP(INDX);        #RELEASE INPUT REGISTERS        #
          PTR = OBJPTR[INDEX[INDX]];
          NIN = IN[PTR];
          FOR J = 1 STEP 1 UNTIL NIN DO 
              BEGIN 
              RWORD = (J-1)/RCNT + PTR + 1; 
              K = B<RSIZE*MOD(J-1,RCNT),RSIZE>PARAMS[RWORD];
              I = B<57,3>K;            #REGISTER NUMBER                #
              L = REGOFF[B<54,3>K];    #REGISTER TYPE                  #
              HOLD[I+L] = FALSE;
              IF  L EQ OFFSETA AND I NQ 0 
              THEN  HOLD[I+OFFSETX] = FALSE;
              END 
          RETURN; 
          END                                                            INSTGEN
          CONTROL EJECT;
          PROC SETCONTENTS; 
 #     SET CONTENTS OF REGISTER CONTENT TABLE ENTRY  #
          BEGIN 
          IF TABLE[I+1] NQ S"DNAT$" 
          THEN
              BEGIN 
              CONTENTDNAT[NEW] = 0; 
              CONTENTS[NEW] = SY[I+1];
              END 
          ELSE # CANT USE SY BECAUSE OF REDEFINES#
              BEGIN 
              CONTENTDNAT[NEW] = 1; 
              CONTENTSUBM[NEW] = DN$SUBMSEC[VIRTUAL(TABLETYPE"DNAT$", 
                  INDEX[I+1])]; 
              CONTENTWORD[NEW] = DN$WORDOFF[VIRTUAL(TABLETYPE"DNAT$", 
                  INDEX[I+1])] + CONS[I+1]; 
              END 
          END 
          CONTROL  EJECT;                                                INSTGEN
          BEGIN                                                          INSTGEN
          ATEMPCNT = 0; 
          OBJCALL = FALSE;
          IINPUT = 0; 
          JINPUT = 0; 
          KINPUT = 0; 
          LINE = FIRSTLINE; 
          NOTE = "NOT AVAIL ";
          INC = 0;
          ZEROREGCON; 
          FOR I = 1 STEP INC WHILE I LS ENDSEQ DO 
              BEGIN 
              OPC = OPCODE[I];
              INC = CLSIZE[CLASS[OPC]]; 
              IF CLASS[OPC] EQ S"CLASS2"  THEN INC =INC + COUNT[I]; 
              REGCONTENT[NEW] = 0;
              GOTO  INSTPR[OPC];
 ERR: 
              ASMABT("BAD INSTGEN INPUT",17); 
              TEST; 
 $XMIT: 
              REGPR;
              IF  IREG[I] EQ JREG[I] THEN TEST; 
              MREG = VREGN[IREG[I]+OFFSETX];
              IF  NOT INUSE[JREG[I] + OFFSETX]
                  AND NOT HOLD[IREG[I]+OFFSETX] 
                  AND (NOT STORED[MREG] OR JREG[I] GQ 6)
              THEN
                  BEGIN 
                  USECNT[IREG[I]+OFFSETX] = 0;
                  HOLD[IREG[I]+OFFSETX] = FALSE;
                  J = REGCONTENT[JREG[I] + OFFSETX];
                  ASSIGN(REGTYPE"TYPEX",JREG[I],MREG);
                  IF  NOT UNOPT[MREG] 
                  THEN  REGCONTENT[JREG[I]+OFFSETX] = J;
                  TEST; 
                  END 
              GOTO  INSTGEN1; 
 $CLASS1: 
              REGPR;
              GOTO  INSTGEN1; 
 $RDEF: 
              REGPR;
              TEST; 
 $INDSTORE: 
              CHANGECORE; 
              REGPR;
              GOTO  INSTGEN1; 
 $SLRAPB: 
              REGPR;
              GOTO INSTGEN1;
 $SSRAPB: 
              CHANGECORE; 
              REGPR;
              GOTO  INSTGEN1; 
 $TEST: 
              TEST; 
 $RFREE:  
              VREG = IREG[I]; 
              MREG = AREG[VREG];
              IF  HOLDB[VREG] 
              THEN  HOLD[MREG+OFFSETB] = FALSE; 
              IF  HOLDX[VREG] 
              THEN  HOLD[MREG+OFFSETX] = FALSE; 
              IF  HOLDA[VREG] 
              THEN  HOLD[MREG+OFFSETA] = FALSE; 
              TEST; 
 $CLASS2: 
              REGPR;
              GOTO  INSTGEN1; 
 $MASK: 
              IF  NOT UNOPT[IREG[I]]
              THEN
                  BEGIN 
                  TYPECON[NEW] = S"MASK"; 
                  CONTENTS[NEW] = CONST[I]; 
                  CONTENTDNAT[NEW] = 0; 
                  FOR  J = 0 STEP 1 UNTIL 7 DO
                      IF  REGCONTENT[J+OFFSETX] EQ REGCONTENT[NEW]
                          AND  USECNT[J+OFFSETX] EQ 0 
                          AND  USECNT[J+OFFSETA] EQ 0 
                      THEN
                          BEGIN 
                          ASSIGN(REGTYPE"TYPEX",J,IREG[I]); 
                          REGCONTENT[J+OFFSETX] = REGCONTENT[NEW];
                          TEST  I;
                          END 
                  END 
              GOTO  $CLASS2;
 $NOTED:  
              NOTE = C<1,9>TEXT[I+1]; 
              GOTO INSTGEN1;
 $LINE: 
              LINE = CONST[I];
          RA$LINE[0] = LINE;
              GOTO  INSTGEN1; 
 $CMU:  
              IF  OPC EQ S"DM$" THEN  CHANGECORE; 
              REGPR;
              ADJADDR(OPC,TRUE);
              POS = 30; 
              IF  TABLE[I+1]  EQ S"DNAT$" 
              THEN  ADDSUBL(CONS[I+1],INDEX[I+1],FALSE);
              POS = 0;
              IF  TABLE[I+2] EQ S"DNAT$"
              THEN  ADDSUBL(CONS[I+2],INDEX[I+2],FALSE);
              GOTO  INSTGEN2; 
 $JP$:  
              ZEROREGCON; 
              GOTO  $CLASS3;
 $EQ$:  
              IF  IREG[I] EQ JREG[I]  THEN ZEROREGCON;
              GOTO  $CLASS3;
 $CLASS3: 
              REGPR;
              ADJADDR(OPC,TRUE);
              IF  TABLE[I+1] EQ S"DNAT$"
              THEN  ADDSUBL(CONS[I+1],INDEX[I+1],FALSE);
              GOTO  INSTGEN2; 
 $SBBPK:  
              GOTO  $CLASS3;
 $SXBPK:  
              GOTO  $CLASS3;
 $SLRBPK: 
              IF  NOT UNOPT[IREG[I]] AND JREG[I] EQ 0 AND 
                  (TABLE[I+1] NQ S"DNAT$" OR
                  DN$MAJMSEC[VIRTUAL(TABLETYPE"DNAT$",INDEX[I+1])] NQ 
                  LINKMSEC) 
              THEN
                  BEGIN 
                  TYPECON[NEW] = S"ADDRESS";
                  SETCONTENTS;
                  FOR  J = 1 STEP 1 UNTIL 7 DO
                      IF  CONTENTS[J+OFFSETX] EQ CONTENTS[NEW]
                          AND REGCONTENT[J+OFFSETA] EQ REGCONTENT[NEW]
                          AND TYPECON[J+OFFSETX] EQ S"STORAGE"
                      AND USECNT[J+OFFSETX] EQ 0
                      AND USECNT[J+OFFSETA] EQ 0
                     THEN 
                          BEGIN 
                          ASSIGN(REGTYPE"TYPEX",J,IREG[I]); 
                          ASSIGN(REGTYPE"TYPEA",J,IREG[I]); 
                          REGCONTENT[J+OFFSETX] = REGCONTENT[NEW];
                          TYPECON[J+OFFSETX] = S"STORAGE";
                          REGCONTENT[J+OFFSETA] = REGCONTENT[NEW];
                          TEST I; 
                           END
                  END 
              GOTO  $CLASS3;
 $SSRBPK: 
              IF  NOT UNOPT[IREG[I]] AND JREG[I] EQ 0 AND 
                  (TABLE[I+1] NQ S"DNAT$" OR
                  DN$MAJMSEC[VIRTUAL(TABLETYPE"DNAT$",INDEX[I+1])] NQ 
                  LINKMSEC) 
              THEN
                  BEGIN 
                  TYPECON[NEW] = S"STORAGE";
                  SETCONTENTS;
                  FOR  J = 1 STEP 1 UNTIL 7 DO
                      IF  REGCONTENT[J+OFFSETX] EQ REGCONTENT[NEW]
                      THEN  REGCONTENT[J+OFFSETX] = 0;
                  TYPECON[NEW] = S"ADDRESS";
                  END 
              ELSE
                  BEGIN 
                  CHANGECORE; 
                  END 
              GOTO  $CLASS3;
 $CL3STORE: 
              CHANGECORE; 
              GOTO $CLASS3; 
 $IM$:  
              CHANGECORE; 
              GOTO  $CLASS3;
 $RJ$:  
              ZEROREGCON; 
              GOTO $CLASS4; 
 $LABEL$: 
              ZEROREGCON; 
              ADJADDR(OPC,TRUE);
              LABELPR(TABLE[I],INDEX[I]); 
              GOTO INSTGEN2;
 $CLASS4: 
              GOTO  INSTGEN1; 
 $EPRC: 
              ADJADDR(OPC,TRUE);
              PN$LASTADDR[VIRTUAL(TABLETYPE"PNAT$",INDEX[I])] = ORG - 1;
              GOTO INSTGEN2;
 $SBBPB:  
              REGPR;
              IF  IREG[I] EQ JREG[I] AND KREG[I] EQ 0  THEN  TEST;
              GOTO  INSTGEN1; 
 $CXMIT:  
              IF  NOT TEMPF[JREG[I]] AND AREG[IREG[I]] EQ AREG[JREG[I]] 
              THEN
                  BEGIN 
                  MREG = AREG[JREG[I]] + OFFSETX; 
                  HOLD[MREG] = TRUE;
                  IF  FIRSTLOCK[MREG] NQ 0
                  THEN  FIRSTLOCK[MREG] = LOCKLINK[FIRSTLOCK[MREG]];
                  USECNT[MREG] = USECNT[MREG] - 1;
                  TEST; 
                  END 
              ELSE
                  BEGIN 
                  OPC = S"XMIT";
                  OPCODE[I] = S"XMIT";
                  GOTO  $XMIT;
                  END 
 $CSBBPB: 
              IF  NOT TEMPF[JREG[I]] AND AREG[IREG[I]] EQ AREG[JREG[I]] 
              THEN
                  BEGIN 
                  MREG = AREG[JREG[I]] + OFFSETB; 
                  HOLD[MREG] = TRUE;
                  IF  FIRSTLOCK[MREG] NQ 0
                  THEN  FIRSTLOCK[MREG] = LOCKLINK[FIRSTLOCK[MREG]];
                  USECNT[MREG] = USECNT[MREG] - 1;
                  TEST; 
                  END 
              ELSE
                  BEGIN 
                  OPC = S"SBBPB"; 
                  OPCODE[I] = S"SBBPB"; 
                  GOTO  $SBBPB; 
                  END 
 $DXMIT:  
              IF  LASTUSE[IREG[I]] LS NEXTLOCK(AREG[JREG[I]]+OFFSETX) 
                  AND NOT RPREF[IREG[I]]
              THEN
                  BEGIN 
                  ASSIGN(REGTYPE"TYPEX",AREG[JREG[I]],IREG[I]); 
                  TEST; 
                  END 
              ELSE
                  BEGIN 
                  OPC = S"XMIT";
                  OPCODE[I] = S"XMIT";
                  GOTO  $XMIT;
                  END 
 $DSBBPB: 
              IF  LASTUSE[IREG[I]] LS NEXTLOCK(AREG[JREG[I]] + OFFSETB) 
                  AND  NOT RPREF[IREG[I]] 
              THEN
                  BEGIN 
                  ASSIGN(REGTYPE"TYPEB",AREG[JREG[I]],IREG[I]); 
                  TEST; 
                  END 
              ELSE
                  BEGIN 
                  OPC =  S"SBBPB";
                  OPCODE[I] = S"SBBPB"; 
                  GOTO  $SBBPB; 
                  END 
 $RESTR:  
              RESTORE;
              TEST; 
 $FREEINP:  
              FREEINP(I); 
              TEST; 
 $END$: 
              ADJADDR(OPC,TRUE);
              ENDP = TRUE;
              ENDINST = TEXT[I];
              GOTO  INSTGEN2; 
 $RSAVE:  
              SAVREG(I);
              TEST; 
 INSTGEN1:  
              ADJADDR(OPC,TRUE);
 INSTGEN2:  
              IF  NOT NOCOPY[OPC] 
              THEN  INSTOUT(LOC(SEQUENCE[I]),INC);
              INCADDR(OPC); 
              END 
          IF  ATEMPCNT GR NATEMPS  THEN  NATEMPS = ATEMPCNT;
          END                                                            INSTGEN
          TERM                                                           INSTGEN
