*DECK EDITPAT 
USETEXT CCTTEXT 
USETEXT DNTEXT
          PROC  EDITPAT;
  
#**       EDITPAT -  EDIT THE EDIT PATTERN FOR NON-BDP CODE 
* 
$         P1 = (INTLENOF,REGB)
*         REGC = INDEX TO DESTINATION DNAT. 
*         REGT = INDEX TO DUMMY DNAT. 
* 
*         EDITPAT 
* 
* 
*         SETS P1 = 0:  COMPLICATED CASE,  AND
*                       (FWA$OF,REGT) = ADDRESS OF NON-BDP PATTERN
*                 " 0:  ZZZ CASE,  READY FOR * MX0 P1 *,  C.EDITZ 
# 
  
          BEGIN 
  
  
*CALL M$
  
*CALL AUXT1 
  
*CALL AUXTVALS
  
  
*CALL CHAR$ 
  
*CALL FIXCOM
  
*CALL FIXED 
  
*CALL REGTABL 
  
  
*CALL DNATVALS
  
*CALL PLT1
  
*CALL TABLETYP
  
  
  
          XREF  PROC  LITPOOL;         # POOL A LITERAL (PATTERN)      #
  
          XREF  FUNC  VIRTUAL;         # REFERENCE AN OUT-OF-CORE TABLE#
  
          $BEGIN
          XREF  PROC  CGABORT;         # COMPILER ABORT                #
          $END
  
          ITEM  AX           I;        # VIRTUAL INDEX TO AUXT         #
          ITEM  BCPASTERS    I;        # BCP OF *-S TO ALIGN DECIMAL PT#
          ITEM  BWZ          I;        # 1 IFF BLANK WHEN ZERO         #
          ITEM  CHAR         I;        # CURRENT CHARACTER             #
          ITEM  CODE         I;        # EDIT CODE                     #
          ITEM  DESTLEN      I;        # CURRENT LENGTH OF DESTINATION #
          ITEM  DX           I;        # VIRTUAL INDEX TO DNAT REGC    #
          ITEM  FLOATCHAR    I;        # CHARACTER FROM 4-TYPE COMMAND #
          ITEM  FLOATTYPE    I;        # TYPE OF FLOAT OPERATION       #
          ITEM  GC$INDEX     I;        # INDEX TO OLD PATTERN          #
          ITEM  GC$NLEFT     I;        # NO. OF CHARS LEFT IN OLD PAT. #
          ITEM  GC$POS       I;        # NEXT AVAIL. BIT IN GC$WORD    #
          ITEM  GC$WORD      I;        # CURRENT WORD FROM OLD PATTERN #
          ITEM  INTLENOFREGC I;        # NUMLENOFREGC - POINTOFREGC    #
          ITEM  LEFTFILLCHAR I;        # LEFT-FILL CHARACTER           #
          ITEM  MINUSCHAR    I;        # MINUS CHAR FROM TYPE 5 COMMAND#
          ITEM  NCHANGES     I;        # NO. OF DIGIT POSITIONS TO CHNG#
          ITEM  PC$INDEX     I;        # INDEX TO NEW PATTERN          #
          ITEM  PC$POS       I;        # NEXT AVAIL. POSITION IN NEW   #
          ITEM  PLUSCHAR     I;        # PLUS CHAR FROM TYPE 5 COMMAND #
          ITEM  PX           I;        # VIRTUAL INDEX TO PLT          #
          ITEM  STARTFLOAT   B;        # TO MODIFY FIRST FLOAT COMMAND #
          ITEM  T            I;        # SCRATCH                       #
          ITEM  TYPEOFREGC   I;        # DNAT TYPE OF REGC ITEM        #
          ITEM  ZZZCASE      B;        # SET TRUE IFF ZZZ CASE         #
  
          ARRAY  [0:10]  S(1);
              ITEM  NEWPATTERN   U(0, 0,60);     # NEW EDIT PATTERN    #
  
          DEF  LOOP          #AX=AX#; 
          DEF  INTLENOFREGB  #FIXEDCELL[FIXED"P1"]#;
          DEF  NUMLENOFREGC  #DN$NUMLEN[DX]#; 
          DEF  POINTOFREGC   #DN$POINT[DX]#;
CONTROL EJECT;
  
          PROC  GETCHAR;
  
#**       GETCHAR -  GET THE NEXT CHARACTER FROM OLD PATTERN
* 
*         GETCHAR 
* 
* 
*         SETS CHAR = NEXT CHARACTER. 
*         THE CALLER MUST ENSURE THAT GETCHAR IS NOT CALLED WITH
*           GC$NLEFT LQ 0.
# 
  
          BEGIN 
  
          IF GC$POS EQ 60  THEN 
              BEGIN 
              GC$INDEX = GC$INDEX + 1;
              T = VIRTUAL(TABLETYPE"PLTSTR$", GC$INDEX);
              GC$WORD = B<0,60>PLT$CHAR[T]; 
              GC$POS = 0; 
              END 
  
          CHAR = B<GC$POS,6>GC$WORD;
          GC$POS = GC$POS + 6;
          GC$NLEFT = GC$NLEFT - 1;
  
          END  #GETCHAR#
CONTROL EJECT;
  
          PROC  PUTCHAR;
  
#**       PUTCHAR -  PUT A CHARACTER INTO THE NEW EDIT PATTERN. 
* 
*         CHAR = CHARACTER TO BE ADDED. 
*         PUTCHAR 
* 
* 
*         ADDS CHAR TO NEWPATTERN.
# 
  
          BEGIN 
  
          IF PC$POS EQ 60  THEN 
              BEGIN 
              PC$INDEX = PC$INDEX + 1;
              PC$POS = 0; 
  
              $BEGIN
              IF PC$INDEX GR 10  THEN CGABORT("EDITPAT1");
              $END
  
              END 
  
          B<PC$POS,6>NEWPATTERN[PC$INDEX] = CHAR; 
          PC$POS = PC$POS + 6;
  
          END  #PUTCHAR#
CONTROL EJECT;
          PROC PUTCOMMAND(CODE, COUNT); 
  
#**       PUTCOMMAND -  PUT A COMMAND AND COUNT INTO EDIT PATTERN 
* 
*      GIVEN: 
*         CODE = EDIT COMMAND CODE
*         COUNT = REPETITION COUNT. 
* 
*      DOES:  
*         PUTS EITHER THE LONG FORM OR THE SHORT FORM INTO THE
*         EDITING DESCRIPTOR. 
# 
  
          BEGIN 
          ITEM  CODE         I; 
          ITEM  COUNT        I; 
  
          IF COUNT LQ 7  THEN 
              BEGIN 
              CHAR = CODE*8 + COUNT;
              PUTCHAR;
              END 
          ELSE
              BEGIN 
              CHAR = O"30" + CODE;
              PUTCHAR;
              CHAR = COUNT/O"100";
              PUTCHAR;
              CHAR = COUNT - (CHAR*O"100"); 
              PUTCHAR;
              END 
          END 
CONTROL EJECT;
          PROC  MODIFY; 
  
#**       MODIFY -  MODIFIES EDIT COMMAND TO INSERT LEADING ZEROS 
* 
*         CODE = TYPE OF EDIT COMMAND 
* 
*         MODIFY
* 
*         ALSO SETS ZZZCASE = FALSE IF JUSTIFIED. 
# 
  
          BEGIN 
  
          SWITCH  MODIFYSW
                  MODIFY$0   # COPY                                    #
               ,  MODIFY$1   # SIGN INSERTION                          #
               ,  MODIFY$2   # FIXED INSERTION                         #
               ,  MODIFY$3   # OVERPUNCH DIGIT                         #
               ,  MODIFY$4   # LEADING FLOAT INSERTION                 #
               ,  MODIFY$5   # FLOATING SIGN                           #
               ,  MODIFY$6   # FLOATING INSERTION                      #
               ,             # (UNUSED)                                #
               ;
  
          ITEM  COUNT        I;        # REPETITION COUNT FROM COMMAND #
  
  
          IF CODE EQ 3  THEN
              BEGIN 
              CODE = B<57,3>CHAR; 
              IF CODE NQ 1  THEN
                  BEGIN                # LONG COPY OR LONG INSERT      #
                  GETCHAR;
                  COUNT = CHAR * 2**6;
                  GETCHAR;
                  COUNT = COUNT + CHAR; 
                  END 
              ELSE
                  CODE = 3;            # OVERPUNCH DIGIT               #
              END 
          ELSE
              BEGIN 
              COUNT = B<57,3>CHAR;
              END 
  
          DESTLEN = DESTLEN + COUNT;
  
          IF CODE NQ 4  THEN           # IF CANNOT BE ZZZ              #
              ZZZCASE = FALSE;
  
          GOTO MODIFYSW[CODE];
  
  
 MODIFY$0:                             # COPY DIGITS                   #
          IF FLOATTYPE EQ 4  THEN 
              BEGIN 
              CHAR = O"40";                      # DECLARE FLOAT CHAR  #
              PUTCHAR;
              CHAR = FLOATCHAR; 
              PUTCHAR;
              CHAR = O"00";                      # REWRITE FLOAT CHAR  #
              PUTCHAR;
              FLOATTYPE = 0;           # DO NOT RE-DECLARE FLOAT CHAR  #
              CHAR = COUNT;                      # RESET ORIG. COMMAND #
              END 
          IF FLOATTYPE EQ 5  THEN 
              BEGIN 
              CHAR = O"50";                      # DECLARE SIGN FLOAT  #
              PUTCHAR;
              CHAR = PLUSCHAR;
              PUTCHAR;
              CHAR = MINUSCHAR; 
              PUTCHAR;
              CHAR = O"00";                      # REWRITE SIGN CHAR   #
              PUTCHAR;
              FLOATTYPE = 0;           # DO NOT RE-DECLARE SIGN CHARS  #
              CHAR = COUNT;                      # RESET ORIG. COMMAND #
              END 
  
          IF COUNT EQ 0  THEN          # IF NEED TO SET T-FLIP-FLOP    #
              BEGIN 
              PUTCHAR;
#*RETURN#     RETURN; 
              END 
  
          IF COUNT GR NCHANGES  THEN
              BEGIN 
              IF NCHANGES NQ 0  THEN
                  BEGIN 
                  PUTCOMMAND(2, NCHANGES);       # INSERT ZEROS        #
                  CHAR = CHAR$ZERO; 
                  PUTCHAR;
                  END 
              PUTCOMMAND(0, COUNT-NCHANGES);
              NCHANGES = 0; 
              END 
          ELSE
              BEGIN 
                  PUTCOMMAND(2, COUNT); 
              CHAR = CHAR$ZERO; 
              PUTCHAR;
              NCHANGES = NCHANGES - COUNT;
              END 
  
          RETURN; 
  
  
 MODIFY$1:                             # SIGN INSERTION                #
          PUTCHAR;
          GETCHAR;
          PUTCHAR;
          GETCHAR;
          PUTCHAR;
          RETURN; 
  
  
 MODIFY$2:                             # FIXED INSERTION               #
          PUTCOMMAND(2, COUNT); 
          GETCHAR;
          PUTCHAR;
          IF CHAR EQ CCTDECPOINT  THEN
              BEGIN 
              BCPASTERS = 31 - DESTLEN; 
              $BEGIN
              IF COUNT NQ 1  THEN 
                  CGABORT("EDITPAT-2"); 
              $END
              END 
          RETURN; 
  
  
MODIFY$3:                              # OVERPUNCH DIGIT               #
          PUTCHAR;                     # (CANNOT HAVE NCHANGES NQ 0)   #
          RETURN; 
  
  
                                       # INCLUDES INSERTING 1 LEFT-FILL#
                                       # AND DECREASING FLOAT COUNT    #
 MODIFY$4:                             # LEADING FLOAT INSERTION       #
          GETCHAR;
          FLOATCHAR = CHAR; 
          FLOATTYPE = 4;
          IF STARTFLOAT 
           AND FLOATCHAR NQ LEFTFILLCHAR  THEN
              BEGIN 
              NCHANGES = NCHANGES + 1;
              END 
          STARTFLOAT = FALSE; 
          IF COUNT GR NCHANGES  THEN
              BEGIN 
              IF NCHANGES NQ 0  THEN
                  BEGIN 
                  CHAR = O"20" + NCHANGES;       # INSERT LEFT-FILLS   #
                  PUTCHAR;
                  CHAR = LEFTFILLCHAR;
                  PUTCHAR;
                  COUNT = COUNT - NCHANGES; 
                  NCHANGES = 0; 
                  END 
              IF COUNT NQ 0  THEN 
                  BEGIN 
                  CHAR = O"40" + COUNT;          # LEADING FLT. INSERT #
                  PUTCHAR;
                  CHAR = FLOATCHAR; 
                  IF CHAR NQ CHAR$BLANK  THEN 
                      ZZZCASE = FALSE;
                  PUTCHAR;
                  FLOATTYPE = 0;       # DO NOT RE-DECLARE FLOAT CHARS #
                  END 
              ELSE
                  BEGIN 
                  IF FLOATCHAR NQ CHAR$BLANK  THEN
                      ZZZCASE = FALSE;
                  END 
              END 
          ELSE
              BEGIN 
              IF FLOATCHAR NQ CHAR$BLANK  THEN
                  ZZZCASE = FALSE;
              CHAR = O"20" + COUNT;              # INSERT LEFT-FILLS   #
              PUTCHAR;
              CHAR = LEFTFILLCHAR;
              PUTCHAR;
              NCHANGES = NCHANGES - COUNT;
              END 
  
          RETURN; 
  
  
 MODIFY$5:                             # FLOATING SIGN INSERTION       #
          FLOATTYPE = 5;
          IF STARTFLOAT  THEN 
              BEGIN 
              NCHANGES = NCHANGES + 1;
              STARTFLOAT = FALSE; 
              END 
          IF COUNT GR NCHANGES  THEN
              BEGIN 
              IF NCHANGES NQ 0  THEN
                  BEGIN 
                  CHAR = O"20" + NCHANGES;       # INSERT BLANKS       #
                  PUTCHAR;
                  CHAR = CHAR$BLANK;
                  PUTCHAR;
                  COUNT = COUNT - NCHANGES; 
                  NCHANGES = 0; 
                  END 
              IF COUNT NQ 0  THEN 
                  BEGIN 
                  CHAR = O"50" + COUNT;          # FLOATING SIGN       #
                  PUTCHAR;
                  GETCHAR;                       # POSITIVE CHARACTER  #
                  PLUSCHAR = CHAR;
                  PUTCHAR;
                  GETCHAR;                       # NEGATIVE CHARACTER  #
                  MINUSCHAR = CHAR; 
                  PUTCHAR;
                  FLOATTYPE = 0;       # DO NOT RE-DECLARE SIGN CHARS  #
                  END 
              ELSE
                  BEGIN 
                  GETCHAR;                       # SKIP POS. CHARACTER #
                  GETCHAR;                       # SKIP NEG. CHARACTER #
                  END 
              END 
          ELSE
              BEGIN 
              CHAR = O"20" + COUNT;              # INSERT BLANKS       #
              PUTCHAR;
              CHAR = CHAR$BLANK;
              PUTCHAR;
              GETCHAR;                           # SKIP PARAMETERS     #
              PLUSCHAR = CHAR;
              GETCHAR;
              MINUSCHAR = CHAR; 
              NCHANGES = NCHANGES - COUNT;
              END 
  
          RETURN; 
  
  
 MODIFY$6:                             # FLOATING INSERTION            #
          IF  NCHANGES NQ 0  THEN 
              BEGIN 
              CHAR = O"20" + COUNT;              # INSERT LEFT-FILLS   #
              PUTCHAR;
              CHAR = LEFTFILLCHAR;
              PUTCHAR;
              GETCHAR;                           # SKIP ORIG. INSERT   #
              END 
          ELSE
              BEGIN 
              PUTCHAR;
              GETCHAR;
              PUTCHAR;
              END 
          RETURN; 
  
          END  #MODIFY# 
CONTROL EJECT;
  
          PROC SETPATTERN;
  
#**       SETPATTERN -  SET EDIT PATTERN FOR NUMERIC-ONLY ITEM WITH BWZ 
* 
# 
  
          BEGIN 
          ITEM  I            I;        # SCRATCH                       #
  
          GC$WORD = O"55070704000000000000";
          I = DN$NUMLEN[DX];
  
          IF I LQ 7  THEN 
              BEGIN 
              B<9,3>GC$WORD = I;
              GC$NLEFT = 2; 
              END 
          ELSE
              BEGIN 
              IF I LQ 14  THEN
                  BEGIN 
                  B<15,3>GC$WORD = I-7; 
                  GC$NLEFT = 3; 
                  END 
              ELSE
                  BEGIN 
                  B<21,3>GC$WORD = I-14;
                  GC$NLEFT = 4; 
                  END 
              END 
  
          IF DN$SCHAR[DX] EQ 1  THEN
              BEGIN 
              IF DN$LSIGN[DX] EQ 1  THEN
                  BEGIN                          # LEADING SEPARATE    #
                  I = B<6,24>GC$WORD; 
                  B<6,18>GC$WORD = O"114546";    # SIGN, +, -          #
                  B<24,24>GC$WORD = I;
                  GC$NLEFT = GC$NLEFT + 3;
                  END 
              ELSE
                  BEGIN                          # TRAILING SEPARATE   #
                  B<6*GC$NLEFT,18>GC$WORD = O"114546";
                  GC$NLEFT = GC$NLEFT + 3;
                  END 
              END 
          ELSE
              BEGIN 
              IF DN$SIGNBIT[DX] EQ 1  THEN
                  BEGIN                          # OVERPUNCH SIGN      #
                  B<9,3>GC$WORD = B<9,3>GC$WORD - 1;
                  IF DN$LSIGN[DX] EQ 1  THEN
                      BEGIN                      # LEADING OVERPUNCH   #
                      I = B<6,24>GC$WORD; 
                      B<6,6>GC$WORD = O"31";     # OVERPUNCH DIGIT     #
                      B<12,24>GC$WORD = I;
                      GC$NLEFT = GC$NLEFT + 1;
                      END 
                  ELSE
                      BEGIN                      # TRAILING OVERPUNCH  #
                      B<6*GC$NLEFT,6>GC$WORD = O"31";      # OVERPUNCH #
                      GC$NLEFT = GC$NLEFT + 1;
                      END 
                  END 
              END 
  
          GC$POS = 0; 
          BWZ = 1;                               # NOTE BLANK WHEN ZERO#
          END  #SETPATTERN# 
CONTROL EJECT;
  
#      BEGIN EXECUTION OF EDITPAT                                      #
  
          T = REGDNATADDR[FIXEDCELL[FIXED"REGC"]];
          DX = VIRTUAL(TABLETYPE"DNAT$", T);
          AX = 0; 
  
          T = DN$AUXREF[DX];
          IF T EQ 0  THEN 
              BEGIN 
              SETPATTERN; 
              GOTO EDITPAT1;                     # *GETCHAR* IS READY  #
              END 
          AX = VIRTUAL(TABLETYPE"AUX$", T); 
          FOR PX=PX  WHILE AX$TTYPE[AX] NQ EDITINFO  DO 
              BEGIN 
              T = AX$TNEXTPTR[AX];
              IF T EQ 0  THEN 
                  BEGIN 
                      AX = 0; 
                  SETPATTERN; 
                  GOTO EDITPAT1;                 # *GETCHAR* IS READY  #
                  END 
              AX = VIRTUAL(TABLETYPE"AUX$", T); 
              END 
  
          PX = VIRTUAL(TABLETYPE"PLT$", AX$PATTOFFS[AX]); 
          BWZ = AX$TBWZ[AX];
  
          GC$NLEFT = PL$LENGTH[PX]; 
          GC$INDEX = PL$STRINGPTR[PX] - 1;       # HAVE GETCHAR        #
          GC$POS = 60;                           #   PRIME ITSELF      #
  
#      *GETCHAR* IS READY TO USE                                       #
  
 EDITPAT1:  
  
          TYPEOFREGC = DN$TYPE[DX];             # NUMEDIT OR ALPHA    # 
  
          IF TYPEOFREGC EQ NUMEDIT  THEN
              BEGIN 
              ZZZCASE = TRUE;                    # MAY BE ZZZ CASE     #
  
              IF POINTOFREGC NQ 0  THEN 
                  ZZZCASE = FALSE;
  
              INTLENOFREGC = NUMLENOFREGC - POINTOFREGC;
  
              IF INTLENOFREGB GQ INTLENOFREGC  THEN 
                  NCHANGES = 0; 
              ELSE
                  NCHANGES = INTLENOFREGC - INTLENOFREGB; 
              END 
          ELSE
              BEGIN 
              ZZZCASE = FALSE;                   # NOT ZZZ CASE        #
              NCHANGES = 0;                      # DO NOT MODIFY PATT. #
              END 
  
          GETCHAR;                               # LEFT-FILL CHARACTER #
  
          B<0,6>NEWPATTERN[0] = CHAR; 
          LEFTFILLCHAR = CHAR;                   # SAVE FOR MODIFY$4   #
  
#**********************************************************************#
#                                                                      #
#    *** BELOW CODE SHOULD BE REMOVED WHEN RIGHT-FILL CHAR ***         #
#    *** IS PUT IN EDIT PATTERN WHERE IT BELONGS *************         #
#                                                                      #
# #       IF TYPEOFREGC EQ NUMEDIT  THEN                             # #
# #           CHAR = CHAR$ZERO;                                      # #
# #       ELSE                                                       # #
# #           CHAR = CHAR$BLANK;                                     # #
#**********************************************************************#
#         GETCHAR                                  RIGHT-FILL CHAR.    #
          B<6,6>NEWPATTERN[0] = CHAR; 
          B<30,1>NEWPATTERN[0] = BWZ; 
  
          IF REGGSCODE[FIXEDCELL[FIXED"REGC"]] EQ 0  THEN  # IF SUBSCR #
              BEGIN 
              B<32,4>NEWPATTERN[0] = REGCHARPOS[FIXEDCELL[FIXED"REGC"]];
              B<12,18>NEWPATTERN[0] =     # CONSTANT SUBSCRIPT# 
                             REGWORDINDX[FIXEDCELL[FIXED"REGC"]]; 
              END 
          ELSE                                   # IF SUBSCRIPTED      #
              BEGIN 
              B<32,4>NEWPATTERN[0] = 0; 
              B<12,18>NEWPATTERN[0] = 0;
              END 
  
          PC$INDEX = 0;                          # PRIME PUTCHAR       #
          PC$POS = 36;
          STARTFLOAT = TRUE;           # MODIFY FIRST FLOAT COMMAND    #
          FLOATTYPE = 0;
  
          BCPASTERS = 0;
          DESTLEN = 0;
  
          FOR LOOP WHILE GC$NLEFT NQ 0  DO
              BEGIN 
              GETCHAR;
              CODE = B<54,3>CHAR; 
              MODIFY; 
              END 
  
          IF AX NQ 0 AND AX$TASTFILL [AX] EQ 1 THEN 
              BEGIN 
              CHAR = O"71"; 
              PUTCHAR;
              IF CCTDECPOINT EQ CHAR$COMMA  THEN
                  CHAR = 31 + BCPASTERS;
              ELSE
                  CHAR = BCPASTERS; 
              PUTCHAR;
              $BEGIN
              IF DESTLEN NQ DN$ITMLEN[DX]  THEN 
                  CGABORT("EDITPAT-1"); 
              $END
              CHAR = DESTLEN; 
              PUTCHAR;
              END 
          ELSE
              BEGIN 
              CHAR = O"70"; 
              PUTCHAR;
              END 
  
          IF TYPEOFREGC EQ NUMEDIT  THEN         # IF NUMERIC-EDITED   #
              BEGIN 
              IF INTLENOFREGB LQ INTLENOFREGC  THEN 
                  T = INTLENOFREGB; 
              ELSE
                  T = INTLENOFREGC; 
              IF T GR 8  THEN 
                  ZZZCASE = FALSE;
              IF INTLENOFREGC GR 10  THEN 
                  ZZZCASE = FALSE;
              END 
  
          IF ZZZCASE  THEN
              FIXEDCELL[FIXED"P1"] = 60 - 6*T;   # INDICATE ZZZ CASE   #
          ELSE
              BEGIN 
  
#          DO NOT SPECIFY AN ADDRESS IF SUBSCRIPTED                    #
              IF REGGSCODE[FIXEDCELL[FIXED"REGC"]] EQ 0  THEN 
                  FIXEDCELL[FIXED"P1"] =
                    1 + REGDNATADDR[FIXEDCELL[FIXED"REGC"]];
              ELSE
                  FIXEDCELL[FIXED"P1"] = 1; 
              FIXEDCELL[FIXED"P2"] = LOC(NEWPATTERN[0]);
              FIXEDCELL[FIXED"P3"] = 2;          # ADDRESS IN C<2,3>   #
              T = REGDNATADDR[FIXEDCELL[FIXED"REGT"]];
              DX = VIRTUAL(TABLETYPE"DNAT$", T);
              DN$CHARPOS[DX] = 0; 
          REGCHARPOS[FIXEDCELL[FIXED"REGT"]] = 0; 
              DN$ITMLEN[DX] = 10*PC$INDEX + PC$POS/6; 
              LITPOOL;                 # SET (FWA$OF,REGT) TO PATTERN  #
              FIXEDCELL[FIXED"P1"] = 0;          # COMPLICATED CASE    #
              END 
  
          END 
          TERM
