*DECK S$GNIM1 
          IDENT  S$GNIM1
          TITLE  S$GNIM1  - GENERATE INTERMEDIATE MERGE CODE PART 1 
          COMMENT  GENERATE INTERMEDIATE MERGE CODE PART 1. 
  
*CALL LBLPTR
  
          B1=1
  
  
**        S$GNIM1  - GENERATE INTERMEDIATE MERGE CODE PART 1
* 
*     CALLING SEQUENCE- 
*         S$GNIM1(REC$LR, LONGKEY, REC$IRRL); 
* 
*     GIVEN-
*         REC $LR   = NUMBER OF BITS TO HOLD
*                      INDEX TO RECORD STORAGE AREA 
*         LONGKEY = NO OF WORDS IN REMAINDER OF KEY 
*                      IN BUFFER
*         REC$IRRL = INTERNAL RECORD LENGTH.
* 
*     DOES- 
*         GENERATE INTERMEDIATE MERGE CODE PART 1 
* 
*         GENERATED CODE IS-
* 
*         "INTMRG":          A1=ADDR OF ACTUAL PARAMETER LIST 
*                             FOR (WSA$,IMTBL$) 
*                (ENTRY/EXIT WORD)
*                B1 SET TO CONSTANT 1 
*                B2 SET TO ADDR OF WSA$ 
*                "IMTBL" SET TO ADDRESS OF IMTBL$ 
*                "MAXNFILE" SET TO MAX NO FILES FOR ALL MERGE PASSES
*                "NSECTS" SET TO NO OF SECTIONS IN IMTBL$ 
*         "INTMRG1":         B1=1 
*                            B2=WSA$
*                "NPASSES" SET TO NO PASSES FOR THIS SECTION (VIA IMTBL$) 
*                "ADDRPASS" SET TO POINT TO FIRST PASS (VIA IMTBL$) 
*         "INTMRG2":         B1=1 
*                            B2=WSA$
*                "NFILES" SET TO NO OF FILES FOR THIS PASS (VIA "IMTBL")
*                SET <LOCAL B3> TO NO OF INPUT FILES (VIA "NFILES") 
*                SET <LOCAL A5> TO "ADDRPASS" 
*                SET <LOCAL A6> TO ADDRESS OF FIRST FET (VIA "ADDRPASS")
*                SET <LOCAL X6> TO ADDRESS FOR FIRST CIO BUFFER 
*                    (VIA B2,B3 AND "NFILES") 
*                FORM OUTPUT FET WITH INFO VIA <LOCAL A5> AND 
*                    <LOCAL X6>, AND STORE WITH <LOCAL A6>
*                    (INCREMENTING <LOCAL A6> TO POINT TO NEXT FET) 
*                FOR EACH INPUT FILE (I.E. WHILE <LOCAL B3> IS "0 ),
*                    INCREMENT <LOCAL A5> 
*                    FORM INPUT FET WITH INFO VIA <LOCAL A5> AND
*                        <LOCAL X6>, AND STORE WITH <LOCAL A6>
*                        (INCREMENTING <LOCAL A6> TO POINT TO NEXT FET) 
*                    REWIND THE FILE (VIA FET)
*                    INITIATE READING OF THE FILE (VIA FET) 
*                INITIALIZE TOUNAMENT VIA B2 AND "NFILES" 
*         "INTMRG3":         B1=1 
*                            B2=WSA$
*                            X6=DESCRIPTOR OF LAST WINNNER
*                X5 SET TO RECORD NO FROM X6
*                X2 SET TO TOURNAMENT INDEX VIA "NFILES" AND X5 
*                A0 SET TO ADDR OF INPUT FET (VIA B2, X5 AND "NFILES")
*                "SAVEAD" SET TO ADDR OF REMAINDER OF RECORD
*                    ASSOCIATED WITH X6 IN INPUT BUFFER (VIA A0)
* 
*                            (REGISTERS LEFT AS ABOVE INCLUDING X5) 
* 
  
  
          ENTRY  S$GNIM1
 S$GNIM1  SUBR               ENTRY/EXIT WORD
          SB1    1           CONSTANT 1 
  
* GET AND SAVE PARAMETERS 
* 
          SA2    X1          X2=VALUE OF *LR* 
          SB2    X2          SAVE IN B2 
          SA2    A1+B1       ADDR OF LONGKEY
          SA2    X2          X2=VALUE OF LONGKEY
          SB3    X2 
          SA4    A1+2        ADDR OF IRRL 
          SA4    X4          X4 = VALUE OF IRRL 
* 
  
          GENLBL INTMRG 
          GENMAC (DATA -0)             *ENTRY/EXIT WORD 
          GEN    (SB1 1)               *CONSTANT 1
          GEN    (SB2 X1)              *SAVE ADDR OF WSA$ IN B2 
  
                                       **SAVE ADDRESS OF IMTBL$ 
          GEN    (SA2 A1+B1)
          GEN    (BX6 X2)              *X6=ADDR OF IMTBL$ 
          NEWLBL IMTBL
          GEN    (SA6 "IMTBL")         *SAVE IN LOCAL IMTBL 
  
                                       **SAVE MAX NUMBER OF INPUT 
                                       *  FILES AT MAXNFILE 
                                       *  AND NO OF SECTIONS AT NSECTS
  
          GEN    (SA2 X6)              *X2=30/NOSECTIONS,30/MAXNFILES 
          GEN    (MX0 30) 
          GEN    (BX7 -X0*X2) 
          NEWLBL MAXNFILE 
          GEN    (SA7 "MAXNFILE")      *SAVE IN MAXNFILE
          GEN    (BX7 X0*X2)
          GEN    (LX7 30)              *RIGHT-JUSTIFY NO SECTIONS 
          NEWLBL NSECTS 
          GEN    (SA7 "NSECTS")        *SAVE IN NSECTS
  
          GENLBL INTMRG1
                                       **NPASSES=NO OF PASSES FROM IMTBL
          GEN    (SA2 "IMTBL")         *X2= ADDRESS OF IMTBL$ 
          GEN    (SA2 X2+B1)           *X2= NO OF PASSES
          GEN    (BX7 X2) 
          NEWLBL NPASSES
          GEN    (SA7 "NPASSES")
                                       **POINT ADDRPASS TO FIRST PASS 
          GEN    (SX7 A2+B1)           *X7= ADDRESS OF 1ST PASS 
          NEWLBL ADDRPASS 
          GEN    (SA7 "ADDRPASS") 
  
          GENLBL INTMRG2
                                       **FOR THIS PASS, GENERATED CODE DOES-
                                       *   SET FETS FOR OUTPUT FILE 
                                       *   AND FOR NFILES INPUT FILES 
                                       *   ALLOCATE SPACE FOR TRN AND BUFFERS 
                                       *   REWIND EACH INPUT FILE AND 
                                       *   DOES FIRST READ TO FILL BUFFERS
  
          GEN    (SA5 "ADDRPASS")      *X5 = ADDRESS OF THIS PASS 
          GEN    (SA5 X5)              *X5=30/NFILES,12/FILENO,18/BUFSIZE 
          GEN    (LX5 30) 
          GEN    (MX0 30) 
          GEN    (BX6 -X0*X5)          *RIGHT-JUSTIFY NFILES
          NEWLBL NFILES 
          GEN    (SA6 "NFILES")        *SAVE AT "NFILES"
          GEN    (SB3 X6)              *KEEP COPY IN B3 
  
          GEN    (LX5 12) 
          GEN    (MX0 48) 
          GEN    (BX3 -X0*X5)          *RIGHT-JUSTIFY FILENO
                                       *SET FILENAME (ZZZZZ1A,ZZZZZ3T)
                                       *  FOR FILENO 1-72 
          NEWLBL ZZZZZ1 
          GEN    (SA4 "ZZZZZ1")        *GET LFN TEMPLATE
  
          GENLBL LABEL1 
          GEN    (SX1 X3-26)           *TEST IF FILENO<=26
  
          NEWLBL LABEL2 
          GEN    (NG X1,"LABEL2")      *IF FILENO<=26 
          GEN    (ZR X1,"LABEL2") 
  
          GEN    (BX3 X1) 
          GEN    (MX0 1)               *CHANGE 1A TO 2B,
          GEN    (LX0 25)              *  2Z TO 3A BY ADDING 1
          GEN    (IX4 X4+X0)           *  AT THE PROPER POSITION
          GEN    (EQ "LABEL1")         *BACK TO TEST FILENO AGAIN 
  
          GENLBL LABEL2 
          GEN    (LX3 18)              *SHIFT TO CORRECT POS. 
          GEN    (BX7 X4+X3)           *OR IN WITH LFN
          GEN    (SA7 B2+B3)           *SET LFN OF OUTPUT FET 
                                       *    AT WSA$ + LTRN
                                       *SAVE ADDR OF OUTPUT FET AT "FETS" 
          GEN    (SX6 A7) 
          NEWLBL FETS 
          GEN    (SA6 "FETS") 
                                       *SET X6 TO ADDR OF OUT BUFFER
          GEN    (SX3 B3+B1)           *LTRN+1
          GEN    (SX0 7)               *LEN OF EACH FET 
          GEN    (IX3 X3*X0)           * (LTRN+1)*LEN OF FET
          GEN    (IX6 X6+X3)           *X6=ADDR OF BUFFER 
          GEN    (SA6 A7+B1)           *SET FIRST PTR 
          GEN    (SA6 A6+B1)           *SET IN PTR
          GEN    (SA6 A6+B1)           *SET OUT PTR 
  
          GEN    (LX5 18) 
          GEN    (MX0 42) 
          GEN    (BX5 -X0*X5)          *RIGHT-JUSTIFY BUFFER SIZE 
          GEN    (IX6 X6+X5)
          GEN    (SA6 A6+B1)           *SET LIMIT PTR 
          GEN    (BX3 X6)              *SAVE X6 
          GEN    (MX6 0)               *CLEAR X6 FOR
          GEN    (SA6 A6+B1)           *    LAST 2 WORDS
          GEN    (SA6 A6+B1)           *         OF FET 
          GEN    (SB4 A6)              *SAVE A6 
  
          IFNOS 
          GENMAC (REWIND A7,RECALL)    *REWIND INT. OUTPUT FILE 
          ELSE
          GENMAC (CLOSE A7,,RECALL) 
          GENMAC (OPEN A7,,RECALL)
          ENDIF 
  
          GEN    (BX6 X3)              *RESTORE X6 FROM X3
  
                                       *THIS LOOP SET FETS AND ALLOCATE 
                                       *   FOR NFILES INPUT FILES 
          GENLBL LABEL3 
          GEN    (SA5 A5+B1)           *POINTS TO NEXT FILE DESC
                                       *X5= NPRUS/FILE NO/BUF. SIZE 
          GEN    (LX5 30) 
          GEN    (MX0 30) 
          GEN    (BX2 -X0*X5)          *RIGHT-JUSTIFY PRUNUM
  
          GEN    (LX5 12) 
          GEN    (MX0 48) 
          GEN    (BX3 -X0*X5)          *RIGHT-JUSTIFY FILENO
                                       *SET FILENAME (ZZZZZ1A,ZZZZZ3T)
                                       *  FOR FILENO 1-72 
          GEN    (SA4 "ZZZZZ1")        *GET LFN TEMPLATE
  
          GENLBL LABEL4 
          GEN    (SX1 X3-26)           *TEST IF FILENO<=26
  
          NEWLBL LABEL5 
          GEN    (NG X1,"LABEL5")      *IF FILENO<=26 
          GEN    (ZR X1,"LABEL5") 
  
          GEN    (BX3 X1) 
          GEN    (MX0 1)               *CHANGE 1A TO 2B,
          GEN    (LX0 25)              *  2Z TO 3A BY ADDING 1
          GEN    (IX4 X4+X0)           *  AT THE PROPER POSITION
          GEN    (EQ "LABEL4")         *BACK TO TEST FILENO AGAIN 
  
          GENLBL LABEL5 
          GEN    (LX3 18)              *SHIFT TO CORRECT POS. 
          GEN    (BX7 X4+X3)           *OR IN WITH LFN
  
          GEN    (SA7 B4+B1)           *SET LFN FOR INPUT FET 
                                       *SET FET WORD 1 FOR RANDOM 
                                       *  READ AT PRUNUM
          NEWLBL ZZZZZ2 
          GEN    (SA3 "ZZZZZ2")        *GET TEMPLATE FOR FET WD 1 
          IFNOS 
          GEN    (BX6 X6+X3)           *OR IN W/ FIRST PTR
          ELSE
          GEN    (BX3 X6) 
          GEN    (SX6 X6) 
          ENDIF 
          GEN    (SA6 A7+B1)           *SET WORD 1 OF FET 
          GEN    (SX6 X6)              *KEEP LO 18 BITS 
          GEN    (SA6 A6+B1)           *SET IN PTR
          GEN    (SA6 A6+B1)           *SET OUT PTR 
  
          GEN    (LX5 18) 
          GEN    (MX0 42) 
          GEN    (BX5 -X0*X5)          *RIGHT-JUSTIFY BUFFER SIZE 
          GEN    (IX6 X6+X5)
          GEN    (SA6 A6+B1)           *SET LIMIT PTR 
  
          IFNOSBE 
          GEN    (SB4 A6) 
          GEN    (SB5 X6) 
          GEN    (BX4 X2) 
          GENMAC (CLOSE A7,,RECALL) 
          GENMAC (OPEN A7,,RECALL)
          GEN    (BX6 X3) 
          GEN    (SA2 "ZZZZZ2") 
          GEN    (BX6 X6+X2)
          GEN    (SA6 A7+B1)
          GEN    (SX6 B5) 
          GEN    (SA6 B4) 
          GEN    (BX2 X4) 
          ENDIF 
          GEN    (BX3 X6)              *SAVE X6 
          GEN    (MX6 0)               *CLEAR WORD 5
          GEN    (SA6 A6+B1)           *    OF FET
          GEN    (BX6 X2)              *PRUNUM FOR RANDOM READ
          GEN    (SA6 A6+B1)           *SET FET WORD 6
          GEN    (BX6 X3)              *RESTORE X6
  
          GEN    (SX6 X6+0),B3         *RESERVE *LONGKEY* WORDS AT END
                                       *   OF BUFFER FOR GNCMPC 
  
          GEN    (SB4 A6)              *SAVE A6 IN B4 
          GEN    (SB5 X6)              *SAVE X6 IN B5 
  
          GENMAC (READ A7,RECALL)      *DO RANDOM READ ON INPUT FILE
  
                                       *COPY LONGKEY WORDS FROM 
                                       *  FIRST PTR TO LIMIT PTR
                                       *  FOR GNCMPC
          GEN    (SA3 A7+B1)           *FET WORD 1
          GEN    (SA3 X3)              *FIRST PTR 
          GEN    (SA4 A7+4)            *FET WORD 4
          GEN    (SA4 X4)              *LIMIT PTR 
          GEN    (SB7 0),B3            *LONGKEY WORDS 
          GEN    (SB6 B0) 
          NEWLBL NEXT 
          GENLBL NEXT 
          GEN    (SA2 A3+B6)           *MOVE WORD FROM FIRST PTR
          GEN    (BX6 X2)              *    TO
          GEN    (SA6 A4+B6)           *   LIMIT PTR
          GEN    (SB6 B6+B1)           *INCREMENT COUNT 
          GEN    (LT B6,B7,"NEXT")     *IF NOT LONGKEY WORDS YET
  
  
          GEN    (SX6 B5)              *RESTORE X6 FROM B5
  
                                       *NOW CLEAR RANDOM REQUEST
                                       *  SO SUBSEQUENT READS ON
                                       *  THIS FILE ARE SEQUENTIAL
          GEN    (SA1 A7+B1)           *FET WORD 1
          GEN    (SX7 X1)              *KEEP LO 18 BITS FIRST PTR 
          GEN    (SA7 A1)              *WRITE BACK TO FET WORD 1
  
          GEN    (SB3 B3-B1)
          GEN    (NE B3,B0,"LABEL3")   *IF NOT NFILES,LOOP
  
                                       *INITIALIZE TRN TO ZERO
          GEN    (SA1 "NFILES")        *X1=LTRN 
          GEN    (SB3 X1-1)            *LTRN-1
          GEN    (MX7 0)               *ZERO WORD MASK
  
          GENLBL INT1 
          GEN    (SA7 B2+B3)
          GEN    (SB3 B3-B1)           *DECREMENT INDEX 
          GEN    (GE B3,B0,"INT1")     *IF MORE WORDS IN TRN,LOOP 
  
                                       *INITIALIZE TRN TO NULL ENTRIES
          GEN    (SB3 X1)              *LTRN
          GEN    (SB4 B0) 
  
  
          GENLBL INT2 
          GEN    (SB4 B4+B1)
          GEN    (SX2 B4+B1)           * RN+1 
          GEN    (AX2 1)               * (RN+1)/2 
          GEN    (IX2 X1-X2)           * LTRN-(RN+1)/2
  
          GENLBL INT3 
          GEN    (SA3 X2+B2)           *X3=TRN ENTRY
          NEWLBL INT4 
          GEN    (ZR X3,"INT4")        *IF ZERO ENTRY,SKIP
          GEN    (AX2 1)               *NEXT LEVEL
          GEN    (PL X2,"INT3")        *CHECK ENTRY AT NEXT LEVEL 
          GEN    (PS)                  *** DEBUG TRAP *** 
  
          GENLBL INT4 
          GEN    (SX2 B4)              *X2=RN 
          SB7    -B2         -LR
          GEN    (LX2 60-1-1),B7       * 60-1-1-LR
          GEN    (MX0 1)               *SET BIT 59TH
          GEN    (BX6 X0+X2)
          GEN    (SA6 A3)              *DEPOSIT ENTRY IN TRN
          GEN    (LT B4,B3,"INT2")     *IF MORE TRN ENTRY,LOOP
* 
  
          GENLBL INTMRG3
          SB3    -B2         -LR
          GEN    (LX6 1+1),B2          *LX6 1+1+LR
          GEN    (MX0 60),B3           * -LR
          GEN    (BX5 -X0*X6)          *MASK OUT TO GET RN
  
          GEN    (SX0 7)               *LEN OF EACH FET 
          GEN    (IX0 X0*X5)           * RN*(LEN OF FET)
          GEN    (SA1 "NFILES")        *X1=LTRN 
          GEN    (IX0 X0+X1)
          GEN    (SA0 X0+B2)           *A0=ADDR OF INPUT FET
  
          GEN    (SX2 X5+B1)           *RN+1
          GEN    (AX2 1)               * (RN+1)/2 
          GEN    (SA1 "NFILES")        * X1=NFILES/LTRN 
          GEN    (IX2 X1-X2)           *LTRN-(RN+1)/2 
  
  
          EXIT
          END 
