LEX   'RASTERLX'
        ID     #53
        MSG    0
        POLL   0
        ENTRY  RASTER   
        CHAR   #F
        KEY   'RASTER$'
        TOKEN  #16
        ENDTXT
* 53 16 F R0A93B RASTER$
IVAERR  GOVLNG #0E920     =IVAERR
        NIBHEX 8422
RASTER  GOSBVL #0E8FD     =POP1R get a real #
        GOSBVL #1B223     =FLTDH convert to hex
        GONC   IVAERR     may not be negative
        C=0    W          clear for test
        LCHEX  7          max allowable input
        ?C<A   A          if greater, error exit
        GOYES  IVAERR     
        LCHEX  1          build mask in position specified
R0A957  A=A-1  A          shift it into desired position
        GOC    R0A961     exit when desired count is done
        C=C+C  A          
        GONC   R0A957     
R0A961  R0=C              save mask
        D1=D1+ 16         move pointer to string parameter
        GOSBVL #0BD38 =POP1S pop it
        D1=D1- 16         replace header with eight 00 bytes
        C=0    W          this is the key to the speed of RASTER$..
        DAT1=C W          you need only test for valid input after 
        LCHEX  E          outputing a byte. Now, we round string length up
        C=C+A  A          to a multiple of 8 bytes
        CSR    W          the number of sets of eigth bytes
        D=C    A          is our loop counter
        D1=D1+ 16         now, compute start of string
        CD1EX             
        C=C+A  A          
        D1=C              and move the input and output pointers to said start
        R1=C              save the address for ADHEAD
        CD0EX             
        CR0EX             save D0 and get your mask back
        B=C    A          Keep mask in B[B]
R0A995  D=D-1  A          the loop counter (we finally start working)
        GOC    R0A9BF     exit if counter was 0
        P=     7          8 bits /input bytes, less 1, per output byte
        C=0    A          pre-clear? (should not be needed)
R0A99E  D1=D1- 2          advance input pointer
        A=DAT1 B          get a byte
        A=B&A  B          is particular bit set?
        C=C+C  A          shift previous inputs out of the way
        ?A=0   B          test to determine if bit was set
        GOYES  R0A9B1     no, the input is a 0 bit
        C=C+1  A          yes, set corresponding bit in output byte
R0A9B1  P=P-1             decrement output bit counter
        GONC   R0A99E     not done, get next output bit
        D0=D0- 2          we have a full byte, advance output pointer
        DAT0=C B          and store the byte
        GONC   R0A995     B.E.T. - keep going until done
R0A9BF  A=R0              restore D0
        AD0EX             
        D=0    A          D[A] should hold AVMEMS for ADHEAD. Since we know
        D1=A              mem is OK, this is the fastest way to avoid errors
        ST=0   0          we do not want to return from ADHEAD
        P=     0          
        GOVLNG #181B7     =ADHEAD Done!
        END
*************************************************
* Obviously, we could save a few nibs by using D0 as the input pointer and D1
* as the output pointer.
* In spite of this, RASTER$ is almost 8 times faster than DOT2DOT$.
*************************************************