*DECK FOOTING 
USETEXT CCTTEXT 
USETEXT DNTEXT
USETEXT RPTEXT
PROC FOOTING; 
          BEGIN 
*CALL RGCOMM1 
*CALL RGCOMM2 
*CALL GETSET
*CALL TABLNAMES 
  
ENTRY PROC G$PFOOT; 
  
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL PAGE FOOTING ROUTINE IN# 
          #CTEXT FORM#
  
  
          #GENPFUBR#
  
          #GEN. CTEXT FOR ROUTINE NAME AND THE STATEMENT FOR# 
          #USE BEFORE REPORTING AND SUPPRESS# 
          #PAGE-FOOTING#
          #NEWVERB REPORT-GROUP-NAME  PF-ROUTINE-EXIT#
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$PFOOT")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENRWVERB;
          CURRPFRGPTR = RWGET1(RGBASERGTABL  #CURRRPTGRPTR#); 
          DNATPTR =  RWGET1(RG$NAMEPF  #CURRPFRGPTR#);
          GENDNREF #DNATPTR# ;
          PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
          GENPNREF #PNATPTR# ;
  
          #IS PF REPORT GROUP PRINTABLE&# 
  
          IF  RWGET1(PFLN$BASE  #CURRPFRGPTR#) EQ 0 
          THEN
              GOTO GPFT1; 
          #WERE NO LINE  NUMBERS  NOT PRINTABLE.# 
  
          #GENPFLINES#
  
  
          #GEN. THE INDICATED CODE THAT WILL PRINT ALL LINES OF#
          #PAGE-FOOTING#
          #MOVE  ABSOLUTE-L-N  TO  S-L-N# 
          #PERFORM SPACING# 
          #MOVE DATA-NAME-N  TO  DATA-NAME-N# 
          #.# 
          #.# 
          #WRITE RECORD-NAME-1# 
          #(ETC. - REPEATED FOR EACH PRINT LINE)# 
  
          PFPLFLAG = 1; 
          CURRPFLNPTR = RWGET1(PFLN$BASE  #CURRPFRGPTR#); 
          CURRPFPLPTR = RWGET1(PFPL$BASE  #CURRPFRGPTR#); 
GPF1: 
  
          #GENPFPOSITN# 
  
          #GEN. MOVE AND PERFORM TO SPACE TO LINE NUMBER# 
          #(THIS SECTION USES TABLE OF LINE NUMBERS THAT HAVE#
          #BEEN CONVERTED TO ABSOLUTE BY THE R-PARSER.)#
  
          GENMOVE;
          PLTPNTR =  RWGET1(ABSOLUT$LNPF  #CURRPFLNPTR#); 
          GENILIT #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENPERFORM; 
          PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
          GENPNREF #PNATPTR# ;
          CURRPFLNPTR =  RWGET1(PFLNLINK  #CURRPFLNPTR#); 
  
          #GENMOVE4#
  
          #TEST IF THIS IS A CASE WHERE NO ITEMS IN THE PRINT#
          #LINE WERE PRINTABLE# 
  
          IF  RWGET1(PL$DNATPF  #CURRPFPLPTR#) EQ 0 
          THEN
              GOTO PFGM2; 
          #GENERATE A MOVE STATEMENT THAT WILL FORMAT ONE#
          #ITEM INTO THE PRINT LINE#
  
PFITEMLOOP: 
          DNATPTR = RWGET1(PL$DNATPF  #CURRPFPLPTR#); 
          LINENUM = GETQUICK(DN$LINE,DNAT$,DNATPTR);
          GENEOC #LINENUM# ;
          GENMOVE;
          IF  RWGET1(ITEMTYPEPF  #CURRPFPLPTR#) EQ 0
              #VALUE# 
          THEN
              BEGIN 
              IF  RWGET1(ALLVALUE$PF  #CURRPFPLPTR#) EQ 1 
              THEN
                  BEGIN 
                  GENALL; 
                  END 
              PLTPNTR = RWGET1(PI$SOURCEPF  #CURRPFPLPTR#); 
              GENVLIT #PLTPNTR# ; 
              GOTO PFGENTO; 
              END 
          IF  RWGET1(ITEMTYPEPF  #CURRPFPLPTR#) EQ 1
              #SOURCE#
          THEN
              BEGIN 
              IF  RWGET1(SISOURCE$PF  #CURRPFPLPTR#) EQ 1 
              THEN
                  BEGIN 
                  SAUXINDEX = RWGET1(PI$SOURCEPF  #CURRPFPLPTR#); 
                  #GET DATA OUT OF RP-AUX-TABLE#
                  DNATPTR = RWGET(RASRCEIDNAT,SAUXINDEX); 
                  GENDNREF #DNATPTR# ;
PFSILOOP1:  
                  SAUXINDEX = SAUXINDEX + 1;
                  PSICTEXTATOM = RWGET(RASICTEXT,SAUXINDEX);
                  GENSUBINDX #PSICTEXTATOM# ; 
                  IF RWGET(RALASTSINTRY,SAUXINDEX) EQ 1 
                  THEN
                      GOTO PFGENTO; 
                  GOTO PFSILOOP1; 
                  END 
              #ELSE#
  
              DNATPTR =  RWGET1(PI$SOURCEPF  #CURRPFPLPTR#);
              GENDNREF #DNATPTR# ;
              GOTO PFGENTO; 
              END 
PFGENTO:  
          GENTO;
          DNATPTR =  RWGET1(PL$DNATPF  #CURRPFPLPTR#);
          GENDNREF #DNATPTR# ;
  
          #DOES CURRENT ENTRY HAVE A PRINT LINE DELIMITER#
          #ASSOCIATED WITH IT&# 
  
          IF  RWGET1(PL$PF$DELIM  #CURRPFPLPTR#) EQ 1 
          THEN
              GOTO PFGM4; 
  
          #A REPORT GROUP DELIMITER&# 
  
          IF  RWGET1(PL$PF$DELIM  #CURRPFPLPTR#) EQ 2 
          THEN
              GOTO PFGM3; 
          CURRPFPLPTR   =  RWGET1(PFPLLINK  #CURRPFPLPTR#); 
          GOTO PFITEMLOOP;
PFGM2:  
          #RG DELIMITER ASS. WITH THIS ENTRY&#
  
          IF  RWGET1(PL$PF$DELIM  #CURRPFPLPTR#) EQ 2 
          THEN
              BEGIN 
PFGM3:  
              PFPLFLAG = 0; 
              GOTO GENPFWRITE;
              END 
PFGM4:  
          CURRPFPLPTR =  RWGET1(PFPLLINK  #CURRPFPLPTR#); 
  
GENPFWRITE: 
          GENWRITE; 
          DNATPTR =  RWGET1(RECORD$NAME1  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          IF PFPLFLAG NQ 0
          THEN
              GOTO GPF1;
  
          #ELSE THE PRINT LINE TABLE (PFPLLINK) HAS BEEN EXHAUSTED.#
  
  
          #END OF GENPFLINES# 
  
  
          #WAS THERE A NEXT GROUP PHRASE IN THIS REPORT GROUP&# 
  
          IF  RWGET1(PFNXTGRUPIND  #CURRPFRGPTR#) EQ 0
          THEN
              GOTO GPFT1; 
          #WAS NO NEXT GROUP PHRASE#
  
          #GENPFNG# 
  
          #GEN. CODE FOR DOING ANY NEXT GROUP SPACING#
          #ADD 1, ABSOLUTE-NG-INTEGER GIVING S-L-N# 
          #PERFORM SPACING# 
          #SUBTRACT 1 FROM LINE COUNTER#
          #(NOTE  NG INTEGER WILL ALWAYS BE ABSOLUTE HERE  IT#
          #WAS CONVERTED IF ORIGINALLY RELATIVE)# 
  
          GENADD; 
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          PLTPNTR =  RWGET1(PFNGINTPLTPT  #CURRPFRGPTR#); 
          GENILIT #PLTPNTR# ; 
          GENGIVING;
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENPERFORM; 
          PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
          GENPNREF #PNATPTR# ;
          GENSUBTRACT;
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENFROM;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
GPFT1:  
  
          #GENPFEXIT# 
          #GENERATE PAGE FOOTING EXIT PARAGRAPH#
          #AND A PRECEDING PERIOD#
          #.# 
          #PAGE-FOOTING-EXIT.#
          #EXIT.# 
  
          GENPERIOD;
          PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENEXIT;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$PFOOT")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$PFOOT# 
          CONTROL EJECT;
ENTRY PROC G$RFOOT; 
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL REPORT FOOTING ROUTINE IN# 
          #CTEXT FORM#
  
  
          #GENRFUBR#
  
          #GEN. CTEXT FOR ROUTINE NAME AND THE STATEMENT FOR# 
          #USE BEFORE REPORTING AND SUPPRESS# 
          #REPORT-FOOTING#
          #NEWVERB REPORT-GROUP-NAME  RF-ROUTINE-EXIT#
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$RFOOT")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENRWVERB;
          CURRRFRGPTR = RWGET1(RGBASERGTABL  #CURRRPTGRPTR#); 
          DNATPTR =  RWGET1(RG$NAMERF  #CURRRFRGPTR#);
          GENDNREF #DNATPTR# ;
          PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
          GENPNREF #PNATPTR# ;
  
          #IS RF REPORT GROUP PRINTABLE&# 
  
          IF  RWGET1(RFLN$BASE  #CURRRFRGPTR#) EQ 0 
          THEN
              GOTO GRF1;
          #NO LINE NUMBERS  RF NOT PRINTABLE# 
  
          #ELSE,IF PRINTABLE# 
  
          RFPLFLAG = 1; 
          CURRRFLNPTR =  RWGET1(RFLN$BASE  #CURRRFRGPTR#);
          CURRRFPLPTR =  RWGET1(RFPL$BASE  #CURRRFRGPTR#);
  
          #GENRFLINES#
  
          #GEN. THE CODE THAT WILL PRINT ALL LINES OF REPORT# 
          #FOOTING# 
  
  
          #GENRFPOSITN# 
  
          #FIRST GEN. THE CODE TO SPACE TO THE FIRST PRINT LINE#
          #POSITION#
          #MOVE  ABSOLUTE-LN  TO  S-L-N#
          #(SOMETIMES INSERT )# 
          #IF S-L-N  -1  -LINE-COUNTER IS LESS THAN 0#
          #ENTER C.RWMSG USING RWVRBLINE RWERR6#
          #GO TO RF-EXIT. # 
          #PERFORM SPACING# 
          #OR#
          #ADD RELATIVE-LN. LINE-COUNTER GIVING S-L-N#
          #(SOMETIMES INSERT )# 
          #IF S-L-N  -1  -LINE-COUNTER IS LESS THAN 0#
          #ENTER C.RWMSG USING RWVRBLINE RWERR6#
          #GO TO RF-EXIT. # 
          #IF S-L-N IS GREATER THAN PAGE-LIMIT# 
          #GO TO RF-EXIT.#
          #PEFORM SPACING#
          #OR#
          #WRITE RECORD-NAME-1 FROM SPACING-AREA AFTER ADVANCING PAGE#
          #MOVE 0 TO LINE-COUNTER#
          #MOVE ABSOLUTE-INT TO S-L-N#
          #PERFORM SPACING# 
          #ADD 1 TO PAGE-COUNTER# 
  
          IF  RWGET1(KIND$LNINTRF  #CURRRFLNPTR#) EQ 1
              #ABSOLUTE#
          THEN
              BEGIN 
              GENMOVE;
              PLTPNTR =  RWGET1(LNINT$PLTRF  #CURRRFLNPTR#);
              GENILIT #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
              GENDNREF #DNATPTR# ;
              IF  RWGET1(RFPF$OVERLAP  #CURRRFRGPTR#) EQ 1
              THEN
                  BEGIN 
                  GENIF;
                  DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
                  GENDNREF #DNATPTR# ;
                  GENMINUS; 
                  PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
                  GENLIT1 #PLTPNTR# ; 
                  GENMINUS; 
                  DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
                  GENDNREF #DNATPTR# ;
                  GENLESSTHAN;
                  PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
                  GENLIT0 #PLTPNTR# ; 
                  GENENTER; 
                  PLTPNTR = RWGET1(OSINCIDENCE #CURRIRTPTR#); 
                  GENLIT #PLTPNTR#; 
                  GENUSING; 
                  DNATPTR = CCTRWVRBLINE; 
                  GENDNREF #DNATPTR#; 
                  PLTPNTR = RWGET1(RF$ERRORMES #CURRFGPTR#);
                  GENLIT #PLTPNTR#; 
                  GENGO;
                  GENTO;
                  PNATPTR= RWGET1(RGPARANAME2  #CURRRPTGRPTR#); 
                  GENPNREF #PNATPTR# ;
                  GENPERIOD;
                  END 
              GENPERFORM; 
              PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
              GENPNREF #PNATPTR# ;
              END 
  
  
          IF  RWGET1(KIND$LNINTRF  #CURRRFLNPTR#) EQ 2
              #RELATIVE#
          THEN
              BEGIN 
              GENADD; 
              PLTPNTR =  RWGET1(LNINT$PLTRF  #CURRRFLNPTR#);
              GENILIT #PLTPNTR# ; 
              DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENGIVING;
              DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
              GENDNREF #DNATPTR# ;
              IF  RWGET1(RFPF$OVERLAP  #CURRRFRGPTR#) EQ 1
              THEN
                  BEGIN 
                  GENIF;
                  DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
                  GENDNREF #DNATPTR# ;
                  GENMINUS; 
                  PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
                  GENLIT1 #PLTPNTR# ; 
                  GENMINUS; 
                  DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
                  GENDNREF #DNATPTR# ;
                  GENLESSTHAN;
                  PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
                  GENLIT0 #PLTPNTR# ; 
                  GENENTER; 
                  PLTPNTR = RWGET1(OSINCIDENCE #CURRIRTPTR#); 
                  GENLIT #PLTPNTR#; 
                  GENUSING; 
                  DNATPTR = CCTRWVRBLINE; 
                  GENDNREF #DNATPTR#; 
                  PLTPNTR = RWGET1(RF$ERRORMES #CURRFGPTR#);
                  GENLIT #PLTPNTR#; 
                  GENGO;
                  GENTO;
                  PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
                  GENPNREF #PNATPTR# ;
                  GENPERIOD;
                  END 
              IF  RWGET1(PFRFOVERLIMT  #CURRRFRGPTR#) EQ 1
              THEN
                  BEGIN 
                  GENIF;
                  DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
                  GENDNREF #DNATPTR# ;
                  GENGREATTHAN; 
                  PLTPNTR =  RWGET1(IRTPAGELIMIT  #CURRIRTPTR#);
                  GENILIT #PLTPNTR# ; 
                  GENGO;
                  GENTO;
                  PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
                  GENPNREF #PNATPTR# ;
                  GENPERIOD;
                  END 
              GENPERFORM; 
              PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
              GENPNREF #PNATPTR# ;
              END 
  
  
          IF  RWGET1(KIND$LNINTRF  #CURRRFLNPTR#) EQ 3
              #NEXT PAGE - ABSOLUTE#
          THEN
              BEGIN 
              GENWRITE; 
              DNATPTR =  RWGET1(RECORD$NAME1  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENFROM;
              DNATPTR =  RWGET1(SPACING$AREA  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENAFTER; 
              GENADVANCING; 
              GENPAGE;
              GENMOVE;
              PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
              GENLIT0 #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENMOVE;
              PLTPNTR =  RWGET1(LNINT$PLTRF  #CURRRFLNPTR#);
              GENILIT #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
              GENDNREF #DNATPTR# ;
              GENPERFORM; 
              PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
              GENPNREF #PNATPTR# ;
              GENADD; 
              PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
              GENLIT1 #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(IRTPCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              END 
  
  
          CURRRFLNPTR = RWGET1(RFLNLINK  #CURRRFLNPTR#);
          GOTO GENMOVE5;
          #GO TO SET UP FIRST PRINT LINE# 
  
          #END OF CODE FOR SPACING  TO FIRST PRINT LINE POSITION# 
          #*********************************************************# 
          #THE FOLLOWING GENERATES CODE FOR SPACING TO ANY PRINT# 
          #LINE POSITION AFTER THE FIRST# 
  
GPLRF1: 
  
          #GENERATE#
          #MOVE ABSOLUTE-LN  TO S-L-N#
          #PERFORM SPACING# 
          #OR#
          #ADD RELATIVE-LN  LINE-COUNTER GIVING S-L-N#
          #(SOMETIMES INSERT )# 
          #IF S-L-N IS GREATER THAN PAGE-LIMIT# 
          #GO TO RF-EXIT.#
          #PERFORM SPACING# 
  
          IF  RWGET1(KIND$LNINTRF  #CURRRFLNPTR#) EQ 1
          THEN
              #ABSOLUTE#
          BEGIN 
              GENMOVE;
              PLTPNTR = RWGET1(LNINT$PLTRF  #CURRRFLNPTR#); 
              GENILIT #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
              GENDNREF #DNATPTR# ;
              GENPERFORM; 
              PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
              GENPNREF #PNATPTR# ;
              END 
          IF  RWGET1(KIND$LNINTRF  #CURRRFLNPTR#) EQ 2
          THEN
              #RELATIVE#
          BEGIN 
              GENADD; 
              PLTPNTR = RWGET1(LNINT$PLTRF  #CURRRFLNPTR#); 
              GENLIT #PLTPNTR# ;
              DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENGIVING;
              DNATPTR =   RWGET1(SLN  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              IF  RWGET1(PFRFOVERLIMT  #CURRRFRGPTR#) EQ 1
              THEN
                  BEGIN 
                  GENIF;
                  DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
                  GENDNREF #DNATPTR# ;
                  GENGREATTHAN; 
                  PLTPNTR =  RWGET1(IRTPAGELIMIT  #CURRIRTPTR#);
                  GENILIT #PLTPNTR# ; 
                  GENGO;
                  GENTO;
                  PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
                  GENPNREF #PNATPTR# ;
                  END 
              GENPERFORM; 
              PNATPTR=  RWGET1(SPACING  #CURRIRTPTR#);
              GENPNREF #PNATPTR# ;
              END 
          CURRRFLNPTR = RWGET1(RFLNLINK  #CURRRFLNPTR#);
  
GENMOVE5: 
          #TEST IF THIS IS A CASE WHERE NO ITEMS IN THE PRINT#
          #LINE WERE PRINTABLE# 
  
          IF  RWGET1(PL$DNATRF  #CURRRFPLPTR#) EQ 0 
          THEN
              GOTO RFGM2; 
RFITEMLOOP: 
          #GENERATE A MOVE STATEMENT THAT WILL FORMAT ONE#
          #ITEM INTO THE PRINT LINE#
  
          DNATPTR = RWGET1(PL$DNATRF  #CURRRFPLPTR#); 
          LINENUM = GETQUICK(DN$LINE,DNAT$,DNATPTR);
          GENEOC #LINENUM# ;
          GENMOVE;
          IF  RWGET1(ITEMTYPERF  #CURRRFPLPTR#) EQ 0
              #VALUE# 
          THEN
              BEGIN 
              IF  RWGET1(ALLVALUE$RF  #CURRRFPLPTR#) EQ 1 
              THEN
                  BEGIN 
                  GENALL; 
                  END 
              PLTPNTR = RWGET1(PI$SOURCERF  #CURRRFPLPTR#); 
              GENVLIT #PLTPNTR# ; 
              GOTO RFGENTO; 
              END 
          IF  RWGET1(ITEMTYPERF  #CURRRFPLPTR#) EQ 1
              #SOURCE#
          THEN
              BEGIN 
              IF  RWGET1(SISOURCE$RF  #CURRRFPLPTR#) EQ 1 
              THEN
                  BEGIN 
                  SAUXINDEX = RWGET1(PI$SOURCERF  #CURRRFPLPTR#); 
                  #GET DATA OUT OF RP-AUX-TABLE#
                  DNATPTR = RWGET(RASRCEIDNAT,SAUXINDEX); 
                  GENDNREF #DNATPTR# ;
RFSILOOP1:  
                  SAUXINDEX = SAUXINDEX + 1;
                  PSICTEXTATOM = RWGET(RASICTEXT,SAUXINDEX);
                  GENSUBINDX #PSICTEXTATOM# ; 
                  IF RWGET(RALASTSINTRY,SAUXINDEX) EQ 1 
                  THEN
                      GOTO RFGENTO; 
                  GOTO RFSILOOP1; 
                  END 
              #ELSE#
  
              DNATPTR =  RWGET1(PI$SOURCERF  #CURRRFPLPTR#);
              GENDNREF #DNATPTR# ;
              GOTO RFGENTO; 
              END 
RFGENTO:  
          GENTO;
          DNATPTR =  RWGET1(PL$DNATRF  #CURRRFPLPTR#);
          GENDNREF #DNATPTR# ;
  
          #DOES CURRENT ENTRY HAVE A PRINT LINE DELIMITER#
          #ASSOCIATED WITH IT&# 
  
          IF  RWGET1(PL$RF$DELIM  #CURRRFPLPTR#) EQ 1 
          THEN
              GOTO RFGM4; 
  
          #A REPORT GROUP DELIMITER&# 
  
          IF  RWGET1(PL$RF$DELIM  #CURRRFPLPTR#) EQ 2 
          THEN
              GOTO RFGM3; 
          CURRRFPLPTR =  RWGET1(RFPLLINK  #CURRRFPLPTR#); 
          GOTO RFITEMLOOP;
RFGM2:  
          #RG DELIMITER ASS. WITH THIS ENTRY&#
  
          IF  RWGET1(PL$RF$DELIM  #CURRRFPLPTR#) EQ 2 
          THEN
              BEGIN 
RFGM3:  
              RFPLFLAG = 0; 
              GOTO GENRFWRITE;
              END 
RFGM4:  
          CURRRFPLPTR =   RWGET1(RFPLLINK  #CURRRFPLPTR#);
  
GENRFWRITE: 
          #GENERATE#
          #WRITE RECORD-NAME-1# 
  
          GENWRITE; 
          DNATPTR =  RWGET1(RECORD$NAME1  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          IF RFPLFLAG  NQ  0
          THEN
              GOTO GPLRF1;
  
          #ELSE THE PRINT LINE TABLE (RFPLLINK) HAS BEEN EXHAUSTED.#
  
  
          #END OF GENRFLINES# 
  
GRF1: 
  
          #GENRFEXIT# 
  
  
          #GENERATE THE REPORT FOOTING EXIT PARAGRAPH#
          #(AND A PRECEDING PERIOD)#
          #.# 
          #REPORT-FOOTING-EXIT.#
          #EXIT.# 
  
          GENPERIOD;
          PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENEXIT;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$RFOOT")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$RFOOT# 
          END #FOOTING# 
          TERM
