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

    PopReg  tmp1                    ; // Shift  b1 left over b2 positions

shllp

    bcf     Status, C
    rlcf    wreg, f
    decfsz  tmp1
    bra     shllp

    return

00003 | (>)                                          | ( u1 u2 -- f ) [0]
00004 | (not)                                        | ( b -- b ) ( )
00005 | (semi)                                       | ( -- ) ( )

    subwf   postdec0, f
    btfsc   status, Z
    retlw   False
    retlw   True

    subwf   postdec0, f
    btfsc   status, Z
    retlw   True
    retlw   False

00000 | (swap)                                       | ( b1 b2 -- b2 b1 )
00001 | (<)                                          | ( u1 u2 -- f )
00002 | (semi)                                       | ( -- ) ( )

00006 | (<)                                          | ( u1 u2 -- f )
00007 | (not)                                        | ( b -- b ) ( )
00008 | (semi)                                       | ( -- ) ( )

    PopReg  tmp1                    ; // Shift  b1 right over b2 positions

shrlp

    bcf     Status, C
    rrcf    wreg, f
    decfsz  tmp1
    bra     shrlp

    return

                                ; // >2Field $Name$ ( $Sign$$Value$)
                                ; // ( dBase -- dBase+dOffset )
    PushLit ( <@" $Name$"> >> 0 ) & D'255'
    PushLit ( <@" $Name$"> >> 8 ) & D'255'
    call    <@" d+">

                                ; // >Field $Name$ ( $Sign$$Value$)
                                ; // ( bBase -- bBase+bOffset )
    PushLit <@" $Name$">
    addwf   postdec0, w         ; // (+) ( u1 u2 -- u3 )

    PopReg    tmp1
    LsPushReg tmp1
    return

                                    ; // 2constant $Name$ ( $Sign$$Value$)
    PushLit ($Sign$D'$Value$' >> 0) & D'255'
    PushLit ($Sign$D'$Value$' >> 8) & D'255'

$Mangled$ equ $Sign$D'$Value$'      ; // 2constant $Name$

    Drop                            ; // (2drop) ( w -- )
    Drop

00009 | (over)                                       | ( b1 b2 -- b1 b2 b1 )
00010 | (over)                                       | ( b1 b2 -- b1 b2 b1 )
00011 | (semi)                                       | ( -- ) ( )

                                ; // 2Field $Name$ ( $Sign$$Value$)
    PushLit ( <@" $Name$"> >> 0) & D'255'
    PushLit ( <@" $Name$"> >> 8) & D'255'

<@" $Name$"> equ $Sign$D'$Value$' ; // 2Field $Name$

    PopReg  tmp4
    PopReg  tmp3
    PopReg  tmp2
    movwf   tmp1

    PushReg tmp2
    PushReg tmp3
    PushReg tmp4
    PushReg tmp1
    PushReg tmp2

    return

dSwap

$Mangled$ equ 256 * D'$Bank$' + D'$Value$' ; // 2variable $Name$ :: Bank = $Bank$

                                    ; // 2variable $Name$ ( $Bank$:$Value$) ; $Mangled$
    PushLit D'$Value$'
    PushLit D'$Bank$'

                                ; // 3constant $Name$ ( $Sign$$Value$)
    PushLit ( <@" $Name$"> >>  0) & D'255'
    PushLit ( <@" $Name$"> >>  8) & D'255'
    PushLit ( <@" $Name$"> >> 16) & D'255'

<@" $Name$"> equ $Sign$D'$Value$' ; // 3constant $Name$

<@" $Name$"> equ 256 * D'$Bank$' + D'$Value$' ; // 3variable $Name$ :: Bank = $Bank$

                                ; // 3variable $Name$ ( $Bank$:$Value$) ; <@" $Name$">
    PushLit D'$Value$'
    PushLit D'$Bank$'

                                    ; // 4constant $Name$ ( $Sign$$Value$)
    PushLit ($Sign$D'$Value$' >> 0 ) & D'255'
    PushLit ($Sign$D'$Value$' >> 8 ) & D'255'
    PushLit ($Sign$D'$Value$' >> 16) & D'255'
    PushLit ($Sign$D'$Value$' >> 24) & D'255'

$Mangled$ equ $Sign$D'$Value$'      ; // 4constant $Name$

$Mangled$ equ 256 * D'$Bank$' + D'$Value$' ; // 4variable $Name$ :: Bank = $Bank$

                                    ; // 4variable $Name$ ( $Bank$:$Value$) ; $Mangled$
    PushLit D'$Value$'
    PushLit D'$Bank$'

    btfsc   wreg, 7
    sublw   D'0'
    return

                                    ; // (again) - unconditional branch
    bra     $Label$

    andwf   postdec0, w             ; // (and) ( b1 b2 -- b3 )

                                    ; // $Size$ Array $Name$ ( $Bank$:$Value$) ; $Mangled$
    PushLit D'$Value$'
    PushLit D'$Bank$'

$Mangled$ equ 256 * D'$Bank$' + D'$Value$' ; // $Size$ Array  $Name$ :: Bank = $Bank$

                                    ; // (begin) - a label
$Label$

                                    ; // (call) $Label$
    call    $Label$

                                    ; // (case)- place holder only

                                    ; // $Bank$:$NLabel$ (code)
    call    $MLabel$

                                    ; // $Bank$:$NLabel$ (colon)
    call    $MLabel$

                                    ; // constant $Name$ ( $Sign$$Value$)
    PushLit $Sign$D'$Value$'

$Mangled$ equ $Sign$D'$Value$'      ; // constant $Name$

$Mangled$
                                    ; // data-constdef $Name$
    db    D'$Size$', $Value$

                                    ; // Default case

                                    ; // dliteral $Sign$$Arg$
    PushLit ($Sign$D'$Arg$' >> 0) & D'255'
    PushLit ($Sign$D'$Arg$' >> 8) & D'255'

                                    ; // (do)
    call    <@" ((do))">
$LoopLabel$

                                    ; // drop ( b -- )
    Drop

                                    ; // (dup) ( b -- b b )
    Dup

                                    ; // (else) - unconditional branch
    bra     $Label2$
$Label1$

                                    ; // (endcase) - a label
$Label$

                                    ; // (endof) - unconditional branch
    bra   $Label1$

$Label2$

                                    ; // (endtry), place holder
$anEndLabel$

    ; // (except) ( bException | -- bException | )

                                    ; // OK :: We fell trough, no exception, nothing on stack
                                    ; // ( )
    call    <@" ((no_except))">     ; // ((no_except)) remove (except) frame

                                    ; // B/ skip to (endtry)
    bra     $anEndLabel$

$aTryLabel$
                                    ; // EXCEPTION :: We came in thhrough a Raise action, exception on stack
                                    ; // ( bException )

    ; // end ( except)

    return                          ; // /B --> Exit

    PushLit False                   ; // (False) ( -- f )

                                ; // Field $Name$ ( $Sign$$Value$)
    PushLit <@" $Name$">

<@" $Name$"> equ $Sign$D'$Value$' ; // Field $Name$

    ; // (finally) ( bException | -- bException | )

                                    ; // OK :: We fell trough, no exception, nothing on stack
                                    ; // ( )
    call    <@" ((no_except))">     ; // ((no_except)) remove(except) frame
    PushLit 0                       ; // Signal 'no exception'

    ; // (finally) Fall through to $aTryLabel$

$aTryLabel$
                                    ; // EXCEPTION :: We came in through a Raise action, exception on stack
                                    ; // or we fell having no exception, zero on stack
                                    ; // ( bException )
    Drop                            ; // But just forget about it for now.
                                    ; // (This should be re-raised at EndTry)

    ; // end ( finally)

    ; // (ForceRomBank) $Nr$ $Address$
    ; // a NOOP for 18fXXX, it has no rom banking.

                                    ; // Free space ($anAmount$ bytes) for local variables.
    movwf   tmp1                    ; // Save TOS
    movf    LDP, w                  ; // Get  LDP
                                    ; // Subtract $anAmount$ from it
    sublw   D'$anAmount$'
    movwf   LDP                     ; // And store it
    movf    tmp1, w                 ; // Restore TOS

                                    ; // Reserve space ($anAmount$ bytes) for local variables.
    movwf   tmp1                    ; // Save TOS
    movf    LDP, w                  ; // Get  LDP
                                    ; // Add $anAmount$ to it
    addlw   D'$anAmount$'
    movwf   LDP                     ; // And store it
    movf    tmp1, w                 ; // Restore TOS

                                    ; // (goto) $Label$
    bra     $Label$

    PushReg indf1                   ; // I ( -- u ) Get inner loop index

    PushLit D'1'                    ; // Get inner loop limit
    movf    plusw1, w
    return

                                    ; // (if) - branch if Z flag set
    fBranch $Label$

                                    ; // Initialize the local data pointer (LDP)
    movlw   D'$aLocalStart$'
    movwf   LDP

    PushLit D'2'                    ; // Get 2nd loop index
    movf    plusw1, w
    return

    PushLit D'3'                    ; // Get 2nd loop limit
    movf    plusw1, w
    return

                                    ; // (jumpto) $Name$
    bra     $Mangled$

    PushLit D'4'                    ; // Get 3d loop index
    movf    plusw1, w
    return

$Label$

    PushNothing                     ; // Save wreg
    incf    fsr1l                   ; // Point to limit
    decf    postdec1, w             ; // Get limit, dec limit, result into wreg
    movwf   indf1                   ; // Store limit - 1 as index
    Drop
    return

                                    ; // literal $Sign$$Arg$
    PushLit $Sign$D'$Arg$'

                                    ; // Loc2Var $Name$ ( $Bank$:$Sign$$Value$) ; $Mangled$
    PushLit $Sign$D'$Value$'
    addwf   LDP, w
    PushLit D'$Bank$'

                                ; // Loc3Var $Name$ ( $Bank$:$Sign$$Value$) ; <@" $Name$">
    PushLit $Sign$D'$Value$'
    addwf   LDP, w
    PushLit D'$Bank$'

                                    ; // Loc4Var $Name$ ( $Bank$:$Sign$$Value$) ; $Mangled$
    PushLit $Sign$D'$Value$'
    addwf   LDP, w
    PushLit D'$Bank$'

                                    ; // LocVar $Name$ ( $Bank$:$Sign$$Value$) ; $Mangled$
    PushLit $Sign$D'$Value$'
    addwf   LDP, w
    PushLit D'$Bank$'

                                    ; // (loop) branch if Z flag set
    fBranch $LoopLabel$
$SkipLabel$

    rlncf   wreg                    ; // lshift ( b1 -- b2 )
    bcf     wreg, 0

    PopReg  tmp1
    cpfslt  tmp1                    ; // S/ tmp1 < wreg , so wreg is maximum
    movf    tmp1, w                 ; //    tmp1 >= wreg, so tmp1 is maximum
    return

    PopReg  tmp1
    cpfsgt  tmp1                    ; // S/ tmp1 > wreg , so wreg is minimum
    movf    tmp1, w                 ; //    tmp1 <= wreg, so tmp1 is minimum
    return

    sublw   D'0'                    ; // negate ( b1 -- b2 )

    xorlw   0xff                    ; // Not ( b1 -- b2 )

                                    ; // (of) - branch if Z flag set
    fBranch $Label$

    iorwf   postdec0, w             ; // (or) ( b1 b2 -- b3 )

    movff   indf0, tmp1
    PushReg tmp1
    return

  ; // Push u:th entry

    PushNothing
    sublw   D'0'                    ; // negate
    movf    plusw0, w               ; // w = offset of reqd. byte,
    return                          ; //     0th byte references TOS

  ; // u th byte of stack replaced by value b
  ; //   0th byte = top of stack

    sublw   D'0'                    ; // negate
    PopReg  tmp1                    ; // Get offset
    movwf   tmp2                    ; // Get velue to put
    movf    tmp1, w                 ; // Offset to wreg
    movff   tmp2, plusw0            ; // Put value
    PopReg  wreg                    ; // Pop top item of stack into wreg
    return

                                    ; // qliteral $Sign$$Arg$
    PushLit ($Sign$D'$Arg$' >>  0) & D'255'
    PushLit ($Sign$D'$Arg$' >>  8) & D'255'
    PushLit ($Sign$D'$Arg$' >> 16) & D'255'
    PushLit ($Sign$D'$Arg$' >> 24) & D'255'

    LsPopReg  tmp1
    PushReg   tmp1
    return

    ; // (raise) ( bExceptionOnCurrentDataStack -- bExceptionOnOldDataStack ) [ tRomAddress dDSP -- ]

    call    <@" ((raise))">         ; // ((raise)) jump to (except) or (finally) handler
                                    ; //  through (except) frame on return stack

                                    ; // (repeat) - unconditional branch
    bra     $Label1$
$Label2$

    PopReg  tmp3
    PopReg  tmp2
    PopReg  tmp1

    PushReg tmp2
    PushReg tmp3
    PushReg tmp1

    return

    PopReg  tmp3
    PopReg  tmp2
    PopReg  tmp1

    PushReg tmp3
    PushReg tmp1
    PushReg tmp2

    return

    rrncf   wreg                    ; // rshift ( b1 -- b2 )
    bcf     wreg, 7

                                ; // s>2Field $Name$ ( $Sign$$Value$)
                                ; // ( bBase -- bBase+dOffset )
    PushLit   0                 ; //  perform u>ud
    PushLit ( <@" $Name$"> >> 0 ) & D'255'
    PushLit ( <@" $Name$"> >> 8 ) & D'255'
    call    <@" d+">

                                ; // s>Field $Name$ ( $Sign$$Value$)
                                ; // ( dBase -- dBase+dOffset )
    PushLit ( <@" $Name$"> >> 0 ) & D'255'
    PushLit ( <@" $Name$"> >> 8 ) & D'255'
    call    <@" d+">

    return                          ; // B/ ----> (;)

                                    ; // (noreturn;)

    PushLit 0x20                    ; // (space) ( -- b )

                                    ; // str-constant $Name$
                                    ; // ( -- wRomAddress )
    PushLit ($Mangled$ >> 0) & D'255'
    PushLit ($Mangled$ >> 8) & D'255'

$Mangled$
                                    ; // str-constdef $Name$
    db    D'$Size$', "$Value$"

                                ; // Struct $Name$ ( $Sign$$Value$)
    PushLit <@" $Name$">

<@" $Name$"> equ $Sign$D'$Value$' ; // Struct $Name$

    PopReg  tmp2
    PopReg  tmp1
    PushReg tmp2
    PushReg tmp1
    return

                                    ; // (table)
    bcf     wreg, 7
    rlncf   wreg
    addwf   pcl, f

                                    ; // (TableElt)
    retlw   $Sign$D'$Arg$'

                                    ; // (then) or (endif) - a label
$Label$

                                    ; // =: $Name$ / To $Name$ ( b -- ) ; $Mangled$
    PopReg  $Mangled$

    PushLit True                    ; // (True) ( -- f )

    ; // (try) ( -- )

    PushLit (( $aTryLabel$) >> 16) & 0xff   ; // Setup a fake return address for (raise)
    PushLit (( $aTryLabel$) >>  8) & 0xff   ; //   long jump to (except) handler
    PushLit (( $aTryLabel$) >>  0) & 0xff   ; //   using REVERSED push

    call    <@" ((try))">           ; // ((try)) Create (except) frame on return stack
                                    ; // ( tRomAddress -- ) [ -- tRomAddress dDSP ]

    ; // end (try) ( -- ) [ -- tRomAddress dDSP ]

                                    ; // (until) - branch if Z flag set
    fBranch $Label$

                                    ; // (value) Value $Name$ ( $Bank$:$Address$) ; $Mangled$
    PushLit D'$Address$'
    PushLit D'$Bank$'
    call    $Fetch$

$Mangled$ equ 256 * D'$Bank$' + D'$Value$' ; // Value $Name$ :: Bank = $Bank$

                                    ; // (valuestartup) - value initialization
                                    ; // Value $Name$ ( $Bank$:$Address$) := $Sign$$Value$ ; $Mangled$
    movlw   $Sign$D'$Value$'
    movwf   D'$Address$'

$Mangled$ equ 256 * D'$Bank$' + D'$Value$' ; // variable  $Name$ :: Bank = $Bank$

                                    ; // variable $Name$ ( $Bank$:$Value$) ; $Mangled$
    PushLit D'$Value$'
    PushLit D'$Bank$'

                                    ; // (while) - branch if Z flag set
    fBranch $Label$

    xorwf   postdec0, w             ; // (xor) ( b1 b2 -- b3 )

    PopReg  tmp1                    ; // Get byte arg
    PopReg  tmp5                    ; // Get long arg
    PopReg  tmp4
    PopReg  tmp3
    movwf   tmp2

    movlw   9                       ; // 9 Shifts
    movwf   <@" Quotient">

    clrf32  <@" Divisor">

    bcf     Status, C

tstar_1
                                    ; // Ignore byte 5
    rrcf    <@" Divisor"> + 3, f
    rrcf    <@" Divisor"> + 2, f
    rrcf    <@" Divisor"> + 1, f
    rrcf    <@" Divisor"> + 0, f
    rrcf    tmp1           , f
    bnc     tstar_2                 ; // B/ Carry clear, skip add

    ; // Carry set, add, ignoring 5th byte

    movf    tmp2, w
    addwf   <@" Divisor"> + 0, f
    movf    tmp3, w
    addwfc  <@" Divisor"> + 1, f
    movf    tmp4, w
    addwfc  <@" Divisor"> + 2, f
    movf    tmp5, w
    addwfc  <@" Divisor"> + 3, f

tstar_2

    decfsz  <@" Quotient">, f
    bra     tstar_1

    movf    tmp1, w
    PushReg <@" Divisor"> + 0
    PushReg <@" Divisor"> + 1
    PushReg <@" Divisor"> + 2

    Return