*DECK  READSEQ                                                           READSEQ
          PROC  READSEQ;                                                 READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   READSEQ - CONTROLS ACCUMULATION OF AN EXPANDED INSTRUCTION        #
 #             SEQUENCE AND PROCESSING OF DATA AND USE BLOCKS          #
 #                                                                     #
 #   GIVEN - INSTRUCTION INPUT FILE                                    #
 #                                                                     #
 #   DOES - CALLS APPROPRIATE PROCESSING ROUTINE FOR EACH INSTRUCTION. #
 #          ADDS INSTRUCTIONS TO INSTRUCTION LIST UNTIL ENO-OF-        #
 #          SEQUENCE CONDITIONS OCCURS                                 #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #        NESTED PROC DIRECTORY                                        #
 #                                                                     #
 #        CMUPR                    PROCESS CMU INSTRUCTION             #
 #        DATAPR                   PROCESS DATA DEFINITION INSTRUCTION #
 #        INITIALT                 INITIALIZE ALTERNATE WSA            #
 #        INITRD                   INITIALIZE READSEQ                  #
 #        LOCPR                    PROCESS LOC DIRECTIVE               #
 #        LOOPR, ENDLPR            PROCESS LOOP, ENDL DIRECTIVES       #
 #        MACPR                    EXPAND MACRO DEFINITION             #
 #            SUBREG               SUBSTITUTE REGISTER PARAMETER       #
 #        NXTINST                  RETURN POINTER TO NEXT INSTRUCTION  #
 #        MOVNEXT                  MOVE INSTRUCTION TO INSTLIST        #
 #        USEPR                    PROCESS USE DIRECTIVE               #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
*CALL ASMINST                                                            READSEQ
*CALL ASMSEQ
*CALL TABLETYP                                                           READSEQ
*CALL LOCLAB
          DEF  FULLSEQ #0#; 
*CALL SEQCOM
*CALL ASMCOMM                                                            READSEQ
*CALL USETAB                                                             READSEQ
*CALL VREGCOM 
*CALL RALINE
          XREF                                                           READSEQ
              BEGIN                                                      READSEQ
              PROC ABORT; 
              PROC  ADDSUBL;
              PROC  ADJADDR;                                             READSEQ
              PROC  ASMABT;                                              READSEQ
              PROC CMM$GLV; 
              PROC CMI$GLV; 
              PROC  GETINST;                                             READSEQ
              PROC  INCADDR;                                             READSEQ
              PROC  INSTOUT;
              PROC  LABELPR;                                             READSEQ
              PROC  PRESCAN;
              PROC  SLOCKPR;
              FUNC  VIRTUAL;
              END                                                        READSEQ
                                                                         READSEQ
          XDEF  PROC  INITRD;                                            READSEQ
                                                                         READSEQ
          BASED ARRAY INST;                                              READSEQ
              ITEM                                                       READSEQ
                  BITCOUNT   DNUM,                                       READSEQ
                  BLOCKSIZ   DNUM,                                       READSEQ
                  CONS       DCONS, 
                  CONST      DCONST,                                     READSEQ
                  COUNT      DCOUNT,                                     READSEQ
                  INDEX      DINDEX,                                     READSEQ
                  INSTI  DRI,                                            READSEQ
                  INSTJ  DRJ,                                            READSEQ
                  INSTW      DTEXT,                                      READSEQ
                  OCFLAG     DOCFLAG, 
                  OPCODE     DOC, 
                  TABL       DTABLE;
          XREF  ARRAY  ALTWSA;                                           READSEQ
                  ITEM                                                   READSEQ
                      ALT,                                               READSEQ
                      CON    DCONST,                                     READSEQ
                      CNT    DCOUNT,                                     READSEQ
                      INDX   DINDEX,                                     READSEQ
                      OC     DOPC,
                      RI     DRI,                                        READSEQ
                      RJ     DRJ,                                        READSEQ
                      RK     DRK,                                        READSEQ
                      SY     DSY,                                        READSEQ
                      TABLE  DTABLE;                                     READSEQ
          XREF  ARRAY  WSA;;                                             READSEQ
          XREF  ITEM  NRESREG;
          DEF  MACOFF  #O"4000"#;                                        READSEQ
          DEF  NEXT #0#;                                                 READSEQ
          ITEM  ALTCNT;                                                  READSEQ
          ITEM  ALTRECL;                                                 READSEQ
          ITEM  BEGINSEQ  B;                                             READSEQ
          ITEM  FIRST  B;                                                READSEQ
          ITEM  II; 
          ITEM  INCR;                                                    READSEQ
          ITEM  LOOPNDX;                                                 READSEQ
          ITEM  RECL;                                                    READSEQ
          ITEM  WSCNT;                                                   READSEQ
          ITEM  OPC  S:OPNAMES;                                          READSEQ
          ITEM  OUTLEN; 
          ITEM  SAVEP;
          ITEM  SEQNO;
          ITEM  USEOCC  B;
          SWITCH READPR:     SPTYPE 
                 SPNONE:     SPNONE,
                 SPCMU:      SPCMU, 
                 SPDATA:     SPDATA,
                 SPEND:      SPEND, 
                 SPENDL:     SPENDL,
                 SPLINE:     SPLINE,
                 SPLOOP:     SPLOOP,
                 SPNOTE:     SPNOTE,
                 SPOBJ:      SPOBJ, 
                 SPSHL:      SPSHL, 
                 SPSTART:    SPSTART, 
                 SPUSE:      SPUSE ;
          CONTROL  EJECT; 
          PROC  CHECKUSE;    #ENSURE THAT SEQUENCE IS IN CODE BLOCK    #
          BEGIN 
          IF  USEOCC
          THEN
              BEGIN 
              OC[0] = S"USE$";
              TABLE[0] = S"USETAB$";
              INDX[0] = CODEBLOCK;
              INSTOUT(LOC(ALTWSA),1); 
              END 
          RETURN; 
          END 
          CONTROL  EJECT; 
          FUNC  NEXTR;
 #     ASSIGN VIRTUAL REGISTER NUMBER UNIQUE TO ASSEMBLER              #
          BEGIN 
          NEXTR = NREGS;
          VREG1[NREGS] = 0; 
          VREG2[NREGS] =0;
          NREGS = NREGS + 1;
          IF NREGS GQ VREGSIZE THEN 
              BEGIN 
              ASMABT("STATEMENT TOO LONG, PLEASE SIMPLIFY",35); 
              ABORT;
              END 
          RETURN; 
          END 
          CONTROL  EJECT;                                                READSEQ
          PROC  CMUPR;                                                   READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   CMUPR - PROCESS A CMU INSTRUCTION                                 #
 #                                                                     #
 #   GIVEN - A CMU INSTRUCTION                                         #
 #                                                                     #
 #   DOES - GENERATE RSTOR AND RFREE INSTRUCTIONS FOR A0 AND X0 AS     #
 #          NECESSARY                                                  #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          DEF  REGA  #O"40"#;                                            READSEQ
          DEF  REGX  #O"20"#;                                            READSEQ
          ITEM I;                                                        READSEQ
          ITEM  INC;                                                     READSEQ
          BEGIN                                                          READSEQ
          ALTRECL = 0;                                                   READSEQ
          IF  OPC  EQ S"CC$" OR OPC EQ S"CU$"                            READSEQ
          THEN                                                           READSEQ
              I = INSTI[NEXT];                                           READSEQ
          ELSE                                                           READSEQ
              BEGIN                                                      READSEQ
              I = NEXTR;                                                 READSEQ
              INSTI[NEXT] = I;
              END                                                        READSEQ
          SAVEP = P<INST>;
          P<INST> = LOC(ALTWSA);
          OC[ALTRECL] = S"RSTOR";                                        READSEQ
          RI[ALTRECL] = I;                                               READSEQ
          RJ[ALTRECL] = REGX + 0;                                        READSEQ
          MOVNEXT;
          P<INST> = SAVEP;
          MOVNEXT;
          P<INST>  = LOC(ALTWSA); 
          OC[ALTRECL] = S"RFREE";                                        READSEQ
          RI[ALTRECL] = I;                                               READSEQ
          MOVNEXT;
          P<INST> = SAVEP;
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          PROC  DATAPR;                                                  READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   DATAPR - PROCESS DATA DEFINITION INSTRUCTIONS                     #
 #                                                                     #
 #   GIVEN - A DATA DEFINITION INSTRUCTION                             #
 #                                                                     #
 #   DOES - ADJUSTS ASSEMBLER COUNTERS ACCORDING TO LENGTH OF          #
 #          GENERATED DATA.                                            #
 #          PROCESSES DATA$, BSS$, REPL$, VFD$                         #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          ITEM  I;                                                       READSEQ
          ITEM  J;                                                       READSEQ
          BEGIN                                                          READSEQ
          IF  OPC EQ S"BSS$"                                             READSEQ
          THEN                                                           READSEQ
              BEGIN                                                      READSEQ
              ORG = ORG + CONST[NEXT];                                   READSEQ
              RETURN; 
              END                                                        READSEQ
          IF OPC EQ S"DATA$"                                             READSEQ
          THEN                                                           READSEQ
              BEGIN                                                      READSEQ
              ORG = ORG + COUNT[NEXT];                                   READSEQ
              RETURN; 
              END                                                        READSEQ
          IF OPC EQ S"REPL"                                              READSEQ
          THEN                                                           READSEQ
              BEGIN                                                      READSEQ
              INCR = CONST[NEXT] * BLOCKSIZ[1];                          READSEQ
              ORG = ORG + INCR;                                          READSEQ
              RETURN; 
              END                                                        READSEQ
          IF  OPC EQ  S"VFD$"                                            READSEQ
          THEN                                                           READSEQ
              BEGIN                                                      READSEQ
              J=COUNT[NEXT]-1;                                           READSEQ
              FOR I = 1 STEP 2 UNTIL J DO                                READSEQ
                  BEGIN                                                  READSEQ
                  POS = POS - BITCOUNT[I];
                  IF  TABL[I] EQ S"DNAT$" 
                  THEN  ADDSUBL(INSTW[I+1],INDEX[I],TRUE);
                  IF BITCOUNT[I] GR WORDSIZE                             READSEQ
                  THEN ASMABT("ILLEGAL BITCOUNT IN VFD",23);             READSEQ
                  IF POS LS 0                                            READSEQ
                  THEN                                                   READSEQ
                      BEGIN                                              READSEQ
                      POS = WORDSIZE - BITCOUNT[I];                      READSEQ
                      ORG = ORG + 1;                                     READSEQ
                      END                                                READSEQ
                  END                                                    READSEQ
              RETURN; 
             END                                                         READSEQ
          IF  OPC EQ S"MD$" 
          THEN
              BEGIN 
              POS = 30; 
              IF  TABL[NEXT+1] EQ S"DNAT$"
              THEN  ADDSUBL(CONS[NEXT+1],INDEX[NEXT+1],TRUE); 
              POS = 0;
              IF  TABL[NEXT+2] EQ S"DNAT$"
              THEN  ADDSUBL(CONS[NEXT+2],INDEX[NEXT+2],TRUE); 
              RETURN; 
              END 
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          PROC  INITRD;                                                  READSEQ
          BEGIN                                                          READSEQ
          GETINST(RECL);
          BEGINSEQ = TRUE;                                               READSEQ
          P<INST> = LOC(WSA);                                            READSEQ
          WSCNT = 0;                                                     READSEQ
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          PROC  LOOPR(LOOPINST);                                         READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   LOOPR - PROCESS A LOOP DIRECTIVE                                  #
 #                                                                     #
 #   GIVEN - A LOOP DIRECTIVE                                          #
 #                                                                     #
 #   DOES - GENERATE A HOLDR INSTRUCTION FOR EACH PARAMETER AND ENTER  #
 #          EACH PARAMETER IN LOOP STACK                               #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          ARRAY  LOOPINST[0:0];                                          READSEQ
              ITEM                                                       READSEQ
                  P1  DREGP1, 
                  P2  DREGP2, 
                  P3  DREGP3; 
          ARRAY  [0:24];                                                 READSEQ
              ITEM  LPWORD;                                              READSEQ
          ITEM  I;                                                       READSEQ
          ITEM  J;                                                       READSEQ
          ITEM  K;
          BEGIN                                                          READSEQ
          ALTRECL = 0;                                                   READSEQ
          J = LOOPNDX;                                                   READSEQ
          K = COUNT[NEXT];
          SAVEP = P<INST>;
          P<INST> = LOC(ALTWSA);
          FOR  I  = 1 STEP 1 UNTIL K  DO
              BEGIN                                                      READSEQ
              LPWORD[LOOPNDX] = P1[I];                                   READSEQ
              LOOPNDX = LOOPNDX + 1;                                     READSEQ
              OC[ALTRECL] = S"HOLDR";                                    READSEQ
              RI[ALTRECL] = P1[I];                                       READSEQ
              MOVNEXT;
              IF  P2[I] EQ 0 THEN TEST;                                  READSEQ
              LPWORD[LOOPNDX] = P2[I];                                   READSEQ
              LOOPNDX = LOOPNDX + 1;                                     READSEQ
              OC[ALTRECL] = S"HOLDR";                                    READSEQ
              RI[ALTRECL] = P2[I];                                       READSEQ
              MOVNEXT;
              IF  P3[I] EQ 0 THEN TEST;                                  READSEQ
              LPWORD[LOOPNDX] = P3[I];                                   READSEQ
              LOOPNDX = LOOPNDX + 1;                                     READSEQ
              OC[ALTRECL] = S"HOLDR";                                    READSEQ
              RI[ALTRECL] = P3[I];                                       READSEQ
              MOVNEXT;
              END                                                        READSEQ
          LPWORD[LOOPNDX] = LOOPNDX - J;                                 READSEQ
          LOOPNDX = LOOPNDX + 1;                                         READSEQ
          P<INST> = SAVEP;
          RETURN;                                                        READSEQ
 ENTRY    PROC  ENDLPR;                                                  READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   ENDLPR - PROCESS AN ENDL DIRECTIVE                                #
 #                                                                     #
 #   GIVEN - AN ENDL DIRECTIVE AND THE LOOP STACK                      #
 #                                                                     #
 #   DOES - GENERATE AN RFREE INSTRUCTION FOR EACH PARAMETER IN THE    #
 #          TOP LOOP-STACK ENTRY                                       #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          LOOPNDX = LOOPNDX - 1;                                         READSEQ
          J = LPWORD[LOOPNDX];                                           READSEQ
          ALTRECL = 0;                                                   READSEQ
          SAVEP = P<INST>;
          P<INST> = LOC(ALTWSA);
          FOR  I = 1 STEP 1 UNTIL J DO                                   READSEQ
              BEGIN                                                      READSEQ
              LOOPNDX = LOOPNDX - 1;                                     READSEQ
              OC[ALTRECL] = S"RFREE";                                    READSEQ
              RI[ALTRECL] = LPWORD[LOOPNDX];                             READSEQ
              MOVNEXT;
              END                                                        READSEQ
          P<INST> = SAVEP;
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL  EJECT;                                                READSEQ
          PROC  MACPR (MACREF);                                          READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   MACPR - EXPAND MACRO REFERENCE                                    #
 #                                                                     #
 #   GIVEN - POINTER TO MACRO REFERENCE                                #
 #                                                                     #
 #   DOES - EXPANDS REFERENCE, SUBSTITUTING ACTUAL PARAMETERS          #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          XREF ARRAY MACDESC [1:1];                                      READSEQ
              ITEM                                                       READSEQ
                    FM   U(0,42,18),   #START OF MACRO TEXT            # READSEQ
                    IMAX U(0,18, 6),   #NUMBER INTERMEDIATE REGISTERS  # READSEQ
                    LM   U(0,24,18),   #LENGTH OF MACRO TEXT           # READSEQ
                    NC   U(0, 0, 6),   #NUMBER OF CONSTANT PARAMETERS  # READSEQ
                    NR   U(0, 6, 6),   #NUMBER OF REGISTER PARAMETERS  # READSEQ
                    NSY  U(0,12, 6);   #NUMBER OF TABLE REF PARAMETERS # READSEQ
          XREF  ARRAY  MACTEXT;                                          READSEQ
              ITEM                                                       READSEQ
                    TEXT    DTEXT;                                       READSEQ
          ARRAY MACREF;                                                  READSEQ
              ITEM                                                       READSEQ
                    MACOP  DOC,                                          READSEQ
                    P1     DREGP1,
                    P2     DREGP2,
                    P3     DREGP3,
                    PARAM;                                               READSEQ
          XREF                                                           READSEQ
          BEGIN                                                          READSEQ
          ARRAY  CBUF[1:1];  ITEM  CPARAM;                               READSEQ
          ARRAY  IBUF[1:1];  ITEM  IPARAM;                               READSEQ
          ARRAY  RBUF[1:1];  ITEM  RPARAM;                               READSEQ
          ARRAY  SBUF[1:1];  ITEM  SPARAM;                               READSEQ
          END                                                            READSEQ
                                                                         READSEQ
          DEF  REGOFF  #O"100000"#;                                      READSEQ
                                                                         READSEQ
          ITEM  I;                                                       READSEQ
          ITEM  INC;                                                     READSEQ
          ITEM  J;                                                       READSEQ
          ITEM  K;                                                       READSEQ
          ITEM  MACNUM;                                                  READSEQ
          ITEM  NCON;                                                    READSEQ
          ITEM  NI;                                                      READSEQ
          ITEM  NREG;                                                    READSEQ
          ITEM  NSYM;                                                    READSEQ
          ITEM  PCOUNT;                                                  READSEQ
          XREF  ITEM  NOMACS; 
          XREF  ITEM  NRESREG;                                           READSEQ
                                                                         READSEQ
          SWITCH  SWCLASS:  CLSTAT                                       READSEQ
                  MACPR1:   CLASS1,                                      READSEQ
                  MACPR2:   CLASS2,                                      READSEQ
                  MACPR3:   CLASS3,                                      READSEQ
                  MACPR4:   CLASS4;                                      READSEQ
          CONTROL EJECT;                                                 READSEQ
          FUNC  SUBREG((REGISTER)); 
          ITEM  REGISTER;                                                READSEQ
          BEGIN                                                          READSEQ
          IF  REGISTER GR REGOFF                                         READSEQ
          THEN  SUBREG = IPARAM[REGISTER - REGOFF];                      READSEQ
          ELSE                                                           READSEQ
              IF  REGISTER LS NRESREG                                    READSEQ
              THEN                                                       READSEQ
                  SUBREG = REGISTER;                                     READSEQ
              ELSE                                                       READSEQ
                  SUBREG = RPARAM[REGISTER - NRESREG];                   READSEQ
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          BEGIN                                                          READSEQ
 #   MOVE PARAMETERS TO SEPARATE BUFFERS                               # READSEQ
          MACNUM = MACOP[0];
          IF  MACNUM GQ NOMACS OR MACNUM EQ 0 
          THEN  ASMABT("REFERENCE TO UNDEFINED MACRO",28);
          NCON = NC[MACNUM];                                             READSEQ
          NI = IMAX[MACNUM];                                             READSEQ
          NREG = NR[MACNUM];                                             READSEQ
          NSYM = NSY[MACNUM];                                            READSEQ
          PCOUNT = 0;                                                    READSEQ
          FOR I = 1 STEP 1 UNTIL NSYM DO
              SPARAM[I] = PARAM[PCOUNT + I];
          PCOUNT = PCOUNT + NSYM; 
          IF  NREG EQ 0 THEN J = 0; ELSE J = (NREG - 1)/3 + 1;           READSEQ
          FOR I = 1 STEP 1 UNTIL J DO                                    READSEQ
              BEGIN                                                      READSEQ
              K = 3 * (I-1) + 1;                                         READSEQ
              RPARAM[K] = P1[I + PCOUNT];                                READSEQ
              RPARAM[K+1] = P2[I + PCOUNT];                              READSEQ
              RPARAM[K+2] = P3[I + PCOUNT];                              READSEQ
              END                                                        READSEQ
          PCOUNT = PCOUNT + J;                                           READSEQ
          IF NCON EQ 0 THEN J = 0; ELSE J = (NCON - 1)/3 + 1;            READSEQ
          FOR I = 1 STEP 1 UNTIL J DO                                    READSEQ
              BEGIN                                                      READSEQ
              K = 3 * (I-1) + 1;                                         READSEQ
              CPARAM[K] = P1[I + PCOUNT];                                READSEQ
              CPARAM[K+1] = P2[I + PCOUNT];                              READSEQ
              CPARAM[K+2] = P3[I + PCOUNT];                              READSEQ
              END                                                        READSEQ
          FOR I = 1 STEP 1 UNTIL NI DO IPARAM[I] = NEXTR;                READSEQ
 #   MOVE MACRO TEXT TO INSTRUCTION BUFFER AND SUBSTITUTE PARAMETERS   # READSEQ
          I = 0;                                                         READSEQ
          J = 0;
          INC = 0;                                                       READSEQ
          SAVEP = P<INST>;
          P<INST> = LOC(ALTWSA);
          DOWHILE J + INC LS LM[MACNUM] DO
              BEGIN                                                      READSEQ
              J = J + INC;
              ALT[I] = TEXT[J+FM[MACNUM]];
              INC = CLSIZE[CLASS[OC[I]]];                                READSEQ
              GOTO SWCLASS[CLASS[OC[I]]];                                READSEQ
 MACPR1:                                                                 READSEQ
              RI[I] =  SUBREG(RI[I]);                                    READSEQ
              IF  OC[I] NQ S"RDEF" AND OC[I] NQ S"RSTOR"                 READSEQ
              THEN       RJ[I] = SUBREG(RJ[I]);                          READSEQ
              RK[I]  = SUBREG(RK[I]);                                    READSEQ
              MOVNEXT;
              TEST;                                                      READSEQ
 MACPR2:                                                                 READSEQ
              IF  CNT[I] NQ 0                                            READSEQ
              THEN                                                       READSEQ
                  BEGIN                                                  READSEQ
                  CNT[I] = 0;                                            READSEQ
                  CON[I] = CPARAM[CON[I]];                               READSEQ
                  END                                                    READSEQ
              RI[I]  = SUBREG(RI[I]);                                    READSEQ
              MOVNEXT;
              TEST;                                                      READSEQ
 MACPR3:                                                                 READSEQ
              RI[I] = SUBREG(RI[I]);                                     READSEQ
              RJ[I] = SUBREG(RJ[I]);                                     READSEQ
              ALT[I+1] = TEXT[J+FM[MACNUM] + 1];
              IF  TABLE[I+1] NQ 0  THEN  SY[I+1] = SPARAM[INDX[I+1]];    READSEQ
              MOVNEXT;
              TEST;                                                      READSEQ
 MACPR4:                                                                 READSEQ
              IF  TABLE[I] NQ 0  THEN  SY[I] = SPARAM[INDX[I]];          READSEQ
              MOVNEXT;
              TEST;                                                      READSEQ
              END                                                        READSEQ
          P<INST> = SAVEP;
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          PROC  NXTINST;                                                 READSEQ
          ITEM  INC;                                                     READSEQ
          ITEM  TCLASS  S:CLSTAT;                                        READSEQ
          BEGIN                                                          READSEQ
          IF  OCFLAG[NEXT]
              THEN  TCLASS = S"CLASS2"; 
              ELSE  TCLASS = CLASS[OPCODE[NEXT]]; 
          IF  TCLASS EQ S"CLASS2" 
          THEN  INC = CLSIZE[CLSTAT"CLASS2"] + COUNT[NEXT]; 
          ELSE  INC = CLSIZE[TCLASS]; 
          WSCNT = WSCNT + INC;
          IF  WSCNT EQ RECL 
          THEN
              BEGIN 
              WSCNT = 0;
              GETINST(RECL);
              END 
          P<INST> = LOC(WSA) + WSCNT; 
          IF  OCFLAG[NEXT]
          THEN
              BEGIN 
              MACPR(INST);
              OPC = S"NULL";
              RETURN; 
              END 
          OPC = OPCODE[NEXT]; 
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL  EJECT;                                                READSEQ
          PROC  MOVNEXT;                                                 READSEQ
#    MOVE INSTRUCTION FROM WORKING STORAGE TO INSTRUCTION LIST         # READSEQ
#       AND REPLACE VIRTUAL REGISTER NUMBERS BY TABLE INDICES          #
          ITEM  INC;                                                     READSEQ
          ITEM  J;                                                       READSEQ
                                                                         READSEQ
          BEGIN                                                          READSEQ
          OPC = OPCODE[NEXT]; 
          INC = CLSIZE[CLASS[OPC]]; 
          IF  CLASS[OPC] EQ S"CLASS2" 
          THEN  INC = INC + COUNT[NEXT];
          IF  OPC EQ S"RSTOR" 
          THEN
              BEGIN 
              J = INSTI[NEXT];
              LOCKREG[J] = INSTJ[NEXT]; 
              RHOLD[J] = TRUE;
              IF  LOCKB[J]  THEN  SLOCKPR(J,REGTYPE"TYPEB");
              ELSE  IF LOCKX[J] OR (LOCKA[J] AND AREG[J] NQ 0)
                    THEN  SLOCKPR(J,REGTYPE"TYPEX");
              RETURN; 
              END 
          IF  OPC EQ S"HOLDR" 
              THEN
              BEGIN 
              RHOLD[INSTI[NEXT]] = TRUE;
              RETURN; 
              END 
          IF  ENDSEQ + INC GQ SEQSIZE 
          THEN
              BEGIN 
              CMM$GLV(SEQUENCE,50);   #GROW TABLE#
              SEQSIZE = SEQSIZE + 50; 
              END 
          FOR J = 1 STEP 1 UNTIL INC DO                                  READSEQ
              SEQ[ENDSEQ+J-1] = INSTW[J-1]; 
          PRESCAN;
          ENDSEQ = ENDSEQ + INC;                                         READSEQ
          END                                                            READSEQ
          CONTROL  EJECT;                                                READSEQ
          PROC  OBJPR(OBJREF);                                           READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   OBJPR - PROCESS AN OBJ INSTRUCTION                                #
 #                                                                     #
 #   GIVEN - AN OBJ INSTRUCTION AND THE OBJECT ROUTINE DESCRIPTION     #
 #           TABLE                                                     #
 #                                                                     #
 #   DOES - GENERATES AN RSTOR INSTRUCTION FOR EACH INPUT PARAMETER,   #
 #          AN RSAVE INSTRUCTION, ENTRY POINT LINKAGE INSTRUCTIONS,    #
 #          AN RFREE INSTRUCTION FOR EACH INPUT PARAMETER, AN STERM    #
 #          INSTRUCTION IF THE OBJECT ROUTINE BREAKS A SEQUENCE, AN    #
 #          RDEF FOR EACH OUTPUT PARAMETER, AND A RESTR INSTRUCTION    #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
*CALL OBJCOMM                                                            READSEQ
          ARRAY  OBJREF;                                                 READSEQ
              ITEM                                                       READSEQ
                  DESC     DREGP1,
                  OLABL    DREGP3,
                  OLINE    DREGP2,
                  P1       DREGP1,
                  P2       DREGP2,
                  P3       DREGP3;
                                                                         READSEQ
          DEF  REGB  #O"10"#;                                            READSEQ
          ITEM  I;                                                       READSEQ
          ITEM  INP;
          ITEM  LNKREG;                                                  READSEQ
          ITEM  NIN;                                                     READSEQ
          ITEM  NOUT;                                                    READSEQ
          ITEM  PBASE;                                                   READSEQ
          ITEM  PTR;                                                     READSEQ
          ITEM  PWORD;                                                   READSEQ
          ITEM  RBASE;                                                   READSEQ
          ITEM  REG;
          ITEM  REGNO;
          ITEM  RETURNL;
          ITEM  RWORD;                                                   READSEQ
          SWITCH  PNUM  FP1, FP2, FP3;                                   READSEQ
          SWITCH  PNUM1  DP1, DP2, DP3;                                  READSEQ
          XREF  FUNC  MOD;                                               READSEQ
          CONTROL  EJECT;                                                READSEQ
          BEGIN                                                          READSEQ
          PTR = OBJPTR[DESC[1]];                                         READSEQ
          NIN = IN[PTR];                                                 READSEQ
          NOUT = OUT[PTR];                                               READSEQ
          ALTRECL = 0;                                                   READSEQ
          SAVEP = P<INST>;
          P<INST> = LOC(ALTWSA);
                                                                         READSEQ
          FOR  I = 1 STEP 1 UNTIL NIN  DO                                READSEQ
              BEGIN          #GENERATE RSTOR FOR EACH INPUT PARAMETER  # READSEQ
              RWORD = (I-1)/10 +1 + PTR;
              REGNO = B<RSIZE*MOD(I-1,RCNT),RSIZE>PARAMS[RWORD];
              PWORD = (I-1)/3 + 2;
              GOTO  PNUM[MOD(I-1,3)]; 
 FP1: 
              INP = P1[PWORD];
              GOTO  FR; 
 FP2: 
              INP = P2[PWORD];
              GOTO  FR; 
 FP3: 
              INP = P3[PWORD];
 FR:  
              $BEGIN
              IF  INP EQ 0
              THEN ASMABT("ZERO VIRTUAL REGISTER NUMBER IN GENOBJ",38); 
              $END
                  OC[ALTRECL] = S"RSTOR"; 
              REG = NEXTR;
              RI[ALTRECL] = REG;
                  RJ[ALTRECL] = REGNO;
              MOVNEXT;
                  IF  B<54,3>REGNO EQ REGTYPE "TYPEX" 
                  THEN  OC[ALTRECL] = S"CXMIT"; 
                  ELSE  OC[ALTRECL] = S"CSBBPB";
              RI[ALTRECL] = REG;
                  RJ[ALTRECL] = INP;
                  RK[ALTRECL] = 0;
                  MOVNEXT;
                  AREG[INP] = REGNO;
                  RPREF[INP] = TRUE;
              END                                                        READSEQ
                                                                         READSEQ
 #        GENERATE RSAVE                                               # READSEQ
          OC[ALTRECL] = S"RSAVE"; 
          INDX[ALTRECL] = DESC[1];
          MOVNEXT;
                                                                         READSEQ
 #        GENERATE  ENTRY POINT LINKAGE                                # READSEQ
                                                                         READSEQ
          IF  BCALL[PTR] EQ 0                                            READSEQ
          THEN                                                           READSEQ
                                                                         READSEQ
 #        GENERATE                                                     # READSEQ
 #            PLUS                                                     # READSEQ
 #            RJ$    ENTRY POINT                                       # READSEQ
 #            MINUS                                                    # READSEQ
 #            PS$    LINE                                              # READSEQ
                                                                         READSEQ
              BEGIN                                                      READSEQ
              OC[ALTRECL] = S"PLUS";                                     READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              MOVNEXT;
              OC[ALTRECL] = S"RJ$";                                      READSEQ
              SY[ALTRECL] = 0;
              TABLE[ALTRECL] = S"OBJ$"; 
              INDX[ALTRECL] = DESC[1];                                   READSEQ
              MOVNEXT;
              OC[ALTRECL] = S"MINUS";                                    READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              MOVNEXT;
              OC[ALTRECL] = S"PS$";                                      READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              CON[ALTRECL] = OLINE[1];
              MOVNEXT;
              END                                                        READSEQ
          ELSE                                                           READSEQ
                                                                         READSEQ
 #        GENERATE                                                     # READSEQ
 #            SBI    GENLAB                                            # READSEQ
 #            RSTOR  BI,BCALL                                          # READSEQ
 #            PLUS                                                     # READSEQ
 #            EQ$    ENTRY POINT                                       # READSEQ
 #            MINUS                                                    # READSEQ
 #            PS$    LINE                                              # READSEQ
 #            LABEL$ GENLAB                                            # READSEQ
 #            RFREE  RI                                                # READSEQ
                                                                         READSEQ
              BEGIN                                                      READSEQ
              RETURNL = OLABL[1]; 
              LNKREG = NEXTR; 
              OC[ALTRECL] = S"RSTOR"; 
              RI[ALTRECL] = LNKREG; 
              RJ[ALTRECL] = BCALL[PTR] + REGB;
              MOVNEXT;
              OC[ALTRECL] = S"SBBPK";                                    READSEQ
              RI[ALTRECL] = LNKREG;                                      READSEQ
              RJ[ALTRECL] = 0;                                           READSEQ
              ALT[ALTRECL + 1] = 0; 
              TABLE[ALTRECL + 1] = S"LOCAL$"; 
              INDX[ALTRECL + 1] = RETURNL;
              MOVNEXT;
              OC[ALTRECL] = S"PLUS";                                     READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              MOVNEXT;
              OC[ALTRECL] = S"EQ$";                                      READSEQ
              RI[ALTRECL] = 0;                                           READSEQ
              RJ[ALTRECL] = 0;                                           READSEQ
              ALT[ALTRECL + 1] = 0; 
              INDX[ALTRECL + 1] = DESC[1];
              TABLE[ALTRECL + 1] = S"OBJ$"; 
              MOVNEXT;
              OC[ALTRECL] = S"MINUS";                                    READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              MOVNEXT;
              OC[ALTRECL] = S"PS$";                                      READSEQ
              CNT[ALTRECL] = 0;                                          READSEQ
              CON[ALTRECL] = OLINE[1];
              MOVNEXT;
              ALT[ALTRECL] = 0; 
              OC[ALTRECL] = S"LABEL$";                                   READSEQ
              TABLE[ALTRECL] = S"LOCAL$"; 
              INDX [ALTRECL] = RETURNL; 
              MOVNEXT;
              OC[ALTRECL] = S"RFREE";                                    READSEQ
              RI[ALTRECL] = LNKREG;                                      READSEQ
              MOVNEXT;
              END                                                        READSEQ
                                                                         READSEQ
#      FREE INPUT REIGSTERS                                            #
          OC[ALTRECL] = S"FREEINP"; 
          INDX[ALTRECL] = DESC[1];
          MOVNEXT;
                                                                         READSEQ
          PBASE = (NIN+2)/3 + 2;                                         READSEQ
          RBASE = (NIN+9)/10 + 1 + PTR;                                  READSEQ
          FOR  I = 1 STEP 1 UNTIL NOUT DO                                READSEQ
              BEGIN          #GENERATE RDEF FOR EACH OUTPUT PARAMETER  # READSEQ
              PWORD = (I-1)/3 + PBASE;                                   READSEQ
              OC[ALTRECL] = S"RDEF";                                     READSEQ
              REG = NEXTR;
              RI[ALTRECL] = REG;
              RWORD = (I-1)/10 + RBASE; 
              REGNO = B<RSIZE*MOD(I-1,RCNT),RSIZE>PARAMS[RWORD];
              RJ[ALTRECL] = REGNO;
              MOVNEXT;
              IF  B<54,3>REGNO EQ REGTYPE"TYPEX"
              THEN  OC[ALTRECL] = S"DXMIT"; 
              IF  B<54,3>REGNO EQ REGTYPE"TYPEB"
              THEN  OC[ALTRECL] = S"DSBBPB";
              RJ[ALTRECL] = REG;
              RK[ALTRECL] = 0;
              GOTO  PNUM1[MOD(I-1,3)];                                   READSEQ
 DP1:                                                                    READSEQ
              RI[ALTRECL] = P1[PWORD];                                   READSEQ
              GOTO  OBJ3;                                                READSEQ
 DP2:                                                                    READSEQ
              RI[ALTRECL] = P2[PWORD];                                   READSEQ
              GOTO  OBJ3;                                                READSEQ
 DP3:                                                                    READSEQ
              RI[ALTRECL] = P3[PWORD];                                   READSEQ
 OBJ3:                                                                   READSEQ
              MOVNEXT;
              END                                                        READSEQ
                                                                         READSEQ
#      GENERATE REGISTER RESTORE                                       #
          OC[ALTRECL] = S"RESTR"; 
          CNT[ALTRECL] = 0; 
          MOVNEXT;
          P<INST> = SAVEP;
          RETURN;                                                        READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          PROC USEPR;                                                    READSEQ
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   USEPR - PROCESSES CODE IN BLOCK OTHER THAN CODE BLOCK             #
 #                                                                     #
 #   GIVEN - POINTER TO USE DIRECTIVE IN INPUT WSA                     #
 #                                                                     #
 #   DOES - COPIES INSTRUCTIONS FOLLOWING USE TO OUTPUT WSA UNTIL      #
 #          ANOTHER USE IS ENCOUNTERED                                 #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          BASED ARRAY  TARRAY[0:0]; 
              ITEM
                  CNT     DCOUNT, 
                  OPN     DOC,
                  IND     DINDEX, 
                  TPOOL;
          ITEM  POOLED  B;
          CONTROL  EJECT; 
          PROC  CHECKMATCH; 
          ITEM  BLOCKSIZE;
          ITEM  I;
          ITEM  IINC; 
          ITEM  INC;
          ITEM  J;
          ITEM  JINC; 
          ITEM  K;
          ITEM  L;
          ITEM  SAVINST;
          BEGIN 
          P<TARRAY> = USEPOOLADR[BLOCK];
          BLOCKSIZE = USEPOOLPTR[BLOCK] - USEPOOLSIZ[BLOCK];
          FOR I = 0 STEP IINC WHILE I+BLOCKSIZE LQ USEPOOLSIZ[BLOCK] DO 
              BEGIN 
              IINC = CLSIZE[CLASS[OPN[I]]]; 
              IF  CLASS[OPN[I]] EQ S"CLASS2"
              THEN  IINC = IINC + CNT[I]; 
              FOR  J = 0 STEP JINC WHILE J LS BLOCKSIZE DO
                  BEGIN 
                  L = J + USEPOOLSIZ[BLOCK];
                  JINC = CLSIZE[CLASS[OPN[L]]]; 
                  IF  CLASS[OPN[L]] EQ S"CLASS2"
                  THEN  JINC = JINC + CNT[L]; 
                  IF  OPN[I+J] NQ OPN[L]  THEN  TEST I; 
                  IF  OPN[L] EQ S"LABEL$" 
                  THEN
                      BEGIN 
                      K = IND[I+J]; 
                      LABEQU[VIRTUAL(TABLETYPE"WORK4$",IND[L])] = K;
                      P<TARRAY> = USEPOOLADR[BLOCK];
                      TEST J; 
                      END 
                  FOR  K = 0 STEP 1 UNTIL JINC - 1 DO 
                      IF  TPOOL[I+J+K]  NQ TPOOL[L+K] THEN  TEST I; 
                  END 
 #     MATCH  FOUND                                                    #
              USEPOOLPTR[BLOCK] = USEPOOLSIZ[BLOCK];
              RETURN; 
              END 
 #     NO  MATCH FOUND, ASSEMBLE INSTRUCTIONS                          #
          SAVINST = P<INST>;
          FOR  I = USEPOOLSIZ[BLOCK] STEP INC 
                          WHILE I LS USEPOOLPTR[BLOCK] DO 
              BEGIN 
              P<TARRAY> = USEPOOLADR[BLOCK];
              P<INST> = LOC(TPOOL[I]);
              OPC = OPCODE[NEXT]; 
              INC = CLSIZE[CLASS[OPC]]; 
              IF  CLASS[OPC] EQ S"CLASS2" 
              THEN  INC = INC + COUNT[NEXT];
              PUTINST;
              END 
          P<INST> = SAVINST;
          USEPOOLSIZ[BLOCK] = USEPOOLPTR[BLOCK];
          RETURN; 
          END 
          CONTROL  EJECT; 
          PROC  COPYTOPOOL; 
          ITEM  I;
          ITEM  INC;
          BEGIN 
 #     MOVE INSTRUCTION TO POOL                                        #
          INC  = CLSIZE[CLASS[OPCODE[NEXT]]]; 
          IF  CLASS[OPCODE[NEXT]] EQ S"CLASS2"
          THEN  INC = INC + COUNT[NEXT];
          IF  USEPOOLPTR[BLOCK] + INC GR USEPOOLLIM[BLOCK]
          THEN
              BEGIN 
              I = USEPOOLPTR[BLOCK] + INC - USEPOOLLIM[BLOCK] + 25; 
              CMI$GLV (LOC(USEPOOLADR[BLOCK]), I);
              USEPOOLLIM[BLOCK] = USEPOOLLIM[BLOCK] + I;
              END 
          P<TARRAY> = USEPOOLADR[BLOCK] + USEPOOLPTR[BLOCK];
          FOR  I = 0 STEP 1 UNTIL INC-1 DO
              TPOOL[I] = INSTW[I];
          USEPOOLPTR[BLOCK] = USEPOOLPTR[BLOCK] + INC;
          RETURN; 
          END 
          CONTROL EJECT;
          PROC  PUTINST;
          BEGIN 
          IF  NOT (USEOK[OPC] OR DATAINST[OPC]) 
          THEN  ASMABT("INSTRUCTION ILLEGAL OUTSIDE CODEBLOCK",38); 
          ADJADDR(OPC,FALSE); 
          IF  DATAINST[OPC]  THEN  DATAPR;
          OUTLEN = CLSIZE[CLASS[OPC]];
          IF  CLASS[OPC] EQ S"CLASS2" 
          THEN  OUTLEN = COUNT[NEXT] + OUTLEN;
          INSTOUT(P<INST>,OUTLEN);
          IF  OPC EQ S"LABEL$"  THEN  LABELPR(TABL[NEXT],INDEX[NEXT]);
          INCADDR(OPC); 
          RETURN; 
          END 
          CONTROL  EJECT; 
          BEGIN                                                          READSEQ
          USEOCC = TRUE;
          POOLED = FALSE; 
 USEPR1:                                                                 READSEQ
          IF  OPC EQ S"USE$" OR OPC EQ S"END$"
          THEN                                                           READSEQ
              BEGIN                                                      READSEQ
              USEORG[BLOCK] = ORG;                                       READSEQ
              USEPOS[BLOCK] = POS;                                       READSEQ
              UPPER[BLOCK] = NEXTUP;                                     READSEQ
              IF  OPC EQ S"USE$"
              THEN  BLOCK = INDEX[NEXT];
              ELSE  BLOCK = CODEBLOCK;
              ORG = USEORG[BLOCK];                                       READSEQ
              POS = USEPOS[BLOCK];                                       READSEQ
              POOLED = USEPOOL[BLOCK];
              NEXTUP = UPPER[BLOCK];                                     READSEQ
              IF  BLOCK EQ CODEBLOCK  THEN  RETURN; 
              OUTLEN = CLSIZE[CLASS[OPC]];
              IF  CLASS[OPC] EQ S"CLASS2" 
              THEN  OUTLEN = COUNT[NEXT] + OUTLEN;
              INSTOUT(P<INST>,OUTLEN);
              INCADDR(OPC); 
              END                                                        READSEQ
          ELSE                                                           READSEQ
              IF  NOT  POOLED 
              THEN  PUTINST;
              ELSE
                  BEGIN 
                  IF  OPC EQ S"ENDPL"  THEN  CHECKMATCH;
                  ELSE  IF  OPC NQ S"PLIST"  THEN COPYTOPOOL; 
                  END 
          NXTINST;                                                       READSEQ
          GOTO USEPR1;                                                   READSEQ
          END                                                            READSEQ
          CONTROL EJECT;                                                 READSEQ
          BEGIN                                                          READSEQ
          FIRST = TRUE;                                                  READSEQ
          ENDSEQ = 1;                                                    READSEQ
          LOOPNDX = 1;                                                   READSEQ
          NOTE = "NOT AVAIL ";
          USEOCC = FALSE; 
          LINE = FIRSTLINE; 
          IF  BEGINSEQ
          THEN
              BEGIN 
              BEGINSEQ = FALSE; 
              OPC = OPCODE[NEXT]; 
              NREGS = NRESREG;
              END 
          ELSE
              BEGIN 
              NREGS = REGCNT[VIRTUAL(TABLETYPE"ASMSEQ$",SEQNO)];
              IF NREGS GQ VREGSIZE THEN 
                  BEGIN 
                  ASMABT("STATEMENT TOO LONG, PLEASE SIMPLIFY", 35);
                  ABORT;
                  END 
              FOR II = NRESREG STEP 1 UNTIL NREGS-1 DO
                  BEGIN 
                  VREG1[II] = 0;
                  VREG2[II] =0; 
                  END 
              NXTINST;
              END 
          IF  NOT OCFLAG[NEXT]  THEN DOWHILE DATAINST[OPC]  DO
              BEGIN                                                      READSEQ
              ADJADDR(OPC,FALSE); 
              DATAPR;                                                    READSEQ
              OUTLEN = CLSIZE[CLASS[OPC]];
              IF  CLASS[OPC] EQ S"CLASS2" 
              THEN  OUTLEN = OUTLEN + COUNT[NEXT];
              INSTOUT(P<INST>,OUTLEN);
              INCADDR(OPC,TRUE);
              NXTINST;                                                   READSEQ
              END                                                        READSEQ
  
          FOR  Q = Q  DO
          BEGIN 
          IF  OCFLAG[NEXT]   #MACRO CALL                               #
          THEN
              BEGIN 
              NXTINST;
              TEST; 
              END 
          GOTO  READPR[SPPROC[OPC]];
 SPOBJ: 
              OBJPR(INST);
              NXTINST;
              TEST; 
 SPLOOP:  
              LOOPR(INST);
              NXTINST;
              TEST; 
 SPENDL:  
              ENDLPR; 
              NXTINST;
              TEST; 
 SPCMU: 
              CMUPR;
              NXTINST;
              FIRST = FALSE;
              TEST; 
 SPUSE: 
              USEPR;
              GOTO  SPNONE; 
 SPNOTE:  
              NOTE = C<1,9>INSTW[NEXT+1]; 
              GOTO SPNONE;
 SPLINE:  
              LINE = CONST[NEXT]; 
              RA$LINE[0] = LINE;
              GOTO  SPNONE; 
 SPSHL:            #OMIT LEFT  SHIFTS OF 0 OR 60 BITS                  #
              IF  CONST[NEXT] EQ 0 OR CONST[NEXT] EQ 60 
              THEN  GOTO SKIPMOVE;
              GOTO SPNONE;
 SPSTART: 
              SEQNO = CONST[NEXT];
              CHECKUSE; 
              RETURN; 
 SPEND: 
              MOVNEXT;
              CHECKUSE; 
              RETURN; 
 SPDATA:  
              ASMABT("STARTSEQ MUST PRECEED DATA DEF INSTRUCTION",43);
              GOTO SPNONE;
 SPNONE:  
          MOVNEXT;                                                       READSEQ
          FIRST = FALSE;                                                 READSEQ
 SKIPMOVE:  
          NXTINST;
          END 
          END                                                            READSEQ
          TERM                                                           READSEQ
