; - - - - - - - - - - - - - - - - - - - - - - - - - - -
; UM/MOD  ( ud u1 -- u2 u3 )
; Dividend ud is 32-bits unsigned.  Divisor u1,
; Remainder u2 and Quotient u3 are 16-bits unsigned
; Invalid inputs and/or outputs are silently ignored
; 1823 cycles (+ NEXT) best case (zero quotient)
; 2239 cycles (+ NEXT) worst case (zero divisor)
;
umslashmod:
        jsr  xudivmod   ; (do the dirty work)
        inx             ; NIP
        jmp  swap       ; SWAP

; - - - - - - - - - - - - - - - - - - - - - - - - - - -
; 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
; 1856 cycles (+ NEXT) best case (zero quotient)
; 2272 cycles (+ NEXT) worst case (zero divisor)
;
udslashmod:
        jsr  xudivmod   ; (do the dirty work)
        jmp  dashrot    ; -ROT

; - - - - - - - - - - - - - - - - - - - - - - - - - - -
; Internal divmod routine used by UM/MOD and UD/MOD
; ( ud1 u1 -- ud2 u2 )
; ud1 is dividend, u1 is divisor
; ud2 is quotient, u2 is remainder
xudivmod:
        ldy  #32        ;[2] init loop counter
        lda  #0         ;[2] init partial remainder
        sta  N          ;[3]   in N:A (h:l)
xudm2:
        asl  stackl+1,x ;[6] dividend in NOS:3OS (h:l)
        rol  stackh+1,x ;[6]   is gradually replaced
        rol  stackl,x   ;[6]   with the quotient
        rol  stackh,x   ;[6]
        rol             ;[2] N:A is gradually replaced
        rol  N          ;[5]   with the remainder
        pha             ;[3]
        cmp  TOS        ;[3] TOS holds divisor
        lda  N          ;[3] partial remainder >= TOS?
        sbc  TOS+1      ;[3]
        bcc  xudm3      ;[3]*
        sta  N          ;[3]   yes: update the partial
        pla             ;[4]     remainder and set the
        sbc  TOS        ;[3]     low bit in the partial
        inc  stackl+1,x ;[6]     quotient
        .db  $c9        ;[2]*  cmp# naked opcode
xudm3:
        pla             ;[4]*
        dey             ;[2] loop 32 times
        bne  xudm2      ;[3]*
        sta  TOS        ;[3]
        ldy  N          ;[3]
        sty  TOS+1      ;[3]
        rts             ;[6]

;------------------------------------------------------
; UM/MOD for the 65802/816 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
;
; ( ud u1 -- u2 u3 )
;
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
;
; Quotient overflow or /0 results in a quotient and
;   remainder of $FFFF.  Although $FFFF could be a
;   valid quotient, it cannot be a valid remainder,
;   so the caller may use this fact to check for an
;   invalid result.
;
; 0,x is TOS ( divisor -- quotient )
; 2,x is NOS ( hi dividend -- remainder )
; 4,x is 3OS ( lo dividend --  )
;
; Accumulator and memory are in 16-bit mode.
; Index registers are in 8-bit mode.
;
HEADER "UM/MOD", NOT_IMMEDIATE ; ( ud u -- rem quot )
        CODE            ; Machine code primitive.
umslashmod:
        lda  2,x        ; If hi cell of dividend is
        cmp  0,x        ;   >= divisor, make a note
        php             ;   of overflow for later.
        ldy  #17        ; Init loop counter.
        .db  $c0        ; Skip following rol.
umsm2:
        rol             ; Shift hi cell of dividend.
; !!!!!!!!! Bug !!!!!!!!! 17th bit is lost here !!!!!!!!!
        cmp  0,x        ; if (hi dividend >= divisor)
        bcc  umsm3      ; then update remainder
        sbc  0,x        ;   and leave carry set
umsm3:
        rol  4,x        ; Shift carry into quotient.
        dey             ; Loop until done.
        bne  umsm2
        plp             ; Check for overflow.
        bcc  umsm5      ;
        tya             ; If so, put $ffff in
        dec             ;   quotient and remainder.
        sta  4,x        ;
umsm5:                  ;
        sta  2,x        ; Save remainder in NOS.
        inx             ;
        inx             ; DROP
        jmp  swap       ; SWAP ;
; 34 bytes, not counting HEADER.

;------------------------------------------------------
; UM/MOD for any 6502 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
;
; ( ud u1 -- u2 u3 )
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
;
; Quotient overflow or /0 results in a quotient and
;   remainder of $FFFF.  Although $FFFF could be a
;   valid quotient, it cannot be a valid remainder,
;   so the caller may use this fact to check for an
;   invalid result.
;
; TOS and TOS+1 are at fixed points in ZP.
; stackl,x and stackh,x are NOS.
; stackl+1,x and stackh+1,x are 3OS.
;
umslashmod:
        ldy  #17        ;[2] Init loop counter
        lda  stackl,x   ;[4]
        cmp  TOS        ;[3] If (dividend:H < divisor)
        lda  stackh,x   ;[4]
        sbc  TOS+1      ;[3] then
        lda  stackh,x   ;[4]   keep NOS:H in A for speed
        bcc  umsm4      ;[3]*  and proceed with division
        lda  #$ff       ;[2] else
        sta  stackl+1,x ;[4]   overflow: Put $ffff in
        sta  stackh+1,x ;[4]   quotient and remainder
        sta  stackl,x   ;[4]
umsm2:                  ;
        sta  stackh,x   ;[4] Exit sequence:
        jsr  slide      ;[28]  DROP the divisor
        jmp  SWAP       ;[34]* SWAP quotient and remainder
umsm3:                  ;
        sbc  TOS        ;[3]
        sta  stackl,x   ;[4] Update remainder
        pla             ;[4]  (gradually replacing
        sbc  TOS+1      ;[3]   dividend:H)
        sec             ;[2]
umsm4:                  ;
        rol  stackl+1,x ;[6] Shift carry into quotient
        rol  stackh+1,x ;[6]  (gradually replacing
        dey             ;[2]   dividend:L)
        beq  umsm2      ;[2]* Exit if done
        rol  stackl,x   ;[6] Shift dividend:H
        rol             ;[2]
        pha             ;[3]
umsm5:                  ;
        lda  stackl,x   ;[4]
        bcs  umsm3      ;[2]*
        cmp  TOS        ;[3] If (17th bit set) or
        pla             ;[4]   (dividend:H >= divisor)
        pha             ;[3]
        sbc  TOS+1      ;[3] then
        bcs  umsm5      ;[2]*  update remainder
        pla             ;[4] else
        bcc  umsm4      ;[3]   continue without update
;------------------- 64 bytes, not counting HEADER

;------------------------------------------------------
; UM/MOD for the 65802/816 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
;
; ( ud u1 -- u2 u3 )
;
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
;
; Quotient overflow or /0 results in a quotient and
;   remainder of $FFFF.  Although $FFFF could be a
;   valid quotient, it cannot be a valid remainder,
;   so the caller may use this fact to check for an
;   invalid result.
;
; 0,x is TOS ( divisor -- quotient )
; 2,x is NOS ( hi dividend -- remainder )
; 4,x is 3OS ( lo dividend --  )
;
; Accumulator and memory are in 16-bit mode.
; Index registers are in 8-bit mode.
;
HEADER "UM/MOD", NOT_IMMEDIATE ; ( ud u -- rem quot )
        CODE            ; Machine code primitive.
umslashmod:
        ldy  #17        ; Init loop counter.
        lda  2,x        ; If (hi dividend >= divisor)
        cmp  0,x        ;   then we have an overflow
        bcc  umsm4      ;   condition, so we exit
        lda  #$ffff     ;   early with $ffff in the
        sta  4,x        ;   quotient and remainder.
umsm2:                  ;
        sta  2,x        ; Save remainder in NOS.
        inx             ;
        inx             ; DROP
        jmp  swap       ; SWAP ;
umsm3:
        sbc  0,x        ; Update remainder
        sec
umsm4:
        rol  4,x        ; Shift carry into quotient.
        dey             ; Loop until done.
        beq  umsm2
        rol             ; Shift hi cell of dividend.
        bcs  umsm3
        cmp  0,x        ; If (hi dividend >= divisor)
        bcs  umsm3      ; then update remainder
        bcc  umsm4      ; else continue
;------------------- 37 bytes, not counting HEADER.
;Inspired by https://raw.githubusercontent.com/AcheronVM/acheronvm/master/src/ops-muldiv.asm

12345678 / 60000 says        64 rem 51534      This one in decimal.
                 should be  205 rem 45678      All others below are in hex.

12345678 / ABCD  says        42 rem  B9E
                 should be 1B20 rem 3DD8

 2345678 /   "   says        42 rem  B9E
                 should be  348 rem 9DD0

  345678 /   "   says        42 rem  B9E  (wrong again)
  123456 /   "   says         "  "    "      "     "

    1234 /   "   says         0 rem 1234   correct
    ABCD /   "   says         1 rem    0     "
    ABCE /   "   says         1 rem    1     "
   1ABCE /   "   says         2 rem 5434     "
  11ABCE /   "   says         2 rem 5434   wrong
                 should be   1A rem 38FC

   10000 / 1000  says        10 rem    0   correct
   20000 /   "   says        20 rem    0     "
  200000 /   "   says       200 rem    0     "
  200000 / 2000  says       100 rem    0     "
     "   / 4000  says        80 rem    0     "
     "   / 8000  says        40 rem    0     "
     "   / ABCD  says         0 rem    0   wrong
     "   / 8BCD  says         " rem    "     "
     "   / A000  says         " rem    "     "     Adding just the one bit (bit 13) in the divisor made it go wrong.  (It was ok with 8000.)

;------------------------------------------------------
; UM/MOD for any 6502 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
;
; ( ud u1 -- u2 u3 )
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
;
; Quotient overflow or /0 produces invalid results.
;
; 0,x and 1,x are TOS  ( divisor -- quotient )
; 2,x and 3,x are NOS  ( dividend:H -- remainder)
; 4,x and 5,x are 3OS  ( dividend:L --  )
;
umslashmod:
        ldy  #17        ;[2] Init loop counter
        clc             ;[2]
        bcc  umsm4      ;[3]
umsm2:                  ;
        rol  2,x        ;[6] Shift dividend:H
        rol  3,x        ;[6]
        bcs  umsm3      ;[2]* <<<<<<<<<<<<<<<<<<
        lda  2,x        ;[4]
        cmp  0,x        ;[4] If (17th bit clear) or
        lda  3,x        ;[4]   (dividend:H < divisor)
        sbc  1,x        ;[4] then
        bcc  umsm4      ;[2]*  skip remainder update
umsm3:                  ;
        lda  2,x        ;[4]
        sbc  0,x        ;[4]
        sta  2,x        ;[4] Update remainder
        lda  3,x        ;[4]  (gradually replacing
        sbc  1,x        ;[4]   dividend:H)
        sta  3,x        ;[4]
        sec             ;[2]
umsm4:                  ;
        rol  4,x        ;[6] Shift carry into quotient
        rol  5,x        ;[6]  (gradually replacing
        dey             ;[2]   dividend:L)
        bne  umsm2      ;[3]* Loop until done
        inx             ;[2] Exit sequence:
        inx             ;[2]   DROP the divisor
        jmp  SWAP       ;[34]* SWAP quotient and remainder
;------------------- 46 bytes, not counting HEADER

;------------------------------------------------------
; UM/MOD for any 6502 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
                        ;
; ( ud u1 -- u2 u3 )
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
                        ;
; Invalid results for quotient overflow or /0
                        ;
; 0,x and 1,x are TOS  ( divisor -- quotient )
; 2,x and 3,x are NOS  ( dividend:H -- remainder )
; 4,x and 5,x are 3OS  ( dividend:L --  )
                        ;
umslashmod:             ;
        ldy  #16        ; loop counter
umsm2:                  ;
        asl  4,x        ; dividend:L is gradually replaced
        rol  5,x        ;   with the quotient
        rol  2,x        ; dividend:H is gradually replaced
        rol  3,x        ;   with the remainder
        bcs  umsm3      ;
        lda  2,x        ;
        cmp  0,x        ; compare remainder to divisor
        lda  3,x        ;
        sbc  1,x        ;
        bcc  umsm4      ;
umsm3:                  ;
        lda  2,x        ;
        sbc  0,x        ; if (remainder >= divisor) then
        sta  2,x        ;   update partial remainder
        lda  3,x        ;
        sbc  1,x        ;
        sta  3,x        ;
        inc  4,x        ;   and set low bit in quotient
umsm4:                  ;
        dey             ;
        bne  umsm2      ; Loop until done
        inx             ; Exit sequence:
        inx             ;   DROP the divisor
        jmp  SWAP       ;   SWAP quotient and remainder
                        ; (SWAP's machine code, not its CFA)
;------------------- 44 bytes, not counting HEADER

;------------------------------------------------------
; UM/MOD for the 65802/816 by Michael T. Barry.
; Free to copy and/or modify, but without warranty.
                        ;
; ( ud u1 -- u2 u3 )
; ud is the 32-bit dividend.
; u1 is the 16-bit divisor.
; u2 is the 16-bit remainder.
; u3 is the 16-bit quotient.
; All values are unsigned.
                        ;
; Invalid results for quotient overflow or /0
; Accumulator and memory are in 16-bit mode
; Index registers are in 8-bit mode
                        ;
; 0,x is TOS  ( divisor -- quotient )
; 2,x is NOS  ( dividend:H -- remainder )
; 4,x is 3OS  ( dividend:L --  )
                        ;
umslashmod:             ;
        ldy  #16        ; loop counter
        lda  2,x        ;
umsm2:                  ;
        asl  4,x        ; dividend:L is gradually replaced
                        ;   with the quotient
        rol             ; dividend:H is gradually replaced
                        ;   with the remainder
        bcs  umsm3      ;
        cmp  0,x        ; compare remainder to divisor
        bcc  umsm4      ;
umsm3:                  ; if (remainder >= divisor) then
        sbc  0,x        ;   update partial remainder
        inc  4,x        ;   and set low bit in quotient
umsm4:                  ;
        dey             ;
        bne  umsm2      ; Loop until done
        sta  2,x        ;
        inx             ; Exit sequence:
        inx             ;   DROP the divisor
        jmp  SWAP       ;   SWAP quotient and remainder
                        ; (SWAP's machine code, not its CFA)
;------------------- 27 bytes, not counting HEADER