*DECK,INITIAL 
USETEXT TAFIT 
USETEXT TCLFN 
USETEXT TCMMDEF 
USETEXT TDFLDEF 
USETEXT TENVIRN 
USETEXT TEXPRES 
USETEXT TOPTION 
USETEXT TREPORT 
      PROC INITIAL; 
      BEGIN 
      DEF NTTYCH#72#;        # NOS TTY CHARS / LINE # 
      DEF NTTYLIN#16#;       # NOS TTY LINES / PAGE # 
      DEF MAXIAF      #255#;       # MAX IAF VALUE-PAGE WIDTH,LENGTH   #
      DEF BATCHPW#136#;  #SYSTEM BATCH PAGE WIDTH#
      DEF BATMODE#0#;        # -TERMINAL- VALUE FOR BATCH MODE #
      DEF TTYMODE#1#;        # -TERMINAL- VALUE FOR TTY MODE #
      DEF CRTMODE#2#;        # -TERMINAL- VALUE FOR CRT MODE #
  
      XDEF ARRAY RWESTAT[0];       # PARAMETER FOR -RWE- CALL          #
        BEGIN 
        ITEM TERMINFO      U(00,12,12);  # 0 = BATCH                   #
                                         # NONZERO = INTERACTIVE       #
  
        ITEM TERMTYPE      U(00,20,04);  # TERMINAL TYPE               #
                                         # 0 = BATCH                   #
                                         # 1 = TTY                     #
                                         # OTHER NONZERO VALUES MEAN   #
                                         # OTHER TERMINAL TYPES WITH   #
                                         # DIFFERENT VALUES FOR        #
                                         # INTERCOM 4 AND INTERCOM 5   #
  
        ITEM LINELENGTH    U(00,24,12);  # LINE LENGTH OF INTERACTIVE  #
                                         # TERMINAL.                   #
  
        ITEM PAGESIZE      U(00,36,12);  # PAGESIZE = NO.LINES * LINELG#
  
        END 
  
      XREF ITEM JOBNAME C(10);     # JOBNAME BY WHICH THE JOB IS KNOWN #
                                   # IN THE SYSTEM DAYFILE.            #
      XREF ITEM MXTRNLG I;         # MAXIMUM TRANSMISSION LENGTH       #
      XREF ITEM DUMMY;
      XREF ITEM SLOPERF      B;    # SLOW *PERFORM* IF TRUE            #
      XREF ITEM RA0;               # ADDRESS OF ZERO FOR CRM CALLS.    # FEAT157
      XREF ITEM QUIWLGW;                                                 FEAT157
      XREF ITEM VERSTL I;          # TL ASSOCIATED WITH PRIMARY CATALOG#
      XREF ITEM MAXTL I;           # MAX TL THAT FITS IN QUIWSA BUFFER #
      XREF ITEM OPROCESSED B;  #-O- PARAMETER PROCESSED FLAG #
      XREF ITEM IPROCESSED B;  #-I- PARAMETER PROCESSED FLAG #
      XREF ITEM TPROCESSED B;  #-T- PARAMETER PROCESSED FLAG #
      XREF ITEM UPROCESSED B;      # *U* PARAMETER PROCESSED FLAG      #
      XREF ITEM AFPROCESSED B;     # *AF* PARAMETER PROCESSED FLAG     #
      XREF BASED ARRAY KEYWSA [0] S(1);;                                 FEAT157
      XREF BASED ARRAY QUIWSA [0:0] P(1);;                               FEAT157
      XREF BASED ARRAY WBUFFER;    # BUFFER FOR WRITING LINES W/BLANKS #
        BEGIN 
        ITEM WBUFFC C(0,0,10);     # IN FRONT TO LOOK NICE.            #
        END 
      XREF BASED ARRAY RBUFFER;;   # BUFFER FOR READ/WRITE             #
      XREF ARRAY INPUT;   # INPUT FILE -FET- IN MAIN OVERLAY #
        BEGIN 
        ITEM INLFN C(0,0,7);
        END 
      XREF ARRAY OUTPUT;  # OUTPUT FILE -FET- IN MAIN OVERLAY # 
        BEGIN 
        ITEM OUTLFN C(0,0,7); 
        END 
      XREF ARRAY TFILE;   # TRANSACTION FILE -FET- IN MAIN OVERLAY #
        BEGIN 
        ITEM TRANLFN C(0,0,7);
        END 
      ITEM RC I = 0;
      ITEM I            I;         # SCRATCH TEMPORARY                 #
  
      BASED ARRAY NEWFIT;          # USED TO ACCESS CATAFIT            #
        BEGIN 
        ITEM NF$WORD      I(00,00,60);
        END 
  
      XREF ARRAY ZZZZZQ2;          # MODEL CATALOG FIT IN (0,0)        #
        BEGIN 
        ITEM Q2$WORD      I(00,00,60);
        END 
  
      XREF PROC CALLRPV;
      XREF PROC DIE;               # ABORT...  BUT DONT LOAD (5,0)     # FEAT157
      XREF PROC GETJN;             # ROUTINE TO RETURN NAME OF THIS JOB#
      XREF PROC GETPAGE;        #COMPASS RTN TO GET PAGE SIZE PARAMS   #
      XREF PROC QUCLOCK;           # UPDATES CURRENT-TIME (MAYBE DATE) #
      XREF PROC WRITE;
      XREF PROC LOADX0; 
      XREF PROC WRTRDY;            # DOES THE INITIAL WRITE TO OUTPUT  #
                                   # FILES...WRITES -QU READY- MESSAGE #
      XREF PROC CALLCMM;     #INITALIZES OWNCODE ERROR PROCESSING      #
      XREF PROC LOADIDP;           # DEBUG PACKAGE LOADER              #
      XREF ARRAY COBCOL [63];      # COBOL COLLATING SEQUENCE          #
        BEGIN 
        ITEM ICOL C(0,54,1);
        END 
      XREF ITEM QU$RPT;            # NON-ZERO IF THIS IS *REPORT*      #
      CONTROL EJECT;
#                                      #
#        I N I T I A L                 #
#                                      #
# THIS PROC IS THE CONTROL MODULE OF THIS INITIALIZATION OVERLAY #
      BEGIN 
      RETURNFILES;                 # RETURN SCRATCH FILES              #
      CLEARCELLS;                                                        INITIAL
      GETPAGE;                  #SET JOB PAGE SIZE PARAMETERS          #
      IF QU$RPT NQ 0               # IF WE ARE IN *REPORT*             #
      THEN
        BEGIN 
        WRTRDY;                    #WRITE REPORT READY MESSAGE         #
        PRIMARY = O"71";           # LOAD (71,0) INSTEAD OF (1,0)      #
        IF RA0 NQ 0                # IF SENSE SWITCHES ARE NOT OFF     #
        THEN
          BEGIN 
          LOADIDP;                 # LOAD IDP FOR DEBUGGING            #
          END 
        RETURN;                    # RETURN TO CALL (71,0)             #
        END 
      GETTTYSTATUS;                                                      INITIAL
      CRACKQUCARD(RC);                                                   INITIAL
      IF RC NQ 0                                                         INITIAL
      THEN                                                               INITIAL
        BEGIN                                                            INITIAL
        DIE;                       #FATAL CC ERR MSG WAS ISSUED--ABORT # INITIAL
        END                                                              INITIAL
                                                                         INITIAL
      GETJN(JOBNAME);              # GET THE JOB NAME                  #
      QUCLOCK;                     # UPDATE TIME AND DATE              #
      WRTRDY;                      #WRITE THE -QU READY- MESSAGE.      # INITIAL
      SAVEFET;                     #SAVE LFNS AND FET ADDRS IN LOW CORE# INITIAL
IF DFLAG02[0] AND TERMINAL NQ BATMODE THEN
  BEGIN 
  LOADIDP;
  END 
      IF IPROCESSED OR OPROCESSED THEN TERMINAL = BATMODE;
      CALLCMM;               #PASS ADDRESS OF QU ERROR EXIT ROUTINE    #
      IF NOT DFLAG00[0]                                                  INITIAL
      THEN                                                               INITIAL
        BEGIN                                                            INITIAL
        CALLRPV;                                                         INITIAL
        END                                                              INITIAL
                                                                         INITIAL
CONTROL IFEQ OS$NAME,SCOPE; 
      XREF PROC SYSPROTECT;        # TEMPORARY KLUGE TO SET SYSTEM     #
      SYSPROTECT;                  # PROTECT BIT. CHECK COMMENTS IN    #
                                   # QU1100.                           #
      IF TERMINFO[0] EQ 0          # IF RUNNING IN BATCH MODE          #
      THEN
        BEGIN 
        BATCHMD = TRUE;            # SET FLAG                          #
        END 
CONTROL ENDIF;
      RETURN; 
      END 
      CONTROL EJECT;
      PROC CLEARCELLS;
#                                      #
#        C L E A R C E L L S           #
#                                      #
# THIS PROC CLEARS CELLS IN COMMON BLOCKS THAT CAN-T BE PRESET #
      BEGIN 
      FLAGA = FALSE;
      RPTLISTASN = FALSE; 
      COLEFFECT = LOC(COBCOL);     # INITIALIZE COLLATING SEQUENCE     #
      AREPORTLIST = LOC(FORMATDLINE); 
      SEPARATOR = SEP;             # INITIALIZE LITERAL DELIMITOR      #
      DESLIST = 0;
      DEFLIST = 0;
      SPELIST = 0;
      RECORDFLAG = FALSE; 
      TOATTPTR = 0; 
      TOATTRIADD[0] = 0;
      TOATTRLEFT[0] = 0;
      RPTCTR = 0; 
      LVL = 0;
      PSFLG = 0;
      B<0,60>TIME = 0;
      SSECONDAR = 5;               # CHOOSE (1,5) AS FIRST SYNTAX OVL  #
      PRIMARY = 1;
      SECONDARY = 0;
      PROMPDIR = NEXTDIR; 
      MAJORKEYLEN = 7;             # MAJOR KEY LENGTH FOR SYNIO        #
      OLDKEY = 0; 
      PERMI = TRUE;                # PERMITTED TO WRITE ON DEFAULT CAT #
      PFCATAL = FALSE;             # NO PF CATALOG YET                 #
      P<NEWFIT> = LOC(CATAFIT);    # POSITION FOR SETTING LFN          #
      FOR I = 0 STEP 1             # FOR EACH FIT WORD                 #
      UNTIL LFITM1                 # UNTIL HAVE DONE ALL THE FIT       #
      DO
        BEGIN 
        NF$WORD[I] = Q2$WORD[I];   # COPY MODEL FIT INTO CATAFIT       #
        END 
  
      RETURN; 
      END 
      CONTROL EJECT;
      PROC COUNTCHARS (P1, CHARCOUNT);
#                                      #
#        C O U N T C H A R S           #
#                                      #
# THIS PROC COUNTS THE NUMBER OF NON-BINARY-ZERO CHARACTERS IN -P1- AND#
# RETURNS THE RESULT IN -CHARCOUNT- # 
      BEGIN 
      ITEM P1 C(10);
      ITEM CHARCOUNT I; 
      ITEM I I; 
      CHARCOUNT = 0;
      FOR I=0 STEP 1                                                     INITIAL
        UNTIL 9                                                          INITIAL
      DO                                                                 INITIAL
        BEGIN 
        IF C<I,1>P1 EQ 0 THEN RETURN; 
        CHARCOUNT = CHARCOUNT + 1;
        END 
      END  # COUNTCHARS # 
      CONTROL EJECT;
      PROC CRACKQUCARD(RC); 
#                                      #
#        C R A C K Q U C A R D         #
#                                      #
# THIS PROC FETCHES PARAMETERS FROM THE -QU- CONTROL CARD AND TAKES # 
# APPROPIATE ACTION BASED ON THEIR VALUES # 
      BEGIN 
      ITEM RC I;
      ITEM I; 
      ITEM J;                      # SCRATCH ITEM.                     #
      ITEM INDEX I;               # LOOP COUNTER THRU PARAMETERS #
      XREF ARRAY RA0[0:64];       # ARRAY WHERE PARAMETERS ARE STORED # 
        BEGIN 
        ITEM PARM  C(0,0,7);      # PARAMETER FROM RA+INDEX AREA #
        ITEM CCODE U(0,54,6);     # CONTROL CODE FROM RA+INDEX #
        ITEM NUMPARMS U(0,42,18); # NUMBER OF PARAMETERS ,RA+64B) # 
        ITEM RA I(0,0,60);        # WHOLE WORD #
        END 
      XREF ITEM RO B;          # READ-ONLY PARAMETER FLAG # 
      DEF RA64#O"64"#;       # RA+64 FOR NUMBER OF CONTROL CARD PARMS # 
      DEF EOC#O"17"#;             # END OF CARD CODE #
      DEF EQSIGN#2#;              # EQUAL SIGN CODE # 
      DEF COMMA#1#;               # COMMA CODE #
      DEF CONT#0#;                # CONTINUATION CODE # 
      ARRAY CODETABLE [0:10];     # LIST OF LEGEL PARAMETERS #
        BEGIN 
        ITEM CODE   C(00,00,10) = [ "D",         # DEBUG SWITCHES      #
                                    "I",         # INPUT FILE          #
                                    "O",         # OUTPUT FILE         #
                                    "PL",        # PAGE LENGTH         #
                                    "PW",        # PAGE WIDTH          #
                                    "T",         # TRACE FILE          #
                                    "TL",        # TRANSMISSION LENGTH #
                                    "RO",        # READ-ONLY PROTECTION#
                                    "FAST",      # FAST PERFORM        #
                                    "U",         # INHIBIT ABORT ON    #
                                                 # FATAL DIAGNOSTIC    #
                                    "AF" ];      # ACCEPT FILE UNCLOSED#
                                                 # AFTER LAST UPDATE   #
        END 
      DEF NUMCODES # 11 #;         # MAXIMUM NUMBER OF PARAMETERS      #
      SWITCH JUMP 
        DPARM,    # 0 # 
        IPARM,    # 1 # 
        OPARM,    # 2 # 
        PLPARM,   # 3 # 
        PWPARM,   # 4 # 
        TPARM,    # 5 # 
        TLPARM,   # 6 # 
        ROPARM,   # 7 # 
        FASTPARM, # 8 # 
        UPARM,    # 9 # 
        AFPARM;   #10 # 
      ITEM PWTEMP     I;           # PAGE WIDTH TEMP STORAGE           #
      ITEM TRNLG I;                # TEMPORARY FOR TL CALCULATION      # FEAT157
      DEF MINTRNLG#20#;            # MINIMUM ACCEPTABLE TRANS LENGTH   #
      ITEM UNKNOWNPARM C(38) =" XXXXXXX IS AN UNKNOWN -QU- PARAMETER";
      ITEM BYTECOUNT I;      # FOR PROCESSING -D- PARAMETER # 
      ITEM LOOPING B; 
      ITEM CHARCOUNT I; 
      FOR INDEX = 1 WHILE CCODE[INDEX] NQ EOC AND NUMPARMS[RA64] NQ 0 DO
        BEGIN 
        INDEX = INDEX + 1;
        COUNTCHARS(PARM[INDEX], CHARCOUNT);                              INITIAL
        FOR I=0 STEP 1                                                   INITIAL
          UNTIL NUMCODES - 1                                             INITIAL
        DO                                                               INITIAL
          BEGIN                                                          INITIAL
          IF C<0,CHARCOUNT>PARM[INDEX] EQ C<0,CHARCOUNT>CODE[I] 
            THEN GOTO JUMP[I];
          END                                                            INITIAL
        RC = 1;              # UNRECOGNIZED CODE ON -QU- CARD # 
        C<1,7>UNKNOWNPARM = C<0,CHARCOUNT>PARM[INDEX];
        MSG(UNKNOWNPARM, 38);                                            INITIAL
        RETURN; 
DPARM:  # PROCESS THE -D- PARAMETER # 
        BYTECOUNT = 0;                                                   FEAT157
        IF CCODE[INDEX] NQ EQSIGN THEN
          BEGIN 
          RC = 1;           # THERE MUST BE AN EQUAL SIGN AFTER -D- # 
          MSG(" THE -D- OPTION MUST HAVE AN = AFTER IT", 39);            INITIAL
          RETURN; 
          END 
        INDEX = INDEX + 1;
        CHARCOUNT = 0;
        FOR I = 999 WHILE I NQ 0 DO 
          BEGIN 
          I = C<CHARCOUNT,1>PARM[INDEX];
          IF I EQ 0 THEN TEST;
          IF I LS "0" OR I GQ "8" THEN # MUST BE OCTAL DIGITS          # FEAT157
            BEGIN 
            RC = 1; 
            MSG(" -D- OPTION CAN HAVE ONLY OCTAL DIGITS", 38);           INITIAL
            RETURN; 
            END 
          DFLAGWORD[0] = (DFLAGWORD[0] * 8) + (I - "0"); # ACC DIGITS  # FEAT157
          CHARCOUNT = CHARCOUNT + 1;
          BYTECOUNT = BYTECOUNT + 1;
          IF BYTECOUNT GR 20 THEN   # DFLAG CAN HOLD ONLY 20 DIGITS # 
            BEGIN 
            RC = 1; 
            MSG(" -D- OPTION CAN HAVE ONLY 20 DIGITS",35);               INITIAL
            RETURN; 
            END 
          IF CHARCOUNT GQ 7 THEN   # GO TO NEXT PARM FOR MORE DIGITS #
            BEGIN 
            IF CCODE[INDEX] NQ CONT THEN RETURN;
            CHARCOUNT = 0;
            INDEX = INDEX + 1;
            END 
          END 
        TEST; 
IPARM:  # PROCESS -I- PARAMETER # 
        IPROCESSED = TRUE;
        IF CCODE[INDEX] EQ EQSIGN THEN  # MUST HAVE AN EQUAL SIGN # 
          BEGIN 
          INDEX = INDEX + 1;
          IF C<0,1>PARM[INDEX] LQ "Z" AND CCODE[INDEX] NQ CONT THEN 
            BEGIN 
            INLFN[0] = PARM[INDEX];     # MOVE INPUT FILE NAME #
            TEST; 
            END 
          ELSE
            BEGIN 
            RC = 1; 
            MSG("   THE -I- LFN MUST START WITH A LETTER AND BE LESS THA INITIAL
N 7 CHARACTERS", 70);                                                    INITIAL
            RETURN; 
            END 
          END 
        ELSE
          INLFN[0] = "COMPILE";     # DEFAULT IF NO I= SPECIFIED #
        TEST; 
OPARM:  # PROCESS -O- PARAMETER # 
        OPROCESSED = TRUE;
        IF CCODE[INDEX] EQ EQSIGN THEN
          BEGIN 
          INDEX = INDEX + 1;
          IF C<0,1>PARM[INDEX] LQ "Z" AND CCODE[INDEX] NQ CONT THEN 
            BEGIN 
            OUTLFN[0] = PARM[INDEX];
            TEST; 
            END 
          ELSE
            BEGIN 
            RC = 1; 
            MSG("   THE -O- LFN MUST START WITH A LETTER AND BE LESS THA INITIAL
N 7 CHARACTERS", 70);                                                    INITIAL
            RETURN; 
            END 
          END 
        ELSE
          OUTLFN[0] = "OUTPUT:";   # DEFAULT IF O= NOT SPECIFIED #
        TEST; 
  
  
  
#                -PL- PARAMETER - PAGE LENGTH                          #
#                DEFAULT IS SCREEN DEPENDENT OR 16 LINES               #
#                PL = 0  INDICATES -MORE- QUERY DISABLED               #
PLPARM: IF CCODE[INDEX] NQ EQSIGN  # IF NO EQUAL SIGN AFTER PARAMETER  #
        THEN
          BEGIN 
          RC = 1;                  # SET ERROR FLAG AND PRINT MESSAGE  #
          MSG(" THE -PL- OPTION MUST HAVE AN = AFTER IT", 40);
          RETURN; 
          END 
        INDEX = INDEX + 1;         # SET PNTR TO -PL- VALUE            #
        NBLINES = 0;               # SET LINES PER PAGE TO UNLIMITED   #
        CHARCOUNT = 0;             # SET PNTR TO FIRST DIGIT OF -PL-   #
  
        FOR DUMMY = DUMMY          # ACCUMULATE DIGITS FOR THE NUMBER  #
          WHILE I NQ 0             # OF LINES PER PAGE                 #
        DO
          BEGIN 
          I = C<CHARCOUNT,1>PARM[INDEX];
          IF I EQ 0                # IF DIGIT EQ BINARY ZERO           #
          THEN
            BEGIN 
            TEST;                  # TERMINATE DIGIT ACCUMULATION      #
            END 
          IF I LS "0"              # IF CHARACTER IS NOT A DIGIT       #
            OR I GR "9" 
          THEN
            BEGIN 
            RC = 1;                # SET ERROR FLAG AND PRINT MESSAGE  #
            MSG(" -PL- OPTION CAN BE SET TO DIGITS ONLY", 38);
            RETURN; 
            END 
          NBLINES = (NBLINES * 10) + (I - "0");  # ACCUMULATE DIGITS   #
          IF NBLINES GR MAXIAF     # IF NBLINES GR IAF MAX NUMBER      #
          THEN
            BEGIN 
            RC = 1;                # SET ERROR FLAG PRINT MESSAGE      #
            MSG(" THE -PL- OPTION HAS A MAXIMUM OF 255", 37); 
            RETURN; 
            END 
          CHARCOUNT = CHARCOUNT + 1;  # INCREMENT DIGIT POINTER        #
          END 
  
        TEST;                      # RETURN FOR NEXT PARM, IF ANY      #
  
  
  
#                -PW- PARAMETER - PAGE WIDTH                           #
#          DEFAULT IS SCREEN DEPENDENT OR 72 CHAR/LINE                 #
PWPARM: IF CCODE[INDEX] NQ EQSIGN  # IF NO EQUAL SIGN AFTER PARAMETER  #
          THEN
            BEGIN 
            RC = 1;                # SET ERROR FLAG PRINT MESSAGE      #
            MSG(" THE -PW- OPTION MUST HAVE AN = AFTER IT", 40);
            RETURN; 
            END 
        INDEX = INDEX + 1;         # SET PNTR TO -PW- VALUE            #
        PWTEMP = 0;                # SET TEMP PAGE WIDTH TO ZERO       #
        CHARCOUNT = 0;             # SET PNTR TO FIRST DIGIT OF -PW-   #
  
        FOR DUMMY = DUMMY          # ACCUMULATE DIGITS FOR THE NUMBER  #
          WHILE I NQ 0             # OF CHAR PER LINES                 #
        DO
          BEGIN 
          I = C<CHARCOUNT,1>PARM[INDEX];
          IF I EQ 0                # IF DIGIT EQ BINARY ZERO           #
          THEN
            BEGIN 
            TEST;                  # TERMINATE DIGIT ACCUMULATION      #
            END 
          IF I LS "0"              # IF DIGIT IS NOT A DIGIT           #
            OR I GR "9" 
          THEN
            BEGIN 
            RC = 1;                # SET ERROR FLAG AND PRINT MESSAGE  #
            MSG(" -PW- OPTION CAN BE SET TO DIGITS ONLY", 38);
            RETURN; 
            END 
          PWTEMP = (PWTEMP * 10) + (I - "0");  # ACCUMULATE DIGITS     #
          IF PWTEMP GR MAXIAF      # IF PAGE WIDTH GR THAN IAF MAXIMUM #
          THEN
            BEGIN 
            RC = 1; 
            MSG(" THE -PW- OPTION HAS A MAXIMUM OF 255", 37); 
            RETURN; 
            END 
CONTROL IFEQ OS$NAME,SCOPE; 
          IF PWTEMP GR BATCHPW     # IF PAGE WIDTH SETTING LARGER THAN #
          THEN                     # SYSTEM SETTING                    #
            BEGIN 
            RC = 1;                # SET ERROR FLAG AND PRINT MESSAGE  #
            MSG(" -PW- LARGER THAN SYSTEM -PW-", 29); 
            RETURN; 
            END 
CONTROL ENDIF;
          CHARCOUNT = CHARCOUNT + 1;  # INCREMENT DIGIT POINTER        #
          END 
  
        IF PWTEMP EQ 0             # IF PAGE WIDTH SETTING IS ZERO     #
        THEN
          BEGIN 
          RC = 1;                  # SET ERROR FLAG AND PRINT MESSAGE  #
          MSG (" A -PW- VALUE OF ZERO IS NOT ALLOWED", 36); 
          RETURN; 
          END 
  
        CHPLINE = PWTEMP;          # SET PAGE WIDTH TO REQUESTED VALUE #
        TEST;                      # RETURN FOR NEXT PARM, IF ANY      #
  
  
  
TPARM:  # PROCESS -T- PARAMETER # 
        TPROCESSED = TRUE;
        IF CCODE[INDEX] EQ EQSIGN THEN
          BEGIN 
          INDEX = INDEX + 1;
          IF C<0,1>PARM[INDEX] LQ "Z" AND CCODE[INDEX] NQ CONT THEN 
            BEGIN 
            TRANLFN[0] = PARM[INDEX]; 
            TEST; 
            END 
          ELSE
            BEGIN 
            RC = 1; 
            MSG("   THE -T- LFN MUST START WITH A LETTER AND BE LESS THA INITIAL
N 7 CHARACTERS", 70);                                                    INITIAL
            RETURN; 
            END 
          END 
        ELSE
          BEGIN 
          RC = 1; 
          MSG(" THE -T- OPTION MUST HAVE AN LFN (T=LFN)", 39);           INITIAL
          RETURN; 
          END 
        TEST;                                                            FEAT157
                                                                         FEAT157
TLPARM: # PROCESS -TL- PARAMETER #                                       FEAT157
        IF CCODE[INDEX] NQ EQSIGN THEN                                   FEAT157
          BEGIN                                                          FEAT157
          RC = 1;   # THERE MUST BE AN EQUAL SIGN AFTER -TL- #           FEAT157
          MSG(" THE -TL- OPTION MUST HAVE AN = AFTER IT", 40);           INITIAL
          RETURN;                                                        FEAT157
          END                                                            FEAT157
        INDEX = INDEX + 1;                                               FEAT157
        TRNLG = 0;                                                       FEAT157
        CHARCOUNT = 0;                                                   FEAT157
        BYTECOUNT = 0;                                                   FEAT157
        FOR I = 999 WHILE I NQ 0 DO                                      FEAT157
          BEGIN                                                          FEAT157
          I = C<CHARCOUNT,1>PARM[INDEX];                                 FEAT157
          IF I EQ 0 THEN TEST;                                           FEAT157
          IF I LS "0" OR I GR "9" THEN  # MUST BE DIGITS #               FEAT157
            BEGIN                                                        FEAT157
            RC = 1;                                                      FEAT157
            MSG(" -TL- OPTION CAN HAVE DIGITS ONLY", 33);                INITIAL
            RETURN;                                                      FEAT157
            END                                                          FEAT157
          TRNLG = (TRNLG * 10) + (I - "0");    # ACCUMULATE DIGITS     # FEAT157
          CHARCOUNT = CHARCOUNT + 1;                                     FEAT157
          BYTECOUNT = BYTECOUNT + 1;                                     FEAT157
          IF BYTECOUNT GR 6 THEN   # -TL- MAX SIZE IS 6 DIGITS #         FEAT157
            BEGIN                                                        FEAT157
            RC = 1;                                                      FEAT157
            MSG(" -TL- OPTION CAN HAVE ONLY 6 DIGITS", 35);              INITIAL
            RETURN;                                                      FEAT157
            END                                                          FEAT157
          END                                                            FEAT157
        IF TRNLG LS MINTRNLG THEN  # IF BELOW MINIMUM                  #
          BEGIN 
          MXTRNLG = MINTRNLG;      # ACCEPT THE MINIMUM VALUE INSTEAD  #
          MSG(" -TL- OPTION TOO SMALL, MINIMUM USED", 36);               INITIAL
          END 
        ELSE
          BEGIN 
          MXTRNLG = TRNLG;         # ACCEPT NEW -TL- VALUE             #
          END 
        TEST;                                                            FEAT157
  
  
ROPARM: #PROCESS -RO- PARAMETER # 
          #  THE PRESENCE OF THE -RO- PARAMETER IS ACTUALLY ALREADY    #
          #  TESTED BY -INIOVL-, WHO TOOK THE APPROPRIATE ACTIONS      #
          #  I. E. LOAD THE MAIN OVERLAY -QO- OVER THE MAIN OVERLAY    #
          #  -QU- IF -RO- IS PRESENT.                                  #
          #  THUS, THE ABOVE LABEL, -ROPARM-, IS A NO-OPERATION,       #
          #  IMPLEMENTED TO ACCEPT THE PARAMETER -RO- AS A LEGAL ONE.  #
        TEST; 
  
  
FASTPARM:   # PROCESS -FAST- PARAMETER #
      SLOPERF = FALSE;             # SWITCH TO FAST PERFORM            #
      TEST; 
  
  
UPARM:                             # PROCESS -U- PARAMETER             #
      UPROCESSED = TRUE;           # DONT ABORT ON FATAL DIAGS         #
      TEST; 
  
  
AFPARM:                            # PROCESS -AF- PARAMETER            #
      AFPROCESSED = TRUE;          # IF FILE HAS NOT BEEN CLOSED SINCE #
                                   # LAST UPDATE, ACCEPT IT ANYWAY     #
      TEST; 
  
        END 
CONTROL IFEQ OS$NAME,SCOPE; 
      XREF PROC CONZIN; 
      XREF PROC CONZOU; 
      IF TERMINAL NQ BATMODE THEN   # CONNECT I/O FILE(S) # 
        BEGIN 
        IF NOT IPROCESSED THEN
          BEGIN 
          CONZIN;                  #CONNECT -ZZZZZIN-                  # INITIAL
          INLFN[0] = "ZZZZZIN"; 
          END 
        IF NOT OPROCESSED THEN
          BEGIN 
          CONZOU;                                                        INITIAL
          OUTLFN[0] = "ZZZZZOU";
          END 
        END 
CONTROL ENDIF;
                                                                         FEAT157
CONTROL IFEQ OS$NAME,NOS;                                                FEAT157
      XREF PROC REQUEST;           # REQUEST ASSIGNMENT OF FILE        # FEAT157
      IF TERMINAL NQ BATMODE THEN  # IF RUNNING IN INTERACTIVE MODE    # FEAT157
        BEGIN                                                            FEAT157
        IF NOT IPROCESSED THEN     # IF NO -I- PARAMETER SPECIFIED     # FEAT157
          BEGIN                                                          FEAT157
          INLFN[0] = "ZZZZZIN";                                          FEAT157
          P<AFIT> = LOC(INPUT);                                          INITIAL
          C<0,2>AFITDVT = "TT";                                          INITIAL
          REQUEST(INPUT);                                                FEAT157
          END                                                            FEAT157
        IF NOT OPROCESSED THEN     # IF NO -O- PARAMETER SPECIFIED     # FEAT157
          BEGIN                                                          FEAT157
          OUTLFN[0] = "ZZZZZOU";                                         FEAT157
          P<AFIT> = LOC(OUTPUT);                                         INITIAL
          C<0,2>AFITDVT = "TT";                                          INITIAL
          REQUEST(OUTPUT);                                               FEAT157
          END                                                            FEAT157
        END                                                              FEAT157
CONTROL ENDIF;                                                           FEAT157
                                                                         FEAT157
      VERSTL = MXTRNLG;            # TL ASSOCIATED WITH THIS CATALOG   #
      QUIWLGW = (MXTRNLG + 9) / 10;  # NO. OF WHOLE WORDS FOR MXTRNLG  # FEAT157
      J = QUIWLGW + 4;             # NUMBER OF WORDS FOR THE TRANSMIS- # FEAT157
                                   # SION RELATED BUFFERS (PLUS A FEW) # FEAT157
      IF J LS 65 THEN J = 65;      # MIN SIZE FOR INPUT BUFFER IS 65   # FEAT157
      MAXTL = 10 * (J - 4);        # MAX TL THAT FITS IN BUFFER        #
      I = CMM$ALF(J,0,0);          # GET TRANSMISSION BUFFER SPACE     #
      IF I LQ 0 THEN               # IF BAD RETURN ADDRESS FROM GETSPC #
        BEGIN 
        NOSPACE;                   #NO SPACE AVAILABLE -- ABORT        # INITIAL
        END 
  
      P<KEYWSA> = I;               # KEYS ARE AT -I-                   # FEAT157
      P<QUIWSA> = I + 1;           # TRANSMISSION BUFFER AT -I+1-      # FEAT157
      I = CMM$ALF(J,0,0);          # GET -J- WORDS AND PUT FWA IN -I-  #
      IF I LQ 0 THEN               # IF BAD RETURN ADDRESS FROM GETSPC #
        BEGIN 
        NOSPACE;                   #NO SPACE AVAILABLE -- ABORT        # INITIAL
        END 
  
      P<AFIT> = LOC(INPUT);                                              INITIAL
      AFITFWB = I;                                                       INITIAL
      AFITIN = I;                                                        INITIAL
      AFITOUT = I;                                                       INITIAL
      AFITLAST = I + J;                                                  INITIAL
      I = CMM$ALF(J,0,0);          # GET -J- WORDS AND PUT FWA IN -I-  #
      IF I LQ 0 THEN               # IF BAD RETURN ADDRESS FROM GETSPC #
        BEGIN 
        NOSPACE;                   #NO SPACE AVAILABLE -- ABORT        # INITIAL
        END 
  
      P<WBUFFER> = I;              # -WBUFFER- GETS IT                 #
      P<RBUFFER> = I + 1;          # -RBUFFER- BEGINS ONE WORD BEYOND  #
      WBUFFC[0] = " ";             # BLANK FILL FIRST WD OF -WBUFFER-  #
      IF TPROCESSED THEN           # ALLOCATE BUFFER FOR IT            #
        BEGIN 
        I = CMM$ALF(65,0,0);       # GET 65 WORDS AND PUT FWA IN -I-   #
      IF I LQ 0 THEN               # IF BAD RETURN ADDRESS FROM GETSPC #
        BEGIN 
        NOSPACE;                   #NO SPACE AVAILABLE -- ABORT        # INITIAL
        END 
  
      P<AFIT> = LOC(TFILE);                                              INITIAL
      AFITFWB = I;                                                       INITIAL
      AFITIN = I;                                                        INITIAL
      AFITOUT = I;                                                       INITIAL
      AFITLAST = I + 65;                                                 INITIAL
        END 
      IF TERMINAL EQ BATMODE THEN 
        BEGIN      # I/O PROCESSED MEANS IT IS A LOCAL FILE # 
        IPROCESSED = TRUE;
        OPROCESSED = TRUE;
        END 
      END  # CRACKQUCARD #
      CONTROL EJECT;
CONTROL IFEQ OS$NAME,NOS; 
      PROC GETTTYSTATUS;
#                                      #
#        G E T T T Y S T A T U S       #
#                                      #
# THIS PROC DETERMINES (WITH THE HELP OF A COMPASS PROC) THE ORIGIN OF #
# THIS -QU- RUN. VALUES ARE THEN FILLED IN FOR TERMINAL PAGE SIZE, #
# LINE LENGTH ETC. #
      BEGIN 
      XREF PROC TTYSTAT;
  
  
  
      TTYSTAT;                     # GET TTY STATUS                    #
      IF TERMINAL NQ 0 THEN        # IF NOT RUNNING BATCH              #
        BEGIN 
        CHPLINE = NTTYCH;          # SET LINE LENGTH                   #
        NBLINES = NTTYLIN;         # SET PAGE SIZE                     #
        END 
      END  # GETTTYSTATUS # 
CONTROL ENDIF;
      CONTROL EJECT;
CONTROL IFEQ OS$NAME,SCOPE; 
      PROC GETTTYSTATUS;
#                                      #
#        G E T T T Y S T A T U S       #
#                                      #
# THIS PROC DETERMINES (WITH THE HELP OF A COMPASS PROC) THE ORIGIN OF #
# THIS -QU- RUN. VALUES ARE THEN FILLED IN FOR TERMINAL PAGE SIZE, #
# LINE LENGTH ETC. #
      BEGIN 
      XREF PROC TTYSTAT;
  
      TTYSTAT;                                                           INITIAL
      TERMINAL = 0;                # ASSUME RUNNING BATCH              #
      IF TERMINFO[0] NQ 0          # IF RUNNING AT SOME INTERCOM TERM. #
      THEN
        BEGIN 
        TERMINAL = 1;              # RUNNING AT INTERCOM TERMINAL      #
        CHPLINE = LINELENGTH[0]; #  AND LINE LENGTH # 
        IF TERMTYPE[0] NQ 1 THEN   # IF INTERACTIVE TERM BUT NOT TTY   #
          BEGIN 
          TERMINAL = CRTMODE; 
          NBLINES = PAGESIZE[0] / CHPLINE;  # FIND LENGTH OF CRT LINE  #
          NBLINES = NBLINES - 1;   # ONE FEWER SINCE INPUT COMES FROM  #
                                   # THE NEXT LINE, NOT THE LAST WRITTN#
          END 
  
        ELSE
          BEGIN 
          NBLINES = NTTYLIN;
          END 
  
        END 
      END  # GETTTYSTATUS # 
CONTROL ENDIF;
      CONTROL EJECT;
      PROC MSG (P1, NUMCHARS);
#                                      #
#        M S G                         #
#                                      #
# THIS PROC ADDS A ZERO BYTE TO THE END OF -P1- AND CALLS # 
# -MESSAGE- TO PUT THE TEXT IN THE DAYFILE #
# CALLERS OF -MSG- SHOULD REALIZE THAT A MAXIMUM OF 40 CHARACTERS # 
# ARE WRITTEN TO ANY LINE. THUS A MESSAGE SHOULD HAVE THE FORTIETH #
# CHARACTER OCCUR BETWEEN WORDS SUCH THAT A WORD IS NOT SPLIT # 
# BETWEEN TWO LINES. THIS WIL MAKE MESSAGES VERY READABLE # 
      BEGIN 
      XREF PROC MESSAGE;
      ARRAY P1; 
        BEGIN 
        ITEM CHAR C(0,0,10);
        END 
  
      ITEM CHARPOS; 
      ITEM WORDPOS; 
      ITEM NUMCHARS;
  
  
  
      WORDPOS = NUMCHARS / 10;
      CHARPOS = NUMCHARS - WORDPOS * 10;
      IF CHARPOS EQ 9 THEN
        BEGIN 
        CHARPOS = 0;
        WORDPOS = WORDPOS + 1;
        END 
  
      FOR CHARPOS=CHARPOS STEP 1                                         INITIAL
        UNTIL 9                                                          INITIAL
      DO                                                                 INITIAL
        BEGIN                                                            INITIAL
        C<CHARPOS,1>CHAR[WORDPOS] = 0;                                   INITIAL
        END                                                              INITIAL
                                                                         INITIAL
      MESSAGE(P1);                                                       INITIAL
      END   # MSG # 
CONTROL EJECT;
      PROC NOSPACE; 
#                                  #
#         N O S P A C E            #
#                                  #
# THIS PROC DIAGNOSES THE CONDITION OF GETSPC NOT RETURNING A PROPER   #
# ADDRESS FROM THE REQUEST FOR BUFFER SPACE. A DAYFILE MSG IS ISSUED   #
# AND QU IS ABORTED.                                                   #
      BEGIN 
      MSG("CANT GET NEEDED CM FOR BUFFERS.", 32);                        INITIAL
      DIE;                         #ABORT...                           # INITIAL
      END 
  
  
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     R E T U R N F I L E S                                            #
#                                                                      #
# RETURNS SCRATCH FILES THAT MAY BE USED LATER BY QU                   #
  
      PROC RETURNFILES; 
      BEGIN 
      XREF ITEM   RA0;
      DEF  $ZZZZZIN$  #O"32323232321116000000"#;
      DEF  $ZZZZZOU$  #O"32323232321725000000"#;
      DEF  $ZZZZZQA$  #O"32323232322101000000"#;
      DEF  $ZZZZZQB$  #O"32323232322102000000"#;
      DEF  $ZZZZZQC$  #O"32323232322103000000"#;
      DEF  $ZZZZZQD$  #O"32323232322104000000"#;
      DEF  $ZZZZZQE$  #O"32323232322105000000"#;
      DEF  $ZZZZZQF$  #O"32323232322106000000"#;
      DEF  $ZZZZZQG$  #O"32323232322107000000"#;
      DEF  $ZZZZZQH$  #O"32323232322110000000"#;
      DEF  $ZZZZZQI$  #O"32323232322111000000"#;
      DEF  $ZZZZZQ2$  #O"32323232322135000000"#;
      DEF  $ZZZZZQ3$  #O"32323232322136000000"#;
      DEF  $ZZZZZQ4$  #O"32323232322137000000"#;
      DEF  $ZZZZZQ5$  #O"32323232322140000000"#;
      DEF  $ZZZZZQ6$  #O"32323232322141000000"#;
      DEF  $ZZZZZQ7$  #O"32323232322142000000"#;
      DEF  $ZZZZZQ8$  #O"32323232322143000000"#;
  
      XREF PROC   RETURNM;
  
  
  
      RETURNM($ZZZZZQ2$, RA0);     # RETURN ANY PREVIOUS DEFLT CATALOG #
      RETURNM($ZZZZZIN$, $ZZZZZOU$, RA0);  # QU INTERACTIVE INPUT/OUTPT#
      RETURNM($ZZZZZQ3$, $ZZZZZQ4$, $ZZZZZQ5$, RA0);
      RETURNM($ZZZZZQ6$, $ZZZZZQ7$, $ZZZZZQ8$, RA0);
      RETURNM($ZZZZZQA$, $ZZZZZQB$, $ZZZZZQC$, RA0);
      RETURNM($ZZZZZQD$, $ZZZZZQE$, $ZZZZZQF$, $ZZZZZQG$, RA0); 
      RETURNM($ZZZZZQH$, $ZZZZZQI$, RA0);  # LFN USED FOR SUBSCHEMA    #
  
      RETURN; 
      END 
  
      CONTROL EJECT;
      PROC SAVEFET; 
#                            #
#      S A V E F E T         #
#                            #
#  THIS PROC SAVES LFNS AND FET ADDRESSES OF OUTPUT FILES IN LOW CORE  #
#  SO -NOS- CAN FIND THEM AND FLUSH THEM. ALSO INPUT SO WE CAN FIND    #
#  IT EASILY.                                                          #
#  RA+2 (OUTPUT)  RA+3 (TFILE OR 0)  RA+4 (0)  RA+5 (INPUT)  RA+6 (0)  #
# THE LFNS ARE ADDED TO CRM"S LIST OF FILES (POINTED TO BY LOF$RM). THE#
# FETS FOR OUTPUT AND TRACE ARE GIVEN BIT 36 SET IN WORD 1 OF THE FET  #
# SUCH THAT THE OPERATING SYSTEM WILL FLUSH THESE ON ABNORMAL TERM-    #
# INATION. THE OUTPUT FET IS INSERTED AS THE FIRST IN THE LIST SO IT   #
# WILL RECEIVE AUTOMATIC INTERACTIVE FLUSHING ON NOS.                  #
  
      BEGIN 
      ITEM I;                      # SCRATCH ITEM                      #
      XREF ITEM TPROCESSED B;      #-T- PARAMETER PROCESSED FLAG       #
      XREF BASED ARRAY LOF$RM;     # CRM"S LIST OF FILES               #
        BEGIN 
        ITEM LOF$CMM      B(00,00,01);  # TRUE IF FWA OF LIST IS THE   #
                                        # FWA OF A CMM BLOCK CONTAINING#
                                        # ONLY THE LIST OF FILES. THIS #
                                        # ITEM IS ONLY DEFINED FOR THE #
                                        # [0] WORD OF THE ARRAY. IT IS #
                                        # PART OF THE TABLE HEADER.    #
  
        ITEM LOF$LG       I(00,42,18);  # NUMBER OF LFNS THAT THIS LIST#
                                        # CAN HOLD. THIS ITEM IS ONLY  #
                                        # DEFINED FOR THE [0] WORD OF  #
                                        # THIS ARRAY. IT IS PART OF THE#
                                        # TABLE HEADER WORD.           #
  
        ITEM LOF$LFN      C(00,00,07);  # LFN OF THIS FILE. THIS ITEM  #
                                        # IS DEFINED ONLY FOR THE [1]  #
                                        # THROUGH [LOF$LG] WORDS OF THE#
                                        # ARRAY.                       #
  
        ITEM LOF$FET      I(00,42,18);  # FET ADDRESS OF THIS FILE.    #
                                        # THIS ITEM IS DEFINED ONLY FOR#
                                        # THE [1] THROUGH [LOF$LG]     #
                                        # WORDS OF THE ARRAY.          #
  
        ITEM LOF$WORD     I(00,00,60);  # WHOLE WORD DEFINEITION. IT IS#
                                        # INTENDED FOR FULL-WORD ACCESS#
                                        # OF WORDS [1] THROUGH [LOF$LG]#
        END 
  
      BASED ARRAY FET;
        BEGIN 
        ITEM FET$FLUSH    B(01,23,01);  # BIT 36, WORD 1 OF AN FET. IF #
                                       # TRUE, AND FILE IS POINTED TO  #
                                       # THE LIST OF FILES, IT IS CAN- #
                                       # DIDATE FOR O/S FLUSHING UPON  #
                                       # ABNORMAL TERMINATION.         #
        END 
  
      ITEM LOFENTRY     I;         # SCRATCH ITEM TO TEMPORARILY HOLD  #
                                   # AN LOF$WORD ENTRY.                #
      ITEM LOFLIMIT     I;         # SCRATCH ITEM FOR HOLDING THE VALUE#
                                   # OF LOF$LG. USED TO AVOID REPEATED #
                                   # ARRAY REFS AS THE LIMIT OF A LOOP.#
  
      XREF PROC SETLOF;            # PASSES ADDRESS OF LIST OF FILES   #
                                   # TO THE OPERATING SYSTEM.          #
      XREF ARRAY RA0; 
        BEGIN 
        ITEM LFN C(0,0,7);
        ITEM FETADDR      I(00,42,18);  # ADDR OF FET FOR *LFN*        #
        ITEM RA0WORD I(0,0,60); 
        END 
  
  
  
      FOR I = 2 STEP 1 UNTIL 6 DO 
        BEGIN 
        RA0WORD[I] = 0;            # ZERO FILL ALL THE WORDS WE WANT   #
        END 
  
      LFN[2] = OUTLFN[0]; 
      FETADDR[2] = LOC(OUTPUT); 
      LFN[5] = INLFN[0];
      FETADDR[5] = LOC(INPUT);
      IF TPROCESSED THEN
        BEGIN 
        LFN[3] = TRANLFN[0];
        FETADDR[3] = LOC(TFILE);
        END 
  
      IF LOF$WORD[1] EQ 0          # IF AT END-OF-LIST                 #
      THEN
        BEGIN 
        LOF$WORD[2] = 0;           # MARK NEW END-OF-LIST              #
        END 
  
      LOFENTRY = LOF$WORD[1];      # SAVE FIRST ENTRY IN LOF           #
      LOF$FET[1] = LOC(OUTPUT);    # QU"S OUTPUT FILE AS FIRST ENTRY   #
      LOF$LFN[1] = OUTLFN;
      P<FET> = LOC(OUTPUT);        # POSITION TO ACCESS THE FET        #
      FET$FLUSH = TRUE;            # SET THE O/S FLUSHING BIT          #
      LOFLIMIT = LOF$LG[0];        # NUMBER OF POSSIBLE LFNS IN LIST   #
      FOR I = 2 STEP 1             # FOR EACH LIST ENTRY EXCEPT 1      #
        UNTIL LOFLIMIT - 1         # CHECKING ALL ENTRIES EXCEPT LAST  #
                                   # (LEAVE ROOM FOR NEW END-OF-LIST)  #
      DO
        BEGIN 
        IF LOF$WORD[I] EQ 0        # IF END OF LIST                    #
          OR B<0,12>LOF$WORD[I] EQ O"7777"  # OR CLEARED OUT ENTRY     #
        THEN
          BEGIN 
          IF LOFENTRY NQ 0         # IF DISPLACED ACTIVE FIRST ENTRY   #
          THEN
            BEGIN 
            IF LOF$WORD[I] EQ 0    # IF AT END-OF-LIST                 #
            THEN
              BEGIN 
              LOF$WORD[I + 1] = 0; # MARK NEW END-OF-LIST              #
              END 
  
            LOF$WORD[I] = LOFENTRY;  # RESTORE IN FIRST AVAILABLE SLOT #
            LOFENTRY = 0;          # CLEAR SAVED ENTRY                 #
            TEST I;                # CHECK FOR NEXT AVAILABLE ENTRY    #
            END 
  
          IF TPROCESSED            # IF *T* CONTROL CARD OPTION USED   #
          THEN
            BEGIN 
            IF LOF$WORD[I] EQ 0    # IF AT END-OF-LIST                 #
            THEN
              BEGIN 
              LOF$WORD[I + 1] = 0; # MARK NEW END-OF-LIST              #
              END 
  
            LOF$FET[I] = LOC(TFILE);  # ENTER FET ADDRESS IN LOF       #
            LOF$LFN[I] = TRANLFN;     # ENTER LFN IN LOF               #
            P<FET> = LOC(TFILE);
            FET$FLUSH = TRUE;      # SET O/S FLUSHING BIT              #
            END 
  
          I = LOFLIMIT;            # SET TO FORCE EXIT FROM LOOP       #
          TEST I; 
          END 
        END 
  
      SETLOF(LOF$RM);              # TELL O/S THE LOC OF LIST OF FILES #
      RETURN; 
      END #SAVEFET# 
      END # INITIAL # 
      TERM
