: UD/MOD  ( ud1 u2 -- u3 ud4 ) \ 32/16->32 divide
  >R 0 R@ UM/MOD ROT ROT R> UM/MOD ROT
;

: #  (+d1 -- +d2 )
\ d1 is divided by BASE and the quotient is d2.
\ The remainder is appended to the numeric output string via HOLD
BASE @  ( +d1 base )
(#)  ( +d2 'digit' )
HOLD ; ( +d2 )

And here's the (currently working) sharp code
: #   BASE @  UD/MOD ROT >6502 
      TOS LDA,
      SED,
      10 # CMP,
      ASCII 0 # ADC,
      CLD,
      TOS STA,
      TOFORTH JSR,
  HOLD ;

: UM/MOD UD/MOD DROP ;

;
; UM/MOD -      ( ud u1 -- u2 u3)
;               An unsigned division of the 32 bit IACC (ud)
;               by the 32 bit IOPR (u1 extended to 32 bits)
;               REMAINDER IS u2 (IACCl)
;      AND QUOTIENT IS u3 (IQUOTl moved to IACCh)
;      
UMDMOD  TXA                     ;      +---------------+
        SEC                     ;  +12 | h         udl |
        SBC     #6              ;  +11 | l          u2 | IACCl
        TAX                     ;      +---------------+
        LDA     #0              ;  +10 | h         udh |
        STA     STACK+1,X       ;   +9 | l             | IACCh
        STA     STACK+2,X       ;      +---------------+
        STA     STACK+3,X       ;   +8 | h          u1 |
        STA     STACK+4,X       ;   +7 | l             | IOPRh
        STA     STACK+5,X       ;      +---------------+
        STA     STACK+6,X       ;   +6 | h           0 |
        LDY     #16             ;   +5 | l             | IOPRl
; IOPR shifted 16 bits already  ;      +---------------+
_SHIFTL LDA     STACK+8,X       ;   +4 | h          u3 |
        BMI     _LOOP           ;   +3 | l             | IQUOTl
        ASL     STACK+7,X       ;      +---------------+
        ROL     STACK+8,X       ;   +2 | h           0 |
        INY                     ;   +1 | l             | IQUOTh
        BNE     _SHIFTL         ;      +---------------+
_LOOP   LDA     STACK+10,X      ;  X-->|               |
        CMP     STACK+8,X       ;
; Check if IOPR  > IACC         ;
        BCC     _SHIFTR         ;
        BNE     _SUBTR          ;
        LDA     STACK+9,X       ;
        CMP     STACK+7,X
        BCC     _SHIFTR
        BNE     _SUBTR
        LDA     STACK+12,X
        CMP     STACK+6,X
        BCC     _SHIFTR
        BNE     _SUBTR
        LDA     STACK+11,X
        CMP     STACK+5,X
        BCC     _SHIFTR
_SUBTR  SEC                     ; If IOPR <= IACC THEN
        LDA     STACK+11,X      ; subtract IOPR from IACC
        SBC     STACK+5,X       ; and shift 1 into IQUOT
        STA     STACK+11,X
        LDA     STACK+12,X
        SBC     STACK+6,X
        STA     STACK+12,X
        LDA     STACK+9,X
        SBC     STACK+7,X
        STA     STACK+9,X
        LDA     STACK+10,X
        SBC     STACK+8,X
        STA     STACK+10,X
_SHIFTR ROL     STACK+3,X       ; else shift 0 into IQUOT
        ROL     STACK+4,X
        ROL     STACK+1,X
        ROL     STACK+2,X
        LSR     STACK+8,X       ; shift IOPR right
        ROR     STACK+7,X
        ROR     STACK+6,X
        ROR     STACK+5,X
        DEY                     ; continue counted shifts and subtracts
        BPL     _LOOP
        LDA     STACK+3,X       ; copy IQUOT(L) TO right spot on stack
        STA     STACK+9,X       ; (remainder already in right place)
        LDA     STACK+4,X
        STA     STACK+10,X
        TXA                     ; CLEAN UP STACK
        CLC
        ADC     #8
        TAX
        RTS

  : ud/mod ( ud1 u2 -- urem udquot )
     >r   0 r@ um/mod   r> swap >r   um/mod r> ;

; - - - - - - - - - - - - - - - - - - - - - - - - - - -
; UD/MOD  ( ud1 u1 -- u2 ud2 )
; Dividend ud1 and Quotient ud2 are 32-bits unsigned
; Divisor u1 and Remainder u2 are 16-bits unsigned
; Invalid inputs and/or outputs are silently ignored
;
udslashmod:
        lda  #0
        sta  N          ;initialize partial remainder
        sta  N+1        ;  in N, N+1
        ldy  #32        ;loop counter
udsm2:
        asl  stackl+1,x ;Dividend in NOS:3OS (h:l)
        rol  stackh+1,x ;  is gradually replaced
        rol  stackl,x   ;  with the quotient
        rol  stackh,x
        rol  N          ;N is gradually replaced
        rol  N+1        ;  with the remainder
        lda  N
        cmp  TOS        ;TOS holds divisor
        lda  N+1        ;partial remainder >= TOS?
        sbc  TOS+1
        bcc  udsm3
        sta  N+1        ;  yes: update the partial
        lda  N          ;    remainder and set the
        sbc  TOS        ;    low bit in the partial
        sta  N          ;    quotient
        inc  stackl+1,x
udsm3:
        dey
        bne  udsm2      ;loop 32 times
        lda  N
        ldy  N+1        ;remainder goes to TOS
        jsr  put
        jsr  rot        ;ROT
        jmp  rot        ;ROT ;