*DECK SET10 
USETEXT CCTTEXT 
USETEXT DNTEXT
USETEXT PPTEXT
    PROC SET10; 
         CONTROL PACK;
         BEGIN
*CALL DPPPDDATA 
*CALL PPCOMMON2 
*CALL RCT 
*CALL DNATVALS
*CALL AUXTVALS
*CALL FNATVALS
*CALL PLTVALS 
          $BEGIN
          XREF ITEM DBUG$STK$TRC  B;   # DEBUG STACK TRACE             #
          XREF PROC OUTPUT;            # OUTPUT TO LISTING FILE        #
          $END
         ITEM   ISLABEL;
         SWITCH SUB    #SUB0#,
         SUB1 , SUB2 , SUB3 , SUB4 , SUB5 , 
         SUB6 , SUB7 , SUB8 , SUB9, SUB10,
         SUB11, SUB12, SUB13, SUB14, SUB15, 
         SUB16, SUB17, SUB18, SUB19, SUB20, 
         SUB21, SUB22,      , SUB24, SUB25, 
         SUB26, SUB27, SUB28, SUB29,      , 
         SUB31, SUB32, SUB33, SUB34, SUB35; 
    PROC PERFORMDEBUG(LOCC);
          BEGIN 
          #PREPARES THE GTEXT FOR PERFORMING THE DEBUGGING PROCS.#
          ITEM  LOCC  I;
          NG($PERFORM); 
          FIX1 = GET(AX$DEBUGPROC,AUX$,LOCC); 
          NGPROCREF(FIX1,0);
          NGPROCREF(FIX1,0);
          NGLABELREF((NEXTPNAT),0); 
          NGLABELDEF(PNATLENGTH); 
          END #PERFORMDEBUG#
    PROC DEBUGFILL; 
          BEGIN 
          #IT FILLS DEBUG-ITEM WITH SPACES AND STORES THE#
          #STATEMENT LINE IN DEBUG-LINE.# 
          NGMOVE; 
          NGLITREF(DLATSPACE);
          NGDATAREF(DEBUGITEM); 
          NGMOVE; 
          LATTEMP=VERBLINE; 
          REG1=DEBUGLINE; 
          NG(CREATELDL(REG1,1));
          SET(L$VCODE,LAT$,LATLENGTH,2);
          NGDATAREF(DEBUGLINE); 
          END #DEBUGFILL# 
    PROC MOVEGTEXT(GANO); 
          BEGIN 
          # IT REMOVES A PART OF THE GTEXT IN ORDER TO LEAVE #
          # SPACE FOR THE DEBUGGING GTEXT.                   #
          #GANO IS THE NUMBER OF PLACES THAT MUST BE MADE AVAILABLE#
          ITEM GANO           I;
          FOR REG1 = G STEP -1 UNTIL DPATCH 
               DO  SETGT(REG1+GANO,GETGT(REG1));
          G = DPATCH - 1; 
          END  #REMOVEGTEXT#
    FUNC LITERALVALUE(PLTPOINTER);
          # THIS FUNCTION CALCULATES THE VALUE OF A LITERAL # 
          # PLTPOINTER POINTS TO THE PLT ENTRY FOR THIS LITERAL # 
          BEGIN 
          ITEM PLTPOINTER        I; 
          ITEM LVALUE            I; 
          LVALUE = 0; 
          FOR REG1=1 STEP 1 UNTIL GET(PL$LENGTH,PLT$,PLTPOINTER)
          DO
            LVALUE = 10 * LVALUE + PLTCHARACTER(PLTPOINTER,REG1)
                           - "0"; 
          LITERALVALUE = LVALUE;
          RETURN; 
          END   #LITERALVALUE#
  
     PROC STDEBUGELEM( (DA), MODE); 
  
          #THIS PROCEDURE STACKS THE DATA-NAMES FOR WHICH DEBUGGING   # 
          #MUST BE DONE AFTER THE PARSING OF THE STATEMENT, IN A STACK# 
          #IT STACKS ALSO IN THE SAME STACK THE SUBSCRIPTS ASSOCIATED # 
          #WITH THAT DATA-NAME.                                       # 
          #DA     THE ADDRESS OF THE DATA-NAME TO BE STACKED      # 
          #MODE   DENOTES THE TYPE OF PROCESSING REQUIRED         # 
  
  
          # MODE=0 A DATA-NAME FOR WHICH DEBUGGING MUST BE DONE HAS    #
          #        BEEN ENCOUNTERED.                                   #
          #        IF IT IS A SUBSCRIPTED DATA-NAME STORE IT IN A TEMP #
          #        UNTIL ALL ITS SUBSCRIPTS ARE PARSED. IF IT IS A     #
          #        SIMPLE DATA-NAME AND IS NOT ALREADY IN THE STACK,   #
          #        CHECK IF ALL ITS REFERENCES MUST BE DEBUGGED. IF YES#
          #        PUT IT IN THE STACK, ELSE STORE IT IN A TEMP UNTIL  #
          #        YOU FIND OUT THAT IT IS A RECEIVING FIELD.          #
  
          # MODE=1 THE DATA-NAME PREVIOUSLY PARSED IS A RECEIVING FIELD#
          #        IF IT IS ALREADY IN THE STACK RETURN, ELSE CHECK IF #
          #        IT IS THE SAME WITH THE DATA-NAME STORED IN THE TEMP#
          #        IN THAT CASE PUT IT IN THE STACK NOW.               #
          #        IF THIS DATA-NAME IS THE SUBSCRIPT OF A DATA-NAME   #
          #        STACKED ALREADY IN THE STACK TURN THE SUBSCRIPT     #
          #        RECEIVING FIELD FLAG ON.                            #
          # MODE=2 THE SUBSCRIPT OF A DATA-NAME FOR WHICH DEBUGGING    #
          #        MUST BE DONE HAS BEEN ENCOUNTERED.                  #
          #        STORE THE SUBSCRIPT AND ALL NECESSARY INFORMATION   #
          #        IN A TEMP FOR LATER USE.                            #
          # MODE=3 THE PARSING OF A SUBSCRIPTED DATA-NAME IS FINISHED  #
          #        SEARCH THE STACK AND IF IT IS ALREADY THERE RETURN, #
          #        ELSE CHECK IF ALL ITS REFERENCES MUST BE DEBUGGED.  #
          #        IF YES PUT IT IN THE STACK, ELSE LEAVE IT IN THE    #
          #        TEMP UNTIL YOU FIND OUT THAT IT IS A RECEIVING FIELD#
          BEGIN 
          ITEM DA                I; 
          ITEM MODE              I; 
          ITEM I                 I; 
          ITEM J                 I; 
          SWITCH STMODE MODE0, MODE1, MODE2, MODE3; 
  
          $BEGIN
          IF DBUG$STK$TRC THEN
              OUTPUT(5," STDEBUGEL","EM   DA = ",DEC(DA), 
                       "   MODE = ",DEC(MODE)); 
          $END
          GOTO STMODE[MODE];
MODE0:  
          IF GET(DN$SDEPTH,DNAT$,DA) EQ 0 
          THEN BEGIN
               # A SIMPLE DATA-NAME IS ENCOUNTERED #
               # SEARCH THE STACK AND IF IT IS ALREADY THERE RETURN # 
               FOR I = 1 WHILE I  NQ  DS + 1
               DO BEGIN 
                  TEMP1 = DEBUGELEMENT(I);
                  TEMP = B<30,15>TEMP1; 
                  IF TEMP EQ DA 
                  THEN RETURN;
                  ELSE I = B<54,6>TEMP1;
                  END 
          # THE DATA-NAME IS NOT IN THE STACK # 
          # STACK IT IN THE STACK NOW # 
               DS = DS + 1; 
               TEMP = 0;
               B<30,15>TEMP = DA; 
               B<54,6>TEMP = DS + 1;
               XDBUGELEMENT(DS,TEMP); 
               RETURN;
               END
          # A SUBSCRIPTED DATA-NAME IS ENCOUNTERED. STORE IT IN THE # 
          # TEMPORARY LOCATION DELEM UNTIL ALL ITS SUBSCRIPTS ARE    #
          # PARSED.                                                 # 
          DELEM = DA; 
          DSCOUNT = 0;
          RETURN; 
MODE1:  
          # IF THE ENCOUNTERED DATA-NAME IS ALREADY IN THE STACK    # 
          # TURN ITS RECEIVING FIELD FLAG ON.                       # 
          # IF THE ENCOUNTERED DATA-NAME IS THE SUBSCRIPT  #
          # OF A DATA-NAME STACKED ALREADY IN THE STACK    #
          # TURN THE SUBSCRIPT RECEIVING FIELD FLAG ON.    #
  
          FOR I = 1 STEP 1 UNTIL DS 
          DO BEGIN
             TEMP1 = DEBUGELEMENT(I); 
             TEMP = B<30,15>TEMP1;     #DNAT POINTER OF THE DATA-NAME#
             IF TEMP EQ DA
             THEN BEGIN 
                  # TURN THE RECEIVING FIELD FLAG ON #
                  B<51,3>TEMP1 = 1; 
                  XDBUGELEMENT(I,TEMP1);
                  END 
             TEMP2 = B<45,6>TEMP1;     # NUMBER OF SUBSCRIPTS # 
             IF TEMP2 NQ 0
             THEN BEGIN 
                  I = I + 1;
                  FOR J = 1 STEP 1 UNTIL TEMP2
                  DO BEGIN
                     I = I + 1; 
                     TEMP1 = DEBUGELEMENT(I); 
                     REG3 = B<33,15>TEMP1;    #THE SUBSCRIPT ADDRESS# 
                     IF REG3 EQ DA
                     THEN BEGIN 
                          # THE ENCOUNTERED DATA-NAME IS THE #
                          # SUBSCRIPT OF A DATA-NAME STACKED #
                          # ALREADY IN THE STACK.            #
                          B<51,3>TEMP1 = 1; 
                          XDBUGELEMENT(I,TEMP1);
                          END 
                     IF B<48,3>TEMP1 EQ 1 
                     THEN I = I + 1;
                     END
                   END
             END
  
          RETURN; 
MODE2:  
          IF DELEM EQ 0 THEN RETURN;
  
          # THE SUBSCRIPT OF A DATA-NAME IS ENCOUNTERED, STORE IT#
          # WITH ALL REQUIRED INFORMATION IN A TEMPORARY LOCATION#
  
          IF RELINDEXFLAG EQ 0
          THEN BEGIN
               # NOT A RELATIVE INDEX # 
               DSCOUNT = DSCOUNT + 1; 
               SUBSTYPE[DSCOUNT] = SSTYPE;
               SUBSADR[DSCOUNT] = DA; 
               LITSIGN[DSCOUNT] = 0;
               LITADR[DSCOUNT] = 0; 
               END
          ELSE BEGIN
               # A RELATIVE INDEX # 
               LITSIGN[DSCOUNT] = RELINDEXFLAG; 
               LITADR[DSCOUNT] = DA;
               END
          RETURN; 
MODE3:  
          IF DELEM EQ 0 THEN RETURN;
  
          # THE PARSING OF A SUBSCRIPTED DATA-NAME IS FINISHED    # 
          # SEARCH THE DEBUG STACK AND IF THE DATA-NAME IS NOT     #
          # THERE OR IT IS BUT ITS SUBSCRIPTS HAVE BEEN MODIFIED   #
          # THEN STACK IT IN THE STACK NOW.                        #
  
          FOR I = 1 STEP 1 UNTIL DS 
          DO BEGIN
             REG2 = DEBUGELEMENT(I);
             REG3 = B<45,6>REG2;     # NUMBER OF SUBSCRIPTS # 
             REG2 = B<30,15>REG2;    # DNAT POINTER        #
             IF REG2 EQ DELEM 
             THEN BEGIN 
                  # THE SUBSCRIPTED DATA-NAME IS ALREADY IN THE STACK#
                  # CHECK IF THE SUBSCRIPTS ARE THE SAME #
                  IF REG3 EQ DSCOUNT
                  THEN BEGIN
                       REG10 = 0; 
                       I = I + 1; 
                       FOR J = 1 STEP 1 UNTIL DSCOUNT 
                       DO BEGIN 
                          I = I + 1;
                          REG2 = DEBUGELEMENT(I); 
                          #CHECK IF THE SUBSCRIPT IN THE STACK HAS #
                          #BEEN A RECEIVING FIELD.                 #
                          IF B<51,3>REG2 EQ 1 THEN REG10 = 1; 
                          REG5 = B<30,3>REG2;    # SUBSCRIPT TYPE # 
                          REG6 = B<33,15>REG2;   # SUBSCRIPT DNAT PTR#
                          IF REG5 EQ SUBSTYPE[J] AND
                             REG6 EQ SUBSADR[J] 
                          THEN BEGIN
                               IF B<48,3>REG2 EQ 1
                               THEN BEGIN 
                                    # A RELATIVE INDEX SUBSCRIPT #
                                    I = I + 1;
                                    REG2 = DEBUGELEMENT(I); 
                                    REG5 = B<30,3>REG2; #LITERAL SIGN#
                                    REG6 = B<33,15>REG2; #PLT POINTER#
                                    IF REG5 NQ LITSIGN[J] 
                                    THEN REG10 = 1; 
                                    ELSE BEGIN
                                         # CALCULATE THE LITERAL VALUES#
                                         REG8=LITERALVALUE(REG6); 
                                         REG9=LITERALVALUE(LITADR[J]);
                                         IF REG8 NQ REG9
                                         THEN REG10 = 1;
                                         END
                                    END 
                                ELSE IF LITSIGN[J] NQ 0 THEN REG10 = 1; 
                                END 
                          ELSE REG10 = 1; 
                          END 
                       IF REG10 EQ 0
                       THEN 
                            # THE ENCOUNTERED DATA-NAME IS ALREADY IN # 
                            # THE STACK WITH EXACTLY THE SAME SUBSCR. # 
                            # AS THE ONES IN THE TEMPORARY LOCATION   # 
                            # AND NONE OF THIS SUBSCRIPTS HAS BEEN A  # 
                            # RECEIVING FIELD. DO NOT STACK THIS      # 
                            # DATA-NAME IS ALREADY THERE.             # 
                            GOTO LL2; 
                       END
                  END 
  
             END
          # THE SUBSCRIPTED DATA-NAME IS NOT IN THE STACK # 
          REG10 = DS + 1; 
          # STACK THE SUBSCRIPTS AND THE NECESSARY INFORMATION #
          DS = DS + 2;
          TEMP = 0; 
          B<30,15>TEMP = MODIFIER [MD];     #M-NUMBER FOR SUB CALC #
          B<45,15>TEMP = COUNTINDEX[MD]; #PTR TO THE REFERENCE COUNT# 
          XDBUGELEMENT(DS,TEMP);
          FOR I = 1 STEP 1 UNTIL DSCOUNT
          DO BEGIN
             DS = DS + 1; 
             TEMP = 0;
             B<30,3>TEMP = SUBSTYPE[I];     #SUBSCRIPT TYPE # 
             B<33,15>TEMP = SUBSADR[I];     # SUBSCRIPT DNAT POINTER #
             IF LITSIGN[I] EQ 0 
             THEN XDBUGELEMENT(DS,TEMP);
             ELSE BEGIN 
                  B<48,3>TEMP = 1;
                  XDBUGELEMENT(DS,TEMP);
                  DS = DS + 1;
                  TEMP = 0; 
                  B<30,3>TEMP = LITSIGN[I];    # LITERAL SIGN # 
                  B<33,15>TEMP = LITADR[I];    # LITERAL PLT POINTER #
                  XDBUGELEMENT(DS,TEMP);
                  END 
             END
          # STACK THE DATA-NAME # 
          TEMP = 0; 
          B<30,15>TEMP = DELEM;      # DATA-NAME DNAT POINTER # 
          B<45,6>TEMP = DSCOUNT;     # NUMBER OF SUBSCRIPTS # 
          B<54,6>TEMP = DS + 1;      # NEXT ENTRY POINTER # 
          XDBUGELEMENT(REG10,TEMP); 
    LL2:  
          FOR J = 1 STEP 1 UNTIL DSCOUNT
          DO BEGIN
             SUBSTYPE[J] = 0; 
             SUBSADR[J] = 0;
             LITSIGN[J] = 0;
             LITADR[J] = 0; 
             END
          DELEM = 0;
          DSCOUNT = 0;
          RETURN; 
         END   #STDEBUGELEM#
  
    PROC MOVESUBS( DEBUGSUBS);
  
          # THIS PROCEDURE IS CALLED WHEN A SUBSCRIPTED OR INDEXED #
          # DATA-NAME CAUSES THE DEBUGGING SECTION TO BE EXECUTED  #
          # IN ORDER TO MOVE THE OCCURRENCE NUMBER OF EACH LEVEL   #
          # IN THE APPROPRIATE FIELDS OF THE SPECIAL REGISTER      #
          # DEBUG-ITEM.                                            #
  
          BEGIN 
            ITEM  DEBUGSUBS                I; 
            ITEM  STYPE                    I; 
            ITEM  DSENTRY                  I; 
            ITEM  LFLAG                    I; 
            ITEM  LSIGN                    I; 
            SWITCH SUBTYPE  #NONE#, DATANAME, LITERAL, INDEXNAME; 
  
          TEMP = DEBUGELEMENT(REG1);
          STYPE = B<30,3>TEMP;      #THE SUBSCRIPT TYPE # 
          LFLAG = B<48,3>TEMP;      #RELATIVE INDEX FLAG# 
          DSENTRY = B<33,15>TEMP;      #SUBSCRIPT ADDRESS#
  
  
          GOTO SUBTYPE[STYPE];
  
DATANAME: 
          # THE SUBSCRIPT IS A DATA-NAME #
          NGMOVE; 
          NGDATAREF(DSENTRY); 
          NGDATAREF(DEBUGSUBS); 
          RETURN; 
LITERAL:  
          # THE SUBSCRIPT IS A LITERAL #
          LATTEMP = DSENTRY;
          NGMOVE; 
          NGLITREF((NEXTLAT));
          NGDATAREF(DEBUGSUBS); 
          #COPY THE RECEIVING FIELD DNAT INTO THE LITERAL DNAT# 
          LITERALDNAT(DEBUGSUBS,GET(L$DNAT,LAT$,LATLENGTH));
          #SET UP VERBCODE FOR MOVE # 
          SET(L$VCODE,LAT$,LATLENGTH,2);
          RETURN; 
INDEXNAME:  
          # THE SUBSCRIPT IS AN INDEX-NAME #
          NG($SET); 
          NG($SETTO); 
          NGDATAREF(DSENTRY); 
          NGDATAREF(DEBUGSUBS); 
          IF LFLAG EQ 1 
          THEN BEGIN
               #THE SUBSCRIPT IS A RELATIVE INDEX, AN INTEGER LITERAL#
               #IS ADDED TO THE INDEX-NAME.                          #
               REG1 = REG1 + 1; 
               DSENTRY = DEBUGELEMENT(REG1);
               DSENTRY = B<33,15>DSENTRY; 
               NG($ADD);
               LATTEMP = DSENTRY; 
               NGLITREF((NEXTLAT)); 
               #COPY THE RECEIVING FIELD DNAT INTO THE LITERAL DNAT#
               LITERALDNAT(DEBUGSUBS,GET(L$DNAT,LAT$,LATLENGTH)); 
               NGDATAREF(DEBUGSUBS);
               NGDATAREF(DEBUGSUBS);
               END
          RETURN; 
          END #MOVESUBS#
  
          GOTO SUB[SUB$]; 
  
SUB26:  
#DEBUG MOD INITIALIZATION#
          IF NOT CCTDEBUGMODE[0]
          THEN RETURN;
               LATTEMP=0; 
               DLATSPACE=NEXTLAT; 
               SET(L$SPACES,LAT$,LATLENGTH,1);
               SET(L$IMMEDIATE,LAT$,LATLENGTH,1); 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTSTARTPROG;
               DLATSPROGRAM=NEXTLAT;
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTFALLTHRU; 
               DLATFTHROUGH=NEXTLAT;
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTUSEPROC;
               DLATUSEPROC=NEXTLAT; 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTPERFLOOP; 
               DLATPLOOP=NEXTLAT; 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTSORTINPUT;
               DLATSORTINP=NEXTLAT; 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTSORTOUT;
               DLATSORTOUT=NEXTLAT; 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               LATTEMP=PLTMERGEOUT; 
               DLATMERGEOUT=NEXTLAT;
          SET(L$VCODE,LAT$,LATLENGTH,2);
          RETURN; 
SUB8: 
#USE FOR DEBUG SPECIAL REGISTER#
          REG1 = VALUE$;
          GOTO SSREG; 
SUB1: 
#USE FOR DEBUG IDENTIFIER#
          DEBUGMODE=0;
          GOTO DEBUGIDENT;
SUB4: 
#USE FOR DEBUG ALL IDENT# 
          DEBUGMODE=1;
DEBUGIDENT: 
          PATCH=0;
          IF STACK(S) EQ SUBMARKER
          THEN S=STACK(S-1)-1;
          #RESTORE THE NUMBER OF SUBSCRIPTS#
          SET(DN$SDEPTH,DNAT$,TEMP1,TEMP2); 
          REG1=TPOINTER(S); 
SSREG:  
          IF REG1  NQ 0  AND GET(DN$TYPE,DNAT$,REG1) NQ ERRTYPE 
          THEN BEGIN
               #CHECK FOR NON DATA ITEMS# 
               IF GET(DN$TYPE,DNAT$,REG1) EQ NONDATA
               THEN BEGIN 
                    FIX1 = GET(DN$LEVEL,DNAT$,REG1);
                    IF FIX1  NQ  FDDESCR  AND 
                       FIX1  NQ  SDDESCR  AND 
                       FIX1  NQ  CDDESCR
                    THEN BEGIN
                         ERROR(SEVERE,802,TABLELINE,TABLECOLUMN); 
                         RETURN;
                         END
                    END 
               #COMPARE DEBUG-ITEM LENGTH WITH THE IDENTIFIER LENGTH# 
               #AND UPDATE, IF NECESSARY.#
               TEMP1=GET(DN$ITMLEN,DNAT$,DEBUGCONTS); 
               TEMP2=GET(DN$ITMLEN,DNAT$,REG1); 
               #IN THE CASE OF A FILE NAME COMPARE WITH#
               #THE RECORD LENGTH.# 
               FIX1 = GET(DN$LEVEL,DNAT$,REG1); 
               IF FIX1 EQ FDDESCR OR
                  FIX1 EQ SDDESCR 
               THEN BEGIN 
                    REG3=GET(DN$FNATPTR,DNAT$,REG1);
                    TEMP2=GET(FN$ACCUMMAX,FNAT$,REG3);
                    END 
               IF TEMP1  LS  TEMP2
               THEN BEGIN 
                    TEMP1=TEMP2-TEMP1;
                    FIX1 = GET(DN$ITMLEN,DNAT$,DEBUGCONTS)+TEMP1; 
                    SET(DN$ITMLEN,DNAT$,DEBUGCONTS,FIX1); 
                    FIX1 = GET(DN$ITMLEN,DNAT$,DEBUGITEM)+TEMP1;
                    SET(DN$ITMLEN,DNAT$,DEBUGITEM,FIX1);
                    I=SREGMSEC; 
                    CCTMSECLEN[I]=CCTMSECLEN[I]+TEMP1;
                    END 
               #ATTACH A DEBUG AUX ENTRY# 
               SET(DN$DEBUG,DNAT$,REG1,1);
               REG2=GET(DN$AUXREF,DNAT$,REG1);
               IF FINDAUX(AUXDEBUG, REG2) EQ 0
               THEN BEGIN 
                    #ADD AN AUX DEBUG ENTRY IN THE LIST#
                    PATCH=ATTACHAUX(REG1);
                    SET(AX$TTYPE,AUX$,PATCH,AUXDEBUG);
                    SET(AX$DEBUGMODE,AUX$,PATCH,DEBUGMODE); 
                    SET(AX$DEBUGCONV,AUX$,PATCH,0); 
                    SET(AX$DEBUGPROC,AUX$,PATCH,LASTSDEF);
                    END 
               ELSE  ERROR(SEVERE,902,TABLELINE,TABLECOLUMN); 
               END
          RETURN; 
SUB14:  
#WITH CONVERSION ROUTINE# 
          IF PATCH  NQ  0 
          THEN BEGIN
               REG2=GET(DN$TYPE,DNAT$,REG1);
               IF REG2 LS LOWNUMOPERND OR 
                  REG2 GR INDXNAME
               THEN  ERROR(SEVERE,895,LINE$,COLUMN$); 
               ELSE SET(AX$DEBUGCONV,AUX$,PATCH,1); 
               END
          RETURN; 
SUB2: 
#USE FOR DEBUG PROCEDURE# 
          PATCH=0;
          IF VALUE$  NQ  0
          THEN BEGIN
               PN1=VALUE$;
               IF GET(PN$DEBUG,PNAT$,PN1) EQ 1
               THEN  ERROR(SEVERE,898,LINE$,COLUMN$); 
               ELSE BEGIN 
                    REG1=GET(PN$AUXREF,PNAT$,PN1);
                    IF FINDAUX(AUXDEBUG,REG1) EQ 0
                    THEN BEGIN
                         #ADD AN AUX DEBUG ENTRY IN THE LIST.#
                         AUXTLENGTH=AUXTLENGTH+1; 
                         PATCH=AUXTLENGTH;
                         SET(AX$TTYPE,AUX$,PATCH,AUXDEBUG); 
                         SET(AX$DEBUGMODE,AUX$,PATCH,0);
                         SET(AX$DEBUGCONV,AUX$,PATCH,0);
                         SET(AX$DEBUGPROC,AUX$,PATCH,LASTSDEF); 
                         IF GET(PN$AUXREF,PNAT$,PN1) EQ 0 
                         THEN BEGIN 
                              SET(PN$AUXREF,PNAT$,PN1,PATCH); 
                              SET(AX$TNEXTPTR,AUX$,PATCH,0);
                              END 
                         ELSE BEGIN 
                              #APPEND TO FRONT OF LIST# 
                              TEMP2=GET(PN$AUXREF,PNAT$,PN1); 
                              SET(PN$AUXREF,PNAT$,PN1,PATCH); 
                              SET(AX$TNEXTPTR,AUX$,PATCH,TEMP2);
                              END 
                         END
                    ELSE  ERROR(SEVERE,901,LINE$,COLUMN$);
                    END 
               END
          RETURN; 
SUB3: 
#USE FOR DEBUG ALL PROCEDURES#
          I = 1;
          FOR $DUMMY$ = 0 WHILE GET(PN$DEBUG,PNAT$,I) EQ 1
               DO  I = I+1; 
          PN1=0;
          TEMP1 = CCTPNINDEX; 
          FOR J = 1 STEP 1 UNTIL CCTPNCOUNT 
          DO   BEGIN
    L1: 
          # THE TWO COMPILER GENERATED PNATS AFTER #
          # END DECLARATIVES HAVE PN$DEBUG SET #
          # SO WE CAN SKIP THEM .. SEE DECLPNT IN TBLPROC # 
          IF GET(PN$DEBUG,PNAT$,I) EQ 1 
          THEN BEGIN
               I = I + 1; 
               GOTO L1; 
               END
               REG1=GET(PN$AUXREF,PNAT$,I); 
               IF FINDAUX(AUXDEBUG,REG1)   EQ 0 
               THEN BEGIN 
                    #ADD AN AUX DEBUG ENTRY IN THE LIST#
                    AUXTLENGTH=AUXTLENGTH+1;
                    TEMP2=AUXTLENGTH; 
                    SET(AX$TTYPE,AUX$,TEMP2,AUXDEBUG);
                    SET(AX$DEBUGMODE,AUX$,TEMP2,0); 
                    SET(AX$DEBUGCONV,AUX$,TEMP2,0); 
                    SET(AX$DEBUGPROC,AUX$,TEMP2,LASTSDEF);
                    LATTEMP=TEMP1;
                    SET(AX$LATPTR,AUX$,TEMP2,(NEXTLAT));
               #THESE LATS WILL BE MOVED SO SET VERBCODE ACCORDINGLY# 
               SET(L$VCODE,LAT$,LATLENGTH,2); 
                    SET(DN$TYPE,DNAT$,DNATLENGTH,ALPHNUM);
                    SET(DN$ITMLEN,DNAT$,DNATLENGTH,30); 
                    IF GET(PN$AUXREF,PNAT$,I) EQ 0
                    THEN BEGIN
                         SET(PN$AUXREF,PNAT$,I,TEMP2);
                         SET(AX$TNEXTPTR,AUX$,TEMP2,0); 
                         END
                    ELSE BEGIN
                         J=GET(PN$AUXREF,PNAT$,I);
                         SET(PN$AUXREF,PNAT$,I,TEMP2);
                         SET(AX$TNEXTPTR,AUX$,TEMP2,J); 
                         END
                    END 
               ELSE BEGIN 
                    IF PN1 EQ 0 
                    THEN  ERROR(SEVERE,899,LINE$,COLUMN$);
                    PN1=1;
                    END 
               TEMP1 = TEMP1 + 1; 
               I = I + 1; 
               END
          RETURN; 
SUB25:  
#STORE DEBUG NAME#
          IF PATCH  NQ  0 
          THEN BEGIN
               LATTEMP=VALUE$;
               SET(AX$LATPTR,AUX$,PATCH,(NEXTLAT)); 
          #THESE LATS WILL BE MOVED SO SET VERBCODE ACCORDINGLY#
          SET(L$VCODE,LAT$,LATLENGTH,2);
               SET(DN$TYPE,DNAT$,DNATLENGTH,ALPHNUM); 
               SET(DN$ITMLEN,DNAT$,DNATLENGTH,30);
               END
          RETURN; 
SUB5: 
#DEBUG ITEM ROUTINE#
          IF CCTFIPSLEVEL LS 2
          THEN BEGIN
               # FIPS=2 SUPPORTS REFERENCES TO DEBUG-ITEM, DEBUG-LINE # 
               # DEBUG-NAME, DEBUG-SUB-1, DEBUG-SUB-2, DEBUG-SUB-3 #
               # AND DEBUG-CONTENTS # 
               ERROR(TRIVIAL,825,LINE$,COLUMN$);
               END
          IF NOT CCTDEBUGMODE[0]
          THEN BEGIN
               ERROR(SEVERE,903,LINE$,COLUMN$); 
               VALUE$=0;
               END
          ELSE BEGIN
               IF GET(PN$DEBUG,PNAT$,LASTSDEF)  NQ 1
               THEN BEGIN 
                    ERROR(SEVERE,904,LINE$,COLUMN$);
                    VALUE$=0; 
                    END 
               END
          RETURN; 
SUB6: 
#KEEP SUBSCRIPTS# 
          #KEEP THE NUMBER OF SUBSCRIPTS# 
          TEMP1=VALUE$; 
          TEMP2=GET(DN$SDEPTH,DNAT$,VALUE$);
          SET(DN$SDEPTH,DNAT$,VALUE$,0);
          RETURN; 
SUB7: 
#CHECK FOR PROC OR IDENT# 
          #SET THE TRUEFALSE FLAG EQUAL TO 1(TRUE) IF THE C-TEXT #
          #ATOM CORRESPONDS TO A DATA-NAME, 0(FALSE) IF IT CORRESPONDS# 
          #TO A PROCEDURE NAME.#
          IF GET(IN$PROCNAME,INT$,IP$) EQ 0 
          THEN TRUEFALSE = 1; 
          ELSE TRUEFALSE = 0; 
          RETURN; 
SUB15:  
#DEBUG PROLOGUE#
          NG($SWITCH);
          NG($DEBUGSW); 
          NGLABELREF((NEXTPNAT),GFALSE);
          DPROCEND=PNATLENGTH;
          RETURN; 
SUB16:  
#PROCEDURE DEBUG ROUTINE# 
          DPATCH = 0; 
          REG10 = VALUE$; 
          REG1=GET(PN$AUXREF,PNAT$,VALUE$); 
          TEMP1=FINDAUX(AUXDEBUG,REG1); 
          IF TEMP1  NQ  0 
          THEN BEGIN
               IF GET(PN$DECLARATV,PNAT$,VALUE$) EQ 0 OR
                  GET(PN$PROCKIND,PNAT$,VALUE$)  EQ 0 
               THEN BEGIN 
                    DPATCH = G; 
                    G=G-1;
                    VERBLINE=PREVIOUSLINE;
                    DEBUGFILL;
                    NGMOVE; 
                    IF VALUE$ NQ CCTDCLUPPBND + 3 
                    THEN NGLITREF(DLATFTHROUGH);
                    ELSE BEGIN
                        LATTEMP = LINE$ + 2;
                         REG1=DEBUGLINE;
                         SETGT(G-2,CREATELDL(REG1,1));
                    SET(L$VCODE,LAT$,LATLENGTH,2);
                         NGLITREF(DLATSPROGRAM);
                         END
                    NGDATAREF(DEBUGCONTS);
                    NGGTX(GVERB,VALUE$,GPROC);
                    TEMP2 = GET(PN$AUXREF,PNAT$,VALUE$);
                    TEMP = FINDAUX(AUXGTEXT,TEMP2); 
                    IF  TEMP NQ 0 
                    THEN  SET(AX$GTEXTPTR,AUX$,TEMP,G); 
                    PATCH = G;
                    END 
               NGMOVE;
               NGLITREF(GET(AX$LATPTR,AUX$,TEMP1)); 
               NGDATAREF(DEBUGNAME);
               PERFORMDEBUG(TEMP1); 
               END
          RETURN; 
SUB13:  
#SEGMENTATION DEBUG ROUTINE#
          RETURN; 
SUB17:  
#ALTER DEBUG ROUTINE# 
          REG1=GET(PN$AUXREF,PNAT$,TPOINTER(2));
          TEMP1=FINDAUX(AUXDEBUG,REG1); 
          IF TEMP1  NQ 0
          THEN BEGIN
               DEBUGFILL; 
               NGMOVE;
               NGLITREF(GET(AX$LATPTR,AUX$,TEMP1)); 
               NGDATAREF(DEBUGNAME);
               NGMOVE;
               LATTEMP=VALUE$;
               NGLITREF((NEXTLAT)); 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               NGDATAREF(DEBUGCONTS); 
                #COMPARE DEBUG-ITEM LENGTH WITH THE LENGTH OF THE # 
               #LITERAL MOVED INTO DEBUG-CONTENTS, AND UPDATE IF #
               #NECESSARY.                                       #
               TEMP=GET(DN$ITMLEN,DNAT$,DEBUGCONTS);
               TEMP2=GET(PL$LENGTH,PLT$,VALUE$);
               IF TEMP LS TEMP2 
               THEN BEGIN 
                    TEMP=TEMP2-TEMP;
                    FIX1=GET(DN$ITMLEN,DNAT$,DEBUGCONTS)+TEMP;
                    SET(DN$ITMLEN,DNAT$,DEBUGCONTS,FIX1); 
                    FIX1=GET(DN$ITMLEN,DNAT$,DEBUGITEM)+TEMP; 
                    SET(DN$ITMLEN,DNAT$,DEBUGITEM,FIX1);
                    CCTMSECLEN[SREGMSEC]=CCTMSECLEN[SREGMSEC]+TEMP; 
                    END 
               # UPDATE THE TYPE AND THE ITEM-LENGTH OF THE GEN. DNAT#
               SET(DN$TYPE,DNAT$,DNATLENGTH,ALPHNUM); 
               FIX1 = GET(DN$ITMLEN,DNAT$,DEBUGCONTS);
               SET(DN$ITMLEN,DNAT$,DNATLENGTH,FIX1);
               PERFORMDEBUG(TEMP1); 
               END
          RETURN; 
SUB18:  
#GOTO DEBUG ROUTINE#
          DEBUGFILL;
          RETURN; 
SUB27:  
#GOTO DEPEN DEBUG ROUTINE#
          IF STACK(S) EQ SUBMARKER
          THEN  TEMP2 = STACK(S-1) - 1; 
          ELSE  TEMP2 = S;
          FOR I = 1 STEP 1 UNTIL TEMP2-1
          DO   BEGIN
               REG1=GET(PN$AUXREF,PNAT$,TPOINTER(I)); 
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1  NQ  0
               THEN BEGIN 
                    DEBUGFILL;
                    RETURN; 
                    END 
               END
          RETURN; 
SUB20:  
#EN DIS DEBUG ROUTINE#
          I=TPOINTER(4);
          GOTO CDDEBUG; 
SUB21:  
#SEND DEBUG ROUTINE#
          I=TPOINTER(1);
          GOTO CDDEBUG; 
SUB22:  
#RECEIVE DEBUG ROUTINE# 
          I=TPOINTER(3);
          GOTO CDDEBUG; 
SUB24:  
#ACCEPT DEBUG ROUTINE#
          I=TPOINTER(S);
CDDEBUG:  
          IF  GET(DN$DEBUG,DNAT$,I) EQ 1
          THEN BEGIN
               REG1=GET(DN$AUXREF,DNAT$,I); 
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1 EQ 0
               THEN  ERROR(SEVERE,94,VERBLINE,VERBCOLUMN);
               ELSE BEGIN 
                    DEBUGFILL;
                    NGMOVE; 
                    NGLITREF(GET(AX$LATPTR,AUX$,TEMP1));
                    NGDATAREF(DEBUGNAME); 
                    NGMOVE; 
                   NGDATAREF(I+1);
                    NGDATAREF(DEBUGCONTS);
                    PERFORMDEBUG(TEMP1);
                    END 
               END
          RETURN; 
SUB32:  
#SET DEBUG FLAG#
          IF CCTDEBUGMODE[0]
          THEN BEGIN
               DEBUGFLAG=1; 
              FIX1 = GETGT(G);
               REG2 = B<36,15>  FIX1; 
               REG1=GET(PN$AUXREF,PNAT$,REG2);
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1  NQ  0
               THEN BEGIN 
                    NGMOVE; 
                    NGLITREF(GET(AX$LATPTR,AUX$,TEMP1));
                    NGDATAREF(DEBUGNAME); 
                    PERFORMDEBUG(TEMP1);
                    FROZENGTEXT=G;
                    END 
               END
          RETURN; 
SUB28:  
#PERFORM S DEBUG ROUTINE# 
          REG1=GET(PN$AUXREF,PNAT$,PERFORMENTRY); 
          TEMP1=FINDAUX(AUXDEBUG,REG1); 
          IF TEMP1  NQ  0 
          THEN BEGIN
               DEBUGFILL; 
               NGMOVE;
               NGLITREF(DLATPLOOP); 
               NGDATAREF(DEBUGCONTS); 
               END
          RETURN; 
SUB29:  
#PERFORM T DEBUG ROUTINE# 
          BEGIN 
               #CHANGE GTEXT TO LOOK LIKE PERFORM COMPLEX#
               SETGT(G-4,$PCOMPLEX);
               REG10 = G; 
               NGLABELREF((NEXTPNAT),0);
               PERFMABORT=PNATLENGTH; 
               TEMP1=NEXTTEMP;
               REG1=TEMP1;
               SET(DN$TYPE,DNAT$,REG1,BINARY);
               SET(DN$ITMLEN,DNAT$,REG1,10);
               SET(DN$NUMLEN,DNAT$,REG1,5); 
               GLOBALTEMP(REG1);
               # MOVE THE NUMBER OF TIMES IN A TEMP, THIS IS GOING TO # 
               # BE USED AS FINAL VALUE OF THE LOOP.                  # 
               FIX1 = GETGT(REG10); 
               IF B<30,6>FIX1 EQ GLITREF
               THEN BEGIN 
                    #THE NUMBER OF TIMES IS A LITERAL, COPY THE  #
                    #RECEIVING FIELD DNAT INTO THE DNAT CORRESPONDING#
                    #TO THIS LITERAL.                                #
                    REG2 = B<36,15>FIX1;
                    LITERALDNAT(TEMP1,GET(L$DNAT,LAT$,REG2)); 
                    # SET UP VERBCODE FOR MOVE #
                    SET(L$VCODE,LAT$,REG2,2); 
                    END 
               NG($MOVE); 
               NG(FIX1);
               NGDATAREF(TEMP1);
               TEMP2=NEXTTEMP;
               REG1=TEMP2;
               SET(DN$TYPE,DNAT$,REG1,BINARY);
               SET(DN$ITMLEN,DNAT$,REG1,10);
               SET(DN$NUMLEN,DNAT$,REG1,5); 
               GLOBALTEMP(REG1);
               LATTEMP=1; 
               # MOVE THE INITIAL VALUE 1 IN A TEMP WHICH IS GOING TO # 
               # BE USED AS THE CONTROL VARIABLE OF THE LOOP.         # 
               NGMOVE;
               NG(CREATELDL(REG1,1)); 
          SET(L$VCODE,LAT$,LATLENGTH,2);
               NGDATAREF(TEMP2);
               NGGOTO;
               NGLABELREF((NEXTPNAT),0);
               NGLABELDEF(PERFMRETURN); 
               NG($PERFORMACT); 
               NGPROCREF(PERFORMENTRY,0); 
               REG1=TEMP2;
               LATTEMP=1; 
               NG($ADD);
               NG(CREATELDL(REG1,1)); 
               NGDATAREF(TEMP2);
               NGDATAREF(TEMP2);
               NGLABELDEF(PNATLENGTH);
          REG1 = GET(PN$AUXREF,PNAT$,PERFORMENTRY); 
          TEMP = FINDAUX(AUXDEBUG,REG1);
          IF TEMP NQ 0
          THEN BEGIN
               DEBUGFILL; 
               NGMOVE;
               NGLITREF(DLATPLOOP); 
               NGDATAREF(DEBUGCONTS); 
          END 
               NG($GREATER);
               NGDATAREF(TEMP2);
               NGDATAREF(TEMP1);
               NGPROCREF(PERFORMENTRY,GFALSE);
               NG($PERFORMEND); 
               NGPROCREF(PN1,0);
               NGLABELDEF(PERFMABORT);
               END
          RETURN; 
SUB31:  
#PERFORM V DEBUG ROUTINE# 
          REG1=GET(PN$AUXREF,PNAT$,PERFORMENTRY); 
          TEMP1=FINDAUX(AUXDEBUG,REG1); 
          IF TEMP1  NQ  0 
          THEN BEGIN
               REG10 = G; 
               MOVEGTEXT(9);
               DEBUGFILL; 
               NGMOVE;
               NGLITREF(DLATPLOOP); 
               NGDATAREF(DEBUGCONTS); 
               G = REG10 + 9; 
               END
          RETURN; 
SUB33:  
#SORT DEBUG ROUTINE#
          IF GETGT(DPATCH) EQ $PERFORMIP
          THEN BEGIN
               REG1=GET(PN$AUXREF,PNAT$,STACK(8));
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1  NQ  0
               THEN BEGIN 
                    REG10 = G;
                    MOVEGTEXT(10);
                    NGLABELDEF((NEXTPNAT)); 
                    DEBUGFILL;
                    NGMOVE; 
                    NGLITREF(DLATSORTINP);
                    NGDATAREF(DEBUGCONTS);
                    DPATCH = G + 7; 
                    G = REG10 + 10; 
                    # UPDATE THE DEBUGGING LABEL REF #
                    SETGT(DPATCH-2,GTX(GLABELREF,PNATLENGTH,0));
                    END 
               END
          DEBUGMODE=0;
          GOTO SMDEBUGROUT; 
SUB34:  
#MERGE DEBUG ROUTINE# 
          DEBUGMODE=1;
SMDEBUGROUT:  
          IF GETGT(DPATCH) EQ $PERFORMOP
          THEN BEGIN
               REG1=GET(PN$AUXREF,PNAT$,STACK(10)); 
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1  NQ  0
               THEN BEGIN 
                    REG10 = G;
                    MOVEGTEXT(10);
                    NGLABELDEF((NEXTPNAT)); 
                    DEBUGFILL;
                    NGMOVE; 
                    IF DEBUGMODE EQ 0 
                    THEN  NGLITREF(DLATSORTOUT);
                    ELSE  NGLITREF(DLATMERGEOUT); 
                    NGDATAREF(DEBUGCONTS);
                    G = REG10 + 10; 
                    # UPDATE THE DEBUGGING LABEL REF #
                    SETGT(G-1,GTX(GLABELREF,PNATLENGTH,0)); 
                    END 
               END
          RETURN; 
SUB35:  
#RW DEBUG ROUTINE#
          IF GETGT(DPATCH) EQ $PERFORM
          THEN BEGIN
               FIX1 = GETGT(DPATCH + 1);
               REG2 = B<36,15> FIX1;
               REG1=GET(PN$AUXREF,PNAT$,REG2);
               TEMP1=FINDAUX(AUXDEBUG,REG1);
               IF TEMP1  NQ  0
               THEN BEGIN 
                    REG10 = G;
                    MOVEGTEXT(9); 
                    NGMOVE; 
                    NGLITREF(DLATSPACE);
                    NGDATAREF(DEBUGITEM); 
                    NGMOVE; 
                    NGDATAREF(CCTRWVRBLINE);
                    NGDATAREF(DEBUGLINE); 
  
                    NGMOVE; 
                    NGLITREF(DLATUSEPROC);
                    NGDATAREF(DEBUGCONTS);
                    G = REG10 + 9;
                    END 
               END
          RETURN; 
SUB19:  
#HASHING ROUTINE# 
          REG1 = GET(DN$FNATPTR,DNAT$,VALUE$);
          IF GET(FN$ORG,FNAT$,REG1) NQ DIRECT 
          THEN BEGIN
               ERROR(SEVERE,811,LINE$,COLUMN$); 
               RETURN;
               END
          #ADD AN AUX ENTRY TO THE LIST ATTACHED TO THE USE PROCEDURE#
          AUXTLENGTH = AUXTLENGTH + 1;
          SET(AX$TTYPE,AUX$,AUXTLENGTH,AUXHASH);
          IF GET(PN$AUXREF,PNAT$,LASTSDEF) EQ 0 
          THEN BEGIN
               SET(PN$AUXREF,PNAT$,LASTSDEF,AUXTLENGTH);
               SET(AX$TNEXTPTR,AUX$,AUXTLENGTH,0);
               END
          ELSE BEGIN
               #APPEND TO FRONT OF LIST#
               TEMP1 = GET(PN$AUXREF,PNAT$,LASTSDEF); 
               SET(PN$AUXREF,PNAT$,LASTSDEF,AUXTLENGTH);
               SET(AX$TNEXTPTR,AUX$,AUXTLENGTH,TEMP1);
               END
          SET(AX$TFIRST,AUX$,AUXTLENGTH,VALUE$);
          RETURN; 
SUB9: 
# STORE DEBUG ELEMENT (CALLED DIRECTLY FROM SET1)#
         STDEBUGELEM(PASSDA,PASSMODE);
         RETURN;
SUB10:  
#STATEMENT DEBUG ROUTINE# 
          # SEARCH THE STACK AND PREPARE THE APPROPRIATE GTEXT  # 
          # FOR EACH DATA-NAME STACKED.                         # 
  
          IF DS NQ 0
          THEN  NG($SIZEOFF); 
          ELSE  RETURN; 
  
          FOR REG1 = 1 STEP 1 UNTIL DS
          DO BEGIN
             TEMP = DEBUGELEMENT(REG1); 
             #SEPARATE THE VARIOUS FIELDS FROM THE ACCESSED ENTRY # 
  
  
             DSCOUNT = B<45,6>TEMP;    # NUMBER OF SUBSCRIPTS # 
             ADR = B<30,15>TEMP;       # DNAT POINTER OF THE DATA-NAME# 
             TEMP1 = GET(DN$AUXREF,DNAT$,ADR);
             TEMP1 = FINDAUX(AUXDEBUG,TEMP1); 
             IF TEMP1 EQ 0
             THEN BEGIN      # ***** COMPILER ERROR ***** # 
                  ERROR(SEVERE,94,VERBLINE,VERBCOLUMN); 
                  RETURN; 
                  END 
          # AX$DEBUGMODE = 0 MEANS DEBUG ON IDENTIFIER #
          # AX$DEBUGMODE = 1 MEANS DEBUG ON ALL IDENTIFEIR #
          # B<51,3> = 1 MEANS ID WAS A RECEIVING FIELD #
          # PERFVARFLAG = 1 MEANS WE ARE BETWEEN PV PROLOGUE AND EP # 
          # CSUBSFLAG = 1 MEANS WE ARE IN THE UNTIL CONDITION # 
          IF NOT (PERFVARFLAG EQ 1 AND CSUBSFLAG EQ 1)
             AND GET (AX$DEBUGMODE,AUX$,TEMP1) NQ 1 
             AND B<51,3> TEMP NQ 1
             THEN BEGIN 
                  REG1 = B<54,6>TEMP - 1; 
                  GOTO LOOPEXIT;
                  END 
             #PREPARE GTEXT FOR PERFORMING THE DEBUGGING PROCS AND #
             #MOVING THE REQUIRED INFORMATION IN THE APPROPRIATE   #
             #FIELDS OF THE SPECIAL REGISTER DEBUG-ITEM.           #
             IF DSCOUNT NQ 0
             THEN BEGIN 
                  #GET THE MNEMONIC NUMBER OF THE SUBSCRIPT CALCULATION#
                  REG1 = REG1 + 1;
                  TEMP = DEBUGELEMENT(REG1);
                 REG9 = B<30,15>TEMP;     # M-NUMBER #
                  #UPDATE THE REFERENCE COUNT FOR THIS SUSCR. CALC. # 
                  REG2 = B<45,15>TEMP;       # REFERENCE COUNT POINTER #
                  FIX1 = GET(RCT$ENTRY,RCT$,REG2) + 1;
                  SET(RCT$ENTRY,RCT$,REG2,FIX1);
                  END 
             ELSE REG9 = 0; 
  
                       NGMOVE;
                       NGLITREF(DLATSPACE); 
                       NGDATAREF(DEBUGITEM);
                       NGMOVE;
                       LATTEMP = VERBLINE;
                       NG(CREATELDL(DEBUGLINE,1));
                      SET(L$VCODE,LAT$,LATLENGTH,2);
                       NGDATAREF(DEBUGLINE);
                       NGMOVE;
                       FIX1 = GET(AX$LATPTR,AUX$,TEMP1);
                       NGLITREF(FIX1);
                       NGDATAREF(DEBUGNAME);
                       IF GET(DN$TYPE,DNAT$,ADR) EQ INDXNAME
                       THEN BEGIN 
                            NG($SET); 
                            NG($SETTO); 
                            NGGTX(GDATAREF,ADR,REG9); 
                            NGDATAREF(DEBUGNUMCON); 
                            END 
                       ELSE BEGIN 
                            IF GET(AX$DEBUGCONV,AUX$,TEMP1) EQ 1
                            THEN BEGIN
                                 NGMOVE;
                                 NGGTX(GDATAREF,ADR,REG9);
                                 NGDATAREF(DEBUGNUMCON);
                                 END
                            ELSE BEGIN
                                 NG($MOVEASIS); 
                                 NGGTX(GDATAREF,ADR,REG9);
                                 NGDATAREF(DEBUGCONTS); 
                                 END
  
                            END 
  
                       # MOVE THE SUBSCRIPTS IF THERE ARE ANY IN       #
                       # DEBUGSUB1, DEBUGSUB2, DEBUGSUB3 RESPECTIVELY  #
                       IF DSCOUNT NQ 0
                       THEN BEGIN 
                            FOR J = 1 STEP 1 UNTIL DSCOUNT
                            DO BEGIN
                               REG1 = REG1 + 1; 
                               IF J EQ 1
                               THEN REG10 = DEBUGSUB1;
                               ELSE BEGIN 
                                    IF J EQ 2 
                                    THEN REG10 = DEBUGSUB2; 
                                    ELSE REG10 = DEBUGSUB3; 
                                    END 
                          # ***ATTENTION*** THE CONTROL VARIABLE OF # 
                          # THE LOOP REG1 MAY BE INCREASED BY ONE IN# 
                          # THE ROUTINE MOVESUBS.                   # 
                               MOVESUBS( REG10 ); 
                               END
                             END
                       NG($PERFORM);
                       FIX1 = GET(AX$DEBUGPROC,AUX$,TEMP1); 
                       NGPROCREF(FIX1,0); 
                       NGPROCREF(FIX1,0); 
                       NGLABELREF((NEXTPNAT),0);
                       NGLABELDEF(PNATLENGTH);
    LOOPEXIT: 
             END        # END OF DO # 
          # IN THE CASE OF A PERFORM VERB LEAVE THE CONTROL VARIABLE #
          # IN THE DEBUG-STACK IF IT IS ALREADY THERE.               #
          IF PERFVARFLAG EQ 1 
          THEN BEGIN
               REG1 = DEBUGELEMENT(1);
               REG1 = B<30,15>REG1; 
               # OPERAND2 CONTAINS THE DNAT-POINTER OF THE CONTROL #
               # VARIABLE OF THE PERFORM.                          #
               REG2 = B<36,15>OPERAND2; 
               IF REG1 EQ REG2
               THEN BEGIN 
                    DS = 1; 
                    RETURN; 
                    END 
                END 
          DS = 0; 
  
  
         RETURN;
SUB11:  
# RECEIVE ND DEBUG PROLOGUE # 
         G = G - 1; 
         NGLABELREF((NEXTPNAT));
         ISLABEL = PNATLENGTH;
         RETURN;
SUB12:  
# RECEIVE ND DEBUG EPILOGUE # 
         NGGOTO;
         NGLABELREF(ENDADDRESS,0);
         NGLABELDEF(ISLABEL); 
         RETURN;
          END #SET10# 
          TERM
