*DECK S$GNPIB 
          IDENT  S$GNPIB
          TITLE  S$GNPIB  - GENERATE PUT INTERNAL RECORD CODE 
          COMMENT  GENERATE PUT INTERNAL RECORD CODE. 
  
*CALL LBLPTR
  
*         LF = NUMBER OF NON-KEY, NON-SUM BITS IN FIXED PART
*              (I.E. REC$LF1 + REC$LF2) 
  
  
**        S$GNPIB  - GENERATE PUT INTERNAL RECORD CODE
* 
*     CALLING SEQUENCE- 
*         S$GNPIB(SPEC$FIXED, REC$IRRL, REC$LF, OFFSET, LL, LF);
* 
*     GIVEN-
*         SPEC$FIXED = TRUE IF FIXED LENGTH RECORDS 
*         REC$IRRL  = INTERNAL RECORD LENGTH. 
*         REC$LR = NO OF BITS TO SPECIFY RECORD NUMBER (RN) 
*         OFFSET = BIT OFFSET TO BEGINNING OF LENGTH FIELD
*                  (I.E. 1+1+LR+LK+LO)
*         LL = LENGTH OF LENGTH FIELD 
*              (I.E. REC$LL1 + REC$LL2) 
*         LF = NUMBER OF BITS IN RECORD BEYOND LAST KEY/SUM/ORD 
*              (I.E. REC$LF1 + REC$LF2) 
* 
*     DOES- 
*         GENERATE CODE TO PUT RECORD TO INTERNAL OUTPUT FILE.
* 
*     GENERATED CODE IS-
* 
*         "PRIENTRY": 
*                            B2=ADDR OF WSA/TRN 
*                            X6=DESCRIPTOR OF LAST WINNER TO BE 
*                                  WRITTEN TO INTERNAL OUTPUT FILE
* 
*                SET <A0> TO OUTPUT FET VIA "FETS"
*                SAVE X6 AT "RECDESC" 
*                IF X6=0, FLUSH OUPUT BUFFER VIA A0 AND GOTO "PRIDONE". 
* 
*                SET <X2> TO N=NO OF WORDS TO MOVE. 
*                SET <A1> TO ADDR OF FET OF *IN* (INPUT FILE) 
*                                     VIA B2 AND "NFILES".
*         "PRIMOVE1": 
*                SET <A3>, <A4> TO IN AND OUT PTR OF OUTPUT FET VIA A0. 
*                SET <X5> TO IN-OUT VIA X3,X4.
*                IF IN>=OUT FOR *OUT* (OUTPUT FILE) 
*                  THEN GO TO "INAHEAD".
*                  ELSE SET <X0> TO N-(OUT-IN) FOR *OUT*
*                       IF <X5> < 0 (I.E. N<(OUT-IN) OR ENOUGH ROOM FOR N), 
*                         THEN GOTO "PRIMOVE2" TO CHECK ON *IN* 
*                         ELSE GO TO "WRITEBUF".
*         "INAHEAD":  
*                SET <A5> TO LIMIT PTR FOR *OUT* (OUTPUT FILE) VIA A4 
*                SET <X0> TO (LIMIT-IN)-N VIA X0,X3,X5. 
*                IF X0>=0 (I.E. (LIMIT-IN)>N OR ENOUGH ROOM FOR N)
*                  THEN GOTO "PRIMOVE2" TO CHECK ON *IN*
*                  ELSE SET <B4> TO <A1> TO SAVE FET ADDR OF *IN* 
*                      SET <A1> TO FIRST PTR OF *OUT* 
*                      SET <X7> TO OUT-FIRST (X4-X1) OF *OUT* 
*                      SET <X0> TO <X0>+<X7> ((LIMIT-IN)-N+(OUT-FIRST)) 
*                      SET <A1> TO ADDR OF INPUT FET VIA <B4> 
*                      IF <X0> <= 0 THEN GOTO "WRITEBUF"
                                    ELSE SET <A5> TO OUT PTR OF *OUT* 
*                                        GOTO "PRIMOVE5" TO MOVE EA. WORD 
*         "WRITEBUF": 
*                SAVE X6 IN <B4>
*                WRITE OUTPUT BUFFER TO FILE
*                RESTORE X6 FROM <B4> 
*                GOTO "PRIMOVE1". 
*         "PRIMOVE2": 
*                SET <A1> TO ADDR OF INPUT FET USING RN (IN X5) AND "NFILES"
*                SET <A4> TO IN PTR FOR *IN* (INPUT FILE) VIA <A1>
*                SET <A5> TO OUT PTR OF *IN* VIA <A4> 
*                SET <X0> TO IN-OUT FOR *IN* VIA <X4> AND <X5>
*                IF <X0> < 0 (IN<OUT) FOR *IN*
*                  THEN GO TO "PRIMOVE3"
*                  ELSE SET <X0> TO N-(IN-OUT) VIA <X2>,<X0>
*                       IF <X0> < 0 (N<(IN-OUT)) FOR *IN* 
*                         THEN GOTO "PRIMOVE4" TO MOVE N WORDS
*                         ELSE GOTO "PRIMOVE5" TO MOVE WORD-BY-WORD 
*         "PRIMOVE3": 
*                SET <A4> TO LIMIT PTR FOR *IN* VIA <A5>. 
*                SET <X0> TO LIMIT-OUT FOR *IN* VIA <X4> AND <X5>.
*                SET <X0> TO N-(LIMIT-OUT) FOR *IN* VIA <X2> AND <X0> 
*                IF <X0> < 0 (NOT N CONTINUOUS WORDS IN *IN* BUFFER)
*                  THEN GOTO "PRIMOVE5" TO MOVE WORD-BY-WORD
*         "PRIMOVE4": 
*                MOVE WORD IN X6 TO *OUT* BUFFER AT <X3>. 
*                INCR IN PTR OF *OUT* (X3=X3+1) 
*                SET <B3> TO N=NO OF WORDS TO MOVE. 
*                WHILE COUNT <B3> > 0 DO
*                  MOVE WORD AT OUT PTR OF *IN* TO WORD 
*                            AT IN PTR OF *OUT* VIA <X3> AND <X5>.
*                  INCR. OUT PTR FOR *IN* AND IN PTR FOR *OUT*. 
*                  DECREMENT COUNT <B3>.
*                UPDATE IN PTR FOR *OUT* VIA <A3> AND <X3>. 
*                UPDATE OUT PTR FOR *IN* VIA <A5> AND <X5>. 
*                GOTO "PRIDONE" TO EXIT.
*         "PRIMOVE5": 
*                MOVE WORD IN X6 TO *OUT* BUFFER AT X3. 
*                INCR. IN PTR OF *OUT* VIA <X3>.
*                SET COUNT <B3> TO N=NO OF WORDS TO MOVE. 
*                WHILE COUNT <B3> > 0 DO
*                  MOVE WORD AT OUT PTR OF *IN* TO WORD 
*                            AT IN PTR OF *OUT* VIA <X3> AND <X5>.
*                  INCR. IN PTR OF *OUT* VIA <X3>.
*                  INCR. OUT PTR OF *IN* VIA <X5>.
*                  IF INLIMIT (FOR *OUT*) THEN SET IN=FIRST 
*                  IF OUT=LIMIT (FOR *IN*) THEN SET OUT=FIRST 
*                  DECREMENT COUNT <B3>.
*                UPDATE IN PTR FOR *OUT* VIA <A3> AND <X3>. 
*                UPDATE OUT PTR FOR *IN* VIA <A5> AND <X5>. 
*         "PRIDONE":  
*                RESET X6 FROM "RECDESC". 
* 
*         GENERATED CODE USES:  
*                B    * * 3 4 5 6 -    *B1=1, *B2=WSA$
*                X  0 1 2 3 4 5 6 7 
*                A  0 1 2 3 4 5 6 7 
* 
*         MEANING OF REGISTERS IN GENERATED CODE: 
*                *B1 = 1
*                *B2 = WSA$ 
*                *B3 = COUNT, OR TO SAVE A1 
*                *B4 = TO SAVE A1 
*                *B5 = TO SAVE X2 
*                *B6 = FLAG FOR VARIABLE-LENGTH RECORDS 
*                       0 => LOOKING FOR LENGTH FIELD 
*                      >0 => LOOKING FOR RIGHT PART OF LENGTH FIELD 
*                            (*B6 = VALUE OF LEFT PART) 
*                      <0 => LOOKING FOR END OF RECORD
*                *A0 = ADDRESS OF FET FOR OUTPUT BUFFER 
*                *A1 = ADDRESS OF FET FOR INPUT BUFFER
*                *A3 = ADDRESS OF *IN* FET POINTER FOR OUTPUT BUFFER
*                *X3 = VALUE OF *IN* FET POINTER FOR OUTPUT BUFFER
*                *A5 = ADDRESS OF *OUT* FET POINTER FOR INPUT BUFFER
*                *X5 = VALUE OF *OUT* FET POINTER FOR INPUT BUFFER
*                *X6 = DESCRIPTOR 
  
  
          ENTRY  S$GNPIB
 S$GNPIB  SUBR               ENTRY/EXIT WORD
          SB1    1           CONSTANT 1 
  
* GET AND SAVE PARAMETERS 
* 
          SA4    X1          X4 = SPEC$FIXED
          SA5    A1+B1       ADDRESS OF *IRRL*
          SA5    X5          X5 = IRRL
          SA2    A1+2        ADDRESS OF *LR*
          SA2    X2          VALUE OF *LR*
          SB2    X2          B2 = LR
          SA2    A1+3        ADDRESS OF *OFFSET*
          SA2    X2          VALUE OF *OFFSET*
          SB5    X2          B5 = OFFSET FROM BEG. OF REC, THEN FROM WORD 
          SA2    A1+4        ADDRESS OF *LL*
          SA2    X2          VALUE OF *LL*
          SB3    X2          B3 = LL
          SA2    A1+5        ADDRESS OF *LF*
          SA2    X2          VALUE OF *LF*
          BX6    X2 
          SA6    LF          LOCAL VARIABLE *LF* := PARAMETER *LF*
* 
          GENLBL PRIENTRY 
         *USES   AX1-3,AX6,B6,B7
  
          NEWLBL NEXT 
          NEWLBL INVERT 
          GEN    (EQ "NEXT")
          GENLBL INVERT 
          GENMAC (DATA 0) 
          NEWLBL VERIFY 
          GENLBL VERIFY 
          GENMAC (DATA 0) 
          GENLBL NEXT 
                                       * SET A0=ADDR OF OUTPUT FET
          GEN    (SA1 "FETS")          *X1=ADDR OF FET
          GEN    (SA0 X1) 
         *USES   X0,AX1-3,AX6,B6,B7 
  
          NEWLBL RECDESC
         *USES   AX1,AX6,B6,B7
          GEN    (SA6 "RECDESC")       *SAVE LW AT RECDESC
  
          NEWLBL NEXT 
          GEN    (NZ X6,"NEXT")        *IF X6"0, SKIP FLUSH PART
  
          GENMAC (WRITER A0,RECALL)    *IF X6=0, (I.E. LW=EOD)
                *USES *AX1-2,*AX6-7 
         *USES   AX1-AX3,AX6,B6,B7
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS,
            GEN    (SB6 -B1)           *DONE WITH RECORD
            ENDIF.
          NEWLBL PRIDONE               *    FLUSH OUTPUT BUFFER 
          GEN    (EQ "PRIDONE") 
  
          GENLBL NEXT 
  
                                       *SET <A1> TO ADDR OF INPUT FET 
          GEN    (BX5 X6)              *COPY IN X5
          GEN    (LX5 1+1),B2          *LX5 1+1+LR
          SB7    -B2         -LR
          GEN    (MX0 60),B7           *MX0 60-LR 
          GEN    (BX5 -X0*X5)          *MASK TO GET RN
  
          GEN    (SX0 7)               *LEN OF FET
          GEN    (IX0 X0*X5)           * RN*(LEN OF FET)
          GEN    (SA1 "NFILES")        *X1=LTRN 
          GEN    (IX0 X0+X1)
          GEN    (SA1 X0+B2)           *A1=ADDR OF INPUT FET
*     SET X2 = NUMBER OF WORDS TO MOVE
  
          IFTHEN X4"0        IF SPEC$FIXED IS TRUE, 
            GEN    (SX2 1+0),X5        *N=X2 = IRRL + 1 
          ELSE-              IF VARIABLE-LENGTH RECORDS,
            SB7    59 
            IFTHEN B5@B7        IF LENGTH BEGINS IN DESCRIPTOR
              SB7    B5+B3      OFFSET PLUS LL (LENGTH OF LENGTH FLD) 
              SB6    60 
              IFTHEN B7@B6      LENGTH ENTIRELY WITHIN DESC.
                GEN    (BX5 X6)     COPY RECORD DESCRIPTOR
                SB7    B5+B3        OFFSET PLUS LL (LENGTH OF LENGTH FLD) 
                GEN    (LX5 0),B7   RIGHT JUSTIFY LENGTH FIELD
                SB6    60 
                SB7    B6-B3        60 - LL 
                GEN    (MX0 0),B7 
                GEN    (BX2 -X0*X5)     *X2 := LENGTH IN BYTES
              ELSE-                 LENGTH FIELD SPANS TWO WORDS
                GEN    (BX5 X6)     COPY RECORD DESCRIPTOR
                GEN    (MX0 0),B5       *MX0 OFFSET 
                GEN    (BX2 -X0*X5)     FIRST PART OF LENGTH FIELD
                GEN    (SB7 X2)         HOLD ON TO IT 
                GEN    (SA2 A1+3)       OUT PTR FOR *IN*
                GEN    (SA2 X2)         GET NEXT RSA WORD 
                SB7    60 
                SB7    B7-B5            60-OFFSET (I.E. 60-58 = 2)
                SB7    B3-B7            LL-(60-OFFSET) I.E. 9-2 
                GEN    (MX0 0),B7       I.E. MX0 7
                GEN    (BX2 X0*X2)      SECOND PART OF LENGTH 
                SB7    60 
                SB7    B7-B5
                SB7    B3-B7
                GEN    (LX2 0),B7 
                GEN    (SX3 B7)         GET BACK FIRST PART 
                SB7    60 
                SB7    B7-B5
                SB7    B3-B7
                GEN    (LX3 0),B7 
                GEN    (BX2 X2+X3)      LENGTH IN BYTES 
                ENDIF.
              SX1    B5+B3       <OFFSET-WITHIN-WORD> + LL
              SA2    LF 
              IX1    X1+X2       <OFFSET-WITHIN-WORD> + LL + LF 
              GEN    (SX1 0),X1  *OFFSET + LL + LF
              GEN    (SX0 6)
              GEN    (IX0 X0*X2) *VARIABLE LENGTH IN BITS 
              GEN    (IX0 X1+X0) *TOTAL LENGTH OF THIS RECORD IN BITS 
              GEN    (SX1 1S22/60+1)
              GEN    (IX2 X0*X1)
              GEN    (AX2 22)    *TOTAL LENGTH OF THIS RECORD IN WORDS
              GEN    (SX2 X2+B1) *COPY DESCRIPTOR AS WELL 
* 
* NOW SET B6 TO ZERO TO MAKE THE REST OF THE CODE IN THIS 
* MODULE WORK CORRECTLY. REMEMBER THAT THIS IS NOT REALLY A 
* TRUE STATEMENT BY SETTING THE FLAG CALLED *INVERT*. 
* 
              GEN    (SB6 B0)          *WE HAVE FOUND THE LENGTH FIELD
              GEN    (SX7 1)           *FIRST-WORD FLAG 
              GEN    (SA7 "INVERT")    *SET FIRST-WORD FLAG 
            ELSE-                     ( LENGTH NOT IN DESCRIPTOR )
              SX2    B5          OFFSET 
              SX0    1S22/60+1   1/60 * 2**22 
              IX3    X0*X2       OFFSET/60 * 2**22
              AX3    22          OFFSET/60
              GEN    (SX2 1+0),X3       *N=X2 = WORDS UNTIL LENGTH FIELD
              GEN    (BX7 X2) 
              GEN    (SA7 "VERIFY") PRESERVE ORIGINAL COUNT 
              GEN    (SB6 B0)           *STILL LOOKING FOR LENGTH FIELD 
              ENDIF.
            ENDIF.
  
  
*     COPY MORE WORDS FROM *IN* BUFFER TO *OUT* BUFFER
  
          GENLBL PIBCPYWD 
          GEN    (BX5 X6)              *DESCRIPTOR
          GEN    (LX5 1)               *SHIFT BIT 58 TO LEFT-MOST 
          NEWLBL PRIMOVE1 
          GEN    (PL X5,"PRIMOVE1")    *IF BIT 58 NOT SET 
  
*     DELETE RECORD IN *IN* BUFFER BY ADVANCING OUT POINTER 
  
          GEN    (SA3 A1+3)            *OUT PTR FOR *IN* FILE 
          GEN    (SA4 A3+B1)           *LIMIT PTR FOR *IN* FILE 
          GEN    (SX4 X4)              *KEEP LO 18 BITS 
          GEN    (IX7 X3+X2)           *OUT + IRRL
          IFTHEN X4"0        IF SPEC$FIXED IS TRUE, 
            GEN    (SX7 X7-1)          *-1 SINCE 1 WORD IN *X6
          ELSE-              IF VARIABLE-LENGTH RECORDS,
            NEWLBL NEXT 
            GEN    (NZ B6,"NEXT")      *IF NOT AT BEG., SKIP
            GEN    (SX7 X7-1)          *-1 SINCE 1 WORD IN *X6
            GENLBL NEXT 
            GEN    (SA5 X7-1)          *LAST WORD OF THIS SET 
            ENDIF.
          GEN    (IX0 X7-X4)           *CHECK NEW OUT PTR VS LIMIT
          NEWLBL NEXT 
          GEN    (MI X0,"NEXT")        *IF NEW OUT<LIMIT
  
          GEN    (SA4 A1+B1)           *FIRST PTR FOR *IN*
          GEN    (SX4 X4)              *KEEP LO 18 BITS 
          GEN    (IX7 X4+X0)           *BRING NEW OUT IN FRONT OF 1ST 
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS,
            GEN    (ZR X0,"NEXT")      *IF OUT=FIRST, LEAVE *X5 
            GEN    (SA5 X7-1)          *LAST WORD OF THIS SET 
            ENDIF.
  
          GENLBL NEXT 
          GEN    (SA7 A3)              *UPDATE OUT PTR FOR *IN* 
          GEN    (EQ "PRIDONE")        *SKIP PUTTING THIS RECORD
  
  
          GENLBL PRIMOVE1 
          GEN    (SA3 A0+2)            *IN PTR FOR *OUT* (OUTPUT FILE)
          GEN    (SA4 A3+B1)           *OUT PTR FOR *OUT* 
          GEN    (IX5 X3-X4)           * (IN-OUT) 
          NEWLBL INAHEAD
          GEN    (PL X5,"INAHEAD")     *IF IN>=OUT
* 
* CASE IN PTR BEHIND OUT PTR FOR *OUT* (OUTPUT FILE)
* 
          GEN    (IX0 X2+X5)           * N-(OUT-IN) 
          NEWLBL PRIMOVE2 
          GEN    (NG X0,"PRIMOVE2")    *IF ENOUGH ROOM FOR N IN *OUT* BUFFER
                                       *    GOTO CHECK *IN* BUFFER
          NEWLBL WRITEBUF              *      ELSE
          GEN    (EQ "WRITEBUF")       * GOTO WRITE OUTPUT BUFFER 
  
* 
* CASE IN PTR AHEAD OF OUT PTR FOR *OUT* (OUTPUT FILE)
* 
          GENLBL INAHEAD
  
          GEN    (SA5 A4+B1)           *LIMIT PTR FOR *OUT* 
          GEN    (SX5 X5)              *KEEP LO 18 BITS 
          GEN    (IX0 X5-X3)           *LIMIT-IN
          GEN    (IX0 X2-X0)           * N-(LIMIT-IN) 
          GEN    (NG X0,"PRIMOVE2")    *IF ENOUGH ROOM FOR N IN *OUT* BUFFER
                                       *    GOTO CHECK *IN* BUFFER
          GEN    (SB4 A1)              *SAVE A1 IN B4 
          GEN    (SA1 A0+B1)           *FIRST PTR OF *OUT*
          GEN    (SX1 X1)              *KEEP LO 18 BITS 
          GEN    (IX7 X4-X1)           * (OUT-FIRST) FOR *OUT*
          GEN    (SA1 B4)              *RESTORE A1 FROM B4
          GEN    (IX0 X0-X7)           * N-(LIMIT-IN)-(OUT-FIRST) 
          GEN    (PL X0,"WRITEBUF")    *IF NOT ENOUGH ROOM IN BUFFER
          GEN    (SA5 A1+3)            *OUT PTR FOR *IN*
          NEWLBL PRIMOVE5 
          GEN    (EQ "PRIMOVE5")       *GOTO MOVE WORD-BY-WORD
  
          GENLBL WRITEBUF 
          GEN    (SB3 A1)              *SAVE A1 IN B3 
          NEWLBL SAVEX6 
          GEN    (SA6 "SAVEX6") 
          GEN    (SB5 X2)              *SAVE X2 IN B5 
          GENMAC (WRITE A0,RECALL)     *WRITE CIOBUF TO FILE
          GEN    (SA1 "SAVEX6") 
          GEN    (BX6 X1) 
          GEN    (SA1 B3)              *RESTORE A1 FROM B3
          GEN    (SX2 B5)              *RESTORE X2 FROM B5
          GEN    (EQ "PRIMOVE1")
  
                                       *HERE WE HAVE ROOM IN *OUT* BUFFER 
                                       *   FOR N WORDS. CHECK *IN* BUFFER FOR 
                                       *   N CONTINUOUS N WORDS.
  
          GENLBL PRIMOVE2 
  
          GEN    (SA4 A1+2)            *IN PTR FOR *IN* 
          GEN    (SA5 A4+B1)           *OUT PTR FOR *IN*
          GEN    (IX0 X4-X5)           *(IN-OUT) FOR *IN* 
          NEWLBL PRIMOVE3 
          GEN    (NG X0,"PRIMOVE3")    *IF IN<OUT FOR *IN*
          GEN    (IX0 X0-X2)           *(IN-OUT)-N
          NEWLBL PRIMOVE4 
          GEN    (PL X0,"PRIMOVE4")    *IF N<=(IN-OUT)
          GEN    (EQ "PRIMOVE5")       *GOTO MOVE WORD-BY-WORD
  
          GENLBL PRIMOVE3 
          GEN    (SA4 A5+B1)           *LIMIT PTR FOR *IN*
          GEN    (SX4 X4)              *KEEP LO 18 BITS 
          GEN    (IX0 X4-X5)           *LIMIT-OUT FOR *IN*
          GEN    (IX0 X2-X0)           *N-(LIMIT-OUT) 
          GEN    (PL X0,"PRIMOVE5")    *IF NOT N CONTINUOUS WDS IN *IN
                                       *   GOTO MOVE WORD-BY-WORD 
  
                                       *HERE WE HAVE ENOUGH ROOM IN 
                                       *  BOTH BUFFERS TO MOVE
                                       *  N CONTINUOUS WORDS. 
  
          GENLBL PRIMOVE4 
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS,
            GEN    (SB3 X2)            *NUMBER OF WORDS TO MOVE 
            NEWLBL NEXT 
            GEN    (NZ B6,"NEXT")       @*IF NOT FIRST PART, SKIP 
            GEN    (SA6 X3)            *MOVE X6 TO *OUT* BUFFER 
            GEN    (SX3 X3+B1)         *IN := IN + 1 FOR *OUT*
            GEN    (SB3 B3-B1)         *N := N - 1 = NO. OF WORDS TO MOVE 
            GENLBL NEXT 
          ELSE-              IF FIXED-LENGTH RECORDS, 
            GEN    (SA6 X3)            *MOVE X6 TO *OUT* BUFFER 
            GEN    (SX3 X3+B1)         *IN := IN + 1 FOR *OUT*
            GEN    (SB3 X2-1)          *N := N - 1 = NO. OF WORDS TO MOVE 
            ENDIF.
  
          IFTHEN X5"0        IF IRRL<>0 OF REC LONGER THAN 1 WORD 
            IFTHEN X4=0        IF VARIABLE LENGTH RECORDS 
            NEWLBL NEXT 
            GEN    (EQ B3,B0,"NEXT") *CASE OF SHORT VL RECS 
              ENDIF.
  
          GENLBL PRILOOP1 
          GEN    (SA2 X5)              *MOVE WORD AT OUT PTR
          GEN    (BX7 X2)              *   FOR *IN* 
          GEN    (SA7 X3)              *   TO WORD AT IN PTR FOR *OUT*
          GEN    (SX3 X3+B1)           *IN=IN+INDEX FOR *OUT* 
          GEN    (SX5 X5+B1)           *OUT=OUT+INDEX FOR *IN*
          GEN    (SB3 B3-B1)           *DECREMENT COUNT 
          GEN    (NE B3,B0,"PRILOOP1")    *IF MORE WORDS,LOOP 
            IFTHEN X4=0        IF VARIABLE LENGTH RECORDS 
            GENLBL NEXT 
              ENDIF.
  
            ENDIF.
  
          GEN    (BX7 X3)              *UPDATE IN PTR 
          GEN    (SA7 A3)              *   FOR *OUT*
          GEN    (BX7 X5)              *UPDATE OUT PTR
          GEN    (SA7 A5)              *   FOR *IN* 
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS,
            GEN    (SA5 X7-1)          *LAST WORD OF THIS SET 
            ENDIF.
          GEN    (EQ "PRIDONE")        *GOTO EXIT 
  
                                       *MOVE WORD-BY-WORD FROM
                                       *    INPUT BUFFER TO OUTPUT BUFFER 
  
          GENLBL PRIMOVE5 
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS 
            GEN    (SB3 X2)            *NUMBER OF WORDS TO MOVE 
            NEWLBL NEXT 
            GEN    (NZ B6,"NEXT")      *IF NOT FIRST PART, SKIP 
            GEN    (SA6 X3)            *MOVE X6 TO *OUT* BUFFER 
            GEN    (SX3 X3+B1)         *IN := IN + 1 FOR *OUT*
            GEN    (SB3 B3-B1)         *N := N - 1 = NO. OF WORDS TO MOVE 
            GENLBL NEXT 
          ELSE-              IF FIXED-LENGTH RECORDS, 
            GEN    (SA6 X3)            *MOVE X6 TO *OUT* BUFFER 
            GEN    (SX3 X3+B1)         *IN := IN + 1 FOR *OUT*
            GEN    (SB3 X2-1)          *N := N - 1 = NO. WORDS TO MOVE
            ENDIF.
          GEN    (SA2 A3+2)            *LIMIT PTR FOR *OUT* 
          GEN    (SX2 X2)              *KEEP LO 18 BITS 
          GEN    (IX0 X3-X2)           *IN-LIMIT FOR *OUT*
          NEWLBL LABEL3 
          GEN    (NG X0,"LABEL3")      *IF IN<LIMIT FOR *OUT* 
          GEN    (SA2 A0+B1)           *FIRST PTR FOR *OUT* 
          GEN    (SX7 X2)         *KEEP LOW 18 BITS 
          GEN    (SA7 A3)              *SET IN=FIRST FOR *OUT*
          GEN    (BX3 X7)              *NEW IN PTR VALUE (*OUT*)
  
          GENLBL LABEL3 
  
          IFTHEN X5"0        IF IRRL<>0 OF REC LONGER THAN 1 WORD 
            IFTHEN X4=0        IF VARIABLE LENGTH RECORDS 
            NEWLBL NEXT 
            GEN    (EQ B3,B0,"NEXT") *CASE OF SHORT VL RECS 
              ENDIF.
  
          GENLBL PRILOOP2 
          GEN    (SA2 X5)              *MOVE WORD AT OUT PTR
          GEN    (BX7 X2)              *   OF *IN* INTO 
          GEN    (SA7 X3)              *   IN PTR OF *OUT*
          GEN    (SX3 X3+B1)           *INCR. IN PTR OF *OUT* 
          GEN    (SX5 X5+B1)           *INCR. OUT PTR OF *IN* 
          GEN    (SA2 A3+2)            *LIMIT PTR FOR *OUT* 
          GEN    (SX2 X2)              *KEEP LO 18 BITS 
          GEN    (IX0 X3-X2)           *IN-LIMIT FOR *OUT*
          NEWLBL LABEL1 
          GEN    (NG X0,"LABEL1")      *IF IN<LIMIT FOR *OUT* 
          GEN    (SA2 A0+B1)           *FIRST PTR FOR *OUT* 
          GEN    (SX7 X2)         *KEEP LOW 18 BITS 
          GEN    (SA7 A3)              *SET IN=FIRST FOR *OUT*
          GEN    (BX3 X7)              *NEW IN PTR VALUE (*OUT*)
  
          GENLBL LABEL1 
          GEN    (SA2 A5+B1)           *LIMIT PTR FOR *IN*
          GEN    (SX2 X2)              *KEEP LO 18 BITS 
          GEN    (IX0 X5-X2)           *OUT-LIMIT FOR *IN*
          NEWLBL LABEL2 
          GEN    (NG X0,"LABEL2")      *IF OUT<LIMIT FOR *IN* 
          GEN    (SA2 A1+B1)           *FIRST PTR FOR *IN*
          GEN    (SX7 X2)         *KEEP LOW 18 BITS 
          GEN    (SA7 A5)              *SET OUT=FIRST FOR *IN*
          GEN    (BX5 X7)              *NEW OUT PTR VALUE (*IN*)
  
          GENLBL LABEL2 
          GEN    (SB3 B3-B1)           *DECREMENT COUNT 
          GEN    (NE B3,B0,"PRILOOP2") *IF MORE WORDS,LOOP
            ENDIF.
            IFTHEN X4=0        IF VARIABLE LENGTH RECORDS 
            GENLBL NEXT 
              ENDIF.
  
          GEN    (BX7 X3)              *UPDATE IN PTR 
          GEN    (SA7 A3)              *    FOR *OUT* 
          GEN    (BX7 X5)              *UPDATE OUT PTR
          GEN    (SA7 A5)              *    FOR *IN*
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS,
            GEN    (SA2 A5-2)          *FIRST POINTER FOR *IN*
            GEN    (SX2 X2) 
            GEN    (IX0 X7-X2)         *OUT - FIRST 
            NEWLBL NEXT 
            GEN    (NZ X0,"NEXT") 
            GEN    (SA2 A5+B1)         *LIMIT POINTER FOR *IN*
            GEN    (SX7 X2) 
            GENLBL NEXT 
            GEN    (SA5 X7-1)          *LAST WORD OF THIS SET 
            ENDIF.
  
*     DONE COPYING SOME WORDS FROM *IN* BUFFER TO *OUT* BUFFER
*     (IF VARIABLE-LENGTH RECORDS,) 
*         CHECK *B6 TO DECIDE WHAT TO DO. 
  
          GENLBL PRIDONE
                                       *X5 = LAST WORD COPIED 
          IFTHEN X4=0        IF VARIABLE-LENGTH RECORDS 
            NEWLBL NEXT 
            GEN    (SA2 "INVERT")  FIRST-WORD FLAG
            NEWLBL NEXT2
            GEN    (ZR X2,"NEXT2")
            GEN    (SB6 -B1)      WHAT IT SHOULD BE 
            GENLBL NEXT2
            GEN    (NG B6,"NEXT")      *IF ALREADY FOUND LENGTH FIELD 
            NEWLBL NEXT2
            GEN    (GT B6,B0,"NEXT2")  *IF IN MIDDLE OF LENGTH FIELD
            SX2    B5          OFFSET 
            BX7    X2 
            SA7    OFFSET      REMEMBER THIS VALUE
            SX0    1S22/60+1   1/60 * 2**22 
            IX3    X0*X2       OFFSET/60 * 2**22
            AX3    22          OFFSET/60
            SX0    60 
            IX1    X0*X3       (OFFSET/60)*60 
            IX1    X2-X1       OFFSET - (OFFSET/60)*60
            SB5    X1          <OFFSET-WITHIN-WORD> 
            SB7    B5+B3       <OFFSET-WITHIN-WORD> + LL
            SB6    60 
            IFTHEN B7@B6       IF LENGTH FIELD ENTIRELY IN *X5
              GEN    (LX5 0),B7        *RIGHT-JUSTIFY LENGTH FIELD
              SB6    60 
              SB7    B6-B3       60 - LL
              GEN    (MX0 0),B7 
              GEN    (BX2 -X0*X5)      *X2 = LENGTH 
              SA1    OFFSET      GET BACK ORIGINAL VALUE
              SB5    X1 
              SX1    B5+B3       OFFSET + LL
              SA2    LF 
              IX1    X1+X2       OFFSET + LL + LF 
              GEN    (SX0 0),X1  *X0 := OFFSET + LL + LF
              GEN    (SX3 6)
              GEN    (IX3 X2*X3) *VARIABLE PORTION IN BITS
              GEN    (IX3 X0+X3) *TOTAL RECORD LENGTH IN BITS 
              GEN    (SX0 1S22/60+1)
              GEN    (IX0 X0*X3)
              GEN    (AX0 22)    *TOTAL RECORD LENGTH IN WORDS
              GEN    (SA3 "VERIFY") 
              GEN    (IX2 X0-X3) *NUMBER OF WORDS LEFT TO COPY
              GEN    (SX2 X2+B1) *COPY DESCRIPTOR AS WELL 
              GEN    (SB6 -B1)         *NOW LOOK FOR END OF RECORD
              GEN    (NZ X2,"PIBCPYWD") *GO COPY/SKIP WORDS 
              GEN    (EQ "NEXT")       *DONE WITH RECORD
            ELSE-              IF FIELD SPANS TWO WORDS 
              GEN    (MX0 0),B5        MX0 OFFSET-WITHIN-WORD 
              GEN    (BX2 -X0*X5)      *LEFT PART OF LENGTH 
              GEN    (SB6 X2+B1)       *NOW GET RIGHT PART OF LENGTH
              GEN    (SX2 B1)           MOVE ONLY ONE WORD
              GEN    (EQ "PIBCPYWD")   *GO COPY/SKIP WORDS
              ENDIF.
            GENLBL NEXT2               *HERE WITH RIGHT PART OF LENGTH FIELD
            SB7    B5+B3       <OFFSET-WITHIN-WORD> + LL
            SB7    B7-60       LENGTH OF RIGHT PART OF FIELD
            GEN    (MX0 0),B7 
            GEN    (BX2 X0*X5)    *RIGHT PART OF FIELD, L.J.
            GEN    (SX0 B6-B1)    *LEFT PART OF FIELD 
            GEN    (BX2 X2+X0)         *BOTH PARTS, SHIFTED 
            SB7    B5+B3       <OFFSET-WITHIN-WORD> + LL
            SB7    B7-60       LENGTH OF RIGHT PART OF FIELD
            GEN    (LX2 0),B7          *RIGHT-JUSTIFY ENTIRE FIELD
            SA1    OFFSET      GET BACK ORIGINAL VALUE
            SB5    X1 
            SX1    B5+B3       OFFSET + LL
            SA2    LF 
            IX1    X1+X2       OFFSET + LL + LF 
            GEN    (SX0 0),X1  *X0 := OFFSET + LL + LF
            GEN    (SX3 6)
            GEN    (IX3 X2*X3) *VARIABLE PORTION IN BITS
            GEN    (IX3 X0+X3) *TOTAL RECORD LENGTH IN BITS 
            GEN    (SX0 1S22/60+1)
            GEN    (IX0 X0*X3)
            GEN    (AX0 22)    *TOTAL RECORD LENGTH IN WORDS
            GEN    (SA3 "VERIFY") 
            GEN    (IX2 X0-X3) *NUMBER OF WORDS LEFT TO COPY
            GEN    (SB6 -B1)      *WE HAVE FOUND THE LENGTH FIELD 
            GEN    (EQ "PIBCPYWD")     *GO COPY WORDS 
            GENLBL NEXT                *DONE COPYING RECORD 
            ENDIF.
  
                                       *RESET X6 FROM "RECDESC" 
          GEN    (SA5 "RECDESC")
          GEN    (BX6 X5) 
  
          EXIT
  
  
 LF       BSS    1           REC$LF1 + REC$LF2
 OFFSET   BSSZ   1           PRESERVE ORIGINAL PARAMETER
  
  
          END 
