*DECK INTERSC 
USETEXT CCTTEXT 
USETEXT RPTEXT
PROC INTERSC; 
          BEGIN 
          ITEM   CTEMP        C(10);
          ITEM   $TEMP$;
*CALL RGCOMM1 
*CALL RGCOMM2 
*CALL GETSET
*CALL PLT1
*CALL PLTVALS 
*CALL PNAT1 
*CALL TABLNAMES 
  
          CONTROL EJECT;
ENTRY PROC G$INIT;
  
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL  INITIATE ROUTINE  IN CTEXT FORM#
  
          #GENERATE#
          #INITIATE.# 
          #IF INITIATE-FLAG NOT =  0# 
          #ENTER C.RWMSG USING RWVRBLINE RWERR7#
          #GO TO  INITIATE-EXIT.# 
          #MOVE 1 TO  INITIATE-FLAG#
          #FIRST-GENERATE#
          #PAGE-COUNTER#
          #GROUP-INDICATE-FLAG-1# 
          #GROUP-INDICATE-FLAG-2  ETC.# 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$INIT ")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          PNATPTR =   RWGET1(INITIATE  #CURRIRTPTR#); 
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENIF;
          DNATPTR =   RWGET1(INITIATEFLAG  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENNOT; 
          GENEQUAL; 
          PLTPNTR =   RWGET1(IRTINTZERO  #CURRIRTPTR#); 
          GENLIT0 #PLTPNTR# ; 
          GENENTER; 
          PLTPNTR = RWGET1(OSINCIDENCE #CURRIRTPTR#); 
          GENLIT #PLTPNTR#; 
          GENUSING; 
          DNATPTR = CCTRWVRBLINE; 
          GENDNREF #DNATPTR#; 
          PLTPNTR = RWGET1(INITERRORPLT #CURRIRTPTR#);
          GENLIT #PLTPNTR#; 
          GENGO;
          GENTO;
          PNATPTR =  RWGET1(INITIATEXIT  #CURRIRTPTR#); 
          GENPNREF #PNATPTR# ;
          GENPERIOD;
          GENWRITE; 
          DNATPTR = RWGET1(RECORD$NAME1  #CURRIRTPTR#); 
          GENDNREF #DNATPTR#; 
          GENFROM;
          DNATPTR = RWGET1(SPACING$AREA  #CURRIRTPTR#); 
          GENDNREF #DNATPTR#; 
          GENAFTER; 
          GENADVANCING; 
          GENPAGE;
          GENMOVE;
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(INITIATEFLAG  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          DNATPTR =  RWGET1(FIRSTGENERAT  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          DNATPTR =  RWGET1(IRTPCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          #GENSETGI#
          CURRGRINDPTR =  RWGET1(BASE$GRPIND  #CURRIRTPTR#);
GRINDLOOP:  
          IF  RWGET1(GIFLAG$DNAT  #CURRGRINDPTR#) EQ 0
          THEN
              GOTO CHKGIDELIM;
          DNATPTR =  RWGET1(GIFLAG$DNAT  #CURRGRINDPTR#); 
          GENDNREF #DNATPTR# ;
CHKGIDELIM: 
          IF  RWGET1(GITEOT$DELIM  #CURRGRINDPTR#) NQ 1 
          THEN
              BEGIN 
              CURRGRINDPTR = RWGET1(GRINDLINK  #CURRGRINDPTR#); 
              GOTO GRINDLOOP; 
              END 
  
          #GENERATE#
          #MOVE 0 TO  LINE-COUNTER# 
          #RH-ON-PAGE#
          #GENERATE-FLAG# 
          #PH-PRESENTED#
          #SNGI#
          #SUM-COUNTER-1# 
          #SUM-COUNTER-2.  ETC.#
          #(PERIOD IS GEN"D UNDER GENINITEXIT)# 
  
          GENMOVE;
          PLTPNTR =   RWGET1(IRTINTZERO  #CURRIRTPTR#); 
          GENLIT0 #PLTPNTR# ; 
          GENTO;
          DNATPTR =   RWGET1(IRTLCINDEX  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          DNATPTR =   RWGET1(RH$ON$PAGE  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          DNATPTR =   RWGET1(GENERATEFLAG  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          DNATPTR =   RWGET1(PH$PRESENTED  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          CURRIPCTPTR = RWGET1(BASE$IPCT  #CURRIRTPTR#);
          IF CURRIPCTPTR NQ 0 
          THEN
              #THERE WAS A PAGE CLAUSE AND# 
              #SO A SNGI                  # 
              BEGIN 
              DNATPTR = RWGET1(SNGIDNAT  #CURRIPCTPTR#);
              GENDNREF #DNATPTR#; 
              END 
  
          #GENZEROSC# 
  
          IF  RWGET1(BASE$SUMCNTR  #CURRIRTPTR#)  EQ  0 
          THEN
              GOTO GENINITEXIT; 
          CURRSUMCNPTR =  RWGET1(BASE$SUMCNTR  #CURRIRTPTR#); 
INITSUMCNTRL: 
          DNATPTR = RWGET1(SUMCNTR$DNAT  #CURRSUMCNPTR#); 
          GENDNREF #DNATPTR# ;
          IF  RWGET1(SUMCNTRDELIM  #CURRSUMCNPTR#)
              NQ  1 
          THEN
              BEGIN 
              CURRSUMCNPTR   =   RWGET1(SUMCNTRLINK  #CURRSUMCNPTR#); 
              GOTO INITSUMCNTRL;
              END 
GENINITEXIT:  
          GENPERIOD;
          #GENERATE#
          #INITIATE-EXIT.#
          #EXIT.# 
  
          PNATPTR =   RWGET1(INITIATEXIT  #CURRIRTPTR#);
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENEXIT;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$INIT ")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$INIT#
          CONTROL EJECT;
ENTRY PROC G$TERM;
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL  TERMINATE ROUTINE  IN CTEXT FORM# 
  
          #GENERATE#
          #TERMINATE.#
          #IF INITIATE-FLAG  =  0#
          #ENTER C.RWMSG USING RWVRBLINE RWERR8#
          #GO TO TERMINATE-EXIT.# 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$TERM ")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          PNATPTR =  RWGET1(TERMINATE  #CURRIRTPTR#); 
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENIF;
          DNATPTR =  RWGET1(INITIATEFLAG  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENEQUAL; 
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENENTER; 
          PLTPNTR = RWGET1(OSINCIDENCE #CURRIRTPTR#); 
          GENLIT #PLTPNTR#; 
          GENUSING; 
          DNATPTR = CCTRWVRBLINE; 
          GENDNREF #DNATPTR#; 
          PLTPNTR = RWGET1(TERMERRORPLT #CURRIRTPTR#);
          GENLIT #PLTPNTR#; 
          GENGO;
          GENTO;
          PNATPTR =  RWGET1(TERMINATEXIT  #CURRIRTPTR#);
          GENPNREF #PNATPTR# ;
          GENPERIOD;
  
          #GENERATE#
          #MOVE 0 TO INITIATE-FLAG# 
          #IF GENERATE-FLAG  = 0# 
          #GO TO TERMINATE-EXIT.# 
  
          GENMOVE;
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(INITIATEFLAG  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENIF;
          DNATPTR =  RWGET1(GENERATEFLAG  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENEQUAL; 
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENGO;
          GENTO;
          PNATPTR =  RWGET1(TERMINATEXIT  #CURRIRTPTR#);
          GENPNREF #PNATPTR# ;
          GENPERIOD;
          NEEDPERIOD = 0; 
  
          #GENERATE  (TO PRODUCE CONTROL FOOTING REPORT GROUPS)#
          #PERFORM CONTROL-FOOTING-N  THRU CF-N-EXIT  (MINOR)#
          #.# 
          #.# 
          #PERFORM CONTROL-FOOTING-FINAL THRU CF-FINAL-EXIT (ETC.)# 
  
          CURRCNTRLPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
  
          #WERE ANY CONTROL DATA ITEMS SPECIFIED FOR THIS REPORT&#
  
          IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#)      NQ  1 
          THEN
              #GEN-CF-PERFORMS# 
          BEGIN 
              #(THERE WAS A CONTROLS CLAUSE FOR THIS REPORT)# 
              NUMCONTROLS = 0;
COUNTLOOP:  
              IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#) NQ  1
              THEN
                  BEGIN 
                  NUMCONTROLS= NUMCONTROLS + 1; 
                  CURRCNTRLPTR =  RWGET1(CONTROLSLINK  #CURRCNTRLPTR#); 
                  GOTO COUNTLOOP; 
                  END 
SETPTR: 
              LINKNUM = 1;
              CURRCNTRLPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
LINKLOOP: 
              IF LINKNUM EQ NUMCONTROLS 
              THEN
                  GOTO TGENCFPERFRM;
              CURRCNTRLPTR =  RWGET1(CONTROLSLINK  #CURRCNTRLPTR#); 
              LINKNUM = LINKNUM + 1;
              GOTO LINKLOOP;
TGENCFPERFRM: 
              IF  RWGET1(CF$BIT  #CURRCNTRLPTR#) EQ 1 
              THEN
                  BEGIN 
                  GENPERFORM; 
                  PNATPTR =  RWGET1(CF$PNAT  #CURRCNTRLPTR#); 
                  GENPNREF #PNATPTR# ;
                  GENTHRU;
                  PNATPTR =  RWGET1(CF$EXIT$PNAT  #CURRCNTRLPTR#);
                  GENPNREF #PNATPTR# ;
                  NEEDPERIOD = 1; 
                  END 
              NUMCONTROLS = NUMCONTROLS - 1;
              IF NUMCONTROLS  NQ  0 
              THEN
                  GOTO SETPTR;
              END 
  
          #DOES PAGE CLAUSE EXIST  AND  IS# 
          #FIRST LINE NUMBER CLAUSE OF REPORT FOOTING RELATIVE&#
  
          IF  RWGET1(QUESTIONTERM  #CURRIRTPTR#) EQ 1 
              #YES# 
          THEN
              BEGIN 
  
              #GENERATE#
              #ADD FOOTING, 1 GIVING S-L-N# 
              #PERFORM SPACING# 
              #SUBTRACT 1 FROM LINE-COUNTER#
  
              GENADD; 
              PLTPNTR =  RWGET1(FOOTING  #CURRIRTPTR#); 
              GENILIT #PLTPNTR# ; 
              PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
              GENLIT1 #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# ;
              NEEDPERIOD = 1; 
              END 
  
          #WAS PAGE-FOOTING DEFINED FOR THIS REPORT&# 
  
          CURRRPTGRPTR =  RWGET1(BASE$REPORTG  #CURRIRTPTR#); 
TCHKPF: 
          IF  RWGET1(RGTYPEOFRG  #CURRRPTGRPTR#) EQ 6 
              #PF#
          THEN
              BEGIN 
              #GENERATE#
              #PERFORM PAGE-FOOTING THRU PAGE-FOOTING-EXIT# 
  
              GENPERFORM; 
              PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              NEEDPERIOD = 1; 
              GOTO TCHKRF;
              END 
          IF RWGET1(RGEOTDELIM  #CURRRPTGRPTR#)  EQ 1 
          THEN
              GOTO TCHKRF;
          CURRRPTGRPTR = RWGET1(RGTLINK  #CURRRPTGRPTR#); 
          GOTO  TCHKPF; 
TCHKRF: 
          CURRRPTGRPTR = RWGET1(BASE$REPORTG  #CURRIRTPTR#);
T2CHKRF:  
          IF  RWGET1(RGTYPEOFRG  #CURRRPTGRPTR#) EQ 7 
              #RF#
          THEN
              BEGIN 
              #GENERATE#
              #PERFORM REPORT-FOOTING  THRU REPORT-FOOTING-EXIT#
  
              GENPERFORM; 
              PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GOTO TEXIT; 
              END 
          IF RWGET1(RGEOTDELIM  #CURRRPTGRPTR#)  EQ 1 
          THEN
              GOTO TEXIT; 
          CURRRPTGRPTR=  RWGET1(RGTLINK  #CURRRPTGRPTR#); 
          GOTO T2CHKRF; 
TEXIT:  
          #GENERATE THE FOLLOWING, INC. "PRECEDING" .#
          #.# 
          #TERMINATE-EXIT.# 
          #EXIT.# 
  
          IF NEEDPERIOD EQ 1
          THEN
              GENPERIOD;
          PNATPTR =   RWGET1(TERMINATEXIT  #CURRIRTPTR#); 
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENEXIT;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$TERM ")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$TERM#
          CONTROL EJECT;
ENTRY PROC G$SPACE; 
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL  SPACING ROUTINE IN CTEXT FORM#
  
          #GENERATE#
          #SPACING.#
          #IF S-L-N > 1#
          #IF LINE-COUNTER = 0# 
          #MOVE 1 TO LINE-COUNTER.# 
          #IF S-L-N - 1 - LINE-COUNTER < 0# 
          #MOVE 0 TO LINE-COUNTER#
          #ELSE#
          #IF LINE-COUNTER NOT = S-L-N - 1# 
          #SUBTRACT 1, LINE-COUNTER FROM S-L-N GIVING TEMP# 
          #WRITE RECORD-NAME-1 FROM SPACING-AREA AFTER# 
          #ADVANCING TEMP LINES.# 
          #MOVE SPACE-1 TO CARRIAGE-CONTROL-REC-AREA# 
          #IF LINE-COUNTER = 0# 
          #MOVE NO-ADVANCE TO CARRIAGE-CONTROL-REC-AREA#
          #MOVE 1 TO LINE-COUNTER#
          #ELSE MOVE S-L-N TO LINE-COUNTER.#
          #MOVE CODE-CLAUSE-LITERALS TO CODE-CLAUSE-REC-AREA (OPTIONAL)#
          #MOVE SPACES TO PRINT-LINE-RECORD-NAME-1.#
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$SPACE")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENIF;
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENGREATTHAN; 
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENIF;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENEQUAL; 
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENMOVE;
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENPERIOD;
          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# ; 
          GENMOVE;
          PLTPNTR = RWGET1(IRTINTZERO #CURRIRTPTR#);
          GENLIT #PLTPNTR#; 
          GENTO;
          DNATPTR = RWGET1(IRTLCINDEX #CURRIRTPTR#);
          GENDNREF #DNATPTR#; 
          GENELSE;
          GENIF;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENNOT; 
          GENEQUAL; 
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENMINUS; 
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENSUBTRACT;
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENFROM;
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENGIVING;
          DNATPTR =  RWGET1(RGTEMPORARY  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENWRITE; 
          DNATPTR =  RWGET1(RECORD$NAME1  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENFROM;
          DNATPTR =  RWGET1(SPACING$AREA  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENAFTER; 
          GENADVANCING; 
          DNATPTR =  RWGET1(RGTEMPORARY  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENLINES; 
          GENPERIOD;
          GENMOVE;
          DNATPTR =  RWGET1(SPACE$1  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENTO;
          DNATPTR =  RWGET1(CC$REC$AREA  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENIF;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENEQUAL; 
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENMOVE;
          DNATPTR =  RWGET1(NOADVANCE  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENTO;
          DNATPTR =  RWGET1(CC$REC$AREA  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENMOVE;
          PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
          GENLIT1 #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENELSE;
          GENMOVE;
          DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENTO;
          DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
          GENPERIOD;
  
          #DID USER SPECIFY A CODE CLAUSE FOR THIS REPORT &  IF SO, GEN#
          #"MOVE CODE-CLAUSE-LITERALS TO CODE-CLAUSE-REC-AREA"# 
  
          IF  RWGET1(CODE$CL$LITS  #CURRIRTPTR#)  NQ 0
          THEN
              BEGIN 
              GENMOVE;
              DNATPTR =  RWGET1(CODE$CL$LITS  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENTO;
              DNATPTR =  RWGET1(CODCLRECAREA  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              END 
          GENMOVE;
          #CREATE PLT ENTRY FOR SPACES# 
          CCTPLTLEN = CCTPLTLEN + 1;
          PLTPNTR = CCTPLTLEN;
          SETFIELD(PL$LENGTH,PLT$,PLTPNTR,1); 
          SETFIELD(PL$TYPE,PLT$,PLTPNTR,PLTQUOTEDLIT);
          CTEMP = " ";
          SETPLST(PLTPNTR,LOC(CTEMP));
          GENLIT #PLTPNTR#; 
          GENTO;
          DNATPTR =  RWGET1(PL$REC$NAME  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$SPACE")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$SPACE# 
          CONTROL EJECT;
ENTRY PROC G$CNTRL; 
          BEGIN 
  
          #THIS ROUTINE#
          #- GENERATES A COBOL  CONTROLS ROUTINE IN CTEXT FORM# 
  
  
          #INTERNAL PROCEDURE NO. 1#
  
PROC GENNEWPNAT;
          BEGIN 
          #GEN A NEW PARAGRAPH-NAME#
          CCTPNATLEN = CCTPNATLEN + 1;
          SETFIELD(PN$PREVSECTN,PNAT$,CCTPNATLEN,CCTRPSECTNAM); 
          #NOT A SOURCE STATEMENT ITEM# 
          PNATPTR = CCTPNATLEN; 
          END #GENNEWPNAT#
  
  
          #INITIALIZE#
          #GENERATE#
          #CONTROLS.# 
          #IF FIRST-GENERATE-FLAG    NOT = 0# 
          #MOVE  0 TO  FIRST-GENERATE-FLAG# 
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EPTRACE("G$CNTRL")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
  
          GENNEWPNAT; 
          #SET BIT IN PNAT# 
          PICONTROLS = PNATPTR; 
          GENPNDEF #PNATPTR# ;
          GENPERIOD;
          GENIF;
          DNATPTR =   RWGET1(FIRSTGENERAT  #CURRIRTPTR#); 
          GENDNREF #DNATPTR# ;
          GENNOT; 
          GENEQUAL; 
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENMOVE;
          PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
          GENLIT0 #PLTPNTR# ; 
          GENTO;
          DNATPTR =  RWGET1(FIRSTGENERAT  #CURRIRTPTR#);
          GENDNREF #DNATPTR# ;
  
          #DOES PAGE CLAUSE EXIST FOR THIS REPORT&# 
          #IF SO, GENERATE# 
          #MOVE 0 TO RH-ON-PAGE#
  
          IF  RWGET1(QUEST$PAGECL  #CURRIRTPTR#) EQ 1 
          THEN
              BEGIN 
              GENMOVE;
              PLTPNTR =  RWGET1(IRTINTZERO  #CURRIRTPTR#);
              GENLIT0 #PLTPNTR# ; 
              GENTO;
              DNATPTR =  RWGET1(RH$ON$PAGE  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              END 
  
          #INITIALIZATION FOR GENFIRSTGEN   AND  GENCFCONTROL#
  
          GOTOEXITFLAG = 0; 
          P001PNAT  = 0;
          CSETGIPNAT = 0; 
          CEXITPNAT =  0; 
  
          #GENFIRSTGEN# 
  
          #GENERATE CODE FOR CALLING ROUTINES FOR WHATEVER# 
          #HEADINGS WERE DEFINED# 
          #PERFORM REPORT-HEADING THRU R-H-EXIT#
          #PERFORM PAGE-HEADING THRU P-H-EXIT#
          #PERFORM CONTROL-HEADING-FINAL THRU CH-FINAL-EXIT#
          #GO TO 001.#
          #(OR)  GO TO CONTROLS-SET-GI.#
          #GO TO CONTROLS-EXIT.#
  
  
          #IS REPORT HEADING DEFINED FOR THIS REPORT&#
  
          CURRRPTGRPTR = RWGET1(BASE$REPORTG  #CURRIRTPTR#);
CRTRH:  
          IF RWGET1(RGTYPEOFRG  #CURRRPTGRPTR#)  EQ  1
          THEN
              BEGIN 
              GENPERFORM; 
              PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GOTO CRTPH; 
              END 
          IF  RWGET1(RGEOTDELIM  #CURRRPTGRPTR#) EQ 0 
          THEN
              BEGIN 
              CURRRPTGRPTR =  RWGET1(RGTLINK  #CURRRPTGRPTR#);
              GOTO  CRTRH;
              END 
  
          #WHEN EOT-DELIMITER = 1#
          #/*#
          #IS PAGE-HEADING DEFINED FOR THIS REPORT&#
  
CRTPH:  
          CURRRPTGRPTR = RWGET1(BASE$REPORTG  #CURRIRTPTR#);
CRT2PH: 
          IF RWGET1(RGTYPEOFRG  #CURRRPTGRPTR#)  EQ 2 
          THEN
              BEGIN 
              GENPERFORM; 
              PNATPTR = RWGET1(RGPARANAME1  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR = RWGET1(RGPARANAME2  #CURRRPTGRPTR#);
              GENPNREF #PNATPTR# ;
              GOTO CRTCH; 
              END 
          IF  RWGET1(RGEOTDELIM  #CURRRPTGRPTR#) EQ 0 
          THEN
              BEGIN 
              CURRRPTGRPTR =  RWGET1(RGTLINK  #CURRRPTGRPTR#);
              GOTO CRT2PH;
              END 
  
          #WHEN  EOT-DELIMITER  = 1#
          #/*#
          #IS A CONTROL HEADING FINAL DEFINED FOR THIS REPORT&# 
  
CRTCH:  
          CURRCNTRLPTR=  RWGET1(BASE$CNTROLS  #CURRIRTPTR#);
          IF RWGET1(EOCDELIMITER  #CURRCNTRLPTR#) EQ 1
          THEN
              GOTO CRTESTGI;
          IF  RWGET1(CID$PREVALUE  #CURRCNTRLPTR#)  EQ  0 
              AND 
              RWGET1(CH$BIT  #CURRCNTRLPTR#) EQ 1 
          THEN
              BEGIN 
              GENPERFORM; 
              PNATPTR =  RWGET1(CH$PNAT  #CURRCNTRLPTR#); 
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR =  RWGET1(CH$EXIT$PNAT  #CURRCNTRLPTR#);
              GENPNREF #PNATPTR# ;
              END 
  
          #DOES AT LEAST 1 CONTROL IDENTIFIER (OTHER THAN A FINAL) #
          #EXIST& # 
  
          CURRCNTRLPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
          IF  RWGET1(CID$PREVALUE  #CURRCNTRLPTR#) NQ  0
          THEN
              GOTO  CRTGEN001;
          CURRCNTRLPTR  = RWGET1(CONTROLSLINK  #CURRCNTRLPTR#); 
          IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#)  EQ 1
          THEN
              GOTO CRTESTGI;
CRTGEN001:  
          #WHEN THERE IS AT LEAST 1 CONTROL ID. OTHER THAN FINAL# 
  
          GENGO;
          GENTO;
          GENNEWPNAT; 
          GENPNREF #PNATPTR# ;
          P001PNAT = PNATPTR; 
          GENPERIOD;
          GOTO  GFG1; 
CRTESTGI: 
  
          #DOES REPORT HAVE DETAIL GROUP(S) WITH GROUP-INDICATED ITEMS&#
  
          CURRGRINDPTR =  RWGET1(BASE$GRPIND  #CURRIRTPTR#);
TGILOOP:  
          IF   RWGET1(GIFLAG$DNAT  #CURRGRINDPTR#)  NQ  0 
          THEN
              BEGIN 
              GENGO;
              GENTO;
              GENNEWPNAT; 
              GENPNREF #PNATPTR# ;
              CSETGIPNAT = PNATPTR; 
              GENPERIOD;
              GOTO  GFG1; 
              END 
          IF  RWGET1(GITEOT$DELIM  #CURRGRINDPTR#) NQ 1 
          THEN
              BEGIN 
              CURRGRINDPTR=  RWGET1(GRINDLINK  #CURRGRINDPTR#); 
              GOTO  TGILOOP;
              END 
  
          #GENERATE  "GO TO CONTROLS-EXIT." AS IS NOTHING ELSE FOR# 
          #THE GENERATED ROUTINE TO DO# 
  
          GENGO;
          GENTO;
          GENNEWPNAT; 
          CSETGIPNAT = PNATPTR; 
          GENNEWPNAT; 
          GENPNREF #PNATPTR# ;
          SETFIELD(PN$PERFLAST,PNAT$,CCTPNATLEN,1); 
          PICEXIT = PNATPTR;
          CEXITPNAT = PNATPTR;
          GENPERIOD;
          #SET THE FOLLOWING FLAG SO THAT THIS SAME STATEMENT#
          #WILL NOT BE GENERATED AT GENFORNCB#
          GOTOEXITFLAG = 1; 
GFG1: 
          #DO ANY CONTROLS EXIST FOR THIS REPORT& IF NOT JUMP TO GC1.#
  
          CURRCNTRLPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
          IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#)  EQ 1
          THEN
              GOTO GC1; 
          #ELSE-# 
          #GENCFCONTROL#
  
  
          #GENERATE CODE FOR CHECKING FOR CONTROL BREAKS, GENERATING# 
          #CONTROL FOOTINGS, AND DOING NEXT GROUP SPACING#
          #(FOR  EXAMPLE   -   )# 
          #IF DATA-NAME-1 NOT = CONTROL-IDENT-1#
          #PERFORM CONTROL-FOOTING-3  THRU  CF-3-EXIT#
          #PERFORM CONTROL-FOOTING-2  THRU  CF-2-EXIT#
          #PERFORM CONTROL-FOOTING-1  THRU  CF-1-EXIT#
          #MOVE NG-CF1-TABLE  TO  NG-TABLE# 
          #PERFORM BODY-NEXT-GROUP  THRU B-N-G-EXIT#
          #GO TO  001.# 
  
          #HOWEVER FOR CASE(S) WHERE IS NO PAGE CLAUSE AND WANT#
          #TO DO NEXT GROUP SPACING, GENERATE#
          #ADD 1 LINE-COUNTER REL-NG-INT-CF-N GIVING S-L-N# 
          #PERFORM SPACING# 
          #SUBTRACT 1 FROM LINE-COUNTER#
          #(THIS IS COND. 6F, IT MUST BE A RELATIVE NEXT GROUP)#
  
  
          #SAVE INITIAL LOCATION(BASE) FOR UPNLINK FOR# 
          #THIS TIME THRU G$CNTRL#
  
          CURRUNBASE = NEXTUPNPTR;
  
          #IS FIRST ENTRY A  "FINAL" &# 
  
          IF   RWGET1(CID$PREVALUE  #CURRCNTRLPTR#) NQ 0
          THEN
              GOTO GCFC1; 
GCC1: 
          CURRCNTRLPTR = RWGET1(CTROLSLINK1  #CURRCNTRLPTR#); 
          IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#) EQ 1 
          THEN
              BEGIN 
              RWSET1(UPNDELIMITER  #CURRUPNPTR#,1); 
              GOTO GENFORNCB; 
              END 
GCFC1:  
  
          #GENERATE#
          #IF DATA-NAME-N  NOT =  CONTROL-IDENT-N#
  
          GENIF;
          DNATPTR =  RWGET1(CID$DNAT  #CURRCNTRLPTR#);
          GENDNREF #DNATPTR# ;
          GENNOT; 
          GENEQUAL; 
          DNATPTR =  RWGET1(CID$PREVALUE  #CURRCNTRLPTR#);
          GENDNREF #DNATPTR# ;
  
          #WILL GEN. ALL PERFORMS, STARTING AT BOTTOM OF CONTROLS-# 
          #TABLE  AND COMING UP THRU CURRENT CONTROL-ID LEVEL.# 
  
          TEMPCTPTR =   RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
          NUMCONTROLS = 0;
CTCOUNTLOOP:  
          IF   RWGET(EOCDELIMITER,TEMPCTPTR)
              NQ 1
          THEN
              BEGIN 
              NUMCONTROLS = NUMCONTROLS + 1;
              TEMPCTPTR =  RWGET(CONTROLSLINK,TEMPCTPTR); 
              GOTO CTCOUNTLOOP; 
              END 
  
          #BUMP THRU CONTROLS-TABLE  TIL GET TO LAST ENTRY THAT#
          #IS NOT AN EOCDELIMITER # 
  
          BUMPCTR = NUMCONTROLS;
          TEMPCTPTR =   RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
CTBUMPLOOP: 
          IF BUMPCTR NQ 1 
          THEN
              BEGIN 
              BUMPCTR = BUMPCTR - 1;
              TEMPCTPTR =   RWGET(CONTROLSLINK,TEMPCTPTR);
              GOTO  CTBUMPLOOP; 
              END 
  
          #WHEN BUMPCTR = 1, TEMPCTPTR  IS POINTING TO THE LAST#
          #NON-EOC CONTROLSLINK  ENTRY# 
  
          MUCOUNT = NUMCONTROLS;
CFPERFRMLOOP: 
  
          #IS CF-BIT  FOR THIS CONTROL = 1&#
  
          IF  RWGET(CF$BIT,TEMPCTPTR)  EQ 1 
          THEN
              BEGIN 
              GENPERFORM; 
              PNATPTR =  RWGET(CF$PNAT,TEMPCTPTR);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR =  RWGET(CF$EXIT$PNAT,TEMPCTPTR); 
              GENPNREF #PNATPTR# ;
              END 
  
          #IS CONTROL FROM CURRCNTRLPTR  ENTRY# 
          #CONTROL OF  TEMPCTPTR  ENTRY&# 
  
          IF CURRCNTRLPTR EQ  TEMPCTPTR 
          THEN
              GOTO  GCC2; 
  
          #IF NOT, MOVE UP THRU CONTROLSLINK TO "PREVIOUS"# 
          #ENTRY# 
  
          MUCOUNT = MUCOUNT - 1;
          LINKNUM = 1;
          TEMPCTPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#);
CFPLINKLOOP:  
          IF LINKNUM EQ MUCOUNT 
          THEN
              GOTO CFPERFRMLOOP;
          TEMPCTPTR =  RWGET(CONTROLSLINK,TEMPCTPTR); 
          LINKNUM = LINKNUM + 1;
          GOTO CFPLINKLOOP; 
GCC2: 
  
          #IS THERE A C.F.  ASSOCIATED WITH THE CONTROL IDENT#
          #ENTRY TO WHICH CURRCNTRLPTR  IS POINTING&# 
  
          IF  RWGET1(CF$BIT  #CURRCNTRLPTR#) EQ 0 
          THEN
              GOTO GCC3;
  
          #IS THERE A NEXT GROUP CLAUSE ASS. WITH THIS CF &#
  
          IF  RWGET1(NULLIFNONG  #CURRCNTRLPTR#) EQ 0 
          THEN
              GOTO GCC3;
  
          #IS THERE A PAGE CLAUSE ASS. WITH THIS REPORT&# 
  
          IF  RWGET1(QUEST$PAGECL  #CURRIRTPTR#)  EQ 1
          THEN
              BEGIN 
              GENMOVE;
              DNATPTR =  RWGET1(NGCFTABLDNAT  #CURRCNTRLPTR#);
              GENDNREF #DNATPTR# ;
              GENTO;
              DNATPTR =  RWGET1(NG$TABLE  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GENPERFORM; 
              PNATPTR =  RWGET1(BODYNEXTGRUP  #CURRIRTPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR =  RWGET1(BNG$EXIT  #CURRIRTPTR#);
              GENPNREF #PNATPTR# ;
              GOTO GCC3;
              END 
          IF RWGET1(BIT6F1  #CURRCNTRLPTR#) EQ 1
          #NO PAGE CLAUSE, NG MUST BE RELATIVE# 
          THEN
              BEGIN 
              GENADD; 
              PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
              GENLIT1 #PLTPNTR# ; 
              DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              PLTPNTR = RWGET1(RELNGINT$PLT  #CURRCNTRLPTR#); 
              GENILIT #PLTPNTR# ; 
              GENGIVING;
              DNATPTR =  RWGET1(SLN  #CURRIRTPTR#); 
              GENDNREF #DNATPTR# ;
              GENPERFORM; 
              PNATPTR =  RWGET1(SPACING  #CURRIRTPTR#); 
              GENPNREF #PNATPTR# ;
              GENSUBTRACT;
              PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
              GENILIT #PLTPNTR# ; 
              GENFROM;
              DNATPTR =  RWGET1(IRTLCINDEX  #CURRIRTPTR#);
              GENDNREF #DNATPTR# ;
              GOTO GCC3;
              END 
GCC3: 
          GENGO;
          GENTO;
          IF P001PNAT NQ  0 
          THEN
              BEGIN 
              PNATPTR = P001PNAT; 
              GENPNREF #PNATPTR# ;
              P001PNAT = 0; 
              GOTO GCC3PERIOD;
              END 
          IF P001PNAT  EQ 0 
          THEN
              BEGIN 
              GENNEWPNAT; 
              GENPNREF #PNATPTR# ;
              END 
GCC3PERIOD: 
          GENPERIOD;
  
          #ADD NEWLY GEN"D PARAGRAPH NAME AND ITS ASSOCIATED# 
          #CONTROL DATA  NAME TO UPDATE-P-NAME-TABLE# 
  
          GETNEXT(UPNLINK); 
          RWSET1(UPNPNAT  #CURRUPNPTR#,PNATPTR);
          $TEMP$ = RWGET1(CID$DNAT  #CURRCNTRLPTR#);
          RWSET1(UPNCONTROLID  #CURRUPNPTR#,$TEMP$);
          RWSET1(UPNDELIMITER  #CURRUPNPTR#,0); 
  
          #LOOP TO LOOK AT NEXT CONTROLSLINK ENTRY# 
  
          GOTO  GCC1; 
          #**********************************************#
GENFORNCB:  
          #GENERATE INDICATED GO TO FOR WHEN NO CONTROL#
          #BREAK OCCURS#
          #GO TO CONTROLS-EXIT.#
  
          IF GOTOEXITFLAG EQ 1
          THEN
              GOTO GENRUPDATE;
          GENGO;
          GENTO;
          IF CEXITPNAT    NQ  0 
          THEN
              BEGIN 
              PNATPTR = CEXITPNAT;
              GENPNREF #PNATPTR# ;
              GOTO NCBPERIOD; 
              END 
          IF CEXITPNAT   EQ 0 
          THEN
              BEGIN 
              IF CSETGIPNAT EQ 0
              THEN
                  BEGIN 
                  GENNEWPNAT; 
                  CSETGIPNAT = PNATPTR; 
                  END 
              GENNEWPNAT; 
              #CONTROLS-EXIT  PNAT# 
              GENPNREF #PNATPTR# ;
              SETFIELD(PN$PERFLAST,PNAT$,CCTPNATLEN,1); 
              CEXITPNAT = PNATPTR;
              PICEXIT = PNATPTR;
              END 
NCBPERIOD:  
          GENPERIOD;
GENRUPDATE: 
          #GEN. PARAGRAPHS FOR UPDATING CONTROL ITEMS#
          #AND PRINTING CONTROL HEADINGS# 
          #001.#
          #MOVE DATA-NAME-1 TO CONTROL-IDENT-1# 
          #PERFORM CONTROL-HEADING-1 THRU CH-1-EXIT.# 
          #002.#
          #MOVE DATA-NAME-2 TO CONTROL-IDENT-2# 
          #PERFORM CONTROL-HEADING-2 THRU CH-2-EXIT.# 
          #ETC.#
  
  
          #IS FIRST ENTRY A "FINAL"&# 
  
          CURRCNTRLPTR =  RWGET1(BASE$CNTROLS  #CURRIRTPTR#); 
          IF  RWGET1(CID$PREVALUE  #CURRCNTRLPTR#) NQ 0 
          THEN
              GOTO GUFU1; 
GU1:  
          CURRCNTRLPTR = RWGET1(CTROLSLINK1  #CURRCNTRLPTR#); 
          IF  RWGET1(EOCDELIMITER  #CURRCNTRLPTR#) EQ 1 
          THEN
              GOTO  GC1;
GUFU1:  
          CURRUPNPTR = CURRUNBASE;
GUPLOOP:  
          IF  RWGET1(UPNCONTROLID  #CURRUPNPTR#) EQ 
              RWGET1(CID$DNAT  #CURRCNTRLPTR#)
          THEN
              BEGIN 
              PNATPTR =  RWGET1(UPNPNAT  #CURRUPNPTR#); 
              GENPNDEF #PNATPTR# ;
              GENPERIOD;
              GOTO GU2; 
              END 
          IF  RWGET1(UPNDELIMITER  #CURRUPNPTR#)  EQ 1
          THEN
              GOTO GU2; 
          CURRUPNPTR  = RWGET1(UPNLINK  #CURRUPNPTR#);
          GOTO GUPLOOP; 
GU2:  
          GENMOVE;
          DNATPTR = RWGET1(CID$DNAT  #CURRCNTRLPTR#); 
          GENDNREF #DNATPTR# ;
          GENTO;
          DNATPTR = RWGET1(CID$PREVALUE  #CURRCNTRLPTR#); 
          GENDNREF #DNATPTR# ;
          IF  RWGET1(CH$BIT  #CURRCNTRLPTR#) EQ 1 
          THEN
              BEGIN 
              GENPERFORM; 
              PNATPTR = RWGET1(CH$PNAT  #CURRCNTRLPTR#);
              GENPNREF #PNATPTR# ;
              GENTHRU;
              PNATPTR = RWGET1(CH$EXIT$PNAT  #CURRCNTRLPTR#); 
              GENPNREF #PNATPTR# ;
              END 
          GENPERIOD;
          GOTO GU1; 
          #LOOP TO NEXT CONTROLSLINK ENTRY# 
          #******************************************************#
  
GC1:  
  
          #GENCONTSETGI#
  
  
          #GENERATE PARAGRAPH FOR SETTING GROUP-INDICATED FLAGS#
          #IF THERE ARE ANY#
          #CONTROLS-SET-GI.#
          #MOVE 1 TO  GROUP-INDICATED-FLAG-1# 
          #GROUP-INDICATED-FLAG-2.# 
          #ETC.#
  
          IF CSETGIPNAT EQ 0
          THEN
              BEGIN 
              GENNEWPNAT; 
              GENPNDEF #PNATPTR# ;
              GOTO CSGIPD;
              END 
          IF CSETGIPNAT  NQ  0
          THEN
              BEGIN 
              PNATPTR = CSETGIPNAT; 
              GENPNDEF #PNATPTR# ;
              END 
CSGIPD: 
          GENPERIOD;
  
          #GENSETGI#
  
          GENMFLAG = 0; 
          CURRGRINDPTR =  RWGET1(BASE$GRPIND  #CURRIRTPTR#);
GI1A: 
          IF  RWGET1(GIFLAG$DNAT  #CURRGRINDPTR#) NQ 0
          THEN
              BEGIN 
              IF GENMFLAG EQ 0
              THEN
                  BEGIN 
                  GENMOVE;
                  PLTPNTR =  RWGET1(IRTINTONE  #CURRIRTPTR#); 
                  GENLIT1 #PLTPNTR# ; 
                  GENTO;
                  GENMFLAG = 1; 
                  END 
              DNATPTR =  RWGET1(GIFLAG$DNAT  #CURRGRINDPTR#); 
              GENDNREF #DNATPTR# ;
              END 
          IF  RWGET1(GITEOT$DELIM  #CURRGRINDPTR#) NQ 1 
          THEN
              BEGIN 
              CURRGRINDPTR = RWGET1(GRINDLINK  #CURRGRINDPTR#); 
              GOTO GI1A;
              END 
          IF GENMFLAG EQ 1
          THEN
              GENPERIOD;
  
          #GENERATE EXIT PARAGRAPH# 
          #CONTROLS-EXIT.#
          #EXIT.# 
  
          IF CEXITPNAT EQ 0 
          THEN
              BEGIN 
              GENNEWPNAT; 
              GENPNDEF #PNATPTR# ;
              SETFIELD(PN$PERFLAST,PNAT$,CCTPNATLEN,1); 
              PICEXIT = PNATPTR;
              GOTO CEPERIOD;
              END 
          PNATPTR = CEXITPNAT;
          GENPNDEF #PNATPTR# ;
CEPERIOD: 
          GENPERIOD;
          GENEXIT;
          GENPERIOD;
  
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  # * #   EXTRACE("G$CNTRL")                                       # * #
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *#
  
          RETURN; 
          END #G$CNTRL# 
          END #INTERSC# 
          TERM
