*DECK             REPRC 
USETEXT   TSOURCE 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TCEXEC
USETEXT   TCOM37Q 
USETEXT   TCOM78Q 
USETEXT   TC7DECS 
PROC REPRC ;                                    #      PROCESSES REPLS # JANDRE 
                                                #OOIX=REPL TRIAD INDEX # JANDRE 
BEGIN 
  
  
  
  
*CALL COMEX 
  
  
  
  
    ITEM OBJL,WINL,FBDL,NBDL,  # PROTECT OBJX,WINX,FBDX,NBDX#            JANDRE 
         STRUCL S:QCLSS;       # AND STRUC#                              JANDRE 
    ITEM I,J,K,L,M,N,P,Q,R; 
          ITEM UNNORM B; # TRUE IF RIGHT IS NOT JUSTIFIED #              JANDRE 
   XREF FUNC STRADR;                                                     JANDRE 
    XREF PROC ADCON;
    XREF PROC CDPOSIT;                                                   JANDRE 
    XREF PROC CLSS; 
    XREF PROC CLSSAV; 
    XREF PROC CLSSRE; 
    XREF PROC DPOSIT; 
     XREF PROC EXPGEN;                                                   JANDRE 
    XREF FUNC FADCON; 
    XREF FUNC GETRD;
    XREF FUNC GTFW; 
    XREF PROC ICFGEN; 
    XREF PROC ICFGNR; 
    XREF FUNC INCRMT;   # FROM KKCW # 
    XREF FUNC KFIND;
    XREF PROC KRP00;
    XREF PROC MOVET;
    XREF FUNC MSKGEN; 
    XREF PROC MULV6;
    XREF FUNC PSCPRC; 
    XREF FUNC PSICON; 
    XREF PROC SADCON; 
    XREF PROC SAVESV; 
    XREF PROC SLOD; 
    XREF PROC SLODL;
    XREF PROC SYMABTL;                                                   REPRC
    XREF FUNC TMPGEN; 
    XREF PROC TMPRLS; 
    DEF J839 #839#;                                                      REPRC
    SWITCH REPSW:QCLSS
              REPA:A, 
              REPB:B, 
              REPC:C, 
              REPD:D, 
              PFUN:F,                                                    JANDRE 
              GENI:I;                                                    JANDRE 
    SWITCH GENSW:QCLSS     # STRUCTURES    #                             JANDRE 
              GENR:A,      #  I OR A[CONS] #                             JANDRE 
              GENB:B,      #  A[I]         #                             JANDRE 
              GENC:C,      #  B<I,J>K      #                             JANDRE 
              GEND:D,      #  B<I,J>A[K]   #                             JANDRE 
              GENR:F,      #  P<A>         #                             JANDRE 
              GENI:I;      #  OTHER        #                             JANDRE 
##       CONTROL EJECT; 
PROC CALLLEFT;                                                           JANDRE 
    BEGIN                                                                JANDRE 
         K=GETRD;                                                        JANDRE 
         MOVET(OBJX,K);                                                  JANDRE 
         MEMR[K]=GTFW(OBJX);                                             JANDRE 
         SLODL(K);                                                       JANDRE 
         XX=ICFPTR;                                                      JANDRE 
         EBT=EFBT[OBJX];                                                 JANDRE 
         MBT=ENBT[OBJX];                                                 JANDRE 
    END # CALLLEFT #                                                     JANDRE 
##       CONTROL EJECT; 
    CLSS(LOPD[OOIX]);  # CLASSIFY LEFT SIDE#                             JANDRE 
    STRUCL=STRUC; OBJL=OBJX;                                             JANDRE 
    GOTO GENSW[STRUC];                                                   JANDRE 
                                                                         JANDRE 
                                                                         JANDRE 
GENI: #ILLEGAL LEFTSIDE#                                                 JANDRE 
    SYMABTL(J839,"ILLEGAL LEFT SIDE(REPRC) LINE XXXXX",35,LINUM);        REPRC
                                                                         JANDRE 
GEND: # 3 INDEXES #                                                      JANDRE 
    WINL=WINX; NBDL=NBDX; FBDL=FBDX;                                     JANDRE 
    EXPGEN(FBDX);                                                        JANDRE 
    EXPGEN(NBDX);                                                        JANDRE 
    EXPGEN(WINX);                                                        JANDRE 
    WINX=WINL; NBDX=NBDL; FBDX=FBDL;                                     JANDRE 
    GOTO GENR;                                                           JANDRE 
                                                                         JANDRE 
GENC: # 2 INDEXES #                                                      JANDRE 
    NBDL=NBDX; FBDL=FBDX;                                                JANDRE 
    EXPGEN(FBDX);                                                        JANDRE 
    EXPGEN(NBDX);                                                        JANDRE 
    NBDX=NBDL; FBDX=FBDL;                                                JANDRE 
    GOTO GENR;                                                           JANDRE 
                                                                         JANDRE 
GENB: # 1 INDEX #                                                        JANDRE 
    WINL=WINX;                                                           JANDRE 
    EXPGEN(WINX);                                                        JANDRE 
    WINX=WINL;                                                           JANDRE 
     # GOTO GENR #                                                       JANDRE 
                                                                         JANDRE 
                                                                         JANDRE 
GENR: # 0 INDEXE, AND RENDEZ-VOUS POINT            #                     JANDRE 
      # GENERATE RIGHT HAND SIDE, AND PROCESS =    #                     JANDRE 
    RR=ROPD[OOIX];                                                       JANDRE 
    QREP[OOIX]=QREP[OOIX] AND AC$S[OBJL] NQ S"EQ";                       JANDRE 
    UNNORM=QREP[OOIX];                                                   JANDRE 
    EXPGEN(RR);                                                          JANDRE 
         OBJX=OBJL; 
         $BEGIN                                                          JANDRE 
            XREF PROC DMPTRD;                                            JANDRE 
            DMPTRD(RR);                                                  JANDRE 
         $END                                                            JANDRE 
    GOTO REPSW[STRUCL];                                                  JANDRE 
                                                                         JANDRE 
                                                                         JANDRE 
REPB: # SUBSCRIPTED LEFT SIDE #                                          JANDRE 
    INDX[OBJX]=MEMR[WINX];                                               JANDRE 
                                                                         JANDRE 
  
REPA: #PRIMITIVE LEFT SIDE# 
    IF VFLG[OBJX] NQ QVFLG"LITR" THEN 
         BEGIN #NON-LITERAL#
         IF AC$S[OBJX] EQ S"LS" THEN
REPA0:        BEGIN #PART-WORD ACCESS#
              CALLLEFT;                                                  JANDRE 
              SYG=$IGN[RR]; 
              IF UNNORM THEN                                             JANDRE 
                 BEGIN                                                   JANDRE 
                   FBT=EFBT[RR];                                         JANDRE 
                   NBT=ENBT[RR];                                         JANDRE 
                 END ELSE                                                JANDRE 
              BEGIN                                                      JANDRE 
              FBT=0; #OPERAND IS NORMALIZED BY EXPGEN#
              NBT=60; 
              END                                                        JANDRE 
REPA01:       DPOSIT; 
REPA02:       XX=ICFPTR;
              GOTO REPA10;                                               JANDRE 
              END #PART-WORD ACCESS#
                                                                         JANDRE 
                   # AC$S IS "EQ" #                                      JANDRE 
         IF KFLG[RR] THEN                                                JANDRE 
              BEGIN  # TRY TO AVOID A FETCH #                            JANDRE 
              K=KONS[RR];                                                JANDRE 
              IF K GR 0 AND B<18,42>K EQ 0 THEN                          JANDRE 
                   BEGIN                                                 JANDRE 
                   ICFGEN(QICFOP"LSHC",PSICON(B<0,18>K),42);             JANDRE 
                   XX=ICFPTR;                                            JANDRE 
                   GOTO REPA10;                                          JANDRE 
                   END                                                   JANDRE 
              END                                                        JANDRE 
REPA1:   XX=MEMR[RR];                                                    JANDRE 
REPA10:  SLOD(OBJX);                                                     JANDRE 
         IF MEMR[OBJX] GR 0 
         AND OPTR[OOIX] NQ QILOP"FRES"
         AND CLAS[MEMR[OBJX]] EQ S"TEMP"
         AND  TPFO[MEMR[OBJX]] THEN        # STORE INTO FOR-LOOP TEMP#
            IF XX GR 0
            AND CLAS[XX] EQ S"CONS" THEN
             ICFS [ MEMR[OBJX]] = XX; 
            ELSE
           BEGIN
           ICFGEN ( QICFOP"SAVE" , MEMR[OBJX] , XX ); 
           ICFS[MEMR[OBJX]] = ICFPTR ;  #RETAIN ICF INDEX OF SAVE FOR 
                                         USE BY DEAD    # 
           END
         ELSE    #NOT A TEMP  # 
         ICFGEN(QICFOP"REPL",MEMR[OBJX],XX);                             JANDRE 
         RETURN;
         END #NON-LITERAL#
                                                                         JANDRE 
    #VFLG=S"LITR"#
    CLSS(RR); 
    # NOW, OBJL IS LEFT OBJECT TRIAD, OBJX RIGHT ONE #                   JANDRE 
# PROVISOIRE # IF OPTR[RR] NQ S"FUNI" THEN BEGIN                         JANDRE 
    IF AC$S[OBJL] NQ S"GR" THEN                                          JANDRE 
       BEGIN # LEFT SIDE (SINK) IS IN ONE WORD #                         JANDRE 
       IF AC$S[OBJX] NQ S"GR" THEN                                       JANDRE 
         BEGIN #NEITHER SIDE SPANS WORDS# 
REPA11:                                                                  JANDRE 
         OBJX=OBJL;  WINX=WINL;                                          JANDRE 
         IF ENBT[OBJX] EQ 60 THEN 
              BEGIN #FULL-WORD LEFT SIDE# 
              IF KFLG[RR] THEN MEMR[RR]=PSICON(KONS[RR]); 
               ELSE 
                     IF NOT ADJF[RR] THEN 
                     BEGIN
                       ICFGEN(QICFOP"LSHC",MEMR[RR],EFBT[RR] ); 
                       MEMR[RR] = ICFPTR; 
                     END
              GOTO REPA1; 
              END 
         #LOOK TO SEE IF WE CAN DO THE THE REPLACEMENT IN SITU         #
         IF  NOT UNNORM                        #SINK NOT YET NORMALIZED#
         AND ENBT[OBJX] EQ ENBT[RR]            #AND SAME WORD POSITION #
         AND EFBT[OBJX] EQ EFBT[RR] 
         AND OPTR[RR] NQ S"VALU" THEN          #NO WAY TO ALIGN VALU   #
             GOTO REPA1;
         CALLLEFT;                                                       JANDRE 
         IF UNNORM THEN                                                  JANDRE 
         BEGIN                                                           JANDRE 
              FBT=EFBT[RR];                                              JANDRE 
              NBT=ENBT[RR];                                              JANDRE 
         END ELSE                                                        JANDRE 
         BEGIN#OPERAND IS NORMALIZED #                                   JANDRE 
              SYG=F;
              NBT=MBT;
              FBT=60-NBT; 
              IF ADJF[OBJX] THEN FBT=0; #LEFT-ADJUSTED# 
         END                                                             JANDRE 
              CDPOSIT;                                                   JANDRE 
              XX=ICFPTR;                                                 JANDRE 
              GOTO REPA10;                                               JANDRE 
         END #NEITHER SIDE SPANS A WORD#
       IF ENBT[OBJL] LQ 60-EFBT[OBJX]                                    JANDRE 
         THEN # ONLY ONE WORD FROM RIGHT(SOURCE) #                       JANDRE 
            BEGIN                                                        JANDRE 
            ENBT[OBJX]=ENBT[OBJL];                                       JANDRE 
            AC$S[OBJX]=AC$S[OBJL];                                       JANDRE 
            QREP[OBJX]=ENBT[OBJL] LS 60;                                 JANDRE 
            QREP[OOIX]=QREP[OBJX] AND QREP[OBJL];                        JANDRE 
            UNNORM=QREP[OOIX];                                           JANDRE 
            IF BWOR[RR] THEN SLODL(RR); ELSE SLODL(OBJX);                JANDRE 
            GOTO REPA11;                                                 JANDRE 
            END                                                          JANDRE 
         ELSE # SOURCE CROSSES WORDS #                                   JANDRE 
            BEGIN                                                        JANDRE 
          L=60-EFBT[OBJX]; #LENGTH FROM 1ST SOURCE D =SINK 1ST PART #    JANDRE 
          M=ENBT[OBJL]-L; # SINK, SECOND PART #                          JANDRE 
          P=EFBT[OBJL]+L; #1ST BIT OF SECOND PART OF SINK #              JANDRE 
          IF ENBT[OBJL] LQ ENBT[OBJX] THEN R=M; #2ND SOURCE WORD #       JANDRE 
                 ELSE R=ENBT[OBJX]-L;                                    JANDRE 
          I = MEMR[OBJX];   # SAVE S.T. OF RIGTH  # 
          AC$S[OBJX]=S"LS";                                              JANDRE 
          SLODL(OBJX);                                                   JANDRE 
          OBJX==OBJL; # NOW, OBJX:-LEFT, OBJL:-RIGHT #                   JANDRE 
          SYG=F;                                                         JANDRE 
          ENBT[OBJX]=L;                                                  JANDRE 
          FBT=EFBT[OBJL];                                                JANDRE 
          NBT=L;                                                         JANDRE 
          CALLLEFT;                                                      JANDRE 
          Q=XX; # SAVE LOADED SINK ICFPTR #                              JANDRE 
          CDPOSIT;                                                       JANDRE 
          XX=ICFPTR;                                                     JANDRE 
          MEMR[OBJL] = I; 
          R=STRADR(OBJL,1,VRAI); #LOAD 2ND WORD OF SOURCE #              JANDRE 
          MEMR[OBJL] = ICFPTR;   # POINT TO 2ND LOAD OF SOURCE  # 
          NBT=M;                                                         JANDRE 
          MBT=M;                                                         JANDRE 
          EBT=P;                                                         JANDRE 
          FBT=0;                                                         JANDRE 
          CDPOSIT;                                                       JANDRE 
          XX=ICFPTR;                                                     JANDRE 
          SLOD(OBJX);                                                    JANDRE 
          ICFGEN(QICFOP"REPL",MEMR[OBJX],XX);   # 2ND PART #             JANDRE 
          RETURN;                                                        JANDRE 
            END                                                          JANDRE 
       END  # SINK IS IN ONE WORD #                                      JANDRE 
                                                                         JANDRE 
    # MORE OPTIM COULD BE DONE HERE, MAINLY GENERATE IN-LINE CODE (WITH# JANDRE 
    # LOOP) INSTEAD OF RJ SYMSM. TODAY, ONLY OBVIOUS AND EASY CASES    # JANDRE 
                                                                         JANDRE 
    IF EFBY[OBJL] NQ 0 OR ENBY[OBJL] GR 4*10 OR EFBY[OBJX] NQ 0          JANDRE 
         THEN GOTO REPLONG;   #OFF-LINE CODE #                           JANDRE 
                                                                         JANDRE 
    BEGIN                                                                JANDRE 
    L=ENBY[OBJL];  R=ENBY[OBJX];   # LENGTHS IN BYTES #                  JANDRE 
    IF L LQ R OR KFLG[OBJX] THEN                                         JANDRE 
         BEGIN                                                           JANDRE 
         M=L/10;  # NUMBER OF FULL WORDS FOR SINK #                      JANDRE 
         Q=(R+9)/10; # CONSTANTS ARE FULL WORDS #                        JANDRE 
         P=M;  K=M-1;  # M SOURCE WORDS #                                JANDRE 
         IF KFLG[OBJX] AND Q LQ M THEN                                   JANDRE 
              BEGIN # SHORT CONSTANT #                                   JANDRE 
              P=0;                                                       JANDRE 
              K=Q-1;                                                     JANDRE 
          IF K EQ 0 THEN    # MIGHT BE INT CONSTANT#
              IF KFLG[OBJX] THEN MEMR[OBJX]= PSICON ( KONS[OBJX]);
          END 
         N=(L-M*10)*6; # REMAINDER BITS TO SINK #                        JANDRE 
         FOR I=0 STEP 1 UNTIL K DO                                       JANDRE 
           ICFGEN(QICFOP"REPL",STRADR(OBJL,I,FAUX),STRADR(OBJX,I,VRAI)); JANDRE 
         IF P EQ 0 THEN # SHORT CONSTANT #                               JANDRE 
              BEGIN                                                      JANDRE 
              FOR I=K+1 STEP 1 UNTIL M-1 DO # BLANK PADDING #            JANDRE 
                   ICFGEN(QICFOP"REPL",STRADR(OBJL,I,FAUX),              JANDRE 
                                       PSICON("          "));            JANDRE 
              KONS[OBJX]="          ";                                   JANDRE 
              END                                                        JANDRE 
         IF N EQ 0 THEN RETURN;   # NO PART WORD AT THE END #            JANDRE 
         OFFS[OBJL]=OFFS[OBJL]+M*INCRMT(OBJL);
         OFFS[OBJX]=OFFS[OBJX]+P*INCRMT(OBJX);
         IF P NQ 0 THEN KFLG[OBJX]=F;                                    JANDRE 
         SLODL(OBJX);                                                    JANDRE 
         OBJX=OBJL;                                                      JANDRE 
         CALLLEFT;                                                       JANDRE 
         FBT=0; EBT=0;                                                   JANDRE 
         NBT=N; MBT=N;                                                   JANDRE 
         GOTO REPA01;                                                    JANDRE 
         END                                                             JANDRE 
    END                                                                  JANDRE 
    END # WAITING BWOR IS DEBUGGED #                                     JANDRE 
    #EITHER(BOTH) SIDE(S) SPAN(S) WORDS- CALL DALE"S ROUTINE# 
REPLONG:                                                                 JANDRE 
          IF QREP[RR] AND KFLG[RR] AND ENBT[RR] LQ 60 
           THEN 
              # QREP CONSTANT IS ALREADY TRANSFORMED# 
           MEMR[RR] = PSICON( KONS[RR] ); 
    SAVESV(OOIX);                                                        JANDRE 
    KRP00(OOIX);                                                         JANDRE 
    RETURN; 
REPD: # SUBSCRIPTED, BEAD-MODIFIED LEFT-SIDE #                           JANDRE 
    INDX[OBJX]=MEMR[WINX];                                               JANDRE 
  
REPC: #UNSUBSCRIPTED BEAD-MODIFIED LEFT SIDE# 
         Q=LOPD[OOIX];                                                   JANDRE 
         K=FNUM[Q];                                                      JANDRE 
    CLSS(RR); 
         IF BWOR[RR] THEN AC$S[OBJX]=S"LS"; #BEAD GIVES 1 WORD #         JANDRE 
         IF BWOR[Q ] THEN AC$S[OBJL]=S"LS"; #BEAD GIVES 1 WORD #         JANDRE 
    IF AC$S[OBJL] NQ S"GR" AND AC$S[OBJX] NQ S"GR" THEN                  JANDRE 
         BEGIN #DOESN"T SPAN WORDS- CHECK FIRST FOR CONSTANT BEADS# 
         OBJX=OBJL; WINX=WINL; NBDX=NBDL; FBDX=FBDL;                     JANDRE 
         L=-1; M=-1;
         IF KFLG[FBDX] THEN L=KONS[FBDX]; 
         IF KFLG[NBDX] THEN M=KONS[NBDX]; 
         IF M EQ 0 THEN RETURN; #NOP# 
         IF K EQ QFNBS"BIT" THEN                                         JANDRE 
REPC0:        BEGIN #BIT MODIFIER#
              IF L LOR M GR 0 THEN
                   BEGIN #CONSTANT FBIT,NBIT# 
                   EFBT[OBJX]=EFBT[OBJX]+L; 
                   ENBT[OBJX]=M;
                   IF M LS 60 THEN AC$S[OBJX]=S"LS";
                   VFLG[OBJX]=S"NUMB";
                   GOTO REPA; 
                   END #CONSTANT FBIT,NBIT# 
              K=GETRD;
              MOVET(OBJX,K);
              MEMR[K]=GTFW(OBJX); 
              SLODL(K); 
              IF M GR 0 THEN
                   BEGIN #NBIT IS CONSTANT,FBIT IS VARIABLE#
                   ICFGEN(QICFOP"ADSC",MEMR[FBDX],PSICON(EFBT[OBJX]-60))
                                                                       ; JANDRE 
                   ICFGNR(QICFOP"RSHV",-1,MSKGEN(M));                    JANDRE 
                   ICFGNR(QICFOP"ADSC",-2,PSICON(M)); 
                   ICFGEN(QICFOP"RSHV",ICFPTR,MEMR[RR]);
                   ICFGNR(QICFOP"LNND",-3,-5);
                   ICFGNR(QICFOP"LAND",-4,-2);
                   ICFGNR(QICFOP"LOR",-1,-2); 
                   GOTO REPA02; 
                   END #CONSTANT NBIT#
              IF L GQ 0 THEN
                   BEGIN #CONSTANT FBIT,VARIABLE NBIT#
                   #SYMPL BIT DEPOSIT#
                   P=ICFPTR; #SAVES FULL-WORD SINK# 
                   ICFGEN(QICFOP"ADSC",MEMR[NBDX],PMINUS1);              JANDRE 
                   ICFGNR(QICFOP"RSHV",-1,MASK1);                        JANDRE 
                   N=60-L-EFBT[OBJX]; 
              IF N NQ 60 THEN 
                   IF N NQ  0 THEN ICFGEN(QICFOP"LSHC",ICFPTR,N); 
                   R=ICFPTR; #MASK PTR# 
                   ICFGEN(QICFOP"ADSC",MEMR[NBDX],PSICON(-N));
                   ICFGEN(QICFOP"RSHV",ICFPTR,MEMR[RR]);
                   ICFGEN(QICFOP"LNND",R,P);
                   ICFGNR(QICFOP"LAND",-4,-2);
                   ICFGNR(QICFOP"LOR",-1,-2); 
                   GOTO REPA02; 
                   END #CONSTANT FBIT#
              #VARIABLE FBIT,VARIABLE NBIT# 
              #SYMPL VARIABLE FBIT,NBIT#
              ICFGEN(QICFOP"ADSC",MEMR[NBDX],PMINUS1);                   JANDRE 
              ICFGNR(QICFOP"RSHV",-1,MASK1);                             JANDRE 
              ICFGEN(QICFOP"ADSC",MEMR[FBDX],PSICON(EFBT[OBJX]-60));
              N=ICFPTR; 
              ICFGNR(QICFOP"RSHV",-1,-2); 
              ICFGEN(QICFOP"IADD",N,MEMR[NBDX]);
              ICFGEN(QICFOP"RSHV",ICFPTR,MEMR[RR]); 
              ICFGNR(QICFOP"LNND",-3,-7); 
              ICFGNR(QICFOP"LAND",-4,-2); 
              ICFGNR(QICFOP"LOR",-1,-2);
              GOTO REPA02;
              END #BIT MODIFIER#
         IF K EQ QFNBS"BYTE" THEN                                        JANDRE 
REPC1:        BEGIN #BYTE MODIFIER# 
          IF QREP[RR] AND KFLG[RR] THEN 
                # GET CONVERT VALUE FOR CONSTANT  # 
            MEMR[RR] = PSICON( KONS[RR] ) ; 
      ADJF[OBJX]=T; 
              IF L LOR M GR 0 THEN
                   BEGIN #CONSTANT FBYT,NBYT# 
                   EFBT[OBJX]=EFBT[OBJX]+6*L; 
                   ENBT[OBJX]=6*M;
                   VFLG[OBJX]=S"LITR";
                   IF M LS 10 THEN AC$S[OBJX]=S"LS";
                   GOTO REPA; 
                   END #CONSTANT FBYT,NBYT# 
              IF EFBT[RR] NQ 0 THEN 
                   BEGIN
                   ICFGEN(QICFOP"LSHC",MEMR[RR],EFBT[RR]);
                   MEMR[RR]=ICFPTR; 
                   END
              K=GETRD;
              IF BWOR[Q] THEN MOVET(Q,K); ELSE MOVET(OBJX,K);            JANDRE 
              MEMR[K]=GTFW(OBJX); 
              SLODL(K); 
              P=ICFPTR; #SINK OVERLAY PTR#
              IF M GR 0 THEN
                   BEGIN #CONSTANT NBYT,VARIABLE FBYT#
                   MULV6(MEMR[FBDX]); 
                    #SYMPL# 
                    ICFGNR(QICFOP"ADSC",-1,PSICON(EFBT[OBJX]-60));
                    ICFGEN(QICFOP"RSHV",ICFPTR,MEMR[RR]); 
                    ICFGNR(QICFOP"RSHV",-2,MSKGEN(6*M));                 JANDRE 
                    ICFGNR(QICFOP"LNND",-1,-7); 
                    ICFGNR(QICFOP"LAND",-2,-3); 
                    ICFGNR(QICFOP"LOR",-1,-2);
                    GOTO REPA02;
                    END #CONSTANT NBYT# 
              IF L GQ 0 THEN
                   BEGIN #CONSTANT FBYT,VARIABLE NBYT#
                   MULV6(MEMR[NBDX]); 
                   Q=ICFPTR; #6*M PTR#
                   ICFGNR(QICFOP"ADSC",-1,PMINUS1);                      JANDRE 
                   ICFGNR(QICFOP"RSHV",-1,MASK1);                        JANDRE 
                   R=60-6*L-EFBT[OBJX]; 
                   #SYMPL#
                   Q=MEMR[RR];
                   N=ICFPTR;
      IF R NQ 0 AND R NQ 60 THEN
                        BEGIN 
                        ICFGNR(QICFOP"LSHC",-1,R);
                        N=ICFPTR; 
                        ICFGEN(QICFOP"LSHC",Q,R); 
                        Q=ICFPTR; 
                        END 
                   ICFGEN(QICFOP"LNND",N,P);
                   ICFGEN(QICFOP"LAND",N,Q);
                   ICFGNR(QICFOP"LOR",-1,-2); 
                   GOTO REPA02; 
                   END #CONSTANT FBYT,VARIABLE NBYT#
              #VARIABLE FBYT,NBYT#
              MULV6(MEMR[FBDX]);
              Q=ICFPTR; #F PTR# 
              MULV6(MEMR[NBDX]);
              R=ICFPTR; #N PTR# 
              ICFGNR(QICFOP"ADSC",-1,PMINUS1);                           JANDRE 
              ICFGNR(QICFOP"RSHV",-1,MASK1);                             JANDRE 
              IF NOT ADJF[OBJX] THEN #RIGHT-ADJUSTED# 
                   BEGIN
                   ICFGNR(QICFOP"RSHC",-2,59);
                   ICFGNR(QICFOP"LNND",-1,-2);
                   END
              ICFGEN(QICFOP"ADSC",Q,PSICON(EFBT[OBJX]-60)); 
              Q=ICFPTR; 
              ICFGNR(QICFOP"RSHV",-1,-2); 
              N=ICFPTR; #MASK PTR#
              IF NOT ADJF[OBJX] THEN #RIGHT-ADJUSTED# 
                   BEGIN
                   ICFGEN(QICFOP"IADD",Q,R);
                   ICFGEN(QICFOP"RSHV",ICFPTR,MEMR[RR]);
                   END
              ELSE BEGIN #SYMPL#
          IF QREP[RR] AND KFLG[RR] AND ENBT[RR] LQ 60 
              THEN   #QREP CONSTANT RHS IS ALREADY TRANSFORMED #
              MEMR[RR] = PSICON( KONS[RR]); 
                   ICFGEN(QICFOP"RSHV",Q,MEMR[RR]); 
                   END
              ICFGEN(QICFOP"LNND",N,P); 
              ICFGEN(QICFOP"LAND",ICFPTR+1,N);
              ICFGNR(QICFOP"LOR",-1,-2);
              GOTO REPA02;
              END #BYTE MODIFIER# 
         #BITY# 
         IF VFLG[OBJX] NQ S"LITR" THEN GOTO REPC0; #NON-LITERAL#
         GOTO REPC1; #LITERAL#
         END #AC$S NQ S"GR" AND AC$S NQ S"GR"#
    #ONE OR BOTH OBJECTS SPANS WORDS- CALL DALE"S ROUTINE#
    GOTO REPLONG;                                                        JANDRE 
  
PFUN: #SYMPL BASED ARRAY POINTER# 
  
          ICFGEN ( QICFOP"PFUN" , MEMR[OBJX] , 0 ); 
          ICFGEN ( QICFOP"REPL" , ICFPTR , MEMR[RR] );
END 
TERM
