*DECK PPBEGIN 
USETEXT CCTTEXT 
USETEXT DNTEXT
USETEXT PPTEXT
PRGM PPBEGIN; 
         BEGIN
         COMMON PARAMS; 
         BEGIN
         ARRAY PARAMT [0:7];
         ITEM PARAMC C(0,0,10); 
         END
*CALL DPPPDDATA 
*CALL PPCOMMON2 
*CALL SPBT1 
*CALL AUXTVALS
*CALL DNATVALS
*CALL PLTVALS 
         XREF PROC SETRTN;
         XREF PROC CSTPURGE;
         $BEGIN XREF ITEM CSTTRACE B; $END
CONTROL EJECT;
         PROC SPBTPROCESSR; 
         ITEM  I             U; 
         ITEM  J             U; 
         ITEM  K             U; 
         ITEM  L             U; 
         ITEM  E             U; 
         ITEM  INDEPENDENT   I; 
         ITEM  X             U; 
         ITEM  CONTAINED     U; 
         ITEM  REFTIESIN     U; 
         # PASS 1 - 1) INPUT AND OUTPUT PROCEDURES ONLY#
         #          2) UPDATE SPBT$LOBOUND AND SPBT$HIBOUND#
         #             FIELDS OF THE SPBT#
         #          3) CHECK FOR NON-CONTIGUOUS SECTIONS WITHIN#
         #             THE SORT PROCEDURE#
         #          4) CHECK THE SEGMENTATION RULES#
         #          5) UPDATE THE PNAT ENTRY FOR EACH PARAGRAPH#
         #             IN THE SORT PROCEDURE# 
         #          6) UPDATE THE PNAT ENTRY FOR THE FIRST AND# 
         #             LAST SECTIONS AS PERFORM FIRST AND # 
         #             PERFORM LAST SECTIONS# 
         # PASS 2 - 1) APPLIES ONLY TO RELEASE AND RETURN#
         #          2) EACH RELEASE STATEMENT MUST BE IN AN#
         #             INPUT PROCEDURE SUCH THAT THE RECORD#
         #             NAME IN THE RELEASE STATEMENT IS#
         #             ASSOCIATED WITH THE FILE ASSOCIATED# 
         #             WITH THE CANDIDATE INPUT PROCEDURE#
         #          3) EACH RETURN STATEMENT MUST BE IN AN# 
         #             OUTPUT PROCEDURE SUCH THAT THE FILE# 
         #             NAME IN THE RETURN STATEMENT IS THE SAME#
         #             AS THE FILE ASSOCIATED WITH THE# 
         #             CANDIDATE OUTPUT PROCEDURE#
         # PASS 3 - 1) INPUT AND OUTPUT PROCEDURES ONLY#
         #          2) EACH INPUT PROCEDURE MUST CONTAIN A# 
         #             VALID RELEASE STATEMENT# 
         #          3) EACH OUTPUT PROCEDURE MUST CONTAIN A#
         #             VALID RETURN STATEMENT#
         #          4) INPUT PROCEDURES CANNOT OVERLAP# 
         #             OUTPUT PROCEDURES, OUTPUT PROCEDURES#
         #             CANNOT OVERLAP INPUT PROCEDURES# 
         BEGIN
PASS1:  
         FOR I = 1
         STEP 1 
         UNTIL SPBTLENGTH 
         DO BEGIN 
#CHANGE SPBT$DNAT FROM INT POINTER TO DNAT POINTER# 
            REG1 = GET(SPBT$DNAT,SPBT$,I);
            IF GET(IN$CODE,INT$,REG1) EQ 0 THEN 
                BEGIN 
                REG1 = GET(IN$DNAT,INT$,REG1);
                SET(SPBT$DNAT,SPBT$,I,REG1);
                END 
            ELSE SET(SPBT$DNAT,SPBT$,I,0);
            REG1 = GET(SPBT$LINE,SPBT$,I);
            REG2 = GET(SPBT$COLUMN,SPBT$,I);
            IF GET(SPBT$TYPE,SPBT$,I) EQ 1 OR 
               GET(SPBT$TYPE,SPBT$,I) EQ 2
            THEN BEGIN
                 #SORT PROCEDURE (INPUT OR OUTPUT)# 
                 #WE NOW WISH TO REPLACE THE INT POINTERS#
                 #IN SORT-LOW-BOUND AND SORT-HI-BOUND WITH# 
                 #THE CORRESPONDING PNAT POINTERS- IF THE INT#
                 #IS ZERO THE SECTION NAME MAY IF FACT BE A#
                 #DATA NAME OR SOMETHING- IF THE VALUE IN THE#
                 #INT-VALUE FIELD IS ZERO, THE PROCEDURE NAME#
                 #MAY BE UNDEFINED OR AMBIGUOUS- IN EITHER CASE#
                 #THE SORT STATEMENT WILL BE RESPONSIBLE FOR# 
                 #THESE DIAGNOSTICS- IN ORDER TO CONTINUE WITH# 
                 #OUR ERROR CHECKING, IF JUST ONE OF THE# 
                 #SECTION NAMES IS PROPERLY DEFINED, IT WILL BE#
                 #USED AS BOTH THE UPPER AND LOWER BOUND- IF# 
                 #THE UPPER BOUND IS LESS THAN THE LOWER BOUND,#
                 #WE WILL USE THE LOWER BOUND FOR BOTH THE# 
                 #LOWER BOUND AND THE UPPER BOUND (DIAG 343)# 
                 J = GET(SPBT$LOBOUND,SPBT$,I); 
                 IF J NQ 0
                 THEN J = GET(IN$VALUE,INT$,J); 
                 K = GET(SPBT$HIBOUND,SPBT$,I); 
                 IF K NQ 0
                 THEN K = GET(IN$VALUE,INT$,K); 
                 IF K NQ 0 AND K LS J 
                 THEN BEGIN 
                      #(DIAG 343) THIS SORT PROCEDURE#
                      #CONTAINS NON-CONTIGUOUS SECTIONS#
                      ERROR(SEVERE,343,REG1,REG2);
                      SET(SPBT$STATUS,SPBT$,I,1); 
                      K = J;
                      END 
                 IF J EQ 0 THEN J = K;
                 IF K EQ 0 THEN K = J;
                 SET(SPBT$LOBOUND,SPBT$,I,J); 
                 SET(SPBT$HIBOUND,SPBT$,I,K); 
                 IF K EQ 0 THEN TEST I; 
                 #THE VALUES OF J AND K ARE NON-ZERO# 
                 #SO, WE SHALL CONTINUE#
                 SET(PN$PERFLAST,PNAT$,K,1);
                 #INPUT AND OUTPUT PROCEDURES MUST# 
                 #RESIDE ENTIRELY WITHIN NON-INDEPENDENT# 
                 #SEGMENTS OR ENTIRELY WITHIN A SINGLE# 
                 #INDEPENDENT SEGMENT#
                 #CORRECT SYNTAX REQUIRES THAT BOTH J AND K#
                 #POINT TO SECTION NAMES- IT IS THE#
                 #RESPONSIBILITY OF THE SORT (MERGE) STATEMENT# 
                 #TO GIVE DIAGNOSTICS IF J AND/OR K ARE PARAGRAPH#
                 #NAMES (SEE SORT-INPUT-SN1-ROUTINE, ETC.)- WE WILL#
                 #EXECUTE THE FOLLOWING PRECAUTIONARY CODE# 
                 #JUST IN CASE SOMEONE TRIES TO GIVE US A#
                 #PARAGRAPH NAME INSTEAD# 
                 IF GET(PN$PROCKIND,PNAT$,J) EQ 1 
                 THEN X = GET(PN$SEGMENTNO,PNAT$,J);
                 ELSE BEGIN 
                      FIX1 = GET(PN$PREVSECTN,PNAT$,J); 
                      X = GET(PN$SEGMENTNO,PNAT$,FIX1); 
                      END 
                 IF X LS 50 
                 THEN INDEPENDENT = 0;
                 ELSE INDEPENDENT = 1;
                 FOR L = J + 1
                 STEP 1 
                 UNTIL K
                 DO BEGIN 
                    FIX1 = GET(PN$PROCKIND,PNAT$,L);
                    FIX2 = GET(PN$SEGMENTNO,PNAT$,L); 
                    IF FIX1 NQ 1
                       OR (INDEPENDENT EQ 1 AND FIX2 EQ X)
                       OR (INDEPENDENT EQ 0 AND FIX2 LS 50) 
                    THEN TEST;
                    ELSE BEGIN
                         #(DIAG 324)# 
                         #AN INPUT OR OUTPUT PROCEDURE# 
                         #MUST BE CONTAINED WHOLLY WITHIN#
                         #NON-INDEPENDENT SEGMENTS OR MUST# 
                         #BE CONTAINED WHOLLY WITHIN A SINGLE#
                         #INDEPENDENT SEGMENT#
                         ERROR(SEVERE,324,REG1,REG2); 
                         SET(SPBT$STATUS,SPBT$,I,1);
                         GOTO NEXTSTEP; 
                         END
                    END 
                 #IF THE ASSOCIATED SORT/MERGE STATEMENT IS IN AN#
                 #INDEPENDENT SEGMENT THE PROCEDURE MUST BE WHOLLY# 
                 #CONTAINED IN THE SAME INDEPENDENT SEGMENT.# 
                 FIX1 = GET(SPBT$PROC,SPBT$,I); 
                 IF GET(PN$PROCKIND,PNAT$,FIX1) EQ 1
                 THEN L = GET(PN$SEGMENTNO,PNAT$,FIX1); 
                 ELSE BEGIN 
                      FIX2 = GET(PN$PREVSECTN,PNAT$,FIX1);
                      L = GET(PN$SEGMENTNO,PNAT$,FIX2); 
                      END 
                 IF L GR 49 
                 THEN BEGIN 
                      IF INDEPENDENT EQ 1 AND L NQ X
                      THEN BEGIN
                           #(DIAG 325)# 
                           #IF A SORT OR MERGE STATEMENT# 
                           #APPEARS WITHIN AN INDEPENDENT#
                           #SEGMENT, ANY ASSOCIATED INPUT#
                           #OR OUTPUT PROCEDURES MUST BE# 
                           #CONTAINED WHOLLY WITHIN THAT# 
                           #SAME INDEPENDENT SEGMENT OR#
                           #MUST BE CONTAINED WHOLLY WITHIN#
                           #NON-INDEPENDENT SEGMENTS# 
                           ERROR(SEVERE,325,REG1,REG2); 
                           SET(SPBT$STATUS,SPBT$,I,1);
                           END
                      END 
                 NEXTSTEP:  
                 #WE NOW WISH TO INDICATE IN EVERY PNAT#
                 #FROM THE BEGINNING TO THE END OF THE SORT#
                 #PROCEDURE THAT THE PNAT IS PART OF A SORT#
                 #PROCEDURE AND ESTABLISH A POINTER BACK TO#
                 #THE CORRESPONDING SPBT ENTRY# 
                 #******* OVERLAP ***** REALLY NECESSARY *****# 
                 #WITH THIS IN MIND, WE NOW LOCATE THE END OF#
                 #THE SORT PROCEDURE# 
                 FIX1 = GET(PN$PROCKIND,PNAT$,K); 
                 IF FIX1 EQ 1 
                 THEN FIX1 = GET(PN$PREVSECTN,PNAT$,K) - 1; 
                 ELSE FIX1 = K; 
                 #NOTE, PREVSECTN REALLY POINTS TO NEXT SECTION#
                 #THE S SCANNER MAY NOT SUPPORT THIS YET# 
                 FOR L = J
                 STEP 1 
                 UNTIL FIX1 
                 DO BEGIN 
                    SET(PN$SORTPROC,PNAT$,L,1); 
                    END 
                 #THE TRUTH OF THE MATTER IS, WE DON"T REALLY#
                 #WANT K IN SPBT-HI-BOUND AFTER ALL- WE WANT THE# 
                 #LAST PARAGRAPH IN SECTION K, NAMELY FIX1# 
                 SET(SPBT$HIBOUND,SPBT$,I,FIX1);
                 END
              END 
PASS2:  
         FOR I = 1
         STEP 1 
         UNTIL SPBTLENGTH 
         DO BEGIN 
            IF GET(SPBT$TYPE,SPBT$,I) GR 2
            THEN BEGIN
                 #RELEASE OR RETURN STATEMENT#
                 REG1 = GET(SPBT$LINE,SPBT$,I); 
                 REG2 = GET(SPBT$COLUMN,SPBT$,I); 
                 CONTAINED = 0; 
                 REFTIESIN = 0; 
                 FOR J = 1
                 STEP 1 
                 UNTIL SPBTLENGTH 
                 DO BEGIN 
                    #FOR EACH RELEASE STATEMENT (3) IN THE# 
                    #SPBT WE ARE LOOKING FOR EACH INPUT#
                    #PROCEDURE (1) IN THE SPBT (1 = 3 - 2)# 
                    #FOR EACH RETURN STATEMENT (4) IN THE#
                    #SPBT WE ARE LOOKING FOR EACH OUTPUT# 
                    #PROCEDURE (2) IN THE SPBT (2 = 4 - 2)# 
                    FIX1 = GET(SPBT$TYPE,SPBT$,J);
                    FIX2 = GET(SPBT$TYPE,SPBT$,I);
                    IF FIX1 EQ FIX2 - 2 
                    THEN BEGIN
                         #WE HAVE A MATCH#
                         #RELEASE - INPUT PROCEDURE#
                         #RETURN - OUTPUT PROCEDURE#
                         FIX1 = GET(SPBT$PROC,SPBT$,I); 
                         IF FIX1 GQ GET(SPBT$LOBOUND,SPBT$,J) AND 
                            FIX1 LQ GET(SPBT$HIBOUND,SPBT$,J) 
                         THEN BEGIN 
                              #THE RELEASE STATEMENT IS#
                              #INSIDE THE INPUT PROCEDURE, OR#
                              #THE RETURN STATEMENT IS# 
                              #INSIDE THE OUTPUT PROCEDURE# 
                              #NOTE - THIS PARTICULAR RELEASE OR# 
                              #RETURN STATEMENT DOES NOT HAVE TO# 
                              #BE IN THIS PARTICULAR SORT PROCEDURE#
                              CONTAINED = 1;
                              IF GET(SPBT$TYPE,SPBT$,I) EQ 3
                              THEN BEGIN
                                   #RELEASE STATEMENT#
                                   #    RELEASE SPBT$DNAT#
                                   # -> RECORD NAME DNAT# 
                                   # -> FILE-NAME AUX ENTRY#
                                   # -> FILE-NAME DNAT# 
                                   REG3 = GET(SPBT$DNAT,SPBT$,I); 
                                   REG3 = GET(DN$AUXREF,DNAT$,REG3);
                                   REG3 = FINDAUX(FILENAME,REG3); 
                                   IF REG3 NQ 0 
                                   THEN REG4 = GET(AX$FDPTR,AUX$,REG3); 
                                   ELSE REG4 = 0; 
                                   END
                              ELSE #RETURN STATEMENT# 
                                   #    RETURN SPBT$DNAT# 
                                   # -> FILE-NAME DNAT# 
                                   REG4 = GET(SPBT$DNAT,SPBT$,I); 
                              IF GET(DN$LEVEL,DNAT$,REG4) NQ SDDESCR
                              OR GET(DN$TYPE,DNAT$,REG4) EQ ERRTYPE 
                              THEN BEGIN
                                   #SOMETHING IS WRONG WITH THE FILE# 
                                   #SORT OR MERGE AND/OR D-PARSER WILL# 
                                   #GIVE DIAGNOSTICS- WE DONT WANT# 
                                   #ANY FURTHER DIAGNOSTICS, SO WE# 
                                   #CHEAT A LITTLE AND SET REFTIESIN# 
                                   SET(SPBT$STATUS,SPBT$,I,1);
                                   REFTIESIN = 1; 
                                   END
                              ELSE IF REG4 EQ GET(SPBT$DNAT,SPBT$,J)
                                   THEN BEGIN 
                                        #GOOD#
                                        #THE FILE IN THE# 
                                        #RETURN STATEMENT#
                                        #IS THE SAME AS THE FILE IN THE#
                                        #SORT STATEMENT- OR THE RECORD# 
                                        #IN THE RELEASE STATEMENT IS IN#
                                        #THE FILE IN THE SORT STATEMENT#
                                        REFTIESIN = 1;
                                        #EACH INPUT PROCEDURE MUST# 
                                        #CONTAIN A RELEASE STATEMENT# 
                                        #AND EACH OUTPUT PROCEDURE# 
                                        #MUST CONTAIN A RETURN# 
                                        #STATEMENT- THIS REQUIREMENT# 
                                        #IS NOW BEING SATISFIED- SEE# 
                                        #PASS 3 FOR FINAL TEST# 
                                        SET(SPBT$VERB,SPBT$,J,1); 
                                        END 
                              END 
                         END
                    END #OF THE INNER DO# 
                 IF CONTAINED EQ 0
                 THEN BEGIN 
                      IF GET(SPBT$TYPE,SPBT$,I) EQ 3
                      THEN E = 331; 
                      ELSE E = 337; 
                      #(DIAG 331)#
                      #THIS RELEASE STATEMENT IS NOT CONTAINED# 
                      #IN AN INPUT PROCEDURE ASSOCIATED WITH A# 
                      #SORT OR MERGE STATEMENT FOR A FILE WHOSE#
                      #FILE DESCRIPTION CONTAINS THE RECORD#
                      #REFERENCED IN THIS STATEMENT#
                      #(DIAG 337)#
                      #THIS RETURN STATEMENT IS NOT CONTAINED#
                      #IN AN OUTPUT PROCEDURE ASSOCIATED WITH#
                      #A SORT OR MERGE STATEMENT FOR THE FILE#
                      #THAT IS REFERENCED IN THIS STATEMENT#
                      ERROR(JOD,E,REG1,REG2); 
                      SET(SPBT$STATUS,SPBT$,I,1); 
                      END 
                 ELSE BEGIN 
                      IF REFTIESIN EQ 0 
                      THEN BEGIN
                           IF GET(SPBT$TYPE,SPBT$,I) EQ 3 
                           THEN E = 334;
                           ELSE E = 338;
                           #(DIAG 334)# 
                           #THE RECORD REFERENCED IN THIS RELEASE#
                           #STATEMENT IS NOT DEFINED IN THE#
                           #SORT-MERGE FILE WHICH IS REFERENCED IN# 
                           #THE SORT OR MERGE STATEMENT WHOSE#
                           #INPUT PROCEDURE CONTAINS THIS STATEMENT#
                           #(DIAG 338)# 
                           #THE FILE THAT IS REFERENCED IN THIS#
                           #RETURN STATEMENT IS NOT REFERENCED# 
                           #IN A SORT OR MERGE STATEMENT WHOSE# 
                           #OUTPUT PROCEDURE CONTAINS THIS STATEMENT# 
                           ERROR(JOD,E,REG1,REG2) ; 
                           SET(SPBT$STATUS,SPBT$,I,1);
                           END
                      END 
                 END #OF RELEASE OR RETURN PROCESSING#
              END #OF OUTER DO# 
PASS3:  
         FOR I = 1
         STEP 1 
         UNTIL SPBTLENGTH 
         DO BEGIN 
            REG1 = GET(SPBT$LINE,SPBT$,I);
            REG2 = GET(SPBT$COLUMN,SPBT$,I);
            J = GET(SPBT$LOBOUND,SPBT$,I);
            K = GET(SPBT$HIBOUND,SPBT$,I);
             IF J EQ 0 OR K EQ 0
             THEN TEST I; 
            IF GET(SPBT$TYPE,SPBT$,I) LS 3
            THEN BEGIN
                 #INPUT OR OUTPUT PROCEDURE#
                 IF GET(SPBT$VERB,SPBT$,I) NQ 1 
                 THEN BEGIN 
                      #THE INPUT OR OUTPUT PROCEDURE# 
                      #FAILS TO CONTAIN A RELEASE OR# 
                      #RETURN STATEMENT#
                      IF GET(SPBT$TYPE,SPBT$,I) EQ 1
                      THEN E = 314; 
                      ELSE E = 315; 
                      #(DIAG 314)#
                      #THIS INPUT PROCEDURE DOES NOT CONTAIN# 
                      #AT LEAST ONE RELEASE STATEMENT THAT# 
                      #REFERENCES A RECORD WHICH IS CONTAINED#
                      #IN THE FILE DESCRIPTION OF THE FILE# 
                      #THAT IS REFERENCED IN THIS SORT OR#
                      #MERGE STATEMENT# 
                      #(DIAG 315)#
                      #THIS OUTPUT PROCEDURE DOES NOT CONTAIN#
                      #AT LEAST ONE RETURN STATEMENT THAT#
                      #REFERENCES THE FILE THAT IS REFERENCED#
                      #IN THIS SORT OR MERGE STATEMENT# 
                      ERROR(JOD,E,REG1,REG2); 
                      SET(SPBT$STATUS,SPBT$,I,1); 
                      END 
                 #LOOK FOR OVERLAPPING SORT PROCEDURES# 
                 #NOTE - SPBT$HIBOUND CONTAINS THE PNAT INDEX#
                 #OF THE LAST PARAGRAPH IN THE SORT PROCEDURE#
                 #SOMEWHAT SIMPLIFYING THE RANGE TEST WHICH WE# 
                 #ARE ABOUT TO MAKE (SEE PASS 1)# 
                 FOR L = 1
                 STEP 1 
                 UNTIL SPBTLENGTH 
                 DO BEGIN 
                    FIX1 = GET(SPBT$TYPE,SPBT$,I);
                    FIX2 = GET(SPBT$TYPE,SPBT$,L);
                    IF (FIX1 EQ 1 AND FIX2 EQ 2 OR
                        FIX2 EQ 1 AND FIX1 EQ 2)
                       AND J LQ GET(SPBT$HIBOUND,SPBT$,L) 
                       AND K GQ GET(SPBT$LOBOUND,SPBT$,L) 
                    THEN BEGIN
                         IF FIX1 EQ 1 
                         THEN E = 312;
                         ELSE E = 313;
                         #(DIAG 312)# 
                         #THE RANGE OF AN INPUT PROCEDURE MUST# 
                         #NOT FORM PART OF ANY OUTPUT PROCEDURE#
                         #(DIAG 313)# 
                         #THE RANGE OF AN OUTPUT PROCEDURE MUST#
                         #NOT FORM PART OF ANY INPUT PROCEDURE# 
                         ERROR(JOD,E,REG1,REG2);
                         SET(SPBT$STATUS,SPBT$,I,1);
                         TEST I;
                         END
                    END #OF OVERLAP TESTING DO# 
                 END #OF INPUT OR OUTPUT PROCESSING#
            END #OF PASS 3 OUTER DO#
         END #OF SPBTPROCESSOR# 
SUB1: 
#LOCAL INITIALIZATION#
         NESTEDIF = 0;
         IMPSTATFLG = 0;
         G = 0; 
         FROZENGTEXT = 0; 
         PARSTATUS = 0; 
         SPBTLENGTH = CCTSPBTLEN; 
         LASTSDEF = 0;
         SEGMENT = 0; 
         LASTPNDEF = 0; 
         SET(DN$TYPE,DNAT$,0,ERRTYPE);
         PERFMRETURN = 0; 
         TRUEFALSE = 1; 
         INPUTDECL = 0; 
         OUTPUTDECL = 0;
         EXTENDDECL = 0;
         IODECL = 0;
         S = 0; 
         S$ = 0;
         DS = 0;
         DPROCEND = 0;
         GOFLAG = 0;
         DNATLENGTH = CCTDNATLEN; 
         PNATLENGTH = CCTPNATLEN; 
         CCTLSTGLPN = CCTPNATLEN; 
         LATLENGTH = CCTLATLEN; 
         FREEZEFLAG = 1;
         NSFLAG = 0;
         DSS$STK$PTR = -1;
         SRCH$STK$PTR = -1; 
         FL = -1; 
         SLENGTH = -1;
         OLENGTH = -1;
         BL = -1; 
         IF CCTSUBSOPTIM[0] 
         THEN OPTIMIZATION = 1; 
         CSTDEBUGSW = 0;
         MGROUPNUMBER = CMM$AGR(0); 
         CSTLENGTH = 60;
         REG1 = CMM$ALV(2*(CSTLENGTH+1),1,3,MGROUPNUMBER,P<CST>,0); 
         IF OPTIMIZATION EQ 1 
         THEN BEGIN 
              $BEGIN IF CSTTRACE THEN CSTDEBUGSW = 1; $END
              #INITIALIZE CST#
              CSTPURGE; 
              CSUBSFLAG = 0;
              CONDDEPTH = 1;
              END 
         ELSE SUBSCRIPT$ = 0; 
         RFTLENGTH = -1;
         CSTMAXNUM = 0; 
         ENDADDRESS = 0;
         ORADDRESS = 0; 
         Z = 0; 
         XPRIORITY(0,0);
         XADDRESS(0,0); 
         D$ = 0;
         DMAX$ = 100000;
         IDENTIFIER2 = 1; 
         BRTBLPTR = 0;
         BRTBLCOUNT = 0;
         AUXTLENGTH = CCTAUXTLEN; 
         CURRNTOFFSET = 0;
         MAXOFFSET = 0; 
          BASEOFFSET = 0; 
         MBACHAIN = 0;
         ALTEREDCHAIN = 0;
         SPBTPROCESSR;
         FREEZEFLAG = 1;
         TSCOPEFLAG = 0;
          IGROUPNUMBER = MGROUPNUMBER;
         REG1 = CMM$ALV(50,1,3,MGROUPNUMBER,P<MSTACK>,0); 
         MAXMD = 9; 
         MD = 0;
         REG1 = CMM$ALV(16,1,3,IGROUPNUMBER,P<ISTACK>,0); 
         MAXILX = 3;
         SETRTN;
         END
         TERM 
