*DECK S$GNFM1 
          IDENT  S$GNFM1
          TITLE  S$GNFM1  - GENERATE FINAL MERGE CODE PART 1
          COMMENT  GENERATE FINAL MERGE CODE PART 1.
  
*CALL LBLPTR
  
          B1=1
  
  
**        S$GNFM1  - GENERATE FINAL MERGE CODE PART 1 
* 
*     CALLING SEQUENCE- 
*         S$GNFM1(WSAF$LTRN, REC$LR, SPEC$OUTFIT, WSAF$OREC,
*                                      SPEC$FASTOUT); 
* 
*     GIVEN-
*         WSAF$LTRN = NUMBER OF TOURNAMENT ENTRIES
*         REC $LR   = NUMBER OF BITS TO HOLD
*                      INDEX TO RECORD STORAGE AREA 
*         SPEC$OUTFIT = ADDRESS OF OUTPUT FIT, OR ZERO
*         WSAF$OREC = OFFSET OF AREA TO HOLD EXTERNAL RECORD
*         SPEC$FASTOUT " 0 IF FAST OUTPUT TO BE DONE. 
* 
*     DOES- 
*         GENERATE FINAL MERGE CODE PART 1
* 
*         GENERATED CODE DOES-
*         SAVE ADDRESS OF WSA$
*         OPEN OUTPUT FILE, IF ANY. 
*         ADD ADDRESS OF WSA$ TO FET POINTERS 
*         REWIND EACH FILE
*         INITIALIZE TRN TO NULL ENTRIES: 1/1, LR/RN , ... /0 
*         SET X6 TO LAST RECORD INITIALIZED (ARBITRARY WINNER)
* 
  
  
          ENTRY  S$GNFM1
 S$GNFM1  SUBR               ENTRY/EXIT WORD
          SB1    1           CONSTANT 1 
  
* GET AND SAVE PARAMETERS 
* 
          SA2    X1          X2=VALUE OF *LTRN* 
          SA0    X2          SAVE IN A0 
          SA2    A1+B1       X2=ADDR OF *LR*
          SA2    X2          X2=VALUE OF *LR* 
          SB2    X2          SAVE IN B2 
          SA2    A1+2        ADDRESS OF SPEC$OUTFIT 
          SA2    X2          VALUE OF SPEC$OUTFIT 
          SB3    X2          B3= SPEC$OUTFIT
          SA2    A1+3        ADDRRESS OF WSAF$OREC
          SA2    X2          VALUE OF WSAF$OREC 
          SB4    X2          B4= WSAF$OREC
          SA2    A1+4        ADDRESS OF SPEC$FASTOUT
          SA2    X2          VALUE OF SPEC$FASTOUT
          SB5    X2          B5 = SPEC$FASTOUT
* 
  
          GENLBL FNLMRG 
          GENMAC (DATA -0)             *ENTRY/EXIT WORD 
          GEN    (SB1 1)               *CONSTANT 1
                                       *SAVE ADDR OF WSA
          GEN    (BX6 X1) 
          NEWLBL WSA
          GEN    (SA6 "WSA")
          GEN    (SB2 X1)              *SAVE IN B2
  
                                       *OPEN OUTPUT FILE, IF ANY
          IFTHEN B3"0        IF WE HAVE AN OUTPUT FILE
            GEN  (SX6 B2+0),B4         *X6=ADDR FOR EXTERNAL RECORD 
            GEN    (SA0 0),B3          *A0 = ADDRESS OF OUTPUT FIT
            GENMAC (STORE A0,WSA=X6)
            GENMAC (STORE A0,PD=IO) 
            GENMAC (FETCH A0,OC,X5)    *CHECK WHETHER FILE IS OPEN
            GEN    (SX5 X5-1)            * 1=#OPE#,CODE FOR OPENED
            NEWLBL INT1 
            GEN    (ZR X5,"INT1")        *IF ALREADY OPENED 
  
            IFTHEN B5"0        IF FAST OUTPUT IS TO BE DONE,
              GENMAC (FETCH A0,BFS,X2) *X2 = SIZE OF BUFFER 
              GEN    (SB2 X2)          *PRESERVE BFS IN B2
              GEN    (MX3 0)           *X3 = GROUP-ID, SIZE-CODE
              GEN    (CALL CMM.ALF)    *SET X1 = BLOCK FWA
                     *SAVES AX0,X5,B2-3 
              GENMAC (STORE A0,FWB=X1)
                     *USES AX5-6,X7 
              GEN    (SX6 X1) 
              GEN    (SA6 A0+2)        *IN
              GEN    (SA6 A6+B1)       *OUT 
              GEN    (SX1 X1+B2)       *FWB + BFS 
              GEN    (SA5 A6+B1)       *WORD WITH LIMIT 
              GEN    (MX6 -18)
              GEN    (BX6 X6*X5)
              GEN    (BX6 X6+X1)
              GEN    (SA6 A5)          *LIMIT 
              GEN    (MX6 1)             *CLEAR EP BIT FOR FASTIO 
              GEN    (LX6 45) 
              GEN    (SA5 A0+1)          *EP BIT IS IN FET + 1
              GEN    (BX6 -X6*X5)        *CLEAR EP BIT IN FET 
              GEN    (SA6 A5)            *STORE BACK IN FET + 1 
              ENDIF.
          IFTHEN B5=B0    IF RECORD MANAGER TO BE USED
            NEWLBL NEXT 
#HAVEB6     SET    1
            GEN    (SB6 "NEXT") 
            GENMAC (FETCH A0,OF,X1) 
            GEN    (SB2 X1) 
            GEN    (SB2 B2-B1)      B2-#R#
            NEWLBL NEXT2
            GEN    (EQ B2,B0,"NEXT2") 
            GEN    (SB3 2)
            NEWLBL NEXT1
            GEN    (EQ B2,B3,"NEXT1") 
            GENMAC (OPENM A0,OUTPUT,N)
            GENLBL NEXT1
            GENMAC (OPENM A0,OUTPUT,E) #EXTEND# 
            GENLBL NEXT2
            GENMAC (OPENM A0,OUTPUT,R)
            GENLBL NEXT 
            ENDIF.
            GENLBL INT1 
  
            GEN    (SA2 "WSA")
            GEN    (SB2 X2) 
            ENDIF.
  
*     GENERATE CODE TO ADD ADDR OF WSA$ TO FET POINTERS 
*       AND TO REWIND EACH FILE 
  
          SX1    A0-1        LTRN-1 
          SX2    7           LEN OF FET 
          IX1    X1*X2       (LTRN-1)*5 
          SB7    X1 
          GEN    (SB3 0),B7            *SB3 (LTRN-1)*5
          GEN    (SX5 B2)              *ADDR OF WSA$
  
          NEWLBL NEXT 
          GENLBL NEXT 
          NEWLBL FETS 
          GEN    (SA0 B3+"FETS")       *ADDR OF A FET 
  
          GEN    (SA3 A0+B1)           *FIRST PTR OFFSET
          GEN    (SX3 X3)         *KEEP LOW 18 BITS 
          GEN    (IX7 X3+X5)           *ADD IN WSA ADDR 
          GEN    (SA7 A3)              *WRITE BACK ACTUAL PTR 
  
          GEN    (SA3 A3+B1)           *IN PTR OFFSET 
          GEN    (IX7 X3+X5)           *ADD IN WSA ADDR 
          GEN    (SA7 A3)              *WRITE BACK ACTUAL PTR 
  
          GEN    (SA3 A3+B1)           *OUT PTR OFFSET
          GEN    (IX7 X3+X5)           *ADD IN WSA ADDR 
          GEN    (SA7 A3)              *WRITE BACK ACTUAL PTR 
  
          GEN    (SA3 A3+B1)           *LIMIT PTR OFFSET
          GEN    (IX7 X3+X5)           *ADD IN WSA ADDR 
          GEN    (SA7 A3)              *WRITE BACK ACTUAL PTR 
  
  
          GENMAC (REWIND A0)
          GEN    (SA3 A0+B1)           *FET WORD 1
          NEWLBL ZZZZZ2 
          GEN    (SA4 "ZZZZZ2")        *GET RANDOM READ TEMPLATE
          GEN    (BX7 X3+X4)           *SET IN FET WORD 1 
          GEN    (SA7 A3) 
  
          GENMAC (READ A0,RECALL) 
          GEN    (SA3 A0+B1)           *FET WORD 1
          GEN    (SX7 X3)              *CLEAR RANDOM READ REQUEST 
          GEN    (SA7 A3)              *WRITE BACK
          GEN    (SB3 B3-7)            *GO UP 1 FET 
          GEN    (GE B3,B0,"NEXT")
  
                                       *INITIALIZE TRN TO ZERO
          SB7    A0-1        LTRN-1 
          GEN    (SB3 0),B7            *LTRN-1
          GEN    (MX7 0)               *ZERO WORD MASK
  
          GENLBL FNL1 
          GEN    (SA7 B2+B3)
          GEN    (SB3 B3-B1)           *DECREMENT INDEX 
          GEN    (GE B3,B0,"FNL1")     *IF MORE WORDS IN TRN,LOOP 
  
                                       *INITIALIZE TRN TO NULL ENTRIES
          GEN    (SB3 0),A0            *LTRN
          GEN    (SX1 B3)              *COPY OF LTRN IN X1
          GEN    (SB4 B0) 
  
  
          NEWLBL FNL4 
          GENLBL FNL2 
          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 FNL3 
          GEN    (SA3 X2+B2)           *X3=TRN ENTRY
          GEN    (ZR X3,"FNL4")        *IF ZERO ENTRY,SKIP
          GEN    (AX2 1)               *NEXT LEVEL
          GEN    (PL X2,"FNL3")        *CHECK ENTRY AT NEXT LEVEL 
          GEN    (PS)                  *** DEBUG TRAP *** 
  
          GENLBL FNL4 
          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,"FNL2")     *IF MORE TRN ENTRY,LOOP
  
          NEWLBL FNLMRG2
          GEN    (EQ "FNLMRG2")        *GOTO FNLMRG PART 2
  
          GENLBL ZZZZZ2 
          GENMAC (VFD 13/1,29/2,18/0)  *RANDOM READ ON
  
          NEWLBL PRUEOD 
          GENLBL FNLMRG1
  
          EXIT
          END 
