PopReg  fsr2h                   ; // Get bank
    PopReg  fsr2l                   ; // Get addrress
    PopReg  indf2                   ; // Get and store data
    return

    PopReg  fsr2h
    PopReg  fsr2l
    subwf   indf2
    Drop
    return

    PopReg  tmp1                    ; // bStart into tmp1
    cpfseq  indf1                   ; // S/ Start = Limit
    bra     dodo                    ; // B/ start <> Limit, perform ((do))

    Drop                            ; // start = limit : drop bLimit
    bsf     status, z               ; // Return with zero flag set (loop skipped)
    return                          ; // B/ ----> done

    addwf   indf1                   ; // Index + inc -> Index
    movf    postinc1, w             ; // Get index LSP++
    subwf   indf1, W                ; // Limit - Index
    bc      LoopMore                ; // B/ Carry   , Not done, see ((loop))

    bra     LoopNoMore              ; // B/ No carry, done    , see ((loop))

    PopReg    tmp1                  ; // Start into tmp1

dodo                                ; // entry point for ((?do)) if loop taken

    PopReg    tmp2                  ; // Limit into tmp2
    LsPushReg tmp2                  ; // Limit on loop stack
    LsPushReg tmp1                  ; // Start on loop stack (as Index)
    bcf       status, z             ; // Return with zero flag cleared
    return                          ; // B/ ----> done (loop taken)

    PopReg  tmp1                    ; // Pop Flag  into tmp1
    movf    tmp1, f                 ; // To set or clear Z flag
    return

    PushNothing                     ; // Save wreg

    incf    indf1                   ; // Advance index
    movf    postinc1, w             ; // get index into wreg
    xorwf   indf1, w                ; // Compare with limit
    bnz     LoopMore                ; // B/ Index <> Limit

LoopNoMore                          ; // Also used by (+loop)

    incf    fsr1l, f                ; // Index == Limit
    Drop                            ; // Restore wreg
    bcf     status, Z               ; // signal index = limit
    return

LoopMore                            ; // Also used by (+loop)

    decf    fsr1l, f                ; // restore Loop stack pointer
    Drop                            ; // Restore wreg
    bsf     status, Z               ; // signal index <> limit
    return

    ; // Discard one (except) frame

    ; //  Exception frame as on loop stack
    ; //
    ; //   +--> | prev_frame        |
    ; //   |    +-------------------+
    ; //   |    |                   |
    ; //   |    ~                   ~
    ; //   |    |                   |
    ; //   |    +-------------------+
    ; //   |    | addr_except low   | -+-- ROM address of ((except)) to invoke
    ; //   |    | addr_except high  | -+
    ; //   |    | addr_except upper | -+
    ; //   |    | old_stkptr        | ---- Old return stack pointer
    ; //   |    | old_wreg          | ---- Value that was on top of old stack
    ; //   |    | old_data_sp low   | -+-- old data stack imcluding wreg
    ; //   |    | old_data_sp high  | -+
    ; //   +-<- | old_EFP     low   |      +-----+
    ; //   +-<- | old_EFP     high  | <--- + EFP |
    ; //        +-------------------+      +-----+
    ; //        |                   |
    ; //        ~                   ~      +-----+
    ; //        |                   | <--- + fsr1|
    ; //                                   +-----+

    RemoveExceptionFrame            ; // Unwind one exception level
    LsFree  7                       ; // Drop old_data_sp, old_wreg and addr_except

    ; //  Exception frame as on loop stack
    ; //                                   +-----+------+
    ; //        | prev_frame        | <--- | EFP | fsr1 |
    ; //        +-------------------+      +-----+------+
    ; //        |                   |
    ; //        ~                   ~
    ; //        |                   |
    ; //        +-------------------+
    ; //        | addr_except low   |
    ; //        ~                   ~

    return                          ; // B/ ----> done

    PopReg  tmp1                    ; // Get & drop n2 into tmp1
    cpfseq  tmp1                    ; // S// n1 == n2
    bra     of_uneq                 ; // B/ n1 <> n2

    ; // n1 == n2

    Drop                            ; // Drop n1
    bcf     Status, Z               ; // Flag match
    return

of_uneq

    bsf     Status, Z               ; // Flag no match
    return

    ; // Should check for original data stack corruption here
    ; // that is, when we have a relative stack underflow
    ; // that's definitly no good.
    ; //
    ; // Use the current (except) frame to determine
    ; // a jump to the nearest (except) handler.

    ; //  Exception frame as on loop stack
    ; //
    ; //   +--> | prev_frame        |
    ; //   |    +-------------------+
    ; //   |    |                   |
    ; //   |    ~                   ~
    ; //   |    |                   |
    ; //   |    +-------------------+
    ; //   |    | addr_except low   | -+-- ROM address of ((except)) to invoke
    ; //   |    | addr_except high  | -+
    ; //   |    | addr_except upper | -+
    ; //   |    | old_stkptr        | ---- Old return stack pointer
    ; //   |    | old_wreg          | ---- Value that was on top of old stack
    ; //   |    | old_data_sp low   | -+-- old data stack imcluding wreg
    ; //   |    | old_data_sp high  | -+
    ; //   +-<- | old_EFP     low   |      +-----+
    ; //   +-<- | old_EFP     high  | <--- + EFP |
    ; //        +-------------------+      +-----+
    ; //        |                   |
    ; //        ~                   ~      +-----+
    ; //        |                   | <--- + fsr1|
    ; //                                   +-----+

    SetBsrDefault                   ; // For 4th execution BSR should have its default value
    movwf   tmp1                    ; // Keep bException in tmp1

    RemoveExceptionFrame            ; // Unwind one exception level

    LsPopReg  fsr0h                 ; // restore data stack pointer
    LsPopReg  fsr0l
    LsPopReg  wreg                  ; // restore wreg

    disable                         ; // Interrupts off
    LsPopReg  stkptr                ; // Pop old stkptr (call stack pointer) back
    LsPopReg  wreg                  ; // Pop (except) handler from loop stack
    movwf     tosu
    LsPopReg  wreg
    movwf     tosh
    LsPopReg  wreg
    movwf     tosl
    enable                          ; // Interrupts back on

    PushReg tmp1                    ; // Repush bException on restored data stack

    ; //  Exception frame as on loop stack
    ; //                                   +-----+------+
    ; //        | prev_frame        | <--- | EFP | fsr1 |
    ; //        +-------------------+      +-----+------+
    ; //        |                   |
    ; //        ~                   ~
    ; //        |                   |
    ; //        +-------------------+
    ; //        | addr_except low   |
    ; //        ~                   ~

    return                          ; // B/ ----> Returns to (except) or (finally) handler

                                    ; // ((table)) $Bank$:$Arg$
    movwf   tmp1
    movlw   ($Arg$ >> 0) & 0xff
    addwf   tmp1, w
    movlw   ($Arg$ >> 8) & 0xff
    btfsc   status, C
    addlw   D'1'
    movwf   pclath
    movf    tmp1, w

    call    $Arg$

    ; // create (except) frame on return stack
    ; // ( tRomAddress -- ) [ -- (except) ]

                                    ; // >r   addr_except_low
    PopReg    tmp1
    LsPushReg tmp1
                                    ; // >r   addr_except_high
    PopReg    tmp1
    LsPushReg tmp1
                                    ; // >r   addr_except_upper
    PopReg    tmp1
    LsPushReg tmp1
                                    ; // >r   stkptr
    LsPushReg stkptr
                                    ; // >r   wreg
    LsPushReg wreg
                                    ; // >r   data stack pointer
    LsPushReg fsr0l
    LsPushReg fsr0h

    AddExceptionFrame               ; // Link in a new exception frame

    ; //  Exception frame as on loop stack.
    ; //  The loop stack grows downwards and uses fsr1.
    ; //  On pussh first fsr1 is decremented then the new
    ; //    value is stored into the stack.
    ; //
    ; //   +--> | prev_exc_frame    | ---- a possible previous frame (old_EFP
    ; //   |    +-------------------+      is zero for outermost frame).
    ; //   |    |                   | -+-- possible loop stack data from do..loop or >r
    ; //   |    ~                   ~ -+
    ; //   |    |                   | -+
    ; //   |    +-------------------+
    ; //   |    | addr_except low   | -+-- ROM address of ((except)) to invoke
    ; //   |    | addr_except high  | -+
    ; //   |    | addr_except upper | -+
    ; //   |    | old_stkptr        | ---- Old return stack pointer
    ; //   |    | old_wreg          | ---- Value that was on top of old stack
    ; //   |    | old_data_sp low   | -+-- old data stack imcluding wreg
    ; //   |    | old_data_sp high  | -+
    ; //   +-<- | old_EFP     low   |      +---------+------+
    ; //   +-<- | old_EFP     high  | <--- | new EFP | fsr1 |
    ; //        +-------------------+      +---------+------+

    return                          ; // B/ ----> done

    subwf   postdec0, w             ; // (-) ( u1 u2 -- u3 )

    PopReg  tmp1
    mulwf   tmp1
    movf    prodl, w

    return

                                    ; // also calculates remainder,
                                    ; // but we don't care about that!
    clrf    tmp1                    ; // remainder
    movwf   tmp3                    ; // u2
    movlw   D'8'                    ; // loop counter
    movwf   tmp2                    ; // to index

slash_0

    rlcf    indf0, w                ; // rotate u1
    rlcf    tmp1, f                 ; // into remainder
    movf    tmp3, w                 ; // get u2
    subwf   tmp1, f                 ; // Try to subtract
    bc      slash_1                 ; // B/ subtract did work, carry is set

    addwf   tmp1, f                 ; // subtract did not work, so add it again
    bcf     status, C               ; // and clear carry

slash_1

    rlcf    indf0, f                ; // result in indf0
    decfsz  tmp2 , f
    bra     slash_0

    movf    postdec0, w             ; // get result to TOS
    return

    ; // ///////////////////////////////////////////////////////////////////////
    ; //  Function      : /Mod ( bDividend  bDivisor -- Quotient Remainder )
    ; //  Input         : bDividend : 8 bits unsigned - high byte on top
    ; //                : bDivisor  : 8 bits unsigned - high byte on top
    ; //  Output        : Quotient  : 8 bits unsigned - high byte on top
    ; //                : Remainder : 8 bits unsigned - high byte on top
    ; //  Description   : 8 / 8 -> 8 bits unsigned divide with remainder
    ; //  Remarks       : Quotient  := bDividend Div bDivisor
    ; //                : Remainder := bDividend Mod bDivisor
    ; // ///////////////////////////////////////////////////////////////////////
    ; //
    ; //  From Zilog Z8 Family Design Handbook, june 1988
    ; //
    ; //  A programmers guide to the Z8 microcomputer,
    ; //  Z8 subroutine library, Application note
    ; //  page 211.
    ; //
    ; //  Adapted from 16 / 16 -> 16 + 16 algorithm above
    ; //
    ; //  This is a 8 / 8 -> 8 + 8 udiv routine
    ; //
    ; // ///////////////////////////////////////////////////////////////////////

    ; // Pop arguments from stack to helper variables

    PopReg  <@" Divisor">           ; // pop bDivisor into divisor ( bDividend )
    movwf   <@" Quotient">          ; // bDividend into Quotient

    clrf    <@" Remainder">

    movlw   8                       ; // ld   d32_LEN, #8      !LOOP COUNTER!
    movwf   tmp2
    bcf     Status, C               ; // rcf                   !carry = 0!

    ; // Then go for it


dlp_8

    rlcf    <@" Quotient">, f       ; // rlc  qout
    rlcf    <@" Remainder">, f      ; // rlc  rem
    bc      subt_8                  ; // B/ C not clear

    movf    <@" Divisor">, w        ; // See if we can subtract
    subwf   <@" Remainder">, w
    bnc     skp_8                   ; // B/ carry not set, skip subtraction

subt_8

    movf    <@" Divisor">, w        ; // sub  rem, dvsr
    subwf   <@" Remainder">, f
    bsf     Status, C               ; // scf

skp_8

    decfsz  tmp2, f                 ; // djnz d16_LEN, dlp_16
    bra     dlp_8                   ; //                       !no flags affected!

    rlcf    <@" Quotient">, f       ; // rlc  quot

    ; // Now copy results to stack

    movf    <@" Quotient">, w       ; // ( bQuotient )
    PushReg <@" Remainder">         ; // ( bQuotient bRemainder )

    return

                                    ; // (?do) : check if limit is count, if so skip loop
    call    <@" ((?do))">
    fBranch $SkipLabel$
$LoopLabel$

    iorlw   D'0'
    btfsc   status, Z
    return

    Dup
    return

    PopReg  fsr2h                   ; // Get bank
    PopReg  fsr2l                   ; // Get address
    PushReg indf2                   ; // dereference
    return

    PopReg  fsr2h
    PopReg  fsr2l
    addwf   indf2
    Drop
    return

    addwf   postdec0, w             ; // (+) ( u1 u2 -- u3 )

(rot)

    subwf   postdec0, f
    movlw   True                    ; // assume true
    btfss   status, Z               ; // if set then always false
    btfsc   status, C               ; // if not then also analyze carry
    clrf    wreg                    ; // false flag
    return