*DECK BASSPA
          IDENT  BASSPA 
          ENTRY  BASTLPD,BASXLPD
          ENTRY  BASTRPD,BASXRPD
          ENTRY  BASTRTR,BASXRTR
          ENTRY  BASTLTR,BASXLTR
          EXT    ER168
          EXT    REG= 
          TITLE  BASIC 3 - LPAD$, RPAD$, LTRM$, RTRM$ PROCESSORS. 
          COMMENT BASIC 3 - LPAD$, RPAD$, LTRM$, RTRM$ PROCESSORS.
          B1=1
          SPACE  4
          CON    10HBASTLPD 
 BASTLPD  PS                 LPAD$ ENTRY
          RJ     =XBASSBR=   SAVE REGISTERS 
          NG     X4,ER192 
          BX6    X4 
          SA6    SAVREG 
          SX6    B6 
          SA6    A6+1 
          SB7    A5 
          RJ     =XBASXLEN
          NX5    X5 
          SA4    SAVREG 
          FX4    X4-X5
          SA5    A5 
          SA3    A4+1 
          SB6    X3 
          NX4    X4 
          PL     X4,LPD01          IF RESULT IS LESS THAN ZERO
          SA4    SETZER0           THEN MAKE IT A ZERO
 LPD01    SB2    ER192       *ILLEGAL LPAD$ PARAMETER*
          RJ     PAD         CRACK INPUT
          SX6    B0 
          SA2    PADH 
          SA6    B3          ZERO FIRST WORD
          ZR     X2,LPD2     NO FULL WORD PADDING 
  
*         SET PRECEEDING FULL WORD (10 CHAR) PADDING. 
  
          BX6    X3 
          SB7    X2          COUNT
 LPD1     SB7    B7-B1
          SA6    B3          NEW STRING AREA
          SB3    B3+1 
          GT     B7,B0,LPD1 
 LPD2     SA2    A2+B1
          ZR     X2,LPD3     NO PARTIAL WORD PADDING
  
*         PUT IN 1-9 LEADING SPACES AND THEN COPY THE REST OF 
*         THE INPUT STRING TO THE NEW STRING AREA.
  
          MX0    1
          IX4    X2+X2
          SA1    PADA        CURRENT STRING POINTER 
          SA1    X1 
          LX5    X4,B1
          IX4    X4+X5       X2*6 
          AX1    18+18
          SB4    X4-1 
          AX0    X0,B4
          SB7    X1+         CURRENT LENGTH 
          BX5    X0*X3       LEADING SPACES (ABC.......)
          ZR     B7,LPD6     IF NULL INPUT STRING 
          SB7    B7+X2
          RJ     CPY         COPY PAD PLUS OLD STRING 
          EQ     LPD5        ALMOST FINISHED
  
*         COPY CURRENT STRING TO NEW STRING AREA. 
  
 LPD3     SA1    PADA 
          SA1    X1 
          SB6    10          CONSTANT 10
          AX1    18+18
          ZR     X1,LPD5     IF NULL INPUT STRING 
          SA2    B2-B1       PRESET A2
          SB7    X1+         CURRENT LENGTH 
 LPD4     SA2    A2+B1       CURRENT STRING 
          SB7    B7-B6
          BX6    X2 
          SA6    B3          NEW STRING AREA
          SB3    B3+B1
          GT     B7,B0,LPD4 
  
*         ANY TRANSFERS COMPLETE. 
  
 LPD5     SB6    BASTLPD     RETURN ADDRESS 
          JP     RETPAD      RETURN FROM LPAD$
  
 LPD6     BX6    X5 
          SA6    B3 
          EQ     LPD5        FINISH 
 SETZER0  BSSZ   1
          SPACE  4
          CON    10HBASTRPD 
 BASTRPD  PS                 RPAD$ ENTRY
          EQ     RPD         GOTO PROCESSOR 
          SPACE  4
**        PAD - PRESET FOR XPAD$ PROCESSORS.
* 
*         ENTRY  (B2) = ERROR JUMP ADDRESS. 
*                (B6) = NUMBER OF PARAMETERS. 
*                (X4) = NUMBER OF PADDING CHARACTERS (FLOATED). 
*                (X5) = INPUT STRING POINTER. 
* 
*         EXIT   (B2) = CURRENT STRING FWA. 
*                (B3) = NEW STRING FWA. 
*                (X3) = 10H          .
*                (X6) = INPUT STRING LENGTH DIV 10. 
*                (X7) = INPUT STRING LENGTH MOD 10. 
* 
*         EXITS TO (B2) IF TOO MANY/FEW PARAMETERS OR IF (X4)<0.
*         EXITS TO ER168 IF PADDED STRING EXCEEDS 1S17-1 (131071D)
*         CHARACTERS IN LENGTH. 
* 
*         CALLS  (B2), ER168, BASSMBS, BAS.MOD. 
  
  
 PAD1     JP     B2          EXIT TO ERROR ROUTINE
  
 PAD      PS                 ENTRY/NORMAL EXIT
          SB7    B1+B1
          NE     B6,B7,PAD1  WRONG NUMBER OF PARAMETERS 
          SX6    A5 
          OR     X4,PAD1     VALIDATE COUNT 
          ID     X4,PAD1
          SA2    =XBASANSI   ROUND THE ARGUMENT IF
          ZR     X2,NOTANS   IN ANSI MODE.
          BX7    X7-X7
          PX7    X7 
          RX4    X4+X7
 NOTANS   BSS    0
          UX7    X4,B7
          SA6    PADA        SAVE INPUT POINTER 
          LX7    X7,B7       INT(M) 
          NG     X4,PAD1     COUNT MUST BE >= 0 
          AX5    18+18
          SA7    A6+B1       SAVE PADDING REQUEST 
          SX5    X5 
          BX2    X7 
          IX5    X5+X7       TOTAL PADDED LENGTH
          RJ     =XBAS.MOD   PADDING QUOTIENTS
          SA6    PADH        PAD COUNT DIV 10 
          SA7    A6+B1       PAD COUNT MOD 10 
          SX4    1S17-1      MAXIMUM STRING LENGTH
          IX4    X4-X5
          NG     X4,ER168    * STRING TOO LONG *
          SX6    X5 
          SA1    PADF        FTN/SYMPL CALL BLOCK 
          SA6    PADE 
          SX7    PADC 
          SA7    PADI        RESET FIELD
          RJ     =XBASSMGS   GET STRING 
          SA1    PADC 
          SB4    B0 
          SB3    X1          NEW FWA
          SA5    PADA 
          SA5    X5 
          SB1    1
          PL     X5,PAD2     FWA IS ABSOLUTE
          SA3    REG=+4 
          SB4    X3+         FWA RELATIVE TO B4 
 PAD2     SB2    X5+B4       CURRENT STRING FWA 
          AX5    18+18
          SX2    X5          CURRENT STRING LENGTH
          RJ     =XBAS.MOD   LENGTH QUOTIENTS 
          SA3    PADD        =10H 
          JP     PAD         RETURN 
  
 PADA     BSS    1           INPUT STRING POINTER 
 PADB     BSS    1           PADDING LENGTH REQUESTED 
 PADC     CON    0           NEW STRING POINTER 
 PADD     CON    1H          PAD CONSTANT 
 PADE     BSS    1           TOTAL PADDED LENGTH
 PADF     CON    PADI        ADDRESS OF ADDRESS OF STRING POINTER 
          CON    PADE        ADDRESS OF STRING LENGTH 
 PADH     BSS    2           PADDING COUNT DIV/MOD 10 
 PADI     CON    PADC        ADDRESS OF STRING POINTER
 CPY      SPACE  4,2
**        CPY - COPY PARTIAL START PLUS DATA BLOCK. 
* 
*         ENTRY  (B1) = 1.
*                (B2) = FWA TO READ.
*                (B3) = FWA TO WRITE. 
*                (B7) = CHARACTER LENGTH OF AREA (B2).
*                (X2) = N.
*                (X5) = FIRST N CHARACTERS. 
* 
*         EXIT   (B3) = NEW FWA FOR WRITE.
* 
*         USES   X - 0, 1, 3, 5, 6. 
*                A - 1, 6.
*                B - 3, 4, 5, 7.
  
  
 CPY      PS                 ENTRY/EXIT 
          IX3    X2+X2
          IX3    X2+X3       X2*6 
          LX3    1
          MX0    1
          SB4    X3 
          SB5    -B4
          SB5    60+B5-1
          SB4    X2 
          SA1    B2-B1       PRESET A1
          AX0    X0,B5       SET MASK 
          SB5    B5+1        ADJUST SHIFT COUNT 
 CPY1     LE     B7,B4,CPY2 
          SB7    B7-10
          SA1    A1+B1
          BX6    X0*X1       0123456... 
          LX6    X6,B5       ...0123456 
          IX6    X5+X6       ABC0123456 
          BX5    -X0*X1      .......789 
          SA6    B3          NEW STRING AREA
          LX5    X5,B5       789....... >> ABC....... 
          SB3    B3+B1
          EQ     CPY1 
 CPY2     ZR     X5,CPY 
          BX6    X5 
          SA6    B3 
          SB3    B3+B1
          EQ     CPY         RETURN 
          SPACE  4,4
**        RETURN - RETURN FROM PROCESSSOR.
* 
*         ENTRY  (A6) = ADDRESS OF THE LAST WORD STORED.
*                (B6) = EXIT ADDRESS. 
*                (PADC) = NEW STRING POINTER. 
* 
*         EXIT   TO (B6) AFTER COMPLETING END-OF-LINE CHECKING AND
*                RESTORATION OF REGISTERS.
* 
*         CALLS  BASRBR=. 
  
  
 RETPAD   SA1    A6          LAST WORD STORED 
          MX0    -12
          SX7    B0 
          BX1    -X0*X1      CHECK EOL
          ZR     X1,RET1     PROPER EOL 
          SA7    A6+1        66-BIT EOL 
 RET1     SB7    PADC 
          RJ     =XBASRBR=   RESTORE REGISTERS
          SX7    B7-B2
          SB7    PADA        RETURN ADDRESS POINTER 
          SA7    B7          POINTER TO STRING POINTER
          JP     B6          EXIT 
*CALL ERMNUM
  
**        ERROR CALLS.
  
          EXT    RNBLOCK,RNLIST,DBUGON,BASEGEN
  
  
 ER192    BSS    0           *ILLEGAL LPAD$ PARAM*
          RTERROR  ERMN192,ERM192,BASEGEN 
  
 ER193    BSS    0           *ILLEGAL RPAD$ PARAM*
          RTERROR  ERMN193,ERM193,BASEGEN 
          SPACE  4
 ERM192   DATA   C* ILLEGAL LPAD$ PARAMETER * 
  
 ERM193   DATA   C* ILLEGAL RPAD$ PARAMETER * 
 SAVREG   BSS    2
          SPACE  4
 BASXLPD  BSS    0           LWA+1 OF LPAD$ PROCESSOR 
          SPACE  4
 RPD      BSS    0           ENTRY FOR RPAD$
          RJ     =XBASSBR=   SAVE REGISTERS 
          NG     X4,ER193 
          BX6    X4 
          SA6    SAVREG 
          SX6    B6 
          SA6    A6+1 
          SB7    A5 
          RJ     =XBASXLEN
          NX5    X5 
          SA4    SAVREG 
          FX4    X4-X5
          SA5    A5 
          SA3    A4+1 
          SB6    X3 
          NX4    X4 
          PL     X4,RPD01          IF RESULT IS LESS THAN ZERO
          SA4    SETZER0           THEN MAKE IT A ZERO
 RPD01    SB2    ER193             *ILLEGAL RPAD$ PARAMETER*
          RJ     PAD               CHECK INPUT
          SA4    PADA 
          SA4    X4 
          SB7    X6          WHOLE WORDS
          SA2    PADB 
          SX6    B0 
          SB6    BASTRPD     RETURN ADDRESS 
          SA6    B3          ZERO FIRST WORD
          ZR     X4,RPD2     IF NULL STRING 
          SA1    B2-1        PRESET A1
          ZR     B7,RPD3     IF NO FULL WORDS 
 RPD1     SA1    A1+B1       COPY OLD STRING TO NEW AREA
          SB7    B7-B1       DECREMENT XFER COUNT 
          BX6    X1 
          SA6    B3          NEW STRING AREA
          SB3    B3+B1
          GT     B7,B0,RPD1 
 RPD3     SA2    PADB 
          ZR     X7,RPD2     NO EXTRA CHARACTERS
  
*         PAD A PARTIALLY FILLED WORD.
  
          IX4    X7+X7
          LX5    X4,B1
          IX4    X4+X5       X7*4 
          MX0    1
          SB4    X4-1 
          SA1    A1+B1
          AX0    X0,B4
          BX4    -X0*X3 
          IX6    X1+X4       SPACE-FILL LAST WORD 
          SX1    X7-10
          SA6    B3 
          IX2    X1+X2       REQUIRED MINUS ADDED 
          ZR     X2,RETPAD   FINISHED 
          SB3    B3+1 
          NG     X2,RPD4     TOO MANY SPACES ADDED
 RPD2     RJ     =XBAS.MOD
          ZR     X6,RPD6     NO WHOLE WORD PADDING
  
*         PUT IN FULL WORD PADDING (10 CHARACTERS). 
  
          SB7    X6 
          BX6    X3          PAD CONSTANT 
 RPD5     SA6    B3 
          SB7    B7-1 
          SB3    B3+B1
          GT     B7,B0,RPD5 
 RPD6     ZR     X7,RETPAD   NO PARTIAL SPACES
  
*         PUT IN 1-9 SPACES.
  
          IX6    X7+X7
          LX7    2
          IX7    X6+X7       X7*6 
          MX0    1
          SB4    X7-1 
          AX0    X0,B4
          BX6    X0*X3
          SA6    B3          FINAL PADDING
          JP     RETPAD      FINISH 
  
*         TOO MANY SPACES ADDED, REMOVE THE EXCESS. 
  
 RPD4     IX5    X2+X2
          LX2    2
          MX0    1
          IX2    X2+X5
          SB4    X2+B1
          LX0    X0,B4       CREATE MASK
          SB4    B1-B4       ADJUST TO POSITIVE 
          LX0    X0,B4       POSITION MASK
          BX6    -X0*X6      REMOVE EXCESS SPACES 
          SA6    A6 
          JP     RETPAD      FINISH 
  
 BASXRPD  BSS    0           LWA+1 OF RPAD$ PROCESSOR 
          EJECT 
          CON    10HBASTRTR 
 BASTRTR  PS                 RTRM$ ENTRY
          RJ     TRM         PRESET 
          SB4    B2+X6       FIND LWA OF STRING 
          ZR     X7,RTR1     IF NO CHARACTERS TRAILING
          SB4    B4+B1
 RTR1     SX6    B0 
          SA1    TRMA 
          SA1    X1 
          SA6    B3          ZERO FIRST WORD
          SB6    BASTRTR     RETURN ADDRESS 
          ZR     X1,RETTRM   IF NULL STRING 
          MX0    -6          CHARACTER MASK 
          SB4    B4-B1       ADJUST LWA PROPERLY
          SB5    10          CONSTANT 10
          AX1    18+18
          SA3    TRMD        =10H 
          SB7    X1          INPUT STRING LENGTH
          ZR     X7,RTR2     IF MULTIPLE OF 10 CHARACTERS 
          IX6    X7+X7
          SA2    B4 
          LX5    X6,B1
          IX6    X6+X5       X5*6 
          SB6    X6 
          LX1    X2,B6       RIGHT JUSTIFY
          BX6    X1-X3       MATCH WITH SPACES
          EQ     B2,B4,RTR5  IF ONLY 1 WORD 
          SB6    X7 
          SB4    B4-B1
          NZ     X6,RTR3     ENTER LOOP IF NECESSARY
          SB7    B7-B6
 RTR2     EQ     B4,B2,RTR5  IF LAST (=FIRST) WORD
          SB6    B5          CHARACTERS/WORD
          SA1    B4          READ UP OBJECT WORD
          SB4    B4-B1
          BX6    X1-X3       MATCH WITH SPACES
          NZ     X6,RTR3     IF SOME NON-BLANK
          SB7    B7-B5       DECREMENT STRING LENGTH
          EQ     RTR2        NEXT WORD
  
 RTR3     ZR     B6,RTR2     IF END OF WORD 
          BX2    -X0*X6 
          SB6    B6-B1       CHARS/WORD 
          LX6    -6          BACK OBJECT 1 CHARACTER
          SB7    B7-B1       CHARACTERS/STRING
          ZR     X2,RTR3     IF A SPACE 
  
*         LAST CHARACTER WAS NOT A SPACE. 
  
 RTR4     SA1    B2          MOVE STRING TO NEW AREA
          SB3    B3+B1
          BX6    X1 
          SB2    B2+B1
          SA6    B3-B1
          LE     B2,B4,RTR4 
          SB6    B6+B1       NON-BLANK CHARS IN LAST WORD 
          SX7    B6+B6
          MX0    1
          LX5    X7,B1
          IX5    X5+X7       B6*6 
          SB2    X5-1 
          SA1    B4+B1
          AX0    X0,B2       CREATE MASK
          BX6    X0*X1       TRIM OFF EXCESS FAT
          SA6    A6+B1       LAST WORD
 RTR8     SX7    B7+1        NEW LENGTH 
          SA7    TRME 
          SX7    A6+
          SA7    TRMA        SAVE A6
          SX6    TRMC 
          SA6    TRMG 
          SA1    TRMF 
          RJ     =XBASSMTS   TRUNCATE NEW STRING
          SA1    TRMA 
          SB6    BASTRTR     RETURN ADDRESS 
          SA2    X1 
          BX6    X2 
          SA6    X1          RESET A6 
          JP     RETTRM      FINISH 
  
 RTR7     SX6    B0 
          SA6    B3          NULL STRING
          EQ     RTR8        FINISH 
  
*         HANDLE LAST WORD. 
  
 RTR5     SX2    B7+B7
          SA1    B2 
          LX4    X2,B1
          BX1    X3-X1       MATCH WITH SPACES
          IX4    X2+X4       B7*6 
          SB4    X4 
          LX1    B4          RIGHT-JUSTIFY WORD 
 RTR6     ZR     B7,RTR7     IF ALL SPACES
          BX6    -X0*X1 
          SB7    B7-B1       DECREMENT STRING LENGTH
          LX1    -6 
          ZR     X6,RTR6     IF A SPACE 
          SB7    B7+B1       OVER CORRECTED BEFORE
          MX0    1
          SX2    B7+B7
          SA4    B2          RELOAD LAST WORD 
          LX3    X2,B1
          SX7    B7 
          IX2    X2+X3       B7*6 
          SA7    TRME        SAVE STRING LENGTH 
          SB4    X2-1 
          AX0    X0,B4
          BX6    X0*X4       TRIM WORD
          SX7    TRMC 
          SA6    B3+         MOVE TO NEW STRING AREA
          SA7    TRMG 
          SA1    TRMF 
          RJ     =XBASSMTS   TRUNCATE TO 1 WORD 
          SA1    TRMC 
          SA1    X1 
          BX6    X1 
          SB6    BASTRTR     RETURN ADDRESS 
          SA6    A1+         RESET A6 
          JP     RETTRM      FINISH 
          SPACE  4,4
          CON    10HBASTLTR 
 BASTLTR  PS                 LTRM$ ENTRY
          EQ     LTR         GOTO PROCESSOR 
          SPACE  4
**        TRM - PRESET FOR LTRM$ AND RTRM$. 
* 
*         ENTRY  (X5) = INPUT STRING POINTER. 
* 
*         EXIT   (B2) = FWA READ. 
*                (B3) = FWA WRITE.
*                (X6) = INPUT STRING LENGTH DIV 10. 
*                (X7) = INPUT STRING LENGTH MODULO 10.
*                (B1) = 1.
* 
*         CALLS  BASSBR=, BASSMGS, BAS.MOD. 
  
  
 TRM      PS                 ENTRY/EXIT 
          RJ     =XBASSBR=   SAVE REGISTERS 
          SX7    TRMC 
          SA7    TRMG 
          SX6    A5 
          SA6    TRMA        SAVE STRING POINTER
          AX5    18+18
          SA1    TRMF        FTN/SYMPL CALL BLOCK 
          SX6    X5 
          SA6    TRME        SET LENGTH 
          RJ     =XBASSMGS   GET NEW STRING SPACE EQUAL IN
*                                LENGTH TO CURRENT STRING.
          SA2    TRMA 
          SA2    X2 
          SB4    0
          PL     X2,TRM1     OLD FWA IS ABSOLUTE
          SA3    REG=+4 
          SB4    X3+         OLD FWA IS REL TO B4 
 TRM1     SB2    X2+B4       SET ACTUAL CURRENT FWA 
          SA1    TRMC 
          AX2    18+18
          SB3    X1          FWA WRITE
          SX2    X2 
          RJ     =XBAS.MOD   GET LENGTH QUOTIENTS 
          SB1    1
          JP     TRM         RETURN 
          SPACE  4
 TRMA     BSS    1           INPUT STRING POINTER 
 TRMC     CON    0           OUTPUT STRING POINTER
 TRMD     CON    1H          BLANK MASK FOR MATCHING
 TRME     BSS    1           REQUESTED LENGTH 
 TRMF     CON    TRMG        ADDRESS OF ADDRESS OF STRING POINTER 
          CON    TRME        ADDRESS OF REQUESTED LENGTH
 TRMG     CON    TRMC        ADDRESS OF STRING POINTER
          SPACE  4
**        RETTRM - RETURN FROM XTRM$ PROCESSOR. 
* 
*         ENTRY  (A6) = ADDRESS OF LAST WORD STORED.
*                (B6) = EXIT ADDRESS. 
*                (TRMC) = FWA OF NEW STRING.
*                (TRME) = LENGTH OF NEW STRING. 
* 
*         CALLS  BASRBR=. 
  
  
 RETTRM   SA1    A6 
          MX0    -12
          SX7    B0 
          BX1    -X0*X1 
          ZR     X1,RTT1     IF PROPER EOL
          SA7    A6+1              66 BIT EOL(CAN'T USE B1 - DESTROYED) 
 RTT1     SB7    TRMC 
          RJ     =XBASRBR=   RESTORE REGISTERS
          SX7    B7-B2
          SB7    TRMA 
          SA7    B7          POINTER TO STRING POINTER
          JP     B6          EXIT 
          SPACE  4
 BASXRTR  BSS    0           LWA+1 OF RTRM$ PROCESSOR 
          SPACE  4,4
 LTR      RJ     TRM         PRESET 
          SB4    B2+X6       FIND LWA 
          NZ     X7,LTR1
          SB4    B4-B1
 LTR1     SA1    TRMA        INPUT STRING POINTER 
          SA1    X1 
          SB6    BASTLTR     RETURN ADDRESS 
          BX6    X6-X6
          AX1    18+18
          MX0    6
          SB7    X1          INPUT STRING LENGTH IN CHARACTERS
          SA3    TRMD        =10H 
          SA6    B3+         ZERO FIRST WORD OF NEW STRING
          ZR     B7,RETTRM   IF NULL INPUT
          SB5    10          CONSTANT TEN 
 LTR2     EQ     B2,B4,LTR4  IF LAST WORD 
          SB6    B5 
          SA1    B2          READ UP INPUT
          SB2    B2+B1
          BX6    X1-X3       MATCH WITH SPACES
          NZ     X6,LTR3     IF NOT ALL SPACES
          SB7    B7-B5       DECREMENT STRING LENGTH 1 WORD 
          EQ     LTR2        GET NEXT WORD
  
 LTR3     ZR     B6,LTR2     IF END OF WORD 
          BX2    X0*X6
          SB6    B6-B1       CHARACTERS/WORD
          LX6    6
          SB7    B7-B1       CHARACTERS/STRING
          ZR     X2,LTR3     IF A SPACE 
  
*         LAST CHARACTER WAS NOT A SPACE. 
  
          SB7    B7+B1       NEW STRING LENGTH
          MX0    1
          SB6    B6+B1       NON-BLANK CHARACTERS LEFT IN WORD
          SX7    B7 
          SX3    B6+B6
          SA7    TRME        SAVE LENGTH
          LX4    X3,B1
          EQ     B5,B6,LTR8  IF ENTIRE WORD 
          IX4    X4+X3       B6*6 
          SB5    X4-60
          AX1    X1,B5       LEFT-JUSTFIY (B5<0)
          SB4    X4-1 
          AX0    X0,B4
          SX2    B6          N
          BX5    X0*X1       FIRST N CHARACTERS 
          RJ     CPY         COPY TO NEW STRING AREA
 LTR6     SX6    A6+
          SA1    TRMF        FTN/SYMPL CALL BLOCK 
          SA6    TRMA        SAVE A6
          SX7    TRMC 
          SA7    TRMG 
          RJ     =XBASSMTS   TRUNCATE NEW STRING
          SA1    TRMA 
          SB6    BASTLTR
          SA1    X1 
          BX6    X1 
          SA6    A1+         RESTORE A6 
          JP     RETTRM      FINISH 
  
 LTR8     BX6    X1 
          SA6    B3          NEW STRING AREA
          SB3    B3+1 
 LTR9     SA1    B2 
          SB2    B2+B1
          BX6    X1 
          SA6    B3 
          SB3    B3+1 
          LE     B2,B4,LTR9 
          EQ     LTR6        COMPLETE 
  
*         HANDLE LAST WORD. 
  
 LTR4     SA2    B2 
          SA1    TRMF        FTN/SYMPL CALL BLOCK 
          BX6    X2-X3       MATCH WITH SPACES
 LTR5     ZR     B7,LTR7     IF ALL SPACES
          BX4    X0*X6
          LX2    6
          SB7    B7-B1       DECREMENT TOTAL LENGTH 
          LX6    6
          ZR     X4,LTR5     IF A SPACE 
          SB7    B7+B1       NEW STRING LENGTH
          MX0    1
          SX3    B7+B7
          SX7    B7 
          LX4    X3,B1
          SA7    TRME        SAVE LENGTH
          IX4    X3+X4       B7*6 
          SB4    X4-1 
          LX2    -6 
          AX0    X0,B4
          BX6    X0*X2       TRIM TO PROPER SIZE
          SA6    B3          STORE IN NEW STRING AREA 
          EQ     LTR6        COMPLETE THE JOB 
  
 LTR7     BX6    X6-X6
          SA6    TRME        SET ZERO LENGTH
          SA6    B3          SET NULL STRING
          EQ     LTR6        COMPLETE THE JOB 
  
 BASXLTR  BSS    0           LWA+1 OF LTRM$ 
          SPACE  4
          END 
