*DECK             SYMBYT
USETEXT   TSOURCE 
USETEXT   TCEXECQ 
USETEXT   TSYMCNS 
USETEXT   TCEXEC
USETEXT   TCOM37Q 
USETEXT   TCOM78Q 
USETEXT   TC7DECS 
PROC SYMBYT((I));            # SYMPL BYTE EXTRACT  #
BEGIN 
  
  
  
  
*CALL COMEX 
  
  
  
    ITEM I;  # FUNI TRIAD INDEX  (L M FLST N FLST FUNI)#
    ITEM J,K,L,M,N,O,P; 
      ITEM Q; 
    XREF PROC ICFGEN; 
    XREF PROC ICFGNR; 
    XREF FUNC KFIND;
    XREF PROC LOAD; 
    XREF PROC MOVET;
    XREF FUNC MSKGEN; 
    XDEF PROC MUL6; 
    XDEF PROC MULV6;
    XREF FUNC PSCARY; 
    XREF FUNC PSICON; 
    XREF PROC SLODL;
      XREF PROC SAVESV; 
      XREF PROC KGT00;
    J=LOPD[I]; #1ST FLST TRIAD# 
    K=LOPD[J]; #2ND FLST TRIAD# 
    L=LOPD[K]; #FIRST BYTE TRIAD# 
    M=ROPD[K]; #NUMBER OF BYTES TRIAD#
    N=ROPD[J]; #OBJECT TRIAD# 
               P=NXOP[I]; 
      Q=OPTR[P];
              IF AC$S[N] EQ S"GR" THEN
              IF Q EQ QILOP"REPL" OR OPAT5[Q] EQ S"EXPR" OR 
              Q EQ QILOP"FCAL" OR Q EQ QILOP"PCAL" OR 
              Q EQ QILOP"FRES"       OR 
              Q EQ QILOP"FLST" OR Q EQ QILOP"PLST" THEN 
                    BEGIN 
                   AC$S[I]=S"GR"; 
                   RETURN;
                   END
                   ELSE 
                    BEGIN 
                    SAVESV(I);
                    IF (MEMR[M] LS 0) AND NOT SAVD[M] THEN
                         BEGIN
                         ICFGEN(QICFOP"SAVE",0,MEMR[M]);
                         SAVD[M] = TRUE;
                         MEMR[M] = ICFPTR;
                         END
                    KGT00(I); 
                    IF NOT KFLG[M] THEN 
                    ENBT[I] = MEMR[M];
                    MEMR[I]=ICFPTR; 
                   RETURN;
                    END 
    VFLG[N]=S"LITR";
    $IGN[N]=F;
    IF KFLG[L] AND KFLG[M] THEN 
         BEGIN #DEGENERATE CASE#
         EFBY[N]=KONS[L]+EFBY[N]; 
         ENBY[N]=KONS[M]; 
         ENBT[N]=6*KONS[M]; 
         EFBT[N]=6*KONS[L]+EFBT[N]; 
         IF ENBY[N] LS 10 THEN
              BEGIN 
              AC$S[N]=S"LS";
              SHRT[N]=T;
              END 
      ADJF[N]=T;
         SFLG[N]=T; #FORCES EXTRACT#
         MOVET(N,I);
         LOAD(I); 
         RETURN;
         END
    SLODL(N); #LOADS WORD#
    IF KFLG[M] THEN 
         BEGIN #N IS CONSTANT#
         ENBY[N]=KONS[M]; 
         P=6*KONS[M]; 
         ENBT[N]=P; 
         IF P LS 60 THEN SHRT[N]=T; 
         O="          ";
         B<0,P>O=0; 
         IF EFBT[N] NQ 0 THEN 
              BEGIN 
              ICFGEN(QICFOP"LSHC",MEMR[N],EFBT[N]); 
              MEMR[N]=ICFPTR; 
              END 
         MUL6(L); 
         ICFGEN(QICFOP"LSHV",ICFPTR,MEMR[N]); 
         ICFGEN(QICFOP"LAND",ICFPTR,MSKGEN(P));                          JANDRE 
          ICFGEN (QICFOP"IAOR",ICFPTR,PSICON(O)); #LETTER O ,NOT0#
SY00:    MEMR[N]=ICFPTR;
         MOVET(N,I);
         RETURN;
         END #CONSTANT N# 
    IF Q NQ QILOP"FUNI" OR FNBR[MEMR[ROPD[P]]] NQ QFNBR"CIX"
         THEN VLNG[N]=T;   # ELSE, BYTE BEQD TO BE CONVERTED TO INTEGER#
    IF KFLG[L] THEN 
         BEGIN #FIRST BYTE IS CONSTANT# 
      P=EFBT[N]+KONS[L]*6;
         IF P NQ 0 THEN 
              BEGIN 
              ICFGEN(QICFOP"LSHC",MEMR[N],P); 
              MEMR[N]=ICFPTR; 
              END 
         MUL6(M); 
         Q=ICFPTR;  #6*M# 
         ICFGEN(QICFOP"ADSC",ICFPTR,PMINUS1);                            JANDRE 
         ICFGEN(QICFOP"RSHV",ICFPTR,MASK1);                              JANDRE 
         ICFGEN(QICFOP"LAND",ICFPTR,MEMR[N]); 
SY01: 
         IF VLNG[N] THEN # REGULAR CASE # 
         BEGIN
         ICFGEN(QICFOP"SUBS",PSCARY("JHB.1"),MEMR[M]);
         ICFGEN(QICFOP"LOAD",ICFPTR,0); 
         ICFGNR(QICFOP"IAOR",-1,-3);
               ADJF[N] = TRUE;
             ENBT[N] = 60;
             EFBT[N] = 0; 
         END
         ELSE BEGIN # CONVERT TO INTEGER #
              ICFGEN(QICFOP"LSHV",Q,ICFPTR); # RIGHT ADJUSTED # 
              EFBT[N]=0; ENBT[N]=60;
              END 
         GOTO SY00; 
         END #CONSTANT F# 
    #BOTH F AND N ARE VARIABLE# 
    P=EFBT[N];
    IF P NQ 0 THEN
         BEGIN
         ICFGEN(QICFOP"LSHC",MEMR[N],P);
         MEMR[N]=ICFPTR;
         END
    MUL6(L);
    P=ICFPTR; 
    MUL6(M);
    Q=ICFPTR; # 6*M # 
         ICFGEN(QICFOP"ADSC",ICFPTR,PMINUS1);                            JANDRE 
         ICFGEN(QICFOP"RSHV",ICFPTR,MASK1);                              JANDRE 
    ICFGEN(QICFOP"LSHV",P,MEMR[N]); 
    ICFGNR(QICFOP"LAND",-1,-2); 
    GOTO SY01;
CONTROL EJECT;
PROC MUL6(A); #MULTIPLY BY 6# 
    BEGIN 
    ITEM A; #TRIAD PRT# 
    ITEM I; 
    I=MEMR[A];
    MULV6(I); 
    END 
CONTROL EJECT;
PROC MULV6(A);
    BEGIN 
    ITEM A; #MEMR#
    ITEM I; 
    I=A;
    ICFGEN(QICFOP"IADD",I,I); 
    ICFGEN(QICFOP"LSHC",I,2); 
    ICFGNR(QICFOP"IADD",-1,-2); 
    END 
END 
TERM
