*COMDECK COM2NQ 
CIB       SPACE  4,10 
**        CIB - CHECK INPUT BUFFER POINTERS.
* 
*         READ OUT POINTER. 
*         VALIDATE OUT POINTER. 
*         CALCULATE SPACE AVAILABLE FOR INPUT.
*         RETURN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) .LT. 0, ERROR RETURN.
*                    .GE. 0, SIZE AVAILABLE FOR INPUT.
* 
*         USES   D.T0 - D.T4, INPNT, OUTPNT, FIRST, LIMIT.
* 
*         CALLS  CSP. 
  
  
 CIB      ENM    X                 ENTRY/EXIT 
          FETREL 3
          ZJN    CIB1              IF ADDRESS ERROR 
          CRD    D.T0              READ OUT 
          LDD    D.T0+C.PT+1
          STD    OUTPNT+1 
          LDD    D.T0+C.PT
          LPN    77B
          STD    OUTPNT            SAVE OUT 
          SBD    LIMIT             CALCULATE OUT - LIMIT
          SHN    12 
          ADD    OUTPNT+1 
          SBD    LIMIT+1
          PJN    CIB1              IF OUT PAST LIMIT
          LDD    OUTPNT 
          SBD    FIRST             CALCULATE OUT - FIRST
          SHN    12 
          ADD    OUTPNT+1 
          SBD    FIRST+1
          PJN    CIB2              IF FIRST .LE. OUT
 CIB1     LCN    0                 SET ERROR RETURN 
          UJN    CIBX 
 CIB2     RJM    CSP               CHECK SPACE AVAILABLE
          UJN    CIBX 
CSP       SPACE  4,10 
**        CSP - CHECK SPACE AVAILABLE.
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) = SPACE AVAILABLE. 
* 
*         USES   INPNT, OUTPNT, FIRST, LIMIT. 
* 
*         CALLS  NONE.
  
  
 CSP      ENM    X                 ENTRY/EXIT 
          LDD    OUTPNT            CALCULATE OUT - IN - 1 
          SBD    INPNT
          SHN    12 
          ADD    OUTPNT+1 
          SBD    INPNT+1
          SBN    1
          PJN    CSPX              IF AVAILABLE SPACE IN ONE PIECE
          ADD    LIMIT+1
          SBD    FIRST+1           CALCULATE OUT - IN - 1 + LIMIT -FIRST
          SHN    6                 GIVES SPACE WHEN SPACE WRAPS AROUND
          ADD    LIMIT
          SBD    FIRST
          SHN    12 
          PJN    CSPX              IF POSITIVE SIZE 
          LDN    0                 SET SIZE TO ZERO 
          UJN    CSPX 
IBR       SPACE  4,10 
**        IBR - INPUT BINARY RECORD.
* 
*         SET UP TO INPUT DATA. 
*         CALL IBD TO INPUT BINARY DATA.
*         IF ERROR THEN RETURN. 
*         IF NOT DATA INPUT THEN RETURN.
*         CALL CUB TO CLEAR UNUSED BITS.
*         RETURN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) =0, NORMAL RETURN. 
*                    .GT. 0, EXPLICIT FET COMPLETE CODE.
*                    .LT. 0, COMPLETE FET WITH NO ERROR.
*                (DBC) .NE. 0, IF DATA INPUT. 
* 
*         USES   DBC, FLUSH, REMWORDS, UBC. 
* 
*         CALLS  CUB, ERR, IBD. 
  
  
 IBR      ENM    X                 ENTRY/EXIT 
          LDC    HDR
          STM    INPA              SET INPUT BUFFER ADDRESS 
          STD    FLUSH             SET FLUSH ON END OF INPUT
          LDC    NPRU+HDRLEN
          RJM    IBD               INPUT HEADER AND TEXT
          NJN    IBRX              IF ERROR 
          LDD    DBC
          ZJN    IBRX              IF NO DATA INPUT 
          RJM    CUB               CLEAR UNUSED BITS
          UJN    IBRX 
IBD       SPACE  4,1/ 
**        IBD - INPUT BINARY DATA.
* 
*         SAVE AMOUNT TO INPUT. 
*         INPUT BINARY DATA.
*         VALIDATE HEADER INPUT.
*         VALIDATE PRU BLOCK. 
*         VALIDATE ABN. 
*         RELEASE CHANNEL.
*         CALCULATE BLOCK SIZE. 
* 
*         ENTRY  (A) = NUMBER OF BYTES TO INPUT.
* 
*         EXIT   (A) = 0, NORMAL RETURN.
*                    .GT. 0, EXPLICIT FET COMPLETE CODE.
*                    .LT. 0, COMPLETE FET WITH NO ERROR.
*                (DBC) .NE. 0, IF DATA INPUT. 
  
*         USES   BUFBYTES, D.Z7, DBC. 
* 
*         CALLS  CMW, ERR, FAN, FFN, INP, REL, WFP. 
  
  
 IBD      ENM    X                 ENTRY/EXIT 
          STM    IBDA              SAVE AMOUNT TO INPUT 
 IBD01    LDN    FCRD              READ DATA
          RJM    FFN
          ZJN    IBD05             IF ACK RESPONSE
          MJN    IBD02             IF HARDWARE ERROR
          LMN    RCTN&RCAK
          ZJN    IBD01.5           IF TNR RESPONSE
          LMN    RCFL&RCTN
          ZJN    IBD01.5           IF PATH FLUSHED
          LMN    RCCA&RCFL
          ZJN    IBD01.5           IF CONVERT MODE ACTIVE 
          LMN    RCAB&RCCA
          NJN    IBD04             IF NOT PATH ABORTED
          LDN    EVTABT 
          STD    EVENT             SAVE EVENT PATH ABORTED
          LCN    0
          UJN    IBDX 
  
 IBD01.5  STD    DBC               INDICATE NO BLOCK INPUT
          UJN    IBDX              INPUT DISAPPEARED
  
 IBD02    RJM    ERR               REPORT ERROR 
          MJN    IBDX              IF RETRIES EXHAUSTED 
          LDK    FCRT              RESET TRANSFER 
          RJM    FFN
          MJN    IBD02             IF HARDWARE ERROR
          UJN    IBD01             RESTART TRANSFER 
 IBD03    MJN    IBD02             IF HARDWARE ERROR
 IBD04    LCN    NADERRH           ABNORMAL RESPONSE CODE 
          UJN    IBD02
  
 IBD05    LDD    D.REQ1+C.REQFLG
          SHN    17-S.CHNDED
          PJN    IBD06             IF CHANNEL NOT DEDICATED 
          LDM    BLKCNT+C.READ+1
          NJN    IBD08             IF BLOCK ALREADY READ IN BINARY MODE 
 IBD06    LDK    FCBM              SELECT BINARY MODE 
          RJM    FFN
 IBD07    NJN    IBD03             IF ERROR 
 IBD08    RJM    WFP               WAIT FOR PRIMED
          MJN    IBD02             IF ERROR 
          LDK    FCIB              INPUT BIT STRING 
          RJM    FAN
          MJN    IBD07             IF ERROR 
          LDC    0
 IBDA     EQU    *-1               AMOUNT TO INPUT
          RJM    INP               INPUT DATA 
          MJN    IBD07             IF HARDWARE ERROR
          SBN    HDRLEN 
          PJN    IBD09             IF HEADER INPUT
          LCN    NADERRP           HEADER LENGTH ERROR
          UJN    IBD07
  
 IBD09    STD    BUFBYTES          BYTES IN DATA BUFFER 
          LDM    HDR+R.PDBC 
          STD    DBC               SAVE DATA BLOCK CLARIFIER
          SHN    17-S.PRU 
          MJN    IBD11             IF PRU BLOCK 
          LDK    FETNTPRU          NEXT BLOCK NOT PRU BLOCK 
 IBD10    STD    D.Z7 
          LDK    FCRT              RESET TRANSFER 
          RJM    FFN
          NJN    IBD07             IF NOT ACK RESPONSE
  
          LDD    D.Z7              PICK UP FET ERROR CODE 
          UJN    IBD15
  
 IBD11    LDM    HDR+R.PABN 
          LMM    FETWD5+C.FABN
          LPN    77B
          ZJN    IBD13             IF ABN COMPARES SO FAR 
 IBD12    LDK    FETBABN           ABN MISCOMPARE 
          UJN    IBD10
  
 IBD13    LDM    HDR+R.PABN+1 
          LMM    FETWD5+C.FABN+1
          NJN    IBD12             IF ABN MISCOMPARE
          LDD    DD 
          SBN    DDAS 
          ZJN    IBD14             IF ASCII DATA
          LDD    D.REQ1+C.REQFLG
          SHN    17-S.CHNDED
          MJN    IBD14             IF CHANNEL DEDICATED 
          LDN    1                 TEMPORARILY
          RJM    REL               RELEASE CHANNEL
 IBD14    RJM    CMW               CALCULATE CM WORDS 
 IBD15    LJM    IBDX 
ICR       SPACE  4,10 
**        ICR - INPUT CHARACTER RECORD. 
* 
*         IF REMWORDS NON-ZERO THEN GO TO SELECT PATH.
*         SET UP TO INPUT HEADER. 
*         CALL IBD TO INPUT BINARY HEADER.
*         IF ERROR THEN RETURN. 
*         IF NO HEADER INPUT THEN RETURN. 
*         IF NO TEXT TO INPUT THEN RETURN.
*         CALL SEL TO SELECT PATH.
*         INPUT CHARACTER DATA. 
*         IF ERROR THEN RETURN. 
*         RELEASE CHANNEL.
*         IF FULL PP BUFFER NOT INPUT AND REMWORDS GREATER THAN 6 PRUS
*         THEN
*           SET LENGTH ERROR AND RETURN.
*         IF REMWORDS LESS THAN OR EQUAL TO 6 PRUS
*         THEN
*           CALL UBC TO CLEAR UNUSED BITS.
*         RETURN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) = 0, NORMAL RETURN.
*                    .GT. 0, EXPLICIT FET COMPLETE CODE.
*                    .LT. 0, COMPLETE FET WITH NO ERROR.
*                (DBC) .NE. 0, IF DATA INPUT. 
* 
*         USES   BUFBYTES, DBC, FLUSH, RECSIZE, REMWORDS. 
* 
*         CALLS  CUB, ERR, FAN, FFN, IBD, INP, REL, SEL.
  
  
 ICR      ENM    X                 ENTRY/EXIT 
          LDD    REMWORDS 
          NJN    ICR01             IF SECOND HALF OF BLOCK TO READ
          STD    FLUSH             SET NO FLUSH 
          LDC    HDR
          STM    INPA              SET INPUT BUFFER ADDRESS 
          LDK    HDRLEN 
          RJM    IBD               INPUT HEADER 
          NJN    ICRX              IF ERROR 
          LDD    DBC
          ZJN    ICRX              IF NO DATA INPUT 
          LDD    REMWORDS 
          ZJN    ICRX              IF NO TEXT TO INPUT
 ICR01    LDC    BUFR 
          STM    INPA              SET INPUT BUFFER ADDRESS 
          STD    FLUSH             SET INPUT FLUSH
          LDD    RECSIZE
          SBD    REMWORDS 
          PJN    ICR02             IF FLUSH (NO SECOND READ REQUIRED) 
          LDN    0
          STD    FLUSH             SET NO INPUT FLUSH 
 ICR02    RJM    SEL               SELECT PATH
 ICR03    MJN    ICRX              IF ERROR 
          LDN    FCRD              READ DATA
          RJM    FFN
          ZJN    ICR06             IF ACK RESPONSE
          LMN    RCFL&RCAK
          ZJN    ICR03.5           IF PATH FLUSHED
          LMN    RCAB&RCFL
          NJN    ICR04             IF NOT PATH ABORTED
          LDN    EVTABT 
          STD    EVENT             SAVE EVENT PATH ABORTED
          LCN    0
          UJN    ICR03
  
 ICR03.5  STD    DBC               INDICATE NO BLOCK INPUT
          LJM    ICRX 
  
 ICR04    MJN    ICR05             IF HARDWARE ERROR
          LCN    NADERRH           ABNORMAL RESPONSE CODE 
 ICR05    RJM    ERR               REPORT ERROR 
          MJN    ICR03             IF RETRIES EXHAUSTED 
          LDK    FCRT              FIRST RESET - MUST RESTART RECORD
          RJM    FFN
          MJN    ICR05             IF ERROR 
          LDK    FCRT              SECOND RESET 
          RJM    FFN
          MJN    ICR05
          AOD    RESET             INDICATE DATA RESET
          LDN    0
 ICR05.5  LJM    ICRX              RETURN 
  
 ICR06    LDK    FCBM              SELECT BINARY MODE 
          RJM    FFN
          NJN    ICR04             IF ERROR 
          RJM    WFP               WAIT FOR PRIMED
          MJN    ICR05             IF ERROR 
          LDK    FCI8              INPUT 8 TO 12
          RJM    FAN
 ICR07    MJN    ICR05             IF ERROR 
          LDC    NPRU 
          RJM    INP               INPUT DATA 
          MJN    ICR07             IF HARDWARE ERROR
          STD    BUFBYTES          BYTES IN DATA BUFFER 
          LDD    D.REQ1+C.REQFLG
          SHN    17-S.CHNDED
          MJN    ICR08             IF CHANNEL DEDICATED 
          LDN    1                 TEMPORARILY
          RJM    REL               RELEASE CHANNEL
 ICR08    LDD    RECSIZE
          SBD    REMWORDS 
          MJN    ICR10             IF ANOTHER READ REQUIRED 
          RJM    CUB               CLEAR UNUSED BIT COUNT 
 ICR09    UJK    ICR05.5           RETURN 
  
 ICR10    LDC    NPRU 
          SBD    BUFBYTES 
          ZJN    ICR09             IF FULL BLOCK INPUT
          LCN    NADERRQ           BAD DATA BLOCK LENGTH
          RJM    ERR               REPORT ERROR 
          UJN    ICR09
CMW       SPACE  4,10 
**        CMW - CALCULATE CM WORDS. 
* 
*         CONVERT TEXT LENGTH BIT COUNT INTO CM WORDS 
*           AND UNUSED BIT COUNT. 
*         VALIDATE BLOCK IS NOT TOO BIG.
*         VALIDATE SHORT BLOCK HAS EOR OR EOI SET.
*         RETURN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) = 0, NORMAL RETURN.
*                    .GT. 0, FET ERROR CODE.
*                    .LT. 0, PATH ERROR.
* 
*         USES   D.T0 - D.T3, DBC, DD, REMWORDS, UBC. 
* 
*         CALLS  ERR. 
* 
*         NOTES  A PRU BLOCK IS COMPOSED OF A BLOCK HEADER AND OPTIONAL 
*                TEXT.  THE BLOCK HEADER CONTAINS THE TEXT LENGTH IN
*                BITS, THE PATH ID OF THE TRANSMITTER, THE DATA BLOCK 
*                CLARIFIER, AND THE ABN.  THE TEXT IS IN EITHER BINARY
*                OR CHARACTER MODE.  A FULL BLOCK CONTAINS 2880 8-BIT 
*                BYTES IF IN BINARY MODE OR 3840 8-BIT BYTES IF IN
*                CHARACTER MODE.  ALL BLOCKS WHICH ARE NOT EOR OR EOI 
*                MUST BE FULL BLOCKS. 
* 
*                A BINARY BLOCK IS TRANSFERED BETWEEN THE NAD, PP,
*                AND CM WITHOUT DATA CONVERSION.  A FULL BINARY BLOCK 
*                FILLS 1920 12-BIT BYTES, 384 60-BIT WORDS, OR 6 64-WORD
*                BLOCKS (6 DISK PRUS).
* 
*                A CHARACTER BLOCK IS ALWAYS CONVERTED TO DISPLAY CODE
*                OR CDC ASCII (8-BITS WITHIN 12-BITS) BETWEEN THE NAD 
*                AND PP. NO CONVERSION IS PERFORMED BETWEEN THE PP
*                AND CM.  A FULL DISPLAY CODE CONVERTED BLOCK FILLS 
*                1920 12-BIT BYTES, 384 60-BIT WORDS, OR 6 64-WORD
*                BLOCKS (6 DISK PRUS).  A FULL ASCII CONVERTED BLOCK
*                FILLS 2*1920 12-BIT BYTES, 2*384 60-BIT WORDS OR 
*                12 64-WORD BLOCKS (12 DISK PRUS).
* 
*                THE TEXT LENGTH IS FIRST CONVERTED BASED ON DATA 
*                CONVERSION TYPE.  NO CONVERSION IS REQUIRED FOR
*                BINARY DATA.  TEXT LENGTH IS MULTIPLIED BY 3/4 
*                FOR DISPLAY CODE.  TEXT LENGTH IS MULTIPLIED BY 3/2
*                FOR ASCII. 
* 
*                THE TEXT LENGTH IS THEN CONVERTED TO THE 60-BIT
*                CM WORD COUNT AND UNUSED BIT COUNT USED WITHIN CM. 
*                THE CM WORD COUNT IS FIRST APPROXIMATED BY THE 
*                FORMULA: 
*                  LENGTH/64 + (17*(LENGTH/64))/256 
* 
*                THIS YIELDS A  RESULT AT MOST TWO LESS THAN THE ACTUAL 
*                RESULT IN A RANGE OF ZERO TO 246,994.
  
  
 CMW      ENM    X                 ENTRY/EXIT 
          LDN    0
          STD    UBC               ZERO USUSED BIT COUNT
          LDM    CMWC,DD
          STM    CMWA              INITIALIZE FOR FIRST CONVERSION
          LDM    HDR+R.PTXTLN+1    PICK UP BIT COUNT
          SHN    -8 
          SHN    14 
          LMM    HDR+R.PTXTLN 
          SHN    4
          STD    D.T1              SAVE BIT COUNT 
          SHN    -12
          STD    D.T0 
 CMWA     UJN    CMW1              BINARY MODE
*         SHN    1                 CHARACTER MODE 
          ADD    D.T0              COUNT * 3
          SHN    12 
          ADD    D.T1 
          ADD    D.T1 
          ADD    D.T1 
          SHN    -1                DIVIDE BY 2 FOR ASCII
          STD    D.T1 
          SHN    -12               SAVE CONVERTED BIT COUNT 
          STD    D.T0 
 CMW1     SHN    12                PICK UP BIT COUNT
          ADD    D.T1 
          SHN    -6                COUNT/64 
          STD    REMWORDS 
          SHN    4                 16*(COUNT/64)
          ADD    REMWORDS          17*(COUNT/64)
          SHN    -8                (17*(COUNT/64))256 
          RAD    REMWORDS          COUNT/64 + (17*(COUNT/64))/256 
          SHN    1                 2*CMWORDS (BE CAREFUL OF OVERFLOW) 
          STD    D.T2 
          SHN    5                 64*CMWORDS 
          SBD    D.T2              62*CMWORDS 
          SBD    D.T2              60*CMWORDS 
          STD    D.T3              SAVE 60*CMWORDS
          SHN    -12
          STD    D.T2 
          LDD    D.T0              CALCULATE COUNT - APPROX. COUNT
          SBD    D.T2 
          SHN    12 
          ADD    D.T1 
          SBD    D.T3 
 CMW2     ZJN    CMW4              IF NO CORRECTION REQUIRED
          SBN    60 
          MJN    CMW3              IF UBC LESS THAN 60
          STD    D.T2 
          AOD    REMWORDS          CORRECT APPROXIMATE WORD COUNT 
          LDD    D.T2 
          UJN    CMW2 
  
 CMW3     LMC    777777B           ADJUST UBC TO POSITIVE 
          STD    UBC               SAVE UNUSED BIT COUNT
          AOD    REMWORDS          INCLUDE WORD WITH UBC
 CMW4     BSS    0
          LDM    CMWE,DD           LOAD ALLOWED CM WORD SIZE
          SBD    REMWORDS          SUBTRACT TEXT CM WORD SIZE 
          ZJN    CMW5              IF FULL BLOCK (EXCEPT FOR UBC) 
          PJN    CMW6              IF NOT FULL BLOCK
          LDK    FETBLKSZ          BLOCK SIZE TOO BIG FOR DD
          UJN    CMW8 
  
 CMW5     LDD    UBC
          ZJN    CMW7              IF FULL BLOCK
 CMW6     LDD    DBC
          SHN    17-S.EOI 
          MJN    CMW7              IF EOI BLOCK 
          SHN    S.EOI-S.EOR
          MJN    CMW7              IF EOR BLOCK 
          LCN    NADERRR           BAD PRU BLOCK
          RJM    ERR               REPORT ERROR 
          UJN    CMW8 
  
 CMW7     LDN    0                 NORMAL RETURN
 CMW8     LJM    CMWX 
  
 CMWC     BSS    0
          LOC    CMWA 
          UJN    CMW1              BINARY MODE
          LOC    *O 
          LOC    CMWA 
          UJN    CMW1              BINARY MODE
          LOC    *O 
          BSSZ   1                 DISPLAY CODE NOT SUPPORTED 
          SHN    1                 CHARACTER MODE 
  
 CMWE     CON    NPRU/5 
          CON    NPRU/5 
          BSSZ   1                 DISPLAY CODE NOT SUPPORTED 
          CON    2*NPRU/5 
CUB       SPACE  4,10 
**        CUB - CLEAR UNUSED BIT COUNT. 
* 
*         CLEAR UNUSED BIT COUNT. 
*         VALIDATE THAT SUFFICIENT DATA HAS BEEN INPUT. 
*         ADJUST BUFBYTES TO PROPER MULTIPLE OF CM WORD COUNT.
*         RETURN. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) = 0, NORMAL RETURN.
*                    .LT. 0, COMPLETE FET WITH NO ERROR.
* 
*         USES   D.T0 - D.T3, BUFBYTES, REMWORDS, UBC.
* 
*         CALLS  ERR. 
  
  
 CUB      ENM    X                 ENTRY/EXIT 
          LDD    REMWORDS 
          SHN    2                 *4 
          ADD    REMWORDS          *5 
          STD    D.T0              SAVE FUTURE BUFBYTES VALUE 
          ADC    BUFR-1 
          STD    D.T1              END OF BUFFER POINTER
          LDN    0
          STD    D.T2              UNUSED BYTES 
          LDD    UBC
          STD    D.T3              SAVE UBC FOR MODIFICATION
 CUB1     LCN    12 
          RAD    D.T3              DECREMENT UBC
          MJN    CUB2              IF FULL BYTE NOT UNUSED
          LDN    0
          STI    D.T1              ZERO UNUSED BYTE 
          SOD    D.T1              POINT TO PREVIOUS BYTE 
          AOD    D.T2              INCREMENT UNUSED BYTES 
          UJN    CUB1 
  
 CUB2     ADN    12 
          ZJN    CUB2.1            IF ENTIRE NEXT BYTE USED 
          ADC    .SHN.             FORM SHIFT INSTRUCTIONS
          STM    CUBB 
          LMN    77B
          STM    CUBA 
          LDI    D.T1              CLEAR UNUSED BITS FROM NEXT BYTE 
 CUBA     SHN    0                 RIGHT SHIFT
 CUBB     SHN    0                 LEFT SHIFT 
          STI    D.T1 
  
 CUB2.1   LDD    BUFBYTES          BYTES INPUT
          ADD    D.T2              UNUSED BYTES 
          SBD    D.T0              5*REMWORDS (BYTES REQUIRED)
          PJN    CUB4              IF ENOUGH BYTES INPUT
          LCN    NADERRQ           BAD DATA BLOCK LENGTH
          RJM    ERR               REPORT ERROR 
 CUB3     UJK    CUBX              EXIT 
  
 CUB4     LDD    D.T0 
          STD    BUFBYTES          ADJUST BUFBYTES
          LDD    DD 
          SBN    DDAS 
          NJN    CUB5              IF NOT ASCII 8/12
          LDD    D.T2              UNUSED BYTES 
          SHN    2                 UB*4 
          STD    UBC
          SHN    1                 UB*8 
          RAD    UBC               UBC = MULTIPLE OF 12 BITS
 CUB5     LDN    0                 NORMAL RETURN
          UJN    CUB3 
WBB       SPACE  4,10 
**        WBB - WRITE BINARY BUFFER.
* 
*         ENTRY  (A) = CM WORD COUNT. 
*                (D.T0) = PP BUFFER ADDRESS.
* 
*         EXIT   (A) .NE. 0, NORMAL RETURN. 
*                    = 0, ADDRESS ERROR.
* 
*         USES   D.T0 - D.T3, FIRST, INPUT, LIMIT.
* 
*         CALLS  NONE.
  
  
 WBB      ENM    X                 ENTRY/EXIT 
          STD    D.T2              SET FIRST PART WORD COUNT
          STD    D.T1              SAVE CM WORD COUNT 
          SBN    1
          MJN    WBBX              IF NO DATA TO WRITE
          LDD    D.T0 
          STM    WBBA              SET WRITE ADDRESS
          LDD    INPNT
          SBD    LIMIT             CALCULATE IN - LIMIT + WORD COUNT
          SHN    12 
          ADD    INPNT+1
          SBD    LIMIT+1
          ADD    D.T1 
          MJN    WBB1              IF NO WRAP AROUND
          STD    D.T3              SET SECOND PART WORD COUNT 
          LDD    D.T1 
          SBD    D.T3 
          STD    D.T2              SET FIRST PART WORD COUNT
 WBB1     LDD    INPNT
          SHN    12 
          LMD    INPNT+1
          ADD    D.T2              VALIDATE LAST WORD BEING WRITTEN 
          ADDRA  ER=WBBX
          SBD    D.T2 
          CWM    *,D.T2            WRITE CM BUFFER
 WBBA     EQU    *-1
          LDD    D.T2 
          RAD    INPNT+1           ADVANCE IN POINTER 
          SHN    -12
          RAD    INPNT
          SBD    LIMIT             CALCULATE IN - LIMIT 
          SHN    12 
          ADD    INPNT+1
          SBD    LIMIT+1
          NJN    WBB2              IF NOT AT LIMIT
          LDD    FIRST
          STD    INPNT             RESET IN POINTER TO FIRST
          LDD    FIRST+1
          STD    INPNT+1
          LDD    D.T2              ADVANCE PP BUFFER ADDRESS
          SHN    2                 *4 
          ADD    D.T2              *5 
          RAM    WBBA 
          LDD    D.T3 
          ZJN    WBB2              IF NO SECOND PART
          STD    D.T2              SET WORD COUNT 
          LDN    0
          STD    D.T3              CLEAR SECOND PART WORD COUNT 
          LJM    WBB1 
  
 WBB2     LDN    1                 NORMAL RETURN
          LJM    WBBX 
UPI       SPACE  4,10 
**        UPI - UPDATE IN AND ABN WITHIN UCP FET. 
* 
*         ENTRY  NONE.
* 
*         EXIT   (A) = 0, NORMAL RETURN.
*                    = FETPERR, ADDRESS ERROR.
* 
*         USES   D.T0 - D.T4, INPNT.
* 
*         CALLS  NONE.
  
  
 UPI      ENM    X                 ENTRY/EXIT 
          FETREL 5
          ZJN    UPI1              IF ADDRESS ERROR 
          CWM    FETWD5,ONE        WRITE ABN, UBC, AND DD.
          LDK    P.ZERO 
          CRD    D.T0 
          LDD    INPNT
          STD    D.T0+C.PT         SET UP IN POINTER
          LDD    INPNT+1
          STD    D.T0+C.PT+1
          FETREL 2
          ZJN    UPI1              IF ADDRESS ERROR 
          CWD    D.T0              WRITE IN 
          LDN    0                 NORMAL RETURN
          UJN    UPIX 
  
 UPI1     LDN    FETPERR           FET PARAMETER ERROR
          UJN    UPIX 
