*DECK S$SETWH 
          PROC S$SETWH(OWNF$,OWNNA$,SPEC$,STATUS$,LONGSUM); 
#**       S$SETWH -  COLLECT RAW PARAM. OF  OWNF$,OWNNA$,SPEC$,STATUS$ #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         S$SETWH(OWNF$,OWNNA$,SPEC$,STATUS$):                         #
#                                                                      #
#                                                                      #
#                                                                      #
#     SETS-                                                            #
#         OWNF$ = NAME OF FILE CONTAINING USER OWNCODE ROUTINES        #
#         OWNNA$ = NAME OF THE USER-SUPPLIED ENTRY POINT FOR EACH OWNN #
#         SPEC$ = COMPLETE SPECIFICATION OF THE SORT.                  #
#         STATUS$ = INDICATES WHETHER AND WHAT ERROR HAS BEEN FOUND    #
#                                                                      #
#     METHOD                                                           #
#         GETS SPEC-PARTS FROM SET-PART (SAVING THEM IN CURRENT-SPEC)  #
#         CHECKS FOR REDUNDANCIES, SUPPLIES DEFAULTS, AND CREATES      #
#         OWN-NAMES, OWN-FILE AND SPEC$                                #
#         ERROR INFORMATION IS RETURNED IN STATUS$                     #
  
  
          BEGIN 
  
          XDEF
              BEGIN 
              ITEM  S$FLAGS  I;        # FLAGS TO CHECK WHEN RESTART   #
              LABEL S$RQUIT;           # WHERE TO GO TO QUIT           #
              LABEL S$RSTAR;           # WHERE TO RESTART INTERACTIVE  #
              END 
  
          XREF
              BEGIN 
              PROC  S$ABORT;
              PROC  S$ERROR;
              PROC  S$OWNLD;           # LOAD OWNCODES FROM A FILE     #
              PROC  S$SETPT;           # GET AN RP$                    #
              PROC  S$GETSUM; 
              ITEM  S$SMFLG  I;        # FLAG SORT OR MERGE            #
              END 
  
  
*CALL A 
  
*CALL KT$ 
  
  
          XREF
*CALL S$CALLR 
  
*CALL OWNF$ 
  
  
*CALL MACHINE 
*CALL OWNNA$
  
*CALL RP$ 
  
*CALL SPEC$ 
  
*CALL STATUS$ 
  
*CALL E$
*CALL STRING$ 
          FUNC  OCT(VALUE) C(20); 
              ITEM  VALUE        U;    # VALUE TO BE CONVERTED         #
              ITEM  C20          C(20); 
              ITEM  I            I; 
              BEGIN 
              FOR I = 0 STEP 1 UNTIL 19 DO
                  C<I,1>C20 = B<3*I,3>VALUE + O"33";
              OCT = C20;
              END  # OCT #
          XREF
              PROC S$PRTCD; 
          ITEM  LINE         C(60); 
          ITEM  LONGSUM      B; 
          ITEM  C20          C(20); 
  
          ITEM  GOODLOAD     B=TRUE;   # TRUE IF LOADING O K           #
          ITEM  SI           I;       # USED TO SET SPEC$NEXTKEY       #
          ITEM  I            I;        # LOCAL SCRATCH                 #
          ITEM  J            I;        # LOCAL SCRATCH                 #
          ITEM  K            I;        # LOCAL SCRATCH                 #
          ITEM  PSI          I;        # USED TO SET SPEC$CSORDER      #
          ITEM  CSTABPTR     I;        # POINTER TO CSTABLE            #
          ITEM  COLSEQNAME   C(10);    # COLLATING SEQUENCE NAME       #
          ITEM  EQUNAME      C(10);    # EQUATE NAME                   #
          ITEM  FOUND        B;        # IF NAME FOUND IN CSTABLE      #
          ITEM  USEROWNCODE  B;        # IF USER HAS CALLED FOR OWNCODE#
          ITEM  GROUPNUM     I;        # GROUP NUMBER                  #
          ITEM  N            I;       # INDEX FOR RP$T SEARCH OF CRSPEC#
          ITEM SEQRFLG       B;        # TRUE IFF SERQ USED            #
          ITEM  CRSPLEN      I;       # LENGTH OF CURRENT-SPEC ARRAY   #
          ARRAY  CRSPEC$ [1:1000]  S(2);
              BEGIN 
              ITEM  CRSPEC$TYPE    I(0, 0,10);
              ITEM  CRSPEC$ORDIN   I(0,24,18);
              ITEM  CRSPEC$GROUP   I(0,42,18);
              ITEM  CRSPEC$VALUE   I(1, 0,60);
              ITEM  CRSPEC$VALUC   C(1, 0,10);
              ITEM  CRSPEC$USED    B(0,10, 1);
              END 
  
          ARRAY  SPEC$OWNN [1:5];   # TEMPORARY ARRAY FOR OWNCODE ADDR #
              ITEM  OWNN  U(0, 0,60)= [0,0,0,0,0];
  
# TEMPORARY ARRAY TO STORE THE COLLATING SEQUENCE ORDER                #
  
          ARRAY  CSARRAY [0:63] S(1); 
              BEGIN 
              ITEM  CSORDER  I( 0, 0,60); 
              END 
  
# TABLE OF COLLATING SEQUENCES:                                        #
#     COBOL6, ASCII6, EBCDIC6, INTBCD AND UP TO 100 USER SEQUENCES     #
  
          ARRAY CSTABLE [1:104] S(2); 
              BEGIN 
              ITEM  CSNAME   C( 0, 0,10); # COLLATING SEQUENCE NAME    #
              ITEM  CSALTER  B( 1, 0, 1); # TRUE IFF ALTER USED        #
              ITEM  CSSEQA   B( 1, 1, 1); # TRUE IFF SEQA USED         #
              ITEM  CSINDEX  I( 1,42,18); # INDEX TO SPEC$             #
              END 
  
*IF DEF,63CSET
#          63 CHARACTER SET COLLATING SEQUENCE TABLES                  #
  
           ARRAY ASCIICODE [0:63] S(1); 
               BEGIN
               ITEM  ASCIICS  U(0, 0,60) =
               [ 45,54,52,48,43, 0,55,56,41,42,39,37,46,38,47,40, 
                 27,28,29,30,31,32,33,34,35,36,51,63,58,44,59,57, 
                 60, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15, 
                 16,17,18,19,20,21,22,23,24,25,26,49,61,50,62,53];
               END
  
           ARRAY COBOLCODE [0:63] S(1); 
               BEGIN
               ITEM COBOLCS  U( 0, 0,60) =
               [ 45,60, 0,49,53,48,55,56,57,59,61,62,47,42,63,37, 
                 43,39,38,40,46,41,44,52,58, 1, 2, 3, 4, 5, 6, 7, 
                  8, 9,54,10,11,12,13,14,15,16,17,18,50,19,20,21, 
                 22,23,24,25,26,51,27,28,29,30,31,32,33,34,35,36 ]; 
               END
  
           ARRAY EBCDIC6CODE [0:63];
               BEGIN
               ITEM EBCDIC6CS   U( 0, 0,60) = 
               [ 45,47,58,41,37,54,55,43,39,42,63,62,38,40,46, 0, 
                 53,59,57,51,48,60,56,44,52,49, 1, 2, 3, 4, 5, 6, 
                  7, 8, 9,50,10,11,12,13,14,15,16,17,18,61,19,20, 
                 21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36];
               END
  
           ARRAY INTBCDCODE [0:63]; 
               BEGIN
               ITEM INTBCDCS    U( 0, 0,60) = 
               [ 27,28,29,30,31,32,33,34,35,36,51,44,52,60, 0,49, 
*ENDIF
*IF -DEF,63CSET 
#          64 CHARACTER SET COLLATING SEQUENCE TABLES                  #
  
          ARRAY ASCIICODE [0:63] S(1);
              BEGIN 
              ITEM  ASCIICS  U( 0, 0,60) =
              [ 45,54,52,48,43,51,55,56,41,42,39,37,46,38,47,40,
                27,28,29,30,31,32,33,34,35,36, 0,63,58,44,59,57,
                60, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
                16,17,18,19,20,21,22,23,24,25,26,49,61,50,62,53]; 
              END 
  
          ARRAY COBOLCODE [0:63] S(1);
              BEGIN 
              ITEM  COBOLCS  U( 0, 0,60) =
              [ 45,60,51,49,53,48,55,56,57,59,61,62,47,42,63,37,
                43,39,38,40,46,41,44,52,58, 1, 2, 3, 4, 5, 6, 7,
                 8, 9,54,10,11,12,13,14,15,16,17,18,50,19,20,21,
                22,23,24,25,26, 0,27,28,29,30,31,32,33,34,35,36 ];
              END 
  
          ARRAY EBCDIC6CODE [0:63]; 
              BEGIN 
              ITEM  EBCDIC6CS   U(0, 0,60) =
              [ 45,47,58,41,37,54,55,43,39,42,63,62,38,40,46,51,
                53,59,57, 0,48,60,56,44,52,49, 1, 2, 3, 4, 5, 6,
                 7, 8, 9,50,10,11,12,13,14,15,16,17,18,61,19,20,
                21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36]; 
              END 
  
          ARRAY INTBCDCODE [0:63];
              BEGIN 
              ITEM  INTBCDCS     U(0, 0,60) = 
              [ 27,28,29,30,31,32,33,34,35,36, 0,44,52,60,51,49,
*ENDIF
                37, 1, 2, 3, 4, 5, 6, 7, 8, 9,58,47,42,61,62,63,
                38,10,11,12,13,14,15,16,17,18,54,43,39,56,57,59,
                45,40,19,20,21,22,23,24,25,26,50,46,41,53,48,55]; 
              END 
  
  
          PROC  SEARCHFORGRP(RPTK,GRPV,N);
#**       SEARCHFORGRP- SEARCH CURRENT-SPEC FOR GROUP                  #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SEARCHFORGRP(RP$T"XXXXXXX",GROUPNUM,N)                       #
#                                                                      #
#     GIVEN-                                                           #
#         RP$T"XXXXXXX" = GROUP TYPE                                   #
#         GROUPNUM = GROUP NUMBER ASSOCIATED WITH EACH KEYTYPE         #
#         N = INTEGER VARIABLE                                         #
#                                                                      #
#     DOES-                                                            #
#         SEARCHES CURRENT-SPEC FOR THE UNUSED ENTRY WITH              #
#         CRSPEC$TYPE = RP$T"KEYTYPE" AND WITH THE SMALLEST VALUE      #
#         OF CRSPEC$GROUP.                                             #
#         IF SUCH AN ENTRY IS FOUND,                                   #
#             SETS N = INDEX TO THE ENTRY                              #
#             SETS GROUPNUM = CRSPEC$GROUP                             #
#         ELSE                                                         #
#             SETS N = 0.                                              #
  
          BEGIN 
          ITEM GRPV          I;        # GROUP NUMBER                  #
          ITEM N             I;        # INTEGER VALUE                 #
          ITEM RPTK                   I;  # RP$ TYPE                   #
          ITEM I             I;        # LOCAL SCRATCH                 #
  
          GRPV = 1000000; 
          N = 0;
          FOR I=1 STEP 1 UNTIL CRSPLEN  DO
              BEGIN 
              IF NOT CRSPEC$USED[I] 
               AND CRSPEC$TYPE[I] EQ RPTK 
               AND CRSPEC$GROUP[I] LS GRPV  THEN
                  BEGIN 
                  N=I;
                  GRPV = CRSPEC$GROUP[N]; 
                  END 
              IF N NQ 0 THEN
                  CRSPEC$USED[N] = TRUE;
              END #FOR# 
          END #SEARCHFORGRP#
  
          PROC SEARCHFORKEY(RPTK,GRPVK,N);
#**       SEARCHFORKEY -  SEARCH CURRENT-SPEC FOR KEYTYPE              #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SEARCHFORKEY(RP$T"KEYXXXXX",GROUPNUM,N):                     #
#                                                                      #
#     GIVEN-                                                           #
#         RP$T"KEYXXXXX" = RAW PARAMETER KEY TYPE TO BE FOUND IN       #
#                           CURRENT-SPEC                               #
#         GROUPNUM = GROUP NUMBER ASSOCIATED WITH KEY TYPE             #
#         N = INTEGER VARIABLE                                         #
#                                                                      #
#     DOES-                                                            #
#         SEARCH CURRENT-SPEC FOR AN UNUSED ENTRY WITH                 #
#         CRSPEC$TYPE = RP$T"KEYXXXXX" AND WITH                        #
#         CRSPEC$GROUP = GROUPNUM.                                     #
#         IF SUCH AN ENTRY IS FOUND,                                   #
#             SETS N = INDEX TO THE ENTRY                              #
#             NOTES THAT THE ENTRY IS USED                             #
#         ELSE                                                         #
#             SETS N = 0.                                              #
  
          BEGIN 
          ITEM RPTK          I;        # RP$ KEY TYPE                  #
          ITEM N             I;        # INTEGER VALUE                 #
          ITEM GRPVK         I;        # GROUP NUMBER                  #
  
          FOR N=1 STEP 1 UNTIL CRSPLEN DO 
              BEGIN 
              IF NOT CRSPEC$USED[N] 
                AND CRSPEC$TYPE[N] EQ RPTK
                AND CRSPEC$GROUP[N] EQ GRPVK  THEN
                  BEGIN 
                  CRSPEC$USED[N] = TRUE;
#***#             RETURN; 
                  END 
              END #FOR# 
          N = 0;
          END #SEARCHFORKEY#
  
          PROC SEARCHFORRPT(RPT,N); 
#**       SEARCHFORRPT -  SEARCH CURRENT-SPEC FOR RAW PARAM. TYPE      #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SEARCHFORRPT(RP$T"XXXXXX",N):                                #
#                                                                      #
#     GIVEN-                                                           #
#         RP$T"XXXXXX" = RAW PARAMETER TYPE TO BE FOUND                #
#         N = INTEGER VARIABLE                                         #
#                                                                      #
#     DOES-                                                            #
#         SEARCH CURRENT-SPEC FOR AN UNUSED ENTRY WITH                 #
#         CRSPEC$TYPE = RP$T"XXXXXX"                                   #
#         IF SUCH AN ENTRY IS FOUND,                                   #
#             SETS N = INDEX TO THE ENTRY                              #
#             NOTES THAT THE ENTRY IS USED                             #
#         ELSE                                                         #
#             SETS N = 0.                                              #
  
          BEGIN 
          ITEM RPT           I;        # RP$ TYPE                      #
          ITEM N             I;        # INTEGER VALUE                 #
  
          FOR N=1 STEP 1 UNTIL CRSPLEN  DO
              BEGIN 
              IF NOT CRSPEC$USED[N] 
               AND CRSPEC$TYPE[N] EQ RPT  THEN
                  BEGIN 
                  CRSPEC$USED[N] = TRUE;
#***#             RETURN; 
                  END 
              END #FOR# 
          N = 0;
          END #SEARCHFORRPT#
  
          # USE THIS PROCEDURE FOR DEBUGGING USER-DEFINED              #
          # COLLATING SEQUENCES AND THE PROBLEMS ASSOCIATED            #
          # WITH THEM # 
          PROC PRINTSTUFF;  # DEBUGGING SEQS RANGES # 
          BEGIN 
          $BEGIN
          ITEM II I;
          ITEM MES C(80); 
          MES = " -- BEGINNING OF PRINTSTUFF LOOP --";
          S$PRTCD(MES); 
          FOR II = 0 STEP 1 UNTIL 63 DO 
              BEGIN 
              MES = " II = "; 
              C<5,20>MES = OCT(II); 
              S$PRTCD(MES); 
              MES = " CSORDER[II] = ";
              C<15,20>MES = OCT(CSORDER[II]); 
              S$PRTCD(MES); 
              END 
          MES = " -- END OF PRINTSTUFF LOOP -- "; 
          S$PRTCD(MES); 
          S$PRTCD(0); 
          $END
          END 
  
  
CONTROL DISJOINT; 
  
CONTROL INERT;
  
CONTROL EJECT;
          LONGSUM = FALSE;
  
S$RSTAR:  
          S$FLAGS = 0;                 # FIRST TIME OR RESTART         #
          K = 0;
          SEQRFLG = FALSE;
  
          FOR I=1 STEP 1 UNTIL 104    DO   # UPPER BOUND OF 'CSTABLE ' #
              BEGIN 
              CSALTER[I] = TRUE;
              CSSEQA[I] = FALSE;
              END 
  
  
# SET CURRENT-SPEC ARRAY                                               #
  
          S$SETPT(RP$,STATUS$); 
          FOR I=1 STEP 1 WHILE RP$TYPE NQ RP$T"$END$"  DO 
              BEGIN 
              CRSPEC$TYPE[I] = RP$TYPE; 
              CRSPEC$ORDIN[I] = RP$ORDINAL; 
              CRSPEC$GROUP[I] = RP$GROUP; 
              CRSPEC$VALUE[I] = RP$VALUE; 
              CRSPEC$VALUC[I] = RP$VALUEC;
              CRSPEC$USED[I] = FALSE; 
              S$SETPT(RP$,STATUS$); 
              END 
          CRSPLEN = I;
  
  
# SET FLAG DEFAULT FOR USER OWNCODE                                    #
  
          USEROWNCODE = FALSE;
# SET OWNF$ # 
  
          SEARCHFORRPT(RP$T"OWNFILE",N);
          IF N NQ 0 THEN               #IF OWN1NAME IS SPECIFIED       #
              BEGIN 
              OWNF$ = CRSPEC$VALUC[N];
              END 
          ELSE
              OWNF$ = " ";
  
# SET OWNNA$OWN1 #
  
          SEARCHFORRPT(RP$T"OWN1NAME",N); 
          IF N NQ 0 THEN               #IF OWN1NAME IS SPECIFIED       #
              BEGIN 
              OWNNA$OWN1 = CRSPEC$VALUC[N]; 
              USEROWNCODE = TRUE; 
              END 
          ELSE
              FOR I = 0 STEP 1 UNTIL 7 DO C<I,1>OWNNA$OWN1 = 0; 
  
# SET OWNNA$OWN2                                                       #
  
          SEARCHFORRPT(RP$T"OWN2NAME",N); 
          IF N NQ 0 THEN               #IF OWN2NAME IS SPECIFIED       #
              BEGIN 
              OWNNA$OWN2 = CRSPEC$VALUC[N]; 
              USEROWNCODE = TRUE; 
              END 
          ELSE
              FOR I = 0 STEP 1 UNTIL 7 DO C<I,1>OWNNA$OWN2 = 0; 
  
# SET OWNNA$OWN3                                                       #
  
          SEARCHFORRPT(RP$T"OWN3NAME",N); 
          IF N NQ 0 THEN               #IF OWM3NAME IS SPECIFIED       #
              BEGIN 
              OWNNA$OWN3 = CRSPEC$VALUC[N]; 
              USEROWNCODE = TRUE; 
              END 
          ELSE
              FOR I = 0 STEP 1 UNTIL 7 DO C<I,1>OWNNA$OWN3 = 0; 
  
# SET OWNNA$OWN4                                                       #
  
          SEARCHFORRPT(RP$T"OWN4NAME",N); 
          IF N NQ 0 THEN               #IF OWN4NAME IS SPECIFIED       #
              BEGIN 
              OWNNA$OWN4 = CRSPEC$VALUC[N]; 
              USEROWNCODE = TRUE; 
              END 
          ELSE
              FOR I = 0 STEP 1 UNTIL 7 DO C<I,1>OWNNA$OWN4 = 0; 
  
# SET OWNNA$OWN5                                                       #
  
          SEARCHFORRPT(RP$T"OWN5NAME",N); 
          IF N NQ 0 THEN               #IF OWN5NAME IS SPECIFIED       #
              BEGIN 
              OWNNA$OWN5 = CRSPEC$VALUC[N]; 
              USEROWNCODE = TRUE; 
              END 
          ELSE
              FOR I = 0 STEP 1 UNTIL 7 DO C<I,1>OWNNA$OWN5 = 0; 
  
          IF USEROWNCODE THEN 
              IF OWNF$ EQ " " THEN
                  S$ERROR(E$122);      # OWNCODE WITHOUT OWNF -FATAL   #
# IGNORE RP$T"BA".           (WE USED TO INDIRECTLY IGNORE IT.         #
                           #  NOW WE ARE DIRECTLY IGNORING IT.         #
                           #  SPEC$LWSA IS SET IN S$STREC.)            #
  
  
#     SET SPEC$FASTIO                                                  #
  
          SEARCHFORRPT(RP$T"FASTIO", N);
          IF N NQ 0 THEN
              SPEC$FASTIO = TRUE; 
          ELSE
              SPEC$FASTIO = FALSE;
  
# SET SPEC$OUTNAME                                                     #
  
          SEARCHFORRPT(RP$T"OUTFILE",N);
          IF N NQ 0 THEN               #IF OUTFILE IS SPECIFIED        #
              BEGIN 
              SPEC$OUTNAME = CRSPEC$VALUC[N]; 
              END 
          ELSE
              SPEC$OUTNAME = " "; 
  
# SET SPEC$OUTFIT                                                      #
  
          SEARCHFORRPT(RP$T"OUTFIT",N); 
          IF N NQ 0 THEN               # IF OUTFIT IS SPECIFIED        #
              BEGIN 
              SPEC$OUTFIT = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OUTFIT = 0;
  
# SET SPEC$OWN1 WITH RPT VALUE FROM CURRENT-SPEC                       #
  
          SEARCHFORRPT(RP$T"OWN1",N); 
          IF N NQ 0  THEN              # IF OWN1 IS SPECIFIED          #
              BEGIN 
              SPEC$OWN1 = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OWN1 = 0;
  
# SET SPEC$OWN2 WITH A RPT VALUE FROM CURRENT-SPEC                     #
  
          SEARCHFORRPT(RP$T"OWN2",N); 
          IF N NQ 0  THEN              # IF OWN2 IS SPECIFIED          #
              BEGIN 
              SPEC$OWN2 = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OWN2 = 0;
  
# SET SPEC$OWN3 WITH RPT VALUE FROM CURRENT-SPEC                       #
  
          SEARCHFORRPT(RP$T"OWN3",N); 
          IF N NQ 0  THEN              # IF OWN3 IS SPECIFIED          #
              BEGIN 
              SPEC$OWN3 = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OWN3 = 0;
  
# SET SPEC$OWN4 WITH RPT VALUE FROM CURRENT-SPEC                       #
  
          SEARCHFORRPT(RP$T"OWN4",N); 
          IF N NQ 0  THEN              # IF OWN4 IS SPECIFIED          #
              BEGIN 
              SPEC$OWN4 = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OWN4 = 0;
  
# SET SPEC$OWN5 WITH RPT VALUE FROM CURRENT-SPEC                       #
  
          SEARCHFORRPT(RP$T"OWN5",N); 
          IF N NQ 0  THEN              # IF OWN5 IS SPECIFIED          #
              BEGIN 
              SPEC$OWN5 = CRSPEC$VALUE[N];
              END 
          ELSE
              SPEC$OWN5 = 0;
  
#     SET SPEC$OWNN FROM OWNNA$ IF OWNF$ SPECIFIED                     #
  
          IF OWNF$ NQ " " THEN
              BEGIN 
              S$OWNLD(GOODLOAD, OWNNA$, OWNF$, SPEC$OWNN);
              IF GOODLOAD THEN
                  BEGIN 
                  SPEC$OWN1 = OWNN[1];
                  SPEC$OWN2 = OWNN[2];
                  SPEC$OWN3 = OWNN[3];
                  SPEC$OWN4 = OWNN[4];
                  SPEC$OWN5 = OWNN[5];
                  END 
              ELSE
                  BEGIN 
                  S$ERROR(E$121); 
                  STATUS$NORML = FALSE; 
                  STATUS$STATE = S"FATAL";
                  END 
              END 
  
  
#         SET SPEC$OWNT WITH VALUE FROM CURRENT-SPEC                   #
  
          SEARCHFORRPT(RP$T"OWNT",N); 
          IF N NQ 0 THEN              # IF OWNT = "OLD"                #
              SPEC$OWNT = FALSE;      # SM4 INTERFACE                  #
          ELSE
              SPEC$OWNT = TRUE;       # SM5 INTERFACE                  #
  
# SET SPEC$VERIFY WITH RPT VALUE FROM CURRENT-SPEC                     #
  
          SPEC$VERIFY = FALSE;   #  SET DEFAULT FOR SORTS # 
          IF S$SMFLG NQ 1 AND S$SMFLG NQ 2 THEN 
              BEGIN 
              S$ERROR(E$157);   # NEITHER SORT NOR MERGE CALLED # 
              STATUS$NORML = FALSE; 
              STATUS$STATE = S"FATAL";
              RETURN; 
              END 
          IF S$SMFLG EQ 2 THEN         # MERGE WAS SPECIFIED           #
              BEGIN 
              SEARCHFORRPT(RP$T"VERIFY",N); 
              IF N NQ 0  THEN          # IF VERIFY IS SPECIFIED        #
                  SPEC$VERIFY = TRUE; 
              ELSE
                  SPEC$VERIFY = FALSE;
              END 
  
# SET SPEC$NODAY WITH RPT VALUE FROM CURRENT-SPEC                      #
  
          SEARCHFORRPT(RP$T"NODAY",N);
          IF N NQ 0 THEN
              SPEC$NODAY = TRUE;
          ELSE
              SPEC$NODAY = FALSE; 
  
# SET SPEC$RETAIN WITH RPT VALUE FROM CURRENT-SPEC                     #
  
          SEARCHFORRPT(RP$T"RETAIN",N); 
          IF N NQ 0  THEN              # IF RETAIN IS SPECIFIED        #
              BEGIN 
              SPEC$RETAIN = TRUE; 
              END 
          ELSE
              SPEC$RETAIN = FALSE;
  
# SET SPEC$SORT                                                        #
  
          IF S$SMFLG EQ 1 THEN
              SPEC$SORT = TRUE; 
          ELSE
              SPEC$SORT = FALSE;
  
          IF (NOT SPEC$SORT) AND SPEC$FASTIO THEN 
              BEGIN 
              S$ERROR(E$118); 
              SPEC$FASTIO = FALSE;
              END 
  
# SET SPEC$ENRHIGH WITH RPT VALUE FROM CURRENT-SPEC                    #
  
          SEARCHFORRPT(RP$T"ENR", N); 
          IF N NQ 0 THEN                          # IF ENR IS SPECIFIED#
              BEGIN 
              SPEC$ENRHIGH = CRSPEC$VALUE[N]; 
              IF SPEC$ENRHIGH LS 0 THEN 
                 SPEC$ENRHIGH = 0;
              ELSE
                 IF SPEC$ENRHIGH GR 1000000000 THEN 
                    SPEC$ENRHIGH = 1000000000;
              END 
          ELSE
              SPEC$ENRHIGH = -1;          # ALSO SEE S$STREC FOR OTHER #
                                          # USE OF ENRDEFAULT          #
  
# SET SPEC$LIBUF                                                       #
  
          SPEC$LIBUF = 1025;
  
# SET SPEC$MRL WITH RPT VALUE FROM CURRENT-SPEC                        #
  
          SPEC$FIXEDOW = TRUE;
          SEARCHFORRPT(RP$T"MRL",N);
          IF N NQ 0  THEN              # IF MRL IS SPECIFIED           #
              BEGIN 
              SPEC$MRL = CRSPEC$VALUE[N]; 
              SPEC$FIXEDOW = FALSE; 
              END 
          ELSE
              SPEC$MRL = 0; 
  
#     START SPEC$FIXLEN WITH VALUE FROM SM5OFL                         #
#         (MAY BE ALTERED LATER BY S$PRSPC.)                           #
  
          SEARCHFORRPT(RP$T"OWNFL",N);
          IF N NQ 0 THEN               # IF OWNFL IS SPECIFIED         #
              SPEC$FIXLEN = CRSPEC$VALUE[N];
          ELSE                         # IF OWNFL IS NOT SPECIFIED     #
              SPEC$FIXLEN = 0;
  
# SET COBOL6, ASCII6, EBCDIC6 AND INTBCD DEFAULT COLLATING SEQUENCES   #
  
          CSNAME[1] = "COBOL6"; 
          CSINDEX[1] = SPEC$1STINDX;
          FOR I = 0 STEP 1 UNTIL 63 DO
              SPEC$CSORDER[ SPEC$1STINDX + COBOLCS[I] ] = I;
          PSI = SPEC$1STINDX + 64;
  
          CSNAME[2] = "ASCII6"; 
          CSINDEX[2] = PSI; 
          FOR I = 0 STEP 1 UNTIL 63 DO
              SPEC$CSORDER[ PSI + ASCIICS[I] ] = I; 
          PSI = PSI + 64; 
  
          CSNAME[3] = "EBCDIC6";
          CSINDEX[3] = PSI; 
          FOR I = 0 STEP 1 UNTIL 63 DO
              SPEC$CSORDER[PSI + EBCDIC6CS[I]] = I; 
          PSI = PSI + 64; 
  
          CSNAME[4] = "INTBCD"; 
          CSINDEX[4] = PSI; 
          FOR I = 0 STEP 1 UNTIL 63 DO
              SPEC$CSORDER[PSI + INTBCDCS[I]] = I;
          PSI = PSI + 64; 
  
          CSTABPTR = 4;      # POINTS TO LAST PRE-DEFINED COL SEQ # 
  
  
          CONTROL EJECT;
  
          # SET UP SPEC$CSORDER FOR USER-DEFINED COLLATING SEQUENCES   #
  
          SEARCHFORRPT(RP$T"SEQNAM",N); 
          FOR PSI = PSI STEP 64 WHILE N NQ 0 DO 
              BEGIN                    # WE HAVE A COLSEQ NAME         #
              FOR I = 0 STEP 1 UNTIL 63 DO
                  CSORDER[I] = -1;     # INITIALIZE THE TEMPORARY      #
                                       # COLLATING SEQUENCE ARRAY      #
  
              CSTABPTR = CSTABPTR + 1; # CSTABPTR[4] IS LAST           #
                                       # PRE-DEFINED COLLATING SEQUENCE#
              GROUPNUM = CRSPEC$GROUP[N]; 
              COLSEQNAME = CRSPEC$VALUC[N]; 
  
              # CHECK FOR DUPLICATE COLLATING SEQUENCE NAMES           #
  
              FOR J = 1 STEP 1 UNTIL CSTABPTR-1 DO
                  IF COLSEQNAME EQ CSNAME[J] THEN 
                      BEGIN 
                      STRING$LEN = 10;
                      STRING$C = COLSEQNAME;
                      S$ERROR(E$8,STRING$,1); 
                      STATUS$NORML = FALSE; 
                      END 
  
              #     NOW CHECK TO SEE IF ALTER HAS BEEN SPECIFIED FOR   #
              #     THIS COLLATING SEQUENCE                            #
  
              CSALTER[CSTABPTR] = FALSE; # SET DEFAULT TO FALSE        #
  
              FOR J = 1 STEP 1 UNTIL CRSPLEN DO 
                  IF (CRSPEC$TYPE[J] EQ RP$T"SEQA") AND 
                    (NOT CRSPEC$USED[J])  THEN
                      IF CRSPEC$GROUP[J] EQ GROUPNUM THEN 
                          BEGIN 
                          CSALTER[CSTABPTR] = TRUE; # UNSET THE DEFAULT#
                          CSSEQA[CSTABPTR] = TRUE; # SEQA IS USED      #
                          CRSPEC$USED[J] = TRUE;
                          J = CRSPLEN;              #  STOP LOOPING    #
                          END 
  
              CSNAME[CSTABPTR] = COLSEQNAME;
              CSINDEX[CSTABPTR] = PSI;
  
              SEARCHFORKEY(RP$T"SEQVAL",GROUPNUM,N);
              SEQRFLG = FALSE;  # INITIALIZE IN CASE OF NO SEQR DIR    #
  
              FOR I = 0 STEP 1 WHILE N NQ 0 DO
                  BEGIN 
                  SI = CRSPEC$VALUE[N]; 
                  # CHECK IF ELEMENT OF COLSEQ IS -1 THEN SAVE INDEX I #
                  # CHECK IF ELEMENT OF COLSEQ HAS BEEN GIVEN BEFORE   #
                  # THEN ERROR ELSE USE IT TO INDEX INTO CSORDER ARRAY #
                  IF SI EQ -1 THEN
                      BEGIN 
                      K = I; # SAVE THIS I FOR LATER #
                      SEQRFLG = TRUE; 
                      END 
                  ELSE
                      BEGIN 
                      IF CSORDER[SI] NQ -1 THEN 
              BEGIN 
              S$ERROR(E$97);  # SHOULD PROBABLY BE AN                  #
                                       # INTERNAL ABORT                #
              STATUS$NORML = FALSE; 
              END 
                      ELSE
                          CSORDER[SI] = I;
                      END 
                      SEARCHFORKEY(RP$T"SEQVAL",GROUPNUM,N);
                  END 
  
              IF NOT SEQRFLG THEN  # NO SEQR DIR, SET TO HIGHEST I     #
                  K = I;
              FOR J = 0 STEP 1 UNTIL 63 DO
                  BEGIN 
                  IF CSORDER[J] EQ -1 THEN
                      SPEC$CSORDER[PSI+J] = K;
                  ELSE
                      SPEC$CSORDER[PSI+J] = CSORDER[J]; 
                  END 
              SEARCHFORRPT(RP$T"SEQNAM",N); 
              END 
  
  
# GET GROUP NUMBER FOR KEY TYPE                                        #
  
          SPEC$1STKEY = SPEC$1STINDX; 
          SEARCHFORGRP(RP$T"KEYTYPE",GROUPNUM,N); 
          SPEC$1STKEY = SPEC$1STINDX; 
          FOR SI = SPEC$1STKEY  WHILE N NQ 0  DO
              BEGIN 
              SPEC$KEYTYPE[SI] = CRSPEC$VALUE[N]; 
              SPEC$NEXTKEY[SI] = SI + 2;
              SPEC$KEYALT[SI] = FALSE;  # INITIALIZE TO FALSE FOR ALL  #
              SPEC$SEQAON[SI] = FALSE;
  
              IF CRSPEC$VALUE[N] NQ KT$T"DISPLAY" THEN
                  SPEC$KEYCS[SI] = 0; 
              ELSE
                  BEGIN 
                  SEARCHFORKEY(RP$T"KEYCOLSEQ", GROUPNUM, N); 
                  COLSEQNAME = CRSPEC$VALUC[N]; 
                  IF COLSEQNAME EQ "DISPLAY" THEN 
                      BEGIN 
                      SPEC$KEYTYPE[SI] = KT$T"LOGICAL"; 
                      SPEC$KEYCS[SI] = 0; 
                      END 
                  ELSE
                      BEGIN 
                      FOUND = FALSE;
                      FOR I = 1 STEP 1
                        WHILE NOT FOUND AND I LQ CSTABPTR DO
                          BEGIN 
                          IF COLSEQNAME EQ CSNAME[I] THEN 
                              BEGIN 
                              SPEC$KEYCS[SI] = CSINDEX[I];
                              SPEC$KEYALT[SI] = CSALTER[I]; 
                              SPEC$SEQAON[SI] = CSSEQA[I];
                              FOUND = TRUE; 
                              END 
                          END 
                      IF NOT FOUND THEN 
                          BEGIN 
                          STRING$LEN = 7; 
                          STRING$C = COLSEQNAME;
                          S$ERROR(E$4,STRING$,1); 
                          STATUS$NORML = FALSE; 
                          END 
                      END 
                  END 
  
              SEARCHFORKEY(RP$T"KEYBYTEPOS",GROUPNUM,N);
              IF N EQ 0  THEN 
                  SPEC$KEYBYTE[SI] = 0; 
              ELSE
                  SPEC$KEYBYTE[SI] = CRSPEC$VALUE[N] - 1; 
  
              SEARCHFORKEY(RP$T"KEYBITPOS",GROUPNUM,N); 
              IF N EQ 0  THEN 
                  SPEC$KEYBIT[SI] = 0;
              ELSE
                  SPEC$KEYBIT[SI] = CRSPEC$VALUE[N] - 1;
  
              SEARCHFORKEY(RP$T"KEYNBYTES",GROUPNUM,N); 
              IF N EQ 0  THEN 
                  SPEC$KEYNBYT[SI] = 0; 
              ELSE
                  SPEC$KEYNBYT[SI] = CRSPEC$VALUE[N]; 
              IF ( SPEC$KEYTYPE[SI] EQ KT$T"NUMERICLS" OR 
                   SPEC$KEYTYPE[SI] EQ KT$T"NUMERICTS" OR 
                   SPEC$KEYTYPE[SI] EQ KT$T"NUMERICFS" )
                 AND
                 SPEC$KEYNBYT[SI] LS 2 THEN 
                   BEGIN
                   S$ERROR(E$100);
                   STATUS$NORML = FALSE;
                   END
  
              SEARCHFORKEY(RP$T"KEYNBITS",GROUPNUM,N);
              IF N EQ 0  THEN 
                  SPEC$KEYNBIT[SI] = 0; 
              ELSE
                  SPEC$KEYNBIT[SI] = CRSPEC$VALUE[N]; 
  
              SEARCHFORKEY(RP$T"KEYORDER",GROUPNUM,N);
#         SINCE THE DEFAULT SORTING SEQUENCE IS ASCENDING,             #
#         RP$T"KEYORDER" SHOULD ONLY BE SET FOR A DESCENDING KEY.      #
#         WE DON'T EVEN CHECK THE VALUE -- IF RP$T"KEYORDER"           #
#         IS SET *AT ALL*, IT MEANS DESCENDING ORDER.                  #
  
          IF N NQ 0 THEN
                  SPEC$KEYASC[SI] = FALSE;
              ELSE
                  SPEC$KEYASC[SI] = TRUE; 
  
              SEARCHFORGRP(RP$T"KEYTYPE",GROUPNUM,N); 
              SI = SI + 2;
              END #FOR# 
  
# IF NO KEY IS SPECIFIED, THE WHOLE RECORD IS THE KEY                  #
# WITH KEYTYPE DISPLAY, COLLATING SEQUENCE ASCII6                      #
  
          SPEC$NOKEY = FALSE; 
  
          IF SI EQ SPEC$1STKEY  THEN
              BEGIN 
              SPEC$KEYTYPE[SI] = KT$T"DISPLAY"; 
              SPEC$KEYCS[SI] = CSINDEX[2];  # ASCII6 #
              SPEC$KEYASC[SI] = TRUE; 
              SPEC$KEYBYTE[SI] = 0; 
              SPEC$KEYBIT[SI]  = 0; 
              SPEC$KEYNBYT[SI] = 0; 
              SPEC$KEYNBIT[SI] = 0; 
              SPEC$NEXTKEY[SI] = 0; 
              SPEC$KEYALT[SI] = TRUE; 
              SI = SI + 2;
  
              SPEC$NOKEY = TRUE;    # FOR S$PRSPC TO KNOW THE WHOLE    #
                                  # RECORD IS THE KEY                  #
  
              END 
          ELSE
              BEGIN 
              SPEC$NEXTKEY[SI-2] = 0; 
              END 
          SI = SI + 20;    # RESERVED FOR OVERLAPPING KEYS PROCESSING  #
  
#     PROCESS FOR SUMMING                                              #
  
          SEARCHFORGRP(RP$T"SUMTYPE",GROUPNUM,N); 
  
          IF N NQ 0 THEN
              BEGIN 
  
              IF SPEC$RETAIN THEN 
                  BEGIN 
                  S$ERROR(E$115);      # SUM AND RETAIN ILLEGAL        #
                  STATUS$NORML = FALSE; 
                  RETURN;              # CATASTROPHIC ERROR            #
                  END 
              SPEC$1STSUM = SI; 
  
              FOR SI = SPEC$1STSUM WHILE N NQ 0 DO
  
                  BEGIN 
  
                  SPEC$SUMTYPE[SI] = CRSPEC$VALUE[N]; 
                  SPEC$NEXTSUM[SI] = SI+2;
                  SPEC$SMLENI[SI] = 0;      # SET THIS FIELD TO ZERO - #
                                                  # RESET BY S$GNINV  # 
                  SPEC$SUMOFF[SI] = 0;      #    DITTO                 #
              IF (SPEC$SUMTYPE[SI] NQ KT$T"NUMERICLO" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"NUMERICLS" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"NUMERICTO" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"NUMERICTS" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"NUMERICNS" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"NUMERICFS" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"LOGICAL" AND 
                  SPEC$SUMTYPE[SI] NQ KT$T"INTEGER") THEN 
                  BEGIN 
                  S$ERROR(E$86);
                  STATUS$NORML = FALSE; 
                  END 
  
                  SEARCHFORKEY(RP$T"SUMBYTEPOS",GROUPNUM,N);
                  IF N EQ 0 THEN
                      SPEC$SUMBIT[SI] = 0;
                  ELSE
                      SPEC$SUMBIT[SI] = BYTE*(CRSPEC$VALUE[N]-1); 
  
                  SEARCHFORKEY(RP$T"SUMBITPOS",GROUPNUM,N); 
                  IF N NQ 0 THEN
                      SPEC$SUMBIT[SI] = SPEC$SUMBIT[SI]+
                                        (CRSPEC$VALUE[N]-1);
  
                  SEARCHFORKEY(RP$T"SUMNBYTES",GROUPNUM,N); 
                  IF N EQ 0 THEN
                      SPEC$SMLENE[SI] = 0;
                  ELSE
                      SPEC$SMLENE[SI] = BYTE*(CRSPEC$VALUE[N]); 
  
                  SEARCHFORKEY(RP$T"SUMNBITS",GROUPNUM,N);
                  IF N NQ 0 THEN
                      SPEC$SMLENE[SI] = SPEC$SMLENE[SI]+
                                         (CRSPEC$VALUE[N]); 
              IF ( SPEC$SUMTYPE[SI] EQ KT$T"NUMERICLS" OR 
                   SPEC$SUMTYPE[SI] EQ KT$T"NUMERICTS" OR 
                   SPEC$SUMTYPE[SI] EQ KT$T"NUMERICFS" )
                 AND
                  SPEC$SMLENE[SI] LS 12 THEN
                   BEGIN
                   S$ERROR(E$100);
                   STATUS$NORML = FALSE;
                   END
  
                  # CHECK THAT SUM FIELDS ARE NOT TOO LONG             #
  
                  IF SPEC$SUMTYPE[SI] EQ KT$T"LOGICAL"
                                     OR 
                     SPEC$SUMTYPE[SI] EQ KT$T"INTEGER" THEN 
                      BEGIN 
                      # SUMTYPE IS -NOT- DISPLAY CHARACTER DATA        #
                      IF SPEC$SMLENE[SI] GR 60 THEN 
                          BEGIN 
                          S$ERROR(E$114); 
                          STATUS$NORML = FALSE; 
                          END 
                      END 
                  ELSE
                      # SUMTYPE IS DISPLAY CHARACTER DATA              #
                      BEGIN 
                      IF SPEC$SMLENE[SI] GR BYTE*17 THEN
                          BEGIN 
                          S$ERROR(E$114); 
                          STATUS$NORML = FALSE; 
                          END 
                      IF SPEC$SMLENE[SI] GR BYTE*10 THEN
                          LONGSUM = TRUE; 
                      END 
  
                  SEARCHFORKEY(RP$T"SUMREP",GROUPNUM,N);
                  IF N NQ 0 THEN
                  SPEC$SUMREP[SI] = CRSPEC$VALUE[N];
                  ELSE
                  SPEC$SUMREP[SI] = 1;
  
                  SEARCHFORGRP(RP$T"SUMTYPE",GROUPNUM,N); 
                  SI = SI+2;
                  END #FOR# 
  
              SPEC$NEXTSUM[SI-2] = 0; 
  
  
              END 
          ELSE   #  NO SUM FIELD WAS SPECIFIED                         #
              SPEC$1STSUM = 0;
  
# SET UP SPEC$CSORDER FOR EQUATE(S)                                    #
  
          SEARCHFORRPT(RP$T"EQUNAM",N); 
          FOR I = I WHILE N NQ 0 DO 
              BEGIN 
              GROUPNUM = CRSPEC$GROUP[N]; 
              EQUNAME = CRSPEC$VALUC[N];
  
              FOUND = FALSE;
              FOR I = 1 STEP 1 WHILE NOT FOUND AND I LQ CSTABPTR DO 
                  BEGIN 
                  IF EQUNAME EQ CSNAME[I] THEN
                      BEGIN 
                      PSI = CSINDEX[I]; 
                      FOUND = TRUE; 
                      END 
                  END 
  
              IF NOT FOUND THEN 
                  BEGIN 
                  S$ABORT("S$SETWH-4"); 
#***#             RETURN; 
                  END 
              ELSE
                  BEGIN 
                  SEARCHFORKEY(RP$T"EQUVAL",GROUPNUM,N);
                  FOR K = 0 STEP 1 WHILE N NQ 0 DO
                      BEGIN 
                      # USE CSORDER TO SAVE THE EQU ELEMENTS #
                      CSORDER[K] = CRSPEC$VALUE[N]; 
                      SEARCHFORKEY(RP$T"EQUVAL",GROUPNUM,N);
                      END 
                  # CSORDER[K-1] CONTAINS THE LAST ELEMENT OF EQU  #
                  # J POINTS TO SPEC$CSORDER OF LAST ELEMENT IN EQU # 
                  J = PSI + CSORDER[K-1]; 
                  FOR I = K-2 STEP -1 UNTIL 0 DO
                      BEGIN 
                      SPEC$CSORDER[PSI+CSORDER[I]] = SPEC$CSORDER[J]; 
                      END 
                  END 
  
              SEARCHFORRPT(RP$T"EQUNAM", N);
              END 
  
# SET SPEC$INNAME FOR INPUT NAME #
  
          SEARCHFORRPT(RP$T"INFILE",N); 
          SPEC$1STINF = SI; 
          FOR SI = SI WHILE N NQ 0 DO 
              BEGIN 
              SPEC$INNAME[SI] = CRSPEC$VALUC[N];
              SPEC$NEXTIN[SI] = SI + 2; 
              SPEC$INFIT[SI] = 0; 
              SI = SI + 2;
              SEARCHFORRPT(RP$T"INFILE",N); 
              END # OF FOR #
  
#     APPEND FORTRAN FIT ADDRESS  (SPEC$INFIT)     #
  
          SEARCHFORRPT(RP$T"INFIT",N);
          FOR SI = SI WHILE N NQ 0 DO 
              BEGIN 
              SPEC$INNAME[SI] = "(FTN)";
              SPEC$INFIT[SI] = CRSPEC$VALUE[N]; 
              SPEC$NEXTIN[SI] = SI + 2; 
              SI = SI + 2;
              SEARCHFORRPT(RP$T"INFIT", N); 
              END 
          IF SI EQ SPEC$1STINF THEN 
              BEGIN 
              SPEC$1STINF = 0;
              END 
          ELSE
              BEGIN 
              SPEC$NEXTIN[SI-2] = 0;
              END 
  
# TEST THAT EITHER INPUT FILE,OWN1 OR OWN2 WAS SPECIFIED               #
  
          IF S$CALLR EQ 1  OR  S$CALLR EQ 2   THEN
  
          BEGIN 
          IF SPEC$1STINF EQ 0   THEN
            BEGIN 
            IF SPEC$OWN1 EQ 0  AND
               SPEC$OWN2 EQ 0   THEN
              BEGIN 
              SPEC$1STINF = SI; 
              SPEC$INNAME[SI] = "OLD";
              SPEC$INFIT[SI] = 0; 
              SPEC$NEXTIN[SI] = 0;
              END 
            END 
  
          ELSE
              BEGIN 
              IF SPEC$INNAME[SPEC$1STINF] EQ "$NULL"  THEN
                  BEGIN 
                  IF SPEC$OWN1 EQ 0  AND  SPEC$OWN2 EQ 0   THEN 
                      BEGIN 
  
#                       EITHER INPUT,OWN1 OR OWN2 MUST BE GIVEN        #
  
                      S$ERROR(E$103, " ", 0); 
                      STATUS$NORML = FALSE; 
                      END 
  
                  SPEC$1STINF = 0;
                  END 
  
  
              END 
  
# TEST THAT EITHER AN OUTPUT FILE, OWN3 OR OWN4 WAS SPECIFIED          #
  
          IF SPEC$OUTFIT EQ 0  AND
                SPEC$OUTNAME EQ " "  AND
                SPEC$OWN3 EQ 0  AND 
                SPEC$OWN4 EQ 0   THEN 
              BEGIN 
              SPEC$OUTNAME = "NEW"; 
              END 
          ELSE
              BEGIN 
              IF SPEC$OUTNAME EQ "$NULL"  THEN
                  BEGIN 
                  IF SPEC$OWN3 EQ 0  AND SPEC$OWN4 EQ 0  THEN 
                      BEGIN 
  
#                       EITHER OUTPUT,OWN3 OR OWN4 MUST BE GIVEN       #
  
                      S$ERROR(E$104, " ", 0); 
                      STATUS$NORML = FALSE; 
                      END 
  
                  SPEC$OUTNAME = " "; 
                  SPEC$OUTFIT = 0;
                  END 
              END 
          END 
  
# PRINT OUT SPEC$CSORDER                                               #
  
          $BEGIN
          FOR I = 1 STEP 1 UNTIL CSTABPTR DO
              BEGIN        # ALL COLSEQS #
              LINE = " ";    # BLANK LINE # 
              C20 = OCT(CSINDEX[I]);
              C<0,7>LINE = CSNAME[I]; 
              C<10,6>LINE = C<14,6>C20; 
              S$PRTCD(LINE);    # PRINT NAME AND PSI #
              IF CSALTER[I] THEN
                LINE = "ALTER IS TRUE FOR THIS COLLATING SEQUENCE"; 
              ELSE
                LINE = "ALTER IS FALSE FOR THIS COLLATING SEQUENCE";
              S$PRTCD(LINE);
              LINE = " ";    # BLANK LINE # 
              FOR J = 0 STEP 1 UNTIL 7 DO 
                  BEGIN 
                  FOR K = 0 STEP 1 UNTIL 7 DO 
                      BEGIN 
                      C20 = OCT(SPEC$CSORDER[CSINDEX[I]+(8*J+K)]);
                      C<K*7,6>LINE = C<14,6>C20;
                      END # K LOOP #
                  S$PRTCD(LINE);
                  END # J LOOP #
              END # I LOOP #
  
          S$PRTCD(0);    # FLUSH BUFFER # 
          $END
  
#***#     RETURN; 
  
  
S$RQUIT:  
          STATUS$NORML = FALSE; 
          STATUS$STATE = S"FATAL";
#***#     RETURN; 
  
          END  # S$SETWH #
          TERM
