*DECK BODYGRP 
USETEXT DNTEXT
USETEXT RPTEXT
PROC BODYGRP; 
          BEGIN 
  
          #BODY GROUPS ROUTINE# 
          #X# 
          #THIS ROUTINE#
          #- PERFORMS ANALYSIS REQUIRED BY THE RULES IN#
          #6.13.5.8 TABLE 3 BODY GROUP PRESENTATION RULES TABLE.# 
          #(GENERATED ROUTINES OBSERVE RULES 3, 4, AND 6, THUS IS#
          #NO ANALYSIS DONE HERE FOR RULE 3, 6, OR 4B.)#
          #- IF WORTHWHILE -# 
          #CALLS 1 OF THE FOLLOWING ROUTINES TO BUILD TABLES.#
          # BLDETAILTABL, BLD$CHTABLES, BUILD CFTABLS        #
          # THESE ROUTINES  # 
          #HAVE BEEN MADE INTERNAL PROCEDURES TO BODYGRP)#
  
          XREF   PROC         INTERCEPT;
          XREF   FUNC         PLTCNVRT I; 
          XREF   PROC         RWSET    ;
          XREF   PROC         RWSET1   ;
          XREF   PROC         GETNEXT  ;
          XREF   FUNC         RWGET    ;
          XREF   FUNC         RWGET1   ;
          XREF   FUNC         RP$AUXPTR;
          XREF PROC COPYD4; 
  
          ITEM   BGDIAGNO     I,
                 BGLINEREF    I,
                 INTPLTINDEX  I,
                 INTVALUE     I,
                 INTINDEX     I,
                 LASTABS      I,
                 RELINT       I,
                 RGDNATPTR    I,
                 AUXINDEX     I,
                 LLN          I,
                 NGFIRSTDTAIL I,
                 NGFOOTING    I,
                 BGFPLP       I,
                 NEWPLTINDEX  I,
                 PLT4LOWLIMIT I,
                 NLENGTH      I,
                 GRUPITEMLGTH I,
                 BPTABLDNAT   I,
                 NGTABLEDNAT  I,
                 BASEDEPLTABL I,
                 SAUXINDEX    I,
                 NEXTAUXENTRY I,
                 BASEDELNTABL I,
                 BASEDERGTABL I,
                 DET1PARANAME I,
                 BASECHPLTABL I,
                 BASECHLNTABL I,
                 BASECHRGTABL I,
                 BASEROLLFRWD I,
                 NEXTENTRYAUX I,
                 BASERESETBTB I,
                 BASEARESETTB I,
                 BASECFPLTABL I,
                 BASECFLNTABL I,
                 BASECFRGTABL I,
                 RUINDEX      I,
                 RGINDEX      I,
                 RPTDNATPTR   I,
                 CURBASSUMCTR I,
                 SUMIDINDEX   I,
                 BASECROSFOOT I,
                 INTEGERVALUE I,
                 $TEMP$       I,
                 CHARVALUE    C(3), 
                 CHARTEMP     C(20),
                 $DUMMY$      I,
                   $DUM$ ,
                 SAVEDPTR    I, 
                 BFLAGS       I;
  
  
          DEF INT1CONVERT #INTVALUE = PLTCNVRT(INTPLTINDEX)#; 
  
          DEF    GET          #GETFIELD#  ; 
          DEF    GETQ         #GETQUICK#  ; 
          DEF    SET          #SETFIELD#  ; 
  
  
  
          DEF    RSTFLAG      #B< 0,1>BFLAGS#;
          DEF    FOUNDDETAIL  #B< 1,1>BFLAGS#;
          DEF    ROLLF$FLAG   #B< 2,1>BFLAGS#;
          DEF    CFIDENT      #B< 3,1>BFLAGS#;
          DEF    DELFLAG      #B< 4,1>BFLAGS#;
          DEF    COND4D       #B< 5,1>BFLAGS#;
          DEF    COND6F       #B< 6,1>BFLAGS#;
          DEF    USEDENTRYBIT #B< 7,1>BFLAGS#;
          DEF    M84          #84#; 
          DEF    M85          #85#; 
          DEF    M86          #86#; 
          CONTROL EJECT;
*CALL RPCOMM
*CALL AUXT1 
*CALL AUXTVALS
*CALL DNATVALS
*CALL GETSET
*CALL PLT1
*CALL PLTVALS 
*CALL PNAT1 
*CALL TABLNAMES 
  
*CALL INT1
*CALL CTXTVALS
*CALL CTEXT 
          ARRAY SAUB[0:0] S(1); 
           BEGIN
           ITEM   SAUBATM          CT$ATOM; 
           ITEM   SAUBTYPE         CT$TYPE2;
           ITEM   SAUBVALUE        CT$VALUE2; 
           END
          CONTROL EJECT;
          #     CHANGE SAUX SUBSCRIPT ENTRY TO POINT DIRECTLY TO     #
          #      THE DNAT INSTEAD OF THE INT                         #
XDEF     PROC     SAUBCHANGE; 
PROC SAUBCHANGE(NDX); 
         BEGIN
  
          ITEM     NDX; 
  
               NDX = NDX + 1; 
         FOR $DUMMY$ = 0 WHILE
            RWGET(RALASTSINTRY,NDX) NQ 1 DO 
              BEGIN 
              SAUBATM = RWGET(RASICTEXT,NDX); 
              IF SAUBTYPE EQ CTDNREF THEN 
                 BEGIN
                 SAUBVALUE = GETQUICK(IN$DNAT,INT$,SAUBVALUE);
                 RWSET(RASICTEXT,NDX,SAUBATM);
                 END
             NDX = NDX + 1; 
             END
          RETURN; 
         END
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO 1# 
  
PROC RT$BGDIAG; 
          BEGIN 
  
          #PARAMETERS = BGDIAGNO# 
          #BGLINEREF# 
  
          ANALONLYRGRP = 1; 
          CALLDDIAG(BGLINEREF,BGDIAGNO);
          END #RT$BGDIAG# 
  
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE  NO. 3# 
  
PROC BLDGROUPDNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,1); 
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          #LITERALLY "7".#
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9) / 10 ) * 10; 
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,GRUPITEMLGTH); 
          #DO NOT UPDATE OFFSET-  SO THAT FIRST ELEMENTARY ITEM#
          #WILL HAVE SAME BYTE OFFSET#
          SET(DN$TYPE,DNAT$,LASTDNATINDX,GROUP);
          END #BLDGROUPDNAT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 4#
  
PROC BLDTYPEDNAT; 
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,2); 
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9 ) / 10 ) * 10;
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,10); 
          RDLBYTOFFSET = RDLBYTOFFSET+ 10;
          SET(DN$TYPE,DNAT$,LASTDNATINDX,COMP1);
          SET(DN$POINT,DNAT$,LASTDNATINDX,0); 
          SET(DN$NUMLEN,DNAT$,LASTDNATINDX,1);
          #1 DEC DIGIT# 
          END #BLDTYPEDNAT# 
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 5#
  
PROC BLD99999DNAT;
          BEGIN 
          LASTDNATINDX = LASTDNATINDX + 1;
          SET(DN$LEVEL,DNAT$,LASTDNATINDX,2); 
          SET(DN$MAJMSEC,DNAT$,LASTDNATINDX,RDMSEC);
          RDLBYTOFFSET = ((RDLBYTOFFSET + 9 ) / 10 ) * 10;
          SET(DN$LONGOFF,DNAT$,LASTDNATINDX,RDLBYTOFFSET);
          SET(DN$ITMLEN,DNAT$,LASTDNATINDX,10); 
          RDLBYTOFFSET  = RDLBYTOFFSET+ 10; 
          SET(DN$TYPE,DNAT$,LASTDNATINDX,COMP1);
          SET(DN$POINT,DNAT$,LASTDNATINDX,0); 
          SET(DN$NUMLEN,DNAT$,LASTDNATINDX,6);
          #PIC 999999#
          END #BLD99999DNAT#
          CONTROL EJECT;
  
          #INTERNAL PROCEDURE NO. 6#
  
PROC CONST$NEWPLT;
          BEGIN 
          #THIS RT. CONSTRUCTS A NEW PLT ENTRY FOR/CONTAINING#
          #WHATEVER INTEGER IS CONTAINED IN INTEGERVALUE# 
          #ON ENTRANCE.IT LEAVES THE PLT INDEX OF THE NEW PLT ENTRY IN# 
          #NEWPLTINDEX  ON EXIT.# 
  
          ITEM VALUE; 
          ITEM LENGTH;
           ITEM REMAINS;
          ITEM OUTDEX;
          ITEM C10       C(10); 
  
          VALUE = INTEGERVALUE; 
          IF VALUE EQ 0 
          THEN
              BEGIN 
              LENGTH = 1; 
              C<0,1> CHARTEMP = "0";
              END 
          ELSE
              BEGIN 
              OUTDEX = 10;
              FOR LENGTH = 0 STEP 1 WHILE VALUE NQ 0 DO 
                  BEGIN 
                  OUTDEX = OUTDEX - 1;
                  REMAINS = VALUE / 10; 
                  C<OUTDEX,1> C10 = VALUE - 10 * REMAINS + O"33"; 
                  VALUE = REMAINS;
                  END 
              C<0,LENGTH> CHARTEMP = C<OUTDEX,LENGTH> C10;
              END 
          #INTEGER IS CONVERTED TO CHARACTER (LEFT JUSTIFIED)#
          SET(PL$LENGTH,PLT$,RPPLTOFFSET,LENGTH); 
          SET(PL$TYPE,PLT$,RPPLTOFFSET,PLTUNSGNILIT); 
          SET(PL$LINE,PLT$,RPPLTOFFSET,0);
          SET(PL$COLUMN,PLT$,RPPLTOFFSET,0);
          SETPLST(RPPLTOFFSET,LOC(CHARTEMP)); 
          NEWPLTINDEX = RPPLTOFFSET;
          RPPLTOFFSET = RPPLTOFFSET + 1;
          END #CONST$NEWPLT#
          CONTROL EJECT;
          #**********************************************#
          #INTERNAL PROCEDURE  NO. 8# 
  
PROC BODYPAGINGTB;
          BEGIN 
          #RETURNS PARAM. IN  BPTABLDNAT# 
          BPTABLDNAT  = 0;
          IF IPAGECLAUSPC EQ 0
              OR
              SEQOFLN EQ NULL$LN
          THEN
              GOTO ENDBPT;
          #BUILD DNAT, PLT, AND LAT ENTRIES FOR THE FOLLOWING#
          #X# 
          #01 DETAIL-N-TABLE, CH-00N-TABLE, CF-00N-TABLE# 
          #02 TYPE-OF-LINE-NUMBER      PIC  9#
          #02 FIRST-LINE-NUMBER        PIC  999999# 
          #02 LOWER$LIMIT               PIC  999999#
          #02 LENGTH$RG       PIC  999999 (IF REL.)#
  
  
          #CONSTRUCT DNAT ENTRY FOR GROUP ITEM# 
  
          GRUPITEMLGTH  = 40; 
          BLDGROUPDNAT; 
          BPTABLDNAT      = LASTDNATINDX; 
  
          #CONSTRUCT DNAT ENTRY FOR 1ST ELEMENTARY ITEM#
  
          BLDTYPEDNAT;
  
          #BUILD PLT ENTRY CONTAINING VALUE TO INDICATE WHETHER#
          #TYPE(SEQ) OF LINE NUMBER =  AR, R, OR NPR# 
  
          INTEGERVALUE  = SEQOFLN;
          #1, 2, OR  3# 
          CONST$NEWPLT; 
  
          #ENSURE THAT  02 TYPE-OF-LINE-NUMBER WILL BE #
          #INITIALIZED TO  1(AR), 2(R), 3(NPR)# 
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, NEWPLTINDEX); 
  
          #CONSTRUCT DNAT ENTRY FOR 2ND ELEM. ITEM# 
  
          BLD99999DNAT; 
  
          #INITIALIZE NEW DNAT# 
          #TO THE FIRST LINE NUMBER OF THE REPORT GROUP#
  
          $TEMP$ = RWGET(RALINENUMPLT,RP$AUXPTR(INDX1STLN));
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, $TEMP$);
  
          #CONSTRUCT DNAT FOR 3RD ELEM. ITEM# 
  
          BLD99999DNAT; 
  
          #INITIALIZE NEW DNAT# 
          #TO THE LOWER$LIMIT  FOR THIS REPORT GROUP# 
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, PLT4LOWLIMIT);
  
          #CONSTRUCT DNAT FOR 4TH ELEM. ITEM# 
  
          BLD99999DNAT; 
  
          #INITIALIZE NEW DNAT# 
          #TO LENGTH$RG # 
          #- BUT FIRST BUILD NEW PLT ENTRY TO CONTAIN LENGTH REPORT#
          #GROUP# 
          INTEGERVALUE = LLN; 
          CONST$NEWPLT; 
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, NEWPLTINDEX); 
ENDBPT: 
          END #BODYPAGINGTB#
          CONTROL EJECT;
          #**********************************************#
          #**********************************************#
          #INTERNAL PROCEDURE NO. 9#
  
PROC NGSPACINGTBL;
          BEGIN 
          #RETURNS PARAM. IN NGTABLEDNAT.#
          NGTABLEDNAT = 0;
          IF IPAGECLAUSPC EQ 0
              #RULE 6F DOESN"T USE THIS TABLE#
  
              OR
              SEQOFLN EQ NULL$LN
              OR
              TNEXTGROUP EQ NULLNG
          THEN
              GOTO ENDNGT;
  
          #BUILD DNAT, PLT, AND LAT ENTRIES FOR THE FOLLOWING#
          #X# 
          #01 NG-DETAIL-N-TABLE, NG-CH-00N-TABLE, NG-CF-00N-TABLE#
          #02 TYPE-OF-NEXT-GROUP      PIC 9#
          #02 NEXT-GROUP-INTEGER      PIC 999999# 
  
  
          #CONSTRUCT DNAT ENTRY FOR GROUP ITEM# 
  
          GRUPITEMLGTH = 20;
          BLDGROUPDNAT; 
          NGTABLEDNAT  = LASTDNATINDX;
  
          #CONSTRUCT DNAT ENTRY FOR 1ST ELEMENTARY ITEM#
  
          BLDTYPEDNAT;
  
          #BUILD PLT ENTRY CONTAINING VALUE TO INDICATE WHETHER#
          #TYPE-OF-NEXT-GROUP =  A, R, OR NP# 
  
          INTEGERVALUE  = TNEXTGROUP; 
          #1, 2, OR 3#
          CONST$NEWPLT; 
  
          #ENSURE THAT 02 TYPE-OF-NEXT-GROUP WILL BE# 
          #INITIALIZED TO 1(A), 2(R), 3(NP)#
  
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, NEWPLTINDEX); 
  
          #CONSTRUCT DNAT ENTRY FOR 2ND ELEM.  ITEM#
  
          BLD99999DNAT; 
  
          #ENSURE THAT NEW DNAT IS INITIALIZED# 
          #TO THE NEXT GROUP INTEGER# 
  
          IF TNEXTGROUP EQ 3
              #NEXT PAGE# 
          THEN
              GOTO ENDNGT;
          $TEMP$ = RWGET(RANGINTPLT,RP$AUXPTR(DNATPOINTER)+ 1); 
          SET(DN$VALUE,DNAT$,LASTDNATINDX, 1);
          SET(DN$PLTPTR,DNAT$,LASTDNATINDX, $TEMP$);
ENDNGT: 
          END #NGSPACINGTBL#
          CONTROL EJECT;
          #***********************************************# 
  
          #INTERNAL  PROCEDURE NO.   10#
  
PROC GEN$RG$PNAT; 
          BEGIN 
           #GEN A NEW PARAGRAPH NAME #
          LASTPNATINDX = LASTPNATINDX + 1;
          SET(PN$PREVSECTN,PNAT$,LASTPNATINDX,RPDUMSECTION);
          #SEE"ONCE-ONLY"SECTION# 
          #NOT A SOURCE STATEMENT ITEM# 
          END #GEN$RG$PNAT# 
          CONTROL  EJECT; 
     #     INTERNAL PROCEDURE NO 11     # 
PROC SKIPSUB(INDX); 
           BEGIN
          ITEM  INDX; 
LOOPSUB:  
          INDX = INDX + 1;
          IF RWGET(RALASTSINTRY,INDX) NQ 1 THEN 
              GOTO LOOPSUB; 
          RETURN; 
          END #SKIPSUB#;
          CONTROL EJECT;
          #***********************************************************# 
PROC BLDETAILTABL;
          BEGIN 
  
          #BUILD DETAIL TABLES ROUTINE# 
          #X# 
          #THIS ROUTINE#
          #- ADDS AN ENTRY TO RGTLINK#
          #- BUILDS DETAIL-N-PRINT-LINE-TABLE (DEPLLINK)# 
          #- BUILDS DETAIL-N-LN-TABLE  (DELNLINK)#
          #- BUILDS DETAIL-N-RG-TABLE  (DERGLINK)#
          #- BUILDS NG-DETAIL-N-TABLE#
          #- BUILDS DETAIL-N-TABLE (FOR BODY-PAGING)# 
          #- ADDS TO GROUP-INDICATED-TABLE# 
          #- SETS UP PARAGRAPH NAMES FOR P-PARSER IN AUX-TABLE ENTRY# 
          #ASS. WITH DNAT FOR DETAIL-N.#
          #***********************************************# 
          #BUILD TABLES FOR DETAIL REPORT GROUP#
  
  
          #BUILD  DETAIL-N-TABLE IF NECESSARY#
  
          BODYPAGINGTB; 
  
          #BUILD NG-DETAIL-N-TABLE IF NECESSARY#
  
          NGSPACINGTBL; 
  
          #BUILD DEPLLINK   (DETAIL-N-PRINT-LINE-TABLE)#
  
          IF SEQOFLN  EQ NULL$LN
          THEN
              GOTO B$DERGTABLE; 
          #WILL NOT BUILD DEPLLINK# 
          #NOR       DELNLINK#
          BASEDEPLTABL = NEXTDEPLPTR; 
          USEDENTRYBIT = 0; 
          GETNEXT(DEPLLINK);
          #WILL HAVE TO HAVE ENTRY FOR DELIMITER EVEN IF ARE NO#
          #PRINTABLE ITEMS - SO THAT CAN PRINT A LINE OF BLANKS.# 
          IF INDX1STLN LS FIRSTF3OR4DE
          THEN
              $TEMP$ = FIRSTF3OR4DE;
          ELSE
              $TEMP$ = INDX1STLN; 
          FOR RGDNATPTR = $TEMP$ STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              RWSET1(PL$DNATDE  #CURRDEPLPTR#,0); 
              IF RWGET(RAPRINTABLEB,AUXINDEX) EQ 0
              THEN
                  GOTO DEPL2; 
              #ELSE PUT PRINTABLE ITEM INTO  DEPLLINK#
              USEDENTRYBIT = 1; 
              RWSET1(ALLVALUE$DE  #CURRDEPLPTR#,0); 
              RWSET1(SISOURCE$DE  #CURRDEPLPTR#,0); 
              RWSET1(PL$DNATDE  #CURRDEPLPTR#,RGDNATPTR); 
              RWSET1(PL$DE$DELIM  #CURRDEPLPTR#,0); 
              RWSET1(GROUPINDITEM  #CURRDEPLPTR#,0);
              IF RWGET(RAGROUPBIT,AUXINDEX) EQ 1
              THEN
                  RWSET1(GROUPINDITEM  #CURRDEPLPTR#,1);
              IF RWGET(RASOURCEBIT,AUXINDEX) EQ 1 
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPEDE  #CURRDEPLPTR#,1);
                  #SOURCE#
                  SAUXINDEX = 1 + AUXINDEX; 
                  IF RWGET(RASRCESIBIT,SAUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      RWSET1(SISOURCE$DE  #CURRDEPLPTR#,1); 
                      RWSET1(PI$SOURCEDE  #CURRDEPLPTR#,SAUXINDEX); 
#          CHANGE SAUX ENTRY TO POINT TO DNAT INSTEAD OF INT          # 
                      SAUBCHANGE(SAUXINDEX);
                      GOTO DEPL2; 
                      END 
                  $TEMP$ = RWGET(RASRCEIDNAT,SAUXINDEX);
                  RWSET1(PI$SOURCEDE  #CURRDEPLPTR#,$TEMP$);
                  GOTO DEPL2; 
                  END 
  
              #ELSE IF HAVE VALUE CLAUSE# 
  
              RWSET1(ITEMTYPEDE  #CURRDEPLPTR#,0);
              #VALUE# 
              $TEMP$ = RWGET(RAVALULITPLT,1 + AUXINDEX);
              RWSET1(PI$SOURCEDE  #CURRDEPLPTR#,$TEMP$);
              IF RWGET(RAVALUALLIND,1 + AUXINDEX) EQ 1
              THEN
                  RWSET1(ALLVALUE$DE  #CURRDEPLPTR#,1); 
DEPL2:  
              IF RGDNATPTR EQ LASTRGDNAT
              THEN
                  BEGIN 
                  RWSET1(PL$DE$DELIM  #CURRDEPLPTR#,ENDREPORTGRP);
                  GOTO ENDEPLDO;
                  END 
  
              #ELSE CHECK IF NEXT ENTRY HAS A LINE NUMBER#
  
              NEXTENTRYAUX = RP$AUXPTR(RGDNATPTR + 1);
              IF RWGET(RA1LINENOPLT,NEXTENTRYAUX) EQ 0
              THEN
                  GOTO DEPL$EL; 
              RWSET1(PL$DE$DELIM  #CURRDEPLPTR#,ENDPRINTLINE);
              USEDENTRYBIT = 1; 
DEPL$EL:  
              IF USEDENTRYBIT EQ 0
              THEN
                  GOTO ENDEPLDO;
              USEDENTRYBIT = 0; 
              GETNEXT(DEPLLINK);
ENDEPLDO: 
              END 
          #******************************************#
          #BUILD DELNLINK  (DETAIL-N-LINE-NUMBER-TABLE)#
  
          BASEDELNTABL = NEXTDELNPTR; 
          FOR RGDNATPTR = INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
              THEN
                  BEGIN 
                  GETNEXT(DELNLINK);
                  $TEMP$ = RWGET(RALINENUMPLT,AUXINDEX);
                  RWSET1(LNINT$PLTDE  #CURRDELNPTR#,$TEMP$);
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                  THEN
                      RWSET1(KIND$LNINTDE  #CURRDELNPTR#,ABSOLUTE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ RELATEVE 
                  THEN
                      RWSET1(KIND$LNINTDE  #CURRDELNPTR#,RELATEVE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ NEXTPAGEABSL 
                  THEN
                      RWSET1(KIND$LNINTDE  #CURRDELNPTR#,NEXTPAGEABSL); 
                  END 
              END 
          #**************************************#
          #BUILD DERGLINK#
  
B$DERGTABLE:  
          #(DETAIL-N-REPORT-GROUPS-TABLE)#
          BASEDERGTABL = NEXTDERGPTR; 
          GETNEXT(DERGLINK);
          RWSET1(RG$NAMEDE  #CURRDERGPTR#,DNATPOINTER); 
          RWSET1(TYPEOFRGDE  #CURRDERGPTR#,DE); 
          IF SEQOFLN EQ NULL$LN 
          THEN
              BEGIN 
              RWSET1(DELN$BASE  #CURRDERGPTR#,0); 
              RWSET1(DEPL$BASE  #CURRDERGPTR#,0); 
              RWSET1(COND4DDE  #CURRDERGPTR#,0);
              RWSET1(BPTBL$DNATDE  #CURRDERGPTR#,0);
              RWSET1(COND6FDE  #CURRDERGPTR#,0);
              RWSET1(NG$INFODE  #CURRDERGPTR#,0); 
              GOTO DEB$RGSTABLE;
              END 
          RWSET1(DELN$BASE  #CURRDERGPTR#,BASEDELNTABL);
          RWSET1(DEPL$BASE  #CURRDERGPTR#,BASEDEPLTABL);
          RWSET1(BPTBL$DNATDE  #CURRDERGPTR#,0);
          IF COND4D EQ 1
          THEN
              BEGIN 
              RWSET1(COND4DDE  #CURRDERGPTR#,1);
              GOTO DE$C6; 
              END 
          IF BPTABLDNAT  NQ  0
          THEN
              RWSET1(BPTBL$DNATDE  #CURRDERGPTR#,BPTABLDNAT); 
DE$C6:  
          RWSET1(NG$INFODE  #CURRDERGPTR#,0); 
          IF COND6F EQ 1
          THEN
              BEGIN 
              RWSET1(COND6FDE  #CURRDERGPTR#,1);
              $TEMP$ = RWGET(RANGINTPLT,RP$AUXPTR(DNATPOINTER)+ 1); 
              RWSET1(NG$INFODE  #CURRDERGPTR#,$TEMP$);
              GOTO  DEB$RGSTABLE; 
              END 
          IF NGTABLEDNAT  NQ 0
          THEN
              RWSET1(NG$INFODE  #CURRDERGPTR#,NGTABLEDNAT); 
          #**********************************************#
          #BUILD RGTLINK ENTRY# 
  
DEB$RGSTABLE: 
          GETNEXT(RGTLINK); 
          RWSET1(RGEOTDELIM  #CURRRPTGRPTR#,0); 
          RWSET1(RGTYPEOFRG  #CURRRPTGRPTR#,DE);
          RWSET1(RGBASERGTABL  #CURRRPTGRPTR#,BASEDERGTABL);
          #GEN NEW PARAGRAPH NAMES# 
          GEN$RG$PNAT;
          RWSET1(RGPARANAME1  #CURRRPTGRPTR#,LASTPNATINDX); 
          DET1PARANAME = LASTPNATINDX;
          GEN$RG$PNAT;
          RWSET1(RGPARANAME2  #CURRRPTGRPTR#,LASTPNATINDX); 
          GEN$RG$PNAT;
          SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
          RWSET1(RGPARANAME3  #CURRRPTGRPTR#,LASTPNATINDX); 
          #***********************************************# 
          #COMPLETE TYPE AUXRPWGEN ENTRY FOR     #
          #DNAT FOR DETAIL-N,TO CONTAIN THE FIRST AND LAST PARAGRAPH# 
          #NAMES THAT APPEAR IN THE REPORT GROUP TABLE #
          #ENTRY.  PPARSER WILL USE THEM IN A PERFORM#
          #STATEMENT IF IT        # 
          #ENCOUNTERS A "GENERATE DETAIL-N."# 
  
          #(THIS AUX-TABLE ENTRY WAS INITIALLY BUILT BY THE TYPE CLAUSE#
          #RT WHEN IT FOUND DNAT LEVEL = 01 AND REPORT GROUP  # 
          #TYPE = DETAIL. IT SETS SUPPERF BIT = 1 SO NOW WILL # 
          #TURN IT OFF   #
          #SINCE ARE NO SERIOUS USER ERRORS.)#
  
          LASTAUXENTRY = GETQ(DN$AUXREF,DNAT$,DNATPOINTER); 
          SET(AX$SUPPERF,AUX$,LASTAUXENTRY,0);
          SET(AX$1DETPAR,AUX$,LASTAUXENTRY,DET1PARANAME); 
          SET(AX$LSTDETPAR,AUX$,LASTAUXENTRY,LASTPNATINDX); 
          #**************************************************#
          #BUILD GROUP-INDICATED-TABLE  ENTRY#
  
          GETNEXT(GRINDLINK); 
          RWSET1(GITEOT$DELIM  #CURRGRINDPTR#,0); 
          RWSET1(DEGROUPDNAT  #CURRGRINDPTR#,DNATPOINTER);
          RWSET1(GIFLAG$DNAT  #CURRGRINDPTR#,0);
          FOR RGDNATPTR = FIRSTF3OR4DE STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RAGROUPBIT,AUXINDEX) EQ 1
              THEN
                  BEGIN 
                  #GENERATE A GROUP-INDICATED-FLAG# 
  
                  BLDTYPEDNAT;
                  #MODIFY DNAT TO FIT A SWITCH# 
                  SET(DN$LEVEL,DNAT$,LASTDNATINDX,1); 
                  RWSET1(GIFLAG$DNAT  #CURRGRINDPTR#,LASTDNATINDX); 
                  RGDNATPTR = LASTRGDNAT; 
                  END 
              END 
          #*********************************************# 
          END #BLDETAILTABL#
          CONTROL EJECT;
PROC BLD$CHTABLES;
          BEGIN 
  
          #BUILD CONTROL HEADING TABLES ROUTINE#
          #X# 
          #THIS ROUTINE#
          #- ADDS AN ENTRY TO RGTLINK#
          #- BUILDS CONTROL-HEADING-00N-REPORT-GROUP-TABLE(CHRGLINK)# 
          #- BUILDS CONTROL-HEADING-00N-LINE-NUMBER-TABLE(CHLNLINK)#
          #- BUILDS CONTROL-HEADING-00N-PRINT-LINE-TABLE(CHPLLINK)# 
          #- BUILDS NG-CH-00N-TABLE#
          #- BUILDS CH-00N-TABLE (FOR BODY PAGING)# 
          #- ADDS INFORMATION TO CONTROLSLINK#
  
  
          #BUILD CH-00N-TABLE IF NECESSARY# 
  
          BODYPAGINGTB; 
  
          #BUILD NG-CH-00N-TABLE  IF NECESSARY# 
  
          NGSPACINGTBL; 
          #*****************************************************# 
          #BUILD CHPLLINK  (CONTROL HEADING 00N PRINT LINE TABLE)#
  
          IF SEQOFLN EQ NULL$LN 
          THEN
              #WILL NOT BUILD CHPLLINK# 
          #NOR  CHLNLINK# 
          GOTO B$CHRGTABLE; 
          BASECHPLTABL = NEXTCHPLPTR; 
          USEDENTRYBIT = 0; 
          GETNEXT(CHPLLINK);
          #WILL HAVE TO HAVE ENTRY(S) FOR DELIMITERS EVEN IF ARE# 
          #NO PRINTABLE ITEMS - SO THAT CAN PRINT A LINE OF BLANKS.#
          IF INDX1STLN LS FIRSTF3OR4DE
          THEN
              $TEMP$ = FIRSTF3OR4DE;
          ELSE
              $TEMP$ = INDX1STLN; 
          FOR RGDNATPTR = $TEMP$ STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              RWSET1(PL$DNATCH  #CURRCHPLPTR#,0); 
              IF RWGET(RAPRINTABLEB,AUXINDEX) EQ 0
              THEN
                  GOTO CHPL$2;
              #ELSE PUT PRINTABLE INTO  RFPLLINK# 
              RWSET1(ALLVALUE$CH  #CURRCHPLPTR#,0); 
              RWSET1(SISOURCE$CH  #CURRCHPLPTR#,0); 
              RWSET1(PL$DNATCH  #CURRCHPLPTR#,RGDNATPTR); 
              RWSET1(PL$CH$DELIM  #CURRCHPLPTR#,0); 
              USEDENTRYBIT = 1; 
              IF RWGET(RASOURCEBIT,AUXINDEX) EQ 1 
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPECH  #CURRCHPLPTR#,1);
                  SAUXINDEX = 1 + AUXINDEX; 
                  IF RWGET(RASRCESIBIT,SAUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      RWSET1(SISOURCE$CH  #CURRCHPLPTR#,1); 
                      RWSET1(PI$SOURCECH  #CURRCHPLPTR#,SAUXINDEX); 
                 SAUBCHANGE(SAUXINDEX); 
                      GOTO CHPL$2;
                      END 
                  $TEMP$ = RWGET(RASRCEIDNAT,SAUXINDEX);
                  RWSET1(PI$SOURCECH  #CURRCHPLPTR#,$TEMP$);
                  GOTO CHPL$2;
                  END 
  
              #ELSE IF HAVE VALUE CLAUSE# 
  
              RWSET1(ITEMTYPECH  #CURRCHPLPTR#,0);
              $TEMP$ = RWGET(RAVALULITPLT,1 + AUXINDEX);
              RWSET1(PI$SOURCECH  #CURRCHPLPTR#,$TEMP$);
              IF RWGET(RAVALUALLIND,1 + AUXINDEX) EQ 1
              THEN
                  RWSET1(ALLVALUE$CH  #CURRCHPLPTR#,1); 
CHPL$2: 
              IF RGDNATPTR EQ LASTRGDNAT
              THEN
                  BEGIN 
                  RWSET1(PL$CH$DELIM  #CURRCHPLPTR#,ENDREPORTGRP);
                  GOTO ENDCHPLDO; 
                  END 
  
              #ELSE CHECK IF NEXT ENTRY HAS A LINE NUMBER#
  
              NEXTENTRYAUX = RP$AUXPTR(RGDNATPTR + 1);
              IF RWGET(RA1LINENOPLT,NEXTENTRYAUX) EQ 0
              THEN
                  GOTO CHPL$EL; 
              RWSET1(PL$CH$DELIM  #CURRCHPLPTR#,ENDPRINTLINE);
              USEDENTRYBIT = 1; 
CHPL$EL:  
              IF USEDENTRYBIT EQ 0
              THEN
                  GOTO ENDCHPLDO; 
              USEDENTRYBIT = 0; 
              GETNEXT(CHPLLINK);
ENDCHPLDO:  
              END 
          #******************************************#
          #BUILD CHLNLINK#
  
          BASECHLNTABL = NEXTCHLNPTR; 
          FOR RGDNATPTR = INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
              THEN
                  BEGIN 
                  GETNEXT(CHLNLINK);
                  $TEMP$ = RWGET(RALINENUMPLT,AUXINDEX);
                  RWSET1(LNINT$PLTCH  #CURRCHLNPTR#,$TEMP$);
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                  THEN
                      RWSET1(KIND$LNINTCH  #CURRCHLNPTR#,ABSOLUTE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ RELATEVE 
                  THEN
                      RWSET1(KIND$LNINTCH  #CURRCHLNPTR#,RELATEVE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ NEXTPAGEABSL 
                  THEN
                      RWSET1(KIND$LNINTCH  #CURRCHLNPTR#,NEXTPAGEABSL); 
                  END 
              END 
          #**************************************#
          #BUILD CHRGLINK#
  
B$CHRGTABLE:  
          BASECHRGTABL = NEXTCHRGPTR; 
          GETNEXT(CHRGLINK);
          RWSET1(RG$NAMECH  #CURRCHRGPTR#,DNATPOINTER); 
          RWSET1(TYPEOFRGCH  #CURRCHRGPTR#,CH); 
          IF SEQOFLN EQ NULL$LN 
          THEN
              BEGIN 
              RWSET1(CHLN$BASE  #CURRCHRGPTR#,0); 
              RWSET1(CHPL$BASE  #CURRCHRGPTR#,0); 
              RWSET1(COND4DCH  #CURRCHRGPTR#,0);
              RWSET1(BPTBL$DNATCH  #CURRCHRGPTR#,0);
              RWSET1(COND6FCH  #CURRCHRGPTR#,0);
              RWSET1(NG$INFOCH  #CURRCHRGPTR#,0); 
              GOTO CHB$RGSTABLE;
              END 
          RWSET1(CHLN$BASE  #CURRCHRGPTR#,BASECHLNTABL);
          RWSET1(CHPL$BASE  #CURRCHRGPTR#,BASECHPLTABL);
          RWSET1(BPTBL$DNATCH  #CURRCHRGPTR#,0);
          IF COND4D EQ 1
          THEN
              BEGIN 
              RWSET1(COND4DCH  #CURRCHRGPTR#,1);
              GOTO CH$C6; 
              END 
          IF BPTABLDNAT  NQ  0
          THEN
              RWSET1(BPTBL$DNATCH  #CURRCHRGPTR#,BPTABLDNAT); 
CH$C6:  
          RWSET1(NG$INFOCH  #CURRCHRGPTR#,0); 
          IF COND6F EQ 1
          THEN
              BEGIN 
              RWSET1(COND6FCH  #CURRCHRGPTR#,1);
              $TEMP$ = RWGET(RANGINTPLT,RP$AUXPTR(DNATPOINTER)+ 1); 
              RWSET1(NG$INFOCH  #CURRCHRGPTR#,$TEMP$);
              GOTO  CHB$RGSTABLE; 
              END 
          IF NGTABLEDNAT  NQ 0
          THEN
              RWSET1(NG$INFOCH  #CURRCHRGPTR#,NGTABLEDNAT); 
          #**********************************************#
          #BUILD RGTLINK ENTRY# 
  
CHB$RGSTABLE: 
          GETNEXT(RGTLINK); 
          RWSET1(RGEOTDELIM  #CURRRPTGRPTR#,0); 
          RWSET1(RGTYPEOFRG  #CURRRPTGRPTR#,CH);
          RWSET1(RGBASERGTABL  #CURRRPTGRPTR#,BASECHRGTABL);
  
          #NOTE#
          #RGPARANAME1  IS FILLED WITH# 
          #DNAT INDEX OF CONTROL IDENTIFIER WHEN TYPE OF RG = CH.#
          $TEMP$ = RWGET(RACONTRLDNAT,RP$AUXPTR(DNATPOINTER));
          RWSET1(RGPARANAME1  #CURRRPTGRPTR#,$TEMP$); 
          #*******************************************************# 
          #ADD TO  CONTROLSLINK#
  
          CURRCNTRLPTR = STRTCURCONTB;
FINDMATCHGCI: 
          IF RWGET1(CID$DNAT  #CURRCNTRLPTR#) EQ
              RWGET(RACONTRLDNAT,RP$AUXPTR(DNATPOINTER))
          THEN
              BEGIN 
              RWSET1(CH$BIT  #CURRCNTRLPTR#,1); 
              GEN$RG$PNAT;
              RWSET1(CH$PNAT  #CURRCNTRLPTR#,LASTPNATINDX); 
              GEN$RG$PNAT;
              SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
              RWSET1(CH$EXIT$PNAT  #CURRCNTRLPTR#,LASTPNATINDX);
              GOTO  ENDBCHT;
              END 
          CURRCNTRLPTR =  RWGET1(CONTROLSLINK  #CURRCNTRLPTR#); 
          GOTO FINDMATCHGCI;
          #****************************************#
ENDBCHT:  
          END #BLD$CHTABLES#
          CONTROL EJECT;
PROC BUILDCFTABLS;
          BEGIN 
  
          #BUILD CONTROL FOOTING TABLES ROUTINE#
          #X# 
          #THIS ROUTINE#
          #- BUILDS CF-00N-TABLE  (FOR BODY PAGING)#
          #- BUILDS NG-CF-00N-TABLE#
          #- BUILDS CONTROL-FOOTING-00N-PRINT-LINE-TABLE(CFPLLINK)# 
          #- BUILDS CONTROL-FOOTING-00N-LINE-NUMBER-TABLE(CFLNLINK)#
          #- BUILDS CF-00N-CROSSFOOTING-TABLE (CROSFOOTLINK)# 
          #- ADDS TO SUM-COUNTER-TABLE  (SUMCNTRLINK)#
          #- BUILDS CF-00N-ROLLING-FORWARD-TABLE (ROLFRWDLINK)# 
          #- BUILDS RESET-A-TABLE  (ARESETLINK)#
          #- BUILDS RESETBLINK# 
          #- ADDS TO   INITIAL  SUBTOTALLING TABLE(ISUBTLINK)#
          #- ADDS TO  CONTROLSLINK# 
          #- BUILDS CFRG (INCLUDES SUM CLAUSE) #
          #- ADDS AN ENTRY TO RGTLINK#
          #NOTE#
          #THE TABLES MUST BE BUILT IN THE ORDER  THEY ARE LISTED#
          #HERE. THE CODE IS VERY DEPENDENT ON THAT.# 
          #/* ****************************************************# 
  
          #BUILD CF-00N TABLE IF NECESSARY# 
  
          BODYPAGINGTB; 
  
          #BUILD NG-CF-00N-TABLE  IF NECESSARY# 
  
          NGSPACINGTBL; 
          #******************************************#
          #BUILD CFPLLINK#
  
          IF SEQOFLN EQ NULL$LN 
          THEN
              #WILL NOT BUILD CFPLLINK# 
          #NOR  CFLNLINK# 
          GOTO BCRXFOOT;
          BASECFPLTABL = NEXTCFPLPTR; 
          USEDENTRYBIT = 0; 
          GETNEXT(CFPLLINK);
          #WILL HAVE TO HAVE ENTRY(S) FOR DELIMITERS EVEN IF ARE# 
          #NO PRINTABLE ITEMS - SO THAT CAN PRINT A LINE OF BLANKS.#
          IF INDX1STLN LS FIRSTF3OR4DE
          THEN
              $TEMP$ = FIRSTF3OR4DE;
          ELSE
              $TEMP$ = INDX1STLN; 
          FOR RGDNATPTR = $TEMP$ STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              RWSET1(PL$DNATCF  #CURRCFPLPTR#,0); 
              IF RWGET(RAPRINTABLEB,AUXINDEX) EQ 0
              THEN
                  GOTO CFPL2; 
              #ELSE PUT PRINTABLE INTO  CFPLLINK# 
              RWSET1(ALLVALUE$CF  #CURRCFPLPTR#,0); 
              RWSET1(SISOURCE$CF  #CURRCFPLPTR#,0); 
              RWSET1(PL$DNATCF  #CURRCFPLPTR#,RGDNATPTR); 
              #WILL BE CHANGED IF SOURCE ITEM IS A SUM CLAUSE#
              RWSET1(PL$CF$DELIM  #CURRCFPLPTR#,0); 
              USEDENTRYBIT = 1; 
              IF RWGET(RASOURCEBIT,AUXINDEX) EQ 1 
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPECF  #CURRCFPLPTR#,1);
                  SAUXINDEX = 1 + AUXINDEX; 
                  IF RWGET(RASRCESIBIT,SAUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      RWSET1(SISOURCE$CF  #CURRCFPLPTR#,1); 
                      RWSET1(PI$SOURCECF  #CURRCFPLPTR#,SAUXINDEX); 
#       CHECK SUBSCRIPTED SOURCE TO SEE IF IT IS CONTROL ITEM     # 
#       IF SO, PICK UP PREVIOUS VALUE INSTEAD                     # 
                      SAUXINDEX = SAUXINDEX + 1;
                      FOR $DUMMY$ = 0 WHILE 
                       RWGET(RALASTSINTRY,SAUXINDEX) NQ 1 DO
                          BEGIN 
                          SAUBATM = RWGET(RASICTEXT,SAUXINDEX); 
                          IF SAUBTYPE EQ CTDNREF THEN 
                             BEGIN
                             $TEMP$ = GETQUICK(IN$DNAT,INT$,SAUBVALUE); 
                             SAUBVALUE = $TEMP$;
                             IF CIDTPTRCURRD NQ 0 
                             THEN 
                                 BEGIN
                                 CURRCIDTPTR = CIDTPTRCURRD;
                                 FOR $DUM$ = 0 WHILE
                                     RWGET1(CIDTLINK #CURRCIDTPTR#) NQ 0
                                     DO 
                                     BEGIN
                                         IF RWGET1 (CIDTCONTRLID
                                            #CURRCIDTPTR# ) EQ $TEMP$ 
                                         THEN SAUBVALUE = 
                                               RWGET1 (CIDTPREVALUE 
                                                       #CURRCIDTPTR#);
                                         CURRCIDTPTR = RWGET1 (CIDTLINK 
                                                       #CURRCIDTPTR#);
                                     END
                                 END
                             RWSET(RASICTEXT,SAUXINDEX,SAUBATM);
                             END
                          SAUXINDEX = SAUXINDEX + 1;
                          END 
                      GOTO CFPL2; 
                      END 
  
                  #MUST CHECK IF SOUCE-ID WAS A CONTROL DATA ITEM,# 
                  #AND USE PREVIOUS VALUE DNAT IF IT WAS.#
                  IF CIDTPTRCURRD NQ 0
                  THEN
                      BEGIN 
                      CURRCIDTPTR = CIDTPTRCURRD; 
                      FOR $DUMMY$ = 0 WHILE 
                          RWGET1(CIDTLINK  #CURRCIDTPTR#) NQ
                          0 DO
                          BEGIN 
                          IF RWGET1(CIDTCONTRLID  #CURRCIDTPTR#) EQ 
                              RWGET(RASRCEIDNAT,SAUXINDEX)
                          THEN
                              BEGIN 
                              $TEMP$=RWGET1(CIDTPREVALUE #CURRCIDTPTR#);
                              RWSET1(PI$SOURCECF  #CURRCFPLPTR#,$TEMP$);
                              GOTO CFPL2; 
                              END 
                          CURRCIDTPTR= RWGET1(CIDTLINK  #CURRCIDTPTR#); 
                          END 
                      END 
                  #IF NOT, THEN#
  
                  $TEMP$ = RWGET(RASRCEIDNAT,SAUXINDEX);
                  RWSET1(PI$SOURCECF  #CURRCFPLPTR#,$TEMP$);
                  GOTO CFPL2; 
                  END 
              IF RWGET(RASUMBIT,AUXINDEX) EQ 1
              THEN
                  BEGIN 
                  RWSET1(ITEMTYPECF  #CURRCFPLPTR#,2);
                  RWSET1(PI$SOURCECF  #CURRCFPLPTR#,RGDNATPTR); 
                  #(IE.- THE ACTUAL SUM COUNTER)# 
                  #MUST BUILD A NEW DNAT ENTRY TO SERVE AS THIS ITEM"S# 
                  #REDEFINITION OF THE PRINTLINE RECORD AREA. # 
                  #WILL SAVE ITS INDEX FOR LATER USE BY RPARSER#
                  #IN RAPLDNAT4SUM IN THE 1ST RPAUX ENTYR      #
                  #FOLLOWING THE FORMAT 3 4                    #
                  #ENTRY# 
  
                  LASTDNATINDX = LASTDNATINDX + 1;
                  COPYD4 (RGDNATPTR,LASTDNATINDX);
                  RWSET(RAPLDNAT4SUM,1 + AUXINDEX,LASTDNATINDX);
  
                  #NOW CHANGE PL$DNATCF # 
  
                  RWSET1(PL$DNATCF  #CURRCFPLPTR#,LASTDNATINDX);
                  GOTO CFPL2; 
                  END 
  
              #ELSE IF HAVE VALUE CLAUSE# 
  
              RWSET1(ITEMTYPECF  #CURRCFPLPTR#,0);
              $TEMP$ = RWGET(RAVALULITPLT,1 + AUXINDEX);
              RWSET1(PI$SOURCECF  #CURRCFPLPTR#,$TEMP$);
              IF RWGET(RAVALUALLIND,1 + AUXINDEX) EQ 1
              THEN
                  RWSET1(ALLVALUE$CF  #CURRCFPLPTR#,1); 
CFPL2:  
              IF RWGET(RASUMBIT,AUXINDEX) EQ 1 THEN 
                  BEGIN 
                  SUMIDINDEX = AUXINDEX + 1;
SUBSUM: 
                  IF RWGET(RASUMIDTYPE,SUMIDINDEX) EQ 1 THEN
                      BEGIN 
                      IF RWGET(RASUMSITBLPT,SUMIDINDEX) 
                        NQ 0 THEN 
                          BEGIN 
                          SAUXINDEX = SUMIDINDEX + 1; 
                          FOR $DUMMY$ = 0 WHILE 
                            RWGET(RALASTSINTRY,SAUXINDEX) NQ 1 DO 
                              BEGIN 
                              SAUBATM = RWGET(RASICTEXT,SAUXINDEX); 
                              IF SAUBTYPE EQ CTDNREF THEN 
                                  BEGIN 
                                  $TEMP$ = GETQUICK(IN$DNAT,
                                    INT$, SAUBVALUE); 
                                      SAUBVALUE = $TEMP$; 
                                  RWSET(RASICTEXT,SAUXINDEX,SAUBATM); 
                                  END 
                              SAUXINDEX = SAUXINDEX + 1;
                              END 
                          IF RWGET(RASLASTAUXEN,SUMIDINDEX) 
                            EQ 0 THEN 
                              BEGIN 
                              SUMIDINDEX = SAUXINDEX + 1; 
                              GOTO SUBSUM;
                              END 
                          END 
                      ELSE
                          IF RWGET(RASLASTAUXEN,SUMIDINDEX) 
                            EQ 0 THEN 
                              BEGIN 
                              SUMIDINDEX = SUMIDINDEX + 1;
                              GOTO SUBSUM;
                              END 
                      END 
                  ELSE
                      IF RWGET(RASLASTAUXEN,SUMIDINDEX) 
                        EQ 0 THEN 
                          BEGIN 
                          SUMIDINDEX = SUMIDINDEX + 1;
                          GOTO SUBSUM;
                          END 
                  END 
              IF RGDNATPTR EQ LASTRGDNAT
              THEN
                  BEGIN 
                  RWSET1(PL$CF$DELIM  #CURRCFPLPTR#,ENDREPORTGRP);
                  GOTO ENDCFPLDO; 
                  END 
  
              #ELSE CHECK IF NEXT ENTRY HAS A LINE NUMBER#
  
              NEXTENTRYAUX = RP$AUXPTR(RGDNATPTR + 1);
              IF RWGET(RA1LINENOPLT,NEXTENTRYAUX) EQ 0
              THEN
                  GOTO CFPLEL;
              RWSET1(PL$CF$DELIM  #CURRCFPLPTR#,ENDPRINTLINE);
              USEDENTRYBIT = 1; 
CFPLEL: 
              IF USEDENTRYBIT EQ 0
              THEN
                  GOTO ENDCFPLDO; 
              USEDENTRYBIT = 0; 
              GETNEXT(CFPLLINK);
ENDCFPLDO:  
              END 
          #******************************************#
          #BUILD CFLNLINK#
  
          BASECFLNTABL = NEXTCFLNPTR; 
          FOR RGDNATPTR = INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
              THEN
                  BEGIN 
                  GETNEXT(CFLNLINK);
                  $TEMP$ = RWGET(RALINENUMPLT,AUXINDEX);
                  RWSET1(LNINT$PLTCF  #CURRCFLNPTR#,$TEMP$);
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                  THEN
                      RWSET1(KIND$LNINTCF  #CURRCFLNPTR#,ABSOLUTE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ RELATEVE 
                  THEN
                      RWSET1(KIND$LNINTCF  #CURRCFLNPTR#,RELATEVE); 
                  IF RWGET(RAKINDLINENO,AUXINDEX) EQ NEXTPAGEABSL 
                  THEN
                      RWSET1(KIND$LNINTCF  #CURRCFLNPTR#,NEXTPAGEABSL); 
                  END 
              END 
          #***************************************************# 
          #BUILD CF 00N CROSS FOOTING TABLE (IF NECESSARY)# 
  
BCRXFOOT: 
          BASECROSFOOT = NEXTCROSFPTR;
          #THIS#
          #WILL LATER BE SET = 0 IF CROSFOOTLINK IS NOT BUILT#
          DELFLAG = 0;
          FOR RGDNATPTR = FIRSTF3OR4DE  STEP 1 UNTIL
              LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              SUMIDINDEX = AUXINDEX + 1;
              IF RWGET(RASUMBIT,AUXINDEX) EQ 1
              THEN
                  BEGIN 
                  CFIDENT = 0;
CKNXTAUXENTY: 
                  IF RWGET(RASUMIDTYPE,SUMIDINDEX)  EQ  1 
                      AND 
                      RWGET(RASUMID1TYPE,SUMIDINDEX) EQ CROSSFOOTING
                      AND 
                      RWGET(RASUMSIERROR,SUMIDINDEX) EQ 0 
                  THEN
                      BEGIN 
                      #BUILD A CROSSFOOT TABLE ENTRY# 
                      GETNEXT(CROSFOOTLINK);
                      RWSET1(CROSFOOT012  #CURRCROSFPTR#,0);
                      #ADDEND#
                      $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                      RWSET1(CROSFOOTSUMC  #CURRCROSFPTR#,$TEMP$);
                      CFIDENT = 1;
                      END 
                  IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ 0
                      #THIS RESLLY CHECKS "LASTAUXENTRY" BIT# 
                      #IN ALL 3 TYPES#
                      #RA-SUM-IDENT#
                      #RA-UPON-DETAIL#
                      #RA-RESET-PHRASE# 
  
                  THEN
                      BEGIN 
                      IF RWGET(RASUMIDTYPE,SUMIDINDEX) EQ 1 THEN
                          BEGIN 
                          IF RWGET(RASUMSITBLPT,SUMIDINDEX) 
                            NQ 0 THEN 
                              SKIPSUB(SUMIDINDEX);
                          END 
                      SUMIDINDEX = SUMIDINDEX + 1;
                      GOTO CKNXTAUXENTY;
                      END 
                  IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ 1
                      #THEN THIS WAS THE LAST AUX ENTRY ASSOCIATED WITH#
                      #THIS DNAT# 
                      AND 
                      CFIDENT EQ 1
                      #FOUND CROSSFOOTING  ADDENDS# 
                  THEN
                      BEGIN 
                      #BUILD ENTRY FOR  THE SUM COUNTER#
                      GETNEXT(CROSFOOTLINK);
                      RWSET1(CROSFOOT012  #CURRCROSFPTR#,1);
                      #SUM COUNTER# 
                      RWSET1(CROSFOOTSUMC  #CURRCROSFPTR#,RGDNATPTR); 
                      DELFLAG = 1;
                      END 
                  END 
              END 
          IF DELFLAG EQ 1 
          THEN
              BEGIN 
              GETNEXT(CROSFOOTLINK);
              RWSET1(CROSFOOT012  #CURRCROSFPTR#,2);
              #DELIMITER# 
              END 
          IF DELFLAG EQ 0 
          THEN
              BASECROSFOOT = 0; 
          #AS SIGNAL TO CFRGLINK# 
          #BUILDING#
          #END OF CROSFOOTLINK  CODE# 
          #***************************************************# 
          #BUILD ADDITIONAL ENTRIES ONTO SUMCNTRLINK# 
          #IF POSSIBLE/NECESSARY# 
  
          CURBASSUMCTR = NEXTSUMCNPTR;
          FOR RGDNATPTR = FIRSTF3OR4DE STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RASUMBIT,AUXINDEX) EQ 1
              THEN
                  BEGIN 
                  GETNEXT(SUMCNTRLINK); 
                  RWSET1(SUMCNTRDELIM  #CURRSUMCNPTR#,0); 
                  RWSET1(SUMCNTR$DNAT  #CURRSUMCNPTR#,RGDNATPTR); 
                  END 
              END 
          SAVEDPTR = CURRSUMCNPTR;
          #****************************************************#
          #BUILD CF 00N ROLLING FORWARD TABLE (IF NECESSARY)# 
  
          BASEROLLFRWD = NEXTROLLFPTR;
          #THIS WILL# 
          #LATER BE SET = 0 IF  ROLFRWDLINK IS NOT BUILT# 
          DELFLAG = 0;
          FOR RPTDNATPTR = CURRDDNAT + 1  STEP 1 UNTIL ENDCURREPORT DO
              BEGIN 
              #WANT TO LOOK AT ALL DNAT ENTRIES WITHIN CURRENT REPORT#
              #EXCEPT FOR THOSE BELONGING TO CURRENT REPORT GROUP#
  
              $TEMP$ = GETQ(DN$LEVEL,DNAT$,RPTDNATPTR); 
              IF $TEMP$ EQ 1
                  AND 
                  RPTDNATPTR  NQ  DNATPOINTER 
                  #IE. IT"S NOT THE#
                  #CURRENT REPORT GROUP#
                  AND 
                  RWGET(RATYPERGROUP,RP$AUXPTR(RPTDNATPTR)) EQ CF 
                  AND 
                  RPTDNATPTR  NQ ENDCURREPORT 
              THEN
                  BEGIN 
                  RGINDEX = RPTDNATPTR + 1; 
                  #USE RGINDEX TO LOOK AT THE DNAT ENTRIES BELONGING TO#
                  #THE CF REPORT GROUP JUST FOUND.# 
LOOKATRGENTS: 
                  IF GETQ(DN$LEVEL,DNAT$,RGINDEX) NQ   1
                  THEN
                      #IF DNAT-LEVEL = 01, THAT MEANS RPTDNATPTR# 
                  BEGIN 
                      #NEEDS TO BE BUMPED UP TO THE NEXT REPORT GROUP.# 
                      AUXINDEX = RP$AUXPTR(RGINDEX);
                      SUMIDINDEX = AUXINDEX + 1;
                      IF RWGET(RASUMBIT,AUXINDEX) EQ 1
                      THEN
                          BEGIN 
                          ROLLF$FLAG = 0; 
RFCKNEXTAUX:  
                          IF RWGET(RASUMIDTYPE,SUMIDINDEX)  EQ 1
                              AND 
                              RWGET(RASUMSIERROR,SUMIDINDEX) EQ  0
                          THEN
                              BEGIN 
                              #CHECK TO SEE IF THIS SUMIDENTIFIER WAS # 
                              #DEFINED WITHIN CURRENT REPORT GROUP.   # 
                              #SEARCH AGAINST CURRENT ADDITIONS TO    # 
                              #SUMCNTR TABLE (IF ANY).                # 
                              CURRSUMCNPTR = CURBASSUMCTR;
                              FOR $DUMMY$ = 0 
                                  WHILE RWGET1(SUMCNTRLINK
                                        #CURRSUMCNPTR#) NQ 0 DO 
                                  BEGIN 
                                  IF RWGET(RASUMID1DNAT,SUMIDINDEX) EQ
                                      RWGET1(SUMCNTR$DNAT 
                                          #CURRSUMCNPTR#) 
                                  THEN
                                      BEGIN 
                                      #BUILD ENTRY FOR SUM IDENT.#
                                      GETNEXT(ROLFRWDLINK); 
                                      RWSET1(ROLFRWDDELIM 
                                          #CURRROLLFPTR#,0);
                                      #ADDEND#
                                      $TEMP$ = RWGET(RASUMID1DNAT,
                                               SUMIDINDEX); 
                                      RWSET1(ROLFRWDSUMCR 
                                          #CURRROLLFPTR#,$TEMP$); 
                                      ROLLF$FLAG = 1; 
                                      GOTO CHKLAE;
                                      END 
                                      CURRSUMCNPTR = RWGET1(SUMCNTRLINK 
                                                 #CURRSUMCNPTR#); 
                                  END 
                              END 
CHKLAE: 
                          CURRSUMCNPTR = SAVEDPTR;
                          IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ 1
                          THEN
                              GOTO HLRFCHK; 
  
                          #ELSE BUMP SUMIDINDEX TO NEXT AUX ENTRY FOR#
                          #CURRENT DNAT ENTRY#
  
                          IF RWGET(RASUMIDTYPE,SUMIDINDEX)
                            EQ 1 THEN 
                              BEGIN 
                              IF RWGET(RASUMSITBLPT,SUMIDINDEX) 
                                NQ 0 THEN 
                                  SKIPSUB(SUMIDINDEX);
                              END 
                          SUMIDINDEX = SUMIDINDEX + 1;
                          GOTO RFCKNEXTAUX; 
  
                          #END OF AUX ENTRY LOOP# 
                          #**************************#
HLRFCHK:  
                          IF ROLLF$FLAG EQ 1
                          THEN
                              BEGIN 
                              #BUILD ENTRY FOR THE HIGH LEVEL SUM CNTR# 
                              GETNEXT(ROLFRWDLINK); 
                              RWSET1(ROLFRWDDELIM  #CURRROLLFPTR#,1); 
                              #HIGHER LEVEL SUM CNTR# 
                              RWSET1(ROLFRWDSUMCR  #CURRROLLFPTR#,
                                      RGINDEX); 
                              DELFLAG = 1;
                              END 
                          END 
  
                      #BUMP TO NEXT DNAT UNDER THIS REPORT GROUP# 
                      #IF POSSIBLE# 
                      IF RGINDEX  NQ  ENDCURREPORT
                      THEN
                          BEGIN 
                          RGINDEX = RGINDEX + 1;
                          GOTO LOOKATRGENTS;
                          END 
                      #END OF CODE FOR DNAT LOOP FOR THIS RG.#
                      END 
                  END 
              END 
          IF DELFLAG EQ 1 
          THEN
              BEGIN 
              GETNEXT(ROLFRWDLINK); 
              RWSET1(ROLFRWDDELIM  #CURRROLLFPTR#,2); 
              #DELIMITER# 
              END 
          IF DELFLAG EQ 0 
          THEN
              BASEROLLFRWD = 0; 
          #AS SIGNAL TO CFRGLINK# 
          #BUILDING#
          #END OF  ROLFRWDLINK  CODE.#
          #*************************************************# 
          #BUILD RESET-A-TABLE  (IF NECESSARY)# 
  
          BASEARESETTB  = NEXTARSETPTR; 
          #WILL BE SET =0, IF TABLE NOT BUILT#
          RSTFLAG = 0;
          FOR RGDNATPTR = FIRSTF3OR4DE STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              IF RWGET(RASUMBIT,AUXINDEX) EQ 1
              THEN
                  BEGIN 
               AUXINDEX = AUXINDEX + 1; 
ABUMPAUX: 
                  #WILL EXAMINE ANY/ALL ADDITIONAL RP-AUX-TABLE#
                  #ENTRIES ASS./W  THIS DNAT TO SEE IF FIND ONE#
                  #THAT IS A "RESET" TYPE#
  
                  IF RWGET(RARESETYPE,AUXINDEX) EQ 1
                  THEN
                      GOTO  ENDARSTLOOP;
                  IF RWGET(RASLASTAUXEN,AUXINDEX) EQ 0
                      #REALLY CHECKS THE FOLLOWING 3 BITS#
                      #LASTAUXENTRY, U-LAST-AUX-ENTRY,# 
                      #R-LAST-AUX-ENTRY#
                  THEN
               BEGIN
               IF RWGET(RASUMIDTYPE,AUXINDEX) EQ 1 THEN 
                   BEGIN
                   IF RWGET(RASUMSITBLPT,AUXINDEX) NQ 0 THEN
                       SKIPSUB(AUXINDEX); 
                   END
               AUXINDEX = AUXINDEX + 1; 
                      GOTO ABUMPAUX;
               END
                  IF RWGET(RASLASTAUXEN,AUXINDEX) EQ 1
                  THEN
                      BEGIN 
                      GETNEXT(ARESETLINK);
                      RWSET1(ARESET$DELIM  #CURRARSETPTR#,0); 
                      RWSET1(ARESET$SUMCR  #CURRARSETPTR#,RGDNATPTR); 
                      RSTFLAG = 1;
                      END 
                  END 
ENDARSTLOOP:  
              END 
          IF RSTFLAG EQ 0 
          THEN
              BASEARESETTB = 0; 
          IF RSTFLAG EQ 1 
          THEN
              RWSET1(ARESET$DELIM  #CURRARSETPTR#,1); 
          #END OF  RESET A TABLE  CODE# 
          #*******************************************************# 
          #BUILD RESETBLINK (IF NECESSARY)# 
  
          BASERESETBTB = NEXTBRSETPTR;
          #WILL BE SET = 0, IF TABLE NOT BUILT# 
          RSTFLAG = 0;
          FOR RPTDNATPTR = CURRDDNAT +1  STEP 1 UNTIL ENDCURREPORT DO 
              BEGIN 
              $TEMP$ = GETQ(DN$LEVEL,DNAT$,RPTDNATPTR); 
              IF $TEMP$ EQ 1
                  AND 
                  RWGET(RATYPERGROUP,RP$AUXPTR(RPTDNATPTR)) EQ CF 
                  AND 
                  RPTDNATPTR  NQ  ENDCURREPORT
              THEN
                  BEGIN 
                  #HAVE FOUND A REPORT GROUP WORTH INVESTIGATING# 
                  RGINDEX = RPTDNATPTR + 1; 
                  #USE RGINDEX TO LOOK AT THE DNAT ENTRIES BELONGING# 
                  #TO THE CF REPORT GROUP JUST FOUND# 
  
EXAMNRGENTRI: 
                  IF GETQ(DN$LEVEL,DNAT$,RGINDEX)  NQ  1
                      #IF DNAT-LEVEL = 1, THE RPTDNATPTR NEEDS TO BE# 
                      #BUMPED UP TO THE NEXT REPORT GROUP#
                  THEN
                      BEGIN 
                      AUXINDEX = RP$AUXPTR(RGINDEX);
                      SUMIDINDEX = AUXINDEX + 1;
                      IF RWGET(RASUMBIT,AUXINDEX) EQ 1
                      THEN
                          BEGIN 
                          #HAVE DNAT WORTHY OF EXAMINATION- WILL SEARCH#
                          #AUX ENTRIES ASS/W IT.# 
SRCHRESET:  
                          IF RWGET(RARESETYPE,SUMIDINDEX) EQ 1
                          THEN
                              GOTO  BRESET; 
                          IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ 0
                          THEN
                              BEGIN 
                              IF RWGET(RASUMIDTYPE,SUMIDINDEX)
                                EQ 1 THEN 
                                  BEGIN 
                                  IF RWGET(RASUMSITBLPT,SUMIDINDEX) 
                                    NQ 0 THEN 
                                      SKIPSUB(SUMIDINDEX);
                                  END 
                              SUMIDINDEX = SUMIDINDEX + 1;
                              GOTO SRCHRESET; 
                              END 
                          IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ 1
                          THEN
                              BEGIN 
CHKBUMPDNAT:  
                              IF RGINDEX  NQ  ENDCURREPORT
                              THEN
                                  BEGIN 
                                  RGINDEX = RGINDEX + 1;
                                  GOTO EXAMNRGENTRI;
                                  END 
                              ELSE
                                  GOTO RBMAINEND; 
                              END 
BRESET: 
                          IF RWGET(RARESETDNAT,SUMIDINDEX) EQ 
                             RWGET(RACONTRLDNAT,
                                RP$AUXPTR(DNATPOINTER)) 
                              AND 
                              RWGET(RARESETIDILL,SUMIDINDEX) EQ 0 
                              #WAS A LEGAL IDENTIF.#
                              AND 
                              RWGET(RAPICBIT,AUXINDEX) EQ 1 
                              #THIS SUM CNTR HAD A PIC CLAUSE#
                          THEN
                              BEGIN 
                              GETNEXT(RESETBLINK);
                              RWSET1(RESETB$DELIM  #CURRBRSETPTR#,0); 
                              RWSET1(RESETB$SUMCR  #CURRBRSETPTR#,
                                  RGINDEX); 
                              RSTFLAG = 1;
                              GOTO  CHKBUMPDNAT;
                              END 
                          END 
                      GOTO CHKBUMPDNAT; 
                      END 
                  END 
RBMAINEND:  
              END 
          IF RSTFLAG EQ 1 
          THEN
              RWSET1(RESETB$DELIM  #CURRBRSETPTR#,1); 
          #LAST ENTRY#
          IF RSTFLAG EQ 0 
          THEN
              BASERESETBTB = 0; 
          #END OF  RESETBLINK   CODE# 
          #*****************************************************# 
          #ADD TO  ISUBTLINK# 
  
          FOR RGDNATPTR = FIRSTF3OR4DE STEP 1 UNTIL LASTRGDNAT DO 
              BEGIN 
              AUXINDEX = RP$AUXPTR(RGDNATPTR);
              SUMIDINDEX = AUXINDEX + 1;
              IF RWGET(RASUMBIT,AUXINDEX) NQ 1
              THEN
                  TEST RGDNATPTR; 
              #ELSE#
  
SUBTSEARCH: 
              #RP-AUX ENTRY LOOP# 
              IF  RWGET(RASUMIDTYPE,SUMIDINDEX) EQ  1 
                  AND 
                  RWGET(RASUMSIERROR,SUMIDINDEX) EQ 0 
                  AND 
                  RWGET(RASUMID1TYPE,SUMIDINDEX) EQ  SUBTOTALLING 
              THEN
                  BEGIN 
                  RUINDEX = SUMIDINDEX; 
RUSEARCH: 
                  IF RWGET(RASLASTAUXEN,RUINDEX) EQ 1 
                  THEN
                      GOTO  NOREALUPON; 
                  IF RWGET(RASUMIDTYPE,RUINDEX) EQ 1 THEN 
                      BEGIN 
                      IF RWGET(RASUMSITBLPT,RUINDEX) NQ 0 THEN
                          SKIPSUB(RUINDEX); 
                      END 
                  RUINDEX = RUINDEX + 1;
                  IF RWGET(RAUPONTYPBIT,RUINDEX) EQ  0
                  THEN
                      GOTO  RUSEARCH; 
                  IF RWGET(RAUPONTYPBIT,RUINDEX) EQ 1 
                      AND 
                      RWGET(RADUMMYUPON,RUINDEX) EQ 1 
                  THEN
                      GOTO NOREALUPON;
  
                  #ELSE -  YES, THERE WAS A USER-SPECIFIED UPON PHRASE# 
                  #ASS. WITH THIS SUM CLAUSE,  SO-# 
                  #WANT TO BUILD AS MANY ENTRIES IN ISUBTLINK AS# 
                  #DETAIL NAMES LISTED IN THE UPON PHRASE#
  
YESREALUPON:  
                  IF FSUBT4CURRD EQ  0
                  THEN
                      FSUBT4CURRD = NEXTSUBTOPTR; 
                  #(IE. IF THIS WILL BE THE FIRST ISUBTLINK#
                  #ENTRY BUILT FOR THIS REPORT)#
  
                  GETNEXT(ISUBTLINK); 
                  $TEMP$ = RWGET(RAUPNDETAIL1,RUINDEX); 
                  RWSET1(SUBTXDETAIL  #CURRSUBTOPTR#,$TEMP$); 
                  $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                  RWSET1(SUBTXSCIDENT  #CURRSUBTOPTR#,$TEMP$);
                  $TEMP$ = RWGET(RASUMSITBLPT,SUMIDINDEX);
                  RWSET1(SUBTXSITABLE  #CURRSUBTOPTR#,$TEMP$);
                  #MAY BE = 0#
                  RWSET1(SUBTXSUMCNTR  #CURRSUBTOPTR#,RGDNATPTR); 
                  IF RWGET(RAUPNDETAIL2,RUINDEX) NQ  0
                  THEN
                      BEGIN 
                      IF FSUBT4CURRD EQ  0
                      THEN
                          FSUBT4CURRD = NEXTSUBTOPTR; 
                      GETNEXT(ISUBTLINK); 
                      $TEMP$ = RWGET(RAUPNDETAIL2,RUINDEX); 
                      RWSET1(SUBTXDETAIL  #CURRSUBTOPTR#,$TEMP$); 
                      $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                      RWSET1(SUBTXSCIDENT  #CURRSUBTOPTR#,$TEMP$);
                      $TEMP$ = RWGET(RASUMSITBLPT,SUMIDINDEX);
                      RWSET1(SUBTXSITABLE  #CURRSUBTOPTR#,$TEMP$);
                      #MAY BE = 0#
                      RWSET1(SUBTXSUMCNTR  #CURRSUBTOPTR#,RGDNATPTR); 
                      IF RWGET(RAUPNDETAIL3,RUINDEX) NQ 0 
                      THEN
                          BEGIN 
                          IF FSUBT4CURRD EQ  0
                          THEN
                              FSUBT4CURRD = NEXTSUBTOPTR; 
                          GETNEXT(ISUBTLINK); 
                          $TEMP$ = RWGET(RAUPNDETAIL3,RUINDEX); 
                          RWSET1(SUBTXDETAIL  #CURRSUBTOPTR#,$TEMP$); 
                          $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                          RWSET1(SUBTXSCIDENT  #CURRSUBTOPTR#,$TEMP$);
                          $TEMP$ = RWGET(RASUMSITBLPT,SUMIDINDEX);
                          RWSET1(SUBTXSITABLE  #CURRSUBTOPTR#,$TEMP$);
                          RWSET1(SUBTXSUMCNTR #CURRSUBTOPTR#,RGDNATPTR);
                          IF RWGET(RASLASTAUXEN,RUINDEX)  NQ  1 
                          THEN
                              BEGIN 
                              RUINDEX = RUINDEX + 1;
                              IF RWGET(RAUPONTYPBIT,RUINDEX) EQ 1 
                              THEN
                                  GOTO  YESREALUPON;
                              #LOOP#
                              END 
                          END 
                      END 
                  GOTO  CKLAESUMID; 
NOREALUPON: 
                  #MAKE AS MANY ENTRIES IN ISUBTLINK AS THERE ARE#
                  #DETAIL REPORT GROUPS IN THE REPORT#
  
                  FOUNDDETAIL = 0;
                  FOR RPTDNATPTR = CURRDDNAT + 1  STEP 1 UNTIL
                      ENDCURREPORT DO 
                      BEGIN 
                      $TEMP$ = GETQ(DN$LEVEL,DNAT$,RPTDNATPTR); 
                      IF $TEMP$ EQ 1
                          AND 
                          RWGET(RATYPERGROUP,RP$AUXPTR(RPTDNATPTR))  EQ 
                          DE
                      THEN
                          BEGIN 
                          IF FSUBT4CURRD  EQ  0 
                          THEN
                              FSUBT4CURRD = NEXTSUBTOPTR; 
                          GETNEXT(ISUBTLINK); 
                          RWSET1(SUBTXDETAIL #CURRSUBTOPTR#,RPTDNATPTR);
                          $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                          RWSET1(SUBTXSCIDENT  #CURRSUBTOPTR#,$TEMP$);
                          $TEMP$ = RWGET(RASUMSITBLPT,SUMIDINDEX);
                          RWSET1(SUBTXSITABLE  #CURRSUBTOPTR#,$TEMP$);
                          RWSET1(SUBTXSUMCNTR #CURRSUBTOPTR#,RGDNATPTR);
                          #SET FLAG#
                          FOUNDDETAIL = 1;
                          END 
                      END 
                  IF FOUNDDETAIL EQ 0 
                      #NO DETAIL GROUPS IN THIS RD# 
                  THEN
                      BEGIN 
                      #THE FOLLOWING CODE IS NEEDED IN   ORDER TO#
                      #ACCOMPLISH FOR THE USER,  ANY SPECIFIED# 
                      #SUBTOTALLING THAT SHOULD BE DONE  IF HE REQUESTS#
                      #SUMMARY REPORTING# 
  
                      IF DUMDTAILDNAT EQ  0 
                      THEN
                          BEGIN 
                          #BUILD A DNAT ENTRY FOR A DUMMY DETAIL# 
                          #REPORT GROUP#
  
                          LASTDNATINDX = LASTDNATINDX + 1;
                          SET(DN$LEVEL,DNAT$,LASTDNATINDX,1); 
                          #NOTE#
                          #IT IS POSSIBLE THAT ADDITIONS TO THIS #
                          #DNAT BUILDING CODE                    #
                          #WILL HAVE TO BE MADE AT A LATER DATE.# 
                          DUMDTAILDNAT = LASTDNATINDX;
                          END 
  
                      #BUILD INIT-SUBT  ENTRY USING CONTENTS OF#
                      #DUMDTAILDNAT#
  
                      IF FSUBT4CURRD  EQ 0
                      THEN
                          FSUBT4CURRD = NEXTSUBTOPTR; 
                      GETNEXT(ISUBTLINK); 
                      RWSET1(SUBTXDETAIL  #CURRSUBTOPTR#,DUMDTAILDNAT); 
                      $TEMP$ = RWGET(RASUMID1DNAT,SUMIDINDEX);
                      RWSET1(SUBTXSCIDENT  #CURRSUBTOPTR#,$TEMP$);
                      $TEMP$ = RWGET(RASUMSITBLPT,SUMIDINDEX);
                      RWSET1(SUBTXSITABLE  #CURRSUBTOPTR#,$TEMP$);
                      RWSET1(SUBTXSUMCNTR  #CURRSUBTOPTR#,RGDNATPTR); 
                      END 
                  END 
CKLAESUMID: 
              IF RWGET(RASLASTAUXEN,SUMIDINDEX) EQ   0
              THEN
                  BEGIN 
                  IF RWGET(RASUMIDTYPE,SUMIDINDEX) EQ 1 AND 
                      RWGET(RASUMSITBLPT,SUMIDINDEX) NQ 0 THEN
                      SKIPSUB(SUMIDINDEX);
                  SUMIDINDEX =  SUMIDINDEX + 1; 
                  GOTO  SUBTSEARCH; 
                  END 
              END 
          #*********************************************************# 
          #ADD TO  CONTROLS TABLE#
  
          CURRCNTRLPTR = STRTCURCONTB;
CFINDMATCHCI: 
          IF RWGET1(EOCDELIMITER  #CURRCNTRLPTR#) EQ 1
          THEN
              GOTO BCFRGTABLE;
          IF RWGET1(CID$DNAT  #CURRCNTRLPTR#) EQ
              RWGET(RACONTRLDNAT,RP$AUXPTR(DNATPOINTER))
          THEN
              BEGIN 
              RWSET1(CF$BIT  #CURRCNTRLPTR#,1); 
              GEN$RG$PNAT;
              RWSET1(CF$PNAT  #CURRCNTRLPTR#,LASTPNATINDX); 
              GEN$RG$PNAT;
              RWSET1(CF$CF2$PNAT  #CURRCNTRLPTR#,LASTPNATINDX); 
              GEN$RG$PNAT;
              RWSET1(CF$EXIT$PNAT  #CURRCNTRLPTR#,LASTPNATINDX);
              SET(PN$PERFLAST,PNAT$,LASTPNATINDX,1);
              IF COND6F EQ 1
              THEN
                  BEGIN 
                  RWSET1(BIT6F1  #CURRCNTRLPTR#,1); 
                  $TEMP$ = RWGET(RANGINTPLT,RP$AUXPTR(DNATPOINTER) + 1);
                  RWSET1(RELNGINT$PLT  #CURRCNTRLPTR#,$TEMP$);
                  GOTO  BCFRGTABLE; 
                  END 
              IF NGTABLEDNAT  NQ  0 
              THEN
                  BEGIN 
                  RWSET1(NGCFTABLDNAT  #CURRCNTRLPTR#,NGTABLEDNAT); 
                  IF TNEXTGROUP NQ 3
                  THEN
                      BEGIN 
            $TEMP$ = RWGET(RANGINTPLT,
                      RP$AUXPTR(DNATPOINTER) + 1);
                      RWSET1(CT$NG$INT  #CURRCNTRLPTR#,$TEMP$); 
                      IF TNEXTGROUP EQ 2
                      THEN
                          RWSET1(CT$TYPENG  #CURRCNTRLPTR#,0);
                      IF TNEXTGROUP EQ 1
                      THEN
                          RWSET1(CT$TYPENG  #CURRCNTRLPTR#,1);
                      END 
                  GOTO BCFRGTABLE;
                  END 
              END 
          CURRCNTRLPTR  =  RWGET1(CONTROLSLINK  #CURRCNTRLPTR#);
          GOTO CFINDMATCHCI;
          #***********************************************************# 
          #**************************************#
          #BUILD CFRGLINK#
  
BCFRGTABLE: 
          BASECFRGTABL = NEXTCFRGPTR; 
          GETNEXT(CFRGLINK);
          RWSET1(RG$NAMECF  #CURRCFRGPTR#,DNATPOINTER); 
          RWSET1(TYPEOFRGCF  #CURRCFRGPTR#,CF); 
          IF SEQOFLN EQ NULL$LN 
          THEN
              BEGIN 
              RWSET1(CFLN$BASE  #CURRCFRGPTR#,0); 
              RWSET1(CFPL$BASE  #CURRCFRGPTR#,0); 
              RWSET1(COND4DCF  #CURRCFRGPTR#,0);
              RWSET1(BPTBL$DNATCF  #CURRCFRGPTR#,0);
              RWSET1(CROSFOOTBASE  #CURRCFRGPTR#,0);
              RWSET1(ROLLFRWDBASE  #CURRCFRGPTR#,0);
              RWSET1(RESETABASE  #CURRCFRGPTR#,0);
              RWSET1(RESETBBASE  #CURRCFRGPTR#,0);
              GOTO  CF$BRGSTABLE; 
              END 
          RWSET1(CFLN$BASE  #CURRCFRGPTR#,BASECFLNTABL);
          RWSET1(CFPL$BASE  #CURRCFRGPTR#,BASECFPLTABL);
          RWSET1(BPTBL$DNATCF  #CURRCFRGPTR#,0);
          IF COND4D EQ 1
          THEN
              BEGIN 
              RWSET1(COND4DCF  #CURRCFRGPTR#,1);
              GOTO CFRGCONT;
              END 
          IF BPTABLDNAT  NQ 0 
          THEN
              RWSET1(BPTBL$DNATCF  #CURRCFRGPTR#,BPTABLDNAT); 
CFRGCONT: 
          RWSET1(CROSFOOTBASE  #CURRCFRGPTR#,BASECROSFOOT); 
          #0 IF TABLE NOT BUILT#
          RWSET1(ROLLFRWDBASE  #CURRCFRGPTR#,BASEROLLFRWD); 
          #0 IF TABLE NOT BUILT#
          RWSET1(RESETABASE  #CURRCFRGPTR#,BASEARESETTB); 
          #0 IF TABLE NOT BUILT#
          RWSET1(RESETBBASE  #CURRCFRGPTR#,BASERESETBTB); 
          #0 IF TABLE NOT BUILT#
          #**** END OF  CFRGLINK CODE    **************************#
          #*************************************************# 
          #BUILD  RGTLINK ENTRY#
  
CF$BRGSTABLE: 
          GETNEXT(RGTLINK); 
          RWSET1(RGEOTDELIM  #CURRRPTGRPTR#,0); 
          RWSET1(RGTYPEOFRG  #CURRRPTGRPTR#,CF);
          RWSET1(RGBASERGTABL  #CURRRPTGRPTR#,BASECFRGTABL);
  
          #NOTE#
          #RGPARANAME1   IS FILLED WITH#
          #DNAT INDEX OF CONTROL IDENTIFIER WHEN TYPE OF RG = CF.#
          $TEMP$ = RWGET(RACONTRLDNAT,RP$AUXPTR(DNATPOINTER));
          RWSET1(RGPARANAME1  #CURRRPTGRPTR#,$TEMP$); 
          END #BUILDCFTABLS#
          CONTROL EJECT;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("BODYGRP")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          IF RDOCURDSWTCH EQ 0
          THEN
          #IF NO VALID CURRDDNAT# 
          COND4D = 0; 
          COND6F = 0; 
          IF IPAGECLAUSPC EQ 0
          THEN
              BEGIN 
              IF SEQOFLN EQ R 
              THEN
                  BEGIN 
                  IF TNEXTGROUP EQ R
                  THEN
                      BEGIN 
                      COND4D = 1; 
                      COND6F = 1; 
                      GOTO  BGBLDTABLES;
                      END 
                  IF TNEXTGROUP EQ NULLNG 
                  THEN
                      BEGIN 
                      COND4D = 1; 
                      GOTO BGBLDTABLES; 
                      END 
                  END 
              IF SEQOFLN EQ NULL$LN 
                  AND 
                  TNEXTGROUP EQ NULLNG
              THEN
                  GOTO BGBLDTABLES; 
              ELSE
                  GOTO ENDBGRT; 
              #(ANY OTHER COMBINATION IS# 
              #ILLEGAL AND ALREADY DIAGNOSED)#
              END 
          ELSE
              COND4D = 0;             # RESET FLAG #
          # ELSE IPAGECLAUSPC IS YES #
          IF TNEXTGROUP EQ A
          THEN
              BEGIN 
              INTPLTINDEX = RWGET(FOOTINGPLT,RP$AUXPTR(CURRDDNAT) + 1); 
              INT1CONVERT;
              NGFOOTING = INTVALUE; 
              INTPLTINDEX = RWGET(F1STDTAILPLT,RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              NGFIRSTDTAIL = INTVALUE;
              IF SVNGINTEGER GQ  NGFIRSTDTAIL 
                  AND 
                  SVNGINTEGER LQ  NGFOOTING 
              THEN
                  #NG INTEGER IS OK#
              GOTO BGCONTINUE;
  
              #ELSE-# 
  
              #DIAGNOSTIC (M84)#
              #NEXT GROUP INTEGER MUST BE GQ FIRST DETAIL INTEGER#
              #AND LQ FOOTING PHRASE INTEGER                     #
  
              BGDIAGNO = M84; 
              BGLINEREF = DNATPOINTER;
              RT$BGDIAG;
              END 
BGCONTINUE: 
          IF SEQOFLN EQ AR
              OR
              SEQOFLN EQ NPR
          THEN
              BEGIN 
              #RULE 4A# 
              #RULE 1#
              #COMPUTE LLN# 
              #RULE 2#
              INTPLTINDEX = RWGET(RALINENUMPLT,RP$AUXPTR(INDX1STLN)); 
              INT1CONVERT;
              BGFPLP = INTVALUE;
              INTPLTINDEX = RWGET(F1STDTAILPLT,RP$AUXPTR(CURRDDNAT)); 
              INT1CONVERT;
              IF BGFPLP  LS  INTVALUE 
              THEN
                  BEGIN 
                  BGDIAGNO   =  M85;
                  BGLINEREF  =  INDX1STLN;
                  RT$BGDIAG;
                  END 
  
              #DIAGNOSTIC (M85)#
              #FIRST LINE NUM ON WHICH BODY GROUP CAN BE PRESENTED IS#
              #LINE NUMBER SPECIFIED BY FIRST DETAIL PHRASE.# 
              #COMPUTE LLN# 
              LASTABS = 0;
              #PLT-PTR# 
              RELINT = 0; 
              #INTEGER VALUE# 
              FOR RGDNATPTR = (INDX1STLN + 1) STEP 1 UNTIL LASTRGDNAT DO
                  BEGIN 
                  AUXINDEX = RP$AUXPTR(RGDNATPTR);
                  IF RWGET(RALINENUMPLT,AUXINDEX)  NQ  0
                  THEN
                      BEGIN 
                      IF RWGET(RAKINDLINENO,AUXINDEX) EQ ABSOLUTE 
                      THEN
                          LASTABS = RWGET(RALINENUMPLT,AUXINDEX); 
                      ELSE
                          BEGIN 
                          INTPLTINDEX = RWGET(RALINENUMPLT,AUXINDEX); 
                          INT1CONVERT;
                          RELINT = RELINT  + INTVALUE;
                          END 
                      END 
                  END 
              IF LASTABS EQ 0 
              THEN
                  LLN =  BGFPLP + RELINT; 
              ELSE
                  BEGIN 
                  INTPLTINDEX = LASTABS;
                  INT1CONVERT;
                  LLN = INTVALUE + RELINT;
                  END 
              #COMPUTE  LOWER  LIMIT# 
BGRULE2CHK: 
              #(THIS CODE USED WHEN SEQ-OF-LN = RELATIVE# 
              #ALSO#
              IF RWGET(RATYPERGROUP,RP$AUXPTR(DNATPOINTER)) EQ CF 
              THEN
                  BEGIN 
                  INTPLTINDEX=RWGET(FOOTINGPLT,RP$AUXPTR(CURRDDNAT)+ 1);
                  PLT4LOWLIMIT = INTPLTINDEX; 
                  INT1CONVERT;
                  IF LLN GR  INTVALUE 
                  THEN
                      GOTO BG3DIAG; 
                  GOTO BGBLDTABLES; 
                  END 
  
              #TYPE = DE  OR  CH# 
              INTPLTINDEX= RWGET(LASTDTAILPLT,RP$AUXPTR(CURRDDNAT) + 1);
              PLT4LOWLIMIT =INTPLTINDEX;
              INT1CONVERT;
              IF LLN GR  INTVALUE 
              THEN
BG3DIAG:  
                  BEGIN 
                  BGDIAGNO = M86; 
                  BGLINEREF = DNATPOINTER;
                  RT$BGDIAG;
                  END 
  
              #DIAGNOSTIC (M86)#
              #LINE NUMBER SPECIFICATIONS IN THIS REPORT GROUP CAUSE   #
              #LOWER    # 
              #LIMIT RULE OF BODY GROUP PRENTATION RULES TO BE VIOLATED#
              GOTO BGBLDTABLES; 
              #NEEDED ESP. WHEN SEQ/LN = R# 
              END 
  
          IF SEQOFLN EQ R 
          THEN
              BEGIN 
              #DUE TO RULE 4B, UPPER LIMIT WON"T BE VIOLATED# 
              #NO NEED TO CHECK.  # 
              #BUT WILL TEST THE SUM OF THE RELATIVE LINE NUMBER# 
              #INTEGERS AGAINST THE LOWER LIMIT#
  
              LLN = 0;
              FOR RGDNATPTR = INDX1STLN  STEP 1 UNTIL LASTRGDNAT DO 
                  BEGIN 
                  AUXINDEX = RP$AUXPTR(RGDNATPTR);
                  IF RWGET(RALINENUMPLT,AUXINDEX) NQ  0 
                  THEN
                      BEGIN 
                      INTPLTINDEX = RWGET(RALINENUMPLT,AUXINDEX); 
                      INT1CONVERT;
                      LLN = LLN + INTVALUE; 
                      END 
                  END 
              #LLN = SUMRELINENOS.# 
              GOTO  BGRULE2CHK; 
              END 
          #***********************************************************# 
BGBLDTABLES:  
          BODYRGDEFIND = 1; 
          #DETERMINE IF IT IS POSSIBLE OR WORTHWHILE TO BUILD ANY#
          #TABLES FOR THIS REPORT GROUP OR REPORT#
  
          IF ANALONLYREPT  EQ 1 
              OR
              ANALONLYRGRP EQ 1 
          THEN
              GOTO ENDBGRT; 
          IF RWGET(RATYPERGROUP,RP$AUXPTR(DNATPOINTER)) EQ CH 
          THEN
              BLD$CHTABLES; 
          IF RWGET(RATYPERGROUP,RP$AUXPTR(DNATPOINTER)) EQ DE 
          THEN
              BLDETAILTABL; 
          IF RWGET(RATYPERGROUP,RP$AUXPTR(DNATPOINTER)) EQ  CF
          THEN
              BUILDCFTABLS; 
ENDBGRT:  
           IF ANALONLYRGRP EQ 1 AND 
            RWGET(RATYPERGROUP,RP$AUXPTR(DNATPOINTER)) EQ CF
            THEN
               RWSET1(PL$CF$DELIM   #CURRCFPLPTR#, ENDREPORTGRP); 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("BODYGRP")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          END #BODYGRP# 
  
          TERM
