*DECK             MAPCRF
USETEXT   TSOURCE 
USETEXT   TTARGET 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TCEXEC
PROC MAPCRF;
 BEGIN#MAPCRF#
      XREF  PROC FIND;             # FIND NAME ENTRY                   #
      XREF  ITEM GENTXTF   I;      # TRUE IF TEXT GENERATION           #
      XREF  PROC PTLST;            # WRITE A LINE TO OUTPUT FILE       #
      XREF  PROC PTLSTV;           # WRITE A LINE, GIVEN NO. OF WORDS  #
*CALL COMEX 
#*******************************************************************# 
*CALL COM99A
     ITEM IST  I = 0;    #SORT TABLE INDEX# 
     ITEM ILOCN;    #LOCN#
     ITEM NAMB B    = FALSE;  #NAME FLAG# 
     ITEM INAM0 C(10) = BLKW; ITEM INAM1 C(10) = BLKW;
     ITEM IC  ; 
#*******************************************************************# 
     DEF  LBYTP 
               #54# ;             #LAST BYTE POSITION#
     DEF  HZERO 
               #O"33"#;  #ZERO# 
     DEF  BLKZ
               #"         0"#;    #RIGHT JUST. "0"# 
     DEF  EHSH #127#     ;  #HASH TABLE SIZE-1# 
#*******************************************************************# 
     DEF  ECMP
               #12#;
     DEF  RLP    #1#;        # PROGRAM RELOCATION NR                   #
     ARRAY ACMP [0:ECMP] S(1); #MAP LINE# 
          ITEM CMP      I(0, 0,WBITS),
#76#           CMPCC C(0,0,10)=[WLIN(BLKW)],
               CMPN  I(0,0,WBITS),
               CMPN1 C(1,0,2),
               CMPC  I(1,0,WBITS),
               CMPT  I(2,0, 6), 
               CMPL  I(2,0,WBITS),
               CMPRL I(2,48,12),
               CMPR0 I(3,0,6),
               CMPF1 I(3,0,18), 
               CMPF0 I(3,0,24), 
               CMPB2 I(3,0,36), 
               CMPB1 I(3,0,42), 
               CMPB0 I(3,0,48); 
     ITEM CMPX I = 0;     #MAP INDEX# 
     DEF  WMAPP 
               #4#;      #MAP ENTRY INCR# 
     DEF  WMAPL 
               #8#;      #LAST MAP ENTRY# 
     DEF WMAPC
               #2#; #MAP CLEAR# 
         ITEM HZEROD  ;     # ZERO FILL TO LEFT OF NUMBER  #
         DEF HBLNK # O"55" #; 
##       ITEM MESPUT B = FALSE; 
#*******************************************************************# 
CONTROL EJECT;
##  PROC MESSAGE; 
##       BEGIN
##            IF MESPUT THEN RETURN;
##            MESPUT = TRUE;
##            PTLSTV("0***** MAP SORT TABLE OVERFLOW",3); 
##       END
CONTROL EJECT;
PROC INDSRT;   #INDIRECT SHELL SORT#
                                        #INDSRT IS A SUBROUTINE INTER- #
                                        # NAL TO MAPCRF WHICH PERFORMS #
                                        # AN "INDIRECT" SORT TO PLACE  #
                                        # THE NAME TABLE ENTRIES IN    #
                                        # ALPHANUMERIC SEQUENCE.       #
     BEGIN#INDSRT#
         FOR K = IST/2  STEP -((K+1)/2) UNTIL 1  DO 
         BEGIN#K# 
               IL = IST-K;
               FOR J = 1 STEP 1 UNTIL IL  DO
               BEGIN#J# 
                    IJ = J-1; 
INDSR2: 
                    IK = IJ+K;
                    IJK = STB [IJ]; IKK = STB [IK]; 
                    IKKL = NAM1[IJK] LXR NAM1[IKK];  #CHECK SIGN# 
                    IF IKKL GR 0 THEN GOTO INDSR3;     #SIGN = #
                    IF IKKL EQ 0 THEN GOTO INDSR6;     #J = K#
                    #BEGIN J NOT= K#
                         IF NAM1[IJK] GQ 0 THEN TEST J; #J < K# 
                         #ELSE#    GOTO INDSR4;   #J > K #
                    #END   J NOT= K#
INDSR3: 
                    IF NAM1[IJK] GR NAM1[IKK] THEN
                    BEGIN#REORDER#
INDSR4: 
                         STB[IJ] == STB[IK]; #EXCHANGE# 
                         IJ = IJ-K; 
                         IF IJ GQ 0 THEN GOTO INDSR2; 
                         #ELSE# TEST J; #END J# 
                    END  #REORDER#
                    #ELSE </=#
               IF NAM1[IJK] EQ NAM1[IKK] THEN 
               BEGIN#=# 
INDSR6: 
                    KB = (NCHR[IJK]-1)/WBYT;  #NO. WDS# 
                    KW = (NCHR[IKK]-1)/WBYT;
                    IF KB LS KW THEN KW = KB; #MIN(NO.WDS)# 
                    FOR I = 1 STEP 1 UNTIL KW  DO 
                    BEGIN#I#
                         IKKL = NAM1[IJK+I] LXR NAM1[IKK+I]; #SIGN# 
                         IF IKKL GR 0 THEN GOTO INDSR7;     #SIGN =#
                         IF IKKL EQ 0 THEN TEST I;  #J = K# 
                         #BEGIN J NOT= K# 
                              IF NAM1[IJK+I] GQ 0 THEN TEST J; # J < K# 
                              #ELSE#    GOTO INDSR4;   #J > K#
                         #END   J NOT= K# 
INDSR7: 
                         IF NAM1[IJK+I] GR NAM1[IKK+I] THEN GOTO INDSR4;
                         IF NAM1[IJK+I] LS NAM1[IKK+I] THEN TEST J; 
                    END  #I#
               END  #=# 
                    #END  </=#
               END  #J# 
         END  #K# 
     END  #INDSRT#
CONTROL EJECT;
#*******************************************************************# 
     DEF  PLC02 
         #"   ITEM   "#;
     DEF  PLC03 
         #"   ARRAY  "#;
     DEF  PLC04 
                #"   CONST  "#; 
     DEF  PLC06 
                #"   LABEL  "#; 
     DEF  PLC07 
                #"   PROC   "#; 
     DEF  PLC08 
                #"   FUNC   "#; 
     DEF  PLC09 
                #"   CLOSE  "#; 
     DEF  PLC10 
                #"   SWITCH "#; 
     DEF  PLC11 
                #"   PROGRM "#; 
     DEF  PLC17 
                #"   COMMON "#; 
     DEF  PLC19 #"   XPAR   "#; 
     DEF  PLC20 
         #"   ARYITM "#;
     DEF  PLC21 
                #"   STRING "#; 
     DEF  PLC22 
                #"   FILE   "#; 
     DEF  PLC24 
                #"   ARRAY  "#; 
#*******************************************************************# 
#*******************************************************************# 
CONTROL EJECT;
 ARRAY MASKIT [0:9];
   ITEM MASK55 = [
            O"55000000000000000000"  ,
              O"550000000000000000"  ,
                O"5500000000000000"  ,
                  O"55000000000000"  ,
                    O"550000000000"  ,
                      O"5500000000"  ,
                        O"55000000"  ,
                          O"550000"  ,
                            O"5500"  ,
                              O"55"  ] ;
PROC PLMPN;   #PUT NAME#
                                        #PLMPN IS A SUBROUTINE INTERNAL#
                                        # TO MAPCRF INVOKED TO FORMAT  #
                                        # AND PRINT STORAGE MAP ENTRIES#
     BEGIN#PLMPN# 
          ITEM I;   #LOCAL LOOP VARIABLE# 
         CMPN[CMPX] = INAM0;   #NAME# 
         CMPN1[CMPX] = INAM1; 
          IF IC GQ 8 THEN 
          B<0,12>CMPN1[CMPX] = B<0,12>CMPN1[CMPX] + 
                               B<0,12>MASK55[IC-8]; 
                     ELSE 
           CMPN [CMPX] = CMPN [ CMPX] + MASK55 [IC+2];
         GOTO PLMP2;
#*******************************************************************# 
ENTRY PROC PLMPC;   #PUT TYPE,LOCN(FBIT,NBIT/NBYT)# 
      #BEGIN PLMPC# 
     SWITCH SWTYPM:QTYPE
            PLM2NL:NULL , 
            PLM2OC:OCT  , 
            PLM2FX:FIX  , 
            PLM2IG:IGR  , 
            PLM2RL:REAL , 
            PLM2DB:DBL  , 
            PLM2BL:BOOL , 
            PLM2ST:STTS , 
            PLM2BC:EBCD , 
            PLM2UN:USI  , 
            PLM2PR:RSLT , 
            PLM2SR:ADR  , 
            PLM2BS:QTYPE$,
            PLM2HL:HLTH , 
            PLM2TR:TRAN ; 
#*******************************************************************# 
PLMP2:  
         IL = RLNO[IJ];       #RL NO.#
      IF CLAS[IJ] EQ S"SWCH" OR CLAS[IJ] EQ S"DEF" THEN 
           GOTO PLM2NL; 
         GOTO SWTYPM[TYPE[IJ]];         #TYPE SWITCH #
PLM2NL: 
               IF IL NQ RLX THEN GOTO PLMP4;      #NOT XTRN#
               #ELSE XTRN#
      IF XTRN[IJ] EQ S"WEAK"  THEN
          CMPT[CMPX] = PLTWK; 
      ELSE
                    CMPT[CMPX] = PLTXT;      #TYPE# 
                    GOTO PLMP5; 
               #END  XTRN#
PLM2OC: 
               CMPT[CMPX] = PLTOC;      #TYPE#
               GOTO PLMP4;
PLM2IG: 
               CMPT[CMPX] = PLTIG;      #TYPE#
               GOTO PLMP4;
PLM2RL: 
               CMPT[CMPX] = PLTRL;      #TYPE#
               GOTO PLMP4;
PLM2DB: 
               CMPT[CMPX] = PLTDB;      #TYPE#
               GOTO PLMP4;
PLM2BL: 
               CMPT[CMPX] = PLTBL;      #TYPE#
               GOTO PLMP4;
PLM2ST: 
               CMPT[CMPX] = PLTST;      #TYPE#
               GOTO PLMP4;
PLM2BC: 
##       CMPT[CMPX] = O"03";   # C = CHARACTER #
               GOTO PLMP4;
PLM2UN: 
               CMPT[CMPX] = PLTUN;      #TYPE#
               GOTO PLMP4;
PLM2PR: 
               CMPT[CMPX] = PLTPR;
               GOTO PLMP4;
PLM2SR: 
               CMPT[CMPX] = PLTSR;
               GOTO PLMP4;
PLM2BS: 
##       CMPC[CMPX] = "   B.ARRY "; 
##       IF PORS[IJ] THEN GOTO PLM2SR;  #SERIAL#
##       #ELSE#  GOTO PLM2PR;  #PARALLEL# 
PLM2HL: 
##       CMPT[CMPX] = O"03";   # C = CHARACTER #
               GOTO PLMP4;
PLM2TR: 
               CMPT[CMPX] = PLTTR;      #TYPE#
               GOTO PLMP4;
PLM2FX: 
               CMPT[CMPX] = PLTFX;      #TYPE#
PLMP4:  
         IF IL LS RLX THEN GOTO PLMP5;  #PROGRAM# 
         #ELSE NOT PROGRAM# 
      IF IL EQ RLX  THEN
          IF XTRN[IJ] EQ S"WEAK" OR 
             (CLAS[IJ] EQ S"TITM" AND XTRN[MAMA[IJ]] EQ S"WEAK")  THEN
              CMPRL[CMPX] = O"3155";
          ELSE
              CMPRL[CMPX] = O"3055";
               ELSE BEGIN#COMMON# 
                    IF IL GQ 10 THEN
                    BEGIN#2 DIGITS# 
                         IK = IL/10;
                         CMPRL[CMPX] = IK+O"0333";   #C-# 
                         CMPR0[CMPX] = IL-IK*10+HZERO;   #DIGIT 2#
                    END  #2 DIGITS# 
                    ELSE CMPRL[CMPX] = IL+O"0333";   #C-# 
               END       #COMMON# 
         #END  NOT PROGRAM# 
PLMP5:  
         ILOCN = LOCN[IJ];    #LOCN#
         K = 12;    #BIT INDEX# 
         HZEROD = HBLNK;
         FOR J = 42 STEP 3 UNTIL 57 DO
         BEGIN#J# 
               IF HZEROD EQ HBLNK 
               AND B<J,3> ILOCN NQ 0   THEN 
                 HZEROD = HZERO ; 
               B<K,6>CMPL[CMPX] = B<J,3>ILOCN + HZEROD; 
               K = K+6;  #INCR BIT INDEX# 
         END  #J# 
               IF HZEROD EQ HBLNK THEN
                 B<K-6 , 6> CMPL[CMPX] = HZERO; 
         GOTO PLMP6;
ENTRY PROC PLMPL; 
PLMP6:  
         CMPX = CMPX+WMAPP;  #INCR MAP INDEX# 
         IF CMPX LQ WMAPL THEN RETURN;    #NOT E-O-LINE#
         #ELSE E-O-LINE#
                    PTLST(ACMP);   #PUT LINE# 
                    FOR I = WMAPC STEP 1 UNTIL ECMP DO CMP[I] = BLKW; 
                    CMPX = 0;  #INIT MAP INDEX# 
         #END  E-O-LINE#
      #END   PLMPC# 
     END  #PLMPN# 
CONTROL EJECT;
#*******************************************************************# 
PROC PLMFN;   #FBIT,NBIT/BYTE#
                                        #PLMFN IS A SUBROUTINE INTERNAL#
                                        # TO MAPCRF WHICH CONVERTS AND #
                                        # POSTS THE FBIT AND NBIT/NBYT #
                                        # FIELDS INTO THE LINE BUFFER. #
     BEGIN#PLMFN# 
               IF TYPE[IJ] EQ S"HLTH" OR TYPE[IJ] EQ S"TRAN" OR 
                  TYPE[IJ] EQ S"OCT"  OR TYPE[IJ] EQ S"EBCD" THEN 
                    CVTOD(NBYT[IJ]);    # NBYT #
               ELSE CVTOD(NBIT[IJ]);    # NBIT #
               CMPB0[CMPX] = DCV[0];         #1ST DIGIT#
               IF IKKL NQ 0 THEN
               BEGIN#2/3 DIGITS#
                    CMPB1[CMPX] = DCV[1];    #2ND DIGIT#
                    IF IKKL NQ 1 THEN CMPB2[CMPX] = DCV[2]; #3RD DIGIT# 
               END  #2/3 DIGITS#
               CVTOD(FBIT[IJ]);    #CONVERT FBIT# 
               CMPF0[CMPX] = DCV[0]; #1ST DIGIT#
               IF IKKL EQ 1 THEN CMPF1[CMPX] = DCV[1]; #2ND DIGIT#
     END  #PLMFN# 
CONTROL EJECT;
#*******************************************************************# 
          PROC CVTOD ( (X) ) ;   # CONVERT OCTAL TO DECIMAL DISPLAY#
                                        #CVTOD IS A SUBROUTINE INTERNAL#
                                        # TO MAPCRF USED TO CONVERT THE#
                                        # OCTAL FBIT AND NBIT/NBYT     #
                                        # VALUES INTO DECIMAL DISPLAY  #
                                        # CHARACTERS. CVTOD(X) WHERE X #
                                        # = POSITIVE OCTAL VALUE.      #
     BEGIN #CVTOD#
          ITEM X;   #OCTAL NO.# 
          ITEM N,Q    ; #LOCAL TEMPS# 
          IKKL = 0;      #INIT DIGIT CNT# 
          IF X EQ 0 THEN
          BEGIN #ZERO#
               DCV[0] = BLKZ;      #"0"#
               RETURN;
          END  #ZERO# 
          #BEGIN - NON-ZERO#
               N = X;    #OCTAL#
CVTOD2: 
                    Q = N/10; 
                    DCV[IKKL] = (N-Q*10)+BLKZ;
                    IF Q EQ 0 THEN RETURN;   #COMPLETE# 
                    #ELSE NOT COMPLETE# 
                         N = Q; 
                         IKKL = IKKL+1;      #INCR DIGIT CNT# 
                         GOTO CVTOD2; 
          #END   - NON-ZERO#
     END  #CVTOD# 
CONTROL EJECT;
#*******************************************************************# 
#*******************************************************************# 
#*******************************************************************# 
     SWITCH SWCLAS:QCLAS #MAP/XREF# 
             MAP28:NULL, #NO  NO #
             MAP30:NAME, #NO  NO #
             MAP27:DATA, #YES YES#
             MAP23:TABL, #YES YES#
             MAP28:CONS, #NO  NO #
             MAP28:TEMP, #NO  NO #
             MAP25A:LABL,#YES YES#
             MAP26:PROC, #YES YES#
             MAP27:FUNC, #YES YES#
             MAP26:CLOS, #YES YES#
     MAP27: SWCH, #YES YES# 
             MAP28:MON , #NO  NO #
             MAP25:DUMY, #NO  YES#
             MAP26:PROG, #YES YES#
     MAP27: DEF, #NO YES# 
             MAP28:SLC , #NO  NO# 
             MAP28:INSC, #NO  NO #
             MAP24:FPAR, #NO  YES#
             MAP28:BPAR, #NO  NO #
             MAP27:COMM, #YES YES#
     MAP27: STSL, #NO YES#
             MAP27:SCON, #NO  YES#
             MAP27:TITM, #YES YES#
             MAP27:STRG, #YES YES#
             MAP28:OVER, #NO  NO #
             MAP26:FILE, #YES YES#
             MAP27:ARRY, #YES YES#
            MAP30:DTXT ,
             MAP27:QCLAS$;#YES NO#
#*******************************************************************# 
     SWITCH  SWCLSM:QCLAS     #MAP# 
             PLMP42:NULL,     #NO # 
             PLMP50:NAME,     #NO # 
             PLMP02:DATA,     #YES# 
             PLMP03:TABL,     #YES# 
             PLMP42:CONS,     #NO # 
             PLMP42:TEMP,     #NO # 
             PLMP06:LABL,     #YES# 
             PLMP07:PROC,     #YES# 
             PLMP08:FUNC,     #YES# 
             PLMP09:CLOS,     #YES# 
             PLMP10:SWCH,     #YES# 
             PLMP42:MON ,     #NO # 
             PLMP42:DUMY,     #NO # 
             PLMP11:PROG,     #YES# 
             PLMP42:DEF ,     #NO # 
             PLMP42:SLC ,     #NO # 
             PLMP42:INSC,     #NO # 
             PLMP42:FPAR,     #NO # 
             PLMP42:BPAR,     #NO # 
             PLMP17:COMM,     #YES# 
             PLMP42:STSL,     #NO # 
             PLMP42:SCON,     #NO # 
             PLMP20:TITM,     #YES# 
             PLMP21:STRG,     #YES# 
             PLMP42:OVER,     #NO # 
             PLMP22:FILE,     #YES# 
             PLMP24:ARRY,     #YES# 
            PLMP50:DTXT , 
             PLMP19:QCLAS$;   #YES# 
#*******************************************************************# 
MAP10:  
         IDUM = 0;  #LOWER  DUMY FLAG # 
         FOR I = 0 STEP 1 UNTIL EHSH  DO
         BEGIN#I# 
               IF HLNK[I] NQ 0 THEN 
               BEGIN#HASH CHAIN#
                    NP = HLNK[I];  #NAME PART#
MAP20:  
                    IKK = NCHR[NP]; 
                    IF IKK EQ 0 THEN GOTO MAP30;
                    #ELSE NAME# 
                         IJ = NLNK[NP]; 
MAP21:  
                    J = CLAS[IJ]; 
                    GOTO SWCLAS[J];     #CLASS# 
                       #TABL# 
MAP23:  
                         IF TTYP[IJ] EQ S"BASED" THEN TYPE[IJ]=SBASED;
                         ELSE BEGIN#NOT BASED#
                                   IF PORS[IJ] THEN TYPE[IJ]=SSERA; 
                                   ELSE TYPE[IJ]=SPARA; 
                              END  #NOT BASED#
                         GOTO MAP27;
                       #FPAR# 
MAP24:  
                         RLNK[IJ] = FDFP[IJ];  #SAVE FDFP#
                         GOTO MAP27;
                       #DUMY# 
MAP25:  
                         IDUM =1;  #RAISE DUMY FLAG#
                         GOTO  MAP27; 
  
MAP25A:                            # LABELS COME HERE                  #
                         IF  LOCN[IJ] EQ 0    # UNREFED LABEL...       #
                         THEN 
                           BEGIN
                           RLNO[IJ] = RLP;    # SET PROGRAM RELOCATION #
                           END
                         #MAP/XREF# 
MAP26:  
                         TYPE[IJ] = S"NULL";  #TYPE#
MAP27:  
                       IF NAMB THEN GOTO MAP28;   #NAME ENTERED#
                       #BEGIN ENTER NAME# 
##       IF IST NQ ESTB THEN BEGIN
                         STB[IST] = NP;  #NAME INDEX TO SORT TBL# 
                         IST = IST+1;   #INCR SORT TBL INDEX# 
                         NAMB = TRUE;   #RAISE NAME FLAG# 
                         IJK = IKK/WBYT;     #WORD INDEX# 
                         IKK = IKK-IJK*WBYT; #CHAR INDEX# 
                         IF IKK NQ 0 THEN C<IKK,1>NAME[NP+IJK] = 0; 
#                        *** INSERT 0 FOR SORT  (NO PRINT CHAR)***# 
##       END
##       ELSE MESSAGE;
                       #END   ENTER NAME# 
                         #NOT MAP/XREF# 
MAP28:  
                         XRFL[IJ] = 0;  #LOWER CRF FLAG#
                         IJ = NLNK[IJ];    #NEXT LINK#
                         GOTO MAP21;
                    #END  NAME# 
MAP30:  
                    NAMB = FALSE;  #LOWER NAME FLAG#
                    IF HLNK[NP] NQ 0 THEN 
                    BEGIN#ANOTHER NAME# 
                         NP = HLNK[NP]; #NAME LINK# 
                         GOTO MAP20;
                    END  #ANOTHER NAME# 
               END  #HASH CHAIN#
         END  #I# 
#*******************************************************************# 
         INDSRT;    #SORT ENTRIES#
         STB[IST] = 0;   #MARK E-O-NAME TABLE#
         IF NOT LMAP THEN RETURN;  #NO MAP# 
     #END  MAP/XREF#
     #ELSE MAP# 
#*******************************************************************# 
         I = 0; 
#*******************************************************************# 
PLMP0:  
               NP = STB[I];   #NAME PART# 
               IC = NCHR[NP]; #NAME LNG#
               B<12,48>INAM0 = B< 0,48>NAM1[NP];
               B< 0,12>INAM1 = B<48,12>NAM1[NP];
               IJ = NLNK[NP];      #ATTRIB PART#
          IF B<24,6> INAM0 EQ "?" THEN  #SKIP DEF PARAM NAMES#           NEWFEAT
                                       GOTO PLMP50;                      NEWFEAT
PLMP00: 
               IJK = CLAS[IJ];
               GOTO SWCLSM[CLAS[IJ]];   #CLASS SWITCH#
#*******************************************************************# 
PLMP02: 
               CMPC[CMPX] =  PLC02;     #CLASS# 
               PLMFN;         #FIRST BIT,NBIT/NBYT# 
               GOTO PLMP40; 
PLMP03: 
               CMPC[CMPX] =  PLC03;     #CLASS# 
  
               IF  GENTXTF NQ 0 
               THEN 
                 BEGIN
                 LOCN[IJ] = 0;
                 END
  
               GOTO PLMP40; 
PLMP06: 
               CMPC[CMPX] =  PLC06;     #CLASS# 
               GOTO PLMP40; 
PLMP07: 
               CMPC[CMPX] =  PLC07;     #CLASS# 
               GOTO PLMP40; 
PLMP08: 
               CMPC[CMPX] =  PLC08;     #CLASS# 
               PLMFN;         #FIRST BIT,NBIT/NBYT# 
               GOTO PLMP40; 
PLMP09: 
               CMPC[CMPX] =  PLC09;     #CLASS# 
               GOTO PLMP40; 
PLMP10: 
               CMPC[CMPX] =  PLC10;     #CLASS# 
               GOTO PLMP40; 
PLMP11: 
               CMPC[CMPX] =  PLC11;     #CLASS# 
               GOTO PLMP40; 
PLMP17: 
               CMPC[CMPX] =  PLC17;     #CLASS# 
               CMPN[CMPX] = INAM0;        #NAME#
               CMPN1[CMPX] = INAM1; 
          IF IC GQ 8 THEN 
          B<0,12>CMPN1[CMPX] = B<0,12>CMPN1[CMPX] + 
                               B<0,12>MASK55[IC-8]; 
                     ELSE 
           CMPN [CMPX] = CMPN [ CMPX] + MASK55 [IC+2];
##       IL = RLNO[IJ]; 
##       IF IL GQ 10 THEN BEGIN 
##            IK = IL/10; 
##            CMPRL[CMPX] = IK + O"0333"; 
##            CMPR0 [CMPX] = IL - IK*10 + HZERO;
##       END
##       ELSE CMPRL[CMPX] = IL + O"0333"; 
               PLMPL; 
               GOTO PLMP42; 
PLMP19: 
               CMPC[CMPX] =  PLC19;     #CLASS# 
               GOTO PLMP40; 
PLMP20: 
               CMPC[CMPX] =  PLC20;     #CLASS# 
               PLMFN;         #FIRST BIT,NBIT/NBYT# 
               GOTO PLMP40; 
PLMP21: 
               CMPC[CMPX] =  PLC21;     #CLASS# 
               PLMFN;         #FIRST BIT,NBIT/NBYT# 
               GOTO PLMP40; 
PLMP22: 
               CMPC[CMPX] =  PLC22;     #CLASS# 
               GOTO PLMP40; 
PLMP24: 
               CMPC[CMPX] =  PLC24;     #CLASS# 
#*******************************************************************# 
PLMP40: 
               PLMPN;    #PUT NAME# 
PLMP42: 
               IJ = NLNK[IJ]; #LINK#
               GOTO PLMP00; 
PLMP50: 
         I = I+1; 
         IF I LS IST THEN GOTO PLMP0; 
#*******************************************************************# 
         IF CMPX GR 1 THEN PTLST(ACMP);  #PUT LAST LINE#
     #END  MAP# 
 END  #MAPCRF#
      TERM
