Okay, you UUencoder types should get a kick out of this.
Quoted in it's entirety...  8-)

-------------------------------------------------------


From jtucker@byron.apana.org.au
Date: Sun, 18 Jun 1995 21:15:52 +0930
From: Jim Tucker <jtucker@byron.apana.org.au>
To: jvahn@short.circuit.com
Subject: Mode 91 encoder/decode

James:

I finally found inspiration to translate the mod91 encoder Terje
Mathisen sent me in Norwegian- a language we can all understand ;).

Here are the working models. The encoder is slightly complex but the
payoff if is the decoder (which is the important bit) is tiny, efficient
and complies with the FTS* standard.

The encoded data can have eol code or blank spaces anywhere. UNIX or 
Mac line endings okay too. Or you can have no line endings at all!

The only thing it will not like is a missing last line. This contains 
the terminating char " (ASCII 34) followed by the number of bytes
to ignore asciified (+'0'). Ideally, I would store a size in the first n 
bytes of data. This would add to the size of the decoder.

The expansion is 1.234 (curious number that). In the real world 
including crlf it is slightly more than 1.25:

       40,000 uue    => 56006 bytes
       40,000 base91 => 50774 bytes




* Fault Tolerant Software

.............. clip ..................................................

; BASE91 DECODER
; BAS91DEC <INFILE >OUTFILE

start:	mov	ah,3Fh		; read from stdin
	xor	bx,bx
	mov	dx,buffer
	push	dx		; save DX for writing
	mov	cx,65000
	int	21h

	mov	si,buffer	; start of data
        mov     di,si		; write over input
	cld
        xor     cx,cx
	mov	cl,8

top:	lodsb
        sub	al,34
        jb	top		; ignore
        jz	done		; eof
        dec	ax
        mov	ah,91
        mul	ah
        xchg    ax,dx           ; Save first 6.5 bits
        xor     ax,ax

next:	lodsb
        sub	al,35
        jb	next
        add	ax,dx           ; Add together to 13 bits
        stosb                   ; Save low 8
        xor     al,al
        shr     ax,cl
        or      ch,al
        sub     cl,5
	jg	top
        mov     [di],ch
        inc     di
        mov     ch,ah
	add	cl,8
        jmp	top

done:	pop	dx		; begin data
	mov	cx,di		; last byte read
	sub	cx,dx		; bytes read
	lodsb			; bytes to ignore
	sub	al,'0'		; ascii correction
	cbw
	sub	cx,ax		; bytes to write
	mov	ah,40h		; write
	mov	bx,1		; stdout
	int	21h
	mov	ax,4C00h
	int	21h

buffer equ $

.............. clip ..................................................

; BASE91 ENCODER
; BAS91ENC <INFILE >OUTFILE

	jmp	start

MAXSIZE EQU 52500

ilen		dw	?	; size of input
out_pointer	dw	0	; pointer
char_count	db	4       ; for crlf
ignore_byte	db	?

start:	mov	bx,sp		; use 64K for this
	mov	cl,4
	shr	bx,cl
	inc	bx
	mov	ah,4Ah
	int	21h		; should jc error

	mov	bx,1000h	; allocate 64K segment
	mov	ah,48h		; for output
	int	21h		; should jc error
	mov	es,ax		; output goes to es

	mov	ah,3Fh		; read stdin
	xor	bx,bx
	mov	dx,buffer
	mov	cx,MAXSIZE
	int	21h
	mov	cx,buffer	; target
	add	cx,ax		; add bytes read
	mov	ilen,cx

; We always read 13 (maybe past eof) so we tell the decoder how many 
; bytes to ignore.

	mov	bx,13		; calc # bytes to ignore
	cwd			; clears dx
	idiv	bx
	mov	al,dl		; mod 13
	or	al,al		; any bytes left?
	jz	>l1		; no
	sub	bl,al		; calc how many
	mov	al,bl
L1:	add	al,'0'		; asciify
	mov	ignore_byte,al	; save it for now
	mov	bx,buffer	; initialize bx

;-----------------------------------------------------------------------
;

enc_loop:

; a = i[2]
; word ptr [0] = i[0] + ((a & 0x1f) << 8);
    
        mov     al,[bx+2]	; a = i[2]
        mov     ah,0
        mov     si,ax

        and     ax,31
        mov     cl,8
        shl     ax,cl
        mov     dl,[bx]
        mov     dh,0
        add     dx,ax
        mov     word ptr [enc],dx

; b = i[5]
; word ptr [1] = i[1] + ((a & 0xe0) << 3) + ((b & 0x3) << 11);

	mov     al,[bx+5]	; b = i[5]
        mov     ah,0
        mov     di,ax

        mov     al,[bx+1]
        mov     ah,0
        mov     dx,si
        and     dx,0E0h
        shl     dx,1
        shl     dx,1
        shl     dx,1
        add     ax,dx
        mov     dx,di
        and     dx,3
        mov     cl,11
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+2],ax

; word ptr [2] = i[3] + ((b & 0x7c) << 6);

        mov     al,[bx+3]
        mov     ah,0
        mov     dx,di
        and     dx,124
        mov     cl,6
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+4],ax
   
; a = i[7];
; word ptr [3] = i[4] + ((b & 0x80) << 1) + ((a & 0xf) << 9);

        mov     al,[bx+7]       ; a = i[7]
        mov     ah,0
        mov     si,ax

        mov     al,[bx+4]
        mov     ah,0
        mov     dx,di
        and     dx,128
        shl     dx,1
        add     ax,dx
        mov     dx,si
        and     dx,15
        mov     cl,9
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+6],ax
 
; b = i[10];
; word ptr [4] = i[6] + ((a & 0xf0) << 4) + ((b & 0x1) << 12);

        mov     al,[bx+10]      ; b = i[10]
        mov     ah,0
        mov     di,ax

        mov     al,[bx+6]
        mov     ah,0
        mov     dx,si
        and     dx,240
        mov     cl,4
        shl     dx,cl
        add     ax,dx
        mov     dx,di
        and     dx,1
        mov     cl,12
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+8],ax

; word ptr [5] = i[8] + ((b & 0x3e) << 7);

	mov     al,[bx+8]
        mov     ah,0
        mov     dx,di
        and     dx,62
        mov     cl,7
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+10],ax
  
; a = i[12];
; word ptr [6] = i[9] + ((b & 0xc0) << 2) + ((a & 0x7) << 10);

        mov     al,[bx+12]      ; a = i[12]
        mov     ah,0
        mov     si,ax

	mov     al,[bx+9]
        mov     ah,0
        mov     dx,di
        and     dx,192
        shl     dx,1
        shl     dx,1
        add     ax,dx
        mov     dx,si
        and     dx,7
        mov     cl,10
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+12],ax

; word ptr [7] = i[11] + ((a & 0xf8) << 5);

	mov     al,[bx+11]
        mov     ah,0
        mov     dx,si
        and     dx,248
        mov     cl,5
        shl     dx,cl
        add     ax,dx
        mov     word ptr [enc+14],ax
  
;-----------------------------------------------------------------------
;    
; read 8 bytes and write 16 to es:di   

	push	bx
	mov	si,OFFSET enc
	mov	di,out_pointer
	mov	cx,8
    
; *o++ = a / 91 + 35;
    
L1:	lodsw
	push	ax
	mov     bx,91
        cwd     
        idiv    bx
        add     al,35
	stosb
    
; *o++ = a % 91 + 35;
    
	pop	ax
        mov     bx,91
        cwd     
        idiv    bx
	mov	al,dl
	add     al,35
	stosb
	loop	l1

	dec	char_count		; crlf
	jnz	no_ch
	mov	ax,0A0Dh
	stosw
	mov	al,4
	mov	char_count,al

no_ch:	mov	out_pointer,di
	pop	bx
	add	bx,13			; bump input pointer
	cmp	bx,word ptr ilen	; read to end?
	jae	done			; yes
	jmp	enc_loop

;-----------------------------------------------------------------------

done:	mov	di,out_pointer          ; eof char
	mov	al,'"'
	stosb
	mov	al,ignore_byte          ; for decoder                  
	stosb
	mov	ax,0A0Dh
	stosw

	mov	cx,di                   ; write stdout
	xor	dx,dx
	mov	ah,40h
	mov	bx,1
	push	es
	pop	ds
	int	21h
	mov	ax,4C00h
	int	21h

enc	equ	$
	dw	8 dup (0)

buffer	equ $

[end.of.it]


From jtucker@byron.apana.org.au
Date: Wed, 21 Jun 1995 12:27:44 +0930
From: Jim Tucker <jtucker@byron.apana.org.au>
To: jvahn@short.circuit.com
Subject: Base 91 (more asm source)

James: You know that Base 91 stuff I translated from C ? It does an 
awful lot of messing around. Well, I sent it to Terje Mathisen who wrote 
the C code. He sent me this. The moral, of course, it don't do maths
when you can use a table. You might like to add this to the other stuff.

.... clip.............................................................

; Table giving offset to low extra bits, high extra bits, and low byte:
encode_table label byte
db 2,2,0, 2,5,1, 5,5,3, 5,7,4, 7,10,6, 10,10,8, 10,12,9, 12,12,11

encode_block:
  mov cx,91 * 256               ; CH has divider, CL shift count (= 0)
  mov bx,0

next_outer_loop:
  mov bp,OFFSET encode_table
  mov dx,8                      ; Generate 8 pairs of output!

next_inner_loop:
  mov bl,[bp]                   ; Offset to low extra bits
  mov al,[si+bx]
  mov bl,[bp+1]                 ; Ditto for high part
  mov ah,[si+bx]
  mov bl,[bp+2]
  add bp,3                      ; Point to next 3-byte offset ptr block
  shl ax,cl                     ; shift into position
  add cl,3                      ; adjust shift count for next iteration
  and ah,1fh                    ; and keep 5 low bits of AH
  and cl,7                      ; Must be in 0 to 7 range!
  mov al,[si+bx]                ; Retrieve AL directly
  div ch                        ; Divide AX by 91
  add ax,2323h                  ; Add 35 to AL and AH
  stosw                         ; and save (already in proper order!)
  dec dx                        ; More pairs?
   jnz next_inner_loop

  add si,13
  cmp si,bytes_to_read
   jb next_outer_loop
   ... done

[.sig]