sqrt10.a

; https://github.com/TobyLobster/sqrt_test/blob/main/sqrt/sqrt10.a
; My tweaking of sqrt1.a, which was based on https://codebase64.org/doku.php?id=base:fast_sqrt

MLO     = $02
MHI     = $03
THI     = $04

    * = $0200

start
    ldy #0          ; R = 0

    ; iteration one
    lda MHI         ;
    cmp #$40        ;
    bcc ++          ;
    sbc #$40        ;
    ldy #$80        ; R = R OR D
++
    asl MLO         ;
    rol             ; M = M ASL 1
    sta MHI         ; M = M - T

    ; iteration two
    tya             ;
    ora #$20        ;
    sta THI         ; (R ASL 8) | (D ASL 7)
    lda MHI         ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI         ;
    bcc ++          ; T <= M
+
    sbc THI         ;
    sta MHI         ; M = M - T
    tya             ;
    ora #$40        ; set bit
    tay             ; R = R OR D
++
    asl MLO
    rol MHI         ; M = M ASL 1

    ; iteration three
    tya             ;
    ora #$10        ;
    sta THI         ; (R ASL 8) | (D ASL 7)
    lda MHI         ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI         ;
    bcc ++          ; T <= M
+
    sbc THI         ;
    sta MHI         ; M = M - T
    tya             ;
    ora #$20        ; set bit
    tay             ; R = R OR D
++
    asl MLO         ;
    rol MHI         ; M = M ASL 1

    ; iteration four
    tya             ;
    ora #$08        ;
    sta THI         ; (R ASL 8) | (D ASL 7)
    lda MHI         ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI         ;
    bcc ++          ; T <= M
+
    sbc THI         ;
    sta MHI         ; M = M - T
    tya             ;
    ora #$10        ; set bit
    tay             ; R = R OR D
++
    asl MLO         ;
    rol MHI         ; M = M ASL 1

    ; iteration five
    tya             ;
    ora #$04        ;
    sta THI         ; (R ASL 8) | (D ASL 7)
    lda MHI         ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI         ;
    bcc ++          ; T <= M
+
    sbc THI         ;
    sta MHI         ; M = M - T
    tya             ;
    ora #$08        ; set bit
    tay             ; R = R OR D
++
    asl MLO         ;
    rol MHI         ; M = M ASL 1

    ; iteration six
    tya             ;
    ora #$02        ;
    sta THI         ; (R ASL 8) | (D ASL 7)
    lda MHI         ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI         ;
    bcc ++          ; T <= M
+
    sbc THI         ;

    ; from this point on, A holds MHI, so no need to store it
    ; sta MHI         ; M = M - T

    ; instead of this...
    ;tya             ;
    ;ora #$04        ; set bit
    ;tay             ; R = R OR D

    ; ...do this (it takes 2 cycles longer, but preserves A to avoid more expensive instructions)
    iny             ;
    iny             ;
    iny             ;
    iny             ;
++
    asl MLO         ;
    rol             ; M = M ASL 1

    ; iteration seven

    ; instead of this...
    ;tya             ;
    ;ora #$01        ;
    ;sta THI         ; (R ASL 8) | (D ASL 7)

    ; ... do this (same timing, but one byte shorter, and doesn't use A):
    iny             ;
    sty THI         ;
    dey             ;

    ; lda MHI        ;
    bcs +           ; M >= 65536? then T <= M is always true
    cmp THI
    bcc ++          ; T <= M
+
    sbc THI         ; M = M - T

    ; instead of this...
    ;tya             ;
    ;ora #$02        ; set bit
    ;tay             ; R = R OR D

    ; ...do this (quicker, shorter, and preserves A)
    iny             ;
    iny             ;
++
    asl MLO         ;
    rol             ; M = M ASL 1

    ; last iteration (iteration eight)

    bcs +           ;
    sty THI         ;
    asl MLO         ;
    sbc THI         ; M = M - T
    bcc ++          ;
+
    iny             ; R = R OR D (D is 1 here)
++
    rts             ;