divide:               ; Common division code - divides #1 by #0 and gives the
   dex               ; quotient in #1 and the remainder in #0 (signed)
   dex               ; Decrement the data stack pointer for a work location
   phy               ; Save the instruction pointer to a temporary location

   stz <$00,x         ; Clear the sign-correct count
   ldy <$00,x         ; Clear the pre-shift count in Y

   lda <$02,x         ; Get the divisor from #0
   beq .z            ; If it's zero, implode
   clc               ; Clear the carry for the upcoming shift
   bpl .pa            ; If it's positive, don't negate it
   eor #$ffff         ; Otherwise, negate it
   inc
   sta <$02,x         ; And store it back
   sec               ; Set the carry for the upcoming shift
.pa   rol <$00,x         ; Update the sign-correct flags

   lda <$04,x         ; Get the dividend from #1
   bpl .pb            ; If it's positive, don't negate it
   eor #$ffff         ; Otherwise, do that
   inc
   sec               ; Set the carry (already cleared) for the upcoming shift
.pb   rol <$00,x         ; Update the sign-correct flags

   stz <$04,x         ; Clear #1 for use as the quotient

.ps   bit <$02,x         ; Check the MSB on the divisor
   bmi .sd            ; If it's 1, don't pre-shift any further
   asl <$02,x         ; Otherwise, shift it left one place
   iny               ; And increment our pre-shift count
   bra .ps            ; And see if we're done with the pre-shift

.sd   ; The divisor is now pre-shifted as far left as it will go - begin!
   ; A contains the working remainder
   cmp <$02,x         ; Is the shifted divisor larger than the remainder?
   bcc .ns            ; If so, don't subtract it from the remainder
   ; Otherwise, do so
   php            ; Save the flag state first      
   sec
   sbc <$02,x
   plp            ; And restore it

.ns   rol <$04,x         ; Whatever we do, shift the carry into the quotient
   lsr <$02,x         ; And shift the divisor right one place
   dey               ; And decrement the pre-shift count
   bpl .sd            ; If it hasn't underflowed, continue

   sta <$02,x         ; Store the remainder into #0
   ply               ; Restore the instruction pointer

   lda <$04,x         ; Load the quotient into A for sign-correction
   lsr <$00,x         ; Check - was the dividend negative?
   bcc .cd            ; If not, skip this bit
   eor #$ffff         ; Otherwise, negate the quotient
   inc
   pha               ; And save it to a temporary location
   lda <$02,x         ; And get the remainder
   eor #$ffff         ; And negate it
   inc
   sta <$02,x         ; And store it back
   pla               ; And retrieve the quotient

.cd   lsr <$00,x         ; Check - was the divisor negative?
   bcc .d            ; If not, skip this bit
   eor #$ffff         ; Otherwise, negate the quotient
   inc
.d   sta <$04,x         ; And store the quotient back

   inx               ; Increment the data stack pointer (drop work location)
   inx
   rts               ; Return to the calling routine

divide:                 ; Common division code - divides #1 by #0 and gives the
                        ;   quotient in #1 and the remainder in #0 (signed)
    lda  <0,x           ;
    beq  implode        ; if /0 then implode
    cmp  #$8000         ; save divisor sign in 'C' flag
    bcc  .div2          ;
    jsr  .div6a         ; divisor = |divisor|
.div2:                  ;
    lda  <2,x           ;
    php                 ; save dividend sign in 'N' flag
    bpl  .div3          ;
    jsr  .div9          ; dividend = |dividend|
.div3:                  ;
    lda  <0,x           ; get the divisor from #0
    phy                 ; save the instruction pointer
    ldy  #16            ; loop counter for unsigned divide
.div4:                  ;
    asl  <2,x           ;   quotient gradually replaces the dividend
    rol                 ;   remainder gradually accumulates in A
    bcs  .div5          ;   don't forget the 17th bit!
    cmp  <0,x           ;   if (partial remainder >= divisor) then
    bcc  .div6          ;
.div5:                  ;     update the partial remainder
    sbc  <0,x           ;
    inc  <2,x           ;     and set low bit in quotient
.div6:                  ;
    dey                 ;
    bne  .div4          ; loop until done dividing
    ply                 ; retrieve the instruction pointer
    sta  <0,x           ; store the remainder
    plp                 ; retrieve the divisor sign (C) and dividend sign (N)
    bpl  .div7          ;
.div6a:                 ;
    eor  #$ffff         ; negate the remainder if dividend < 0
    inc                 ;
    sta  <0,x           ;
    bcc  .div8          ;   and negate the quotient if divisor >= 0
    rts                 ; return to the caller
.div7:                  ;
    bcc  .div99         ; done if dividend and divisor were the same sign
.div8:                  ;
    lda  <2,x           ;
.div9:                  ;
    eor  #$ffff         ; negate #1 (dividend or quotient)
    inc                 ;
    sta  <2,x           ;
.div99:                 ;
    rts                 ; return to the caller